From 5c2915f00d9ac1f0b0189fe2d282f44b40ebc565 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Thu, 16 Dec 2010 17:43:42 +0100
Subject: [PATCH 0001/1541] Minor changes

Better output for Singles
---
 single.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/single.py b/single.py
index e684fff8..03cffd9e 100644
--- a/single.py
+++ b/single.py
@@ -160,7 +160,8 @@ def __str__(self):
         name = self.world.model.get_species_type_by_id(sid)["name"]
         if name[0] != '(':
             name = '(' + name + ')'
-        return 'Single[%s: %s, ST%s]' % (self.domain_id, pid, name)
+        return 'Single[%s: %s, ST%s, %s]' % (self.domain_id, pid, name,
+                                             self.pid_particle_pair[1].position)
 
 
 class NonInteractionSingle(Single):

From 5f4ff8baf44ee1179d9001ab81252be5e4c404b4 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Mon, 22 Nov 2010 15:26:01 +0100
Subject: [PATCH 0002/1541] Minor tweaks visualization/pipeline.py

Add annotate time filter to Paraview pipeline
Turn Paraview pipeline constants into variables
---
 visualization/pipeline.py | 41 ++++++++++++++++++++++++++++-----------
 1 file changed, 30 insertions(+), 11 deletions(-)

diff --git a/visualization/pipeline.py b/visualization/pipeline.py
index c33c092f..9e7fc148 100644
--- a/visualization/pipeline.py
+++ b/visualization/pipeline.py
@@ -20,6 +20,8 @@
 DARK_BACKGROUND = True
 
 PARTICLE_RADIUS_SCALE_FACTOR = 1
+SPHERE_RADIUS_SCALE_FACTOR = 1
+CYLINDER_RADIUS_SCALE_FACTOR = 1
 HELIX_RADIUS_SCALE_FACTOR = 1
 RESOLUTION = 18
 
@@ -122,12 +124,19 @@ def __init__(self, egfrd_directory, simulation_data_directory):
                 path of the directory that contains the files 
                 'files.pvd' and 'static.pvd', as created by VTKLogger.
 
+        Call p.rebuild() after this.
+
         """
         self.paraview_scripts_directory = egfrd_directory + '/visualization/'
         self.simulation_data_directory = simulation_data_directory
         
+        self.particle_radius_scale_factor = PARTICLE_RADIUS_SCALE_FACTOR
+        self.sphere_radius_scale_factor = SPHERE_RADIUS_SCALE_FACTOR
+        self.cylinder_radius_scale_factor = CYLINDER_RADIUS_SCALE_FACTOR
+        self.helix_radius_scale_factor = HELIX_RADIUS_SCALE_FACTOR
+        self.resolution = RESOLUTION
+
         self.initialize()
-        self.rebuild()
 
     def initialize(self):
         dir = self.paraview_scripts_directory
@@ -284,12 +293,19 @@ def rebuild(self):
 
             static = self.add_pvd_reader(static_pvd_path, 'static.pvd')
 
+            if version > 4: 
+                self.annTime = self.simple.AnnotateTimeFilter(files)
+                self.annTime.Format = '%.2f s'
+                rep = self.show(self.annTime)
+                #rep.WindowLocation
+                rep.FontSize = 12
 
         if PARTICLES:
             particle_data = self.add_extract_block(files, [2], 'b1')
 
-            particles = self.add_sphere_glyph(particle_data, name='Particles')
-            particles.SetScaleFactor = PARTICLE_RADIUS_SCALE_FACTOR
+            particles = self.add_sphere_glyph(particle_data, self.resolution,
+                                              name='Particles')
+            particles.SetScaleFactor = self.particle_radius_scale_factor
 
             rep1 = self.show(particles)
             self.set_color(particles, rep1)
@@ -298,8 +314,9 @@ def rebuild(self):
         if SPHERES:
             sphere_data = self.add_extract_block(files, [4], 'b2')
 
-            spheres = self.add_sphere_glyph(sphere_data, RESOLUTION, 
+            spheres = self.add_sphere_glyph(sphere_data, self.resolution, 
                                             name='Spheres')
+            spheres.SetScaleFactor = self.sphere_radius_scale_factor
 
             rep2 = self.show(spheres)
             self.set_color(spheres, rep2, color_map=MakeNiceLT)
@@ -309,9 +326,11 @@ def rebuild(self):
 
         if CYLINDERS:
             cylinder_data = self.add_extract_block(files, [6], 'b3')
-
+            scale = self.cylinder_radius_scale_factor
             cylinders = self.add_tensor_glyph(cylinder_data, 'Cylinder', 
-                                              resolution=RESOLUTION, name='tg')
+                                              resolution=self.resolution,
+                                              name='tg',
+                                              scale=scale)
 
             programmable_filter = self.add_color_hack(cylinders,
                                                       name='Cylinders')
@@ -330,7 +349,7 @@ def rebuild(self):
                 cylindrical_surfaces = \
                     self.add_tensor_glyph(cylindrical_surface_data, 'Cylinder',
                                           name='Cylindrical Surfaces',
-                                          scale=HELIX_RADIUS_SCALE_FACTOR) 
+                                          scale=self.helix_radius_scale_factor)
 
                 rep4 = self.show(cylindrical_surfaces)
                 rep4.Representation = 'Wireframe'
@@ -342,7 +361,7 @@ def rebuild(self):
                 helix_file = open(helix_path, 'r')
                 helix_source = servermanager.sources.ProgrammableSource()
                 helix_source.Script = 'HELIX_RADIUS_SCALE_FACTOR = ' + \
-                                      str(HELIX_RADIUS_SCALE_FACTOR) + \
+                                      str(self.helix_radius_scale_factor) + \
                                       '\n' + helix_file.read()
                 helix_source.UpdatePipeline()
                 servermanager.Register(helix_source, registrationName='ps')
@@ -378,15 +397,15 @@ def rebuild(self):
                     if value > 0 and value < cylindrical_surface_radius:
                         cylindrical_surface_radius = value
 
-                helix_radius = HELIX_RADIUS_SCALE_FACTOR * \
+                helix_radius = self.helix_radius_scale_factor * \
                                cylindrical_surface_radius
 
                 # Make double_helix a bit thinner than helix.
                 double_helix.Radius = helix_radius / 20
 
                 rep4 = self.show(double_helix)
-                self.set_color(double_helix, rep4,
-                               color_array_name = 'TubeNormals')
+                self.set_color(double_helix, rep4, color_map=MakeCoolToWarmLT,
+                               color_array_name='TubeNormals')
 
 
             # Planar surfaces.

From 587c57ab65d71301a3371b8c6de4727f27032339 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Tue, 9 Nov 2010 18:34:25 +0100
Subject: [PATCH 0003/1541] Refactor single.py

Nothing major, just reshuffling a bit for Interactions later.
---
 single.py | 59 ++++++++++++++++++++++---------------------------------
 1 file changed, 24 insertions(+), 35 deletions(-)

diff --git a/single.py b/single.py
index 03cffd9e..ab5c588a 100644
--- a/single.py
+++ b/single.py
@@ -21,8 +21,7 @@ class Single(object):
     specified.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
-                 surface):
+    def __init__(self, domain_id, pid_particle_pair, reactiontypes, surface):
         self.multiplicity = 1
         self.num_shells = 1
 
@@ -37,12 +36,6 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
 
         self.surface = surface
 
-        # Create shell.
-        shell = self.create_new_shell(pid_particle_pair[1].position,
-                                      pid_particle_pair[1].radius, domain_id)
-
-        self.shell_list = [(shell_id, shell), ]
-
         self.event_id = None
 
         self.domain_id = domain_id
@@ -73,6 +66,12 @@ def set_shell_id_shell_pair(self, value):
     shell_id_shell_pair = property(get_shell_id_shell_pair, 
                                    set_shell_id_shell_pair)
 
+    def get_mobility_radius(self):
+        return self.get_shell_size() - self.pid_particle_pair[1].radius
+
+    def get_shell_size(self):
+        return self.shell_list[0][1].shape.radius
+
     def initialize(self, t):
         '''
         Reset the Single.
@@ -100,21 +99,11 @@ def draw_reaction_time_tuple(self):
             dt = (1.0 / self.k_tot) * math.log(1.0 / myrandom.uniform())
         return dt, EventType.SINGLE_REACTION
 
-    def draw_interaction_time(self):
-        """Todo.
-        
-        Note: we are not calling single.drawEventType() just yet, but 
-        postpone it to the very last minute (when this event is executed 
-        in fire_single). So IV_EVENT can still be an iv escape or an iv 
-        interaction.
-
-        """
-        pass
+    def draw_escape_time_tuple(self):
+        """Return an (escape time, event type)-tuple.
 
-    def draw_escape_or_interaction_time_tuple(self):
-        """Return an (escape or interaction time, event type)-tuple.
-
-        Handles also all interaction events.
+        In case of an interaction single, does not handle escapes in 
+        the interaction coordinate.
         
         """
         if self.getD() == 0:
@@ -125,13 +114,6 @@ def draw_escape_or_interaction_time_tuple(self):
         event_type = EventType.SINGLE_ESCAPE
         return dt, event_type
 
-    def determine_next_event(self):
-        """Return an (event time, event type)-tuple.
-
-        """
-        return min(self.draw_escape_or_interaction_time_tuple(),
-                   self.draw_reaction_time_tuple())
-
     def updatek_tot(self):
         self.k_tot = 0
 
@@ -175,14 +157,21 @@ class NonInteractionSingle(Single):
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
                  surface):
-        Single.__init__(self, domain_id, pid_particle_pair, shell_id,
-                        reactiontypes, surface)
+        Single.__init__(self, domain_id, pid_particle_pair, reactiontypes,
+                        surface)
 
-    def get_mobility_radius(self):
-        return self.get_shell_size() - self.pid_particle_pair[1].radius
+        # Create shell.
+        shell = self.create_new_shell(pid_particle_pair[1].position,
+                                      pid_particle_pair[1].radius, domain_id)
 
-    def get_shell_size(self):
-        return self.shell_list[0][1].shape.radius
+        self.shell_list = [(shell_id, shell), ]
+
+    def determine_next_event(self):
+        """Return an (event time, event type)-tuple.
+
+        """
+        return min(self.draw_escape_time_tuple(),
+                   self.draw_reaction_time_tuple())
 
     def draw_new_position(self, dt, event_type):
         if event_type == EventType.SINGLE_ESCAPE:

From 63ee93652525d6cb8b8321f1c52aa239a5b98502 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Tue, 26 Oct 2010 11:17:57 +0200
Subject: [PATCH 0004/1541] Add stubs + docstrings to model for surface binding

---
 model.py | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/model.py b/model.py
index 59dc00f0..86ac16fe 100644
--- a/model.py
+++ b/model.py
@@ -11,6 +11,9 @@
     'create_annihilation_reaction_rule',
     'create_binding_reaction_rule',
     'create_unbinding_reaction_rule',
+    'create_surface_absorption_reaction_rule',
+    'create_surface_binding_reaction_rule',
+    'create_surface_unbinding_reaction_rule',
 
     # From _gfrd. Should be part of the model class.
     'create_cuboidal_region',
@@ -88,6 +91,9 @@
 
 Surfaces are not allowed to touch or overlap.
 
+Todo: allow the user to specify the position of a planar surface 
+relative to a region.
+
 """
 
 _gfrd.Model.add_species_type.im_func.__doc__ = \
@@ -364,3 +370,104 @@ def create_unbinding_reaction_rule(reactant, product1, product2, kd):
     rr['k'] = '%.16g' % kd
     return rr
 
+def create_surface_absorption_reaction_rule(reactant, surface, ka):
+    """Example: A + some_surface -> 0 + some_surface
+
+    Arguments:
+        - reactant
+            a Species in the "world" or in a Region.
+        - surface
+            a Surface created with one of the functions 
+            model.create_<>_surface.
+        - ka
+            intrinsic reaction rate. Units: meters^3 per second. (Rough 
+            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
+
+    ka should be an *intrinsic* reaction rate. No analytical expression 
+    is currently known to convert an overall reaction rate (kon) to 
+    an intrinsic reaction rate (ka) for surface binding or absorption 
+    reaction rules.
+
+    By default an EGFRDSimulator will assume a repulsive 
+    surface binding reaction rule (ka=0) for each possible 
+    combination of reactant and Surface for which no surface 
+    binding or absorption reaction rule is specified. You can 
+    explicitly add these reaction rules to the model by calling 
+    model.ParticleModel.set_all_repulsive().
+
+    """
+    assert isinstance(reactant['structure'], _gfrd.BoxShapedRegion)
+
+def create_surface_binding_reaction_rule(reactant, surface, product, ka):
+    """Example: A + some_surface -> A_on_surface + some_surface
+
+    Arguments:
+        - reactant
+            a Species in the "world" or in a Region.
+        - surface
+            a Surface created with one of the functions 
+            model.create_<>_surface.
+        - product
+            a Species that can exist on the Surface mentioned in the 
+            previous argument. For example: if you assigned that 
+            Surface to the variable some_surface, then a valid product 
+            Species would be:
+            model.Species('A_on_surface', some_D, some_r, some_surface)
+        - ka
+            intrinsic reaction rate. Units: meters^3 per second. (Rough 
+            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
+
+    A surface binding reaction rule always has exactly one product.
+
+    ka should be an *intrinsic* reaction rate. No analytical expression 
+    is currently known to convert an overall reaction rate (kon) to 
+    an intrinsic reaction rate (ka) for surface binding or absorption 
+    reaction rules.
+
+    By default an EGFRDSimulator will assume a repulsive 
+    surface binding reaction rule (ka=0) for each possible 
+    combination of reactant and Surface for which no surface 
+    binding or absorption reaction rule is specified. You can 
+    explicitly add these reaction rules to the model by calling 
+    model.ParticleModel.set_all_repulsive().
+
+    """
+    assert product['structure'] == surface
+
+def create_surface_unbinding_reaction_rule(reactant, surface, product, kd):
+    """Example: A_on_surface + some_surface -> A + some_surface
+
+    Arguments:
+        - reactant
+            a Species that can exist on the Surface mentioned in the 
+            next argument. For example: if you assign that 
+            Surface to the variable some_surface, then a valid reactant 
+            Species would be:
+            model.Species('A_on_surface', some_D, some_r, some_surface)
+        - surface
+            a Surface created with one of the functions 
+            model.create_<>_surface.
+        - product
+            a Species in the "world" or in a Region.
+        - kd
+            intrinsic reaction rate. Units: per second. (Rough order of 
+            magnitude: 1e-2 /s to 1e2 /s).
+
+    A surface unbinding reaction rule always has exactly one product.
+
+    kd should be an *intrinsic* reaction rate. No analytical expression 
+    is currently known to convert an overall reaction rate (koff) to 
+    an intrinsic reaction rate (kd) for surface unbinding reaction rules.
+
+    A surface unbinding reaction rule defines a Poissonian process.
+
+    """
+    assert reactant['structure'] == surface
+
+def create_membrane_traversal_reaction_rule(reactant, surface1, 
+                                            product, surface2, ka):
+    """
+
+    """
+    # Implementation: also flip orientation of cylinder.
+    pass

From 3478bacc2ad8441a6552b9478923b32b95937962 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Tue, 26 Oct 2010 16:18:31 +0200
Subject: [PATCH 0005/1541] Change fire_single to try interactions also

---
 egfrd.py | 38 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 37 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index b3abadcf..b58f414c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -21,6 +21,7 @@
     CuboidalRegion,
     CylindricalSurface,
     PlanarSurface,
+    Surface,
     _random_vector,
     Sphere,
     NetworkRulesWrapper,
@@ -736,6 +737,7 @@ def fire_single(self, single):
         min_shell = single.pid_particle_pair[1].radius * \
                     self.SINGLE_SHELL_FACTOR
 
+        # Burst intruders.
         intruders, closest, closest_distance = \
             self.get_intruders(singlepos, min_shell,
                                ignore=[single.domain_id, ])
@@ -747,7 +749,25 @@ def fire_single(self, single):
 
         if intruders:
             burst = self.burst_non_multis(intruders)
+        else:
+            burst = None
+
+        # Check closest surface.
+        # Only relevant when in the "world" or other 3D region.
+        if isinstance(single.surface, CuboidalRegion):
+            interaction_surface, closest_surface, surface_distance = \
+                get_closest_surface_within_radius(self.world, 
+                                                  singlepos, min_shell,
+                                                  ignore=[single.surface.id])
+            if interaction_surface:
+                obj = self.form_interaction(single, interaction_surface, burst)
+                if obj:
+                    return
+        else:
+            # Surfaces are not allowed to touch or overlap.
+            closest_surface = None
 
+        if burst:
             obj = self.form_pair_or_multi(single, burst)
 
             if obj:
@@ -777,6 +797,9 @@ def fire_single(self, single):
                                FORMAT_DOUBLE % s.dt, closest,
                                FORMAT_DOUBLE % closest_distance))
         else:
+            if closest_surface and surface_distance < closest_distance:
+                closest = closest_surface
+                closest_distance = surface_distance
             self.update_single(single, closest, closest_distance)
             
         if __debug__:
@@ -1133,6 +1156,11 @@ def form_pair_or_multi(self, single, neighbors):
         if obj:
             return obj
 
+    def form_interaction(self, single, surface, burst):
+        if __debug__:
+           log.debug('trying to form Interaction(%s, %s)' %
+                     (single.pid_particle_pair, surface))
+        raise NotImplementedError
 
     def form_pair(self, single1, pos1, single2, burst):
         if __debug__:
@@ -1142,6 +1170,14 @@ def form_pair(self, single1, pos1, single2, burst):
         assert single1.is_reset()
         assert single2.is_reset()
 
+        # Try forming a Pair only if singles are on same surface.
+        if single1.surface != single2.surface:
+            if __debug__:
+                log.debug('Pair(%s, %s) not formed: not on same surface.' %
+                          (single1.pid_particle_pair[0],
+                           single2.pid_particle_pair[0]))
+            return None
+
         # 1. Determine min shell size.
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
@@ -1258,7 +1294,7 @@ def form_pair(self, single1, pos1, single2, burst):
             assert shell_size < closest_shell_distance
 
         else:
-            assert isinstance(closest, (Pair, Multi, None.__class__))
+            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
 
             shell_size = closest_shell_distance / SAFETY
 

From cf64b1d1d69581942e4c3f1640118b8fa627a240 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Fri, 12 Nov 2010 17:38:07 +0100
Subject: [PATCH 0006/1541] Implement creation of InteractionSingles

Miedema's algorithm.
---
 egfrd.py  | 272 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 single.py | 158 +++++++++++++++++++++++++++++++
 2 files changed, 427 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b58f414c..abec1869 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -56,6 +56,25 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, surface):
         return PlanarSurfaceSingle(domain_id, pid_particle_pair, 
                                    shell_id, rt, surface)
 
+def create_default_interaction(domain_id, pid_particle_pair, shell_id,
+                               reaction_types, interaction_type, surface,
+                               projected_point, particle_distance, 
+                               orientation_vector, dr, dz_left, dz_right):
+    if isinstance(surface, CylindricalSurface):
+        return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
+                                             shell_id, reaction_types,
+                                             interaction_type, surface, 
+                                             projected_point, particle_distance,
+                                             orientation_vector,
+                                             dr, dz_left, dz_right)
+    elif isinstance(surface, PlanarSurface):
+        return PlanarSurfaceInteraction(domain_id, pid_particle_pair,
+                                        shell_id, reaction_types,
+                                        interaction_type, surface,
+                                        projected_point, particle_distance, 
+                                        orientation_vector,
+                                        dr, dz_left, dz_right)
+
 def create_default_pair(domain_id, com, single1, single2, shell_id, 
                         r0, shell_size, rt, surface):
     if isinstance(surface, CuboidalRegion):
@@ -327,6 +346,40 @@ def create_single(self, pid_particle_pair):
             single.world = self.world
         return single
 
+    def create_interaction(self, single, surface, projected_point, 
+                           particle_distance, orientation_vector,
+                           dr, dz_left, dz_right):
+        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
+
+        pid_particle_pair = single.pid_particle_pair
+        species_id = pid_particle_pair[1].sid
+
+        reaction_types = self.network_rules.query_reaction_rule(species_id)
+        #interaction_type = self.query_interaction_rule(species_id, surface)
+        # TODO.
+        interaction_type = None
+
+        domain_id = self.domain_id_generator()
+        shell_id = self.shell_id_generator()
+
+        interaction = \
+            create_default_interaction(domain_id, pid_particle_pair, shell_id,
+                                       reaction_types, interaction_type,
+                                       surface, projected_point,
+                                       particle_distance, orientation_vector,
+                                       dr, dz_left, dz_right)
+        interaction.initialize(self.t)
+
+        self.move_shell(interaction.shell_id_shell_pair)
+        self.domains[domain_id] = interaction
+
+        if __debug__:
+            # Used in __str__.
+            interaction.world = self.world
+
+        assert isinstance(interaction, InteractionSingle)
+        return interaction
+
     def create_pair(self, single1, single2, com, r0, shell_size):
         assert single1.dt == 0.0
         assert single2.dt == 0.0
@@ -1157,10 +1210,223 @@ def form_pair_or_multi(self, single, neighbors):
             return obj
 
     def form_interaction(self, single, surface, burst):
+        # Try to form an interaction.
+
+        particle = single.pid_particle_pair[1]
+        # Cyclic transpose needed when calling surface.projected_point!
+        pos_transposed = self.world.cyclic_transpose(particle.position, 
+                                                     surface.shape.position) 
+        projected_point, projection_distance = \
+                surface.projected_point(pos_transposed)
+
+        particle_distance = abs(projection_distance)
+
+        # For interaction with a planar surface, decide orientation. 
+        orientation_vector = cmp(projection_distance, 0) * surface.shape.unit_z 
+
         if __debug__:
-           log.debug('trying to form Interaction(%s, %s)' %
-                     (single.pid_particle_pair, surface))
-        raise NotImplementedError
+           log.debug('trying to form Interaction(%s, %s)' % (particle, surface))
+
+        # For an interaction with a PlanarSurface (membrane):
+        # * dr is the radius of the cylinder.
+        # * dz_left determines how much the cylinder is sticking out on the 
+        # other side of the surface, measured from the projected point.
+        # * dz_right is the distance between the particle position and 
+        # the edge of the cylinder in the z direction.
+        #
+        # For interaction with a CylindricalSurface (dna):
+        # * dr is the distance between the particle position and the 
+        # edge of the cylinder in the r direction.
+        # * dz_left is the distance from the projected point to the left edge 
+        # of the cylinder.
+        # * dz_right is the distance from the projected point to the right edge 
+        # of the cylinder.
+
+        # Initialize dr, dz_left, dz_right to maximum allowed values.
+        # And decide minimal dr, dz_left, dz_right.
+        if isinstance(surface, PlanarSurface):
+            dr = self.get_max_shell_size()
+            # Leave enough for the particle itself to the left.
+            dz_left = particle.radius
+            # Make sure the cylinder stays within 1 cell.
+            dz_right = self.get_max_shell_size() * 2 - \
+                      (particle_distance + dz_left)
+
+            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
+            min_dz_left = dz_left
+            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
+
+        elif isinstance(surface, CylindricalSurface):
+            # Make sure the cylinder stays within 1 cell.
+            dr = self.get_max_shell_size() - particle_distance
+            dz_left = self.get_max_shell_size()
+            dz_right = self.get_max_shell_size()
+
+            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
+            min_dz_left = particle.radius * self.SINGLE_SHELL_FACTOR
+            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
+
+        # Miedema's algorithm.
+        dr, dz_left, dz_right = \
+            self.determine_optimal_cylinder(single, surface,
+                                            projected_point,
+                                            particle_distance,
+                                            orientation_vector,
+                                            dr, dz_left, dz_right,
+                                            burst)
+        dr /= SAFETY
+        dz_left /= SAFETY
+        dz_right /= SAFETY
+
+        # Decide if interaction domain is possible.
+        if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
+            if __debug__:
+                log.debug('        *Interaction not possible:\n'
+                          '            %s +\n'
+                          '            %s.\n'
+                          '            dr = %.3g. min_dr = %.3g.\n'
+                          '            dz_left = %.3g. min_dz_left = %.3g.\n'
+                          '            dz_right = %.3g. min_dz_right = %.3g.' %
+                          (single, surface, dr, min_dr, dz_left, min_dz_left, 
+                           dz_right, min_dz_right))
+            return None
+
+        interaction = self.create_interaction(single, surface,
+                                              projected_point, 
+                                              particle_distance,
+                                              orientation_vector, 
+                                              dr, dz_left, dz_right)
+
+        # Below here similar as in fire_pair after creating a pair.
+        interaction.dt, interaction.event_type, = \
+            interaction.determine_next_event()
+        assert interaction.dt >= 0
+
+        self.last_time = self.t
+
+        self.remove_domain(single)
+        # single event will be removed by the scheduler.
+
+        if __debug__:
+            log.debug('        *create_interaction\n'
+                      '            dr = %s. dz_left = %s. dz_right = %s.\n' %
+                      (FORMAT_DOUBLE % dr, FORMAT_DOUBLE % dz_left,
+                       FORMAT_DOUBLE % dz_right))
+
+        assert self.check_obj(interaction)
+        self.add_single_event(interaction)
+
+        return interaction
+
+    def determine_optimal_cylinder(self, single, surface, projected_point, 
+                                   particle_distance, orientation_vector,
+                                   dr, dz_left, dz_right, burst):
+        # Find optimal cylinder around particle and surface, such that 
+        # it is not interfering with other shells.
+        # Todo. Finding all spheres and cylinders in the matrixspace 
+        # should be sufficient, but domain information is now used for 
+        # get_shell_size is overridden for cylindrical singles and 
+        # pairs.
+        all_neighbors = \
+            self.get_neighbors_within_radius_no_sort(projected_point, 
+                                                     self.get_max_shell_size(),
+                                                     ignore=[single.domain_id])
+
+        for domain in all_neighbors:
+            if isinstance(domain, Multi):
+                for shell in domain.shell_list:
+                    shell_position = shell.shape.position
+                    shell_size = shell.shape.radius
+                    dr, dz_left, dz_right = \
+                        self.miedema_algorithm(shell_position, shell_size,
+                                               projected_point, 
+                                               orientation_vector, dr, 
+                                               dz_left, dz_right, 
+                                               surface, particle_distance)
+            else:
+                # Get shell size, which normally is the radius of the 
+                # shell, but in case of a cylinder around the same 
+                # CylindricalSurface it should be the half_length of 
+                # the cylinder.
+                shell_position = domain.shell.shape.position
+                shell_size = domain.get_shell_size()
+
+                # Make bursted singles look bigger, like in form_pair, 
+                # because the size of their shell is only 
+                # particle.radius (not yet multiplied by 
+                # SINGLE_SHELL_FACTOR)
+                # (and no we can not do that immediately after they are 
+                # bursted, singles might start overlapping).
+                if domain.dt == 0.0 and domain.getD() > 0:
+                    # This is one of the bursted singles.
+                    # Or a particle that just escaped it's multi.
+                    shell_size *= self.SINGLE_SHELL_FACTOR
+
+                dr, dz_left, dz_right = \
+                    self.miedema_algorithm(shell_position, shell_size, 
+                                           projected_point, 
+                                           orientation_vector, dr, 
+                                           dz_left, dz_right, surface,
+                                           particle_distance)
+
+
+        return dr, dz_left, dz_right
+
+    def miedema_algorithm(self, shell_position, shell_size, projected_point,
+                          orientation_vector, dr, dz_left, dz_right,
+                          surface, particle_distance):
+        # Find optimal cylinder around particle and surface, such that 
+        # it does not interfere with the shell at position 
+        # shell_position and with size (radius or half_length) 
+        # shell_size.
+
+        shell_vector = shell_position - projected_point
+
+        # Calculate zi and ri for this shell.
+        zi = numpy.dot(shell_vector, orientation_vector)
+        z_vector = zi * numpy.array(orientation_vector)
+        r_vector = numpy.array(shell_vector) - numpy.array(z_vector)
+        ri = numpy.linalg.norm(r_vector)
+
+        # Calculate dr_i for this shell.
+        dr_i = ri - shell_size
+        if isinstance(surface, CylindricalSurface):
+            # Run Miedema's algorithm in the r direction 
+            # relative to the particle's position, not to 
+            # projected point (r=0).
+            dr_i -= particle_distance
+
+        # Calculate dz_left_i or dz_right_i (both will usually 
+        # be positive values).
+        if zi < 0:
+            # Calculate dz_left_i for this shell.
+            dz_left_i = - zi - shell_size
+
+            # Miedema's algorithm left side.
+            if dz_left_i < dz_left and dr_i < dr:
+                if dz_left_i > dr_i:
+                    dz_left = dz_left_i
+                else:
+                    dr = dr_i
+        else:
+            # Calculate dz_right_i for this shell.
+            dz_right_i = zi - shell_size
+
+            if isinstance(surface, PlanarSurface):
+                # On the particle side (right side), run 
+                # Miedema's algorithm in the z direction 
+                # relative to the particle's position, not the 
+                # projected point (z=0).
+                dz_right_i -= particle_distance
+
+            # Miedema's algorithm right side.
+            if dz_right_i < dz_right and dr_i < dr:
+                if dz_right_i > dr_i:
+                    dz_right = dz_right_i
+                else:
+                    dr = dr_i
+
+        return dr, dz_left, dz_right
 
     def form_pair(self, single1, pos1, single2, burst):
         if __debug__:
diff --git a/single.py b/single.py
index ab5c588a..cb2325a3 100644
--- a/single.py
+++ b/single.py
@@ -9,6 +9,9 @@
     'PlanarSurfaceSingle',
     'SphericalSingle',
     'Single',
+    'InteractionSingle',
+    'CylindricalSurfaceInteraction',
+    'PlanarSurfaceInteraction',
     ]
 
 class Single(object):
@@ -314,3 +317,158 @@ def __str__(self):
         return 'CylindricalSurface' + Single.__str__(self)
 
 
+class InteractionSingle(Single):
+    """Interactions singles are used when a particle is close to a 
+    surface.
+
+    There are 2 types of InteractionSingles:
+        * PlanarSurfaceInteraction.
+        * CylindricalSurfaceInteraction.
+
+    """
+    def __init__(self, domain_id, pid_particle_pair, shell_id, shell,  
+                 reactiontypes, interaction_type, surface):
+
+        Single.__init__(self, domain_id, pid_particle_pair, reactiontypes,
+                        surface)
+        self.interaction_type = interaction_type
+        self.shell_list = [(shell_id, shell), ]
+
+    def determine_next_event(self):
+        """Return an (event time, event type)-tuple.
+
+        """
+        return min(self.draw_escape_time_tuple(),
+                   self.draw_iv_interaction_or_escape_time_tuple(),
+                   self.draw_reaction_time_tuple())
+
+    def draw_iv_interaction_or_escape_time_tuple(self):
+        """Return an (interaction/escape time, event type)-tuple.
+ 
+        Note: we are not calling single.draw_iv_event_type() just yet, but 
+        postpone it to the very last minute (when this event is executed 
+        in fire_single). So IV_EVENT can still be an iv escape or an iv 
+        interaction.
+
+        """
+        dt = draw_time_wrapper(self.iv_greens_function())
+
+        return dt, EventType.IV_EVENT
+
+    def draw_iv_event_type(self):
+        gf = self.iv_greens_function()
+        event_kind = draw_event_type_wrapper(gf, self.dt)
+        if event_kind == PairEventKind.IV_REACTION:
+            return EventType.IV_REACTION
+        elif event_kind == PairEventKind.IV_ESCAPE:
+            return EventType.IV_ESCAPE
+        raise NotImplemented()
+
+
+class PlanarSurfaceInteraction(InteractionSingle):
+    pass
+
+
+class CylindricalSurfaceInteraction(InteractionSingle):
+    """1 Particle close to a CylindricalSurface, inside a cylindrical shell 
+    that surrounds the surface.
+
+        * Particle coordinates inside shell: r, theta, z.
+        * Domains: composite r-theta, cartesian z.
+        * Initial position: r = r, theta = 0, z = z.
+        * Selected randomly when drawing displacement vector: none.
+
+    """
+    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
+                 interaction_type, surface, projected_point, particle_distance,
+                 orientation_vector, dr, dz_left, dz_right):
+
+        self.particle_distance = particle_distance
+        self.dz_left = dz_left
+
+        # Only needed for this type of Interaction.
+        self.unit_r = normalize(pid_particle_pair[1].position - projected_point)
+
+        shell = self.create_shell(domain_id, projected_point,
+                                  particle_distance, orientation_vector,
+                                  dr, dz_left, dz_right)
+
+        InteractionSingle.__init__(self, domain_id, pid_particle_pair,
+                                   shell_id, shell, reactiontypes,
+                                   interaction_type, surface)
+
+    def create_shell(self, domain_id, projected_point, particle_distance,
+                     orientation_vector, dr, dz_left, dz_right):
+
+        # Compute origin, radius and half_length of cylinder.
+        # This stuff is complicated.
+        half_length = (dz_left + dz_right) / 2
+        shiftZ = half_length - dz_left
+        origin = projected_point + shiftZ * orientation_vector
+        radius = dr + particle_distance
+
+        # Return shell.
+        return CylindricalShell(domain_id, Cylinder(origin, radius, 
+                                                    orientation_vector, 
+                                                    half_length))
+
+    def greens_function(self):
+        z0 = self.dz_left - self.shell.shape.half_length
+
+        # Free diffusion in z direction.
+        return GreensFunction1DAbsAbs(self.getD(), self.getv(), z0,
+                                      -self.get_mobility_radius(),
+                                      self.get_mobility_radius())
+
+    def iv_greens_function(self):
+        # Interaction possible in r direction.
+        # Todo.
+        #k = self.interaction_type.k
+        k = 0
+        r0 = self.particle_distance
+        sigma = self.surface.shape.radius + self.pid_particle_pair[1].radius
+        a_r = self.shell.shape.radius - self.pid_particle_pair[1].radius
+        # Todo 2D.
+        return GreensFunction3DRadAbs(self.getD(), k, r0, sigma, a_r)
+
+    def draw_new_position(self, dt, event_type):
+        # 1) Draw z.
+        if event_type == EventType.SINGLE_ESCAPE:
+            # Moving this checks to the Green's functions is not a good 
+            # idea, because then you'd draw an unused random number.  
+            # The same yields for the draw_new_com and draw_new_iv.  
+            z = self.get_mobility_radius()
+        else:
+            gf = self.greens_function()
+            z = draw_r_wrapper(gf, dt, self.get_mobility_radius())
+
+        # Orientation matters, so use shell.shape.unit_z instead of 
+        # surface.shape.unit_z.
+        z_vector = z * self.shell.shape.unit_z
+
+        # 2) Draw r and theta.
+        sigma = self.surface.shape.radius + self.pid_particle_pair[1].radius
+        a_r = self.shell.shape.radius - self.pid_particle_pair[1].radius
+        iv_gf = self.iv_greens_function()
+        if event_type == EventType.IV_ESCAPE:
+            r = a_r
+        elif event_type == EventType.IV_INTERACTION:
+            r = sigma
+        else:
+            r = draw_r_wrapper(iv_gf, dt, a_r, sigma)
+        theta = draw_theta_wrapper(iv_gf, r, dt)
+
+        r_vector = r * rotate_vector(self.unit_r, self.shell.shape.unit_z,
+                                     theta)
+
+        # Add displacement to shape.position, not to particle.position.  
+        return self.shell.shape.position + z_vector + r_vector
+
+    def get_shell_size(self):
+        # Heads up. The cylinder's *half_length*, not radius, 
+        # determines the size in case of a cylindrical surface.
+        return self.shell_list[0][1].shape.half_length
+
+    def __str__(self):
+        return 'CylindricalSurfaceInteraction' + Single.__str__(self)
+

From 4a62a19eb4f41fc53a9e9df68bc9e2e75966b037 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Wed, 15 Dec 2010 17:49:10 +0100
Subject: [PATCH 0007/1541] Fix check_obj in case of cylinders and spheres

---
 egfrd.py | 37 +++++++++++++++++++++++++++++++------
 1 file changed, 31 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index abec1869..a4b9a8bc 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -23,6 +23,7 @@
     PlanarSurface,
     Surface,
     _random_vector,
+    Cylinder,
     Sphere,
     NetworkRulesWrapper,
     )
@@ -1891,15 +1892,39 @@ def check_obj(self, obj):
             if not isinstance(obj, Multi):
                 ignores = [obj.surface.id]
             else:
-                ignores = []
+                # Ignore all surfaces, multi shells can overlap with 
+                # surfaces.
+                ignores = [s.id for s in self.world.structures]
             closest, distance = self.get_closest_obj(shell.shape.position,
                                                      ignore=[obj.domain_id],
                                                      ignores=ignores)
-            if(type(obj) is CylindricalSurfaceSingle or
-               type(obj) is CylindricalSurfacePair):
+            if(type(shell.shape) is Cylinder and
+               closest and type(closest.shell.shape) is Sphere):
+                # Note: this case is special.
+                # Note: only checking if cylinder doesn't overlap with 
+                # closest sphere, like we do here, is not really 
+                # sufficient (but checking all spheres is too much 
+                # work).
                 shell_size = shell.shape.half_length
+                # Reverse overlap calculation: from closest sphere to 
+                # cylinder is easier than the other way around, because 
+                # the distance calculation from a point to a cylinder 
+                # is already implemented.
+                sphere = closest.shell.shape
+                diff = self.world.distance(shell.shape, sphere.position) - \
+                       sphere.radius
             else:
-                shell_size = shell.shape.radius
+                if(type(obj) is CylindricalSurfaceSingle or
+                   type(obj) is CylindricalSurfacePair or
+                   type(obj) is CylindricalSurfaceInteraction):
+                    # On CylindricalSurface, use half_lenghts.
+                    # (assume all nearby other cylinders are on the 
+                    # same surface)
+                    shell_size = shell.shape.half_length
+                else:
+                    # Normally compare radii.
+                    shell_size = shell.shape.radius
+                diff = distance - shell_size
 
             assert shell_size <= self.get_user_max_shell_size(), \
                 '%s shell size larger than user-set max shell size' % \
@@ -1909,11 +1934,11 @@ def check_obj(self, obj):
                 '%s shell size larger than simulator cell size / 2' % \
                 str(shell_id)
 
-            assert distance - shell_size >= 0.0, \
+            assert diff >= 0.0, \
                 '%s overlaps with %s. (shell: %s, dist: %s, diff: %s.' % \
                 (str(obj), str(closest), FORMAT_DOUBLE % shell_size,
                  FORMAT_DOUBLE % distance,
-                 FORMAT_DOUBLE % (distance - shell_size))
+                 FORMAT_DOUBLE % diff)
 
         return True
 

From 4e3479fc95efa522936d509072c60b398d5d0ba7 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Thu, 16 Dec 2010 17:02:37 +0100
Subject: [PATCH 0008/1541] Add burst and propagate InteractionSingles

---
 egfrd.py | 65 ++++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 51 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a4b9a8bc..8bcd0d2d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -556,6 +556,8 @@ def burst_obj(self, obj):
             self.remove_event(obj)
 
         if __debug__:
+            # After a burst, InteractionSingles should be gone.
+            assert all(not isinstance(b, InteractionSingle) for b in bursted)
             log.info('bursted = %s' % ',\n\t  '.join(str(i) for i in bursted))
 
         return bursted
@@ -585,7 +587,9 @@ def burst_non_multis(self, neighbors):
 
         return bursted
 
-    def fire_single_reaction(self, single):
+    def fire_single_reaction(self, single, interaction_flag=False):
+        if interaction_flag == True:
+            raise NotImplementedError
         reactant_species_radius = single.pid_particle_pair[1].radius
         oldpos = single.pid_particle_pair[1].position
         current_surface = single.surface
@@ -725,19 +729,34 @@ def propagate_single(self, single):
                                         single.pid_particle_pair[0]):
                 raise RuntimeError('propagate_single: check_overlap failed.')
 
-        if(single.event_type == EventType.SINGLE_REACTION and
-           single.event_type != EventType.BURST):
-            # SINGLE_REACTION, and not a burst. No need to update, single is 
-            # removed anyway.
+        if(single.event_type == EventType.SINGLE_REACTION or
+           single.event_type == EventType.IV_INTERACTION):
+            # Single reaction or interaction, and not a burst. Only 
+            # update particle, single is removed anyway.
             self.move_single_particle(single, newpos)
             return single
         else:
-            # Todo. if isinstance(single, InteractionSingle):
-            single.initialize(self.t)
-            self.move_single(single, newpos,
-                             single.pid_particle_pair[1].radius)
-
-            return single
+            if isinstance(single, InteractionSingle):
+                # If for an interaction single a single reaction or iv 
+                # interaction occurs, we create a new single and get 
+                # rid of the old interactionSingle in 
+                # fire_single_reaction.
+                # For escapes and bursts of interaction singles we do 
+                # it here.
+                self.move_single_particle(single, newpos)
+                self.remove_domain(single)
+                newsingle = self.create_single(single.pid_particle_pair)
+                if __debug__:
+                    log.debug('    *New %s.\n'
+                              '        radius = %.3g. dt = %.3g.' %
+                              (newsingle, newsingle.shell.shape.radius,
+                               newsingle.dt))
+                return newsingle
+            else:
+                single.initialize(self.t)
+                self.move_single(single, newpos,
+                                 single.pid_particle_pair[1].radius)
+                return single
 
     def fire_single(self, single):
         assert abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t
@@ -784,6 +803,16 @@ def fire_single(self, single):
             # Propagate this particle to the exit point on the shell.
             single = self.propagate_single(single)
 
+        # An interaction event is similar to a single reaction.
+        if single.event_type == EventType.IV_INTERACTION:
+            try:
+                self.remove_domain(single)
+                self.fire_single_reaction(single, interaction_flag=True)
+            except NoSpace:
+                self.reject_single_reaction(single)
+
+            return
+
         singlepos = single.shell.shape.position
 
         # (2) Clear volume.
@@ -897,7 +926,7 @@ def calculate_single_shell_size(self, single, closest,
         return shell_size
 
     def update_single(self, single, closest, distance_to_shell): 
-        # Todo. assert not isinstance(single, InteractionSingle)
+        assert not isinstance(single, InteractionSingle)
 
         singlepos = single.shell.shape.position
         if isinstance(closest, Single):
@@ -1088,8 +1117,16 @@ def burst_single(self, single):
                old_shell_size - particle_radius
         # Displacement check is in NonInteractionSingle.draw_new_position.
 
-        # Todo. if isinstance(single, InteractionSingle):
-        self.update_single_event(self.t, single)
+        if isinstance(single, InteractionSingle):
+            # Removing the event has to be done for *bursting* 
+            # *Interaction*Singles, not for propagating 
+            # InteractionSingles nor for bursting 
+            # NonInteractionSingles.
+            self.remove_event(single)
+            self.add_single_event(newsingle)
+        else:
+            assert single == newsingle
+            self.update_single_event(self.t, single)
 
         assert newsingle.shell.shape.radius == particle_radius
 

From bdc955b708cc34e45200295042fdc1df69ce5050 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Tue, 9 Nov 2010 18:31:04 +0100
Subject: [PATCH 0009/1541] Add CylindricalSurfaceInteractionTestCase

---
 test/EGFRDSimulator_test.py | 84 +++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/test/EGFRDSimulator_test.py b/test/EGFRDSimulator_test.py
index 59331a90..29790e53 100755
--- a/test/EGFRDSimulator_test.py
+++ b/test/EGFRDSimulator_test.py
@@ -293,5 +293,89 @@ def test_vtklogger(self):
         vtk_logger.cleanup()
 
 
+class CylindricalSurfaceInteractionTestCase(EGFRDSimulatorTestCaseBase):
+    """Events between the "world" and a cylindrical surface.
+
+    """
+    def setUp(self):
+        self.create_model()
+        self.add_cylindrical_surface()
+
+        # Only species B is on the cylindrical surface.
+        self.B["structure"] = "d"
+        self.add_species() 
+        self.create_simulator() 
+        # Don't add particles yet.
+        # Don't add all reactions.
+
+    def test_simulation_does_not_come_to_a_halt(self):
+        # Place a particle on the cylindrical surface.
+        L = self.L
+        place_particle(self.s.world, self.B, [L / 2, L / 2, L / 2])
+
+        # Place a particle very close to the cylindrical surface.
+        offset = self.radius
+        place_particle(self.s.world, self.A,
+                       [L / 2, L / 2 + 2 * offset, L / 2 + 2.1 * offset])
+
+        vtk_logger = vtklogger.VTKLogger(self.s, 'vtk_temp_data')
+        for i in range(3):
+            self.s.step()
+            vtk_logger.log()
+        vtk_logger.stop()
+        vtk_logger.cleanup()
+
+        self.failIf(self.s.t < 1.e-10)
+
+    def test_no_pair_between_species_on_different_surfaces(self):
+        myrandom.seed(0)
+        # Place a particle on the cylindrical surface.
+        L = self.L
+        place_particle(self.s.world, self.B, [L / 2, L / 2, L / 2])
+
+        # Place a particle very close to the cylindrical surface.
+        offset = self.radius
+        place_particle(self.s.world, self.A,
+                       [L / 2, L / 2, L / 2 + 2.1 * offset])
+
+        vtk_logger = vtklogger.VTKLogger(self.s, 'vtk_temp_data')
+
+        # After 24 steps multi particle tries a move that would result 
+        # in overlap with surface.
+        self.s.bd_dt_factor = 5
+        for i in range(25):
+            self.s.step()
+            vtk_logger.log()
+            self.s.check()
+        vtk_logger.stop()
+        vtk_logger.cleanup()
+        self.failIf(numpy.array(self.s.pair_steps.values()).sum() > 0)
+
+    def test_no_overlap_interaction_and_cylindrical_single(self):
+        myrandom.seed(2)
+        # Place a particle on the cylindrical surface.
+        L = self.L
+        place_particle(self.s.world, self.B, [L / 2, L / 2, L / 2])
+
+        # Place a particle very close to the cylindrical surface.
+        offset = self.radius
+        place_particle(self.s.world, self.A,
+                       [L / 2, L / 2 + 3 * offset, L / 2 + 2.1 * offset])
+
+        vtk_logger = vtklogger.VTKLogger(self.s, 'vtk_temp_data')
+        for i in range(10):
+            self.s.step()
+            vtk_logger.log()
+            self.s.check()
+        vtk_logger.stop()
+        vtk_logger.cleanup()
+
+    def test_longer_run(self):
+        self.add_particles(20)
+
+        for i in range(100):
+            self.s.step()
+
+
 if __name__ == "__main__":
     unittest.main()

From 9ced75224e6c5f1b22d3f171e143142b6e5cb8a8 Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Thu, 16 Dec 2010 17:19:57 +0100
Subject: [PATCH 0010/1541] Add PlanarSurfaceInteractionTestCase

---
 test/EGFRDSimulator_test.py | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/test/EGFRDSimulator_test.py b/test/EGFRDSimulator_test.py
index 29790e53..db9c2100 100755
--- a/test/EGFRDSimulator_test.py
+++ b/test/EGFRDSimulator_test.py
@@ -293,6 +293,30 @@ def test_vtklogger(self):
         vtk_logger.cleanup()
 
 
+class PlanarSurfaceInteractionTestCase(EGFRDSimulatorTestCaseBase):
+    """Events between the "world" and a planar surface.
+
+    """
+    def setUp(self):
+        self.create_model()
+        self.add_planar_surface()
+
+        # Only species B is on the planar surface.
+        self.B["structure"] = "m1"
+        self.add_species() 
+        self.create_simulator() 
+        self.add_particles(10)
+        # Don't add all reactions.
+
+    def test_interaction_single_is_formed(self):
+        # Place a particle very close to the planar surface.
+        z_position = float(self.A['radius']) * (1 + 1e-8)
+        place_particle(self.s.world, self.A, [0.0,0.0, z_position])
+
+        for i in range(100):
+            self.s.step()
+
+
 class CylindricalSurfaceInteractionTestCase(EGFRDSimulatorTestCaseBase):
     """Events between the "world" and a cylindrical surface.
 

From 184d0ec455966d1e717d4fcd790a3e1ee6b6915c Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Thu, 16 Dec 2010 17:44:24 +0100
Subject: [PATCH 0011/1541] Add PlanarSurfaceInteraction

---
 single.py | 98 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 97 insertions(+), 1 deletion(-)

diff --git a/single.py b/single.py
index cb2325a3..8f9d9d6c 100644
--- a/single.py
+++ b/single.py
@@ -366,7 +366,103 @@ def draw_iv_event_type(self):
 
 
 class PlanarSurfaceInteraction(InteractionSingle):
-    pass
+    """1 Particle close to a PlanarSurface, inside a cylindrical shell 
+    placed on top of the surface.
+
+        * Particle coordinates inside shell: r, theta, z.
+        * Coordinates: radial r, cartesian z.
+        * Initial position: r = 0, z = z.
+        * Selected randomly when drawing displacement vector: theta.
+
+    """
+    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
+                 surface, interaction_type, origin, orientation, half_length, 
+                 particle_offset, projected_point, size_of_domain):
+        InteractionSingle.__init__(self, domain_id, pid_particle_pair, 
+                                   shell_id, reactiontypes, surface, 
+                                   interaction_type, origin, orientation,
+                                   half_length, particle_offset,
+                                   projected_point, size_of_domain)
+
+        # Compute from dr, dz_left and dz_right the length of the new 
+        # domain (only that part of the cylinder where the particle can 
+        # diffuse to) and the radius and half_length of the new 
+        # cylinder.
+
+        # a
+        # sigma
+        sigma = self.surface.shape.Lz + self.pid_particle_pair[1].radius
+        # r0
+        if isinstance(surface, PlanarSurface):
+            # Heads up: length of domain (the part of the cylinder 
+            # where the particle can get) is a bit different from the 
+            # length of the cylinder because of dz_left.
+            # Assume surface.Lz == 0
+            length_of_domain = particle_distance + dz_right
+            radius = dr
+            half_length = (particle_distance + dz_left + dz_right) / 2
+
+        # TODO. This is not correct anymore.
+        if isinstance(surface, PlanarSurface):
+            # Compute new particle offset relative to origin of the 
+            # domain in the z-direction (z=0).
+            # The surface boundary is at z=-length_of_domain / 2, the 
+            # other end in the middles*at* the surface boundary. (z=L) 
+            # is at the end of the cylinder.
+            # (min_radius correction in the constructor).
+            particle_offset = [0, particle_distance - length_of_domain.Lz]
+
+    def greens_function_r(self):
+        # Todo. 2D gf Abs Sym.
+        #gf = FirstPassageGreensFunction2D(self.getD())
+        return FirstPassageGreensFunction(self.getD(),
+                                          self.get_mobility_radius())
+
+    def greens_function_z(self):
+        # Todo. 1D gf Rad Abs should be sigma to a.
+        #gf = FirstPassageGreensFunction1DRad(self.D_tot, self.rt.k)
+
+        return FirstPassagePairGreensFunction(self.getD(),
+                                              self.interaction_type.k, self.r0,
+                                              self.sigma, self.sigma)
+        gf.seta(a)
+        return gf
+
+        # TODO.
+
+        # Cartesian domain of half_length L. Correction with getMinRadius().
+        #zDomain = CartesianDomain(particle_offset[1] - self.getMinRadius(), 
+        #                           size_of_domain - 2 * self.getMinRadius(), 
+        #                           gfz)
+
+    def createNewShell(self, position, radius, domain_id):
+        orientation = self.orientation
+        half_length = self.half_length
+        return CylindricalShell(position, radius, orientation, half_length,
+                                domain_id)
+
+    def draw_new_positions(self, dt, eventType):
+        gf_r = self.greens_function_r()
+        a = self.get_mobility_radius()
+        r = draw_displacement_wrapper(gf_r, dt, eventType, a)
+        x, y = randomVector2D(r)
+
+        # Todo. Cartesian coordinate will return absolute position.
+        gf_z = self.greens_function_z()
+        # Heads up. size_of_domain is different from the half_length of 
+        # the cylinder, because the domain ends where the surface 
+        # starts, while the cylinder is continuing into the surface.
+        a = 1 #TODO 
+        r0 = self.particle_offset
+        sigma = self.sigma
+        z = draw_displacement_wrapper(gf_z, dt, eventType, a, r0, sigma)
+
+        # Add displacement vector to self.particle.pos, not self.pos.
+        return self.particle.pos + x * self.interactionSurface.unitX + \
+               y * self.interactionSurface.unitY + z * self.shellList[0].unitZ
+
+    def __str__(self):
+        return 'PlanarSurfaceInteraction' + Single.__str__(self)
 
 
 class CylindricalSurfaceInteraction(InteractionSingle):

From 534adf5698d0566fa02d9b688d51d05ea76f4bec Mon Sep 17 00:00:00 2001
From: thomie <miedema@amolf.nl>
Date: Fri, 7 Jan 2011 21:12:20 +0100
Subject: [PATCH 0012/1541] Work in progress

---
 single.py                   | 19 +++++++++++++++++++
 test/EGFRDSimulator_test.py | 11 +++++++++--
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/single.py b/single.py
index 8f9d9d6c..4c5f282d 100644
--- a/single.py
+++ b/single.py
@@ -568,3 +568,22 @@ def get_shell_size(self):
     def __str__(self):
         return 'CylindricalSurfaceInteraction' + Single.__str__(self)
 
+class DummySingle(object):
+    def __init__(self):
+        self.multiplicity = 1
+        self.half_length = 0.0
+        self.shellList = [Sphere(NOWHERE, 0.0)]
+
+    def getMinSize(self):
+        return 0.0
+
+    def getD(self):
+        return 0.0
+
+    def getPos(self):
+        return NOWHERE
+    pos = property(getPos)
+
+    def __str__(self):
+        return 'DummySingle()'
+
diff --git a/test/EGFRDSimulator_test.py b/test/EGFRDSimulator_test.py
index db9c2100..fc71a73f 100755
--- a/test/EGFRDSimulator_test.py
+++ b/test/EGFRDSimulator_test.py
@@ -15,7 +15,8 @@
 import gfrdbase
 import myrandom
 
-log.setLevel(logging.WARNING)
+#log.setLevel(logging.WARNING)
+log.setLevel(logging.DEBUG)
 
 
 class EGFRDSimulatorTestCase(unittest.TestCase):
@@ -402,4 +403,10 @@ def test_longer_run(self):
 
 
 if __name__ == "__main__":
-    unittest.main()
+    suite = unittest.TestLoader().loadTestsFromTestCase(CylindricalSurfaceInteractionTestCase)
+    unittest.TextTestRunner(verbosity=2).run(suite)
+
+    # Todo: taking huge bd steps.
+
+    #unittest.main()
+

From 938ee5772278f9cd0bbcdc5e5ed6b67691463dbb Mon Sep 17 00:00:00 2001
From: Thomas Miedema <thomasmiedema@gmail.com>
Date: Fri, 29 Apr 2011 23:16:58 +0200
Subject: [PATCH 0013/1541] Visualize extra particle for arbitrary timesteps

Tricking Paraview into showing 2 steps for each simulator step.
---
 visualization/vtklogger.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 0a1ee26a..41743d52 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -85,9 +85,8 @@ def __init__(self, sim, dir='vtkdata', buffer_size=None, show_shells=True,
         # Step counter.
         self.i = 0
 
-        # Needed for ParaView time hack. Note: don't make delta_t too 
-        # small, should be relative to max time.
-        self.delta_t = 1e-11
+        # Needed for ParaView time hack. Note: don't make delta_t too small.
+        self.delta_t = 1e-10
         self.last_time = INF
 
     def cleanup(self):
@@ -118,7 +117,7 @@ def log(self):
             #
             # Now ParaView should perceive a state change.
             # Only needed when showing shells (this is a choice).
-            time = self.last_time + self.delta_t
+            time = self.last_time * (1 + self.delta_t) + self.delta_t
 
         # Get data.
         particle_data = self.get_particle_data()
@@ -169,7 +168,7 @@ def writelog(self, time, index,
             self.make_snapshot('cylinder_data', cylinder_data_1, index, time)
 
             # Continue with case. 
-            time += self.delta_t / 2
+            time *= (1 + self.delta_t / 2)
             index += 1
 
         if index == 0:

From 5b6e777972b0ef3d09d170184277f4b77501d7fe Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 May 2011 16:06:33 +0200
Subject: [PATCH 0014/1541] Added documentation files to track (latex of GFs
 and pseudocode)

---
 doc/greens_functions/Makefile                 |   7 +
 doc/greens_functions/tex/Makefile             |  31 ++
 .../tex/greensFunction1DAbsAbs.tex            |  13 +
 .../tex/greensFunction1DAbsInf.tex            |  13 +
 .../tex/greensFunction1DRadAbs.tex            |  13 +
 .../tex/greensFunction1DRadInf.tex            |  13 +
 .../tex/greensFunction2DRadAbs.tex            |  12 +
 doc/greens_functions/tex/greensFunctions.tex  |  32 +++
 .../tex/greensFunctionsWDrift.tex             |  24 ++
 .../greensFunction1DAbsAbs.include.tex        |  29 ++
 .../greensFunction1DAbsInf.include.tex        |  27 ++
 .../greensFunction1DRadAbs.include.tex        |  47 ++++
 .../greensFunction1DRadInf.include.tex        |  29 ++
 .../greensFunction1DwDriftAbsAbs.include.tex  |  47 ++++
 .../greensFunction1DwDriftAbsInf.include.tex  |  35 +++
 .../greensFunction1DwDriftRadAbs.include.tex  |  67 +++++
 .../greensFunction1DwDriftRadInf.include.tex  |  40 +++
 .../greensFunction2DRadAbs.include.tex        |  62 ++++
 doc/greens_functions/tex/include/include.tex  |  27 ++
 .../tex/include/subSectionOnly.tex            |  27 ++
 doc/pseudocode/Makefile                       |  15 +
 doc/pseudocode/diagrams.html                  |   9 +
 doc/pseudocode/diagrams/Makefile              |  22 ++
 doc/pseudocode/diagrams/createMulti.dot       |  23 ++
 doc/pseudocode/diagrams/egfrd.dot             |  29 ++
 doc/pseudocode/diagrams/fireMulti.dot         |  15 +
 doc/pseudocode/diagrams/firePair.dot          |  42 +++
 doc/pseudocode/diagrams/fireSingle.dot        |  38 +++
 doc/pseudocode/pseudocode.py                  | 265 ++++++++++++++++++
 doc/visualization.txt                         | 158 +++++++++++
 30 files changed, 1211 insertions(+)
 create mode 100644 doc/greens_functions/Makefile
 create mode 100644 doc/greens_functions/tex/Makefile
 create mode 100644 doc/greens_functions/tex/greensFunction1DAbsAbs.tex
 create mode 100644 doc/greens_functions/tex/greensFunction1DAbsInf.tex
 create mode 100644 doc/greens_functions/tex/greensFunction1DRadAbs.tex
 create mode 100644 doc/greens_functions/tex/greensFunction1DRadInf.tex
 create mode 100644 doc/greens_functions/tex/greensFunction2DRadAbs.tex
 create mode 100644 doc/greens_functions/tex/greensFunctions.tex
 create mode 100644 doc/greens_functions/tex/greensFunctionsWDrift.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DAbsAbs.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DAbsInf.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DRadAbs.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DRadInf.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DwDriftAbsAbs.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DwDriftAbsInf.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DwDriftRadAbs.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DwDriftRadInf.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction2DRadAbs.include.tex
 create mode 100644 doc/greens_functions/tex/include/include.tex
 create mode 100644 doc/greens_functions/tex/include/subSectionOnly.tex
 create mode 100644 doc/pseudocode/Makefile
 create mode 100644 doc/pseudocode/diagrams.html
 create mode 100644 doc/pseudocode/diagrams/Makefile
 create mode 100644 doc/pseudocode/diagrams/createMulti.dot
 create mode 100644 doc/pseudocode/diagrams/egfrd.dot
 create mode 100644 doc/pseudocode/diagrams/fireMulti.dot
 create mode 100644 doc/pseudocode/diagrams/firePair.dot
 create mode 100644 doc/pseudocode/diagrams/fireSingle.dot
 create mode 100644 doc/pseudocode/pseudocode.py
 create mode 100644 doc/visualization.txt

diff --git a/doc/greens_functions/Makefile b/doc/greens_functions/Makefile
new file mode 100644
index 00000000..5670cce2
--- /dev/null
+++ b/doc/greens_functions/Makefile
@@ -0,0 +1,7 @@
+
+.PHONY: all
+all:
+	cd tex && $(MAKE) $(MKFLAGS) && cd ../ && mv -f build/*.pdf .
+
+clean:
+	rm -rf build/*.aux build/*.log build/include/*.aux build/include/*.log *.pdf
diff --git a/doc/greens_functions/tex/Makefile b/doc/greens_functions/tex/Makefile
new file mode 100644
index 00000000..3b842c79
--- /dev/null
+++ b/doc/greens_functions/tex/Makefile
@@ -0,0 +1,31 @@
+# Todo. Use that Makefile.am magic. And why is it recompiling even though 
+# nothing changed?
+
+# make should produce:
+#   * 1 pdf for the derivation of the Greens function of each diffusion 
+#   problem. (Todo)
+#   * 1 pdf for each problem giving the results: Greens function, survival 
+#   probability and propensity function.
+#   * greensFunctions.pdf, all results combined.
+
+
+PDFLATEX=pdflatex -output-directory=../build
+
+greensFunctions.pdf: greensFunctions.tex greensFunction1DAbsAbs.pdf greensFunction1DAbsInf.pdf greensFunction1DRadAbs.pdf greensFunction1DRadInf.pdf greensFunction2DRadAbs.pdf
+	$(PDFLATEX) greensFunctions.tex
+
+greensFunction1DAbsAbs.pdf: greensFunction1DAbsAbs.tex include/greensFunction1DAbsAbs.include.tex 
+	$(PDFLATEX) greensFunction1DAbsAbs.tex 
+
+greensFunction1DAbsInf.pdf: greensFunction1DAbsInf.tex include/greensFunction1DAbsInf.include.tex
+	$(PDFLATEX) greensFunction1DAbsInf.tex
+
+greensFunction1DRadAbs.pdf: greensFunction1DRadAbs.tex include/greensFunction1DRadAbs.include.tex
+	$(PDFLATEX) greensFunction1DRadAbs.tex
+
+greensFunction1DRadInf.pdf: greensFunction1DRadInf.tex include/greensFunction1DRadInf.include.tex
+	$(PDFLATEX) greensFunction1DRadInf.tex
+
+greensFunction2DRadAbs.pdf: greensFunction2DRadAbs.tex include/greensFunction2DRadAbs.include.tex
+	$(PDFLATEX) greensFunction2DRadAbs.tex
+
diff --git a/doc/greens_functions/tex/greensFunction1DAbsAbs.tex b/doc/greens_functions/tex/greensFunction1DAbsAbs.tex
new file mode 100644
index 00000000..77538747
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunction1DAbsAbs.tex
@@ -0,0 +1,13 @@
+
+\documentclass{article}
+
+\include{include/include}
+\include{include/subSectionOnly}
+
+
+\begin{document}
+
+\include{include/greensFunction1DAbsAbs.include}
+\include{include/greensFunction1DwDriftAbsAbs.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/greensFunction1DAbsInf.tex b/doc/greens_functions/tex/greensFunction1DAbsInf.tex
new file mode 100644
index 00000000..f0a1dfd2
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunction1DAbsInf.tex
@@ -0,0 +1,13 @@
+
+\documentclass{article}
+
+\include{include/include}
+\include{include/subSectionOnly}
+
+
+\begin{document}
+
+\include{include/greensFunction1DAbsInf.include}
+\include{include/greensFunction1DwDriftAbsInf.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/greensFunction1DRadAbs.tex b/doc/greens_functions/tex/greensFunction1DRadAbs.tex
new file mode 100644
index 00000000..83ce9cf2
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunction1DRadAbs.tex
@@ -0,0 +1,13 @@
+
+\documentclass{article}
+
+\include{include/include}
+\include{include/subSectionOnly}
+
+
+\begin{document}
+
+\include{include/greensFunction1DRadAbs.include}
+\include{include/greensFunction1DwDriftRadAbs.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/greensFunction1DRadInf.tex b/doc/greens_functions/tex/greensFunction1DRadInf.tex
new file mode 100644
index 00000000..a2adf5e3
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunction1DRadInf.tex
@@ -0,0 +1,13 @@
+
+\documentclass{article}
+
+\include{include/include}
+\include{include/subSectionOnly}
+
+
+\begin{document}
+
+\include{include/greensFunction1DRadInf.include}
+\include{include/greensFunction1DwDriftRadInf.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/greensFunction2DRadAbs.tex b/doc/greens_functions/tex/greensFunction2DRadAbs.tex
new file mode 100644
index 00000000..f6b04146
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunction2DRadAbs.tex
@@ -0,0 +1,12 @@
+
+\documentclass{article}
+
+\include{include/include}
+\include{include/subSectionOnly}
+
+
+\begin{document}
+
+\include{include/greensFunction2DRadAbs.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/greensFunctions.tex b/doc/greens_functions/tex/greensFunctions.tex
new file mode 100644
index 00000000..3dbaf570
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunctions.tex
@@ -0,0 +1,32 @@
+
+\documentclass[twoside]{report}
+
+\include{include/include}
+\include{include/subSectionOnly}
+%Page numbers instead of name.
+\fancyfoot[RO, LE]{\thepage}
+
+
+\begin{document}
+
+\title{Greens functions, survival probabilies and propensity functions (1D and 
+2D)}
+\thispagestyle{empty}
+\maketitle
+
+
+\newpage\input{include/greensFunction1DAbsAbs.include}
+\newpage\input{include/greensFunction1DwDriftAbsAbs.include}
+
+\newpage\include{include/greensFunction1DAbsInf.include}
+\newpage\include{include/greensFunction1DwDriftAbsInf.include}
+
+\newpage\include{include/greensFunction1DRadAbs.include}
+\newpage\include{include/greensFunction1DwDriftRadAbs.include}
+
+\newpage\include{include/greensFunction1DRadInf.include}
+\newpage\include{include/greensFunction1DwDriftRadInf.include}
+
+\newpage\include{include/greensFunction2DRadAbs.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/greensFunctionsWDrift.tex b/doc/greens_functions/tex/greensFunctionsWDrift.tex
new file mode 100644
index 00000000..efc4649d
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunctionsWDrift.tex
@@ -0,0 +1,24 @@
+
+\documentclass[twoside]{report}
+
+\include{include/include}
+\include{include/subSectionOnly}
+%Page numbers instead of name.
+\fancyfoot[RO, LE]{\thepage}
+
+
+\begin{document}
+
+\title{Greens functions, survival probabilies and propensity functions (1D and 
+2D)}
+\thispagestyle{empty}
+\maketitle
+
+
+\input{include/greensFunction1DwDriftAbsAbs.include}
+\include{include/greensFunction1DwDriftAbsInf.include}
+\include{include/greensFunction1DwDriftRadAbs.include}
+\include{include/greensFunction1DwDriftRadInf.include}
+\include{include/greensFunction2DwDriftRadAbs.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/include/greensFunction1DAbsAbs.include.tex b/doc/greens_functions/tex/include/greensFunction1DAbsAbs.include.tex
new file mode 100644
index 00000000..e5118ced
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DAbsAbs.include.tex
@@ -0,0 +1,29 @@
+
+\subsection{1D Abs Abs}
+
+\paragraph{Green's function}
+\begin{align}
+  p(z,t|z',t'=0) = \frac{2}{L}\sum_{n=1}^{\infty}
+  e^{-D_1n^2\pi^2t/L^2} \sin\bigg(\frac{n\pi z}{L}\bigg) \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_z(t) = \int_0^L p dz = \frac{4}{\pi} \sum_{m=0}^{\infty} \frac{1}{2m+1}
+  e^{-D_1(2m+1)^2\pi^2t/L^2} \sin\left(\frac{(2m+1)\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Propensity function}
+\begin{align}
+  q_{z=0}(t) &= \left.D_1 \pd{p}{z}\right|_{z=0} = \frac{2\pi D_1}{L^2} 
+  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n \sin\left(\frac{n\pi z'}{L}\right),\\
+  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=L} = \frac{2\pi D_1}{L^2} 
+  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n (-1)^{n+1} \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P(Z,t|z',t'=0) = \int_0^Z p dz =
+  \frac{2}{\pi} \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2 t/L^2}
+      \frac{1}{n} \left[ 1 - \cos\left(\frac{n\pi Z}{L}\right) \right] \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
\ No newline at end of file
diff --git a/doc/greens_functions/tex/include/greensFunction1DAbsInf.include.tex b/doc/greens_functions/tex/include/greensFunction1DAbsInf.include.tex
new file mode 100644
index 00000000..2329a085
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DAbsInf.include.tex
@@ -0,0 +1,27 @@
+
+\subsection{1D Abs Inf}
+
+\paragraph{Green's function}
+\begin{align}
+ p(z,t|z',t'=0)	&= \frac{1}{\sqrt{4\pi D_1t}} \left[ e^{-\frac{1}{4D_1t}(z-z')^2} - e^{-\frac{1}{4D_1t}(z+z')^2} \right].	\\
+		&= \frac{1}{\sqrt{4\pi D_1t}} \left[ 1 - e^{-\frac{zz'}{D_1t}} \right]e^{-\frac{1}{4D_1t}(z-z')^2}.
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_{z=0}(t) = \int_0^\infty p dz =
+  \text{erf}\left( \frac{z'}{\sqrt{4D_1 t}} \right).
+\end{align}
+
+\paragraph{Propensity functions}
+\begin{align}
+  q_{z=0}(t) = -\frac{d}{dt} S_{z=0}(t)=
+  \frac{z'}{2\sqrt{\pi D_1 t^3}} e^{-\frac{z'^2}{4D_1t}}.
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P_{z=0}(Z,t) = \int_a^Z p dz =
+  \erf{\left(\frac{z'}{\sqrt{4D_1t}}\right)}
+  + \frac{1}{2} \left[ \erf{\left(\frac{Z-z'}{\sqrt{4D_1t}}\right)} - \erf{\left(\frac{Z+z'}{\sqrt{4D_1t}}\right)} \right]
+\end{align}
\ No newline at end of file
diff --git a/doc/greens_functions/tex/include/greensFunction1DRadAbs.include.tex b/doc/greens_functions/tex/include/greensFunction1DRadAbs.include.tex
new file mode 100644
index 00000000..5d92fab2
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DRadAbs.include.tex
@@ -0,0 +1,47 @@
+
+\subsection{1D Rad Abs}
+
+\renewcommand{\an}{\rho_n}
+
+\paragraph{Green's function}
+\begin{align}
+  p(z,t|z',t'=0) &= 2\sum_{n=0}^{\infty}
+  e^{-D_1\an^2t} \frac
+  { F_n(z')F_n(z) }
+  {h + (\an^2 + h^2)L}, \\
+  h &= k_+ / D_1, \\
+  F_n(z) &= h\sin\an z +  \an\cos\an z  , \\
+  \tan\an L &= -\frac{\an}{h}.
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_z(t) = \int_0^L pdz
+  = 2\sum_{n=0}^{\infty} e^{-D_1\an^2t}
+    \frac{F_n(z')}{h + (\an^2 + h^2)L}
+    \frac{\left[h^2 - (\an^2 + h^2) \cos(\an L)\right]}{h\an}.
+\end{align}
+
+\paragraph{Propensity function}
+\begin{align}
+  q_{z=0}(t) = k_+ p|_{z=0} =
+    2hD_1 \sum_{n=0}^{\infty} e^{-D_1\an^2t}
+	  \frac{\an F_n(z')}{h + (\an^2 + h^2)L},
+\end{align}
+\begin{align}
+  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=L} \\
+  &=  -2D_1 \sum_{n=0}^{\infty} e^{-D_1\an^2t}
+	    \frac{
+	    F_n(z') \left[\frac{1}{h}\an^3 + h\an\right] \cos(\an L)
+	    }
+	    {h + (\an^2 + h^2)L}.
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P(Z,t|z',t'=0)) &= \int_0^Z pdz	\\
+  &= 2\sum_{n=0}^{\infty} e^{-D_1\an^2t}
+    \frac{F_n(z')}{h + (\an^2 + h^2)L}
+    \frac{\left[h^2 + h\an\sin(\an Z) - h^2 \cos(\an Z)\right]}{h\an}.
+\end{align}
+
diff --git a/doc/greens_functions/tex/include/greensFunction1DRadInf.include.tex b/doc/greens_functions/tex/include/greensFunction1DRadInf.include.tex
new file mode 100644
index 00000000..5a7d78c1
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DRadInf.include.tex
@@ -0,0 +1,29 @@
+
+\subsection{1D Rad Inf}
+
+\paragraph{Green's function}
+\begin{multline}
+  v(z,t|z',t'=0) = \frac{1}{\sqrt{4\pi D_1 t}} [
+  e^{-(z-z')^2/(4 D_1 t)} +
+  e^{-(z+z')^2/(4 D_1 t)} ] \\
+  -h e^{h(z+z') + D_1 th^2} \erfc(\frac{z+z'}{2\sqrt{D_1t}} + h\sqrt{D_1t}) 
+  .\label{green-promoter-solo}
+\end{multline}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_{z=0}(t) = 1 +  e^{h z' + D_1 t h^2}
+  \erfc(\frac{z'}{2 \sqrt{D_1 t}}  + h \sqrt{D_1 t}) -
+  \erfc(\frac{z'}{2 \sqrt{D_1 t}}).
+\end{align}
+
+\paragraph{Propensity function}
+% Not in my notes (Thomas).
+\begin{align}
+  q_{z=0}(t) &= k_+ v|_{z=0} \\
+  &= \frac{h \sqrt{D_1}}{\sqrt{\pi t}} e^{-z'^2/(4 D_1 t)}  
+  -h^2D_1e^{hz'+D_1th^2} \erfc(\frac{z'}{2\sqrt{D_1t}} + kh\sqrt{D_1t}).  
+\end{align}
+\begin{multline}
+\end{multline}
+
diff --git a/doc/greens_functions/tex/include/greensFunction1DwDriftAbsAbs.include.tex b/doc/greens_functions/tex/include/greensFunction1DwDriftAbsAbs.include.tex
new file mode 100644
index 00000000..28412252
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DwDriftAbsAbs.include.tex
@@ -0,0 +1,47 @@
+
+\subsection{1D Abs Abs with drift $v\neq 0$}
+
+Solution on an interval $[a,b]$, initial condition $p(z,z',t'=0)=\delta (z-z')$.
+
+\paragraph{Green's function}
+\begin{align}
+  p(z,t|z',t'=0) &= \frac{2}{b-a}e^{-\frac{1}{4D_1t}\left[v^2t^2 - 2(z-z')vt \right]}
+  \sum_{n=1}^{\infty}
+  e^{-D_1\left(\frac{n\pi}{b-a}\right)^2 t} \sin\left(\frac{z-a}{b-a}n\pi\right) \sin\left(\frac{z'-a}{b-a}n\pi\right).
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_z(t) = \int_a^b pdz
+  = 2e^{-\frac{1}{4D_1t}\left[ v^2t^2 + 2 z'vt \right]}
+    \sum_{n=1}^{\infty}
+	\frac{ e^{-D_1\left(\frac{n\pi}{b-a}\right)^2 t} \left[ e^{\frac{va}{2D_1}} - (-1)^n e^{\frac{vb}{2D_1}}\right] }
+	     { \frac{v^2}{4D_1^2}(b-a)^2 + n^2\pi^2 }
+	n\pi \sin\left(\frac{z'-a}{b-a}n\pi \right).
+\end{align}
+
+\paragraph{Propensity function}
+\begin{align}
+  q_{z=0}(t) &= \left.D_1 \pd{p}{z}\right|_{z=a} = \frac{2 D_1}{(b-a)^2} e^{-\frac{1}{4D_1 t}\left[ v^2t^2 - 2(a-z')vt \right]}
+  \sum_{n=1}^{\infty} e^{-D_1\left(\frac{n\pi}{b-a}\right)^2 t} n\pi \sin\left(\frac{z'-a}{b-a}n\pi\right),\\
+  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=b} = \frac{2 D_1}{(b-a)^2} e^{-\frac{1}{4D_1 t}\left[ v^2t^2 - 2(b-z')vt \right]}
+  \sum_{n=1}^{\infty} (-1)^{n+1} e^{-D_1\left(\frac{n\pi}{b-a}\right)^2 t} n\pi \sin\left(\frac{z'-a}{b-a}n\pi\right).
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+ & P(Z,t|z',t'=0) = \int_a^Z p dz &\\
+ & = 2e^{-\frac{1}{4D_1t}\left[v^2t^2 + 2z'vt \right]}  &\\
+ & \quad\times \sum_{n=1}^{\infty}
+      \frac{	e^{-D_1\left(\frac{n\pi}{b-a}\right)^2 t}
+		\left[
+		  e^{\frac{va}{2D_1}} + e^{\frac{vZ}{2D_1}}
+		      \left\lbrace
+			\frac{v}{2D_1}\frac{(b-a)}{n\pi}\sin\left(\frac{Z-a}{b-a}n\pi\right)
+		      - \cos\left(\frac{Z-a}{b-a}n\pi\right)
+		      \right\rbrace
+		\right]
+      }
+      { \frac{v^2}{4D_1^2}(b-a)^2 + n^2\pi^2 } 
+      n\pi \sin\left(\frac{z'-a}{b-a}n\pi\right).&
+\end{align}
\ No newline at end of file
diff --git a/doc/greens_functions/tex/include/greensFunction1DwDriftAbsInf.include.tex b/doc/greens_functions/tex/include/greensFunction1DwDriftAbsInf.include.tex
new file mode 100644
index 00000000..39ec09da
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DwDriftAbsInf.include.tex
@@ -0,0 +1,35 @@
+
+\subsection{1D Abs Inf with drift $v\neq 0$}
+
+Absorbing boundary at $z=0$.
+
+\paragraph{Green's function}
+\begin{align}
+ p(z,t|z',t'=0)	&= e^{-\frac{1}{4D_1t}\left[v^2t^2 - 2(z-z')vt \right]} \frac{1}{\sqrt{4\pi D_1t}}
+			\left[ e^{-\frac{1}{4D_1t}(z-z')^2} - e^{-\frac{1}{4D_1t}(z+z')^2} \right].	\\
+		&= \frac{1}{\sqrt{4\pi D_1t}} \left[ 1 - e^{-\frac{zz'}{D_1t}} \right]e^{-\frac{1}{4D_1t}(z-z'-vt)^2}.
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_{z=0}(t) &= \int_a^\infty p dz				\\
+& = \frac{1}{2}\left( 1 - e^{-\frac{vz'}{D_1}} \right)
+  + \frac{1}{2} \left[ \erf{\left(\frac{z'+vt}{\sqrt{4D_1t}}\right)} + e^{-\frac{vz'}{D_1}} \erf{\left(\frac{z'-vt}{\sqrt{4D_1t}}\right)} \right] .
+\end{align}
+
+\paragraph{Propensity functions}
+\begin{align}
+  q_{z=0}(t) = -\frac{d}{dt} S_{z=0}(t)=
+  \frac{z'}{\sqrt{4 \pi D_1 t^3}} e^{-\frac{1}{4D_1t}(z'+vt)^2} .
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P_{z=0}(Z,t) &= \int_a^Z p dz 													\\
+& = \frac{1}{2} \left[ \erf{\left(\frac{z'+vt}{\sqrt{4D_1t}}\right)} + \erf{\left(\frac{Z-z'-vt}{\sqrt{4D_1t}}\right)} \right]
+  +\frac{1}{2} e^{-\frac{vz'}{D_1}} \left[ \erf{\left(\frac{z'-vt}{\sqrt{4D_1t}}\right)} - \erf{\left(\frac{Z+z'-vt}{\sqrt{4D_1t}}\right)} \right] .
+\end{align}
+
+\vspace{1cm}
+\noindent \textit{For the case 1D Refl Inf with drift see:}\\
+\textit{\textsc{Smoluchowski}, Phys.Z. 17, p. 557-587, 1916, eq. (52)--(54)}.
\ No newline at end of file
diff --git a/doc/greens_functions/tex/include/greensFunction1DwDriftRadAbs.include.tex b/doc/greens_functions/tex/include/greensFunction1DwDriftRadAbs.include.tex
new file mode 100644
index 00000000..13b2d608
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DwDriftRadAbs.include.tex
@@ -0,0 +1,67 @@
+
+\subsection{1D Rad Abs with drift $v\neq 0$}
+
+Solution on an interval $[a,b]$, initial condition $p(z,z',t'=0)=\delta (z-z')$.
+
+\newcommand{\rn}{\rho_n}
+
+\paragraph{Green's function}
+\begin{align}
+  & p(z,t|z',t'=0) = 2e^{-\frac{1}{4D_1t}\left[v^2t^2 - 2(z-z')vt \right]}
+      \sum_{n=0}^{\infty} e^{-D_1\rn^2t} \frac{ F_n(z')F_n(z) }
+      {h + \left[\rn^2 + h^2\right]L}, \\
+  &\quad\quad F_n(z) = h\sin\left(\rn(z-a)\right) +  \rn\cos\left(\rn(z-a)\right)  , \\
+  &\quad\quad h = \frac{v/2 + k_+}{D_1}, \quad\quad L=(b-a), \quad\quad \tan\left(\rn L\right)=-\frac{\rn}{h}.
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_z(t)
+  &= \int_a^b pdz = 2e^{-\frac{1}{4D_1t}\left[ v^2t^2 + 2z'vt \right]} \\
+  &\quad\quad
+    \times\sum_{n=0}^{\infty} e^{-D_1\rn^2t}
+    \frac{F_n(z')}{\Big. h + \left[\rn^2 + h^2\right]L \Big.}
+    \frac{
+    \left[
+	  e^{\frac{va}{2D_1}} h \frac{k_+}{D_1}
+	- e^{\frac{vb}{2D_1}} \left(\rn^2 + h^2\right) \cos(\rn L)
+    \right]
+    }
+    {\frac{h}{\rn}\left[ \rn^2 + \frac{v^2}{4 D_1^2} \right]}.
+\end{align}
+
+\paragraph{Propensity function}
+\begin{align}
+  q_{z=0}(t) &= k_+ p|_{z=a} = 2k_+ e^{-\frac{1}{4D_1t}\left[v^2t^2 - 2(a-z')vt \right]} 
+  \sum_{n=0}^{\infty} e^{-D_1\rn^2t}
+  \frac{ \rn F_n(z')} {h + \left[\rn^2 + h^2\right]L}, \\
+  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=b} \\
+  &=  -2D_1 e^{-\frac{1}{4D_1t}\left[v^2t^2 - 2(b-z')vt \right]} 
+    \sum_{n=0}^{\infty} e^{-D_1\rn^2t}
+    \frac{F_n(z') \left[\frac{1}{h}\rn^3 + h\rn\right]\cos\left(\rn L\right)
+ }
+  {h + \left[\rn^2 + h^2\right]L}.
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{multline}
+ P(Z,t|z',t'=0) = \int_a^Z pdz \\
+ \shoveleft{
+  = 2e^{-\frac{1}{4D_1t}\left[ v^2t^2 + 2z'vt \right]}
+    \sum_{n=0}^{\infty} e^{-D_1\rn^2t} \left\lbrace \frac{F_n(z')}{\Big. h + \left[\rn^2 + h^2\right]L \Big.} \right.
+ } \\
+ \shoveright{
+    \quad\quad\quad \left.\times
+    \frac{
+    \left[
+	  e^{\frac{va}{2D_1}} h\frac{k_+}{D_1}
+	- e^{\frac{vZ}{2D_1}}
+	    \left\lbrace
+	       h\frac{k_+}{D_1}\cos\left(\rn(Z-a)\right) - \left(h\rn + \frac{h^2}{\rn}\frac{v}{2D_1}\right)\sin\left(\rn(Z-a)\right)
+	    \right\rbrace
+    \right]
+    }
+    {\frac{h}{\rn}\left[ \rn^2 + \frac{v^2}{4 D_1^2} \right]}
+    \right\rbrace .
+ }
+\end{multline}
diff --git a/doc/greens_functions/tex/include/greensFunction1DwDriftRadInf.include.tex b/doc/greens_functions/tex/include/greensFunction1DwDriftRadInf.include.tex
new file mode 100644
index 00000000..b5530cb7
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DwDriftRadInf.include.tex
@@ -0,0 +1,40 @@
+
+\subsection{1D Rad Inf with drift $v\neq 0$}
+
+\paragraph{Green's function}
+\begin{multline}
+  p(z,t|z',t'=0) = \frac{1}{\sqrt{4\pi D_1 t}} [
+			e^{-(z-z'-vt)^2/(4 D_1 t)} +
+  e^{-\frac{vz'}{D_1}}	e^{-(z+z'-vt)^2/(4 D_1 t)} ] \\
+  -(h+\frac{v}{2D_1}) e^{\frac{vz'}{D_1}}
+    e^{h \left[ (z+z') + (h + v/D_1) D_1 t \right]} \erfc\left(\frac{z+z'}{\sqrt{4D_1t}} + (h+\frac{v}{2D_1})\sqrt{D_1t} \right) 
+  .\label{green-promoter-solo-drift}
+\end{multline}
+\textit{Source: \textsc{Lamm \& Schulten}, J. Chem. Phys. 78(5), 1983.}
+
+\paragraph{Survival probability}
+%\begin{align}
+%  S_{z=0}(t) &= 1 + \frac{1}{2}\left[ \erf\left( \frac{z'+vt}{4D_1 t}\right) - \erf\left( \frac{z'-vt}{4D_1 t}\right) \right] \\
+%  &\quad + \left(\frac{k_+ + \frac{v}{2}}{k_+ + v}\right) 
+%  \times \left\lgroup
+%	e^{h \left[ z' + \left(h+\frac{v}{D_1}\right) D_1 t \right]} \erfc\left[ \frac{z'}{\sqrt{4D_1 t}} + \left(h+\frac{v}{2D_1}\right)\sqrt{D_1 t} \right] \right.\\
+%	&\left. \quad- \, e^{- \frac{v}{D_1}z'}
+%	\erfc\left[ \frac{z'}{\sqrt{4D_1 t}} - \frac{v}{2D_1}\sqrt{D_1 t} \right]
+%  \right\rgroup.
+%\end{align}
+%%% ABOVE VERSION IS WRONG, HAS TO BE RECALCULATED!
+
+\paragraph{Propensity function}
+% Mathematica result (Tomek)
+%\begin{align}
+%  q_{z=0}(t) &= -\partial_t S(t) \\
+%  &= \frac{1}{4\sqrt{\pi D_1 t^3}}
+%	\Bigg\lbrace
+%		e^{-\frac{(z'+vt)^2}{4D_1 t}} \left[ z'\left( 1-e^{\frac{vz'}{D_1}} \right)
+%						     - vt \left( 1+e^{\frac{vz'}{D_1}}\right) \right] \\
+%	&
+%		+ 2t (2k_+ + v) \left[ 1 - h \sqrt{\frac{\pi t}{D_1}} e^{\frac{\left[z'+(2k_+ + v)t\right]^2}{4D_1 t}}
+%			\erfc\left(\frac{z' + (2k_+ + v)t}{\sqrt{4 D_1 t}} \right)
+%		\right]	\Bigg\rbrace
+%\end{align}
+%%% ABOVE VERSION IS WRONG, HAS TO BE RECALCULATED!
\ No newline at end of file
diff --git a/doc/greens_functions/tex/include/greensFunction2DRadAbs.include.tex b/doc/greens_functions/tex/include/greensFunction2DRadAbs.include.tex
new file mode 100644
index 00000000..a90d643c
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction2DRadAbs.include.tex
@@ -0,0 +1,62 @@
+\subsection{2D Rad Abs}
+
+\paragraph{Green's function}
+\begin{multline}
+  v(r,\t, t) = \frac{\pi}{4} \sum_{m=-\infty}^{\infty} \cos m(\t-\t') \\
+  \cdot \sum_{n=1}^{\infty} \frac{\amn^2 J_m^2(b\amn)}{F(\amn)} 
+  C_m(r,\amn)C_m(r',\amn)e^{-D_3\amn^2t},
+\end{multline}
+
+where
+\begin{align}
+  F(\amn) = \left[hJ_m(a\amn) - \amn J_m'(a\amn)\right]^2
+  -[\amn^2+h^2-m^2/a^2]J_m^2(b\amn)
+\end{align}
+and
+\begin{multline}
+  C_m(r,\amn) = J_m(r\amn)\left[hY_m(a\amn)-\amn Y_m'(a\amn)\right]-\\
+  Y_m(r\amn)\left[hJ_m(a\amn)-\amn J_m'(a\amn)\right],
+\end{multline}
+%How can you get F= and C= to align?
+
+while $\amn$ is the $n$-th root of
+\begin{align}
+ \left[\a J_m'(a\a)-hJ_m(a\a)\right]Y_m(b\a) -
+ \left[\a Y_m'(a\a)-hY_m(a\a)\right]J_m(b\a) = 0.
+\end{align}
+
+
+
+\paragraph{Survival probability}
+\begin{align}
+  S(t) &= \int_0^{2\pi}\int_a^bv(r,\t,t)rd\t dr\notag\\
+  &= \frac{\pi^2}{2} \cdot \sum_{n=1}^{\infty}
+  \frac{\azn^2 J_0^2(b\azn)}{F(\azn)}
+  C_0(r',\azn)e^{-D_3\azn^2t} \cdot \int_a^bC_0(r,\azn)r dr
+\end{align}
+
+where
+\begin{align}
+  \int_a^bC_0(r,\azn)r dr = &\frac{1}{\azn}\left[bJ_1(b\azn) - 
+  aJ_1(a\azn)\right] \left[hY_m(a\azn)-\azn Y_m'(a\azn)\right]-\\
+  &\frac{1}{\azn}\left[bY_1(b\azn) - aY_1(a\azn)\right] \left[hJ_m(a\azn)-\azn 
+  J_m'(a\azn)\right]
+\end{align}
+
+and $C_0(r,\azn)$, $F(\azn)$ and $\azn$ are the same as above with $m=0$.
+
+\paragraph{Propensity function}
+Todo.
+% Not in my notes (Thomas).
+
+%\begin{align}
+%  q_{r=a}(t) = k_+ v|_{r=a} =
+%\end{align}
+%\begin{multline}
+%  q_{z=L}(t) = \left.- D_3 \pd{v}{z}\right|_{z=L} =
+%\end{multline}
+
+
+
+
+
diff --git a/doc/greens_functions/tex/include/include.tex b/doc/greens_functions/tex/include/include.tex
new file mode 100644
index 00000000..755dfe88
--- /dev/null
+++ b/doc/greens_functions/tex/include/include.tex
@@ -0,0 +1,27 @@
+
+\author{Thomas Miedema (miedema@amolf.nl)\\Thomas Sokolowski (sokolowski@amolf.nl)}
+\date{}
+
+\usepackage{amsmath}
+
+\numberwithin{equation}{section}  %nice equation numbers
+\usepackage{verbatim}		  %multiline comments
+\usepackage{graphicx}
+\usepackage{algorithmic}
+\usepackage{algorithm}
+
+\hbadness 10000  % Disable underfull hbox warnings.
+
+
+
+\newcommand{\pd}[2]{\frac{\partial #1}{\partial #2}}
+\renewcommand{\a}{\alpha}
+\newcommand{\an}{\alpha_n}
+\newcommand{\amn}{\alpha_{mn}}
+\newcommand{\azn}{\alpha_{0n}} % alpha zero n
+\renewcommand{\t}{\theta}
+\newcommand{\pdd}[2]{\frac{\partial^{2} #1}{\partial #2^{2}}}
+\newcommand{\ora}{\overrightarrow}
+
+\DeclareMathOperator{\erf}{erf}
+\DeclareMathOperator{\erfc}{erfc}
diff --git a/doc/greens_functions/tex/include/subSectionOnly.tex b/doc/greens_functions/tex/include/subSectionOnly.tex
new file mode 100644
index 00000000..2c442cab
--- /dev/null
+++ b/doc/greens_functions/tex/include/subSectionOnly.tex
@@ -0,0 +1,27 @@
+\usepackage{fancyhdr}
+
+\pagestyle{fancy} %fancyplain
+\lhead{}
+\chead{}
+\rhead{}
+\renewcommand{\headrulewidth}{0pt}
+\cfoot{}
+% Name instead of page numbers.
+\fancyfoot[RO]{\small Th. Miedema (miedema@amolf.nl), Th. Sokolowski (sokolowski@amolf.nl)}
+
+
+% Disables chapter, section and subsection numbering.
+\setcounter{secnumdepth}{-1} 
+
+% Disables numbering of equations.
+\nonumber
+
+
+
+
+
+
+
+
+% GRAVEYARD
+%\renewcommand{\align}{\align*} %Doesn't do anything!
diff --git a/doc/pseudocode/Makefile b/doc/pseudocode/Makefile
new file mode 100644
index 00000000..5536a9c9
--- /dev/null
+++ b/doc/pseudocode/Makefile
@@ -0,0 +1,15 @@
+
+# sudo yum install python-pygments
+
+all: pseudocode diagrams
+
+pseudocode:
+	pygmentize -l python -f html -O full -o pseudocode.html pseudocode.py
+
+.PHONY: diagrams
+diagrams:
+	cd diagrams && make
+
+clean:
+	rm -rf pseudocode.html
+	cd diagrams && make clean
diff --git a/doc/pseudocode/diagrams.html b/doc/pseudocode/diagrams.html
new file mode 100644
index 00000000..9a4fdde8
--- /dev/null
+++ b/doc/pseudocode/diagrams.html
@@ -0,0 +1,9 @@
+<html>
+<body>
+  <img src="diagrams/egfrd.png"/>
+  <img src="diagrams/fireSingle.png"/>
+  <img src="diagrams/createMulti.png"/>
+  <img src="diagrams/firePair.png"/>
+  <img src="diagrams/fireMulti.png"/>
+</body>
+</html>
diff --git a/doc/pseudocode/diagrams/Makefile b/doc/pseudocode/diagrams/Makefile
new file mode 100644
index 00000000..4ba1126e
--- /dev/null
+++ b/doc/pseudocode/diagrams/Makefile
@@ -0,0 +1,22 @@
+
+# sudo yum install graphviz
+
+all: egfrd fireSingle firePair fireMulti createMulti
+
+egfrd:
+	dot egfrd.dot -Tpng -o egfrd.png
+
+fireSingle:
+	dot fireSingle.dot -Tpng -o fireSingle.png
+
+firePair:
+	dot firePair.dot -Tpng -o firePair.png
+
+fireMulti:
+	dot fireMulti.dot -Tpng -o fireMulti.png
+
+createMulti:
+	dot createMulti.dot -Tpng -o createMulti.png
+
+clean:
+	rm -rf *.png
diff --git a/doc/pseudocode/diagrams/createMulti.dot b/doc/pseudocode/diagrams/createMulti.dot
new file mode 100644
index 00000000..a352c7eb
--- /dev/null
+++ b/doc/pseudocode/diagrams/createMulti.dot
@@ -0,0 +1,23 @@
+
+// dot createMulti.dot -Tpng -o createMulti.png
+
+digraph createMulti {
+
+edge [color=blue];
+node [color=red];
+
+createMulti -> addToMultiRecursive
+createMulti -> addToMultiRecursive
+createMulti -> addToMultiRecursive [label=" neighbors"]
+
+addToMultiRecursive -> "type?"
+
+"type?" -> single
+single -> addToMulti
+single -> burstNonMultis
+single -> addToMultiRecursive2
+addToMultiRecursive2 [label="addToMultiRecursive"]
+
+"type?" -> multi
+multi -> mergeMultis
+}
diff --git a/doc/pseudocode/diagrams/egfrd.dot b/doc/pseudocode/diagrams/egfrd.dot
new file mode 100644
index 00000000..3f49720e
--- /dev/null
+++ b/doc/pseudocode/diagrams/egfrd.dot
@@ -0,0 +1,29 @@
+
+// http://linuxdevcenter.com/pub/a/linux/2004/05/06/graphviz_dot.html
+// dot egfrd.dot -Tpng -o egfrd.png
+
+// Directed graph.
+digraph egfrd {
+
+edge [color=blue];
+node [color=red];
+  
+EGFRDSimulator [shape=box]
+
+EGFRDSimulator -> initialize
+EGFRDSimulator -> step
+
+initialize -> createSingle
+initialize -> createSingle
+initialize -> createSingle
+
+step -> scheduler
+
+scheduler -> "topEvent"
+
+"topEvent" -> fireSingle [label="single?"]
+"topEvent" -> firePair [label=" pair?"]
+"topEvent" -> fireMulti [label="multi?"]
+
+}
+
diff --git a/doc/pseudocode/diagrams/fireMulti.dot b/doc/pseudocode/diagrams/fireMulti.dot
new file mode 100644
index 00000000..63e006fc
--- /dev/null
+++ b/doc/pseudocode/diagrams/fireMulti.dot
@@ -0,0 +1,15 @@
+// dot fireMulti.dot -Tpng -o fireMulti.png
+
+digraph fireMulti {
+
+edge [color=blue];
+node [color=red];
+
+fireMulti -> "bd step (not discussed)"
+fireMulti -> burstMulti [label="reaction\nor escape?"]
+
+burstMulti -> createSingle
+burstMulti -> createSingle
+burstMulti -> createSingle
+}
+
diff --git a/doc/pseudocode/diagrams/firePair.dot b/doc/pseudocode/diagrams/firePair.dot
new file mode 100644
index 00000000..da1ebf98
--- /dev/null
+++ b/doc/pseudocode/diagrams/firePair.dot
@@ -0,0 +1,42 @@
+// dot firePair.dot -Tpng -o firePair.png
+
+digraph firePair {
+
+edge [color=blue];
+node [color=red];
+
+firePair -> "eventType?"
+
+"eventType?" -> "Single Reaction"
+"eventType?" -> "Pair Reaction"
+"eventType?" -> Escape
+
+"Single Reaction" -> burstPair
+burstPair -> propagatePair1
+propagatePair1 [label=propagatePair]
+propagatePair1 -> drawNewPositions1
+drawNewPositions1 [label=drawNewPositions]
+drawNewPositions1 -> drawNewCoM1
+drawNewCoM1 [label=drawNewCoM]
+drawNewPositions1 -> drawNewIV1
+drawNewIV1 [label=drawNewIV]
+
+
+"Single Reaction" -> fireSingleReaction
+fireSingleReaction -> createSingle [label=" product?"]
+
+"Pair Reaction" -> drawNewCoM
+"Pair Reaction" -> createSingle1
+createSingle1 [label=createSingle]
+
+
+Escape -> propagatePair2
+propagatePair2 [label=propagatePair]
+propagatePair2 -> drawNewPositions2
+drawNewPositions2 [label=drawNewPositions]
+drawNewPositions2 -> drawNewCoM2
+drawNewCoM2 [label=drawNewCoM]
+drawNewPositions2 -> drawNewIV2
+drawNewIV2 [label=drawNewIV]
+}
+
diff --git a/doc/pseudocode/diagrams/fireSingle.dot b/doc/pseudocode/diagrams/fireSingle.dot
new file mode 100644
index 00000000..a5acf4f1
--- /dev/null
+++ b/doc/pseudocode/diagrams/fireSingle.dot
@@ -0,0 +1,38 @@
+// dot fireSingle.dot -Tpng -o fireSingle.png
+
+digraph fireSingle {
+
+edge [color=blue];
+node [color=red];
+
+fireSingle -> "eventType?"
+
+"eventType?" -> "Single Reaction"
+"eventType?" -> Else
+
+"Single Reaction" -> propagateSingle1
+propagateSingle1 [label=propagateSingle]
+propagateSingle1 -> drawNewPosition1
+drawNewPosition1 [label=drawNewPosition]
+"Single Reaction" -> fireSingleReaction
+fireSingleReaction -> createSingle1 [label=" product?"]
+createSingle1 [label=createSingle]
+
+Else -> propagateSingle2
+propagateSingle2 [label=propagateSingle]
+propagateSingle2 -> drawNewPosition2
+drawNewPosition2 [label=drawNewPosition]
+
+Else -> eventType2
+eventType2 [label="eventType?"]
+
+eventType2 -> Interaction
+Interaction -> fireSingleReaction2
+fireSingleReaction2 [label=fireSingleReaction]
+fireSingleReaction2 -> createSingle2 [label=" product?"]
+createSingle2 [label=createSingle]
+
+eventType2 -> Escape
+Escape -> "See code"
+}
+
diff --git a/doc/pseudocode/pseudocode.py b/doc/pseudocode/pseudocode.py
new file mode 100644
index 00000000..221dbbfc
--- /dev/null
+++ b/doc/pseudocode/pseudocode.py
@@ -0,0 +1,265 @@
+class Single: 
+    """ A Single contains:
+        - 1 Particle of a certain Species
+        - 1 shell (Sphere or Cylinder)
+        - 1 Domain (Cartesian or Radial, wrapper around appropriate GF) 
+        - public methods determineNextEvent and drawNewPosition
+
+    """
+
+
+class Pair:
+    """A pair contains:
+        - 2 Particles
+        - 1 shell (Sphere or Cylinder)
+        - 1 domain for center of mass (Cartesian or Radial)
+        - 1 domain for interparticle vector (Composite: r and theta)
+        - public methods determineNextEvent, drawNewPositions, drawNewCoM
+
+    """
+
+
+class EGFRDSimulator:
+    """An EGFRDSimulator stores information about:
+
+    surfaces:
+        - surfaceList
+
+    types of particles that can exist on each surface:
+        - speciesList
+
+    possible reactions each species can undergo:
+        - reactionTypeMap1 (for the monomolecular reactions)
+        - reactionTypeMap2 (for the bimolecular reactions)
+        - interactionTypeMap (for the particle-surface interactions)
+
+    position of each particle:
+        - particleMatrix
+
+    position and size of each shell:
+        - sphereMatrix (for the spherical shells)
+        - cylinderMatrix (for the cylindrical shells)
+
+    order of events:
+        - scheduler (contains Singles, Pairs and Multis)
+
+    """
+    def initialize:
+        for particle in all particles:
+            createSingle( particle )
+
+
+    def step:
+        # The event scheduler calls fireSingle, firePair or fireMulti, 
+        # depending on the type of the top event.
+
+
+
+    # singles
+
+    def createSingle( particle ):
+        # Create single with dt=0. The surface the particle is on determines 
+        # the type of the single (CylindricalSurfaceSingle, 
+        # PlanarSurfaceSingle, SphericalSingle).
+
+
+    def createInteraction( single, surface ):
+        # Create interaction single including the particle and the surface.
+        # The surface the particle is on determines the type of the 
+        # interaction single (CylindricalSurfaceInteraction, 
+        # PlanarSurfaceInteraction).
+
+
+    def fireSingle( single ):
+        if eventType == REACTION:
+            propagateSingle( single )
+            fireSingleReaction( single )
+            return
+        if eventType == INTERACTION:
+            propagateSingle( single )
+            # The reactionType of the single distinguishes this case from the 
+            # above in fireSingleReaction.
+            fireSingleReaction( single )
+            return
+
+        # ESCAPE
+        propagateSingle( single )
+
+        # Find neighbors within burstVolume, and closestObject outside of 
+        # burstVolume. BurstVolume depends on the surface the particle is on.  
+        # Spherical by default.
+        ( neighbors, closestObject, distanceToShellOfClosestObject ) =
+            getNeighbors( position, burstVolume )
+
+        if neighbors:
+            burstedSingles = burstNonMultis( neighbor )
+            if tryInteractionOrPairOrMulti( single, bursted ):
+                return
+            else:
+                # If nothing was formed, recheck closest and restore shells.
+                ( closestObject, distanceToShellOfClosestObject ) = 
+                getClosestObj( position )
+
+        updateSingle( single, closestObject, distanceToShellOfClosestObject )
+
+        # Avoid livelock.
+        restoreSingleShells( burstedSingles )
+            
+
+    def tryInteractionOrPairOrMulti( single1, neighbors ):
+        # Try to make an interaction or a pair with single1 and the closest 
+        # neighbor. If single1 and closest neighbor are too far apart, do 
+        # nothing. If more than 2 objects are close together, make a multi.
+
+
+    def burstSingle( single ):
+        # There is a technical difference, not mentioned now.
+        propagateSingle( single )
+
+
+    def propagateSingle( single ):
+        drawNewPosition()
+        # If the single is an interaction single, remove it and create a 
+        # normal single at the same position using createSingle().
+
+
+    def restoreSingleShells( singles ):
+        for single in singles:
+            ( closestObject, distanceToShellOfClosestObject ) = getClosestObj()
+            updateSingle( single, closestObject,
+                          distanceToShellOfClosestObject )
+
+
+    def updateSingle( single, closestObject, distanceToShellOfClosestObject ): 
+        if closestObject is Single:
+            radiusOfSingle = 
+                calculateSingleShellSize( single, closestObject, 
+                                          distanceToShellOfClosestObject )
+        else:
+            # closestObject is Pair or Multi or Surface.
+            # It is harder to determine the optimal shellSize. Make single as 
+            # big as possible for now.
+            radiusOfSingle = distanceToShellOfClosestObject
+
+        ( dt, eventType ) = determineNextEvent( )
+
+
+    def calculateSingleShellSize( single, single2, 
+                                  distanceToShellOfSingle2 ):
+        # Optimal shellSize is half of the distance between the 2 particles if 
+        # the radii and the diffusion constants are the same.
+        return min( radius1 + sqrtD1 / ( sqrtD1 + sqrtD2 ) *
+                              ( distanceBetweenParticles -
+                                ( radius1 + radius2 ) ),
+                    distanceToShellOfSingle2 )
+
+
+    def fireSingleReaction( single ):
+        if number of products is 1:
+            if reactionType is SurfaceUnbindingReactionType:
+                newpos = randomUnbindingSite( oldpos )
+            elif reactionType is SurfaceBindingReactionType:
+                newpos = projectedPoint( oldpos )
+            else:
+                # A -> B, no surfaces involved.
+                newpos = oldpos
+
+            createSingle( productParticle ) # at newpos
+
+        elif number of products is 2:
+            # A -> B + C, no surfaces involved.
+            # Draw a random vector of a fixed length. The orientation depends 
+            # on the surface the particle is on.
+            length = ( particleRadius1 + particleRadius2 ) * 
+                     MINIMAL_SEPERATION_FACTOR )
+            vector = randomVector( length )
+
+            newpos1 = oldpos + vector * ( D1 / D12 )
+            newpos2 = oldpos - vector * ( D2 / D12 )
+
+            createSingle( particle1 ) # at newpos1
+            createSingle( particle2 ) # at newpos2
+
+
+
+    # pairs
+
+    def createPair( single1, single2, shellSize )
+        # Create pair around the CoM of particle1 and particle2 with shellSize 
+        # as radius. The surface the particles are on determines the type of 
+        # the pair (CylindricalSurfacePair, PlanarSurfacePair, SphericalPair).
+
+
+    def firePair( pair ):
+        if eventType == SINGLE_REACTION:
+            burstPair( pair )
+            fireSingleReaction( reactingsingle )
+        elif eventType == PAIR_REACTION:
+            newCenterOfMass = drawNewCoM()
+            createSingle( productParticle ) # at newCenterOfMass
+        else:
+            # Escape through either r or R.
+            propagatePair( pair )
+
+
+    def burstPair( pair ):
+        # There is a technical difference, not mentioned now.
+        propagatePair( pair )
+
+
+    def propagatePair( pair ):
+        drawNewPositions() # for both particles.
+
+
+
+    # multis
+
+    def createMulti( single, neighbors ):
+        # Create multi and add the single and all objects in the neighbors 
+        # list recursively. A multi has it's own Brownian Dynamics simulator.    
+        addToMulti( single, multi )
+        for neighbor in neighbors:
+            addToMultiRecursive( neighbor, multi )
+
+
+    def addToMultiRecursive( thisObject, multi ):
+        if thisObject is Single:
+            addToMulti( thisObject, multi )
+            # First burst neighboring objects that have a shell within 
+            # MULTI_SHELL_FACTOR * radius of thisObject.
+            neighbors = burstNonMulti( neighbors )
+            # Then select only those neighbors who have a particle that is 
+            # within MULTI_SHELL_FACTOR * radius of thisObject. 
+            (no pseudocode here)
+            # Finally, add those neighbors recursively.
+            for neighbor in neighbors:
+                addToMultiRecursive( neighbor, multi )
+        else:
+            mergeMultis( thisObject, multi )
+
+
+    def addToMulti( single, multi ):
+        addParticle( particle )
+        # Add a static shell with a radius that is the radius of the particle 
+        # multiplied by MULTI_SHELL_FACTOR. When the particle leaves this 
+        # shell, the multi is bursted (see fireMulti).  
+        shellSize = radiusOfParticle * MULTI_SHELL_FACTOR
+        addShell( position, shellSize )
+
+
+    def mergeMultis( multi1, multi2 ):
+        #Merge multi1 into multi2.
+
+
+    def fireMulti( multi ):
+        # Do one execution step of the Brownian Dynamics simulator. Not 
+        # further discussed here.
+
+        if reaction occured or particle escaped:
+            burstMulti( multi )
+
+
+    def burstMulti( multi ):
+        for particle in all multi particles:
+            createSingle( particle )
+
diff --git a/doc/visualization.txt b/doc/visualization.txt
new file mode 100644
index 00000000..b13c9553
--- /dev/null
+++ b/doc/visualization.txt
@@ -0,0 +1,158 @@
+Visualization
+=============
+
+Notes
+-----
+* Right now this is not real-time. First you run your simulation, then you use 
+  Paraview to visualize it.
+
+
+Setting up the simulation
+-------------------------
+### Option 1
+Let a vtklogger write visualization data for the last 100 steps.
+
+* Setup the vtklogger like this in your simulation script (also see 
+  <egfrdDir>/example/example.py):
+
+	{% highlight python %}
+
+        s.initialize()
+        vtklogger = VTKLogger( s, 'myVisualizationDataDirectory', 100 )
+        while(True):
+            try:
+                vtklogger.log()
+                s.step()
+            except RuntimeError, message:
+                print 'Error.', message
+                break
+        vtklogger.stop()
+        s.stop( s.t )
+
+	{% endhighlight %}
+
+* Replace 'myVisualizationDataDirectory' by a descriptive name for each 
+  simulation that you run. It can be a nested directory structure, like 
+  'data/10000steps/run1', and is automatically created.
+
+* This stores all data in a buffer during the simulation, and only writes the 
+  last 100 steps after the simulation has finished. 
+  
+### Option 2
+Let a vtklogger write visualization data for all steps.
+
+* This is done the same way as option 1, except remove the last argument to 
+  VTKLogger.
+
+* This writes the visualization data files directly during the simulation. See 
+  below.
+
+
+
+
+Running the simulation
+----------------------
+* Run the simulation script. 
+
+  PYTHONPATH=../../ python run.py
+
+* This should produce the files static.pvd and files.pvd inside the 
+  visualization data directory specified in your simulation script. The former 
+  contains static information about the surfaces you defined in your 
+  simulation. The latter contains a list of references to .vtu files. For each 
+  timestep there is a .vtu file that contains information about the particles, 
+  a .vtu file for the sphericle shells, and a .vtu file for all the 
+  cylindrical shells.  
+
+* When not using a buffer, i.e. option 2, the .vtu files are created during 
+  the simulation. However, we have to wait for the simulation to finish before 
+  we can visualize the data using Paraview. It is not till the call to 
+  vtklogger.stop() that files.pvd is created with an overview of all .vtu 
+  files. This is the reason that the visualization can not be shown real-time 
+  at the moment.
+
+
+
+
+Configuring Paraview
+--------------------
+* Install Paraview. http://paraview.org/
+
+* Copy the plugins <egfrdDir>/paraview/tensorGlyph.xml and
+  <egfrdDir>/paraview/tensorGlyphCustomSource.xml to
+  /home/<username>/.config/ParaView/ParaView<VERSION>/Plugins/
+  replacing <VERSION> by the version of your Paraview installation (for
+  example 3.6). These 2 files are needed to show cylinders of different sizes
+  and different orientations correctly.
+
+* In <egfrdDir>/paraview/pipeline.pvsm search for and replace
+  /full/path/to/some/files.pvd and /full/path/to/some/static.pvd by the full
+  paths to those files that were created by the simulation. So you should get 
+  something like:
+  /home/<username>/<egfrdDir>/simulations/<mySimulation>/<myVisualizationDataDirectory>/files.pvd
+  and
+  /home/<username>/<egfrdDir>/simulations/<mySimulation>/<myVisualizationDataDirectory>/static.pvd.
+
+  Note that Paraview will crash if these files don't exist. And they have are
+  to be absolute paths, using ~ for home directory, or ./../ for the egfrd
+  directory doesn't seem to work. This means Paraview will also crash if you
+  move your egfrd directory or something at some later point.
+
+* Start Paraview.
+
+* Go to Tools > Manage Plugins/Extensions and check that the plugins are
+  loaded, or load them manually.
+
+  Note that Paraview will crash if the plugins are not loaded when you try
+  to load the pipeline in the next step.
+
+
+
+
+Visualizing the data
+--------------------
+* Go to File > Load State, and select <egfrdDir>/paraview/pipeline.pvsm.
+
+* Click the play button. You should see an animation of your simulation. Yeah!  
+
+
+
+
+Tweaking the pipeline
+---------------------
+* From now on you can make changes to the pipeline from inside Paraview. Here
+  is an example of what to do when you want to use data from a completely
+  different simulation.
+  - Right click in the Pipeline Browswer window. Open files.pvd in the 
+    visualization data directory of the new simulation. Then click apply in 
+    the Object Inspector window. The new files.pvd is now added to the 
+    pipeline, but doesn't do anything yet.
+  - Left click on the 'plus' next to files.pvd in the pipeline browser, then   
+    right click on Objects below files.pvd, then Change Input. In the middle 
+    window that appears, called Select Sources, select the new files.pvd file 
+    you just added. It might be a bit hard to find. Click Ok. Objects is now 
+    rewired to use the new files.pvd. 
+  - Right click the old files.pvd, and delete it. Note that this is only 
+    possible if you actually rewired Objects to a new files.pvd file in the 
+    previous step, otherwise this options is grayed out.
+  - If the definition of the surfaces also changed: open and apply the new
+      static.pvd, rewire Surfaces to it and delete the old static.pvd.
+  - Save the new pipeline. File > Save State.
+
+* If you run a new simulation that writes to the same visualization data 
+  directory, usually Paraview will reload the new data correctly. There can be 
+  a problem if you increase the number of timesteps. If so, open the new 
+  files.pvd into the pipeline and rewire Objects as explained above.
+
+* Different species are given different colors. If you run a new simulation
+  that has many more species, you might need to rescale the color range. Select
+  Particle in the Pipeline Browser window. Then in the Object Inspector window
+  click the middle tab called Display. Click Rescale to Data Range in the
+  Color subsection.
+  Typically you don't want to rescale the colors for Sphere and Cylinder.
+  Pairs are given a different color (2) than Singles (1) by default. The
+  sphere or cylinder that will be updated next is highlighed (color 0).
+
+
+
+

From 74eaf42d928ea5c9b34c158816a5b0864b76956a Mon Sep 17 00:00:00 2001
From: Thomas Miedema <thomasmiedema@gmail.com>
Date: Wed, 4 May 2011 01:02:54 +0200
Subject: [PATCH 0015/1541] Use repr() for printing time, str() truncates
 floats

When time gets truncated, ParaView thinks nothing has changed.
---
 visualization/vtk_xml_serial_unstructured.py |  4 +++-
 visualization/vtklogger.py                   | 17 ++++++++++++++---
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/visualization/vtk_xml_serial_unstructured.py b/visualization/vtk_xml_serial_unstructured.py
index ff3b6886..b5ef9fc6 100644
--- a/visualization/vtk_xml_serial_unstructured.py
+++ b/visualization/vtk_xml_serial_unstructured.py
@@ -230,7 +230,9 @@ def write_pvd(self, file, file_list):
                 # Problem with adding real time can be that 
                 # TimestepValues is not updated in Proxy group="misc" 
                 # in .pvsm file after a reload.
-                time = str(time)
+                # Note: use repr(time), since str(time) truncates floating 
+                # points. Alternatively: http://labix.org/python-nicefloat.
+                time = repr(time)
                 data_set.setAttribute("timestep", time)
             data_set.setAttribute("group", "")
             data_set.setAttribute("part", type) # Use Extractblock.
diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 41743d52..aec85800 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -85,8 +85,16 @@ def __init__(self, sim, dir='vtkdata', buffer_size=None, show_shells=True,
         # Step counter.
         self.i = 0
 
-        # Needed for ParaView time hack. Note: don't make delta_t too small.
-        self.delta_t = 1e-10
+        # Needed for ParaView time hack.
+        #
+        # The result should be that with extra_particle_step=True, the number 
+        # of Paraview timesteps should be twice the number of simulation steps.
+        #
+        # delta_t should not be smaller than the precision of your
+        # floating point output (use repr, not str). But it should be smaller 
+        # than the first simulation timestep divided by the number of initial 
+        # particles. 1e-15 seems to be a good value.
+        self.delta_t = 1e-15
         self.last_time = INF
 
     def cleanup(self):
@@ -117,6 +125,9 @@ def log(self):
             #
             # Now ParaView should perceive a state change.
             # Only needed when showing shells (this is a choice).
+            #
+            # A relative offset is needed when last_time > 1, and an absolute 
+            # offset when last_time < 1.
             time = self.last_time * (1 + self.delta_t) + self.delta_t
 
         # Get data.
@@ -168,7 +179,7 @@ def writelog(self, time, index,
             self.make_snapshot('cylinder_data', cylinder_data_1, index, time)
 
             # Continue with case. 
-            time *= (1 + self.delta_t / 2)
+            time = time * (1 + self.delta_t / 2.) + self.delta_t / 2.
             index += 1
 
         if index == 0:

From 886c19ad778bcb34da32eaae6ccaaafadd917cd8 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 4 May 2011 12:30:45 +0200
Subject: [PATCH 0016/1541] This is merely a simple test, with an edited
 comment, which should be edited out.

---
 samples/reversible/run.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/samples/reversible/run.py b/samples/reversible/run.py
index 8df2696d..4a9ab466 100644
--- a/samples/reversible/run.py
+++ b/samples/reversible/run.py
@@ -1,4 +1,5 @@
 #!/usr/bin/env python
+#blabla
 
 '''
 LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.3.out 1.25e-2 5000000 &

From 6a65f9f4065a78a1e7d262cef9978c06983e1cbe Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 4 May 2011 12:35:28 +0200
Subject: [PATCH 0017/1541] Removed the previously edited useless comment
 (which was only for testing).

---
 samples/reversible/run.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/samples/reversible/run.py b/samples/reversible/run.py
index 4a9ab466..8df2696d 100644
--- a/samples/reversible/run.py
+++ b/samples/reversible/run.py
@@ -1,5 +1,4 @@
 #!/usr/bin/env python
-#blabla
 
 '''
 LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.3.out 1.25e-2 5000000 &

From 9ca2669a8199b9deca72b2b706546198b177f891 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 4 May 2011 14:15:59 +0200
Subject: [PATCH 0018/1541] working on samples directory (bd_test)

---
 samples/bd_test/irr.py | 29 +++++++++++++++++++++--------
 1 file changed, 21 insertions(+), 8 deletions(-)

diff --git a/samples/bd_test/irr.py b/samples/bd_test/irr.py
index 8d10ef2c..016bc835 100644
--- a/samples/bd_test/irr.py
+++ b/samples/bd_test/irr.py
@@ -2,6 +2,8 @@
 
 from bd import *
 import sys
+import gfrdbase
+import model
 
 def run(outfilename, T, N):
 
@@ -19,21 +21,24 @@ def run(outfilename, T, N):
 
 def singlerun(T):
 
-    w = World(1e-3, 3)
-    s = BDSimulator(w)
-
     sigma = 5e-9
     r0 = sigma
     D = 1e-12
     kf = 10 * sigma * D
 
-    m = ParticleModel()
+    m = model.ParticleModel(world_size=1e-5)
 
-    A = m.new_species_type('A', D/2, sigma/2)
-    B = m.new_species_type('B', D/2, sigma/2)
-    C = m.new_species_type('C', D/2, sigma/2)
+    A = model.Species('A', D/2, sigma/2)
+    B = model.Species('B', D/2, sigma/2)
+    C = model.Species('C', D/2, sigma/2)
+    # Couple these species to the previously defined particle model
+    m.add_species_type(A) # "m.add_species_type(species=A)" not
+                          # allowed due boost package
+    m.add_species_type(B) 
+    m.add_species_type(C) 
     
-    r1 = create_binding_reaction_rule(A, B, C, kf)
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+
     m.network_rules.add_reaction_rule(r1)
 
     s.set_model(m)
@@ -42,6 +47,14 @@ def singlerun(T):
     particleB = s.place_particle(B, [(float(A['radius']) + float(B['radius']))+1e-23,0,0])
 
     end_time = T
+
+    # Create world size m, with matrix_size sized
+    # neighbour matrix
+#    w = gfrdbase.create_world(m=1e-3, matrix_size=3)
+    w = gfrdbase.create_world(1e-3, 3)
+    s = BDSimulator(w)
+
+
     #s.initialize()
 
     while 1:

From ca55c5d013d9a4bf98e3327f56ad8bedbb93fb55 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 4 May 2011 14:51:10 +0200
Subject: [PATCH 0019/1541] Fixed missing folders for latex files in doc
 directory.

---
 doc/greens_functions/build/include/.empty-dir | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 doc/greens_functions/build/include/.empty-dir

diff --git a/doc/greens_functions/build/include/.empty-dir b/doc/greens_functions/build/include/.empty-dir
new file mode 100644
index 00000000..e69de29b

From e0542ad6c08dc3093b823791022dae14f04880c1 Mon Sep 17 00:00:00 2001
From: Thomas Miedema <thomasmiedema@gmail.com>
Date: Sat, 30 Apr 2011 05:16:58 +0800
Subject: [PATCH 0020/1541] Visualize extra particle for arbitrary timesteps

Tricking Paraview into showing 2 steps for each simulator step.
---
 visualization/vtklogger.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 0a1ee26a..41743d52 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -85,9 +85,8 @@ def __init__(self, sim, dir='vtkdata', buffer_size=None, show_shells=True,
         # Step counter.
         self.i = 0
 
-        # Needed for ParaView time hack. Note: don't make delta_t too 
-        # small, should be relative to max time.
-        self.delta_t = 1e-11
+        # Needed for ParaView time hack. Note: don't make delta_t too small.
+        self.delta_t = 1e-10
         self.last_time = INF
 
     def cleanup(self):
@@ -118,7 +117,7 @@ def log(self):
             #
             # Now ParaView should perceive a state change.
             # Only needed when showing shells (this is a choice).
-            time = self.last_time + self.delta_t
+            time = self.last_time * (1 + self.delta_t) + self.delta_t
 
         # Get data.
         particle_data = self.get_particle_data()
@@ -169,7 +168,7 @@ def writelog(self, time, index,
             self.make_snapshot('cylinder_data', cylinder_data_1, index, time)
 
             # Continue with case. 
-            time += self.delta_t / 2
+            time *= (1 + self.delta_t / 2)
             index += 1
 
         if index == 0:

From 8f24f8b5d22927547e8b039964c4da1eac980b75 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 9 May 2011 16:17:39 +0200
Subject: [PATCH 0021/1541] Fixed the BD_test sample irr.py. But also wrecked
 it again.

I converted the code to the newer syntax, and also
added stuff that seemed necessary to make it do
what it is supposed to.

Also, I've added the option to switch between the
eGFRD simulator and Brownian dynamics via bash input
arguments.

When you run it as follows:
$ python irr.py out.txt 1 1 GF
there are no problems.

However if you make it run more
than once, it does give problems
(e.g.:
$ python irr.py out.txt 1 2 GF
)

This is particularly curious because
the 2 means that a function is called
twice. But the arguments given to the
function don't change. Thus it shouldn't
matter if the simulation is performed
once or twice.
Somehow it does however.

Anyone?

For more comments see the code itself.

	modified:   irr.py
---
 samples/bd_test/irr.py | 137 +++++++++++++++++++++++++++++++----------
 1 file changed, 104 insertions(+), 33 deletions(-)

diff --git a/samples/bd_test/irr.py b/samples/bd_test/irr.py
index 016bc835..8c2cff11 100644
--- a/samples/bd_test/irr.py
+++ b/samples/bd_test/irr.py
@@ -1,16 +1,57 @@
 #!/usr/bin/env python
+"""
+Brownian Dynamics test script
+
+Does the same as the irreversible example, 
+but allows for forcing the script to use
+Brownian Dynamics (BD) only.
+
+Script is programmed in such a way that 
+choosing between BD and normal eGFRD (which 
+includes BD) can be done by giving "BD" 
+(Brownian Dynamics) or "GF" (Green's Functions) 
+as first bash argument:
+
+$ python irr.py [outputfile name] [time reaction is 
+    allowed to run] [number of runs] [BD/GF]
+
+e.g.:
+$ python irr.py out.txt 1e-4 100 GF
+
+"""
+
+# import necessary libraries
 
-from bd import *
 import sys
+# Tell Python where the main .py files are.
+sys.path.append('../../')
+# Alternatively one could use the bash command:
+# $ export PYTHONPATH=../../
+
+from bd import *
 import gfrdbase
 import model
+import myrandom
+import _gfrd
+
+from egfrd import *
 
-def run(outfilename, T, N):
+
+def run(outfilename, T, N, which_sim):
+    """
+    Simply runs simulation N times.
+
+    Arguments: 
+    - outfilename   : in which file to put output
+    - T             : time single simulation is allowed to run
+    - N             : number of times single sim is performed
+    - which_sim     : whether to use eGFRD or BD simulator
+    """
 
     outfile = open(outfilename, 'w')
 
     for i in range(N):
-        d, t = singlerun(T)
+        d, t = singlerun(T, which_sim)
         outfile.write('%g\n' % d)
 
         print d, t
@@ -19,66 +60,96 @@ def run(outfilename, T, N):
     outfile.close()
 
 
-def singlerun(T):
+def singlerun(T, which_sim):
+    """
+    Performs a simulation that involves calculating the reaction time
+    between two particles that are released next to each other.
 
+    Input arguments:
+    - T:    Time after which simulation is ended no matter what.
+    - which_sim     : whether to use eGFRD or BD simulator
+    """
+    
+    # Some constants
     sigma = 5e-9
     r0 = sigma
     D = 1e-12
     kf = 10 * sigma * D
 
+    # ### Set up model
     m = model.ParticleModel(world_size=1e-5)
 
     A = model.Species('A', D/2, sigma/2)
     B = model.Species('B', D/2, sigma/2)
     C = model.Species('C', D/2, sigma/2)
+
     # Couple these species to the previously defined particle model
     m.add_species_type(A) # "m.add_species_type(species=A)" not
                           # allowed due boost package
     m.add_species_type(B) 
     m.add_species_type(C) 
     
+    # Create reaction rules
     r1 = model.create_binding_reaction_rule(A, B, C, kf)
-
     m.network_rules.add_reaction_rule(r1)
 
-    s.set_model(m)
-    
-    particleA = s.place_particle(A, [0,0,0])
-    particleB = s.place_particle(B, [(float(A['radius']) + float(B['radius']))+1e-23,0,0])
-
-    end_time = T
-
-    # Create world size m, with matrix_size sized
-    # neighbour matrix
-#    w = gfrdbase.create_world(m=1e-3, matrix_size=3)
-    w = gfrdbase.create_world(1e-3, 3)
-    s = BDSimulator(w)
-
 
-    #s.initialize()
+    # ### Set up simulator
+    w = gfrdbase.create_world(m, 3)
+
+    # Set up the chosen simulator with an if-statement
+    if (which_sim == "GF"):
+        s = EGFRDSimulator(w, myrandom.rng)
+                # EGFRDSimulator(self, world, 
+                # rng=<_gfrd.RandomNumberGenerator 
+                # object at 0xef5140>, network_rules=None)
+    elif (which_sim == "BD"):
+        s = BDSimulator(w, myrandom.rng,\
+            _gfrd.NetworkRulesWrapper(w.model.network_rules)) 
+            # BDSimulator isn't meant for user-friendly use,
+            # so setting it u requires the "network_rules" 
+            # (present reaction rules), which should be parsed
+            # with the _gfrd.NetworkRulesWrapper(). 
+    else:
+        print "Incorrect argument given for simulator choice. Quitting."
+        quit()
+    
+    # ### Place particles
+    particleA = gfrdbase.place_particle(w, A, [0,0,0])
+    particleB = gfrdbase.place_particle(w, B, [(float(A['radius']) + float(B['radius']))+1e-23,0,0])
 
+    # ### Run the simulation
     while 1:
         next_time = s.t + s.dt
-        if next_time > end_time:
+        if next_time > T: # stop if too much time has passed
             break
-        s.step()
+        s.step() # Perform simulation step
+
 
-        if s.core.last_reaction:
+        if s.last_reaction: # stop if reaction has occured
             print 'reaction'
             return 0.0, s.t
 
-    distance = s.distance_between_particles(particleA[1], particleB[1])
+    distance = s.distance_between_particles(particleA[1], particleB[1]) 
+        # Give distance between particles
+
+    return distance, s.t # return variables of interest: distance and time
+        # s.t gives the current time, time that has passed in the simulator.
+
+if __name__ == '__main__':
+    run(sys.argv[1], float(sys.argv[2]), int(sys.argv[3]), sys.argv[4])
+
+
+
+
+
+
+
+
+
+
+
 
-    return distance, s.t
 
 
-def first(x):
-    x = iter(x)
-    try:
-        return x.next()
-    except StopIteration, e:
-        return None
-    
 
-if __name__ == '__main__':
-    run(sys.argv[1], float(sys.argv[2]), int(sys.argv[3]))

From e57ccf98f77e66ff0efd02d25a042e8cd047412b Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 10 May 2011 10:09:55 +0200
Subject: [PATCH 0022/1541] Nog wat geprobeerd te debuggen aan irr.py. 
 modified:   irr.py

---
 samples/bd_test/irr.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/samples/bd_test/irr.py b/samples/bd_test/irr.py
index 8c2cff11..d3832a2e 100644
--- a/samples/bd_test/irr.py
+++ b/samples/bd_test/irr.py
@@ -136,10 +136,26 @@ def singlerun(T, which_sim):
     return distance, s.t # return variables of interest: distance and time
         # s.t gives the current time, time that has passed in the simulator.
 
+# go
 if __name__ == '__main__':
     run(sys.argv[1], float(sys.argv[2]), int(sys.argv[3]), sys.argv[4])
 
 
+# Some debugging attempts:
+"""
+def print_vars():
+    print "############"
+    for name in dir():
+        myvalue = eval(name)
+        print name, "is", type(name), "and is equal to ", myvalue
+
+print_vars()
+singlerun(float(sys.argv[2]), sys.argv[4])
+print_vars()
+singlerun(float(sys.argv[2]), sys.argv[4])
+print_vars()
+singlerun(float(sys.argv[2]), sys.argv[4])
+"""
 
 
 

From fcb56879d38e666bddbf15c23f142e3445d55faa Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 10 May 2011 15:25:47 +0200
Subject: [PATCH 0023/1541] Deleted all files in bd_test. These files were
 outdated.

Moreover, there was already a more convenient implementation
of this functionality in the "irreversible" example.

I'll add a README explaining this situation.
---
 samples/bd_test/data/.empty-dir |   0
 samples/bd_test/irr.py          | 171 --------------------------------
 2 files changed, 171 deletions(-)
 delete mode 100644 samples/bd_test/data/.empty-dir
 delete mode 100644 samples/bd_test/irr.py

diff --git a/samples/bd_test/data/.empty-dir b/samples/bd_test/data/.empty-dir
deleted file mode 100644
index e69de29b..00000000
diff --git a/samples/bd_test/irr.py b/samples/bd_test/irr.py
deleted file mode 100644
index d3832a2e..00000000
--- a/samples/bd_test/irr.py
+++ /dev/null
@@ -1,171 +0,0 @@
-#!/usr/bin/env python
-"""
-Brownian Dynamics test script
-
-Does the same as the irreversible example, 
-but allows for forcing the script to use
-Brownian Dynamics (BD) only.
-
-Script is programmed in such a way that 
-choosing between BD and normal eGFRD (which 
-includes BD) can be done by giving "BD" 
-(Brownian Dynamics) or "GF" (Green's Functions) 
-as first bash argument:
-
-$ python irr.py [outputfile name] [time reaction is 
-    allowed to run] [number of runs] [BD/GF]
-
-e.g.:
-$ python irr.py out.txt 1e-4 100 GF
-
-"""
-
-# import necessary libraries
-
-import sys
-# Tell Python where the main .py files are.
-sys.path.append('../../')
-# Alternatively one could use the bash command:
-# $ export PYTHONPATH=../../
-
-from bd import *
-import gfrdbase
-import model
-import myrandom
-import _gfrd
-
-from egfrd import *
-
-
-def run(outfilename, T, N, which_sim):
-    """
-    Simply runs simulation N times.
-
-    Arguments: 
-    - outfilename   : in which file to put output
-    - T             : time single simulation is allowed to run
-    - N             : number of times single sim is performed
-    - which_sim     : whether to use eGFRD or BD simulator
-    """
-
-    outfile = open(outfilename, 'w')
-
-    for i in range(N):
-        d, t = singlerun(T, which_sim)
-        outfile.write('%g\n' % d)
-
-        print d, t
-        #assert d == 0 or t == T
-
-    outfile.close()
-
-
-def singlerun(T, which_sim):
-    """
-    Performs a simulation that involves calculating the reaction time
-    between two particles that are released next to each other.
-
-    Input arguments:
-    - T:    Time after which simulation is ended no matter what.
-    - which_sim     : whether to use eGFRD or BD simulator
-    """
-    
-    # Some constants
-    sigma = 5e-9
-    r0 = sigma
-    D = 1e-12
-    kf = 10 * sigma * D
-
-    # ### Set up model
-    m = model.ParticleModel(world_size=1e-5)
-
-    A = model.Species('A', D/2, sigma/2)
-    B = model.Species('B', D/2, sigma/2)
-    C = model.Species('C', D/2, sigma/2)
-
-    # Couple these species to the previously defined particle model
-    m.add_species_type(A) # "m.add_species_type(species=A)" not
-                          # allowed due boost package
-    m.add_species_type(B) 
-    m.add_species_type(C) 
-    
-    # Create reaction rules
-    r1 = model.create_binding_reaction_rule(A, B, C, kf)
-    m.network_rules.add_reaction_rule(r1)
-
-
-    # ### Set up simulator
-    w = gfrdbase.create_world(m, 3)
-
-    # Set up the chosen simulator with an if-statement
-    if (which_sim == "GF"):
-        s = EGFRDSimulator(w, myrandom.rng)
-                # EGFRDSimulator(self, world, 
-                # rng=<_gfrd.RandomNumberGenerator 
-                # object at 0xef5140>, network_rules=None)
-    elif (which_sim == "BD"):
-        s = BDSimulator(w, myrandom.rng,\
-            _gfrd.NetworkRulesWrapper(w.model.network_rules)) 
-            # BDSimulator isn't meant for user-friendly use,
-            # so setting it u requires the "network_rules" 
-            # (present reaction rules), which should be parsed
-            # with the _gfrd.NetworkRulesWrapper(). 
-    else:
-        print "Incorrect argument given for simulator choice. Quitting."
-        quit()
-    
-    # ### Place particles
-    particleA = gfrdbase.place_particle(w, A, [0,0,0])
-    particleB = gfrdbase.place_particle(w, B, [(float(A['radius']) + float(B['radius']))+1e-23,0,0])
-
-    # ### Run the simulation
-    while 1:
-        next_time = s.t + s.dt
-        if next_time > T: # stop if too much time has passed
-            break
-        s.step() # Perform simulation step
-
-
-        if s.last_reaction: # stop if reaction has occured
-            print 'reaction'
-            return 0.0, s.t
-
-    distance = s.distance_between_particles(particleA[1], particleB[1]) 
-        # Give distance between particles
-
-    return distance, s.t # return variables of interest: distance and time
-        # s.t gives the current time, time that has passed in the simulator.
-
-# go
-if __name__ == '__main__':
-    run(sys.argv[1], float(sys.argv[2]), int(sys.argv[3]), sys.argv[4])
-
-
-# Some debugging attempts:
-"""
-def print_vars():
-    print "############"
-    for name in dir():
-        myvalue = eval(name)
-        print name, "is", type(name), "and is equal to ", myvalue
-
-print_vars()
-singlerun(float(sys.argv[2]), sys.argv[4])
-print_vars()
-singlerun(float(sys.argv[2]), sys.argv[4])
-print_vars()
-singlerun(float(sys.argv[2]), sys.argv[4])
-"""
-
-
-
-
-
-
-
-
-
-
-
-
-

From c642f432f87b56af55270a9e721416de05f0a7d2 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 10 May 2011 15:29:53 +0200
Subject: [PATCH 0024/1541] Added README file promised in previous commit.

---
 samples/bd_test/README | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 samples/bd_test/README

diff --git a/samples/bd_test/README b/samples/bd_test/README
new file mode 100644
index 00000000..4b9ff75f
--- /dev/null
+++ b/samples/bd_test/README
@@ -0,0 +1,11 @@
+
+
+Introduction
+=====================================
+
+This folder will in the future hold scripts to test the Brownian
+Dynamics part of the code.
+
+To test Brownian Dynamics, one is now referred to the "irreversible"
+example. Which also contains a functionality to test Brownian 
+Dynamics.

From e7830535a91a3dc5dc8df6217b8f2202cf0385df Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 11 May 2011 11:29:31 +0200
Subject: [PATCH 0025/1541] Some updates for the rebind sample, doesn't work
 yet, still working on it. 	modified:   samples/rebind/run.py

---
 samples/rebind/run.py | 97 ++++++++++++++++++++++++++++++++-----------
 1 file changed, 72 insertions(+), 25 deletions(-)

diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index 3d1a56b9..d61837a4 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -11,6 +11,8 @@
 from egfrd import *
 from bd import *
 import sys
+import gfrdbase
+import model
 
 def run(outfilename, D_factor, N_B, N_X, N):
     print outfilename
@@ -58,6 +60,7 @@ def singlerun(T_list, D_factor, N_B, N_X):
     # V = 1.66e-21 m^3
     # L = 1.18e-7
 
+    # ### Define constants
     DX_factor = 1
 
     V = 1e-18 # m^3
@@ -66,13 +69,6 @@ def singlerun(T_list, D_factor, N_B, N_X):
     matrix_size = min(max(3, int((9 * (N_X+N_B)) ** (1.0/3.0))), 60)
     print 'matrix_size=', matrix_size
 
-    w = World(L, matrix_size)
-    s = EGFRDSimulator(w)
-    #s.set_user_max_shell_size(1e-6)
-    #s = BDSimulator(w)
-
-    box1 = CuboidalRegion([0,0,0],[L,L,L])
-
     radius = 2.5e-9
     sigma = radius * 2
     r0 = sigma
@@ -82,22 +78,44 @@ def singlerun(T_list, D_factor, N_B, N_X):
     tau = sigma**2 / D_tot
 
     #kf = 1000 * sigma * D_tot
-
     # 1e9 [1 / (M s)] -> 1e9 / 1000 / N_A [m^3 / s]
     kf = 0.092e-18
 
-    m = ParticleModel()
+    DX = D * DX_factor
+
+    # ### Define model
+    
+    # Create model class
+    m = model.ParticleModel(L)
+
+    # Particle species classes
+    A = model.Species('A', D, radius)
+    m.add_species_type(A)
+    B = model.Species('B', D, radius)
+    m.add_species_type(B)
+    C = model.Species('C', D, radius)
+    m.add_species_type(C)
+    X = model.Species('X', DX, radius)
+    m.add_species_type(X)
+    
+    # Reaction rules
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+    m.network_rules.add_reaction_rule(r1)
 
-    A = m.new_species_type('A', D, radius)
-    B = m.new_species_type('B', D, radius)
-    C = m.new_species_type('C', D, radius)
+    r2 = model.create_unbinding_reaction_rule(C, A, B, 1e3)
+    m.network_rules.add_reaction_rule(r2)
 
-    DX = D * DX_factor
+    # ### Set up simulator
 
-    X = m.new_species_type('X', DX, radius)
+    w = gfrdbase.create_world(L, matrix_size)
+    nrw = gfrdbase.create_network_rules_wrapper(m)
+    s = EGFRDSimulator(w, myrandom.rng, nrw)
 
+    # ### Place particles 
+
+    # Throw in some X particles and stirr
     if N_X != 0:
-        s.throw_in_particles(X, N_X, box1)
+        gfrdbase.throw_in_particles(w, X, N_X)
 
         end_time = tau * 1
         while 1:
@@ -109,18 +127,27 @@ def singlerun(T_list, D_factor, N_B, N_X):
 
 
     s.reset()
-
-    r1 = create_binding_reaction_rule(A, B, C, kf)
-    m.network_rules.add_reaction_rule(r1)
-
-    r2 = create_unbinding_reaction_rule(C, A, B, 1e3)
-    m.network_rules.add_reaction_rule(r2)
-
-    s.set_model(m)
+    # Removed introduction of network rules here.
+    # s.set_model(m) # IF presence of network rules results in data
+                     # that is not cleaned in reset, this might give 
+                     # problems. Originally, s.set_model(m) would 
+                     # have introduced these rules here.
 
     A_pos = [0,0,0]
     B_pos = [(float(A['radius']) + float(B['radius']))+1e-23,0,0]
 
+    # Clear an area at position A_pos and place particle A there
+    """
+    What happens here:
+        - find particles at position A_pos within species A radius
+        - delete those
+        - add a number of X particles _randomly to the box_, the 
+          number being equal to # removed particles.
+        - if a particle is accidently placed within the "cleared"
+          area, repeat the process (in very crowded box, this 
+          leads to infinite loop)
+        - 
+    """
     while 1:
         pp = s.get_particles_within_radius(A_pos, float(A['radius']))
         if not pp:
@@ -131,6 +158,7 @@ def singlerun(T_list, D_factor, N_B, N_X):
 
     s.place_particle(A, A_pos)
 
+    # Idem for a particle B:
     while 1:
         pp = s.get_particles_within_radius(B_pos, float(B['radius']))
         if not pp:
@@ -141,6 +169,7 @@ def singlerun(T_list, D_factor, N_B, N_X):
 
     s.place_particle(B, B_pos)
 
+    # Place rest of B at random positions
     if N_B > 1:
         s.throw_in_particles(B, N_B-1, box1)
 
@@ -150,12 +179,30 @@ def singlerun(T_list, D_factor, N_B, N_X):
 
     s.step()
 
-    next_stop = T_list[0]
+    next_stop = T_list[0] # In this case T_list[0] equals infinity
 
     i_T = 0
 
+    #TODO (following correct?-:)
+    """
+    What happens here: 
+    - If there was a reaction
+        - And there are no C-particles, set t_last to current simulation
+          time
+        - And there are C particles, calculate dt between previous??? and 
+          this reaction. 
+
+    OR:
+    
+        - If the last C particle has just reacted away, record the time
+        - If there are still C particles, record the time relative to this  
+          occurence 
+
+    T-list in principle contains a list with scheduled "stops"
+
+    """
     while 1:
-        if s.last_reaction:
+        if s.last_reaction: # aka if there was a reaction
             print s.last_reaction
             if len(s.world.get_particle_ids(C.id)) == 0:  #A,B
                 print 'set t_last', s.t

From f94b323a928c86fc101b2df22e8fb3ff1cdd661c Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 11 May 2011 11:31:19 +0200
Subject: [PATCH 0026/1541] Added template folder, which should in future
 contain file from which users can easily compose working script.

---
 samples/template/README | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 samples/template/README

diff --git a/samples/template/README b/samples/template/README
new file mode 100644
index 00000000..c98a176a
--- /dev/null
+++ b/samples/template/README
@@ -0,0 +1,33 @@
+
+
+General lay-out of a simulation
+=====================================
+
+    # ### Import correct modules
+import sys
+from egfrd import *
+from bd import *
+import model
+import gfrdbase
+import myrandom
+
+    # ### Define model
+
+    m = model.ParticleModel(1e-3)
+
+    A = model.Species('A', 0.0, sigma/2)
+    m.add_species_type(A)
+
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+    m.network_rules.add_reaction_rule(r1)
+
+    # ### Set up simulator
+
+
+    w = gfrdbase.create_world(m, 3)
+    nrw = gfrdbase.create_network_rules_wrapper(m)
+    s = EGFRDSimulator(w, myrandom.rng, nrw)
+
+    # ### Place particles 
+
+    # ### Run simulation

From 252992f0906fa101903d36a22840b87e95744952 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 12 May 2011 18:31:25 +0200
Subject: [PATCH 0027/1541] Most importantly, added some docstrings to usefull
 "user-interface" functions. Also worked a very little bit on fixing the
 samples. 	modified:   dumper.py 	modified:   egfrd.py 	modified:  
 gfrdbase.py 	modified:   model.py 	modified:   samples/rebind/run.py 
 modified:   samples/template/README

---
 dumper.py               | 47 +++++++++++++++++++++++++++++++++++------
 egfrd.py                | 11 ++++++++++
 gfrdbase.py             | 22 +++++++++----------
 model.py                |  2 +-
 samples/rebind/run.py   | 40 +++++++++++++++++------------------
 samples/template/README | 27 -----------------------
 6 files changed, 82 insertions(+), 67 deletions(-)

diff --git a/dumper.py b/dumper.py
index 839764e2..4737fe86 100644
--- a/dumper.py
+++ b/dumper.py
@@ -66,7 +66,14 @@ def dump_species_names(sim):
     return ' '.join(get_species_names(sim))
 
 def _get_species_type_by_name(sim, name):
-    #Helper.
+    """ Return the type of a species with a certain name
+
+    Arguments:
+        - sim
+            an EGFRDSimulator
+        - name
+            species name
+    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
     for species_type in sim.world.model.species_types:
         if species_type['name'] == name:
             return species_type
@@ -74,7 +81,21 @@ def _get_species_type_by_name(sim, name):
     raise RuntimeError('SpeciesType %s does not exist.' % (name))
 
 def _get_particles_by_sid(sim, sid):
-    # Helper.
+    """ Return a generator (using "yield") to loop over (pid, particle).
+    
+    Arguments:
+        - sim
+            an EGFRDSimulator
+        - sid
+            ID of a species
+
+    E.g.:
+    
+    myparticles = _get_particles_by_sid(sim, sid)
+
+    for mypid, myparticle in myparticles:
+        print str(str(mypid), str(myparticle))
+    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
     for pid in sim.world.get_particle_ids(sid):
         particle = sim.world.get_particle(pid)[1]
         yield (pid, particle)
@@ -121,7 +142,16 @@ def dump_particles(sim, identifier=None):
     return '\n'.join((str(x) for x in get_particles(sim, identifier)))
 
 def _get_number_of_particles_by_sid(sim, sid):
-    # Helper.
+    """ 
+    Returns the number of particles of a certain species.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+        - sid
+            ID of a species    
+
+    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
     if isinstance(sim, EGFRDSimulator):
         return len(sim.world.get_particle_ids(sid))
     else:
@@ -174,7 +204,10 @@ def dump_number_of_particles(sim, identifier=None):
 def get_domains(egfrdsim):
     """Return an iterator over the protective domains in the simulator.
 
-    """
+    Arguments:
+        - egfrdsim
+            an EGFRDSimulator
+    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
     for did, domain in egfrdsim.domains.iteritems():
         shell_list = domain.shell_list
         pid_particle_pair_list = []
@@ -244,10 +277,10 @@ def get_reaction_rules(model_or_simulator):
     return reaction_rules_1, reaction_rules_2, repulsive_rules
 
 def _dump_reaction_rule(model, reaction_rule):
-    # Helper. Return ReactionRule as string.
+    """Helper. Return ReactionRule as string.
 
-    #ReactionRule.__str__ would be good, but we are actually getting a 
-    #ReactionRuleInfo or ReactionRuleCache object.
+    ReactionRule.__str__ would be good, but we are actually getting a 
+    ReactionRuleInfo or ReactionRuleCache object."""
     buf = ('k=%.3g' % reaction_rule.k + ': ').ljust(15)
     for index, sid in enumerate(reaction_rule.reactants):
         if index != 0:
diff --git a/egfrd.py b/egfrd.py
index b3abadcf..ec6ce565 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -126,6 +126,10 @@ def get_matrix_cell_size(self):
         return self.containers[0].cell_size
 
     def get_next_time(self):
+    """ 
+    Returns the time it will be when the next egfrd timestep
+    is completed.
+    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
         if self.scheduler.size == 0:
             return self.t
 
@@ -142,6 +146,13 @@ def get_max_shell_size(self):
                    self.user_max_shell_size)
 
     def reset(self):
+    """
+    This function resets the "records" of the simulator. This means
+    the simulator time is reset, the step counter is reset, events
+    are reset, etc.
+    Can be for example usefull when users want to "stirr" the 
+    simulation before starting the "real experiment".
+    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
         self.t = 0.0
         self.dt = 0.0
         self.step_counter = 0
diff --git a/gfrdbase.py b/gfrdbase.py
index e4bf7a18..d62c038b 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -81,13 +81,13 @@ class NoSpace(Exception):
     pass
 
 def get_closest_surface(world, pos, ignore):
-    # Return
-    #   - closest surface
-    #   - distance to closest surface
-    #
-    # We can not use matrix_space, it would miss a surface if the 
-    # origin of the surface would not be in the same or neighboring 
-    # cells as pos.
+    """Return
+      - closest surface
+      - distance to closest surface
+    
+    We can not use matrix_space, it would miss a surface if the 
+    origin of the surface would not be in the same or neighboring 
+    cells as pos."""
 
     surfaces_and_distances_to_surfaces = []
 
@@ -104,10 +104,10 @@ def get_closest_surface(world, pos, ignore):
         return None, numpy.inf
 
 def get_closest_surface_within_radius(world, pos, radius, ignore):
-    # Return:
-    #   - surface within radius or None
-    #   - closest surface (regardless of radius)
-    #   - distance to closest surface
+    """Return:
+      - surface within radius or None
+      - closest surface (regardless of radius)
+      - distance to closest surface"""
 
     surface, distance = get_closest_surface(world, pos, ignore) 
     if distance < radius:
diff --git a/model.py b/model.py
index 59dc00f0..192ab32b 100644
--- a/model.py
+++ b/model.py
@@ -19,7 +19,7 @@
     ]
 
 
-# Define _gfrd docstrigns here, much easier to format than in C++.
+# Define _gfrd docstrings here, much easier to format than in C++.
 _gfrd.create_cuboidal_region.__doc__ = \
 """create_cuboidal_region(id, corner, diagonal)
 
diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index d61837a4..84b09a2b 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -1,11 +1,14 @@
 #!/usr/bin/env python
 
-'''
+#TODO
+"""
+See README for a description
+
 # D_factor N_B N_X N
 
 LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py 1 1 100 10
 
-'''
+"""
 
 
 from egfrd import *
@@ -107,7 +110,7 @@ def singlerun(T_list, D_factor, N_B, N_X):
 
     # ### Set up simulator
 
-    w = gfrdbase.create_world(L, matrix_size)
+    w = gfrdbase.create_world(m, matrix_size)
     nrw = gfrdbase.create_network_rules_wrapper(m)
     s = EGFRDSimulator(w, myrandom.rng, nrw)
 
@@ -183,25 +186,20 @@ def singlerun(T_list, D_factor, N_B, N_X):
 
     i_T = 0
 
-    #TODO (following correct?-:)
-    """
-    What happens here: 
-    - If there was a reaction
-        - And there are no C-particles, set t_last to current simulation
-          time
-        - And there are C particles, calculate dt between previous??? and 
-          this reaction. 
-
-    OR:
-    
-        - If the last C particle has just reacted away, record the time
-        - If there are still C particles, record the time relative to this  
-          occurence 
-
-    T-list in principle contains a list with scheduled "stops"
-
-    """
+    #  ### Start simulating
     while 1:
+        """
+        What happens in this if-statement: 
+        Create a list of the times particles were in bound state.
+
+        If there was a reaction:
+            - Binding: Indicated by the fact that there are no C-particles.
+              In this case: record the current time (s.t) to t_last.
+            - Unbinding: Indicated because this is the only other case when
+              a reaction has taken place. 
+              In this case: record the time binding lasted, i.e. dt between
+              current time (s.t) and last reaction time (t_last).
+        """
         if s.last_reaction: # aka if there was a reaction
             print s.last_reaction
             if len(s.world.get_particle_ids(C.id)) == 0:  #A,B
diff --git a/samples/template/README b/samples/template/README
index c98a176a..3a85ba66 100644
--- a/samples/template/README
+++ b/samples/template/README
@@ -3,31 +3,4 @@
 General lay-out of a simulation
 =====================================
 
-    # ### Import correct modules
-import sys
-from egfrd import *
-from bd import *
-import model
-import gfrdbase
-import myrandom
 
-    # ### Define model
-
-    m = model.ParticleModel(1e-3)
-
-    A = model.Species('A', 0.0, sigma/2)
-    m.add_species_type(A)
-
-    r1 = model.create_binding_reaction_rule(A, B, C, kf)
-    m.network_rules.add_reaction_rule(r1)
-
-    # ### Set up simulator
-
-
-    w = gfrdbase.create_world(m, 3)
-    nrw = gfrdbase.create_network_rules_wrapper(m)
-    s = EGFRDSimulator(w, myrandom.rng, nrw)
-
-    # ### Place particles 
-
-    # ### Run simulation

From 518785c61cc254564454fa584964ab5224a8a8f1 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 13 May 2011 12:09:31 +0200
Subject: [PATCH 0028/1541] Added implementation_functions to the doc
 directory.

---
 doc/Makefile.am              |    3 +-
 doc/interface_functions.aux  |   34 ++
 doc/interface_functions.log  |  846 ++++++++++++++++++++++++++
 doc/interface_functions.pdf  |  Bin 0 -> 92315 bytes
 doc/interface_functions.tex  | 1107 ++++++++++++++++++++++++++++++++++
 doc/interface_functions.tex~ | 1107 ++++++++++++++++++++++++++++++++++
 doc/interface_functions.toc  |   33 +
 samples/template/README      |   29 +
 utils.py                     |   40 +-
 9 files changed, 3178 insertions(+), 21 deletions(-)
 create mode 100644 doc/interface_functions.aux
 create mode 100644 doc/interface_functions.log
 create mode 100644 doc/interface_functions.pdf
 create mode 100644 doc/interface_functions.tex
 create mode 100644 doc/interface_functions.tex~
 create mode 100644 doc/interface_functions.toc

diff --git a/doc/Makefile.am b/doc/Makefile.am
index 091794b5..44ad9b22 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -8,7 +8,8 @@ if HAVE_PDFLATEX
 # Compile and install; do not distribute.
 pdf_DATA = \
 	implementation_notes.pdf\
-	p1_fp.pdf
+	p1_fp.pdf\
+    interface_functions.pdf
 endif
 
 
diff --git a/doc/interface_functions.aux b/doc/interface_functions.aux
new file mode 100644
index 00000000..53196f5c
--- /dev/null
+++ b/doc/interface_functions.aux
@@ -0,0 +1,34 @@
+\relax 
+\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{1}}
+\@writefile{toc}{\contentsline {section}{\numberline {2}Functions}{1}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Functions from \texttt  {model.py}}{1}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{1}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{2}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{4}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Functions from \texttt  {gfrdbase.py}}{7}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{7}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.2}Handling objects}{8}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{8}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Functions from \texttt  {egfrd.py}}{9}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{9}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{10}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.3}Get data}{10}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{10}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}Functions from \texttt  {dumper.py}}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{13}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Functions from \texttt  {utils.py}}{14}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{15}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{15}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{19}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.4}\texttt  {multi.py}, \texttt  {pair.py}, \texttt  {single.py}}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.5}\texttt  {myrandom.py}}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.6}\texttt  {make\_cjy\_table.py.py}, \texttt  {make\_sjy\_table.py.py}}{21}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.7}Function from module \texttt  {logger.py}}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{21}}
+\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{21}}
diff --git a/doc/interface_functions.log b/doc/interface_functions.log
new file mode 100644
index 00000000..5099a1e6
--- /dev/null
+++ b/doc/interface_functions.log
@@ -0,0 +1,846 @@
+This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  13 MAY 2011 12:08
+entering extended mode
+ %&-line parsing enabled.
+**interface_functions.tex
+(./interface_functions.tex
+LaTeX2e <2005/12/01>
+Babel <v3.8h> and hyphenation patterns for english, usenglishmax, dumylang, noh
+yphenation, loaded.
+(/usr/share/texmf-texlive/tex/latex/base/article.cls
+Document Class: article 2005/09/16 v1.4f Standard LaTeX document class
+(/usr/share/texmf-texlive/tex/latex/base/size10.clo
+File: size10.clo 2005/09/16 v1.4f Standard LaTeX file (size option)
+)
+\c@part=\count79
+\c@section=\count80
+\c@subsection=\count81
+\c@subsubsection=\count82
+\c@paragraph=\count83
+\c@subparagraph=\count84
+\c@figure=\count85
+\c@table=\count86
+\abovecaptionskip=\skip41
+\belowcaptionskip=\skip42
+\bibindent=\dimen102
+)
+(/usr/share/texmf-texlive/tex/latex/base/inputenc.sty
+Package: inputenc 2006/05/05 v1.1b Input encoding file
+\inpenc@prehook=\toks14
+\inpenc@posthook=\toks15
+
+(/usr/share/texmf-texlive/tex/latex/ucs/utf8x.def
+File: utf8x.def 2004/10/17 UCS: Input encoding UTF-8
+))
+(/usr/share/texmf-texlive/tex/latex/ucs/ucs.sty
+Package: ucs 2004/10/17 UCS: Unicode input support
+
+(/usr/share/texmf-texlive/tex/latex/ucs/data/uni-global.def
+File: uni-global.def 2004/10/17 UCS: Unicode global data
+)
+\uc@secondtry=\count87
+\uc@combtoks=\toks16
+\uc@combtoksb=\toks17
+\uc@temptokena=\toks18
+)
+(./interface_functions.aux)
+\openout1 = `interface_functions.aux'.
+
+LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 8.
+LaTeX Font Info:    ... okay on input line 8.
+LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 8.
+LaTeX Font Info:    ... okay on input line 8.
+LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 8.
+LaTeX Font Info:    ... okay on input line 8.
+LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 8.
+LaTeX Font Info:    ... okay on input line 8.
+LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 8.
+LaTeX Font Info:    ... okay on input line 8.
+LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 8.
+LaTeX Font Info:    ... okay on input line 8.
+ (/usr/share/texmf-texlive/tex/latex/ucs/ucsencs.def
+File: ucsencs.def 2003/11/29 Fixes to fontencodings LGR, T3
+)
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <12> on input line 10.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <8> on input line 10.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <6> on input line 10.
+ (./interface_functions.toc)
+\tf@toc=\write3
+\openout3 = `interface_functions.toc'.
+
+LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <12> not available
+(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 21.
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 46--46
+[]                \OT1/cmtt/m/n/10 the size of one side of the simulation "worl
+d". Units:[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 46--46
+[]        \OT1/cmtt/m/n/10 The simulation "world" is always assumed to be a cub
+e with[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 46--46
+[]        \OT1/cmtt/m/n/10 *periodic boundary conditions*, with 1 corner at [0,
+ 0, 0] and[] 
+ []
+
+[1
+
+{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
+[]            \OT1/cmtt/m/n/10 the radius for this Species in/on this Region or
+ Surface.[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
+[]            \OT1/cmtt/m/n/10 the Region or Surface in/on which this Species c
+an exist.[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 76--76
+[]            \OT1/cmtt/m/n/10 Optional. If you do not specify a Structure the 
+Species is[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 76--76
+[]    \OT1/cmtt/m/n/10 If a certain Species should be able to exist in the "wor
+ld" as[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 76--76
+[]    \OT1/cmtt/m/n/10 well as in/on one of the previously created Regions or S
+urfaces,[] 
+ []
+
+[2]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 the vector [x, y, z] from the corner closest to [0, 
+0, 0], to[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 164--164
+[]\OT1/cmtt/m/n/10 """create_cylindrical_surface(id, corner, radius, orientatio
+n, length)[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 the point [x, y, z] on the axis of the cylinder clos
+est to[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 the unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] al
+ong the[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 the length of the cylinder. Should be equal to the w
+orld_size.[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 164--164
+[]\OT1/cmtt/m/n/10 """create_planar_surface(id, corner, unit_x, unit_y, length_
+x, length_y)[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 the point [x, y, z] on the plane closest to [0, 0, 0
+]. Units:[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] alon
+g the plane[] 
+ []
+
+[3]
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 the length of the plane along the unit vector unit_x
+. Should be[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
+[]        \OT1/cmtt/m/n/10 the length of the plane along the unit vector unit_y
+. Should be[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 180--180
+[]        \OT1/cmtt/m/n/10 """Add a Structure (Region or Surface) to the Partic
+leModel.[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 180--180
+[]              \OT1/cmtt/m/n/10 a Region or Surface created with one of the fu
+nctions[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 198--198
+[]        \OT1/cmtt/m/n/10 """Set all 'other' possible ReactionRules to be repu
+lsive.[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 198--198
+[]            \OT1/cmtt/m/n/10 - a repulsive bimolecular reaction rule (k=0) fo
+r each[] 
+ []
+
+[4]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
+[]            \OT1/cmtt/m/n/10 reaction rate. Units: per second. (Rough order o
+f magnitude:[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
+[]    \OT1/cmtt/m/n/10 There is no distinction between an intrinsic and an over
+all reaction[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 241--241
+[]            \OT1/cmtt/m/n/10 reaction rate. Units: per second. (Rough order o
+f magnitude:[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 241--241
+[]    \OT1/cmtt/m/n/10 There is no distinction between an intrinsic and an over
+all reaction[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 269--269
+[]            \OT1/cmtt/m/n/10 intrinsic reaction rate. Units: meters^3 per sec
+ond. (Rough[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 269--269
+[]    \OT1/cmtt/m/n/10 overall reaction rate (kon) to an intrinsic reaction rat
+e (ka) with[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 269--269
+[]    \OT1/cmtt/m/n/10 the function utils.k_a(kon, kD), but only for reaction r
+ules in 3D.[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 269--269
+[]    \OT1/cmtt/m/n/10 bimolecular reaction rule (ka=0) for each possible combi
+nation of[] 
+ []
+
+[5]
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 269--269
+[]    \OT1/cmtt/m/n/10 reactants for which no bimolecular reaction rule is spec
+ified.[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 269--269
+[]    \OT1/cmtt/m/n/10 You can explicitly add these reaction rules to the model
+ with the[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 302--302
+[]\OT1/cmtt/m/n/10 def create_binding_reaction_rule(reactant1, reactant2, produ
+ct, ka):[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 302--302
+[]            \OT1/cmtt/m/n/10 intrinsic reaction rate. Units: meters^3 per sec
+ond. (Rough[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 302--302
+[]    \OT1/cmtt/m/n/10 overall reaction rate (kon) to an intrinsic reaction rat
+e (ka) with[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 302--302
+[]    \OT1/cmtt/m/n/10 the function utils.k_a(kon, kD), but only for reaction r
+ules in 3D.[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 302--302
+[]    \OT1/cmtt/m/n/10 bimolecular reaction rule (ka=0) for each possible combi
+nation of[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 302--302
+[]    \OT1/cmtt/m/n/10 reactants for which no bimolecular reaction rule is spec
+ified.[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 302--302
+[]    \OT1/cmtt/m/n/10 You can explicitly add these reaction rules to the model
+ with the[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 332--332
+[]\OT1/cmtt/m/n/10 def create_unbinding_reaction_rule(reactant, product1, produ
+ct2, kd):[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
+[]            \OT1/cmtt/m/n/10 intrinsic reaction rate. Units: per second. (Rou
+gh order of[] 
+ []
+
+[6]
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
+[]    \OT1/cmtt/m/n/10 overall reaction rate (koff) for this reaction rule to a
+n intrinsic[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 332--332
+[]    \OT1/cmtt/m/n/10 reaction rate (kd) with the function utils.k_d(koff, kon
+, kD) or[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 The world object keeps track of the positions of the par
+ticles[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 378--378
+[]            \OT1/cmtt/m/n/10 a ParticleModel previously created with model.Pa
+rticleModel.[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
+[]            \OT1/cmtt/m/n/10 the number of cells in the MatrixSpace along the
+ x, y and z[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
+[]            \OT1/cmtt/m/n/10 axis. Leave it to the default number if you don'
+t know what[] 
+ []
+
+
+Overfull \hbox (43.49661pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 The simulation cube "world" is divided into (matrix_size
+ x matrix_size[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 x matrix_size) cells. Together these cells form a Matrix
+Space. The[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 MatrixSpace keeps track in which cell every particle and
+ protective[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 neighbours of particle, only objects in the same cell an
+d the 26[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 (3x3x3 - 1) neighbouring cells (the simulation cube has 
+periodic[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 The matrix_size limits the size of the protective domain
+s. If you[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 have fewer particles, you want a smaller matrix_size, su
+ch that the[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 protective domains and thus the eGFRD timesteps can be l
+arger. If[] 
+ []
+
+[7]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 you have more particles, you want a larger matrix_size, 
+such that[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 378--378
+[]    \OT1/cmtt/m/n/10 (N * 6) ** (1. / 3.) is used, where N is the average num
+ber of[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 400--400
+[]\OT1/cmtt/m/n/10 def get_closest_surface_within_radius(world, pos, radius, ig
+nore):[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 419--419
+[]    \OT1/cmtt/m/n/10 """Add n particles of a certain Species to the specified
+ world.[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 419--419
+[]    \OT1/cmtt/m/n/10 Make sure to first add the Species to the model with the
+ method[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 437--437
+[]    \OT1/cmtt/m/n/10 """Place a particle of a certain Species at a specific p
+osition in[] 
+ []
+
+[8]
+Overfull \hbox (38.24666pt too wide) in paragraph at lines 437--437
+[]            \OT1/cmtt/m/n/10 a position vector [x, y, z]. Units: [meters, met
+ers, meters].[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 437--437
+[]    \OT1/cmtt/m/n/10 Make sure to first add the Species to the model with the
+ method[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 462--462
+[]    \OT1/cmtt/m/n/10 def __init__(self, world, rng=myrandom.rng, network_rule
+s=None):[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 462--462
+[]                \OT1/cmtt/m/n/10 a random number generator. By default myrand
+om.rng is[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 462--462
+[]                \OT1/cmtt/m/n/10 used, which uses Mersenne Twister from the G
+SL library.[] 
+ []
+
+
+Overfull \hbox (53.99652pt too wide) in paragraph at lines 462--462
+[]                \OT1/cmtt/m/n/10 you don't need to use this, for backward com
+patibility only.[] 
+ []
+
+
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 470--471
+\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
+cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 493--493
+[]        \OT1/cmtt/m/n/10 asynchronously. This method bursts all protective do
+mains and[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 493--493
+[]                \OT1/cmtt/m/n/10 the time at which to synchronize the particl
+es. Usually[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 493--493
+[]                \OT1/cmtt/m/n/10 you will want to use the current time of the
+ simulator:[] 
+ []
+
+[9]
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 493--493
+[]        \OT1/cmtt/m/n/10 This method is called stop because it is usually cal
+led at the[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 493--493
+[]        \OT1/cmtt/m/n/10 end of a simulation. It is possible to call this met
+hod at an[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 493--493
+[]        \OT1/cmtt/m/n/10 earlier time. For example the Logger module does thi
+s, because[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 493--493
+[]        \OT1/cmtt/m/n/10 it needs to know the positions of the particles at e
+ach log[] 
+ []
+
+
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 494--495
+\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
+cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
+ []
+
+
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 505--506
+\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
+cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 517--517
+[]    \OT1/cmtt/m/n/10 This function resets the "records" of the simulator. Thi
+s means[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 517--517
+[]    \OT1/cmtt/m/n/10 the simulator time is reset, the step counter is reset, 
+events[] 
+ []
+
+
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 518--519
+\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
+cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
+ []
+
+[10] [11]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 626--626
+[]    \OT1/cmtt/m/n/10 """ Return a generator (using "yield") to loop over (pid
+, particle).[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 641--641
+[]            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
+pecified,[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 641--641
+[]            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
+e returned.[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 656--656
+[]            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
+pecified,[] 
+ []
+
+[12]
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 656--656
+[]            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
+e returned.[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 685--685
+[]            \OT1/cmtt/m/n/10 (Species name, number of particles)-pairs will b
+e returned.[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 701--701
+[]    \OT1/cmtt/m/n/10 """Return a string containing the number of particles of
+ a certain[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 701--701
+[]            \OT1/cmtt/m/n/10 a string of (Species name, number of particles)-
+pairs will[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 713--713
+[]    \OT1/cmtt/m/n/10 """Return an iterator over the protective domains in the
+ simulator.[] 
+ []
+
+[13]
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 742--742
+[]    \OT1/cmtt/m/n/10 """Return three lists with all the reaction rules define
+d in the[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 742--742
+[]        \OT1/cmtt/m/n/10 - reaction rules between two reactants with a reacti
+on rate[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 750--750
+[]    \OT1/cmtt/m/n/10 ReactionRule.__str__ would be good, but we are actually 
+getting a[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 762--762
+[]    \OT1/cmtt/m/n/10 """Return a formatted string containing all the reaction
+ rules[] 
+ []
+
+[14]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 801--801
+[]    \OT1/cmtt/m/n/10 """Return True if a and b are equal, subject to given to
+lerances.[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 801--801
+[]    \OT1/cmtt/m/n/10 relative tolerance multipied by this typical value, and 
+will be[] 
+ []
+
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 801--801
+[]    \OT1/cmtt/m/n/10 """Return True if a is greater than b, subject to given 
+tolerances.[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 801--801
+[]    \OT1/cmtt/m/n/10 """Return True if a is less than b, subject to given tol
+erances.[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 801--801
+[]    \OT1/cmtt/m/n/10 """Return True if a is greater or equal than b, subject 
+to given[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 801--801
+[]    \OT1/cmtt/m/n/10 """Return True if a is less than or equal than b, subjec
+t to given[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 841--841
+[]    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per molar per sec
+ond' to[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 841--841
+[]    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per micromolar pe
+r second' to[] 
+ []
+
+[15]
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 841--841
+[]    \OT1/cmtt/m/n/10 """Convert a concentration from units 'micromolar' to un
+its 'per[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 """Calculate the 'pseudo-'reaction rate (kD) caused by d
+iffusion.[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 kD is equal to 1 divided by the time it takes for two pa
+rticles to[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 meet each other by diffusion. It is needed when converti
+ng from[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 an intrinsic reaction rate to an overall reaction rates 
+or vice[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+[]            \OT1/cmtt/m/n/10 the diffusion constant of particle A plus the di
+ffusion[] 
+ []
+
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+[]            \OT1/cmtt/m/n/10 the radius of particle A plus the radius of part
+icle B.[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (kon) for a binding/
+annihilation[] 
+ []
+
+[16]
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+[]            \OT1/cmtt/m/n/10 the overall reaction rate for the reaction rule.
+ Units:[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
+ing reaction[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 This one is a bit tricky. We consider reaction rules wit
+h only 1[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 reactant. In case there is only 1 product also, no conve
+rsion in[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 necessary. But when the reaction rule has 2 products, we
+ need to[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 996--996
+[]            \OT1/cmtt/m/n/10 the overall reaction rate for the unbinding reac
+tion rule.[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+[]            \OT1/cmtt/m/n/10 the overall reaction rate for the reverse reacti
+on rule.[] 
+ []
+
+[17]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
+ing reaction[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 Similar to the function k_d(), but expects an intrinsic 
+rate (ka)[] 
+ []
+
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 instead of an overall rate (kon) for the reversed reacti
+on rule as[] 
+ []
+
+
+Overfull \hbox (38.24666pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (ka) for a binding
+/annihilation[] 
+ []
+
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
+ing reaction[] 
+ []
+
+[18]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
+ing reaction[] 
+ []
+
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 996--996
+[]    \OT1/cmtt/m/n/10 Similar to the function k_off(), but expects an intrinsi
+c rate[] 
+ []
+
+[19]
+LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <10> not available
+(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 1056.
+
+ [20]
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1099--1099
+[]    \OT1/cmtt/m/n/10 def __init__(self, logname='log', directory='data', comm
+ent=''):[] 
+ []
+
+[21] (./interface_functions.aux) ) 
+Here is how much of TeX's memory you used:
+ 506 strings out of 95086
+ 7733 string characters out of 1183255
+ 66134 words of memory out of 1500000
+ 3729 multiletter control sequences out of 10000+50000
+ 8578 words of font info for 31 fonts, out of 1200000 for 2000
+ 28 hyphenation exceptions out of 8191
+ 23i,6n,20p,323b,243s stack positions out of 5000i,500n,6000p,200000b,5000s
+</usr/share/texmf-texlive/fonts/type1/bluesky
+/cm/cmbx10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmbx12.pfb></us
+r/share/texmf-texlive/fonts/type1/bluesky/cm/cmr10.pfb></usr/share/texmf-texliv
+e/fonts/type1/bluesky/cm/cmr12.pfb></usr/share/texmf-texlive/fonts/type1/bluesk
+y/cm/cmr17.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmti10.pfb></us
+r/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt10.pfb></usr/share/texmf-texli
+ve/fonts/type1/bluesky/cm/cmtt12.pfb>
+Output written on interface_functions.pdf (21 pages, 92315 bytes).
+PDF statistics:
+ 102 PDF objects out of 1000 (max. 8388607)
+ 0 named destinations out of 1000 (max. 131072)
+ 1 words of extra memory for PDF output out of 10000 (max. 10000000)
+
diff --git a/doc/interface_functions.pdf b/doc/interface_functions.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..23375729af9377b1c371b3e36a732439af741ba7
GIT binary patch
literal 92315
zcmb@uWmH{T)~yW$2<{%--QC?GxJz(%cXtVH!QI_81b26LcME<wdC$3(`cA&8RK1s9
zi`|%eZCYFXnSJyz<|dL66sDr1W`rObpYEB5V8ErtwbC`k<>Z8*ku<P0vNy)1qi3YU
z{qX}qBWz-BZ(xf{BW$i?Zy;!(XQgid!Oaa}XK!nuV*%m37@(wWwZshPbyh(8MBfy_
z7#(9?WM$Ee^kH0wl=B!58cI0ZqP*HTN&)(8>MT-(s5-~|BPaG5kC)SS-_4hdGZi|$
z68{?fjIsuX^ov}|>IK_ml2(n;*^y)JhdT9hgYDdfP&MjJ%AJY&Gt&ZlBUIR<wXglQ
zy()6ZAa}x(x$85Oy9RPfspjtRy+s`y<Dl|hRN^QDZPB?r6tSl9KJE$nlpnTH-I3G8
z(hXPy&*SJW`#bg0_3tO$!d2_VA%ZzZi}iby^tY6p!ovC1YojWV^qpfWe4*64!!LmB
z1krOk;lol^jYP@^RpS*Ttid9AztrSzhu6-z8SrHlXM-ZSpwB!5wgPUT*rexANI!o~
zgObb6QPi`w*YzZIfmo(08|%4YUe;>Nv?PRYi(hKD=(_jy;rlpP9<nh!PvVDX(2NDK
zc+x4Jj*Q!es!8=>nJQ;Yc<_`&Lc}SIKFpPNc}52J3?CRcMmsO_(s|<Jo;0Qc7E(u^
z5IN79$1^Z6fz8Bet*oV&D9S~#Xw@{LtO?kVH_-AWcu9_w-p1@zYbX*5qDooyXbjj6
zKx<RBE$n)CSHZ)`1i@I&=WoSowI}E`5W;C4?2Pc#l7-A@sAH$Wbeesg(EXK^rrQm1
zJ87=Fm`ke&AQR*QxifUan_-dk`wz#rxv?Twfz*gu`f0K&qoZ`|lwsEd{`1hG)}+&x
zpW|&~JJCIOxtKLrKAToAiI$2h33r&GN`t*U6@l31WnJ|rj)acB5`^vh#wRVHUzN-d
zp}_HZGacJ#zO&ZSN?WeAy>sRlCNNS>5TMfaI)kwj44filp+-2x37S|p85WBzb{Lqp
zZ!~qmR(r9O-I>_I+(NaZydfyU6h`<spKF*}22sqiK-$NQrlvw)xnqH8Pq4J@43j-$
zT-)tuJUmE9Q9@F%je@Z^JI6*L67R;tmOaip{t9qmWBg5r(kI3oK(>`MlTMu-(<gEl
z)mxl3U^$XdL8ZuymGPnbtALLhj=uE)9t1OJoGa5eqU4xvj160$ezRj$VE$$ZD&A|K
zP{6pu`bA7&rgT)uBQ3p8B#Vuo-evo4tilfBThDCFgC>+ku(P|{WR7KObeB1-F?Ys&
zKNY!CX!QNGASeC6VSzluxV~T%>5tq=;oT-HJS+VnN!CR$9so?)#ZxhoufZ|^I>N5k
z*#6^_v{u9C_{iWF(f4@01h<YWpl(4MD2v`jlvsX<8H!K_@uinB{NV6N<8WTU^4f5#
z-+|2?)u#x%650yfL-kdwhTM0r?iJ9rby#dAU|2qY<T%#wX)Dz)ebCLQHTe>u_}Xt&
zasHu*)l27PR@CPTb_SRVi@Td<(uJR>)~M%O*K6l7-1pH)cMSs+?V#)8+`e~%u4Eq%
zq6&g=u$YuZ2+9Q3K)-K!o@#C`1-0;GN#hNc=wcJLrX)=Iu@I5jc_wc^cyW#kgFpq}
z5{|yJpo%L1_c2w&p()Y4d)L)Lfe6^nC7xrSbC_AN(F8w^n_J$}%Ts@QGSVMjFpsOt
z{v_{Q5IOtED9Td?%a>`U^-QVxVd)n1J983Jl+*g-#%+crcAl5CfG8r&Sq9)0&@>Gi
zY~p(Be%g?-kIi>ny$|Q)WJ9*!pM00UXwO=`fZ!?6gh3cs>i@~Ox2rckLeT%jNd*^c
z16&#z9U}t>8UZUydjm^*JKR4&DhEL$XJBXLV5?_fhfDWAFGv~ao9OUcIpeC+zP-T2
z#zale!i>wxNJq`erU~)(F1ByWaq0f&uerH#|GeKHzyHN$;kSFd0s4)?bWFI6f4uD<
zm&~|Ke_qlv<1+tw$%@PJ*Nd#Utbbjy;j;aC$v}%s_s8du!+oPTjf}08p1grQuKL@5
zBPfhZqhR1{kE{6x`2YJU{<zy;ALGyMfsOvp-2wOCZx3loQlH<phqki{IQL5+vvO`q
zb(m(57;~Un-e}!9uDS@^usA7RV(6IABQI?^O!9203cplBae+}c2CKj;9gn;3Y+*Ub
zYE+X#wU*h0X*u}PIR>q~V$GqmtPgIXVs<=3Q|=G0xJ*Qs8LXdG>qua4j~F<G0!&CU
zbXCNOn$;Y9Ii(^sYMp`Bsxl*7LvQc~S{}XTIz&vul}r#uVt~somzz^1iN|uY!sof-
zJ!oyOz2^gb1QrO4(#sf$q03GV1I&vU)`4IS1m$PC0r<G0SX1)Q)rdlR&b7>2xOBuL
zKjm`|qpwePHi`?K^!E?qdpj3n#be`z>7lTLYH+RH`k74G+h(fU5i9n@X);AV2UxYB
zfmAnmH(p1g%ual$5_G&l%^@~@eoQCD-=4dcMTh`iGc-1^|3W<fj8vkY!i#Nn?mlqH
zoSX$_dFAqM6eMITa<+v9eGWM(=Cx3PG_H^4eIAw)72ydB+)jv7CIL+Ij;V$mNyV_%
zdtdKB|8Fz`7p1hsX!RF0C*$;%?;FpEd1MgVl5hCBUy4m%O8v7PBxVczN@lXkfJxms
z>*5Y-j*4&O4AkT<Ic+Vz499Pti*F5g-4WhICy^8;8F^;dhWLd~3l@e}^I~jAI#CI_
zZ?PZc6M4e8cCz*aOaZC;sdB~CW4&Y?CDeq$fZ@RSy63dUQuUXh<jP57*E8x@GH(lj
z1#r*l@Yv3w<YkvC@t~mr0Ej(qdgB!Nek(zHktRn1vl!sm3D>lSr7A0eK=}xQDt*p8
z$&!8l^t}m9bFK!nEMcgf7e%76OdIyDrZx$vjdBRob=O1BE2U>yVckO)WdO<Z1N`+E
zRuzrgs@2zA52F>gEuh9RU4_&!h=*gjpi1UTDxtX)H|B&~i{)DDTbd@%A=AS%x?8~)
zpcd_ByL*^W+q|dubL-Dh4|i^#AXLAzAh7zy+qjf%XawvXxY#u-!btT!yz?chKSN(Y
z9Mbl@>Eg6RD(Z8RiAp~bM!--Lk3<nNl#-9jR2ae^*g6o|3aT!f6^K4iF~=%pphAlR
z8BB#6v>>Q_r|R@U+GZxfk%L@f_^7&8BO}v@c!ASi%4B{+{-Ft$r;$vA7JoTdtfb5&
zMOewF`!2j+6&W%cGCH77YR`E&VpT4#m3!Vdm$Y5s@mnk$aW#s9)2mg^1-xdxH=$<s
za%yzBj4UOdSMTZR)WfM4!6Ad?-|<HGvk&|w-{^jT=br%g2NU0r_umrkXQciEasMC`
zjqp!2`wL;ehpj&#`2WEcGc*1FnA+dK)`+r{-4|N8wnt@JZX$;IZ$X{;3|zHoyW@IW
z>6oxNxIRpNM9N@G+jFQnJ)rNyr--Lg{ku)?PL@_!&K<ZLTbv}jMB0tqdO7J!L&Eaw
z^(3WWRqL&WL#i6l*CI8S+Q0+06;`SDc%YU9+burm4e_@hnNrkcFIp0yDL>d$;T!~E
z&hF)D3FXdh<<Yt!gs%&pc}^yQ!&o6iPa<KG%l5K-$wDP=<SCcP#qqSspZo}5D1{tP
zmQ-t=kauQ7z*fNrsKbiV%DW)(Eg?|69~%XqY<7>+I7XdeZd7ZRy}4VeWREnq$7KiO
z%-R#CFmbY;UPJ7>o4+PR9_|Ept@?Up!&;?@^7D-eoJdTjj9jTP+%EW*U^N^GU&;Vj
z5E2L=ybjzxZpO`}F<UINvrw?*$Itm@^z_B@ARj`&hl)A<_2Vc?Lr?u<{V!F@LXVUn
zU#tu`KP4ktiz*UlHC1V`uJCOm(tDf(gfOT2-O<pG&VpbT3NL(CVldiQ7iQ-`frCp4
zjIlsk0@8?_gL7DRJmF&W$ru4zt*Mou7Ef;m&C_x}TOrCG2)0c06#jZ@>q-U36!|hZ
z&0dEisRV31K~*AQ8flJARg5tRb6@!tfW)`2z+AoeI<z=PD{EGMA%k^ZQ!yYYz8@iJ
zgM>D#qsCN@!iQUH4Lmst*I=yRpiFO{(o_Juj;avg+}D69CtL2E5S~MP)H|3`gJ}rA
zUV+$os+d@r^qja8bI1#6EkD+Bh3i_svcl>za2tEAli4e)(~II8#s<jq^ZDgbTfh^x
zac0FMf=kUue@M2Y_I-kD0x~r*!e;8K)|#YOjw-c}NN{JTMmKAqZlTNXJ}rsVEJ(g{
zgmLscyXwT5wdctEg=YWQ^#6Lwf34XcX5gPR`@=K*_nQ4<`CqsE*P8t;q0;~1MgDrf
zzsgTKTH4<&KYNs<thV0##iKG<Q#a^rxTuGUnmwxMcrLFG$l^R#p3hg&S}95*7csKP
z$0H6Tu?5>W;vf)L1Rmio7Ar$+mzorf6_EDCY)0a$1~oU<NLftb)o-8SiHjP@TZ72T
zLKiskC+z#SBNai$)cNvMO--*XC|31pjBgtsR=yzO<oP?>h09_H^$sl0gDY92Slmvc
zM=mg_JDQsG-Yll?GCTPyIf@EtT8!2+VKBHFy2uaV^;%Xh&z4o%a8<!XT19t*f<I2k
z(S=v@eA1SX)en8`DsAcb+VEiBOJtU$fU~=K-eF_ooDsHfWDBnw=MQL&kcp(X<+3oy
zG?H8mD0);|`~fwl@UE1Vqs7urBnZ0D(@<_4%XYtoVHh4271j0TkeaRR8ZJ)<%n^=A
zI(&mE6U_Hhb58X})2GAO^dR{G=GOA#{A&G!iz##I7%~P#HKbBn9^+KkqAgL_!R8vu
zBwo<L%p?3bY7}19QaB0cPV<ybvwVz&T`7u%HP3Ad;@OPh)dTjICqs0;r?~)wsKxLW
zo)Lw|wliPM7}MCCm5%5q9!kYEQ`9B&`#IaGgwjcniLI_K;V&6NQ|P)l0d&})x}C4@
z<roHtaw1BSxz0HH>IO<s)EX35?a8o<o~t28z7Koerwl}IjakI`=pAu?B^B*gkxDm%
zQ4AGRzt^}BXQ~~PTEyaDzFRP)f~@5%^QJp*R+D+HaNQ3IM*ZA7l}Pt6wk!(DF%!Ho
zgSCv%C(d2(>>o1?Dg@Wf^Uf=pCxCxjE!&q6pnx$*<)SvHM%^Sp35e@hjTGDhk|;j_
zC|iBsfx)a6+}fO`v;}>BDUN>)9*B|gp<>{~^it2abM>w=2o?O>xHDfWKBg`W4GHY$
zcIB_caNfR*7q@992k>#ec58^MwwHU`!fRjN(TUN1vjI*=kU`e9BkS%@CganOehFuo
z0*huvPbXU_M-Jr~3#Wuf;6+D=u>G3j#$Pc}UnBt$0cjS5UI`^6#1HpcPuJVpq|jSC
zK3JEu%l<LSMQh~Tp5eN5NFmXm+mX&d4}t|&9;vfMS7Qs8108n&^FeEGb*7GpLkrQ+
zT2-K@U&4)PR{VmbGu3juobXgCKJ9QJmgxW<DsPziWTaCC(0UQVsoElJY3=mXOY;(8
zRrr~zWe*00k-2|87!)Q0_!=rusBcKEGFCaUHhNx_LfZc65%slj&MXMnbH2T(L?Gp|
z*?kk4>%qx(Ax)fbaLoOzVR@xjkt-h?r+2K(tWJ+j+fFGQyilsw^r&<rqN=QHu_iHX
zoz1E{tAksS=JxQJf83S<p|fQ!b?PbyAib61fxiJ2n6urLpT18h-((!zo>4t(ZJ^nE
zx4P!ch{{L1uKNU%%E@=(Zm#ZrxFh9kM5Mx)-c^Xh*ed-j9hKe7{2Um&!s)|u|5Z4p
zOs*_2AcWW_Pl&Yi7f2d;i?(0j^^cnAFE;%WuRrMZ&o$qVlIy?6>mSSiy5+ydD~&My
ze`Ja1e>Ql3l9ri;;kPZ(NkXUXA}w6tnF|DL0bxXdLFGG4_9@92fsa`Huxa%={%zi%
z1at{Aj8@v{WtfuYG2@u7`(n4prcSRjp4An^Br8i=>(B$VFnU(>cl+xxf;PvRpmbRq
z<6m-D@8lhKMRe?48+`oz@Qrv#GPro4`e}31Ka!yfM>|}XZJ8cTY)8G5fS?Yz8Bzu8
z=JrHxl_7X+^;za770nf$*b;#Q(JMlgcqG4?ZW?IPoHN(S-bWH%dIHRkv@nJ6G=6R#
zEDxxq2pIenBQrf$pg(?wp2kI=%iOIGuHsDQ7xJy0E?Sq@Xl<K*20Ud(?huO0aQ~~&
z98=a}?mUKRfZkYdWg$DU>}A^M9wp%B(~;0FH6#QwDdSG@y6zr;p$sPg7)jTR(zXU^
z`f-t+<2|Hpf&oVw=@yfHE2q{Glas?1p-JZ)y`P{F6trGA!>npf@kfgfcf^C{B4xCD
zKnheRr~~maz8plmNeD8<WZDH&MW0=a{U>~wQs$X?b*oWnrSNn<%PSAmQf8+ru@Iq(
z3bASAC^1U*epxeb8vvl=9e5FG0llHu)V>VR@*`a+0t$+dQDRt9`sy|Kite4A2(T!<
z{H1?k;o`I(vkMB*m&T=+lFnj(JnZ2-Fp|g-QxfOc)&Z_eZy?*tM`;<2&Yed^)vU11
z#sj(4j1*V-u5B)BnRYR#Q}~kyM$SR|9i|b1Q{Q5*{ZfHC)`gAm>gqL{R@JQ_O!3tr
z*r+zEpOqYekY$BQW0Q0-Pjs&q%PNcFe!-NQm~4I3>VAUy$tTQPq+K7>h<7p$j^$1?
z3YzDV(KB&6T#<K2^!V+=jDzv`Zp$q=8EY1U@m6!IH@9)k4Sp*ft1sTyj~)!{@aX=|
zdO~??10&npuw4=NYk!w7{m<paujTu<$mT8C_}^4CKbHTVe1Fd!{cQ05)GW(?qFH5i
zt0`I}&$Wu++gj+u-Rj&E!YHMBJSl#Dbr;^R<SdRD6w(?!x74rLB=vR&a-e!(*v{;Z
z?(XFoV{@aZZd+kr9SlFA+(*}lVxF-ABl1`iTLN=>?NUZv?R<K%W`%e@2iO1>C%*<o
zQA_XWXk>38ZpxLZl=EsKh{K>7HHaKh3q!CX+}TFK@l@AfFK4*qq=ghXF%_~EwkZvd
zSNhQFOS@GXH;wjq7-$K))+p}!Afek<@}Wq}0&P#<prV^nI~u5dR)rpk{{$Yz*DAS9
zBBV~8mdcA=O*i}kI#P_E7Km#s`t~VV46%rcx_wOs0g+GYJubg1p4{*Sbw+RUr-*W`
zZ73a64#LS>`%DNn6f%J{w{-$akPxyLnKM=t3DJY<1H;&89Pi|Uh~u-fIc<@4NW=Dm
z+{<;Tn=Jm=0VM<6bGaMPXx+Bjd&&}pV&<hl=L!z+k~XW`FEM!NkTpY}Ktf^{D;$=j
zBzx>VVXvTjNFKfwp;Xi+nbEnH?6hRnN)Ocm)$xn=g{@ib6yg*&FkoJhmQ#HC1oN<S
zNN%Zmtv#Ggwx;Jcadm89ZDgDaM?}UN@;<tR7vTC*p09Y*^jybB!V@v+Q<aMeW?w09
zCKjl&Wcd^xVGY89#4s*(kl79&J|rOQ=hlAA72vJ1yBukc20OLSsm&05*h$#$xy&i$
zmaUK)wh%1Zgw>tWqz4I^Feo?}L#xW9>_WOQVIv|bS}prh25!|7z{B6;>=vbI-^4y%
z9Q$6wa3@j9^`Cr_8+0VE%FdXK>VrC!o|bOO0mTvd2(W#Tt6<#NV=yEoz$*hWjxeP+
zg{7q<Btd}!GCL8Ac6upqmXF=|F2aocOMkYWC<H%Sf5LdTUeJ=N!GyVz-2B6mG^2i9
zEK=}2QYy5=0ngN{PCo1_UjFA7l&PUjvGOzdmbo>x&9U*T!qu3^*1o3>$(ye3CtXfc
zJ1>*$*EDUIXKfbrVufDRsZ$&<FQ9M5f_wn^h}uUY@vE!%x@R2UN%WY1!G)hom|t_@
z583_Gwod<N_VHgP9Y2=;zvRNt&g8GEiGlgIn|5W&5>`vXaP3FRaP8C7*-VMKg!H^H
zF4IC`pvH(dGPypL#LAOO+vS5n277Z({b?IZVz53iYB60d?pGszR`p>^9BU5vC}nMR
zH7gvP%at>(C+5pcTUy)Zh<j6YlLqDXS({&W2Guq9<ht|dF)9SflDS@r6jfVm_iBbu
zvZAUcz{Q_V%9mmD*)dP@1`rV#9>0t&X=BZ)+Ky(=462QG1KKNv2$pG3bGbEB9ebJV
zi#-B_ThAJ+gQf=foKbRR2&Jm0E#(~d;Mtp0_)E(WaPjOB7i}UyBa6uAk=lMn5MM)p
zI#Cbkf7_99wzGPMKaJy*xYOtkh_>5Ig?0!}h_6wkk$NQcw2My^i_&a@b8$g%_KUzt
zXN-4-p$9S<-NbR?l=9~A)Z2f*_~8D1NZ}T4s)aY;eR4xEthJgtDil~SqldIZUry}8
z*^$B$hugPW&f?7@6?lXGqR3SSlgHxsVn(mogImGikK%V)W#aKD$F&mucc`~71IFxa
zN7H<a45PK|j*5VB^J(2G$!PlzFx}$YS|%aE5RZ2)vO+qw_y9h#Rg}X1{C3L9$~PxV
zEtPWy2^1(6%(!4x7jQ$D#Mc#g41DXF870-+-;;(P1Yb7tCRw!R^{W%!YqRP5Khjg5
zVCCc?6B5rEMWghlZ>H!(sQaDnfl$Arf)m(^5sgtZzL;{nIP>k&oZE=RDNAkvPm6ES
zwcO{hssDbx;DF!^*2%yFktRWq!p6Pj305$D-}qhc!f?|3nN$~B+ppL=K<6!(?6w71
zF~=(J2-?8~2-Bji)*$hSp%^oW-h(HkG1tBUEF=XBjHg)eX-gHToBhg%V(Frw)PJRX
zOT!Q%sR~t<XdBeJ43E&VSe3G05xs16{z?_Sa_iG{-&yP5o0x%t1>zSjJ+qst)zS9u
z^U0%Dm%Q!D5`ZKtG#6-Wpk1Y#6C%i*%Jx?YuXjutU!a%*Jftv9@ipvxFDl1k-DE`_
zJ^2p`wXq4?w(+jq9MLPNDwdBLh~IlY%FsQ|z92a}6#|H(w^a6^TZ?_MjKhme_7?u$
zNHL9iAKJo1D#hLcd>a+e?738kZXYO2<XHLWm5E{G#?RqHvYGUeY>aW$4nAWMT8A-1
zDhux6eh;5U5y~V(ulKl-rW53bH*HLxKl(Cva7jtb;^T|^-3HdEM7&~AVOp|9(|y)p
zZn;wqinP`KC;|g*&xf!uHJaY*c51Xsb#795WX639$Jh&%Y9eN5oW$IwYig2k=LB#n
z@8-c%x1&@C;d~Q5JxAd0kHYtT4CcJG-Duw$kzEBXxg+XpX==ng6hKa~JH+@x6n3mn
z8=A9l1>+Os&yZbT1tBGMuVDqHEvSP}WaI3#qS6dQnIMygcV1ORIZ*JNkx#UgrSdeg
zoVvwsG7-cXDe3Z;Bp+OAXh-+#w(k{+mqb$}@f+3cqP%rmYzFwHC!rx#nfIaF>|;~5
zN>LHDhVR~OPVE$K>KS31A=dX7=zKtfFH}Bd;GW;a*`yle<D{dkE*oATeTXu4DX(Uh
zk%TUl+bYk=W1oH^H7uIuY-3U6KD0qXL<yQuc&d-!R<;>w7yv6WA-JBkb90fRc!l>=
z0{Z}b1~&Py$UKPs;jm%I>Z<kG-e*k2Am%<E(|li0#`UN|f&-LYInv@pUN*`{E;Sch
zIXqZTMs>9Aw4Rv+IlfpDe!Q)J|H2+)<TI*%KTTUC1EMYJxRzGo>EivZ?sOUTiU?J6
zd}q5v#SMNZY8bg?hi35hj*TJeHebK5>&cZ4jJdVN@_7CO4myt!<uCS_pX<0^?=e3b
zaz7_?^nYe`zqiM{rR0C?QUB=F{aF5cd(2zu_>YDm{V&>tzhzDteo;`e(fxkLUZ%8W
z^_H=Fo@vA1kfouJ@QRA9v0JRbnkdc)Ep{;rQ8RacnD1wnXzB0-%>d8WpU5YZs~lOl
zTX9-TbE#wdvL+ZdfKjHrVOl*v+(|E-sKeN#Q7QvhPV#~Np1v%1oN?xuq%EmOhm$C~
zJDh@}Gj-l)b!IT)YgBt%lNYpEX|DJbgrwZ?$vU7UB&8jBbXw~eb-M+(BucC*T&4r2
zI@-tV`U<CcJhA|P*?>Gl6TTS<j<fK)Bs1Q{JK)EvgkzhMc^ZgEg|t%*B$dyd{b(fN
zdww!(2KSNTh<a8pxTfHM49<r0m7g~K{kp)){Jvs8?ZPK2@?pK_jWR`@Nks$7dls3A
zMU|z2Xu%b}e{2p$ZJ1pT@F*RY1E8p!MgsxRvBZIAPimqy6#}QNxB6D!rM^~3(6=qI
zxlE^+2pjoolc`C)!OG2QNu$r_4sp_Zb#-Ov;HekqHhxX1k?DYzWE39LuNK(<L>)fo
zOy^-ls8Nd^5o1h_O>J1RbKL^pS{>v9GRZ3?102t1Y>2m`U^T^08v9ySY!E2FNV|X!
zl1{!+J78;RzZB&<1G;g3!$zC6EUziCss;>Ms{u`EC?hsoB5!r%8m>S~B55)#|4A+k
zF=#k-uU&>`iVxl{i$nE$OzAKmwdqN<GU_<Jcz#@g{@$WxKa2|wxTt6Xhe@zGF8o<$
zdLK;D5yx1!!QqHv^tHGuGXi>N^klZRY$5dwSna&Lw)dv7iyF%k*Az!@0|KH_$rgF_
z*{hJ8aslH`&D^(x$LoV8<mIuk!&>eZB?6O3BD%ctCqc)~_pd@jA{YWlnWW$uOo3n+
zT}*hI>c(y{su}ej2gcf>nRNP0EU5YGrcj=V9&NF@9ZXH9?5ngZp-u2S$r|raCEqJ&
zf24|26VL0VuE-!yp*PwO=8O}(V%CepwCET|D>u+ej5C|*LXV^fkIu<jhnI}c<w-77
z1Z2@BC!58>%^3&O?|Vgi&cm(cwdTAGvj-;kf<Z#^Y<zmAun6}MAt&ZtF-OnTM|ZiK
z6M5Pi?*OeHO|sAK^@sZQZ1=M0{aH>?t_^XURn`fvzt7Ro-75a3e&!?ca~Bh*v4_Bg
zve48qrc_^m6+5<>oQvG6lhB-6Wrkk|CBU&4t?!dOj<l0UINTj-yj`=kl3oBqhuDMm
z$p%sA7w8QPqJg}XC`LykD`uk(KvXHFp}#YX;osKJKM3$oKAGV^s-OSHupi6+HN*aI
z==G20;P27u7o{{EEi>cqHX6#5mLlH<89eTk!5$Gl1f#D|f%FTotU$}y`_((jAT0&(
zNz{&%6E+jpY3&_xAOwYOOF%PvAc#R51saWFUOLjbI^i@*i%-sfPU~5`h(Qn8oKJ3|
zyLg&b-5%XalFpCDiP+;vu*o0RCs}|*ts{pqOcxVo8XD0byO|BYPDt)-E~g(6VscS?
z+HM@3z7l=wIe3xTD#6)*R0}IQi<!O)bd-mpLORocKHlVOPt)XZ(@92|49C%4OX&pc
z(9Q@(cQ0yGI-4lgPZ0|sHX{C*WVRno2!*@notrMU;lsVvsYqp$3&P)-H)$w(^#oP`
z*zYKE*C2F=-y8K7Y$d|K1c;B+_;S@U1h**=FUsLKhR;W|=`AlWGnSm4`e5~DtX1Zg
zMDh@b`BGkp(fVXY^*s|p_o-O1iqZNpNXTXv<em-qeG)t7o1cBZRB9mY_?}V9Z8%kJ
zswgok6E)6RYQ7)K3kiCX55ZnvzIV)fquj>(vBsAi`0;e=*@|b>MHLk(__E+b6H0~U
zMFKe}PwQR5bQq{N)|QtJn~@o!Thlgg>rQn@u}YP2%1HpFE#{EvRTihH+D<khZRbv?
zNu{gSVDqQLE+bhilKl+*%PI>+!pxg$p7-CP5c)%Kw)3e~XKDwCkn-EEX)q?*WjT;a
zIx@vNv_E1Xlw~S(v#QqPl^;QPyGqGHJq4?3mZL!o1}aKobT8gh72_i%&4OSTX>-+l
zn`yc>>oK3WQ%~O*&_ND)0GRA5hVW52ZklBNTt5=X>yh$m4ho_zMh?5J(a$3oQ7IoM
z(Q_S5&|}U9T%B<AN_>YB)Vp<44Ta_zE%n~bS3|+7cEyCDo*x2tQLt&|vaStTiP3FU
zK17{f_Ox)9Ld!a021(IoU!tAI9BOG>e#wb@dyhz@45nvsfw^O`*r|fD#G(R1-FBAo
zfW_*Sd|6DJza^|VQ6+Zh8CY;i$^7u~#Tg_+e;6XkZ7aeQ#Sf)tw*WZ=JP9p}_NXig
zsMvEJu84HlbSP3D>((!7_**~uYxKFfw`Zl1eFNGvmudO?xr<a<2r+<wI|5j2lB(GF
zoIaAdfen&W97Zmi+cJ}buVrwAwB)Jx`*RZ~0~{pbhJ@jA)-wQ~rL?N%>|~9|Y*x0t
zLQ=kWLvHCPj7T`DQ4j)W3t;4@0@`4FWdq{9K$z=3-4~xwW@F(|SWpTL^{R6c^!XTx
zwHj0?FikFK2f)BC(zC|lVC?efxNr7dp(gz#wg{ox|9sx-hT7`PpCN@G*>HthOf~>@
zeA_QE+T;o&UHkC6v7B+E+jqzsayhxxJbBIFqVM@NY<Ii0)m?>(Hg3mft*SRde$qZ2
ziaoPMPRaA#(>7%-Cz@p^T`Dscc+$Zsf`roE!BIn$jBL5}AuoXM07WByLD7GkHZc4x
zZD9D1(uTiN^yitaUpEo{jsN>k+4`$Ef{yjKo47m5D{n($P+nu&I@<;?*0NLs8Sie#
zmt1=Sb>|mb>w5T%C_?D^1_|#cAJ0ToV-Pt``vRA`DoKWrgyaal2pw8fTN`s^Wis)J
zOez;Z2?u3UjrdUVz+&;|6*?c!#q3KQ_+!o$SR&M`l$PRAZkNbT!Q2{1Imqt6D&b(N
znv=K}bK65t@q2bWG~N>h`!e+wiXxOe%^bBf@U&e~isq!7VClv65vm}DLWENt8ER8d
zTz<XLQgA#mAu_`_H5L!c(d0UhfzF?Eb<dT@!gOus9=pDWVPL+h$5@Mxuv7~}QT;ZC
z7$B0R@H~EAWfoyrVRag~iZMHi(WNhM=K|w5<w1fO;iVg-#}Kjlp=#+~{=KY2dKQ94
zT0|4Nn~iYWoym|(UhmyQ4st<=k~OczQx115g$S{OCi5z=m)+=Kn<kSki&4PjQ}9!-
z!6;>-gn*|_qITw2LsSrHI3I?gdpz;%7Def<a;k`s5+*!Cckhqbm!K~;jq-t_kB})+
z87&l_s_xAW47%cMutGenp>Gt9+Ug9T#4vIwrN5rDaUM4^8=+J%hw-4IC1nG=w?QBf
zw~o>$8??cU3+j3NEGyGV%nC4p4=c@egqI06g{dTUZh7&zd0ULzEf%<$yDyYC?^3gq
zv0G~h5}N&_TDuFp!HQ*eBGIo{D(Vlx-|7S>2(C_CsD%ojry41m!Y_&#hg!5l9E@M>
zD=3yd?jI6^C&~C(b0izi7V+_&*-?(4RYl(3LbJJyT{J_!j%YU~wH1@nvH@fF$!g=p
zDk<G2vQ@qCu{pfGDmzifPIGKo%BO7&Q?A=lhsVy7)Z5lH%p*V3iQ1*XL&~8~MkovI
zl@RjWj1}Xkk{JNQE&1<NUNS&bQW4^i$9!lA$jHtc){oHR*qtNdUZk8OfXm4={Cr_W
z0I^~;ZF_Ebq%Q50*I+{Ez|wYK<Sym<#i=@&%^HcF+30B@H~Bg!5ax_3KIKzWHYb}h
z?%S{)sGX=EE~CGIZN;Qq0mixqY9`hMKStN-RazNwa9tl+ungM?Z~;^+WPG?x5TBEy
z?qGdN4Z^en*~dxMd2niJiNr8#4H2R4tSQrac^w4L17|FHVml0hN6zbMn2y~WKZF<*
zJ?faMC_0*}=#2KTDo--hHfg`FeZ)3cIdmKN%n#!*kR@*a5Tq?MG-fcU$|=>g77pdM
z8$F<AZ`yC8`A%A#Cx_d+|DJxD2iP!hGSPMp9jp-Y-TAzC9kM=U9c(rrknkulh29)Y
z*GYFx)z$G(@u89RyMbi*J^G{x<Hm)gBiV2&Ekj*|Dee-(Xd5a_LmqMZF-;&{z=V_;
z!}Y8r|4<$bh{U$6%v*Eg4zI<zJe~Qa6@j*;JA~tM3SdX8!hqfP#e8S7;gE6B`j;v6
z!tb=>9>v9S@JrPtY(cpecpPfk2Ok9dw<ZxJ47I+nDvbN+rUW*;0GcvOb<k^z#;LL6
z1ulRM3j2mu8qhxR!5`(VpiLFA?b$15KTD4xk3;eRk$^k}uMWzYi0-FVgNMi`ZPc);
z6u^g8h0#R1!{0*!l9HJGg6IFXvS;{PWzX=xtL%R)|JSbgznzm~{MqCG86-0?vHf;a
zctuGnZ0T)IZcjNWHMLslT4zBiD~Kur)phy1T)hOXDjP-c4(@=#lD77OoE!(?fu%s!
zHRDT?%h|z5c<kpM{d7b$+OG(yz(UBGNxn$2xB=k2NgzG)=WyH?rYN$KUC=Bg&5Yu$
zrL*oWnkE;1UI9p^?PcbIXGWiU_5cLF(!${T1LREeky@$|VTmU~&qgrjMQI$o{|*LY
z%*9(P@)elYKT^<`B6~(dm57Go*}ZhD*QiMZmGFjM8ldR`w&RnuG5f|4h?rIFZe0G_
z(x$5&mIu{#J6P(GL(p#ZS`$EFm>p_D!+rL5+o`JwBpH4!Be&0HVY^Lfg38`4A>nB6
z2&ImT<f9Cd-*w`qt13t&j;UbQ+gb<`+)(0^K~v03W0QTr$2(F_$OLfRTXgM1p7*$G
zGOq-k;AY`R$35nSkP(s4aqf$Nx77n@K!8wXDyBXusf^vgKFwKO2o`8Z(HL{eqt|WQ
zS+t2%f@QBho}N6=)Lvr|nHGT-((@~rI(W`3$ou@wS}{eqsb%-Wo$~I&$EQh~@8&Mo
zvy=5p<=EHV)|>$irc<*T7#^OZ+3!YGcif7?TAp5}Y$efp!1U?RPcpa;KG9L4)qf)8
zxU4w3QUrC~a71nnbeenFa%g-#<H8(X7f-m+PVY|d>?qSZs&ulyF1jyxYBzRv)iJKH
zeuB<%t2-DFntC0-a!H4NP5T6aTV+ICPaB~Lc<9AU9Hx7T7<s5q_jfV99W(mJxWg}F
zvL6rVKb4q_{}X)u=FsWi%+ZhK|5{A{Z_N?o&j#=>iLw6v1bvT^=37jL<S|yk>tdR>
zsfz%naM+bkEdMrgl+a+o&&WEBpiOV6`11U<9St+tU|}zouATetd-@jSSx(Q1<&Fv-
zgvVS%wqJlB^ridSA}jYdOJkv;n|pGy3X8Fu@_HP{kFaC4##jEzP?}y5+-kQNIiK39
z&7A`HDYp`b@-*zQkebnim8tW$aVIvz&l`&d(qo8s`%=1T`Whu6E_*Ig15sG$p;p&9
z0NHSL!}-TPOofb-d{YP2xTo+5f>GsGjAD&`mzxmFGN@fQ!==NSwbRd+>$IL~J?=zl
z1}S%G$UizWun-lFQu8#jGecqQt&l58x45B@i*Quy&Qqk6Mk{^iQlLztC?Ky%cE2f?
zmAQ&e29CIgGKJk_VVpd0a49O5PVMF_Qx~JBrN~tH7$JE(%Lt<MZqJiuQjoJE>$QRD
zSezO1{`<MW(x_%T)!=yAKxvQc07>*IjpD3KTNkcMP`Nm_Va(MAh7{Vcc2dejjDXrG
zFf3az6j#It3kTqnIV7ni!rX<!@7;%LT-W^LwRR9(GT%;l6nF01bJ4Mc2MdI8ES8)o
zNzajl8dYfu@O3I1HA&)_Tvrrn%&%9UVO!AI-H?0bM+AoY_e`ux<_FM)Y8W&z=L5Ho
z;ZcU9g>lCvsa5)N?5-4GDrI8!VyUmpnp-CTw?XRZHxOgA9;CSHEEiF3&RphL+>|xh
zW@7FX7rbz1o?aL3J~z(s9IY;C(mu=D&Vt?1`;&q(+cG#lHuf;9xxY6u_Zt3%@O~~4
zel5H|9@~Ew-k;MF|7AYS_;XzR>#F3hUF^349mbzG;y-o8{1#^aZlE)x)EW7vtJXaV
z8R-xtOsFK@JZ!ZS;zevV6P5;x08!c^qRQwK^O=r{5GkOdB46gjbg1tOSF2ypx5kzR
zY_XiBfnxeUr&?@$B?XcVPK`$e+$R}jcG5CBT^8a_iN=%{gYdn7>bniwa>KpI+TsU8
z@VD2`C(t%+B~jT&?Y$xO(tYNw8RV?u|NLyg+rgDAHdqKwVkk1vUBr3WLk53F9#lQ8
zv&OYOgPy3by?F$I@*u!b#-F8b<p056J9kCjD8ZKUbLu8$D((uLFDn%094s$T7HGP3
zfot_iI4mHP9#^uSytM0A`n*2VAeX_=+7aH|mbD^Wm)Kg|_<@gJ-Z-EiR&}***6-uW
z8ZDo|>((9^+T)|ScIgRfr)~qW-#Hg+Zh345>E*dnuqQtd=M|FRD=t;KLXB@3K0lrF
z7waX9_40KTt$^%tU3GG0V3!6Yt5NDlZrFMcatEPKcsv#7a(*?k@10p*No-EX6Em_4
za}?~jXh4jxB*s7tuqdvIUFBhy6#K9vPHF1<S`@MG5tP8@(LNJHn-Z@FlVe#<1b;ak
zmNyh3>{`lLu(=6Zz2>A4A?xH>`sQLksP3$!$lCJ53fG4-S95i&bpo!Oez1Xh$cjJp
zIsve+d6&(>@%5JD<;zw=!K3R}U#>;?p}OWP4NC!3FWkydeyl@3xbJoWeyt0j6tVAZ
zG8q+UwG3hkL(p>`^f-1)<=BxhGM!dTFC+NiND^?uRA(5$aUjwu*diDb(L=gh2?|-<
zJ#b3cVx4IQzPMOTVHv=ba3mZxx-~#Wi`O5x0c|?xp?=K-Pvx{E@dAj^oICo341YeR
z@M{_V@s$6w4F8M^eouys|6@k~(I#U2IS2i<4FB7RmFX8|l8*N6V9Af4e}7hNMrq~8
zQQ|*h05MQ};pv8lSxbioz;}VuR!6wwC>Cb%f}gW7wma6ac#w*sWApbV00p>X`dZdJ
zE>|roELmhL$wi|B4@})uCK!oKQcJ6Gi5MxBmP~IN_9~tUB{@Ag`->}<Zg`e>lyrDQ
zqsraI#i9uVKRX0oJO_=eRNx#r8Ydyh)jZM>xnPdmS5#DtWFeve$qSC?^uP+MG1cx>
zBT$vJyvRoZ!+?%oj|frXK1P=Csfog<Rp_r^LARl%0cCBer8VM>%8|A!-=MbC4~}G?
zVmHaUe7eaOwmKUoK4lCS<ud|Zv%Cx$diF<BWoBu|ar`a-m;Ly4X7O`2m;#Q!Ir`~_
z@Nx2Me{AZ>3Uz5<;GOUoWj%L<7<?b<vio+iy{$MEP})jpC`(?{j`3W{a=CPjItjBw
zMJeQ&nM1XXNlJzLt8u87iM%A-_pDRr8+SO$(2gX9oAwPaeAg~;m&T|s5`2s7q(ke;
z+lW_PF4xbf;c&AH*=E?7OiZZ`p_J&?G0RxWcc~l&%VACZ1(w=KeQ`F#(4wiMH!PCa
zP4<>HJxFM!FW&;-&s~fks-iqGUm#ggDe23OI((WW5$(?5iDa=Cp(@GFm9T>n{5Atb
z$DrNSa1vW`nl1*HF+c20F<<hpQ95j;#$T&Uuv|GecI`nvvaF`EeVtS;Q1mqFS@uEt
zkm<Q-xu<AoBTW-s4Ln+1Yl9*n-_%+;A{IQTy9zy6eNlx=RizAPpsX@JHa)+%ASWvY
z{{&O!fE|8tKx2NE;yeEgshQlmdGN3yHA5WZ0vTr(GS+6kHfxBgVPAFN`H}oRk6!eO
z<@yC92LE$#B;c56dQTt=;Q+=b@9UA~;I^!(_5h4v`rufkviP`<M6xmo1xU-;22jP8
zuC|^kXmFSXAMN%P1KjdW72r@;3%q+(oJ9q;=X6fV7%J9Bb$p3ONBT3-mu4rTgh?Xp
zda%C`o(5yFQe5E9bW(pTE1Dw!Btj#~Dj+<1ut8Fl#GF-R4M$>^fQN5v37Um3$hwoQ
z#jwcC5YPv@;c9q7Y^<E_iRd2J!`LKp1}-G&vE~Ff2iZ!9A4tiGI+v?uafB8{0l38w
z#55EJL3p<2W??GsoB>1x1wWdk`M#k!(!%v#fFA3Z^Aht*IRqg<5%7u)f^(YZiVY%F
zokrUVkOW|z4Xsl4ZPh#dd=~Zr--=yHxYW#%^P=H9lTAUq5brf&G;ViR?E2#?j9Tj&
z-Cfu|*Y4HIKDJA2DwNBs2-U;hF!=(TG!#XgkL)YMot~V9WngH?#qY0UiWo3@2(#Fb
zKJs01GBg^88!4YPD8IfFe6d;hI}(}xZAtJ0GyjA{rvIoU_!|;`EdSRf!C%hg|F3iY
z*0^H&VUK?AR4vob5dPD<u)ck+-zDXUlKRJ`x4F(eWrfx#>FI9isUcuk5T9BTTJRf-
z#6c;|^X=|V>Ck3v9u974D?TVCVy#2WyVS7^o(#Q=tBcM7Wc2z#<9UL%S?ASnxnZDq
zCO2K!-*z)DN^hueNrf9%I$2@-%+!`^;!rrVvR6VtS8$_Eq><<7r%rIT#z>T98$r?P
z*`2+!0eMH}TUSEFFozeq?r32Ssu&7rQHGZBGjyyZI*~>Y9GPDpb}k+5?QBfGor|={
zh4~wcR;mKz=q%eoVq#;jR%a_DhvAgOG||97%A-}ImqOJ8@!ZPD0hS!uK7<hk6m0f#
zw0~Ma;fNsT$FmN>N~FLe1FjG(<`VM{oM(&l2elsY7FNo?N07xsz+<YBTkx;~6}bM6
zty`L?`wesSoA5eS%&4RUbZS0rti*^#e*$emfn_(TdFB(@6iCiGIiGr3jsI98XUmle
zt#lodL1#Uf&!B{=ujp#WH`RwLQyG-WZWqeJ^B~Sd)2+BRHlZjOtzr^1zGCB~_6pd=
zZl>{bT^_tzQs>d+v6{S~;teNen^p(l&l<rGr5Lj`bs}D+Mf~|QB9%GOV_R#IVo^Jo
zjmd|(fj1YXQy&E9(0QB6HXbZ=^i3--Prd_b4t<#cu`WQPN?JUlg6lX&IZyQoTWc8W
zI#6GIH$r~WPna}&#!n!zjRjU4EBxpwdK=CEvRZ^4s~kKlV{(L`l>UmJ;!Kjwv@^|J
z7p9%Fq9ma}fqpZA+gp+l%qwA!SK}z?8}O_ne$@<*aeT`+4jM6B-jcPV^5MNOzB#rh
z#}xFgK>`x8puwOdWty3;5}sdXCZ`?Zw2QIb4CHRUKi?KQ+O2FkT%Pz+E>0W}J_11^
zU&_K>z64mSsA6kp`F9n+cOc}oM5JH*XAIIIue!5H*xw-QOmT0UPdpd<HZ4?Wsv<eV
z`9(o^6GXm87$(`ZBn~L-q0hZs|FC^995qTyq={xk0ixKHxc!L!a5VDJ+?2G#p)@X;
ze~u@|FfJc-OnFE8wX!&V22@&U1rw%gToq^8ngLxgZKa0DQc>C^dwWf6#SO9O<bh^}
z<K?3(OYTPCWYSIR<d^vHmMXsRVUJJ1$4*%Ek!4$*JKxt~;l)4yib6jZ?Y}f;KP3Fm
z6#9?4Hh-tk&n4MEjM-0S>@Caq^XUG6*q?a|^!^dE{DqspTHn8M8n#SH%I@vx$6Lxr
zdjL4u`%N1yRe%GJkl{qqF1x7~I%gi=xRQu`DC+4^JV8H-4sT%FcbjQ(<?i-maO*(q
zmDrktE|`GlP;w7z47RiXhC>z;$O_Fd-(=5;M(B#cXdTv-$0&7FDR|^^{WFKPT?!vD
z^J>q++QH|@GvE0;_Q*XSXIdGNj~_o)kg5{&#=kF2@Q(q8AI0s9Bb`c}&^QtIb;+t<
zAs1BUvTlCWB9!lObeI<n7=aflZG>(9+IsU2&dou37CntzpjDqenY?t-Qz@+bsHxlx
z-O4Bt!E<MX?%WA~rhA7~r*<H{woOpynh$B#X7%gVx}Gy9m}=W;Nsqt;AjTI?t^0<_
zkGAF5XOUsBhGNNlk&M>?t5Nh`yzG$0X%)CztOHTIz=&aIOe2FD8K<ib4aK5YkD1aP
zojsseJypdHu~<gFsqHr3F-CJdMiC{louoR`+0uij9&@3>6A0sdD1hTle9#_<{jRNq
zIo`fN#oL(`Nhb&w#vNH{|8f}TX7*BKUyv7J8HA6tiNP_YjLs!)H<RR3&L;nTeQ)Ge
z04|IGAQNcLM4{}>jyb-3s`a452INyxmlJA73%N|PT)_~WWPQM=8y<t&9eoKgpdp|<
z)7SITS){SOJb&{<u{jgA3H(W2{#Ws&g_AvW9<x;Dw7DW%bH*TtN4rKwh&1`KPwiP{
z2q;-<UocFxf!Y&Dkl`2jyl1YQECukvW?ZaLf~SEJbBf7bxMI~}yu0nujgpX5N^WI@
zpiFkrkoi6(V6o@QGd`8t_%6o4Nkh!5bsUi-RnXTG(5!JEl8z;s-e)INsiju9s`;cv
z@2Y#a4`BB&;<d73@D;yQ4w_|6&lC^ISc^J8`q$WM8yHN;tjwwomAXV6Rm~35xb$f3
zbI7a^d3NxA6M{IlS@Uf*z1-?Ym#pGDSIX=gi{$%aeQRUFn)O~-=Tp3EGc6Va%|N7d
zM0|{-6Q+hhYUg{zX3Mj{_MtWk@+9MSD--n|T%U!SulmGru4;4&<~?%niwhDwH>8fa
zFF(jrk)b2vGvCvIuS7X{lKFpqsYO7&K146AG>B{agkF!}a^IrE<~Ji*u)U01W(E70
za+M7h9=J=4LC&K^`08xS#dQx`3w&|$3lH>jwDD{D{H@2p^dI#Y{!X8tE75<@=f6hI
z+gba+A%}(S_lE=Pl>c%#f~{W}H;E4dKutvBd~3Omb&hI-G^4~YO^NC#mQ**^#)?jI
zrLln2T?$iKZ`sz^_BawpQAGTfbk=)t(*+T&qFpwOp+<AEoUkQ%(Rx<#Z#+}6ad5Qd
zFW=K$jN*uF$%{^l@1RgZ+<b$R1kQgz^aCm?$mnG4CySOSWTqdiMXOuZi_yKL_4Z#U
zqFz_(ujnD6Ie(%BzHly;sYQwlP{J*YfI#e|-C%VAq*mz!5>{sfwm~DeVEJraM?Kzi
ztB&N&8fwnkj$oIUaA%ra)YGAG<Y329Yh{*`21hYe?ACs?DKQP2W=e&_Q{sl?dthw*
zxE;zBM<ED&b|YRcu>TD=VITRrXhBYUNd#(oi^UhZ7R5nH6t~w4_B|$1TyExE+r2x^
zOD@Q({)lX{+-okRE09E_oYZAO0y5cXb<A9Y@$R>_K*{x7-em}OLbZL#4=>1B3D>2B
z98s4oE<KJtH(s{!J)jQORo%;Z!^d)R#$PsYNXeYEYYCchL@nu6%DS2YACsFi`GLYn
z4sZ&|{ITbtE_w^<@X@6tEDP60?u;!3K8p7ejzGVpjzim^fUBZuezl&}@4VfZT;G?*
z1f`pUd5}Z!QQi-v8ysbvyA|?@#X@QD-)XM(9KSVXfk_!uepXvjioX4lbE1cw`0YgO
zZDO5>q1Mka{lt}8s8__P=nziTQE7{HNzq|KRSaf4v3htW>3Sokaj16a)UP(jz5}Z+
zHUdFEw(c~05nN6^hUXy3gC#Fm9GL7-q7@ot$nkbjC;j+ZSJYqWDmp2&?~8c1j56Q&
zixxvlLP&^aXAulX7Lzf0KXFFY)D<uh{Q({W@t8Q3O^sk~gF|5f(KH$XB>J2;^8*@R
zek!C99|En28wLfU>$F5D+9V-({K8uC6`6%t{P$V<Bp9%Wu@|%Aruz4xx3v@TQJUa(
znN9g_sfTt~e8MS|ZZ*mIb2eX*%~yIFg0y%xTMvS7%~`!ma<9=D8q-c+K7tG5mb!{V
z<xdsGz@;niMOvbWcmW!F>SX^N6>n!g{-Lv9qT+`V|H-H@|L@ABAIpEQT>7mbm-%O}
z^`|>wq5b_J_e6Qf_ASU=d89ydf-i`0S%8a8rcP;AwVx0YQ1)=vC)9;jarPID?Wo{|
z^@DdzOLm;1rtiM=ShI^fx8SrrH7rM7klhbbN>$TBTioEREMFPFed-U*x^bXyO9l0$
z9Y{!A+xnbvwitb;DnC|}gA0dZ?&m+!Q!a>1nU9L(<G<k>tOt?AD9WpdPx_+G6IO5=
z$SPGL=Z0(&JASge2smgRlOu=Lh6u~6Kd!FMc?QoOoUW9sC|9rMY4<Mi)n#%Eva_`H
zAQwt#kV-c=fyYofB*vGwr7C%p%Z)BWRo=@`B%L;#rIC?Hz5ryvU~C<J9kbL<QJrrm
zx7n`5K0^h2B%ylwV}J>}xA#->*!%5o5L_pu<aZ1+A>WxfY`E@KJ<e!a@<@>Lf@u}K
zghMmBm5^(NX|X>`5e$2uyOrd_9v&EhG|BBuf1!1V>wNdIaT5&>wnQ>eR37<VDwHsM
zNg+P~lAD6JB@>{mt7ZKcZZ>|d=sOS>!8o$QL9r`>sJ-4cv-ZMVDS;K}Vpe2TJs_8e
z_tBCk$`ID2`=FivvXbJdPr__6QTZK@Zmm0+`72O<Pky0Zwvk7nCd1kO@qLiT3BZ9U
zqnc<yGLVDO(3r!iXu{=gS-~x)ct^2HyJS*C2e|xFxnv%N^{Lt`RWFJ0c&Z0setiwh
zMMe11T4zpV4c~<mQc%6?c&9Mg{l3AsE3je!G!-b~vz8<5!67Co@W)7q`o9C~`~VZp
z7l7t{nWdGAr<F^CiZLh3v@l*YG|9IC@EFzt8#m^SA3*F2CpfNu^O4~YI8OoO@|$9X
z$f#!lbdfot-J&3aDiauT0<^Yv$d$#jrNd==Lh#AuC~xa-{r22+{Ow~HroY!iKKEl?
zXZR~B9c)UnQ>yFeO7=6P9`-r)(cEso7G-%rK|>+52+rmN4eP$bFTUC1&7A)`S^up+
z!~7rhXa42@ek}igDeIq2%%8GmWBw0ht;7}kHgJ1#rfgiEjSwaRmrLqOEah$!o!l5a
z(}NBz=!+nXWDUs6Hdt}D8HRwA?xEahmj@E;@#uKr_<z`Y>!7-tWpNY>A-Dwy?i$!^
z+=4s7U4m<HcPD6Y2oT(ZyE_CA?(V_e{kMUf`+fJGQ}3QruihW8>POXXdU|?#&2;zl
z%&awQR=U=dBhsNYOTm~+0>Eh3!atay$c9UOQYbiIx7xzUlWg~c{HahvoEYnoFk{;S
z^&aeEYO;`&-?{#ryr+h!k*Ij_-TJWnVc#8w$H(MjzF&`;kKFx+aDJop@9`kp#XKhq
ziJCZt9^Io9@=&bd?VP?^M`{HeUh92qdY6@@@%rI49rq~{eUG&o$vW2j(vma^C-UZ1
z$mLRmv}yt#lqcF%E4HLdaB;)&m*jyotR-_q#2f_5^+c<v9lo0^+Di6{o{Gvr*(5QE
zhAC(_(-DYidlkxl&NgX<&j2q%gkrL_VCLvc=}OE%xX-r1hrnfcw|*x$cuT7sYI>*{
z6BJ*VWs#eQR|;u_{vQj$UOz_S@y#-XrCr+P1I-K&(!ft+=Mi1T>C7u{T$<pEc5&mv
z{K&-U&LJ=*#dgQ`n!jC0X52yWk4rKHv-r5m5Ic6DaOmfgdZLO6Y+8w{&q^iV06(Op
z;@2>OU31~nDNmgHY|XiP)>;r4J)%p(m_E9(+e7ZT957d`uefV!HKE1z%H<Ty7BEWp
zqYr`S|B4D<g_#OeW&@`kuue((jYSs2_*r?@y&@PnO&3$w{%xC;TDFto>$kE7VEt|}
zkqi<^m9{Z3MmFgSC}@mYWZ&ZxnQ&;6yh4Q&SmyFr4Qn8*T}5A+F*AOZ&A7wZZ+JzS
z{rcRPXviXtSL@^1Ml`xQG94~;@cc+AbXA~#I_qBbBAO?!9rlinq@kyE#`K5`fs3xK
zpKAfN{%9OV2ICC&Sdx8_UZeUAmB1^bW;#UI9gC8XfU;a4>qy)g3ro}A+-BxYKh)!U
zbv?ZGG|8}kP<sA?=MNCT`<3>?PQAER8+1B`!Y+3r)4Zuqa3x)E{5-+<FS^b5GbWnt
zAGh4WYLjcE$VLdhbp}GZIy;~K!~?g|D-&%2BIjUcrS>d2%@#Mb)(g3lQzTj^7>?u}
z*M(IzQI6H;a~T2B9kVR=vJ-0t_3sk4n`qSfe=B{1ff{Ht`zkiE+dtASiM%)*deg1&
zC5bhyI(JcNLyWQ@<w)~O)yb|@*`qO2AvcT^fb46)!=r#li4##;IGVGWL$cY}@fg%V
zYcV^kyOSG5az{{H7KhT*btBu{X0&V0_mZFCqy1gRWh}m4^y11ik5k<PHpA<^XFPYV
zD9zp7CabR44;&L%ZUvP+jg0vNxeZH`j#^+U5bBEmV#f0KmBzoGvHa6BFP8u4nHS6d
zeCG9B{Qo(${p~i(KkoJZTay>of3eO1(zE^BuNB0C&PU8-LvFe(>4_A@Lt<GX*(clC
z9y!o)tcw1yUr78~v{VpGC)bs+#iM{y0F6H+1uovE$)-;8L*o9y%2>r_G3qxzVvYSU
z8ag+O2Hm%HL~F#V`{ffnQr`%s5_zGdsMVuQ$qJhCF6*gIl(Nh34xlYyksh4y4-aZ$
z8)jj`$=rPK=21AI_zRo6rP_)L%WoQ66#DkGPR7Ug@nsKI^DkRdy_<+;kv2uKj?WN3
zLr|aY=)<1HhBPZKq!{FRtS8@QA{@bKNez7asFZsG?WUq(`*prQS|OI@mcaEob!W#@
zMU&Iqv?#H9kS_1KuBy8yp(+k;a#Hxa+t1aIPYqR;sw|!A@zO(S;Df5DP!LsKvLqPY
zO0Rsr>>_M}-8T9E{$$xmX|>bWj9|x#(9$pu&`BXCC$Z+^#b>lckFd6B7)isVp9*bl
zIOWhUtQ&+v1M}x9nlhS3-W;qhno6<Kq=~@LN4p&ytBNv;T@BcDlQ&9gjzNXx2d>HX
zNcIpJ+9Yli_e|j|L2`)aoqw$NXk8^dK%3!iBR-@BJ6@yT`y~Ghg@j-d2ZeKiq1kqX
zepyObtFJzu8;*9!;jA7y;%9d(yqvUKi<|oc+!!B$sL9xQpML{Nh#wMU7Dtu_{U`0A
z%un2M`-qqVUH+(M;c2{*<b_PrH{v1!+5248a~MeAQWd2r2gdUWy#`%g#lwydlg<Su
z4^=<jh|c97nHcwtyGP60%5|+JX*UpC+sxA;oR^wp?ubX1^=VDwWj+34#7^Kh>7hKS
zHMnKrHwXWT3BP#dgS6c5&yKn=COCF8-=nlGMV+!aF5-48h=y&p$QHAaXAw&^xPAgF
z@I5{T=e>K~Oye+=odIg|8_D;u`&r@<=9wqXO<#P3(s@Sartk$2DzZwTH~_0PHxOT`
z4J06#r=iM9tH3)hf)-irv|Y*h4oMdk$-|-GqWCNY%6<83P=7kakq4ZuUI}N%LzLsQ
zvy_CLOGy#0{0eVZ9}G`U^2)aMjyRPnmR#c50-8)9jc(J9s{W=((A=y$Bl#`7=-1EF
z_f^I0bWhHJP&vq^C_+}Cfm<^_2FiZO{CzwQT2)7Ho{X~w+h+ZowF8wb)4c7?n=3qO
z&g<4%AH?uw+@854_=TBnb4J3Qp#rMUrXS6FaQ$%jk?uabaN^-PsiTUk`I*TlQK2V8
zFul=DiZpWvzMD^a2V_#)5tzRUndiNIcaF$xC3FSJ9L|{T#pzgkiJdol&8ykNPxlSt
zc#)6huJaxLf=vGkYb%m(gDZ+9H6VB|RC-PJzL%GJ-_Y!xYXcJ#HR&RPYJxP_><+17
zEw8w+tH1IzjqoLm*(8ygo;8cNH8G=x5!Qll4o)%dunFwmn%MmPZ+N5X%~m8j7Nsc|
z8hrovVavn_s2Em5EM6hDNLmg^kB~nZ`ToVEk@bIF3qD7y|F#xn{g2jy{}frDi~lc?
z^>445{^P)+|M31b>%Ukb0+~S1-2Tmt1p~^ePlwQYT$Ui8lrxkXI&Hl#rTm_gNK7eL
zd9IHAUOz~aab#tyXY#R`5m&t0%;+=<!o4gYa|M@RlTfP&6L4s-ll?waf4!(CB?4Tc
z_DmNa2(C5x<#I9Zz3$3M$IX7fYp1lIVh>yR2PwIU^nsm>yy*wt^4_4WzTRTNc7@fm
zhxu`dge!N$9g8|S>LbQG`3EH)l*s6xaoJzpKjBE8oE0%uIm~_Er)<{n=1n(Yx2q@I
zF?p?Cv^AV?6B)l=T){T(Z27%jZ~Yb?{h&y{CyI%q9mO3dY%f|ky%Vt8x%mZ*<<gG=
zwM`-3NtW~-QcRq3$R$Coa%*=Dz7e%#BL$6`bMTv3Fhv(n+6R@!_RQ}IXkx8COwfux
zWPH3zr{Mt-nNhai0*_p=Vl~Q`6l^oytErfAZ|zPP&)Va^P-E%TH9=^=*Y<8&M^hPT
zxMR-i!=hR<A*DC?C$3Tv-hHx?hbR|zhpSQT3?wxSLRDZW)?M6Et5H2XxwXVUQF3%m
zJi|V@g!}f|4c(&-{lS}on};_Wy{NY$s+w;WZDikZ_Jl8za0Ow@M{buR*FXukvRqTz
z9@UwjSJ=<yJ-QW#SQmc~Ur0o{XUoU*Gjdw%ElYKE7hXk~O7W{sna{b5>=RVPTY@7o
z_y(s}KjumZe+x>Zs2_ecM=h&@EK}wD7MWU=ip2p}n0k~;1g+|;t;~mY)iQMx6Kc19
z*-)5TD;1vCZE4X_JnjE;mc=~wyrx#v%3Fuf0v&igZ)P^eIN){Tv{%Ei`+b(S(B^8W
zzi_u$A$l2ncpGNAq~x$;sb>l9Cx0(`syJFE6w(qiOG~Q{+<;t{YASz?g*!exshVkY
zHja?D-dj?}9^hcCmm#4ZGm<0b0dTQ{L3SN7Kpql-A=U#DxmqynTcigQ6DkJ<^Vw}W
zMLoSU(p$OV{LgB+CIT$)7s7XT3kih5afvI!ZwBsDOG=WZmAF}owjJL(!8Lg|B9L2g
zXb5^tekR_@p@7&u*OsWv4Hn3GFw)|O&giK9Io9b(y>Y=?0IMtz20RRuH}08>GWHS`
z0PPys!PKr@J?^T80Yj6Z{XlE1GUFFDZ$Lv|UpV@+yeeWqn&R9uBV3-k6+>LOzd8Y;
zkeX(ghK%g1R&-`mGGmN;`G|d{yQ|ZcfnA<uv5<8>IVxB#j2SKD0_)i$)TVBca8StW
z_~=aDO;t%KzE#qCZd3EYVN9Gu0|PPe4nPWZzePJ^Re-as2Dnj_bo;nn5mnP+VC6do
zb`_bR9(rvE4oV^X&`ptE(^~*@?6Om^GCB1}39PH`lxurdva??@_^z!RU|QMJN_viO
zU~?A-p&TwF<}e`X_<UlfVd$~;V3qGyD;D>n$o;^r_vE%rDz0JH;P3C-e2Cd4vg0WP
z(rYTuSK7vNJe^uYlj&+|e)^}G_UP46e}uzMys&bV*LQbVn_g&Ux?gZta=0-@$i>2~
zWUE+{;R22%^vO2m6;rZJ(Ubks=&n4*y#(%EZ=iAf=(z9X#3kPdVcbgv=dKfc;NiPJ
zfDTODEE`J9AGP;%v^{O{@^FZTNgo8R5ZSEIG1kt63a59CP(th+^z`*b1#Z*wNw^LK
z?lX5dU};Nkm@&(Cz~|rx*Q*)jG7SS@&5VhUc@RH&TKIHPe{`!=NJ)+<?%G7+@~if>
zN178JlhP1*R}V7-T;$)jsF)w!n`Su5z@&dGxF#emR=OP}S7*A2UE(|)qyx_yS85Yt
zOuVpCSiDZvSm=}Y&ORqCx;~Rfp0_!^$on>xif#f9(Q(ht#p^@;ZmBCteRZD9F0E{0
z+Xu2#dX>hSVMRKx^rQ{<ZR}#udwV%)bIff9R$$u~BCgOEv1simKm2;N&7ySO6z<@l
z)3*ozd1b)*zuxqC9ti&X`1K#%^!VrT>#6uZk6(XV4g9MoApd$7$iKH<__Ol^R-G9L
zqyrK%f$pX<(zDR9K4UMmm-Js$24-eD(1GzlRysC9W)=oIhEGqr1JxRq_0L)gB#nWY
z@c;h)Kh?osTK{ur3s#+lo&jVNc4js@MnYzgbG~3~>`Zh_gp5FT5M*LvrDOO5pE&-W
z$H>MAD)++ol=tucUP}Cdpv_A!GMSkeLH_gtUnp!WPc>izvVrJqjPy@F#0I2eCuDv0
zCsqbV5QUwd2~<CJ(1E*5j4V&(pX<&}5Bfd~AqzVY<d;DD=YLNuY%GjV#o3-1UvM^%
zJ2DfpFtUN@Y)>3)OrRn!7X|{^p2;t@c!sRc`g*DPi|+nv{oh;l^a|38(3c+Z2WMaf
zU6_&iscuiYdZGS956?9Q^(6K`8hx?FpOXK@&GO8_#QM~BCgx}OY@rvvm)sX!z2MLA
zFU$YgNb%HrnLrZ$FZ}<x2L8*kpqG`O2Lg~~pL-?qb02wuY>ZF+^aV1oK1E?h`lpD@
z408DY`C|q3M<%AH{{NK2$^eSigsjhHp3>~k{{OTm`l%m1lV1eBz$ccM%lw7?os03g
zL%qOf@qd%R_*}`q<UHm7JHNkQ{{?@!A`|OV)nDKX<*8|)=W-xb{At#6G+<$S3M?$l
zPl1s2x%WTufzG0P3MPMRCktqRVh27AbkB00YyML9kMx)D^CvVttL^D}pdXMP)bByU
z|0G$S$IZVQ`aiM1(l6HgV~uCQFZkcA_e^~$@rU|+tryB4Q@nV>lR96pXAZ{apvd?V
z>7UK=_uLl+F+X!Y!@vCO&l(*xc7PP}tQ1C8PzYszhK#_caLNdZ<gCvlJ!njL4zT|W
zLAymkoX-YkWqJz7&n4NOMv><dARl7`F#ti!WYE7S`afhdJb5nY{j--VzHq<be{nHA
z*X9MjaQv0W_+PUAxmN!v<xiddwEC%L&n;jCf?SXJ89t?7+RDn#4)TIO?F6+E<c6SO
zhY948Pb2Kpzys=|tn45eOhESM7P5g{lZ}vtl^N98Ku5hi4IVEHY@iMb>VGUx8hXLm
z7}-I&Pv&4{V*m+dV|fbiFBb*^L66X1&=<(U_GGb_x<6_15B9A0zqg2)>1i~268dDP
z=l`G%0UGiDX5T03pE560_9xrFP+qL^T<%%+GxnU%#QbD^CQu1B(763n8&KX~KKAFH
zG^{!U=!Op?0}H4@PZ$&1vv&Spz$YpH__2bzI7ru^nt^6H&+vu93Oc=l1ysv_ScVle
zzJjd4!UD1q3+UbGC$&G>4m3jojlUo}(}PkVS)g1{&jwkT{mGtB`7iQbO8$|}@DyyA
znf^=m6Bp<Q`d|RdOA%0lnf=Kv{%Y`l$Now^iD6;{eU0f^;0wk8a<YFY>M8%ZvClMS
zQ0!uRPP09Ic<HI^vm&3cmpsO2cVh(2jzCI(#{bHDancvQXZV+~{;WV?)fqwI0;Et@
zAjq7o&yz>yr|(38!rqfQK}rJAK#F8wds5E}4!R1+xq$RfZU*viP#k{de1YuDOizyS
zHwrT-Vgm^oK%wJl^1}v#|BU~g@*<fDG-Y~f<I`1Ma0XD90y*BZgctftsXz4RQQ(Eb
z3K~V8#)0Ruf8%F*=3xZY@M%K#G);ZMpE>{1&EFS<FOQIcgg}sn{_&+k(9D&AiT)oc
zkS70uf;<8U@~fx6|NXtAqBsKu4fV-lYeyJV81w@<HYlHl27!q7bSp<`D>zitd9qq4
zirR*T=;ecXj@$<66Z^-e%$;tJoMzMFstc^d?;5J1sz2e)Aflk=8t5Taz3#w(uVl>$
zalm@oyU2t2C24;{F*uY#%!S}IcwK?>a&tR)k@i5HfL)*3TAx%{XUahSY(-3wQo{H~
z2gU)sY4LFaBX%I9ppn;e_3|kTA?rbu>lmNLNP}jnf~a#U2NN_i2haC3V1rcP8ziJ)
zjd%wKiwr|w!C(&_@AbZLPgdn|lvK|W5&Gz^-|Y9!5kVYIPwzWoSl-K;k1k+>S?{J7
zC(*Q_8ANmxp#<u^3Dq7vdu|R_ql&AmgS#9&V;^1R9@ki_E6UIB9HFKM+a_MEL&<<8
zdME8Yaw@=`0jx8$=N?T+)^yEG4XAZ3b>JXM@B8&P-kWTIGssul0IQ(lappLDAF6%#
z1|HNQ^sPMMv?ov_<rQOf?=Djw_7zyF%N=De?XGh7v_?D`k5~nA*7P^PhxL5FV#2)f
zyL&j*Khhc?-IHuHRJy<bbD*>EDvORTqkvsM;|+vcMu1Y8N%ZCdBSZ?+Rl;yBg(H0h
z_AUs}io54`GUab$3$7ycz;GW@3tpJf67;&2`XbQ@ym0jq841Tr@q`r|yil$s2(Oj;
zK9Nun-2*Kvc-3+hvXuH>pb-~Lsmc?^MolHu6OD9eot5w8<0BDW;1IeQ9DDd<nU&3h
zL0QFZGLpV849hJfQ81q;p<wy-p${_AZzYSCdkxRJwqhwyQeOV|54@rR{XEDFiUlB`
zw9A8>F?E6D_rB|Zl^+qd;GO^m1@@tdUiAI+1JVj_AVa{Cg=n#F8CuUGhW^3H9PC}q
zxmMgU0i$3n<T{6sXZRP$a(EHtQn;R9KQA7kA-$2O2zFodD{bAma(klmAe^bQVv^3k
zv+;X0fu4~xQrFw$@rUv|dtC5>BOdJ>eRI}5OcY{m4cY|&mbY^An!ju7;x)hU+5^rE
z(K**+*JD#sMus+$r6FR^J8i=NJ8#Mrs3U8e+lN$9d1Z>89*qZ&bH0Ns&*^#C6JaoK
zF5VnUxC-sD8lp+6bDd5P)VejYBlzJA3<T?7W<2?#A8n_{!_}{RZNlISCT1_Qw`;K)
zjvDk2!ha4DsJkf$lS)J2t;rdsI4&$6=D0GWn5O2^I32Lb%tJl4n-!-vbFKR*eb>OF
zmKyEdy|$UXrBP3i(r`zzPQcBVA1bOowS{2~uhy?G5_U3XMtEIEt(3244P|r{%&8;?
zG2f?BnrhD`N3u5huD0{-CO0M(&G8J(&LBDw!|1jB&m=hNn^lxDnFz}<HCiM_0%hgt
z$*HFDUpK4uvacp#SHtiY?7Kw7fJm1)rtW=3hgDgZ>Z>%6**_r!@VfY{Pkr3KJ2ILN
z3HberRX3s9G#nEx3e=Y2_SYKa^|TXpIR^*xc#qj)M*1M6SUumH1*??(dhOQ9Y(KDT
z{oBMjw<Aw9B6oWi=#b%jnS<pl`I2z+29*y^4I}NBpl4Y8e#T6zwi9IN)<N0Ibqk{`
z4Vf86T}{8-99R}!Ns!`kDN1<t%oMNwC{=SL?@L##HzlD(moT)6_%u+3C1Pd_#-ae<
z-Hl}JCB1H;_xsiRI|?g@<9peaf>?-#4pZ@SYLj>@9W=TgqxA!yZwIC_>82A(b$FVu
zep?9^#baT9@L_N5*`tra7OFpNy8R_Vs>=!X;9UjfxUPaR5|*emz4%HY8u0qSOu+>R
zB+yQzjFCrSWU{$Ox2MKxwwbau{B7q}Twjmwn(H)bL>bd}0oOZ>G%u{DnbVKi=_VD>
zO8<@hM_zBh3H7uH%YKB2)1vd9-xq2*H)LgoGI~)Fo%vwd^kn!J*Y#4ubR2=ZynSdy
zxWrN+Nr}TGj9SOFtzOlGAGd2o;59}9Jzk~j2Z3OHTwOn_$R%TmyQeeU?IZYVuA1JI
zmuZTmox%~h?XIQaUc9Xzusf2+T3UEui%rQQq}=@)l+&^mkKaGBKNilIc6BE$nZUbi
zv!<Is@FgbOKHcOfXp>TdgvBFXbt9cRb56hO4J=O~nL$~3!8-c^!E(FGw2OI=D-)kX
zAe?39u>D?HvxQRZxXa@FX1>d}DK!k4s*zvA)mnH(>RUgNMO-2#$<)n5hbVu}muTUd
ze|M@^_w?)(qpt5aM?%{|9*5Q}L67Z)<LhW<ys5oe6+EI_2u#2EE;cT0`3~E6_-p0+
z!P%p;;xD*wypt-9;8ml!1l05OQr?pMLN{u&!!tr~=cY}mG{S#}E0Y*WL+2@6GOn3l
zrNlxnMeKZ>tQY}x7-7D3k&JP#8qj~1P{(n{+j}p!&az#m^5%iUmArCA2HbhwHfWSW
zZ2AB-G_{|SgX|(<w)YZK{<2M^DRIXN>NBM)jSvNHL8#Lzuhqap1LyIV*HD;E<@*uK
z<JHi4$=Zd#=iw`8QTXrEh%S9i%1V-5D2#B0(Q9(&skwE@$K%-iD>QvIiDI^bzgB;#
zm1cpswrLq3AzLxzhPJH&Th8-qSaWJmS+d5miTG+`1lP8tJ*M%R&?S~YNgLt1^_JdL
z!;kIFPKBhdl$8)OPF!oMC=6U90wD*JB6lH1^TT*KgRC2Mp4Kgks0K~UHkPFmKUILA
z7;C$A4}2brYN0oS&@zOpn1KD_*B`?29wkBVvGR*Qs9E6D6-wlKY^v-lI)&W9!F8Ve
zI7c3rB?%HBIaN687P|N%Xb3Jb#ypb_&*QxB<v+v6Je%EmYXs)}_GI4XOm2@)Ce0#f
zcp2F(_@pG&#j>c$T~>J0i|B##q;4h7B!2_qy2Kd}!UltVo6>8%&`%&j(V-z&lG4e%
zYp!CM`-^sqAtj;E)<{D~2vgHu5kIt*v4+S41&uGY_-9Td-$yLSo!E8ZYNoLi^<8l)
z(R1!(N$%=Fnrmbj_WF<$?7O|94Om%iH}|FuM!Fh?NwW6^dvaMHXKa7%3ZqR`%^Xp$
zWI6YPi8z^KmjuN}aSBv?%Zb0eMH!r%IIwC9FY+bNt$v#lj{A<>O`lRzbPl7X9P#%S
zw2-obtNBkkFmN~;@sHUV`0ADGeZ=TAoWZxgY9*0I6ZXcxu=}~n&{6M<)u9Z>h~pbv
zBrpLPeRAtRY01@*l6~!dlr=W~o>ZiAd(&J{q!`w*(=6-pg-2EiGT-hHjo{=F-{;F7
z86{Ew04xmLC#o;qLBp@c-=BD3UuuaVaFiHUmzj)zfZY*>{DhM|vHBYkufi0+C97-2
zL-oT=`eE>bGK0!!_40jEf}yY?S(4XIqfuh$Va>Ww$}}yeR_^EA_MatU>!^*YZm$o>
z78<{HHuYX^JcI?1%GUC!*=Rai$VJ4w!w9IxByR7P0;<gG7mh+Tz~`dy16|5Kog2t-
zYd6m|8KqY^EwH0JKr*-qbk6uDjUnUUgs9h@BmNkUPy*a`pZTS5X$%fAw}TN_k7*-n
zg}0@L4N9bcrHkYwFqj8+82wO(Gh*QQp+P93C*Mic(qWK5b_!J&NQ1Bx8mz0Q9(Ejf
z3dkK*DC=Sixl8h9{0;i%Hnd?we6eBZSg6w5^E^zhUd4jZwGVFn?|PN&ja^A%zvHzZ
zj>~h47>{wDyT#=Qhrd(dXM?7)9{SuYZl>QF;1-lUia=#m0@oyXwOjK!B)@?PuXA_}
z_sFEMbZ<q_Rdq@5)HK3)gU+~h(?2H!qS>GH6_89U&R*v`O5iue+U&_CF_j6PVl3KB
zq0_y5{Ymp~DLkaeR?D9JP<0!ZI~mPjn?k3YW`EWkLAc47fKNnYfrXt3nWT<%byIKZ
zXQO`TCrgau;gQzfx<RkGnSIa^l^Z<U3vxnfyoa7Otk<ZjUqv{^!8z{8keX{OW?e_{
z;T=!Sbt3t+Rd7rO!4}Oc&=)$~i;abl>E>&qxOAS2)}?bs9VMoD9p0XOO&#Ux(JzA@
zZx{8N6d0OGKE8POvtH@c$1#qSBN*n#>MEkEL{+`!s+Nu{rwa7<)Y9Ttc!*$VHYJBw
zinnm2n({xY)r!CF1gCT=XTE`mTx^Lppv>nPUE63($$sr{(Xe89-J+gfC@oETuQa;5
zjk-i1iE(7wIjQ|xzGSWGa)o!QC-1YDRU7!y$P6M^_^!gxZxs?s{{Frg>D;$wb9#R0
zkGwxvef0^bjnSP8>1@osS(mRcHtU+3=IViy<p?_?uAK3c_xh6<Lo02Yu!WLFK7D38
zOub{KM>cp5F7h3IS7(gHJE7f7!JBh@BJXk)<_w~|tBR3Ht#WMq)r_;0)}p;8U?Yz;
z#md95cC&qnNFb-QZ|i#cR1)(hi}#`)Lyk#}^vyaO00XlWZwXr5_Ju;#hWFEuTed}5
zjma6D<%<a^wWB?IN-YC_0HIR0@0VRn<d8E(qXanTP-n=PvDa`1YH#eh(*#)0$>l!%
zm@sW=?wE?q8G!;l|4x}+W0*%Cn-{ii!CkE%;c}**`I7y1A5n@U(b`p<$#AS4SLyJf
zy2OD8fMm<$@>y~=X<Oz@=q*?K_>szW)49o#qTNVzf-N<PKtn$&%cVD;VHnOr<)K7j
zFGWj3`en~+?9^bL>MMU8VclGDustGnRT>GbCHUnEechnNxRUpTvmzLR*a;@8F>p-*
zeYAJk<A%3yN?<G2t9w0ViqvXfr}NqipVUu9D^FLGu|nmrsTvD;=xHUnCd|Z=>6fo7
z>c-2a-C3h)GJLY-fSfH-Xr4Iz(C&UeiId$)dPM!cG3+qGP>pXHLu4%lj1sf(jX_eD
zDK0A=-8<!4-`A-NVIM^2tQ{GFHcZ;)gH7L(Lg^WKrzG8VZq~h*fB){U(AbkECfL<n
zok$Rc6No7Yo)4*)#2yXINn76Y6M~+%?L&?qztcr7o6jOCVMaysclR<7B`#~=zmpWW
zO!wH_YO{n!aTJ9-*mQemD7lO#Zo3G<3)&qQ*qRT#Y8uJ-Zp+DMLa)?;g1PXek>Epq
zozJyQ#8vovlGQHxPq9rjeQQ<ewK8m_M+<3`ked@k{9+PYrt1V4jSl3N1>+1T*^Mll
z`?5SW+e@S|twp6Z5iU_*5YydbGuv&;cZswuwY43T;Dqd#Hle<BB}S1TADS*VjiN0@
znd`|3aIZJFARi2pR__*3QF=~rpgeS%gzwnuGugs7eg4i?1Pq`$jXi6aOazGLuO%%c
zqegAWT-&UbW`5hhbMN^kjlEkrv)d>}bY`VBlA}y(6@d>!f1I7kGe-7~)XMCJS~Oqn
zb(G6|r|iwG*i08}*~F)m6avZpRUzE)6uGhH{VCY?TsTg977j+vjEIF=r-<G@pEpR#
zLA}8GURoT<au2$AP8MH^#?roO0z`(sO??OHF83~b!Umfq2y+Gm^hEk&2rHz7T9a-G
zQ&x6N)lgZt3(8f6+~mXK6U1)<Ulw1Lf8iZcThWX+_^t9m-lo9)Ad{QegXR1XWmGq6
zXzjyDOE2v2@SXtYPMwb|tP;)|kN!P|Sw7ZX?*VY!7SZbSV+U^;E(2!`olVww2l><4
z6`}nHBi5xI=i}QGY9njl$0x#6E}(-9SIXX^s>cmAolLyjgOm0!URoOI6H+xIoRGJO
zk}pN7_!<eeeczDXxNIr>-As!Jo0Gdr=m%5eb>&t}3l}g>p^B7-+KmL&DX3*01_}G1
zDC_~~c@+qla6W2A(g6#}<>1b3&!yPotu0*@x}5DUE3ZVSQ1W7BfDTi{OCnB3Ms4tr
z-?QbS?`^i)>z1Ff)-(EW)Eh$S(;D1{?;xD+ZHTkh9bgr5PNmlXwNbapt^^wZ-r+pU
zIi5V8-djL$EYGrSG0Q_uK|Rw~1fk{46rY+`o75;!<~&fq9h+*VUNbmPej?!Lyi}PP
zzStjHZJ3m5D>StN*B!RXOugidGZ4bzi@I!bt7iN;O(J_Z;AWFYwU|-v^i$0eexuY(
z+<Va&q&q|D1qHc??1e--V?9aZ5JuLp3;)6Ug|VY|U%-A**y}hS#M+=gKx8jm$^w#a
z1U{z|<9++aq`sZ~5ThAV#lyB9$}g=Ej({UJT<UzDKT(H90)y__r0-&2Ay&s+DKsBf
zhIX%`fJb+qk(=)WOUi_(#<@PA(4l}S+0)t1KBlwu8h$;TUVVvf#oCZY4AC<O8Bc6G
z=?K+Y<#I6NurccG+u%yVRqr6~j$$iG^}|F33Y|nT)%hZspZrde!}KN`>axn;vYZ5N
zmE!lRBnejQBIgE8=<Xks`2$eaiJZ5@Ir0kq4}D`Q`oI6s7ko?5U2!|v%pP9^gOaem
zRem_u5F4Jw?yu#|dvMg6G<g}@W!L`>YL~yhz?M`xv*Eia_Bo}8?Cuhyv-*lwx((Fo
z;T8cuvt59Ui)k*k>eZWLUhlD4F|yP&1i$SOi3zCVMw$}Emd}BQX*z~3Z?<I%#=ccJ
zW+)eupWv0n7%$nxp9fwF#u`Nzc9GyVlJTj0SuDM0AKag#krZH!w8;(}0UljvDs0MY
zO^sD0hvIT_B<`Qifq|co5iP0B4;Qra=4g^^Z!6_E&H%@4nx$)$N^?iu$Z|fLwt7$*
zfZv^r0gCtzLuNJOm5`Dm$jXieXrc%VJlrz6Hsj2B=-x%U3(i&dF}Fx5{^(+n*cYMc
zP;NQ5zw}O!qc#$>IT?JV(c!LPd~;=sOs0?=M=zeYKTZ)c7!4VKe9C3-``b#dzf9<@
zr~0JjZ*_X^G|`!A!&)dtF^I_&GNMgz169F{1kLN8n0#V>WK6i3C|6V}Sl~&i+<s-4
zBHk7kcFq3L6{W#Eu0M8ox8#t;^~Nq3<vL~CZHJRIsncb=M(vY0cD$Bx>|4?D5)cE<
z9KQkJXj7aU=~M11H5m(UYGtI|I`+$D1%jneNVl?9Z3O9HVA-41u-38@$vp~6Qm4%Q
z^QfF8T6`{)1rYEjow+I*j9VT!3~&N;*)rZ{-&lPllnXNqVu2W=qMthN>nSgk<Zy{E
z$wT%3g5%HCG}(fjc!w9>D66jE0M}%J8qZ}<+sN29pbGbnLT(Aw04lPBH$=Fx#oY%<
zI=Qx*H|?Rl9#b(WX(wd?&Ny#FAZX%(93om!itu!LW~I&XEet?)jzIXk8n3>VyK7Q0
zfFx)a<x(liy<E{<u5ITo>7pxH>~S<u__qB!He2*|0a|sJoi0#T#OKxG1cNN+#w%H#
zq)c0CcMVhc6`SJh32mN&29pB@K(z#0yjlJ!+<?Z(PRDre8_-9_MUw;4J+UopaGW+)
z0^$)0B(~?E<|)0qPGI16&8|D4$pU#V>?2((LxLX#wi+70Pav|_v9AWYz00e#v~*vm
z9wh(vD^e_+I|J52Iikr>uIgHLK&A6{sSL4C;uUv=HDW#`=B)|&zJ%*H$Lu3LM~yU(
zRC=Ei_YnRrnr{BiPh<n2kGz|F4EYiixzi8Bum^NniqP-U<ebB8OxT}V&y}C1t92l+
zSV$MbWk@AcewU$0N<Pji)2xc}adyvM%wNiA)`vBlyP0$X@O#&qaArN)@YGydS*SU{
z<gSshTEWIHGpF0ngI{F4<!v@gyQsIm8a@-T=Kg_5p?IjDy6>{eH964L8P_rs?iGc5
z>MMEl-^>~qktIws+;_YvAFqv*u_GjK7F$%`lyPdy_BT%k2t2s0-%lWoJrHZ7Wyl3a
z2M$cXN%c$%_+*B`UGP)d#Y6aJ*N^k}#6)X=)&u_BXS#1axh2~3jZ2<!Ob=Jl1-%}{
zzt23}eLgu9OdTX7B#3!G9OaCsG72*4PMX0y>^m;1aff^^PITAWr+;+1lwg+9?qPFs
zUB|mGlR8NRbJJKa1BwitP9o3ZJ1n~T^3l51=J`;|`fhFgz*(j7-(=XsyrY@#v5(js
zxuAYCzIpPolKlPMga}ssYsGhnHSwJL;AdEV^Q}ml!mKy9=8Z$_m8Rldsc(jY*IYL@
zz9XhpY`hwxo0hjiRMpd=YcS^?RS+x^$At!8<JmI$)wXH=K@mENAnc@T)lZkhGc->9
zcf0iT$3dg)q(uvkICW1<Rug*jG1q`qNBi?Zdr!puWTrCtlamw4MmJsk<U5f$AhZIk
zkfc6Y4dgJnPD&Y_>*4O}$*h9yHW}PP>YU78wI<*3d#o{m=DQsiMYhoKnXh|kj9j=l
z71<xYYka~&d9+AGUPNg6CLQl{;xK3UYMg;!)n^DuhZPXZ21g|nhAn7&KQi(2I7@Tu
z0I4jKA)sBDY6!<=r%f~|F?NeL;DRU`&{giJK04@+BhI5wOQOb)U0&hy3yH#I1HD@z
z3Gj|q5`JM}2C!Z+&16D?`5imE6)%r!5_4F2Jp)Z3d2t=+el=&ir8N?idK*m1blf;W
z55pr&znH}tXY`v&sq%A00b{6wvtyr8T|{lWTDN2(o4j*~%Nh4bbT}1srJEy6m}W?n
zt`J)t8=0HE@z7o^d=>upcXikJ9Nj0`<Hu+@lawV8z3IIo%Z4P$w%%5g52N^>j?OTq
z!Z%lrg7qx<*s7B0?(SzUvyo=*w;wJXy9h*MOxd=4%9wUi1nIvrj16llITu_{GHv+Q
z)K0*;>6jH8pm0IXo`AJAu9^D{I*xEE+5$Swhr)mh$qz~bquImNSrW1b`1Wsx{Q^n{
zG<SlTLt9VR?Sp^z?RhV#?CqP*<kVJuTj}DS^HaO@3gO@YqJMmIk<$J~#DO2~`w67~
zcc1k{_R$`lfCRsp9riUZ3cw9QOEWiD_to&HiWvUWjofHobM{yEKWJey!jL+y9A<@z
zySIX5wjQ7XWs)CHTVSYCw?8GI2tc(giqps+q<en0jq}=JA5F_r%GNcW{`s@n({t!O
zpq<e-RDjrTJIEJdNzl7s5H9wuNZOjnxA}?83Vc=VTMJDx2w*lTlNL#E>6DedwDR$Q
z8+cWkIS;cB<^T>G*KSxMXBlxF4#CclY@)axX@y0v;=P)4J-UE(qbhMvC1;%ESk?xt
zl5?gcFCRR2-a$|*{4AnnqrT$%HfQRSULEYyy6ZUKjw3Bwit)Vx1KmC<%~OrH>@MZD
z&1S$VI;Z|vsf4Ui)n>8Q&kXK|BkGrKG<cWXX{_5$Kdhr`TIqc9(9xP)zEKL=^~H0~
zgDo9eM|Enl!(A(=3zyBTm)k5yifD`F=QUnox=BLjleX5tSVfe=G?vtA(y)gGS<qy@
zRrmoM{3Xd}9~BWdy;~9eVS^Gn+}&dC=E2+Czda9|=X+%SnFk4wG#nDPWogn(Ygg!u
zf4kjvcl8^0sPIZNdjIcRCr_U5VeQo{MaPSIJM785i;drZA2T9Q@qf|P1NaQot5%Wu
zU<&)T=8K$jO4Mh?Vkpg1#anQ(gmpwl9V;lL+8o+s=LKtW3(usoS@zfW?@>Zl{Vp`r
zE27cW`=xJ$lxr6*S@7MYjjCH0XJ5R*RDd9Ho^?s{QB5<Yxmw)qp2MkX-Jvt#Bjq>J
zX;+DHOU1UDaz74ggKF{Q$VLw^y?20=OR*&ZrrOZ^^4#ooU(Ms$k5C_POfFA5V<TS~
z5ZNnWdiQ8ve5)8Bfv|Vf*#9)PD&SD7D4f57EPD*cv=K-X3`>`<muM?umtf`@hOag(
zra5;LAHm6Y@4M}!v5X{XBax-#7o7}8Xi+WR?VCvzc{V}UoiXzkpDN!`0EsAW3`yK|
z1!<$}^JpYNl(BQz31wZkSe8$=ISYdQl&`@rICzfOV5M#@4;x_Tz1<j<m8{`F7v<wC
z5{KNx)YY9kAkmr&yq+lr#zTCd>!8WD%f5@Y8^vvxlOVI(-Z8b7fUKk(ZRK_=mdL&J
zPq{Qf7Zt+JV<YxYBQf#l_@cz;1D%aP>&o%P3iB44mQEe{j#=5I4B0IOiSUd;3RH-g
z3jHF;&h^<zaP>_Q?^F8|vk%(RimT{dZ^Nd<`b>|%YT?F?wpZrPkf&uGTz7CocChjX
z?ze|I?M6f8IG<h1-`&kw(Xmix)CxedeKm#CAz7EEYwir?kjxUA3P`jOm3Bx}*hN9w
zc44iUWT(p#Q*BdkBN_uYdCf_ar{+pd-d$)~Wkp|NBC|BOU2MGL>`^Cm-^cHI7M~P`
zLvbcHPc}IQ6PS4>Axs8vU8ZEp;oY_~K<OSFp8ML##d#m}?V`I|Imj<aT=U*KVkj)-
zbI5lj@ut_cA0*!NhC2t2)o-9*7r?^V)4Xc8cD71N{iSxCWE!KFou9`ceOQHhrwLvD
zsdk~eau?39C#WN0+HuSRXAzG0ka;TrOSU4dqcl)8z)6g&p!tV@rzFL(dSL44yq@XX
zIC3R{;k8#DEm_k);_{Ai%5>#bVkP)B9V85K+_*C|MmN=vw|+vRQaxyxbShCbU5J;S
zvLwri&&sR@)t(s;)m1c5<jTnLmVTvVmUd%pqQ6Qhdpil3p~iJz(0<^!=EO|C5aO|=
zX{c|mQp(T!*wd!C*Ih*@Esc3LC12xh%Y(-C0~un^4YB@&vlo&sf@Z?tf(>I@WKP9K
zKF5!d{(#j9lNKvJZ;k*k(P@yJ!>rtiY-}g%YNxc=ld>B+iK%YIH}k!XElMXTS~e!y
z_JqYopBWBM{C-rvPJxo|d#e9Qmo7{J4$2ZKDi5Sha$NRl`-EFguwcq+>l_pQjSxNn
zC9H;2xyhR(iZcwV@nhE^llXfaV_{2;qn+ZjGZ=QP9js=_F$1$D7HezydiU<^G4ZTn
zcfxF!=+qVrqlZpi-FIwgr$6*5Ojk^%PNHQIXv@rVyWSwU+h&2jX9Mpsa#2kcJBi5_
zTVD}h3ZKdnpTCvvjrko&QSJcyox2y_ycxRU&SDvy!UCM)SDt+8Q2nwUw%uTgz;K{f
zp85T2DDaXGhZ<jNI~Tvnz5fLi=Uc7exlvG2yl14CwG?1F8X7g;UndoYR*fsm#2YHT
zsX+0UQc^(V);nzxcB$&AS5^3V%s(=`Bvmz9H6V~$@nN`Y$C!+^4}*jzH91B)%0?v#
zmNp$Fzdd!lT1r)c){;B1XBK^y@neC1v1Z@Z$zFu)+8GRu%7AG%t6C>Yq=7F^6+3VL
zcXyw#AB5Rcu9T>o74M^IeAQ#5#T)Ea87OtHh4K4}+h`erOWloOMUNIF6?54MsGA;&
z<9d*xy6fXU(Or`m?nK%qd{wO9jcD?f3Bd+%<ytf}_Kcn~-j`Hk*Z<sfPun)uacmuo
zD?ne-$(WKc5JYO%T`REd88#CDm;D(7=nP#Ik&}HT-QtuZzkpR3miG&lnzEr}Z11eM
zR%?J7c}B6TuMGIh3_W)?y<c3Je%RF1*dcGDhiN=i+Clik-e5(14;-AYt<j=Tb@g(e
z4E4>frLR8~hjY|t38qsC#P-;866V4ov1@kQu`izVLeMo<h(Kd>8!SA69?zC9GkBu&
zRGPEO`REgfkg1uCJ7qyQta7EflI&S~=8JFyNewW3KWgo?3XJq#Eg{dO99h$wN+!Nd
zR#+tYU8`$Hv$w#a*RSGkl>s$Ehb5mLBjdT^OWjJ=NbBxje!qkFxF0uSC-a%KCXs@j
zhNn$0Q8LxUFD1Q`f<SB`M*di4)%rb{N0FQ_uG!G<Zm^Avd&Vf@Qx(7Fi_1bq(ZInF
zk{%K>l!U8=Mv5t7G|MZmX1ApJm@lrvzxXGs61J0eE#e(C`EOu00CW!c15T4BB`DJ;
zgE324XJ7&*T&VtIs=n3wvn4PkNmv@^_Zd4^J4>d*_)I}aO4(d(wmu}qDh|=LJcSA)
z<0`8z+Idk~RhYLmu%-=b`d(5@Sn`(mgLHIttLeJ6!uL&TxuVU}*ySpfft+y5%SwuX
z@=$rGSw3m~=?}WN9#kFtx4&gIG;(=@S}T3KSPUlH9NF8zLsU%CaOm0Bg7QpHmX}%S
zmVC%-(nk!vm&#As)PMO-h_tHaijtoyjkR*PBkQ+aai#P;1kH7OuR&J~slIhq+Mezr
zzety``!x?qv(Z~}0sJ<e9WLqfslmmWT_g0tZ-|AG-mY8nR}0v6|HW~x>>;^C&cbC#
zQxSc3Rr?HOjQ}KsPr`SBS&y@lm~%UzgBPIR_<SU?PM_EkH?hcg7ayy?ls46I$1Ach
zxPd^IUy_(auK6Q|-0{08_h~My<l%iZI>}hpX(DaDWeVJ1u9wv5RwJGl!3P8TKj(-x
zMoxDetH{%KT$;neU?3qLQXMmsdlXAifkS>Kv^W<WMP7GDRE;WGN>!pd-<B6)7jW5S
z^=9yk>>A@#oi_Y0JvdH7=Ss*cW_3Nz<SF-u*|640of{}*F>_6ZR277-Yc%C5HLg0E
zKe7~=!oWdiCX0=ZI<cH4zeRY(@yT#Ft_eT7A6|oa1EFx%tVNKJF*?TsGjJ_7d6;D8
z1nt2_Vi1rMSpem*fvRJ|_<N_m3jO!)7t<W|yiayem8}kO{pI$)IW2kdfeyWl?fUK?
z`GoR9YPT3Yj&%uGSv@)+4rtrLT}BG#CjDf&6N(`GpsGH#Tt#lCkAl|JQ=jTlvRmbA
zGh!n@S8sS9Q56`~Us3}5*DY%eK7Ud+k4`6uztP1fH&gdJ9+Z%omA*}<5fyAP7CFUQ
zwEFl}l)*K!JUdY?>{{E6zih$kQ*QS1KCr7<g<Vz?J_!@bO2FJ`Ywob^C$N(uCq$TA
z$;NdaMmN0dJxok5=0SP^3QXZZiUOP;k_Y9-d%|z=N0pnyLwha-Cj51=2cdP!WbkM_
z*`odNQl467Q=Vz`+ClFs_|m+~Y?FVkvD%UkbFd*qET)ChiVRVXw0%sG(xYozr`T-O
z&&jA6PW90PFXXZAdwXIOz3rUtXA+aX<iOo_vp%3Z`1{eu_%xX9<K|d>RM=P;1c?Hi
zno=)M&?|Q%QTqY7jmPf>J+H}2W;`hzi^bw`J|;@{RohEkH1g_y(0ZFWo3-6lqDc8`
z=+Z$oq2GU_3qr+*>}Xd6=~ZQXx{*A;wiCHIYx+PbxHP*WDUiWb9sAw)U+Xl;8+*&2
zP9Ka9J{bx0WeAzF;qOQe_f6=Yu9`?yb=Oa+x<b6+63H6$FG~_HnjmE1_Ih)3L>}u^
zad>JHS%IKI<1WY+uv_nUdzGYHIld>e>fO|lD4de~OOWc-=?<J3@42^U+@5qD;rq|8
z#a3XPesW6q?j^^ZeGG`_W3~n`|BUM#3P-&3!!@v@=>JfMmks~cm7*c^q)>mK|4gdl
zhb=6@9K)O|6LKbNm8Uz4%7>~#VB(x+e=2Gc9@drzdH=n5XIh=G`xsCe>@*E$FkV3@
zu_ZO6YFVzq@t5Zw7a_`*Sz*u?0UmomiRh$bsaLS0>%E=bS>0g&cYr;Nt2rdW6(e4>
zogU`T71V?u$xdaP+oVh;oFti>+be|r7sL14x6o1up%w*%(h>HAOsOACrqM&@5KZmC
z!{nV=@?^z#&_b1F9u96!VEpk759OnOKSEAN9?t&r>tAetf6MpfV2G!K=mZUH^=wS6
z>@00SJNZCqDIIeILVz-#gq)lRjesP-3J|pGPuNVy$d-`lg@d2p(uq)=mXRJvNXziF
zfgA`rPKTX|<r6G`&sNXC!Va`462vN?V<l=}Vq^?Tva!Gdp04whM+<z)6tmMYGtuL-
zFfucE+EplTXJD@Mw3`|hpz@~>XfHWPhOv%~yn!7dC4djW4-fzd0)zn~08xM>KnfrY
zkO$}hbOCw*Jxeo73lKCn*8%7Q3;>1zLlXzkKTCTXfDynLU;_9IFawwaEC7}OOA7;l
z6~Icz#=yeNz|igmvw5l}z{<eJ#8Mw%ZEtC3ps#E8LbL(c0&EQ&3@iY)CQblbGaXxF
zfE~cj*v7yBVCQHFum?B*90AT$FRBqX0ksEoI>mqgbTHdLA4d$@X9;8mHSlHE<<pi}
zR<?hn{=Ux=^rp_gebz-$w1Gyn<y?0*3bG8JATl|F+_W$?gt%jk-#C_USsRw9FW~|(
z<{;vGB_Y`;k+>+y=mMD!*Vt{{<IVi#+@@_)UGpYN%aVOk_p8RtybcP3&~m@N%m^%Q
z7#=}*!c1~=7!)wxt2T7rG<fXK-rkuJ<rr8$u)t21!J!B@ARuA9z>!gad_+JUB3MFR
z=#8x~{|+-C7~Q)AEwKzRs@Ig*76#r>KUB5N(h;xll`vqu5c^;eJ8MrNvyfrDE=pjH
zyjaHH1v`9EJC)}p1T(FD3$6X;OIsv*npRj$1Pi6tR!dmXC)`Ion=cv3$2njcPSNvV
zjY6jAs4Ix2{<AV(<FZb)l#9KO0eO#Rbca5?Kh)XoK0msOKfbN8@*<gkWQE*V-tzIz
z0RK#BN{M})ng>1XnGh{Z^dKSpM$g+zU5rQvh7#<qgrv5DYaZcq(VK3S83?oY$b-X6
zn=)DFo@%Y(`!(PZ{*{r{k@$y?i<^gOIj?YoM(iE$a`#L2mf){DuC~)wEWq^Wd9dKy
zC{|NFTM`}u;&De|4G=_DG5J-Xw7rGZYvq?&A*I{Fq+!6qD*fxh(=4322|Y+*eF5Oh
zBC80ceCbpkpK=2!!AMVcw^)OGzzMH;NMXRJ?$d9<B5ru>v|zwS?*s6;z`P0{h+wdm
zx^4h|V7$XEGGJik*S;+<4@j_Z51`|Gx7%A*DKXEq&Yeu=T4b=md>+3zB?h)2AO2cF
z;y)UU@FZG%w?ly5zL^o>ne{~wj8NpRIpg6514i=>06=c6JtZh<f!Tq*&m{aR?bx-n
zo(kb6{VSDTlRz)T|KYsO$v58UM+@u`=K2ZFqib(gwyZ^p+g0T8n`KTuLLVfsjCSqA
z$7tgXA7O#W_@zgHhvMS^i`AX3K)QttP4F>*vLFDkr#T7LbP?HqtsvMgK!{KfDqCXq
z?sFDARtOpI`sEL{<6jC`DHs%5xthePy6z5L>$sE4*%N@4`+2J06Foy@%BR`-;T+^0
zP5R82LL${`UiRM|nLA$Nv_oP0GB%Z<eYKezbKsb)V5-x%kL%4j&~UNbQ#<G0_!9Ud
z-Hm}Cz*g!ba1_R}Pm?=E#NReHWQ?{NnEM*SZO^B7=|t)v16!jw`FDg-*Q1-b{z8eR
zM`3yFmWRPZugS-y<0>1TvG!8uxQ|t&nLkDuCDy1W6#{{}0Aho9+eiE^(!9c6>kKot
z50|};2sXm$#9w3#Mre*oZ@T6=UE=!mtZ<tltHx#!s((w5hpXJ!G}F)JQ)(y#IC0G<
z6=7$D<y%5GX4J#2)YeIbu8FT0w#Z;8yul5BK&5olRNF}Wxr!?<)uc<28UR;jl5Q}j
zPoN6FD*rtXe{QQYOyYH=e4yy`?=H69ow0+!p+v234cLZDa;l`5(gk6Uik!qTZ>8wM
zZ+;v&2Xpb{&j4hDqtJA2xch_0*0_=mZCfBbz~v*?mxaYp-_R#)C6wb}`+cE1<ukLH
z6(LZ@h_gi$mFL54#(|R1&p-GG0p|y-W4yz5%h{2QVaTe7Z04_tCnsZ1X_B^51TdQ+
zafvRG#a)YuMjzYX$z=`13iZW|?D5;lL6R;Qp0U%)CqHoIeN+;6Q_dJFdX)=LzacG<
zm<&KO+&6@;nGX2eTW#yr(F~h0SwQt^qcU<x@<Lo(8s$WZW|>z${_3-e`I-D9{E}Ii
zt}mXnn5BJ*^G^EgIgR#;Lw!&Cu{@CwQT=KAb)KCcfBm}B$;8J`ppQf3)+yC+=N1S5
z!WQDwgm8mfBszx{t{yQsypBTqG@bAP5R09H-}}im;ita%a?k1zhM3*`ul}6&{I(|j
z8&_HNc&7?Gyp!hib@M1vJcifm^*zPkEzG5XzeEnrYf1|^3d^S`TSir6d`P<|rfxCC
zp%3Az#4&q^C(K*ajQOSOi>2j}g$uJ4-2=5Z^gLag(b2)wsz@grHl=Bm<y%g{ao>OH
zdId@B+^uTSV1+b{t;||a`R?+yNlGUorUZjK1}R1bmtay_LhlJ=XmRhWleyw%awnO<
z9*uz#m#)v^%9=mhQV(Cfw)qKl9$PrV*b9xvm+hY+P3$&cHji<hK_J5|4tJ5YZ#82{
zQ!r=X`1MmskV|b=d+3{y*_jDR{Z&QyI(0n?Qqk*luYUKL+@A4#3j_B<ncwlBf2dPe
z)%rS}ql6<4N_t}4N&YAs8Va}$dBZ6a8h*F+&_l6S%YIP;qhhblvOQ42i}P?DE5ZbY
za{YdFsm1bM<MM3MD5R!}VpU4BsvAEwOc>Rjt2Y87K59cp_?me-hXdxl9&Q-ZlnHMk
zGh0-E)EnaX1k{b3xvab_Sn983c<{UNa0kEj@V_v3pL!^vSAFJ}NcA;58T81!*U{50
z8F6;$i;Z&3nwY$kSUYK2F~Hp>fG{K%#O~EYw1%E+Uo}i_yVb;FZdjNS-9qRJB^a-Q
zM^&9`VRBsH=9!rhp-4~Zg!n(Col~r6QIut`ZN6*Uwr$(C@4L2b+qP}nwr#UtrPArH
zbam26|DLaNc6M@-G1nXmEWR$MlThUNz<vI_+dIaHaI^}`Nrktz5c@JYg_YH6Xk!Ko
z`_HQ#!|PhK!6H#malxfln=25yQk4a8UGg-Z$`*Mlq+(?Br7a@gqrY@pP<)r+Uo{&~
zfWo-|3|Ns95zkQL5j63s0+qGE9(|@A#A2Q@+=C7$q$*(;H0yN0s8iTeVJF3by*SF2
zN~-KY0Vt>?yG~e4VW@RNs152&_ZLrattH4zq+TD7HS_wWus7$URE@D&!r9(FKH8HB
z2}o=@9z-zk>Qq|ji7oz0H3P93f{5Dj(h>|LkCI8%pv;0b1#sIEs-A>E8m0OAd5;NN
zMYVUhX%Qc8s}s_{GVzwa7_Fe?9!H{1R``gijIaLDOl)C<udsug7~7})s0KTl@)#v=
zu6jEY$f;=Xfzz~udeZJ(8BDa`&cA=?9r3noQQJH|k&Or|l1DiN`O(iYp|s7^+LxC7
zV>U5P@72ZK@igDEnQs*QMKmxUhmfU0h=va0VsT|_*_wHj$G@xZ)UEzx#D6M=U+DxW
zHPGypFznK*&T~*30aM`B{*heVWc2&1O2*>n(2x<()jIUZ#3VjpC|z=5*_i~q1u0Ty
z8!E>;wq;%VXmc@Vtb9?Yu=HcNCu<M#Q}Q=h<dr*`{MneywIe#P{A!soRUR!yo0QnV
z+<${OwDeSoqi*qeUW6>m%qmk3A;Z`E*?IStnX3{lXQI(hou0`o{0*b_x{q@6H*G-?
zFDKQm+DoVN?K4#9Ho47*?|8ZlUW&_q6$!?Yf2dU1KQt$M`l!i<7UzW|KnHK~Mh#(n
zg+$E9Kf<;$3xJn7LqB*Q4a*4S{3}}>DH)P7oNV#yR#-jqDg6N9q>}ldnX<v3lWo~L
zDNgBh7x!1a*X`k>V56O%o<^~=2t$8>eez$wyaOuA%inUPEH+MF&-P^E$D*hr{7v(u
z4^`dX{X}r|LU*xj&1vLFO7p>)z!cSn!;?<4`Jnu(i~l-Q3PX0)O0PWEZ<qb=M`kT<
zF}7{V=dSbcl!?m<MYn(VQ^gOW&43s7)L>RlBN2tNRurt>CAe;G0|^<^t<=N_3<xI9
zkVi067<0=aAA$~)b>kTwWSSW|53LV-Q%O)HhFjuDY2k{P2<g}dqfo7KQOQ#Kq8++?
z5{k=m#h+;>h3^EE78MX`!V61GLQiaabx`J2#ub+z0t89K)vMzPwvR(m)<yH-u$oWk
z?qZP`KcRu*?of<YpC}|41sgHDNw1zUFIr~HMT8DuD+SEf<5FoUB@?=HD7x*AN!iZ7
za;l1P8&+XJfvAP9zy-V!B+{IG+T-Znnzc1PZNiJDdY5FyCPD-EJ`n0Q+ia4u)A#QA
zuN+52u7QPT1XwXDa>u+1U{@EO_M4}FL!==K=+7kRkn`QWzC&X9f31&L=s0g0Yzn|P
zQibG(q=f$sp{9gn038K^z$45aWtYb+v#h9dX4vHp8~50=p0K9>zWX0e!*ry}SLbOJ
z)DV@YT3E_iuw`A&=Xm4iD;^rmA3q8+_3JJ+=SUHP%OPU*m)>Gjg^LZbmB9n)jETN8
z(=2vPE`|icG>8skM2<BuUvy>@fvehOu{5FIS-aZH5m%PJLH@dJ!J0TZL;Ip<5vJmS
zRaR%8Wu$whcSs@Ol8jYJal$qwdB28?H8e6L$7l`N9=Ke6(vEtz#&eve%C+Ncn`fO`
z4wdIC(O;_M*4Rm*5_&J=fKRVl`*pNXHl(K4@8=g*tB|1feHYXeZGwd&axT0IG%<-w
zd|tb75yeBXVaZnOzj_*0>eRkw6vFw`anJ`5wJRS{KC7qm3UDO8jT09S9h1{}(Yf$p
zAgSKlfqU}0zuklgXP;O4CnJW8tZ+;wzmV6Psx6N4^60qc1|{c%<v#!k7fhv8FD@=I
zOlch_(?1|y5hZUfxTn>MokM1*=66Z;`R%RJ_wL`H<SL9ft@Qvw`?#^n9pK#Wxmi|A
zQ`@~LP#L^`S~o4FM%pzyL0Zdr@5nCK8hxgMISKZNdjGhu&QqUxMW*XH6Y3c+PsgNf
z|N4y7J7`nE>$xHD40NP%hMrv$lQ+fP{*5V0l0yM*Hr46tJP)r3h>JAZ2WEi3eRj1}
zH6r~Y(ZB;Q|Nhq9(P7usXx-^G@mOsX1M|i^<<muL{iEOz2mI~jQ(dP0r0P{=P!)nN
z#e2K8c&9vI#noosc)c;j>aBsmPRtH46-LlAe#4nwvf;8PM%!BAEl6^**eKIu38p}3
z+i_nPo`X!9`_`kFG9-0_Rq%4swp*%OiO?`}3hb5F#Le{A?qD<XF^~vSs)!UcP6F<9
zc>2jCs|lbsgBlqgYDz0krm#&SS+5fa@%jqR%oR%{yO76<D6!@<NrkJp*4;YF$4MiW
zSW2P}f-B6&(rAdeReQYw@mxW^LaKD6FZge0dd60ygkM#a&KT7oKnuRWXu4)N>7RIB
z2`^Qj+f3T9v*_;a$tx982F<fIjGNk+a3zOGkdh+VL)iRQv7>qnd1gHai%0!$+c~n4
zlSwM4?)4WU&WGiKTxjIRlaTDZqztvSqZfKfk%eGr?TUe{WW&6h@BU*&*w_ho#E{Je
zkM+z$<wM*q0NW1*OWy*;``Xt<Kr5`sXJ^exOM^=oE+tXeFR+))!7k*G;~LB688K}|
zmV)335O;+bbk}m%nbhmriS3TA{c4tm_L9SE^aUJLgI>A@CE0-nLMB$B9U{h_TT+2f
z#8UMp)^?6zUSe0mIwBi3rOL1TEQOeVLwE1(!h=jfi$%@?Y*@oY;h_?=gO>~mh?14F
zTrOCkJ9Q|^4pbxO&C||uRG?JeZm^(7KBKnIVeWT6;#1xP7)02v-JxHN>m)G`p2i+M
ztF|5@DZD!o`^de*?JVPT=*q{XCicz9HGd!DoTt1VU~hf|4ZP9KM0HSIUhXJz&6BG8
zw_}-O31wYgbBIM*ybB%CABoox{|#AG_15)w_I5JFzqmvfkNAaTUVSMXqR!?^ZaU`8
z;bMQ#s8vKxqp8jH`ObD$&@>uy`xN%BIZiB!2(?pCnhg9bj9%R_3~TI%UB~yQHai_`
zsuS#&*j@?4MHf-sgT6rX#a>4=1|ozuuOF{3`*Cc%0-C{d37YXxhH@Ihi8^7l;3!ae
zEm3^2L8N|Gu<CS;p*~F<AZxP)!5%)eA+m>^VPt;)eS?gflB)8pO1zklMD{JujWDu5
zn0vV%%S8$_XmTEk%4fSkuN;x`PESvanQu~&v2KgGL#W1>ab~n;D(gMi-vm;jJHN$5
znz?LG=udE&7W#<>^u~+#A?0P-ol%sP0TE4)yU3M4i--`6=r8B-eJ;Y3ggcguahKIn
zqO7Aac13dCTy57-p-jk0@N3w5v`uxQ@H!6_&%MP}8io|1ovbsyZZBw=;ic5x51m{a
zb=kJl12S)l6X@h#K!!`$pUVW_OBlXkI_rR9PrGP5ggYKqo_=V}n$&<|`uQkbrLdWO
zNQiat8U0Lo8q&z)>bp|m+8GH@z0km*ym}PXj&LZgfWJ|dpW@2i-+qU%lT=#RA0Ifh
z0q-7}8=m@JHUyg+whhZ?AVpxzn*}9a)0{?xE#ldkJKW(;343x|G^<2}dYr6dz`mHj
zL2j4CS@eYK`pxL#b`p^uRFlZ$ZrejyShT!m+|4hPGk>Yyeu{tCPB~R8qTpBYM)jr`
zaHxr;faGi{e;;|)eNk%#M|&ce{+BscY)pBT-m+YKQl_P!`W}+1CjvfMQ=1eoCQjFh
znzkg}i!S`7UTHBOb-+h<b)({T|MXgs)gIA{TWS{I^VwYeJ-zE*x|*$i?=RA;Bvb7r
zBSoRhN^N&A?a|7uu&a^s4u%NkVIo=dNRoRyl&IT&I46NWa1c9(gWHKR<4u&)d<pO|
zUVvm|x19yG$K*`L>b=t`Y_Oh4$d<}222<0u40+SSs(yN=%Tckp-$uzE0%W<;P!hn~
zXU<D0msqxg+9Jb8MQf)FMq4P12I6Flh_zjCHVO8$6f(5Sgc7Sv16CP2!#uGGzf4=O
zUZc3#GIa^DNOoV?$&E$(MB2+_EV|HnSfi9%^w(G$jQ)!Hwh2~=1c>-%p7PvRayQ4S
zT63#vPMR`KBQ5ilzT7@>DYA_n62gl#Gg`kk!U+l~UI9`HQW?){A}>{j(q;|qV*zUH
zaRb&CQQo;TSGMC$dhY+(cDmyD*c0C!n<@F5jkkd{y_3kI{=2@qt+^kpnv&?jOcPwR
zh{#bW)s12Qc@il);Uk*hV$q@6HjHCwh})<It}9ZPVFPxcE-{?UP6&q^9#&=jl<<Qk
z2>wAlqQT}pzlMNR$n=rJyd^?7#gVGI>-c@2x0J&{G+c?P*m4^TOGc@NY``*-+t9xw
zhqrc=-iGc;a@HWyXgP>L|4DG&PY=qN=a^2tanT`Cmk;NPItochV8mBc^YG~eR}>e&
z*$rVdWIb0ZoO^ck5H{-iFbr5?+g<lu1j*JDa01adJ2EVuu>@3za)0ZOE0BBmdHs;m
zQL<LZ5UmFsW~a%_Js5DFa@$ZkHD~qAz@cr{!yT>zMHS8D;kF^iFHrYOI}i9wfS*9|
z68#Y{O8mOQawG%BRrAE2oHxm~75ml8zm&DO*_7sN><0c<6s~8yg-u%mO95fp5X!)!
zbeYeKz}-r(FQ_M{HGXT7a<4egEMrJHH2LsCWG20hqg6OU4aPIC4a-}R)efxh*@3NG
zV!=$N<NngzJ?DBfQ+>E3qbDk-l~J~dr)}SOM_iug_KT2Kz(1?aw}aNf{>#lNVW(m!
zF->@fReE{QSOoG(fFbLFEOsqDDB0+fnMx^Ty5`=JcRwS6`?9rX;#A0`({E9^+vi|0
z#KT13Ix);M(r}zzgvGIyoFYrpnG`={xu&jdDp$;2YKt-+_&I1I+`QHSY~1&G{uf~5
z^y|Ob>&^auI-dXUC|^!cLs3KJKT$s8e~<G2?biE8^8bTL|A#<=h5rAa<kNHfUrD~u
zKZY;ykKZf*BlrK4*8gw7{y%X2e}VP?N#*}5hyO1G{=cyI|1??uuYIiS|EDJZ-*>Vx
z{(Haw$=(?l8UB0t&cO5^=kfn2IcPO<#@Xt5!P&HJGu&)hU$dw)+_bRXWW{2Mw&|?L
z+>{7pd)+y`a>+ft<VuLI_wk*!(siog5FHCoRz3@sxr*{ba%q`)nu3|)22gM}F(n0H
z0!B`Rz~*Q#Bbu9AADB^{n!^|a);~Eh1r!H}=H>PJdZ=r>uWRg!2Nu4*;=!hwn#u-L
zE?D|SaR3Uk@rywl326av7cz6on;wNR60-7($gT&STMq=px3+<m|0x}W%!6?T;_LvD
z`Lman4oHeNG6O)AmmW-meaM$kWFvD8ko60f*|zp;H-UO~_Cx^1|4f&@<Od&5>e8};
z3xJ$Qfn6A|J!;tpPxJdvaL_wQqFq&u3S;ww@f)k~E4MK>GO%&z3w33ErIY0!1K`eu
zoL6}LOS25{qm{`$H#9JO@@rb04O>kU6>KwI<quHe8%mu;Ougk#Dv35Tasr?vWJR{u
zd%&-i_)B##*zPN#zoeX$psZ5({hIzmRcdT*a9MR>@S9uyi}D+p{(Be76@zvIfKvkR
zna&5r=kxQLxbv$awY9P~Gc>RQ(>E{!Nbl^-{N(r9#)CHmcV`HuzLo*74aolr-ya3j
z;xdCr;|DM21yJG=WB-dy4$kGL@RmE*8xGt@{t(Iz7**gK2Hi*g650kBb?{3dOA1gp
zgl7mwFZn~D3Q+ij_mM{N8_H`+`IR4=9`Q?16PqsS8wT1}_Vw>!#TNl9K;Z@6$6EY`
z@7duD1LjYD>~qx5+^EOMFTqP}R(<yKX!Xx71lA@WB335f_mnhVf%MNnY&OuZ^qc+d
zuIq(df2j2$-<yK%2l`K9)7#?A2Ykm5%WZB~cI2VnA+O}r&j7stiSLn*_14zl4z~HH
z+OXKv0o|9p`8&E#n$a`554-+1y3d-?W9mz6^>6yr&%C9T0rVHuZ#_pRpCNC?^$*o|
zJ;o>Bd91-pNDRN0Ro*#X=UUn?*~Ob4ZNtC4Air*GS3m5tF9t!~&5?_Gk9>r1zBQ+O
zM?lUWr{`aCamm-YdD%>JL;r4qn*Q-m?v!t6dO9EHPebne;5469!><tkYVVclFS+Z-
z+s=>0oBWR%_UGtJ)-;a4Z}wd%?2N68FN@dO#RIxeR@kN98^Pjr?d9YA_o^W^-XYHq
z`_uddr1RJ7)$gl25@Nm6Yk}E&+|zyNd2Zx1?B2=V%X_V)5&CHCp#9J4<?sE(H(jQt
zS64WH9@pHTo6~}92D>;DODFO6TDN^?P-57!u=Q8=;E<bkxVOGzH~Gs11r6|wXpiaB
z2^i-h?=f$}R&?&tFqhj|WF+(-I0p-8yU!ZE7bb4sJqum4G0(3CGIt1W0b8q_ULF&0
zm8|VQRB{WHm}5QI+~aBmNJ>0@x<p{-^A0vw<1hz%OG#sOs?e}CrTQeQq7qKz@J7%&
zu0j%$e(JeUPt7pF7Wq2e4OXrKp0q*ZQeKPReNiGTwq%AXJNf<cya?PhR8S%UKQB9c
z{~Fkk^hypOS3)&?<gt?ACwZYurk)28SX0`DauK29ow{@1=Bva$B&Tzm<m*iO#Vqu6
z2^zGf9n$1Yl@TRg0ry^9U`5=H=uMNPAMrNc-FKq0&NH#9tHmoJ#G+pY5)suraq%3{
z`{Pm0nZ+SgSI}aHbZJjF$An4wWLHWDAZGQE57rcd-v^cEAhBC~W2MeXf!T|~<Yb$*
zQP*SQe~6r$X^;;4<vWWjtC`V@qbPqFscNB4wnbuEVl2T8x(JH2HLDk>wf8Q2PjioO
zna6D-$f7CIa)HH=1NKbH&<^^Bdi8)+LW=NXf?$s?I(ApY69rV4Y3122j>kV$OWa0y
zel|r_N_)Eb#PFz=K{^<@B&I!nkV38mi59Vo+@nibA$0BO{U+jxLez%baV(PxSy$8x
zz~!9B9I~R~Q`2N!AelD^dX;I3&S8k_-`M02T_!<A8eAabTr?pz6pdmcvPRM$CV!!z
zggzciVxU2!02i$c5+hmF76m9}OyDV$acw^)iDX-ZCNFFn6fYfCmf>$}^6yd3)9#1F
zwXKs(J@aM}Ey7nU%fLd=!Lm@2keB;!lyc!^)xG7j$jjIVRJl&x8OC&%f*jVSp>KyD
zW_=Lkaqt-nBVgM&hg)6QBS}*7zxc6?bV_V1nG__+JTLUBGo<<8h=RsG)TzzvP)IU~
z+pz}6DrFY&OzUEgjb(>}I;<)A7ua+)qSln0qh+|mfC+19WJ7r@?h7lbw=;b)Rs>32
z7T}^Am@6RKx1<hnET*>_r6AbTj>$hMA~xH{7r1-2so@_OMN4`KxSAtaqzzK?q>#|y
zj^)}Op_!4!rGJ3hj5R01({HGWcwmCnRfMjOgz#4v?0PkOFu$Iv%}2yp<!EeN)x?2U
z2yj?UM@ECZ<9j+}q=EQ!E%xJM4NdR~YNDGH<5g7#>}d1D{?s?dk}(0K>L??xCt1H*
z>M#>+)kec_OJF@#QO6)!TViuE4_{CiQBs~>fyO8$LuL&>6eF!|p$=kPutQYTS<48(
zmG^XvY-Zn7D+)AD)Z5%bjP@LcE1+j8gMA_<G<bCW6E>LVVsn?YF`^RqbHC7+>$)mt
zWHOP<utD8jhkPDk$9;D21W!&oT_Ras81Srg2_SvW@Ch^YVp;`CUl8=T^=t5ik7L3*
z^|dk3%?Ku-p5KZ1${aErKG|@MlCD`&^RxL{?z{gfY=DGuU6uO^Ibkg$yUn>zlGqy`
zN;rCVZ)CI!X0vd|&1)o*B#@?{$n_``z=XlHaVCwN%*G&cLc5+$h)mcX57LlqxAiq`
zY@L`V0iBE9;0$(394U4~dI|w%D`jTnUxuJ4>qto5f*XbCLu%#ewx~2fh6*KL!KOvp
z8w0qud(5}FtZ*fl0{H91d@j{1F;~fn8r<wr&+|C1P%n{KR{Hncxc`Lp2|D=D3$~?j
zOP}i6C8x{IdiwgO=Ak=uotmOP(?C4D^mxvBmJi%R&j(_#y6yW|NpWhsUqa8$YrVSy
z5>gE_6%pWPh%ZKxOSsegN~_2Zhog6s9vgznA+El)*_zk<-4(1MiX+#_q5Ni3eH(HV
zg+kI-ZG%X-eI&K3j_2szpo}pt=#==2S?hsvC9Cgc{ooS=cjZYpYVipu=jMJ${k-`>
z9`L#Zk$kIF?v;St8fUeGkJK_JC8<pbby+p95#Q?0LyyP#qW^;A+#0@V0V44&Wo%Y*
zM&Iq!u2A5aeD=ib#sRs0(U_0KACxM&n)P^#&XQs#fXXG2o@{o~jlYhrTd%byUG2<+
zwhm`f<}mB@ShP5i1dZZ1raX!kCYxZ!YAcwJdw3dxlKTBco?b14U7OdXt4)!x%i*E}
z@V<OlkvGj<B>&dzUmF2uQY3WZ0sVW!9)GAw5{hD*-1c!H!L!<m(@YNUFAoRaT7%ZX
z1mw}E+FdD!fvYxpNLG{#P=9c3BOn-Bln^+p4%c(eS^mi~d~F8QcIm7P@Bu3$C{UMd
z)<GhUDEMHGPz7=I1uV!Yr2OCQti50&prgSMUTgSXDY;%`bEXEa##MG^*UKgMalnF_
zd@6h~RceP`+~eyXL5((kD#0n2xRz!W*C~l%QU=-(<3Tlg%e#zt#Fd_p@ikUVa^=Oj
zh5XGu70dIyspTlDLA@w?#cnuaj@U;BNoknKj~H6!+c1QyZuW&%DgQkaaD|~(iR(>)
z?bevfVpJ7Mq@CtLAVjrRg6j*!YTR9gu-{^62M4I>r4GDWVlM60?I%yR76H`M^;t>`
zxnCS_NL#>Q`M{o;>z&4PjqNb@X!I%Ytf)gjD=C!6Kl{4Cf`kLM*2J}raun-|xhcCJ
z(gvrFz&#5Fcdu^mt%3Tx#QDiS!&0b~fgs=#G~i~l-6d3wH^nV&4NDX?Sh3xdBSD+G
zSIKA<rV$QAlXxB`!}-*$Mg$T+35giN0{TtOGE3osOo(u(ghXqAaiCaZjzF3^cSLCR
zv3yzt3YJs&G@8nWj!<7e+^&Sd`P*NC*@=bGx7h(C4RZc~!bpZkVs7$U+&>d%oSgy5
z`B!PkUdkSE!5H<3&Xid|)_=ZE9uQjqU9$jzQb1UKBR|wd!2_`PGVzA&6t)CY`xkei
z9I!(aN@ZqB_|ZAlm*KjLcm86m6$NP=Mx|Qa#CORi9Sdmi)TbS!xM&opB5^J_Z0xpK
zF}@ha^{UBS$l>)+sH1MGS$Gm<;B~K%rs;@f6fmAwbfBoiE{N(bWt$yr?Te`DCG+9z
z^)xX1c4$`pa4(zMW?Y_5D*r(ELUzjU%xHWTYBV1w`F3{rLX*t%e4N@0xVA3tt8zd9
z@4iq@p~qr(-48B2n2Su}pAZx@-59`xYG9H#59-Bzb0}H`$(&iS#%41^I7gxkkYoWq
z3(uZ2Q7!Vhw?@|l_2vA<9=NmuWx1OXI2$h{98b`<hDi#PcYeg8g1PgWKo{FnzL^HC
zI@iD#(z>t@R+=9C8fOn4g4_j|QZ-6>Z%W+DG2iL667-UT7}rn*Sah6llaOH3@8l`b
z)9)BD?|m6I5dPO}0W|QH4^0SZ7X-=guU!tHc(Pii<Su6DGid&&tg<CE`hMUiS?~_C
z<PO7=!m&^bv!fr~-i~TOaaNf*Ef9OsT(!}sK9O`a&5I!R;}{HBfX67%Rc(_QB~qhE
zE)ou#C|`y4xGrfSMh$D;&Ei^w(QIfwXPg&aW+V|-aODR|=l6XMlTy7!3zE%H_0>!n
za<-*cC)$N%F#-5}4)?2@dZE2E6EbAGN;{4uleI+dQyD|~)HtIEwuOb0SFL1!18r1v
zbAM+V^f5Q5pD~ra?YJo;=^qLB$p}Q#BlaEs5#gC@{v8n=5(Z8Zb<o~s#0hrcm8TFX
zB0O%&vj`{SYv6KI5qSLk%YEcw+Yl1U*juqIj2vNzFoZ(@@!(3bq7WITLHz95rcj`j
zGy4{=TsdfU7>s`3E)DLPPGc#yZbn6VQfZOo!WK*%71s-S=NN7p?X#y)00bHtS<n{K
zlUMepPo*SQk%hW&{X?lXxu24|zntGFKuj<Z`O0@k(_bvVy#H|^<}7H>b~pg-c`;u|
z3SGs)uP*JQ_B^1uVO8u*u}^f3H(vaxRU<EOJdElaZMlDl&x7*7;)}sp;g}QgBbvAR
zGcv<&`+UM28OHIH!4qt`-Ytug!^U5g*J-GwuU}A?>H05n7hIj&|0lvc`X(v6=6)oY
z7Bdwzzp!bf|Kc{<c&VA)=@^f6F!O|*<g@i}idlP9BPl5qXmi`<;aVy^(orCwFYKC6
ziKtUWnJ*T}dN!u*YIR)RR;!a<E7(a_u<#Ql3QWE7250pMmC3uWf|pzzLShXK4!5=9
zA(RjrBjns5{F$TmZ)qxJ{7NnVn|<BkTyk$Fw}o=f_8dNr$8(-Va_!J2vbV&2(1<i4
zsXrWyBo588lkZ@222;ttrHs39LgIm_vGjq36b`Zv`aH^EpsCCtvT{juU4~S+-*ufw
z88`}3i!VmGO+Ok9X+;<R^;%@v`>}h8f3Iedp#u_>e+hJamVX8+pG=2pQi~Bab-chO
zi1ms`vV0jAN`Dt&IFJ_3ZP@tPZqYrfw%mp4@_oK1Lc<JYZ{@?k%OGJavMZaSBbJpB
zKljHq{I!iPg?xf)CN`*fM6a}kguZ;`npodX!nXnksk%v*5~&s1{SOw9&}QZHk+2CN
zA(`|hYYYqiqM2C29J=%j<a)KuxtG!gC$;MLLFyp`zMvg}>OyzK&CqRf$sAj3Y;xrC
z4yE<HO<2DQVNLgzc!6I1Bn<A|UlEYb({@r)6~Szda;s!-Ua6?CHkpKhe%dBEH~3YD
zm6dmVl-C&qVT_)MzaLO42owY(chx|g?q1^rONp_>y06xMo;mNxK$*bJ@T?>)GbLLh
z?ny6H`brhja7If<%dz?}$&l>3P^0KD<{$vuXh6T`3-_6-@DFgbB0}ty!`_4sYJ82M
z%?WL{?aa>WrbelHIIYL$K7Tkc)n}Q(<6F$8;)vqA_Fm9BZ}{W45JA9B_vb50NR}Po
zO2=`U^L`@m<)C8~c&`mf_YVb>Uu>Mw>k;(c2^Wo}M_0r`$~NcPcK1nWkG@O&mHkwZ
zRb`g4rn}pF?KZ-=szzLEF?$OLqe_OnSc1Bgj4f-qVmiXYLCOjZK^7KTbWF9rTdR%n
zKW<>Ku$mPgWPnsi(E;<u=U33C)d3%~J*dksxmmZK(FymlYasimIFflfG7;ykV>d*9
zTGv6CKc25Id}bqF*&40CzBvdAo_*wf{FdVUBC2i~RVYCK9pROGnnf1qP`&dDPw6Ds
zTpl2mU`?BbC^d6e-xO##<(wWZxc^M-ZPUf`GvJeeuiLioc)wsRRc#(LJJTsldh4&p
zQoWR8e-@SsXo_oB)wkg-maj+fTV2So^7m5Xn3WWNy3|E28z`y2w*b3SMW2$7Hp>yy
z5RV9i4Iq99FEXnVb2ttoC%q@DCX0lzF``vlA5f^4yr%BR$TZ&eCWplHs#KJ#QJVD>
z1U5l)TE(D0B%=>Z{@I37uJ=+3&<mq}?x!tW!C88y?+mv&U8do);u*}c!jo8QB^=jt
zI8e{Ks;Hq9i%VuTvPP)LMjuh2eTVr29Zr!y)}9o1o*D@0WlD|skp=J2LGxi6ISs*t
z4N*w4aXcZj+7f3HV9<G<wwnUeuRV4Vni@$T1$>%%79`M<duU>QL=Sb&HNP=*g?a#1
z!JGO(WvRy{d?~=+y`YYjZB?Vj#JCyYggYdpuZ_}7Vb~ffd*i6ahW_4cUDdEeik{=j
zs$FsIFg+TNjMI|axG-%(E`?ZZH|~4WPAz?pi#oFNmXH~F7wQ&r?*Gpwl-feQ+p;U3
zB5=S*K*A^VU~?mNEAF^VR8ZH#aJ9+4Iw-gISdu}{Gl_!x!AnxmkZWWh^lpi+y|s~?
zC~o0eGk|O#x+|q_mAD6_C&Yz@x^7&NC;ab^Tf~ps*Nxg|m7ZlpSh^?aUMTqGAw~^Q
z@;xqT;RQv<u@42hB4=cRBfrVQ)Z1=%uryyA8*Uti;9QD7gysd!nQ=*|W!wej<<)xk
zx_{to_H28rfMvAwTnRX3JFafAtH18*d~5rHcJ`z@F`9@G?i=Y0$1H-I!I>LA^}YbI
zxj5kA5Y^|%{=%3s?oxUXHW^F}v!ro%k<<_-VagcGo3)$cZ|QqDk?Dub0FPW3?d)cp
zOnU{eJZkR7O&J|z^4FYGq%cD!Xm-`T+<W3zhZJkp20T!=jlDEBOIMW#WZBi;_rA^T
zyu8b+O+#+CBkr;@cZwyJ2FhnR|1IpVH$FNf3M;*RK#k5ZL6P`QWkmb&XB9|DB!h`-
z5At4srI?NVvP^`YSD$WkwO0&UW!*ZqKHnyIMl9P1#!bF-SaS4U#E75WbPdxk*s0S!
zk5H6=@HnXriMpq=j=P(g@e!<dOK&2epyX@<8%hem-kX%9@;cUI*pWB94Ob}-$3wm5
z$Xw_=^xnccuJK5UxsuVQVZB$yAaRJBO^c6hEdosEG7#nBa`8!@zwD*b^lCl;e4A!h
zG=faWIn>-9KfiiN6ejtfC(*0TC{0==&I7B_f>R-lPTvpzdU;-lQ!cN4Jqj7YOSsSK
zpBo2e0QeQvaX_LTh@fpOW8UCCNf3J5mXlR8ybjWVc&r@mPP<x4_vxYfxARY^T{55X
zt*#%<BjpbY!<kn}<;Ev(Q)sY5ayKQ;B<nRBg4;kzLKAY3_Q;%UV%2wY=O!cQ`jfI@
zx!_EKkHXHLPY$2qEOqsjjyw${p?Dei!LT-6qaV~b&ukQiM*j*)A0g=Nt9)QUt0<l3
ziE--EjZKvhKgM+RG@Y5ql<v(#AK|sb*@5_CK!WYi5@DLUVYAE6Uj8&zTw0n9y!S39
z?;Ea<`k^^@eK{9x#6?rvRdyA&KocT{pm&h*i~GVBme!37yQ29RPK+q{wJ+6w&}fe0
z<+S0T*U~aypcyqUwh$)z{oNG<bRu|i@DSc%@(TXT5TF!K*!a3~8?+Uy-|)t!Iq@S|
zzS@yXJET>pRix^#P96eaVtKXIG@ta5+ny5VZaQk~U_pBEWPjK<i^xd*zi2R%Rny5c
zv!oD;0>e~uRMCl9U2Tx~h_kA~>cI6(lg_-5&Y(m&*uhlGL*QewYS~X4@nL(Gg67l;
zg1~)wPBUlx^Y*GA!A79u1iBl+>7zVIaeaM6L3zcnTVo94-R#f1Ua^VpFshDn1u>oT
zE@;)gbVRI~FMax-eDGb#NCOVUBuJPOvr8x(cS7G#-iMXE4`Tjcwrx4X=SSpwB$<T+
z@3N8o8V3x&B8LRp9(3lC{_b4X9p_JkLrA>9u8LSGY-WRIXGfGH(vKDXjMF<y`2Z9a
zwmq|~M>XY)*LdvlW;<*`788Y`sM*H@tib(b=l6A<2a$`u6s&Xk4398}ZPi*wXM?f<
z?y6IZFnyi^`)k;G|5YPB+LzR`gH3+hC-6T^Ljn7jh}<qotq69R^zTbha64K|DLP7M
z+h5{19XuTD-3dzo@#$PFzlzAMHMDMAc_aQTN0E<k>OL5R6ze%Eaj{@OsWUs+*`8qW
zS8@&N^6|wm;S4UOsfumFlLYo>Y*&e(pVjUVC(I!58lu%ycS=&s3A6&ws>aF~3Fg#V
zFHd`2Wp^#@0^$IaKJgvOhdyqYE}Y5v^p#^`JVBeqtv4{*4C`6@1tchur}3noc4#&1
z_TUGzqrnhIj_hYm&rPkRX4qak39eF+&r&iy>V1;R!TS%v-zYS7dW?4xY(hDJ3zmU_
zT9B)1^ikr7ML&<al}6zQk-D=34$zNdAXz-NU!Bl<f@!elU@^*nikK&E=ufEgZDQfu
zgURgvJfKp|_A0M@gI0qxd5^$P^FWRpi-XuOMu_Dq`$=bM0xPYUvLdiecWrIgve@E$
zkpMaUsM5?QO_y{h1EaEW-NL?&J*YS+_!J5$Y6js1Oo*b8ANT6{sG-VjGh<S!1(m)B
z_BRZeGms~WfP^@?827+N<JO%bd*@4~=h$cNJ$~buxKItXRd?|Eeo8f0o@dh)Xp}6F
z(5~<-cdhXlm^UbfRiN%@z@;cP!S>Y98dK(W0V6H5m~iONJ~Qm!Q!!x({1GSkB>Yq#
zTQ#QiG@gX$Cmoh!mvHh3Xz`-XTrZk`hJZA!clfir*BHU^epkAaBwJC|{?<BJjq%iP
zaOpzn<U>Rf@@%L;j_}t26cb8zitxA=CalzRrH7NALj#`gd1ii=O|fV9;KWHsdd6zx
zgFVctgn#bnt!F@{g>8s`=S)Z&!?Vm1D6l4tDZZ=4jzbWjGS(dw(K9<a?%jilDoEKN
zeYno)(2*^f&FPO*SXV;DuA%T|>dKhr%ue#{-~+YspyB%;feQ3va7Up5id}}>H2<|;
zS7V%tbG%U+N}nJ?GAL_o|3TQdwE2}TIja5*b{_j}uzT^&PH;@5XN)+n#D8T>x@%e%
z?(_|hcVRB=DtIBrTgBWu(>A0+0vA2(<)fizZc7}?M`O^F3(%bMa1^a97>dM3Rg9gn
zV2J2fQQzZceKb#Xrs>s3%V>Rnz{pBE!po~#tGfEnVQ_{(b3qdlidk1f<6_8B{e3ge
zuZT;*x+rk-ZFG%%l2r-)#@I^KM0f-HjK}T^wcdkK5Jccfc~MtW{-*X(gDd8BQE73L
zHR(iC=USN4DISNB6_4;dRL3P^MUqTq5TZ3F-#e#%65|!SG#6{Y31q8TbOr9aV#;-j
zk8Ou;y?2Jo$i&Bmazr_b7cIKnaSj)EjX~E+m{^GW-Qaj@5fTDuTMCUuA{jJGNZrh8
z_Fyg+9BU=FTW!@K7wkw5Bw|3rXJN5rHh3^GXeS9LG72||GN3=`Nk3Vy`cDbw#ES>E
zNA#Xip0wJ_d8dL*1$ruaEHyyGA+F%q(%dTzF=9Ll37_cav59$*8xjmnvGs#&eWso`
zH6ZT2wi;p?D_NoWHrC#mr?$n;1qfW6^0X*b7lag04K|pJRhQe4(N#=JiUWL539KwF
z1ZlaI+3nJ1gX(uWgx<;{g@2kynC{BSD&Hj6hglFxamt$|1KR1wbA@LWZtk-R;8qM>
zQT$5awtd$pZw*fU+hy&cv0Oz)+=SxpU|Vh*G$Hi`QKwyHpTDU@j~Onro>15I8(?D@
ze?FX!O)4JmOH@Cuj#2+ug8~@=Nix*%le=@RK`^l6G@$;f5nDx?FZ3r8ZBd{ai*FyL
z3MCP4FJIPao_^}(9O+%x?QRpKoJ(?rxlSv~1<<fuZ`$GBeXYpOS99%z-J;2#Riq>U
zaq-^@wpLPtn%Nw88>X+u8=YXIOzslLw4qdCrXA@+^eB(hQ2R7<m<>Vp>B8MehYm<%
zjd(DT3}WdGN&3x;C7k5q#@6NE#>N&~jxT+|$tK}l#s5K`A-0(#z^I#y;Y@0RwZ^w8
zTw(JQl{@S}E160-?4=hT8`L3rb&p2mUP0o5+}%5DaDId8kYY73T7OmXE@WgxZy!Px
zvDCe9<~1J-p%F>l!C1UdzYaa`=?)?Sp$Evxj_vRjD07JEuB>1JJ)=s!SuI7Rn8J<R
z!Q_N{?FoSAkV*wtwryW_lty!tBE!gS?t=%ffdY9#n|YT<fr-7Y8)(>u^vuvDGx(<$
zug8qd?iHVk-&vV54>1hbOsYs!ac|}e#~zYWDDv?AITj4T8<L2qi?=>PQqj~=%qsTF
zK?yD_J8BAz_iaM!7+oF5R!g_)CtUwHyVLS}A1$g~=mwD$f=~&$v2^sSpsuV{0dkcV
z-M9|RP4Ac#xx{(HX$F>nGc8!=FnF82jqg`T_A1e18vhJcs4HFhda}~X;ub_6bo<6I
zXW-f^CS9<2sf<Tr%I}k_+$W~Ry=nx7G2Z0Hw%_^i1)FTj2^}QmA|)~P%o0L6S?{pa
zQ~W-$S0p?ok#7fIMjp8P*Uu*i7u37!Jq~}Xz*VmJk(d{9q(pB<@Xa*j9iWzn;%v3i
zvvqk{BFnfFNl>_RInUTJ>O6knb`FMCbu4*<wY>Rw^_wcgEzRsq;+<UE0m9`qxSk@c
zu_8*a<Ml)44A$i2E*~jt-Xi>U5Yhs>l2^d22l4g0?!hW<yG52b@4;ds4w#&;oAt<I
zgXC$Qm2*=PyF?x2Hy0z5zGDi_(x@pq4AD=sY%;r{<6mYY0)wW8mUM{RtsG-XM_UNk
zpZ_C(y2oX>%^dgoPi(Q#8%rw1jV=s4f0t(y4jMjO<rG+-t6kv@5!PS&rtdS=V7c_c
zqFuOLG?g{2`6b$RU&IJRvk_oaJ3SE}t(8rwh4lxMHWI5BGLz9ALaf&m9)HS&r~k*>
z>(}TV%(}doL*%H;);79GZ;4UW!C8|qJ)^;USM2D4aX%E)Ku5<{L3CDu2v=S>^=1=w
zrS^GNX+usUxn1;u%|$IpES-ZRZ~IOmH)R}=F6`<nzT!$*ovCcqD1P9JN(k~{?JCtC
zCVV$MX;h<uZGNJ6P5_c>H>Lnd+69?z;+nkkAUa|(xPG3dRlj!O?(lq#D@Lh0$Mg7R
zTOo=Z@ujhbcovG6Z-J1y)t89oezNzfVgo7&BCTf!Z4YiRKh||3Z*pVEe?@2t@mO4@
zsp2YpN#-F>?YkhL#M8BeVE-tkLO1FnPYB)>hWVn~al*=MkEtv<(^Qn$6#YZ<wvhUp
z={uSy*!s2ud3OJi4%P{dHMuyHK*DuwQGwR$#OnGpB$7YSD9BB4;K#80*-b=!M=-}q
z*JwUoDv5y_WLjO0c7B4HM&M+zOL12&JkR|Sk+)UfF;|vlOHF*X&(%7G!=42|kpj1J
z2N`2|`)uENW%ZgirAsW9cRwlkZ~9&YK8=yZ;RIBjn|R(PAA3Ma39DyS*m~%nGbkPN
z{>5Y`Z^MYyyQZr&>}<xdM2MbUqh%Gkb^|>Sq}4BNT9D9`JITPxSx^ILYcxu{cG2-s
z!03OP&G1s+l$}I=&kxN+;?DxoKuP;e+3l6LJZwcI56#k$<g(K}OdK}g1LaD4AWS?b
zo7ugsj^er0NP;Ox83Ij5pk%OJ#F~Ol<S@l+u|gx+*zhd&4MJSJfLsb=h@_$I)(1S#
z<VZ=3fM=~T{ZZY5j*>ezP|w?2JaZNN?e#RNL`f4%h+$Xe603*LfZ;uYs^N9h;!HiM
zErlB^I5(*igA^<g&cCRnYB+Bglco59v||vP+-Z2QT6OJRNq{kGCK+AK;n-Vl6EDwP
zYkBErdFcIPZ;WcH89GPzXtr6~YRxhCg8Odo!(1PoqmM;o@oPAO9dHOK6H|Zm9*cHX
z>EEAf9ooSWd6z{4#<vKNBa>hC6+S_W^(y)PzD*Yv*czp#PO3%@XClP8G8@8hi5@0X
z1#gAu7af7xL)W~E(iBFQ!Uka#6IifB@Bljm1j~gfTcxRy?_e3vd0Ce*f;Xej&+haY
z+a>UWy;q48@F2Kyi49u_;wp4}6-rM<gKU!k)eBl!GgmUa!OPVHVR2KIZhP=5SX!CD
zT0~^+zF>L=*3PgUM#0BOemvFKrsv1P8|I`NSzlf9yC-cqOQFb|@&x+V1b)a4$p|i_
z_TuKLQNZ)Mp4l)*Z&M>wA1|5r_=HY5XoDRCFIy3s4<27+^z0#mWr7jn3K^fM0V?r~
z*-24|mx_16RoS{L|8>8wY@>!czb2TF4P>)hiNm1JvKO%$kb!N@%-S{~-F#K9bvfO^
zskjaa_1)XJmM9dvC=3#b2}8uybh;^m9L{ifwsbO^@%@XP<dQ{rvIjqWmlckvQec6N
zL9D-i-F>FFTD!PnuB@?w@)Qp@;I_n`Ted#LfVqdjh`lEH!+d2!?V@(?7P!AV*ldCO
zhy(vu<AHzQ21=vDZAF7M{^TRGeOM^ykpt~Xgo<;ksK-F}()MaPqi(30u6dg0Y-^0P
zIGqBVXo;F@7*lLVMDNbN(>Z<EYNJi5(+yF~_-L$%Mk&m*k2jeL5KSY_Phcd%qsh6D
zDMpVKnZo!gcB(<SG*A7fQa`wilMUESFDh^pIzn?`rT@Aq411!-AGRXspcbuSV9CHc
zEdnT(6**)O$@P3Y8<^1gjC=oa5xiRu)+sAuwiR2yI8*%|hWs#cz3g*8#Lg&rEC1zB
z9x~nr_I-0|6B42*2*(mNS)@gQ=d%rsoR?$sOPsA)QjRwI`uyojl|I0Nt&=`Ucv#5<
zffm2!dfrq^mB%ZHNQ#mqxLWMQiOM&|VoJbay8rOf#{LOi+Z};CAd1sgw0DPaf>&yj
zBy}kA7EVvs1n%qt$=}}A!KuG{)uqjmZAYcY;CGy*jafLEiTQtIWxNn3^7V#oIePXr
z@IkA^OzZsC8!6g)!}p%v_CANr=m5IU)ae3x*nq(2sY*e4!E>(8Ye@r~5Mn0hFaC5Q
z>|G0R_q{~m6+k_YDJ-ZSBoJ$3rc*R>5z+<=i^`vLz4l{W=c3q~lQPUWZhlEVkKKWe
zpRktqSuii_=Pzf620(eXQK)MNs)5QrV_>VsR$@$kl2Ri^id0-r^}fz5Zztth5Vsoh
zZc9lNqP#R6Oc_vGkOowF_MhLlOjTY^(PnHG4wA0bfUFW3CTHRez@02eCzjP*JYPLs
zoODA$;<P66*kj-+ft_PguzTYrpUz!IyKosuKGXNE_A%L7Vbm?<OlV4PE_Hq|I~t{k
zXw){6&m^i64^ZgM!_idf1A#{!DTS<R>W8IYC>LGs3CiLI6)0nKm0@!IEKJbrGN+k3
zzhTg3;Du*JF&Zpn_E!lJR6r<0T>rZo=co)bg)eG+?h`lMW@x#;bP=*;K+k@dA(~PL
z_}2poTS!!~5skV)p_y+}B4L^A++HE7@0E)ScFW}z!2NRj#G9B|L=9Em@y<xGVqRBi
z(8L=JK+(tIfPAELUeG26m2x|a)@_v{y!#}40<k(&bSgJWgT6B=l90l<UL6^3?QVcW
zt1wY|$>W)Fh&_KRf2z8$$nuci6ac4V)6F9ekHgQ4#HM!%jc2fzWsCUcS7x%dTMqQk
zccXVO2fk)xQ~WUX_$k<PdW+hk&)TK}70(BX64G&I<_@lPaedX)dn%x~N^{8Fp)RYM
z`D^C27t7DjPhjWqIVGWvxw%Ada3Q2}Do(hk8r~{Y)c_wp?6VHNkE~(H1g^5g*Mu9V
zH<q~;wK%_!3plxx7;f9;M6G`C(R!H>mBq_=qJkHrqE(Jz5iQ~=I+Mm(G(Jy3h(TTx
zR}^=&v}RX%s?(i*Fg6nvGCX`jDnIP+>H)Lbm90;&^EDIeQV6ByaY8&4<=zRtGH-|#
z$eoIF>|TJV?TvQRr)cZiTTB+t7g$ECo8jU+3h6?Dp)w9hSB&u`r7%evj%RkmXb&07
z{#kQ4shXYO@j+O%AMuG#@iYoaz-C~v9h^3L48OQT<a$+xp+*}Up_;dXWcn=5{iL;}
z8=e`nLlp@go*O{8a$^d8QSoqZFgv_Gxyt{T?vaghxUtA|Oo#iY0CoK?bq@jJxj~9f
z^kVAFrEeT6HO^ykL-NgWv)m%H$uUi7{H1U+CxNFK9?759uDA>$BYD_GvC6A6>Bcm)
z#xZ3E9}Wv~_udosx!X5WtAK%g2x**o)Y#t_hax0bdmD$`)|K994P-xJ{C4IQ-|BU|
zPwVHK)#B7#*xH>*ia!Ci#mt@WtP~<(L9=7_brUpc_9V`Stp?>R^1k%ImbQMUuLyq<
zfjPNr5AmEs7p47nFP2?!$Hx}sBn?(P#QZpU1q{TeLfGs=%o&8ZMc1uND@!CnQh$q5
zTATrN+!b=sbNUxYP91XUo~vV--{h@j2G!=7S@;dBq#)8y!e|mXaw?PMG(hu!%R`I$
zxGP8d<J$a&3^JzDUH2&9U8)m3z*+-4a^NY1*hb26!XB3h@mEKeMHpf<MIfXi7Z-tp
zDgg#AZ!U6<sVVYQ`y7SedVOFvu*tC>F(tjSS!^pVF=#`Et;ZsNDU5TK1TTxFD59@;
z^M0N=pkvvbV-0L#7M>+v<LHcUI9;xI(tgq&kDtW|!&g~lvhVZx3cS5^gWV&pux<Vu
zX-SB)81d5hs%lq^>|T_w;`R?m6O26ZC-@D8yf6mWG#DMrVIMx$aF=#7S<6<2m4>Dx
zg&mp6s|yLhzhfrn-;Pj7x7u_0j#E*6;Biil$<Tt|@@E<&>M6wQlH2YkAu;Re>5qa;
zs52<0a|k@UFc^JJySGPN+i!SYdY6aDf4D)CTO+WMKHKrth6D6=Rt}|g^byg>j4)6J
z@KKiwVtW)nYCKM*e*`r`QV!-JtVnlDjA+$ajDQuLgAj$m&#pSQ<9<c$;PO##zfFxT
zvr{>xh<TR9RX^LidJ_)*+b>iCIZnLBMk8E2rmM46f^~I+k)!e0AfwC-JpwNGZ@!4;
z1sq^;oIAkrd4QaZ6p`EPv^2bpx5J60nI$3@)EIG&Qb;HB>4vljadx74q~1oUqLNlR
zUK$<jR%%3{VHYP4=KdcZ(`;8G97%Ghf0hpgPpt4H8r#_Z+c(W&L|IOkP;{G8$2>0I
zpL+jF>m0YvjMpQ_$2Ul*-eD$;RxhaLlY*QSYcptz<rh{^k;|YfLNYpOfmy2x1?TyR
z#{90lyDm4b#15ka@`~HNynDy05CjW>h)YVEE#26*udzonbP8Hm@`O}GU231=<hzrr
zA>EZ{U8&BskZ<$o4O;lu4X@~p@Z#@qJ7P0UDj~Mj%HcoFmh_#r@C0#~h;=D%Hb4&f
z$cZ~3eDUODs;mirrpdvDMYarltxt^SSp%=cI)7Ny_Qe&twbgH?-ST-3Q}2WN4EZp2
zLX9Xi_z-&jMNF)Ik)|pa8j={PCv3rQPxouq=%}?W%acOlfrW+n9`*CNg|WjfNbCA+
zJts3Z{HmDpB&|Ozul$qp#w}wj92|FN2r34oY$P={>_?UEuyjRfW&)YkzbqFDTKDhp
zl+&5*t^SA9hD9u}4k9+S;zN+2mVG!y%LvD4oS32!!R8&s_N|@uiKBkyl~CKRP#F~}
z+Vc>8hmUu~w}xMVGGCFD1Y9fUn2BFo;cfR?@!(c)-ct~{f~0HXiE_YVCnJd3SPv#G
z=g$oi1#qfb90~@{MGId*@MK=uatz8pHzso)4{?h0$Nhl;?S}{YidV1hHO6^mQ#1sA
z{gOCra><q@8s$a33x+4{MF%Dw#ep;V7=8pzoJPP54k6EKN#ngd(_VO*2xOQBMQk~B
z=@LaOYi!`Qk6f<;_r3LB6UjNOQA>UmF%2(}bqY*da5{@qpDH8A=ON4ECL5!NJ~x_@
z>8*qQc|@{psWBXV64!cF_->)q0|*cmF2n?;AWO43cs?DX9T_RMo-$5_uav*HIKD5_
z3Ssx)xpA5V^pG>N$rFGF-SF5pdS2<ks7dyVn=>#(HZip7ou%aEIT|};kU)Z|Cc|jU
z;HV&^Rs~BtI*|ANd~`MlrXqW3F(On0?t_d4e{SCJcd^=J#NDSnHG{-Dkw(K`FeVOY
zKcG_&c=VKE*Af#4J?yjSm)dNmr344okm};-k2bIcAGiKFK{y+dbsr8i1vk|L&fBm_
z{cE%<vO?QE=eYCNaD?GS3ywqe=}~r*PUlR}uVyO1O=B*&2*$W;2-V%A^^%E|=gC1E
zXcPyA)1L_ioFaAn&4y^Yv6k828-xIM0~9S}5-qL8^c!hWsrR<MzuEq|4CGA~W_kGq
zpKp_(V6Ap6LbXr6dm14A2o!ZNjlKeQ%Cui(swXgAVeJ#Bo?-W456quWi#}HM-Se&$
z5jrL~v3gR?8V)vN{qFw{(%vaLw>Rt4PO@V=*>SRWY}>YN+qP}nwr$&Xc5IuSf7M&v
zRbSWJT|K_DwZ>TEIk=ybIe+(@*R>uSz}PibuBJLT+$~5|KM*IwUGf9lI^w?Ksme)~
z&9_0@ny^wI7(|v6?T4xBt&PO`xjQl3q8QAdh!<-=%A4oa`=boAh|{6DR!0EBG?ztK
zP+{=eEY<CwNRGq$1D6?^GDvGRB2nE4@Xt{Z?IL+qwM}J(fcv?tA(j|^+S^Vz4w%9w
z>RH;ddby|kg9d#ZOO$2+f_Ja<iwxR*5S51KASjPofK(K=k;pLdwO1Yv$R={E6xclL
z1kdb#nuzPUuQ(pRDG0Vu8<?cp5<5H)2q)~L!QZB{8SWXD8c>poRe%p4A;-*A+K6;4
z=Z{*2;MO@{LO?;t;FnT@sENJ69T~<T9iVV&6*PT0vf#Z=tls>5!KMx-^1aZAm-&gG
zvLq=ixgnf)+M^wH1I6-QLm|1_o#<z#(JvWp;<3tv+yZj^r|AQOaFV26R~rmI{WmT1
zWAdyF?~>CPtZ*cd7|`c_Ws9{slu;*#>^p6fC-`xe#Bq1;2j+IWV=iM&a~~-ME;!#}
zomd-g2bCCVaxSayB9)LU7M^Fj!v2}zJAwTZP?r99xdi9dZQs{QHU(&8CZAFZiXwng
zSm)F!>&*+w38MV&jRaT%{BHne|7C~A<KTd#{=WgtRHQ|O75>_KlKb!YWq&O^{heP%
zL&J*4%EbDA*m|P>kN9Ow|Ge}>|7}tI-|=OFe*>6_{ujVZhFb0$Vx~Z?_}_rc{)SKc
z3upEh(d?ggr2c}MnYh}Rd{fE(Vw;)&*TR&Q={MZ$KS7+?SUB2K+kTVIzA*u&-{`b|
zMV|fb?cdSQ{$=axZ`?B%YFBDELp$q#S;6{i<4O+lf30A#{+IjxZ~xmrG_$NM-)H)d
z4J`U^aq&Oi{+WKpK*#cT$?Sh(nT>blSg>3ls#GQ8ORC^DfT8b4H?IqZ7Zq60iKv~R
z(f?^4dTs#64=qS?wnFG$M?d04oJSEWqR=7#^tSP^HQjw>{Q2TJeb*9o_MCCVsMlwN
zTBjz34i>-#dO-;l>t6!IMx=~)3m^bHK|xgHFWA#5i{3!Bftd@*qo9E2lLUtt1NH+x
zrOdC6OeIzodZyRqRbN&F&6-C}__SCAV&;}dM>fiaK?mr`iPuGj1MAPF56BQg;Pqqj
zkA{s+Uvh5g9UpRVETFS+n>hU-9suHmeC8b=p1hffoNQm{*(r3MldHP;=p%2nE^vw{
zM97$efCL~CgiIO}XYU?}KNHY&gEE(VGI8(T0k6%iUD56Bq#Jw1AJh0B%9xkFc28g0
zfJ6QB!<fDx5;Ria6tCNI<OAEQ67W(axY6FuFr9xcNrWjG=CA>MzNm6-UP(CmMxhTb
zj)7SEH*G_-9f8+Qw(&{q-%tP@KH{=w8^e!2w~nf_eqseacAZ|mM4w6DPzSvmjXBhi
zaOglK{qV;}#y@z<rf&D%EDUxUV9A|H0Lumcv7<t<k)3)=M^XR|%m;wH2H^_^?;@rX
zgN3mt$qFQ6gb2-|Uo*kITv`C^BjJ_g6-yWRjX4|Z;<@$)hXmn?LWhgqMgb>80KWl~
zL#Fc1Apqd}@TCFRf5pVt0SNfCtOD|(Ip*%bL#95*6}jpA@I|J+@|KB3>|X~7fA-Xf
z)w{e1e(~hVBDneTOs4~Y<k9)M{CYZVXrz7SQ3WBvBbTmKl2rmtK<@4R5<WWiA0(LB
z>i$GY`1lIWlucOn<Jm!onvh3A7jCp!25UqZ#CHSfC%m6qSQ}{*m_Jpzz1!1`7hSjv
z>`d+`I4b|1FRW)#NjgameDAvZqnGAC0d~*K--$>+1efe-O=%3maII=>oci2-hr9}<
zu5Vd}y{@WU(8a;Ft(@WZA*(#4^n@`hA@_6&*<V4Um|jU;8VL_8U$-=E*BsHIOjw2I
zai9>SY>UibH+7|8Mz^^kqY`5NTmPdqRXW88_t76{s3V~tlO0!x(XzE}Sl8*e_hy+2
z3FngPdWFT`UM9E2515aC@5$eIH3zC6vT--`=W*@bDydD1R;S6W%N39{JSnlj<>mQG
zXBUS)w`*(JK_1q|`Oo<?OP)^$BwcAKqqjAzwjqbkS+;~W2eDkDV^7|#ko1BV^Zs!b
zqG-)V)uW>76UJEY!ZRK}>pp1-+O26CgW-^=PQWY0mr299?GVFps`07)h!YJO%x9{-
zj@S;NQ{y-)-4Jz~77>LS{Bdct^vJm)6jDrbEL~+N7t4Il*(l}*Hg(Oczz*TEjbfNe
za5I`%Ha*BLuLKBOQF11g3~0X%6bUK!b9^k*@<dy1pKy~4)1{lZX@%iBQPXw1JTX%m
z&o?r==)~uk2b|ACsXTErr|z%EWxDbkPCowSn2#XMAVq#R8hlS3aAq!B`{~1+(VxYm
z^Uq5sY^cYh*u5{|Zy1F$(0iih6mlE3u}{QOv>p@L<s9;;izsvruA}BB4D<|=I!dz#
zp*Q5R)p;fuTk>TcGSc<9foJZaXfgR%K*WAj7=&s9IrZNvFWKA3Sizc*Maa{H<7%Re
zpAwlr{Q!3&6<W!f!s4l&(zSuutv%V1!DH4Iiy%8-!^!32<!I2eyftd@={i4^M%?Jh
z6s;dZ?S+9RwU?clM_g*i{P})BY1KCF-?es(XH3Ow_(|6d3rQHwQ4J7bf8p4tFF~&~
ze!XgH+^y2@Hd6CH9hm*8z`yzxIq;?g%Hk*s!;aY{YlUX^5q)S5-l)ms9^o6U=gH+)
z)=3WWvDR^dkr8}<M)-yc=2X@(A%y}^yia4>39<%efx4^ZpZH`UkOmZOFF<$&-CWz{
z4UNLN+E@M~U*EOgW`Xgp=$BR#B{+Tz=Pwk~A6QBn4&&qpBwd@XlWZ&v(vxzpnX}2w
zM0kd8L#bf(kkwf!M2@{ui);s??Xk8%x}wqzpk!)p9fh33QlNuMU8&!+pY8B&(?;#n
zSv7GbK(xm4qE&0pwj|Fs9B%F0w1YP1qD(L5X*yT<lqH3Qj5790>Ja1jm;%mzF~OE3
zJIWHnE5D#tqpPHybwp2XOk4RhbTR|G1Si+_ke9a>3hsKqwE3{<2<>o4&SO)!1#sq=
zW|9<o(GQDdJyK9W*XNSpD5)?7cEf-d*sa(VgY7x_d(v?=I}vRe1aqwO$Vj~mr7rTh
z5)r@iHb)2ar6)J^#r}-2c-Ud-J?)Oh!pRESP1t?j4owe}2jyj|sk8L1sWZnzTAax(
zJhWC6f)km&6~st8K_88ti__^OhV0k7{>MgD-a<I_?0bWZbyDpqHtH-DP6Op(#m!`h
zvk5(E#sN>dq)9(Q6N2n+5w%^Cm?L@il4Zx=&fBeq1{Q9kHZI=XM8ivlnOKzfwpn<K
zGo;iM?#mNITI!YHug~vlko9A&d}dw_f7E16L(k;N2>)2m@JVe(L!mD(V_Yh+rK_iM
zSt1Nl%SPMac|gS5Ot5cT7jvS?_~w>bqO^iJ!j7!yxsqi*ns-%YV}K=?fC>xf$ycIM
zR?tgb7+;vuT1wHIJkGvM>~V_MaGX29D#}z6ZK+F-FY2{|c&1#YUe7;yyb&C5tNrj1
ztq!m=L29C<vyg#HlK3Xlf++)C+??~07Lzo#CriVMdYn57&;JSD&^f4stRAqm8hZ1(
za-h^{O{{ZKHaZB{DVdO%`1q}~j?bBjrCMobIroyr|8^D3Xz;Ej(30T3s=#X{oRW*|
zkI{xMR%x!74T3hW!zO-d)z)!;zJ6VPY6Unnm}<Z4f(gjzjw)N50)nuu7K!y$wrKYH
zDo-mB+jmJpZKBu@uD$Z=gYK8c5(WSslR4;l=9i)D4FG1Yqw8XoUNYtSNf#a#NhuUM
zy*21G@T9sxfCF=QRv|$nTs|zlA$glEx}I@d4Tgz1Z7>ZVO=zI-5RDHquPRg!@FZfP
zP^ceEWjS4mU2R_^VZqU1sH2EEv9i{DOy;a*)vOZD4_62Y)YxlX{L@Z!6`Opb-9BH&
z%Ds)LW***El)<Wm!Iclu%RMMZ$)UyOcjH_Fr<aPG_O7NKjQW@CrS_VZKYOxm=OExt
zYe&8ZT=z~ln~Z7vz|oq16}wgR<Uq!JV>iSBZgzKXiUkJp@JvdX>=>4HRa~*vz>JS?
ztFs4yhMn9kQnk1k_vH)U;p5@d^@2+2B$0ArbWhP4l@ch_ql#8-O4^!7NvoNphuJ_j
zk>0GjVdzihnTw{;C<0`AhNF}_g>4nhaGpxBWbyk)e}a0k<U0h?i0dEibltvx#^&=x
zi808iX$zMbiYEAl>7uR%cB;G#P3S9jP>$gaA{Qr<|4gKEJEd8)wa~w`y-sOVq!>io
zfxUqs#v6cl*DMTk;P+e|2z$`Fv!lg^%?!TzPOiAU<OvH~4VwBUZ-M19q46hkV62Y8
zV5R)DwRpd~Si7BQEmzF*Wk!D)RH+s63{s3*0Y)%`aHo^Lr$wt_VKnY~sM3QIeQPa|
z%(SjGq4ifF=^Z<^!CRma;yYHu_MTQmdtuMZ^z+D0N4*|3i>E&0T8$mq831CtS+Xii
zlb$%w>PxvQKA6Je4}q}nYL?tZZKWOcmu30&Ybv5fkhe0|Q%W%H;<TI;>m!!A<20!%
zJ~vdc0Nj5P$HNm0k<7fOx*a&HYO;8_$2R+-#dkDv=|Vr>{9eT*iV3SgP_(wSCHb00
z+<+#B7D9jYArN0%U~-xiUfa@2hq#x8v}niJ?WKh#&~EGEh_iulkY>C=jExl<@?D`N
z>2#$EB_OC{N>%c1Q-^Y4O~vV^#VKCVN$$;fbwqR7T7aEU)3@qfPf_|kDaj(5{CR3*
z?w(OT4<YRszJd^mXtxjgb*CFa1bY1AKCp|L^`jvNxZhw_m;Xln=<@7TeY?+P7J>$P
zwEt{Jj3d<g)8$YjxxO$)=ToA?KY-}t{vsq}eW+7|+~x&y``AL;Sv~j*+%4y5WZ7$L
z%y`f#MUgFo)lJU&tVJsP&qGnuOt=`}KG-x$LIdRMWoMuD;|<8joQY-i@o=rC<vRgI
zY59SQQ1XC6ulO;wM$I~zCKaC(+_Vt7VQ$bg%-xF}N>2_%VGwVaAaEDEyMud}|A_KW
z)wei`{b$d`9#ti*>CDex`)puO_JJL0Y)qG1%c8VSBd<OpGWR=5#wRN@VCE(oa^hD4
zIM(|t7zhyxk9%?qoymo?4@TgZqD9eJ#`TycTG=XpE{RqQj*W{PoHb~t&gC@$D4-q8
zph}q@s40mZ11Rll9<76jRg)(>L}yo5a^Om2xC<xO{g8L3nHMper^*r#(dRXH4}Mch
zgaLexHbaZIIXC%T^>U+2hLSXr?In-zXRpl4k5+YO98!f7#n>5GU!*Wob6*d{i+j&d
zj&+kZ!Rpb1S21EbpCypNk)WH7VyAw20JE`^wf<#-ftcJ%$y2Su#4I%BB;yg8t9a+}
zhGz+HR#O(Xp*4E;5bq4N!IgZmxY`@}>L;dO<?<-gJ?9mDZ$|s<$Lw=`Vgys)z0*h|
z;`_iVCk{-b+S(viH4PuMQ{r&PqmikmH9Bq_%7%Ko2ZFv{OsOg9jDqM&QE}AGUe`Gs
zCR6By>c%uxcOOyL*w#If=bGn4PiWh{Rb_XKJ}7KOn|27PU`xu7+B@FY7<O~=<y`lm
zDX-J)e37V+HMXfFxbbMPDp$%Stqr;fK~GWIH)D8EslitvvVAGL5DYF%Fo97A+mlOf
z6#MzayEiBfiEI3!Rn*<>oTV;D7wlhtiesz*DJ=_J^?n)nvl=0UZc+biT}ivtB`!7~
z*iZf76O@>8A)SyqfSA(-A;tZmt{>lWuvQr){t6f7ER*Jefq=Z;(pj9VbYhR4N3n~t
z8zTV<C89fRNPv(BfXgFmv<J$6x6w?&GXJ8b7gkM{V17lN*ne@Sx=S9D!9yi#&H>su
zsP++y9N7<I^pRdNakB(-119$pCtRu!DQ%VeW%0;V?~TtD?#7hGxU@jR25>&%v%Pur
zH^MyeRS}9)1E>Tl&#x5s=s+}dm(}*13fT@~<<;t_-g2q23YgBrKe8B{-CAs}f`u8C
zHcmy|)vNMVJbTy>t_yRB2{PCCCh!Len&sV_j05+A+AcgC4)W=Mdb>$6B6SzIwHGFf
zSnvb(u?rXPa^}>ntJrss1YRCg#CnJcaiE^ALaU56K8`|axkV85oi+z+7Z=w)W$&>w
zgh4YwW4>>YZP7Vt_I-{Ho~NbOV$)>MMnqX2h`m(`%pv+W8xu+DNGp(|O>PUNiQRo$
zzxwU6AB*~Nw34&r<#w+JKSS|PkhAM4xS|6jeyY2Kv=N5us_cis>8^2ftax;4_diP=
zL(GUb<?I}=NHLcwN5v!o-7Mrl$-f3kWMjU#tVLM@+$)_<6AMYwc<AjBHAEYC7r2y)
zMow*8CpBF&vpO4WJ;d;vvb4F~pR6jS&+uwud(zrn3ouG}QZGl6rXTrx@V{DChTN@E
zIz0r|lCkI4mqVbf`KLsby=o{ll%L_&+&Sgr?gy8~-<xOvx~9l)Jf=TC1pm4pr`QyJ
z`5{zYeo&eCC+IQxy!4o<D}Iz;nm<?bN_ya;g)xc<JSzTj?i22+jlb-F54u=szY`Q|
zJ+r?BCjYmfOI2J@OzAIDzZ~s<L-(O)_&eQ)^_zwBe}?<~hcOr9Ke2uOHRh6}R{oB%
z{!ZdI{4etUH+BCzmimj|^UwLw|DGHDEhhSx+=%X<j^Q7<5ew`8<mA)g(fv2M5j`C}
z-QT!9|4D8X_njNPJq;U%5{ZKc&JNQx(WQHiO3^-25<uVm6w(h$?N#~ZeyLa|6ehFE
zN45HNnOyhV{I>zAK#~~AN73b#m-TknmltlfH`lbi)=|dtUIw$o#+VW>obV$+<mm4-
zAjqgW0O$!znKA&#sDK_FP-J-VUooOVDi|ezISY%jK3YC#K0-hwC@_MIFb#;npy)9l
zex$(E));u^cu$%IkjF26$bQ60z$yBsTRGJE!Nf`6D{-6<c$Da{#|WW5lTVOjIzQxi
z#qdJ>`DI7|gs%$#adOanfq6Zc4fy)v0T;XbS^&Dc<$du2$7n!C=p@Dfp~G3|LeZgj
zcsPJ{d5tE3eoB3!6?s`&Ve$M{)A8(X{^~0D64UpD7})tji}CybGQk6(A>QMGJW)Pj
zy{5K4#EXL8c{5)M2qHw}co5MNfam!{A&`lLaDX=!%yD)5;X)A$`5EH>d!w2N-Th4$
z@J~Q3O(VPaZMFO7h^j8c?=;Pt?e2Cjv@e|n?uixHKpwD+SexI7gYa}+-CtDibmJlW
zqC*HG5n#C$Ksuzz7Bm4jbm#@p0eJvG5MXnFF;g@VKJg<ALJ&PGqAWhd@_5_RrDfoF
z5?#Sw@OymV=iCLbcpP7nBtss+&q#TIz@Nklpzs0S@PWYa1=%sO;-3(S0Kf;t1`BfD
zd?*0CZxBC=fV_6RtyQ(NCEyfg6o8Ru#zc5DMSsdD%E5iXWf}tn0>znd<IwCWc++R~
zuuy={@k)<`%hnYeMMxW2YS;$I_SPdZz5IC9imp;sXog|Ljlz*;<>`0>-lP6H&E2yy
zW#WD!Sl<oJp(a=$m(*SI9J<PXuQrT4rv`1KHVR${XR$I$2cv!#wGghpW>|vtb}9Dg
zxqT@w9yFB-jJ99?(im-yV{CBm|CGxp-DJIve#}5eQ54>@$n*3#=QkC!P5-6(IS3(k
zBhM>5S5+?sBOv@dV84)=v4O`7a(#hnvtM}GUfX_nzz<BOyegz(2PHV8Sa9$6DWQ_9
z(P-~V<9h|grpoUW{B8h5GUnz<)Wf(tcl2X2af6i=3yl~}8B8yrk^J+W#QZx1D#cva
zp}iXnPEClV)x)(>3Lte5E}t=y9QM{IE_fX*Cw(dZ8Li)f%R=2Dk>~>TaR|AmCj09K
zW$SWv{UyI21iN$58_qs8OFPxw`o!0eKXCta*e}(_u@Q<1$e2xBEFQNu6*vYXjvHMu
zB`p9&Jn<n5hn9diJ4{CO&UUNDr`WjA`bj12S{_R+LXvP#PspH3Jd2QGdJCKSi>CaM
zB=WWcosXi6Fm(y)zVt*kc8G6^$2+{NK!Uv6>$WVKNsp~azpkckV^+_!?J(tBW>d)m
zdZ~8L$f+2jHY<l_#3KV95*H`Pu}B-^%I*j<gVrqqg}72%1}P8S0Vfg;f8V)>aa%X=
z50o>oeP6*O7mUymQ<UcH;BCe(B>%+5)@0nX(X^cxuu;Y+Qs<*bNPB}>_(6;cl69;Z
ztag4>Re4#@4Z+2(EQKYClX36VU8c9~u?MD*Cv6xtHu(aKe90!eT3G#{&MQ`2fyWtg
zy;RvlXRMT2;i6KLaM6U4C#-OE++?;Wtd-3uSSfP5^>}k;j@dO`dG1@s69-}#oj-I_
z{=j54YO|x2Fx^c!Tshc_^|)7OBYYEXmR%>+r>37%Vq#)5Lqj+zErSNC3K+<%$<o+v
z_5wAfax%HR)<&`v|5W{S=6rG=<e*n<>xA2AgrFydFpU)cLsQVHQ(Yj7rI+;&OZU52
zc6g6H^^Ib`#FzcCcj7E3CGF)VYsHsuft%Mef5j<CbMHs>^<hckUhH{ZFn$Kg+HLj*
zA^j~qZ8@KH4}jiz^9>HnS+cQayG9P*G<|PdWep=!^HWCO&=#m>v-~Mko6h#@YqT&V
zUydJFAMET;{gtAUJ%VWX@@S5%J$-3eK{aUT`(Vswv#qLqPsf8|lV!(JB@;!Xe(IS1
zeJIE{w~<#piPz`_3ScP%oCDU~<NaZRuB$NH9-7srX`tvIP?i{tMyuMd(&-#2HEd+Z
zBHA~ha!U7Yv7;P4bDJFZt(JpL5ry^4m%RgTT2QSu;Dv;nOAuYbLKvb;$0yYk3o)-0
zuN#Gig=Jl{@%6sJTY^hVBRIIq>ia#RtwxUgQ-hOPVW*EpXToHRnOpVbYgzP83h6cm
z?8n~N2(mL<IN@4a`^~p!txme>VBYz50<(&q9Vsa>vL+L1#|zl#U2H>MCav5bR14E7
zW4*TIh~ipQ<pRs;AgA0eiaAvsp$>Q1bQDTvRH|l~{gQuPob5giu_4V$1#k&@Kbt}3
z{IH%Q>-rj?)=XCmVI1y%(S_D@tlqnwwIY`%HYP5rq?@Y?jltedB7iWbFsQ#Kio2YT
zL@N4P(cKnE>aUa(2s*b6*RJ7Z?Jk(F$w|KUcLG(i_XSbpA41HMh9_+J%cpmvMW=t6
z1H{+O{5D#%COai-Ex$2KM?$44vq0(DqHkSAC~XUv8n>2I30FYTNxri#RO2hHP2S=c
ze8yvqFQ-717EG-G8GYKayzUcj#o{a+?xRt3fU62pZq$~>u3!6xaSdnS)UvwAIytc@
z5snFbrD0Cb9afS^M3<y0<h<_QTA5EFG@33!a^<@eA74UtmU0i`A|G#Ho#77hBjw_r
zEr}5`lty!pZDz_AbtZ>3l5+yA&YH9`USN`t-m6ZmSWf|rsanug`hPmnl+Y_K?owtk
z>V9qU9XoVOLu}BP42Xb&jz1P+z(SQ`JJJOlaEu?1z#u$vk)V5~Q|i|+Ofe1d2pNwF
zI{DPB0)f{^d&LqbbK~BV+)1`)$#o!l54TC=9gZIUI79T3qe_t5WnM5L!KqqOOw}O}
zC=27lZtK(rwrn{%xPC-0WAY@7-!2(pu=hl>^A=J`qB!wEU8+9hcyUkN+Vo*pd!Z|)
zKJE0niXJ@BO!RW`=<F789O(8yf_T7?=3y00w#`ZYCYdHojZ7D0G~sDd>`x4bwW+r8
z1x^N&1E0Ah(;NQAjz@K<{52?vbPl;qWEJaxOMsG>B5x^?5S*curd)|i&jbnyAM8v6
z3CTpvY1nd->7AjZd?ATPl$23|i*)tAs|=AU-+;)kC**Z!HLS~W5(<lv-ckBPFEnc5
zas5SH5{oUaQdz!GGpdsH6xohr{Y;Nt>K9(TgNhhl%vQQMzQqH&f3B5Cb^MfS;D%X|
zljl}OQcRjInr63ozLkgCA_t`5IwJ1*`CPlJE126V6}L!gqZBlwVK{~-YX9Q0=b7E4
zU@Xt6VJpz&TuO^vuUhDm-HlepZ(9~d6Np^Ot!Av;_(lDwB(+Gq<&L@bX><D(8Pbj8
z_jd{507K{i{g4K>F$iZnck~Gf@3H2`mk*A4UK#iZuH`y-*Dq*me|8emo2vRRu`#Nv
zwF&HchcB~KSN0>Xf-RA$^|BI?UnM|xtEwR!3_CXt^z`A)RVfE2ONsi;%*lgErpfiK
z7*>47bW7%#@A$ERlz_bx*!CcqNbX0}oALd{_3U?L5t`_V)giQb&A3k8DRbtEv7C1W
z+~jcNw+fd2_GzOQC}^8paU;gwLJD$3L;G7V?0dfm9p-(@^K?c<4obJlmpX69y|aTI
zf*6`=*cQHJ+sNir0z&i46F;0IBsMS8S+OA-g`*$KM~_#8JD!u1Mk1Z#4cq)*f$T%v
zbJW_zn6t9ODqdJtPRP7f>auLQo}gBVptp*`J!4Up`<k6;)`$J&^?j$QejT8nWye`o
zk57sS6TMjSr==1Fr&8=OigKjc{|H=%(5Q(+>mal9r1f8WbIfjw!wTT8I{0`@!!<wq
zJPl|dn{ODCc?Z|t?2_{ZmmBK4e~^tm#GnOpPiZVfobt+Cf*f0(>bWGE3pjR`5u&%Z
zNBZ!ih8qjOO3GYuOMP>!vC~V-#_8B5&8EM4Pgk;BGjY15u;b0(7z!J^Vg1brrwN0a
zcqkILYHDN4{c(LNfum3Z7{C8@5P+RW4w>mhd;5NzARtywh|tX)VnSWN!&RbpH4%t@
zi-wIQvh{7?yomt`->!vPcbsioRdSkR+tzvw`$T~`!3s_9gJk+KYm_PG*@p|uakoti
zfi^VZ%|)ry2RG__C;E^P-Qm<=sIBz#E+YQtSnRtO+L}t7xYdWl1x%MKRqwQsCk@-X
z5YAIi2b720J@n|W9DVC|dr#R1fxc^IUluF471q);sC+wO3!L?8!$}!|>9&HgkjZde
zhBIK5UDD-1FMGRpZU6{E&wtY#eqWIPKQxC@VhU=1YYv(JJ^GdYZ|GN=Z+{yj9y7y#
zJ_GUH1O8iw8{>Bm`9BqI^xtZ?|1|?4`d4fCH$9u_-&AaWZwVd$d3J#Hua@s$dceP2
zYX4}3|Iq_7vwZ*VKV}DL8EOCR>;N4N<KNk>|6vc9V2(M=j!ySYKIOy7rI@@8nUx`q
zAT+h15dFz`=qdzPPb2ggl8}OG0E3{FI73%RB8H8<FOg!<up^=>B&i0`$^US2=k)2x
zJ^eBK(Oz}dRdsdOZv8`(8Lk3m;3gQG#R3O)z&8mXb@v1q5ddBoZzT@~dPE~-h@ZuR
z9Rscjm<Mqb*~aI?5OcMTfmqE?paGEQ5LnnQ)~A!BC&q$7-2iZ<Mu&>8xE2sHvKh^2
z)NRI8qQ{?KSV!wOY>h4*;L|Ent`9pFr2SJbJS>bKK){Tv4>y)i&Fr%(5iyhh4;2q6
ze%)Sfxi=lF5@<-8jD7|ngBbYW$p~P)6yKqC8-sbBpW|OY&Xx~hbtQ_RA{p1crb@jJ
zOeq3>zI6KaL&EO$YWVc|>QKEc%UM5TVu1w3&@5G}65~XM&RDJhN}%`n8L{}SHnSj}
z`Uv#IVD{x-fuJ)Ok#L{|ug+Beru#Z%x%O_6$sm0s+OBq@IuYVu;g}xLLC1Tq$eQ1g
zrlb!I7XWAnr%UEl%{_ms&HtpE$dWwb0cQuGVI&4(ph`v!P2wa-r31_31<>WU0R|8r
z3Atfm3MOU;8p#L+LC2zUd(`3u0_@?huf0M9zP^?w%^#{i+VA$BT}nbihy)2e1FR@*
zwIDJP0u~XFJO5Ic>u=FWnM`*VrYrU`0VSYE3;LzQrnWJdtBwsl(dBf!;q?|5d?YKB
ztJZn|hPyxvVOMFBKV69$-onTy?XuY77Uza1S4(0((TWI1JMl)dY@v54?7kD<ws=)e
zMN2kyC*#JC`|uF|cIF_Tk5RreLS8!+zJn3Z%;|>f_OzH^)(qp1YD}X~3VDR%EZMz|
zi@dx<tTgI-4_ZI7Fz>id_veDYlUR+IFe(Evs^z@;pvx7P!Dt|5$QYYfTG3v#w3zfZ
z+KyS06e)rL{ln7aS|KLNMHt_7d^y}t*{rSQ&{NZ@b(5+L_22;C8O;>T2{?~|BI-;m
z#GsH*RNFqV7!OO>Qq+Z{&E|_!E5=qUw?MbtC^@g-3tpshI@?N<l$v{iRX}Ckh}Bg?
zaDat<p^gR^(M^*!6FHUeIw~woomsv4^ch4)0x=22aT=bepuJ$6OT#nA*GXy2t@1e4
zG`#wu4A%-Cjf6$UF7MJ&g<&e2qaZKp?v;IwAa|e@q1jZYHM!;0GI!ojfB(#DoRHtv
z*qTCAOrvP~kD2Y$f&f#}liaRL45p(xp?A5VarDxuI=Cfw+mZj#sqG#rw-~0OUfGAu
z&-_CueoVod;u0sukI<+!_@#wcRm7+c`lVGY=Od=(M_2o2(b?-h*TbNpag_auRrb3<
zl+9yzqoK=CYNv#1QD^U~Qbn*<ZBh>b)oHoj0^D)yY8ClZ7D(jX%l6W2UnY~BiV{aV
z*fCmlhw3P1Ocz*c*`F(cmL}t&)9gzeiA9ecG7mAH64!y@>%znf_oU6^rvh3Z3QXv5
zX6;a$R7?YTdpXX75al!a%(k<N%9%zDUn$etX0huF&ikkNRNRzk6%ekx)l&sq{^JW0
zxWDLRTw*Q=O&;FC@64IY&;{#af(^=uRq$Pnhqcq@{fN8#p(4x7=sJE6b%u7$85CK;
z><!(e|86c<23BPew0&PCa$Pu(;jHlQTW2iN)?mC@y-htsWFjMuEnf=+8f}rLB@$h;
zP)6;vXEWurKCQ$to8EPeB>ed$5h(4wn;vmdDiwJGaqGnMqQVWEzi)8g*hu1>MX|~)
z7b$86Ji1OxcK5TYu==iR3(9o(K2s}g`dRqdNd0-~36zLjdf#4CmJLIs_G>quIBdkZ
zT7OYceQhMNEis8yis<!mknNNF@);Ligz~OJn=40rSk!EGD>d5;%p(|roeX9fXUnE%
z0aj|eb#iM$oV`A}`l2OgZkt#l9uM;N@^1W?VP#M&)@)iqy&3TdCB#!^8<S!w7_}-a
ze@%<doGX4C1pADo2Zd`hzvxUw?X^G)9jL6WmCYG!X|*Um;xZ4eLs`z@{k#louG-|t
z7I`kFD#pr-RmAR3YBieR#aP?Q4RmyygYdSf`EL-4+mID`X-&QhrR~hSLsZv%wO9IP
ze_af5@?Sz)6-X>Ond#@lhgTUE2~r*l+&BA5ejPsE)h2GgHC*<ETIXzPCZ8RGawp>h
zR)8>15QRsQ4x^Q-9&rHfb~m>_51qLg&G+MHcX#<q`rlr%sSyZomdEGVD4!vWRGt<T
z=7#sjhvjLOt5k$r3o1TKOxgBWxE=yil9ZVBUir3bNKo5{G02Q{qc~;}z!KOT;ViMn
zMQlE#_jl5JNCYj~z9jZspB`hB8^>O3>8&gEboHA1ttKx(I(2z+OZq(6I_yzA%|FMI
z?q-Gc-;vku_us6bdShiAl(nF~MB8=wn67MRivdJ2Z;<DIm8eyj=@sW%``SHTHdw6b
zwy%)2X8Bb5k9pS**mZMaMOK?{ui%N2H)2$k?chF)iUdu7NeGS3kDH~<e(-hQHzqq^
zo;C>h8;|Q{Kb$SNaZj!$u%MzpWn`~-=U$F*F2*i{jHLDOJUpNnTPq-^84o-rqn@iT
zW-icw=#{D~&`}<&=KTq84{jT-9NyzETJcqF{I$C`+R1EX1RfWiCRp9eJo)9>EK`*o
z*Qk5Y(bnsWj<jsQSJvemnW$CSl+IDQQ?EBBfkUHdJKsobEvM!hsy5%aDZNweI;O_Z
zIP=ooq<Zf3Z_2Iz7i+Gpl%%+%;CH#DAo|};ozgP>SHblyyJh<SGj&S&mn`@1-dv{d
zNc?}*T>mn6`WIl|>R&3X|F4{u_20^AS(*O1#G<2R`Jb-Zf1b~zrKe+N{7(V-ZiWgO
z>vfcum%NzH&dEEMmoqF3mlzB!K|8&hlp-;}&dzY~zgc<@9=MLSCb^D2J@em$r_0nB
zjTI}a-R{vPC9BGMDXbvqz{LDBHd0qrS3m%+5*Zj*R{_o`EG!U378b5FeT^=g@Q6j}
zopS(uGPARP;9Z_W?(6{8)I-?V`fQ6V_&nhme`ho1n9cy3?yuc`E`YmHJj&`&^u#`K
zsqHW`2pRo-6M#8@bu}PuZ#4h|*jNCk-kCN(N`7qmRAupqqyBbs@+qtgWbeT;u{;YH
zcugi^B_@aWdD=D-hdcUmbOqAf?8yUg_=*#S0|;*bW@UW_pzu`^sTjkf!Gy0k_zJH0
zlA^l!vy)?S_^kZu?Rfh2Jc(tA?eR$rw10g52i5_E#FxUiO6m){?8kdE3t>)SW$>Q2
z`@zN}mIdWNW(BqnK$Ca6#b$wJr*BeO(<LesfU`2(PWJ>4@%Yygz~x3aa!r{@==g~^
z-RHE-*MS0Ky`$aoz3nIanfB~g-?=sV29C12wGSX>OZWK>&-Ix%_s<Ws)P(r&Tl1w+
zjGo@fA2jxkjCZ_1+PE~kpwG2GEHWv4w*YdORcOe=kw&mRfB`N=0eT?!!|s;_Tw4Gu
zcD++SBV7P05UoSddR{+aZU9vXx8b>c6i=-O#zA!wz4*@olv0@o0Cf^Q`7;2NTA6_l
z<vsXyxC;Mz@cMp8>_)&%k$!;j{kgCWpTfHbV+*LlxDDT;R>=%(wEX>rQ|9-l^KY2G
z)l}uHm_SDi_VqQ5jWv#q*Ea9#Q-e3j*dBi@HqW>HdJR*$@ohp{Qv*BG{ZrE?(@{2P
z?3HVN9$x}9*m>96e_DP$`QJDHsF>Qd9)KyT0bupP9qCTA`7pF~@R*;N0<}s#;KoZq
zd}f;LjtK{QR`q}aAa8Wb2OzJld+=cI{Yb{#|MMFCV+a1MIYOuVL3<qPc^bZ^qPeWK
zr@!XLwh55!;}?)c{RbGZ^vESHJO}8TH;>Jxb(m`p2phoW#^)a}=Mzh|^Bv-thsZFb
ziT(XQCZEe>^`F5&*Qf>{ou<IW0IYyte?XTH-VZ^G9hmGv*gl3=z8wt1ui5;2Kxli=
zU06BIv^Ku(hvz#taFgdc;p6I(-uQ4i>)P6Y)?=-obbcGYNr%>p_P1ZrH{7hNtKW01
zDFEy(r_4-NHS;hX#-B+)F0Z_|B%GXTj+-4ecE&a=HGIEXz;<9;+<iZ70W$jcF7o_d
zIC|Je7AJxBU#FS;gpXd}z?H5ZKv{c4JHG&XE4aRVb`YMsOhJurLE1jmd%rgO5fSmM
zxs9j*=)qieIx^087JE^zadlB~s&-^szs}fUJI24z)K~q`xZ#gs8hF&S093()RtuX2
z62Qbzq!fGTc*IniiO85AC%pJ!HO2fKNPf!N=&qQ|c$Q2I2(1Ti65qKI*o9x-D`O^e
zLD`DFb9~iZnYLx0tP2&mr<U&5A4%9^x<zcw(m8*mW6BvC={ImFR+n%edF-%gCrZiP
zp}k|U3RL?V%Udg<!&O%~6!|L|xcq=2Ze<%XPQE3n8gZnKSTIO=7@gs17YV42C`ZeY
zf~yGT3!o;YCW3!LwV}mj`E8f1Mtl+Qi#~PxrV>+3ZM%9H0|5vRL%dD3bh6&ejowV}
za4j>5-AcKwxQTJ?%-s|3Fv|&k^5@X@2Zlm{fA+5PJgaYYf{<b`D{72crCeW)vwszA
zB8>4KNn+cOG|HqLD<ECaDO%xt5~J>GR~(5%Kpc~PL%^PQ+G*X#j2Q?z%G&FcLL*h8
z9qDTMJEr8ec2_jrOB8yYJl_#WdD30m8wtc86ni>sVbed&_Pp9xmnfQ_v=3Cw55GvY
zr13V<ou^<@13Z16W3k0n+CVCW)My<B@%tX(>9w~Qe!Tcv21#4NE4r3Ji*u<(qUAB_
zp^+I4MsTdxAz9IelF#Mi4NWL1YFKme{OMUl*Sj%hCFyU!!>*=ZuA>1Odn@3~#wB}_
zPT<N<aV-GVJP2Sv*5FI>p^_USg>p|RrrnocxVno{I*Ni(@Q`yr&KEu+2o^SchiH)E
z9Eaw$-0Iw_DX+K%j2_GhTmwJS$3Yp142T_8)A5;%rao5@W#d3fM4=tzR9tY#Z4$EE
z=899y!d@{V_~3xB4#O$T85v|enm|YWY@E0t>aN=j*WU_fCFZ7<Gs&rEUVIOr5C>Q}
z$We*(PRkbT@3c0SC%yY)yn1@RN`>!eJ>iWAKNL)$QV<7;Q^A8x<8~ya^bQnu!Bi-O
zk)J4cEF^*}D>4B~*<>dfuD~rz^SByC^Pten7{xN}IdTWx{r&@mrQoU%XEg-0W>ZFK
zuJ@I3kW{=xc4tDRY;+$;_!2a8gh{k{feEkVp|m43_HLO@u#6)c%J{g#u;D$>RCjX*
z#aao0dT*-wS8JG4blUvq!$qMLrYgR!om$1t7!%@TZH#m;7DZy!`hrN-2)}tX7X<XC
zr!ofVXf_NAX6Y%O#)+hxB){Hii{z3*jhB&UQemv$;xp@>9TnD-XBvL132M(nM6=(=
zqCF`S>MW&%o2hLwOE(24HPk0F@fCGKRCb_N0w|5YDt5UN(m=p2uCf|&996cA8Mbl}
zUEC3G)qN<_l?jbh;FHpawaYmQn&JRq|I*MpVSUz5r<j?u>qH?dF7Ru_<<Ht*-}QA0
zp0|Qy2R<~1+@BN7^e;i?T}h7gq=L)G{J`{><6}2&0jwlNHpND0m%4HMr%Hk};ewO1
zpgYPBW}NdL8N=gW(!_%lYN&3tB{??FY;Sr$4-2^&t){U7NopQP0ci7sF-J1>$u~GF
zCto_!w)n*tkF4Sd(^G%--M7rmAbf=6$mP;@0O0#pf0AE>9L+%+!U4gr6^%wBk0E!U
zIEMS9QDzR+@TQz2o}JUhQgs6g;}?Nr&+@j-Vv*GK@uq;vlXV&)iX{%hPT|?xq*l*J
z`teV70U4|iglP<87>1a*qgu2Py(1CA^a~$588p5icg1W3N<jT6tnBmPGh!B!m;-vP
zLoX(Rp{M<`UK=k@c(7S)A>_r}wX5;O?>K!(I_)_ub2=!^BuQiXi11Wt(=n0-Hu^Zr
z)^Wrp$<s*585*x{TWr(CgbEBS(O@otvoVHbKgE9qu>1Na7(&z!0eL$xl(m&fB@ii_
ze<`&li&fRQc9UB`lvsFR5T)KOPel(0IWc3m;8z%T8<3P`7X#GAGi~s$6^Y|G)iX!Z
zP6vEhdV614q3L7MO4jz7@C`1-1aacd@b~76Ip#K$e^<AcS-IN@x)wgAoCu`Zw$9Rz
z=LQyzE}2Oy#DK>;w(cyH2ADU57QJFO+Enba>2_(Blw!uVgG{seoV?dZ%SeUwSDM|{
zv}Ea$pONgpC-g38n4}MXo2cXXlxRzsOGqd@%PV&t<WtnnFn;q@A}oPY3EtmU7r(P%
zM^J9;leiuo99%T1L|UL7-H>Eucx<NyA}qRgg_qbJA`btyYqj0+capXUarGpsicR*2
z;Pax&IgLl&(ZIV^bv3<2hx0Q?;f}emiG8Uw87+EPZl^<`Cjv{$QK@Bmma~!+P3zrv
zy-<`NUKAweC}~(f4D{!&i5tPoTUfyUNMM7^5X@Ac+Z@})(L*r}&;Qm!Ky4A$aLoM>
zGlG?pK2RPaJMHf01Yv$B(cwYYx1p~BC{wwHYyHAUhU9Y&p3k&Infm!#aY<m?z;FE$
zQvst2&v8WO^+PK!w%!EN4Oiuq*N3DTTruP-2Kmeurucq+LMB=Gz@JaND<$A%nd#WE
z$Ze_DPx>vEi^&4JZLOPXT>CaL#yMhkf0P>zdzv9<%QYmpe4#oa=6=^G{a^xeYKEtF
z0RXJ3sb$c)9YSBN0X({u)iDtJ0F`T|kbXnWEh3u?$xPa%8IM7b%$79kLR+j$qe`qf
zMUZ?a{-?T97!ryY;S$rUqwRVQ(Mkj>hhU%%@^)*gSSPW7gbZ|h2ON(52r9ee;3Qcx
z>M*bLEC@q3U8(yLc<$VvWz9<t+`|`-1o$SYFOTrJ<`P8uAJEn%_X9DbxMo|{d+^n7
zmNA5n@mvAE$lG4@U@P<n)5N%bE#mOj^+iEu7d7y`O|@o%wFoWzVeHDFW^ErTdQMo3
z`E+24!)%(s3=pN^*YC13^N1eGg$1%$q9<bvvX$i6Fuc5<m~L*F#r-_#956xW@Ml=Y
z03dT-`p<gZfsWAP3xIbZYQ)AEc}%rrM+_(VuA{$KrFdy`y>dL38$l6gQgdjsSv>^>
z@|u<p5ZDX4z~Irj1e@|Qa>ZW#Bj)>eF~6rX*puZs<><9h22>&W-NfUve|C7R`<~S!
zI`Y$}mTeydrA^$e3r8gam=nn(gzT1z&Q1@bk5*brl_&0+z!;Cn!hMEiDf{!X@rP&G
znh`&RSil39;lBNTTo$jGtm$SYzb&sfopT6)KNlf9zG&uUa^Vdl<6@0DuLqU{>`PGv
zqO0v1r$wSvkBxh6k~IU~J91~wMN!sIA;G=4j3%epH$`@Imy8QT6(6RBajM>!U3s-1
z6;Qi!gfg0-^^T@$r&UzJN!<ptbjL}K4X(KqxUb`mHo(WBC|B0vcpU@ZXK$(54u5{Q
zOmcRn92B_=icUD;H~Gc1*tNltEhq!3rR9B=DqDo@iZ1G3*vvR4U9+Y0;wp(&|0TfA
z7xdQe`D01^L^y5dU|OUF1ua-Y%Mm;~fdo>y+AwR(FbaYHhI)~?T%g7gix77^7t-KK
zx4i)3;N$!Jk8lY<I<JItj_PNvpZ9VL^Z|ug@0dRpcG;qM05&s!`D;Q+#C&9^X_kl*
zjxFkg@9Ldo9+{-6W(IspB#hyu4<cf8okzaGb@GPfsi>d6gX*#+CU#UOb#Q8~ELOTM
zbn7CwTgqAJ8KaC}<nQSIVJGb9{+um`b;&D}9^*CS<B;ROL4u$Rw6Nn^gHYDq?0o@w
zLO&aC!Y?%ZTw^JvhKe2k5_?pAiqkr)@gmVM&rWOMdIuE>En#dEPt@wBtt&ge$qVc+
zh)-1gkcg;R&PAa`<+>E-p!Y#d;(K6*Yc`p|%}^oC>ZGxcM?k8rWI0?INfAxQ42ROX
z5b~=OGgj^5@QoP$!%B+bYD79FC`tdwZ8*<l2mwnA9I78UW7K>TgY+C<hGLJ^yxMO*
zg}TW>dt0V=RmdKDVI`~XOi2ifXyYnl;L4)FXhXf~eo4OARy?rmu(|#+3g-h#z!D=7
zQP@X2oAPU*TLd9VeKyU%ufFMHvn%nao-2}j*;!~tivUbFa=wl|f7K|-3whJ+x^iS5
zN5=goVC7&=&|ykLYBtfgJU><a_vZWuQGcG`+ep6~+}%2NL$i$--0A6rr(~qA|E-rE
zWH~CXw>eR6qA6Y}+rx>nSZ%4|AyxGw%c{+NK$!>7V>`*=V=@-bk(taR7@7SIzj!b2
zJJyYap>E}JGLe9!7;5<;^rHQ=vge!yKCo%Bg?EJQ>(wr7RtXAuK0z0!R<Er6hkm-(
zuLMl{;r+;IidhQR3sdCQ<|~vfS-aE4W^Kl;_yeblWP%Y2csy`2umH6jFCSq$vugdh
z_H8Q#m3M*zo!pp-*c%Dw(OH6;2bVeuL4?v8lLy=F*tI;Uwdf98+Fr01QnTw{3_DJG
z7K!UCJT9c-Rn#OJ9s=VF$H&gK?|)V{)mTU7-e*luuf<wlHgJw4D45$F<@G(?M2<j|
zp7gsxDhq@jGvD!}941CE90qZ3L?3`gcs4k2D)6w@DlVR|ewRBE>*3dSEtf|*o;$Xr
zzq0YJyjQa)AGlsK<S~YAqiMDJA>e8%c+!u@O=VlLErWtP<D!@2$t{aBEpSc_&j9-S
zVJ&2b%on@DRZUtcpD`JZNhvKVyzV6rP%dTq#emu_&^8QTCzCBAy$Y3~Kq4o{sJ^CJ
z-oxAu)81QYz6Dwk<Jv-FJrrX)L&0KoMX(2<$nH>l_J#}xN`DAc*bE~aDJBuu!kATQ
zxxtS6-af{IOj_I0K$!72(X$vJnN_1!$__*6&F@4Hu8(ilaQ~VvRRjJC^)eg1m$KX;
ze<mypr;2U6D$$g(qpI1y)rb8FoA%VfW@quc3ceM@-1(dB{>AP-BpQ1q8zZfi^SesG
zPr6gV5yuaC&7^Kn)uSxi`wpDedx+Q}G6mB-?e2XG$7oRTvY-xbrYm^e2v*PceV7*f
z_sG==MxoLxY{6ofB|d6%FdZn^qw~V>ZVg$T3s6z)w9&iJTRf+lL{La7`(j!ObI$IA
zKglMydglNh+_J_<?(HwS^*BQFG%$2F{A)zJcB+bKyjk24{4)YYMDrGjoBADG#k3$b
z%lf{vVE9awvz1J{aIAHMLmFHL#4p(fUUS+TBv#Q~LRo{~JT`|K9jd`P$Rov|5ZQ*r
zr!Vvbg~l|J^57Y?e=;d)0^1dpLz~3++$EaEwati#*Qh;ci+C6jo#%=ucvdo3<~)2*
z#00J}?1EedRq%8YZKuaL=QzXgrPE$Do-YuD6q1VZ9%bmeH{GHFP@>IpT%6I1*hHA0
z%#+uQyAf{+Bt=8llpO1QaLu>RflaHV=tv(hrmkTlJAOZyqYfUfOTGiAJ8U&O4MmTU
zOpSV-4MkiJVv@^7vU$led|&igt00R-Wq-o6yBc;jg2bJlhz?FxvFF^{2(>j#{-I6U
zC*?`eGCs^R6F^L2-QdEK=j`%?Bz)-v%)~q)u7*5gMb+rCNuPL<kc(ho72&;FFEZMQ
z4776a#c@sC_h}gG?YR&wk!u0ZEgtSqmE4H3*F{Qlc!Iwv<9*}^yC_Hhh6Rm#25X5T
z_>-%u-p?PzeSQ$kX4S(gfTl;VMjm>4FDEveT<emnTeZVhs>(((s?WX{tpPw2Wy^Fu
zxHvoHq*f!k`c>c2L6!18`J+$X{L&E4jht!Z&Ml6TBm`n_##T6di#TybP$lplOi&1`
zHi7iL%=l?;*20ATJ0^hR{&@Vk1BDV9PVn*u{1@6Loe2wyk$vBxCbT)*+;+3ca71&V
zutaL-d?6__ao7;|doNY#E5FF`m|v23K~}PC_)J6f<XzN9L|{du=h=FF4C$a>kUNvG
za2OjhsYJ4vo?dIp>eY|Ibx}lwa??Hx0}P*OAv)ZX>|TqIXjEpFUg)N_{x?O%&`9Et
z>tx~6cD#|h`{6qDSK{Hf%6U>HJ^E)2`NB!ZY!B>elF@NMTJ2nG^eX1PO7Q+qbLeE_
zO922_s5pkxuAbrGPzR*@4SB+V)dk(q<lli!uG5oavhUR-p0#{FQUTX#V(V02&Sij*
zFGZLBe{AS9dS1&+Nsh69@g!voKYWB~C<shP)(_n=m}ThpM3Jnir5~}sab5MR9c*RA
zOU^ss!&pvF>w4(6bS4{)xoDW37$^^2iayjcc+yrI#PSVL=$>1+2hmmcv2`j>)r$+D
zOuUWG=KtthwLNEPsaA@lzT}c+GbI;L6bv}d)NT~4smgaH=RWL#t$WwAnb!J5q#_$8
zcNCN)Fk!R(-TP)S_^cW6l@$3A<eQaQ({VtnLB0(2QqFONDj_te3%5mG1kA?9+iI}4
zpUT|>B**b(l(sf*u$67qmLHk+_=44l=82XVbE94y*0_4ow9VLJWx>Q5^g4^jhiKxD
zNB|q=ZRxp$)8c=dZA<VKIF~~9xMp{H=P9*QB~bFmD}7~dvAo|Y>3rufu8KPSwp2^w
z-nRkAZ}t2$B9InYb<{-TXaKO=nOh1Z^cn2Z&t_aAKNh7)#Z@lILHrVs2y`1-p=mfV
zOqxcZZSewT@>D>%gFH(!*(l<rq#3q{l?}`<P_Ys($d_N_l%BvOtdph8UQm3b(I;!l
zEGxZ?y0u|kx#rxw{k*9B1c+{n22aO@(>qklqiUm>;ynO(C`w=cYUsusqT~569s>)F
z=NT?yMrw4bnRAlHo!>4;#G}&YHBY9e!@A)3+MmO;XO*g`*03Jhj7^V|U=t^pb5!a*
zrcpFWgLOvrtMjcX<LtI;nC}uC<d&b_>5Zo<S;%jV9gzMgJKo-y+6g&(r<;sBC({UV
zMO6hV@}UUAY@Nn{)wZ>B2X9WPO@3>VG9(_Ci=8bs-LuLyZANv;6_I%9ZcY18h;k%h
z&=+IteHL)L`ubk6^9}4pYWtUajc#Oj{r@QKEx@9Vmi}=NL<B)Pq?S%$19q2??(URW
zy1QEh>6B1u3`#(dk_HLsmPQaHrMvXE=zH%~xc7bU|M{cO<L-FQnK?6a<{akxJ)e05
zcqC0n;lmK?Vt<AY^L>C=G-9C;Q~PM`%XoK#3}<z0{tVF}t!j57-qY$%Sf7f$XwIwh
zMS5n9?E&T8V&|lr`(d~waTB{1kwHfvs4_f*>EBmW>6CBYVR#~|Y479mU>tv>6bOr<
zdAU2i{kCYu%4p=Xie0N~q+rA?b#^K9JGNst)!HbE*eVa8jFlpUCx}H$VO&tdRLXt4
zFN`hE49Y#;y4E%6ycg5ye@Bdg&rQ^AR|!{REVNT0cxL%cVTFb1Ra$?Ei)i2aq(xbp
zH%Wk<1lyRlhRf4}eC4Brvq$Q_kzZ@`{SY};z7Z;eQO2HdV_nIL{n|r{g_!Yz%9<Vl
zt7L5pwa%q^l-j4{sm)GbWeywzw3~IrWCH3Bs=+i|YEArfi2Dwp!@~X>UU=5EqnV7u
zID=SNrx+se`w#JFDZ|jb#^_8iq+WSR%SZ0^%ff99{Fj3s-R+uwm#<!OTMe_8D<GK0
z-AKa*v6XPwE~|fl!k0B2`-@J%9f5r^#&rrt*{Z^rH_tt5vNC$L$%n*MV7~Ca0ivPB
z18x{$oH^pGQnFXLFDV8m+^Obm;>YD<P$I02-}L+=zdZRk4+YHJRpcUihtHtFJ*{#I
z(MD$aO;|S$(TSJOn#$o$EzORpTFz`SpL{k2d7Pb;Dqb+iHu2dh2P3lRX#)Mp#N3N8
zm!_84liF%$pOTCd+KKyV1Mx4T6LAtTX*62*zDe<VUswda8X!@kk1WJX*s`A~Bf5XC
zR=H_1G|H$Jdc&-$H-PCCg_2J|q2~k_3oGMSdD)Glgd+!h>$SKl9m(n;vrthn;FyhY
zlJP-+dYjk<pukZiI@_t?k<}ou*TCxe@cdT5n^KJ<WmZ`1O4U<UOz|AC(1av<d|A8u
zhB4!7Y2gmr#Ks3jnu2@rbGhaXtBCT=Btd_N$ont!PtsLlK0Du5ZKZqoBns*^)CNkn
zmKV=`quXH^-fA6|RqN@IzOFwXbeBJ(OV^uA<IUT?6;T&uTGz0rkDj8kKWvn@=<}SY
zDLn~J>6Oln%X|f(j%ip`I}7@*ATxG0h_^DhrSt(URD>qrLu|BX(gK3qLv5dMqrKE^
zb4~LN1NslZog;rO)POO5SBRPuGiA~UDZihm`+%={;NCK!8f#uL_Q$4YTivLuZ<^<t
z?oNFrCh}YV&J5{d@^=4ncZotB++j>CW}{oOp>;Pr5iV<YV+LT__PwIyqhR5qR1k%!
z0_-8Ja|m>}#agd>NPlE-A-($OBU$qCA?ebJp|Lu3Y-5=Q65B~Nb#4cIj!sp*Guq+`
zmd3|aNM{v0Y`){5xSpyq9A_ngK-(W1mO@!BlF%l`U{g~VeN6K7i19U>kiUk=`Iy53
zT6WnT8>s_H+}i@ljMNp>D3PVyDPM?gcobQW`G_e|I8RglP;)c$kPT<hBDUtxE0(3i
zX6<|$R@lz2Wgk4NXfP2($X>$(@<TP}T>D^ou6mIw5$!Xac8kJ^Ba(;eUXH5(#Y2xJ
zwF>u6n*<*_TqSNx6j+ds>5|gcM3CAysN=adi_iTaIU?T0wKWA(TV?N_pd8F;Kaic|
zX$_@1?UCS3JPG`C!IX|CjZup0;BkNCe$u-{=Wc;`KB*u}<`_SLDA6P-d6grk=N0_&
zp-}n2X%`-T|4EiJt(*k>XRWGB2%bzsAa6fieJLuP0bs?kUO)zYCLfL0zp8Eh!gXQ@
zE`2LVb-T7ntE8D^X=<V2<7m(G>X((nn=e=AF*eIv@zS=9x9)tMr!C=S^N|iYHLsSe
zzGr1=C0*I~6jAs*>FskLJ#;xYg~&0T#QJ&(3v{)3o3Up`lXqa!ZqHRP?#dG{>D;)t
z&l?T5zE!L(qRWbB52XqEi679;7b|@9nQpPW7pHSjW`B>aukFNLn&0VW?1@0fkdkO7
zG|kp^XO1ZRplA!Gflt}~^cERQrica)0}sYFF4ehvw;{*}x2;;kDgHx!!BXfT(|g8q
zCrxe@0><4JXm}5lg3}&ikVTReD`$Tu>bQ$W7}TR}%$1|2@Hj#*+HR<<jHokccRZEH
z84!&VAo_Cf@ZKybyWF=OpT4D!rwHcgv>fWXr%pmRTo&)&77O&~!q1JJ0wEHr*dG-8
zV)B*R1e#K~gql|3_ARD5zFUZFzk9{`e7xTc_T7h|ArVEt_^tA@MHJ{bvLsfW=XM6|
ztsRdb#WcQjrTIafXZbXiLLn`jAtmxTyQDT-vED_w?<Kk`su}Km9rT1dG>-YZi=a_E
zppf!Mo@dfK(+9I;<}f_F(RP4y(}GGXjEgXlZkQ@pO4=#&o>*l8t(fuXWW}ND#8U~6
zUG_D`hgyOn=yL9DlTD@l$|33aUVL<Svv<)Jh@2vVvrIe8aAbK&<fI#qT+2Mcwwb9h
z29o)ehgfsi<yuXiLpO8s&uE6SdUg%gsyb{$!3{R=Vn4(nd^z08-x_~d%O?%SZ4Ny;
z1epDh#4_`g!ftMU%gCbyS$yder{@{e>yb&JS|{Y#`iXdT`JM6NZrV+%Dg*L^kk!?E
zVMqBezUWN6+*F>TT$XhawTJcg7G~y6G^wc+8E)(%XXc-M+L~AZeKl;7<6LKyKM7e>
zWuQt8ue@9yGzAvNs+D~YChRW?qIuo$C?IT&Y+fuF*4kM+vc)bi#?2sP_PJ7Y8i;jo
zg-@TubM>ufVJiF{1e**fvn(pg;4$XwM5Q*zq$@2MsrmJxu3OaGBRnF4Y372;SKGup
zce~Zl^{5ORWI6}v8x)1)$Lf!k8<|)f%qlC?Fo&ms2K`J}TAUWc%xA)H8prI#*9tB0
zUn_~u7g8BakW=D@Ruh9X+WB`hYGR-h@@3(+90w~oD&KB|B`<b9E24H(ell8;SMO6N
zC8>>mP~BvG(X6OS2M4?nAK(^izCa&3Zm5o~soV3s>tOA*P1O~>ojJ6KO0}-hY25cU
zR)h14q01dgxQoYONS9{?k*MGp0<L~Lkxv47iH+<mQZnM19L;<#e9_BnX|xkzI7#IH
zu!9xTe3XQgza4QR5)dxF6lanpsoQj}^f5)UhIce6*5_$?3r`8dzQT=zJxY$wqV`Aa
z6L75lRuc@rRY<JuE=_AN9clPJ-=e|CgMc5wCx@$~M~tUd1!)<|Xm^#c^Sd6P0pF3e
zJq`^mEs}qq%&@B#LnO+o1f3A=dfz;9%If~5Fx_Qjoc2{h4o<Y*tdu-z*JvSEY#HRG
z0KQt&R(a}<wT1X0UpU`DTA#;~o9|$Y`64xq**ij~ZQnMxGJn6)M-h96W`l`6`C1(2
zx=*CS8e~fw^9w(cT8!(VwmrDlT9A~m1oxd3RobqRAXz8Vg#^G|fN#&=Bqo)dm<@mz
z?sX-7uJp+^q9#B!e9aZ%(kDdJIY}AvSm?vW+CAojO&;SU0Yl{L@1`-2ZY*r;8cnHd
zpX#7|B%n_BitaoguHn~=O2e+&!BQxFp`5=XbwQe*D>oM+%bU9CHa*~GI~UEsMAYU5
zp!hr<Z}Yq+(w<J4-1_d5+XYGO8WXIg#;o+>2`s@9q%E8f6x8;FTH=}9w)MzJZ5N#p
zw|)J|NhwNxKlk>OY7=>mTEH}$2=3GyTBEXeK3R*o&4#11A@UeS)%3-p{Oc<@mT0>z
zg9QWFbSGI~R#~0Si<qdfscIbY!FAprj(XTJKOXnRzVj#U@CwCDy}fMps@}{0wRNVG
zN@6IDX+*c0?8=JZYaa~V$=5!4&Lr;AY`O_PrrUQh8Z9A3mR(O*YL~vdI}=p8O@XG_
z@<qrEV^pZ!a^*<W=xzFv*!U(F=D%xVI5froSWLuy6gc4N*YdFYKy+AldhPh@`>~gb
z4x5QAbOK6_PlcP3=?uaqIKCx?ZC2eM{u$w3mhPUN(66Z@?fmncpHQ7ueD7Jpns7N~
zR{;Z?Z9k{j`+c4L^mc8$s>;2KQ6mkH9ElA=ivowRQe0AUKVT5ZA(Nfs<&O*7JdIeJ
zaP}oaU&kPbS492>ed|UQzhHH>iy~eaobkTEG3lEWj1J9Jmxr~CXe;C+@*5qVA)@RP
z&q#>W{R$s!Zkr}Eygi%D44qYr@O-kXK?~q6Ii=<_>GAdbHjt_xYl%A{K6X>Z;<bvT
zp>}%M_fwvmbTT@MqOOXr^QTR+FZFlLgI14r<i55dahuU?DELp+RknLVaO_RC*6jPZ
zM*Bs>Dw8NPEDGuwY6{o+o5Y5w6VpW8>3Z-KN=!Me3{^*rDceLh;T_I2M_(5gjp}FK
zQANrtd|#UJR`1G04_H|h6XmkKVXvxC@&E;rkMN5_7pw>M#CGV8?I2YMMuolmhU;sX
zaeIZ$W**m5zNMk%w8r%n^}`S3W<(Tu*)w`gmSAfOZ89C#pUUjIX|fYdFE{Vh;;*uE
zz=b2D`L*ahg30b>eY?pPOJ>aIpCrGiti+)#GSt}l@Lcy+NRt+`+dMwNl%dD#3HaQ;
zCkM#F+7Pjp3tneGOTd(};wOg5JNH;BIx~Lk`1WxBUjCz`)z4s*A=8ad`r}WS!4s!j
zB#N3=Z5fyy<u$_Csha$itFiRGBOEC1maRQ{N)SlD3o7MWp255_f${D^)*P7WYnXZw
zy+P;;m!DC3>x0!igzgW*hht7_lC{#T<DiQvB(wrDc9<t)<eQm#V2}dP5_k?qW7{{!
zpxMTnW-5jCC=Ky^Q9`~e&$rnFTd;Q$=}G+|Xqbv+a-j`ycNS2v{N5r;-SW2TY)~5A
zQ9wtRXz+m)`BI>(R8DAtwMN&y)lY5VCtd*u3EObYLxlVigmKjg$0DRHR9}gfA8{jE
zF<w*IHZU8t;;naDdQ_CXmZ9<FOZ4o4TywP`Vw#sMu4Auu^|GSn(<oz(h$VGqv4Ve2
zF86zOKX7_=OkQig@qMhUIIucbDfw;O$E48;6}28BqR$wyyD4sA%Y_&oe0c<}=oV}>
zoFx)0W}FEPGc<RKUL2#z;1zry6g*O^nn}?I`vO1oZ}jgXU)~<8tramL^ytiF27pPq
zv=An(iuO-vVyRmZ`a|r4w-JwjHWQMyj7Iy#25|XOiW{ZR)m%Whh9w<FZ<d(6F@~dl
zF7mUqaHShQg7!|ER#%j#n3;X*#wprwvtV46eneJ6=a*GN5Xog4e1hfAnvH|TS0d1~
zoFd+Y7H;GqqzGfMaV_gB_X&EmfpgpbMPge`u!O@vhf&qr7QEo8XC+vs5uZ1DyYXo4
zF}>STY}-DOrX@|I*$gjd+#T*g+m<3te1dh_JU(=*H*lP1YBdVuV+&8aDYZ9y`3r61
zNs$#|s<9Ara&h02)L_J@T>M<a2>`px>(#CLu(Csgj)|oP5}!#Hm#AL(kD`<OnRaHS
z99nK|Oy+0D=aLIJxQ%b@gflAh2HvW<&X(laSV|gnZ@xy5k5U(NlEpb)xcf>@<%T&}
z%EwJiZ);h2iFOfbt>yMpqC#)1faD<L#7(ufD87vRgKrKWYGvmikN6t5#p!67UK}@r
zdH3rZzPLcB*JL?$c}*G74{m&TU2Nx!y6#-Y;f57d>}+L3HY1%QW1c-guYUOXXgA@u
zbmY6z&m==bZq93j=ip6kwl7h-q)$d#BaGm#TV=*In^yP?=sUNtepE)9?e-;%a+^!*
zu{?+$n`Npiz(SAG$4q@i`%P`Hc$ldow|(ZuW54>L`X1jXd%Glay)8qt)_`#pAzD2$
zERW3B12&|^2C)VgHEd~_o(bLkKNrK;PQ@_&(iM#=gY~}O#3}LV0=eDYo!}-gil2!$
z5wnwuq<XOAA~HUqv9G|gw%wpX@zcP^dgv)+)kjD!2pS}YEVyU;owUE}{afPWcK#@y
z51Be6J6w#-^SU!aG>UFUXY^5Gno*Mc;Cv%`#5|(tLGMJE#cZkaYE4s>OgdlI*Powx
z%7MG1wHe;UM>T;?B|nU&Z?HoRIBE7aS533N|BxLaXW7ML8r1F=-u&o8Ufh&V7DOB<
zHJD{!U+dpqVFa#MGPm)xagVVLmEZ6b(;c&b@LLvl4S$kiM2x6Rx{&H5XuUjTix-t#
zbaH438K~ydBXd&?S14%>4Zfhp?059ecqN}bd2go(-+XpudoM}e{pBiuV!SxEX6B6y
znWt8jKMJ3gQL=?M9~j-V@p(OWq{%Cuq&DxSTpq<;^B_i^ZgCqpJ;pVWc_N@=EoG=b
z%A-o_!jex(9Iy2y;KMxz9PSZ-x0TQB9<QLH0FGot0AmrcBZGIA)1nlnMvVLyuO(i4
ze#cw4Q>9;)^nHK#ye;E>uy%;{JEi%E&r7YX%WH@4P{>t;KdR2w4KH%)Q7y*`(|%w*
z2o|ppC>><jTH=+!(9aR!oGstlT7Z{~<PN|C@@S$)n=6Y_Chq5Z<Xbe{<H3v4jvhD4
zC7Wf`VaDE0%upUxVAw&c40>`~<(*1`6GMTDe0r_M$CoFxvU?=MOG<QEwdPnSeVZ*k
z$X9;~TJl?1*JpVG16sldjA9uy?qo*olKQs}bcuht*l`xt|LNJy75^-iI%#V9M-jqa
zK&&Z+Qso3~R&A&>Rt;wlmK|^D(j%Zp9%dyr!I<kP0(v_wFMoqL%X&Bvw~^vUCvX1(
z-`S}xU%c(bS=k5Bd_Nk-hn3y(2lc7W<y*Jj>fn3a?K9z!VN|G}loowvsmYp|s7l+L
zWzyb0sa=qY?GN;SZb`!AFMr0`?R?=)T+BvbNT11)6QvU}Y4R!Jg5Qu>P_pg`YI)@|
z+r%4aWsIB5dk|EPyjyA>0DG30-6zamDw99R57}$akyZ7as^kmaDzLw4VF>9~Vv8=%
zK1FGYzFp)o@8(Sw1^qc4zL&jz)Vb-*^7e@Tj_Q!=55;Qx;yL389(e!z;psAk$Bxp;
z-pq9wTQGqYXBBF$p!X+vvs5B%^%rN~@^5W$fW6k&CD8n+Bkd)P*DNum;+{SC6}lIl
zgiZjGhiK8=Kot)m8;6ZRZI0+-IUO^%H!{EGkh;ymS<`^LA!pCMD;c1vovItU;~yN;
zEyDdR(wtA_cSx-LpL<3_v7)S)Rt=&A5d)wS9OAuEMSl74yT{_(_b54(ccr`*=`?RI
zlk=aBTPd;$+t=Ok!~W5^d6PhDyh5umvpRf%Z}v`AOrbZ^rleoz4&l+sgL{4Jt`Uu*
z)E1MWB^@V|x7m{`XaMioU{Ilc{^VzH=Z*#6#CBzxa66)%m6D=ULDl1_5VRE0WBr^0
zwVgw;a~=%$8L_vuXS2aKGV(GZ1j-!TGmD6nx-#V3oO-l*p%=`1;L7tQct-AcqJ2$M
z6brY0)tfP~F)dPKO!tHvM2J&#43ZsJdm<JxJFD;Ln-%8jxblepE}<Y*C-gPzcY8jT
zWrF8)UO#HXHFLt8H$F7LTixqNgw(QCv53a-IdvAYkg@lX>tnXY%nU;`X1<9{DH%pb
zt|yhDv;5Wzvj`ETgblWo!oKtfGn0d#?k6v1-HqV{mW42r!YP|`U!EVb)|ouPuU#5V
z+NJ$nsY0ZFcqYHj5~gc^{<8F7R)lFE`Gh*c>J86Ko`k>~D~-E}hmuIx>gMyHC$rn8
zy9>94$emS_4heAg&YE=n=awDgXp10v-$qeYwQS%NEbIOAnU;l*Gvj?9Q>{I*J!RVW
zoEjqdHZqAx&ACCJ`R46n`X|=hj&1FfTWp;k`p}$t4txEXbO5&~ebr%-#_hYs)E_Q}
z6ZAd1hhAx&CNF)f&401|`OGL9Bl`T|cegncGw)71z|X+4aX8&B6P1=^sN`cWujhcy
zoCaofV;2Wtk@ege*I-q))Q#-M{)s^~<=tjMQCz}ebsb#Ky&ZQ>^TdURrgG25G>D^3
zN4s^Z1wtQaC$k-!PFy%2Hl`oD=qQ>Ec=g4gK2|f|LEJoY_0v}6E0?auT>D^Xjgf0e
z)v)?PzA(dp`isB~6@nbZ!BS0vWoDSB(2Lq1eU-@@*mpkP3Xz>H#cyj51mhTM?taP9
zfupVIY`{E(-n5r;j+fspujW-hBS0TKgsXjOL0P$9Q$0bk%oz+FuxzHuI8tC_y_MNA
zQm$>>ed?Px0+8TBQ~2CcCFJ8kA9dt~fAkodqN!~ss~{>4?M~On$?<T0i&HCwtyar6
zTcv@Y@BrO@y2~#|{W-UeY|#tZVCT~yY`Q|JP#Wm%X^A@630n5tz2r`n9f_~)*{>mz
zjG21=RpN6Y49UskR=`p{6AIC~TO}#q<Yf6&m_%^j-ih6l+3J(-yC3QjRUz^y+nH8Z
zVlTA(Md*~Ou#)J&*jTVsu$z{#=5PhYIic-nH>3Kh=&6Jp<$F9reg)diyhy{efGCmO
zj)65hq3Cc?R{rt1?r!kZ8>Pa!Esl+L@?d(>J*fyyr#7K>W-L!A`%Q^_#^=;_pzj+a
z9hv2yG3)2NXxDR8gtgkGzl`I;ILWYc@w}Bk4+=d`T~Ga9)Rcw_v3{UwsPS1M;LAmy
z?W2s?_|3?Iez~OY8#Lw#PL6>Ix+B_AH3eNN7mQQ*F$AB`>hd$@m*tw*6a8O2&rUe$
zUA!-L<akf*r&F$MUAe6t*9Sr|3{ITnC%AkbG5JLTk~tS-HQ&h?Cy?jW@;p<lhnW#p
z?^}QzKa}n|F&<9HDCJw!?z6DQG(FjY_@d?*$V1&i9L{1hoj$y#!dmKtNEi4>IhVHB
zvVV$>eAqQ|`x*C7f#jZGOooiC9%a0`Dx;o6j(%xd8DPIzBZ2hlxpTfIlPjZ>1sPAu
znr@f?1+($o&L<uY2?P3z@ruE?xrM^>{q)yE67;M2?QF5LSeu_u$Qq(#bfA%{XXMV|
zw&||!O3KtQHkO0Pt@waq4Jod)wS3L}TnCBd(U592Tl^aD{^xAOCtWyc`^P2FJOSTa
z^$ye9kEtuRL6S*!nbVPOI&L?F;{7&p{Oo_cv&<(IAhOU9FG&r@BUq2z>7LtEwu7b9
zZ!khU;$L}1*BguxoaWL-7FG|+cqf~0y~pW{`m~iaAM5yr(6uw?gup#TDqDef+t_{B
zR$pYI;zfIrdf%!i;>gTJY6KfIVclE{%UEz6Yi-2))9PqMLkoA19NmfDth|NY7uga=
z5syXd2qES*HWwn(k8Shtvb~cXvAgF_-q9@);g&O?4@3iR2H9yRVk~LPec7XU$c<k#
zer%X&{@^wGx%m0hl)2Q#f+m*6j>65!cp3`yB;p9l^sjccZAoZ@%1Yhz{J0SlUk*8^
z%wGzX>2lF8ej{E0%=-#3tC|sVL9nAu;;4(qg=^~t6n#q6HD2c@%(NLv)t3+N$PoaF
zM=Ob}9<{0^d&T*TYwz7cmQSebI4%hY2rM2+mP)gwKVRO%i_rB1$GjI`NXJ+b`BuuO
z9VD8AT2h_xHGB_|&-jj}8V9_*DDvrp@{GrO-HCo7OeX)Tz-N(dp*)rgy)^}JuNv!>
zj655C1d2qR_t@6>Ts9M|zO;;0kaov*)!gK0<epOPPa!eTS?RyIGX?wO()Ry_U#6rX
zBBLvQd1p%fKi!$S#4m#&uct#m05}l%2TVWc@~#uYQTi87J^*_8Rou+Q#LV6m*#nG(
zL;JT^)c<RkerYZlF8OOv{hCOOGackrc7%(Gm6eH=vx%D>^0TX%vz3btmob+y!o<eK
z7U5#aW$cXnXy$5bX72ir&%aUiO^^s_wn*6h-#BTPSG3HW+z_^xK>t?mW?beDZq8g5
zTo%q|2;`{Oq5f^nTwJ*9kXPvK-Rz9boL#IekPvIXK-L_&91+fD_P;p(`t+NhBT_a8
zQ?CDn`u`jL{|~@_D^IT9Gx!s*&5g^=-W18r#KGC@U)cZG(Eop3C;RIL|7AIVt2g+0
zVgJ0d4+cQE!T-E$_UG*~ZXmKk!+(3bEZIvy{pV4K)%RB%GFY%PLCEK4BvBP_$<Gq3
z?mPi~eAaB*oqV58u8h$%yo^g`!t6-Ix9sU_(`Zvx-(0~j{ma88TaAq!7t4bEyjv~?
zM`<ow3s{*jaJ;5V(-(1@c_(qJygTYQ1J~*Clyy+p&=3S9PY4I3=`do4g$V}PP}FtE
zvGU^6khfY;G}Pm@l;gEb2{7h7J;107i}L8Lb6<sm5>a?y+^CO5zoPgt43ck1c0Lj{
zMkN%$dd!qyhQh-^QvG8gnAwqPBb>=Io67WAmU0v7W4ar#K}9l3!sAdn{WN4P)6?$n
z!p=XZzJ)M(s*0l;6UBc;k;p-#4rN5cwUlCdhnk^^t)Q~|lXmTBQI~<^Gs@~A{Y5|L
zMJ&zgljek<6puVynDGbEg=w||ndbcO@<{z;RHWGmr2TNQIm$>^N|t!9?{*{xAmBML
zLzj%E{4xHMFlUS~bYzqzk9IlMM|<rcL>!0{Rjg|ONj%>Y4&aN9BcsF@asSD@9=nox
z=OTr5gVx9w#U|_y`i<A<s>O|4wgK#K!o}vPfbcF!7M2^*H&A8FbKYWv5TO{d1UB<#
z`Jt5Gl>lmEgfgqfpd@A-qs4gM7>-50M{z^)2k=6I6lJ>?iTnQu#VFJe4=Zr6F$<Z{
zI=}f1<=rq>9!emn5x@vJBvr>~vj0hEw$pTM7?&_{L6fNU3eU`8yHWa47n)HEmo)3r
z3AU;tUVum!B;kjIjx1<b>HJG+e&K?j@9XTq^0#RMSpfFCENtw@KQn<u;ljcTVM2zO
zT`ND$rS6z14Or4}M_9R{#|DMe2;?=Wk!3yK>rm6ZZS9u(0{%FnJzJ}XcI#_?sh9qk
z0K=QE`-hRLyxOEzq$l-_nFmn?N07}?-MhPCa^!*!_sb0B>kq!ZZ8I+r^lH{OVm3W#
z?Ov-g)FjHoxs_XkO?cmB3Jjf0p`i%30tgN$rR7?e9TwQiVr!_E4al~=coLcv`6<28
zAKdm5C@SbXbY}Y1??va2IFuB}C%T<G{m0$}Xa2Zinl1A<abhLUFK9dP-5xY~ap{MC
zNU3-{c3Qje#J=U#a=Xo&GIl02x5bYXpIF40Wr`)ocoBlyRc4cdh4qtF2y8pTqxfJ^
zxq0>YP`Bz^7X^;%<9Rk~EXQw`xR*uK#;2Z(XRy8I)yQs}eXf*Wo5iAY#u4&tzRZab
zdwVBGPwndk$Svw96uSa**e6$@%6JIZv&SMHdnlHj_ZuI2+}@+b&>w~(w<`&zs}kJH
z?0B~{xV40m+!W#y?6|5Nv6j!?(;X5Kb6a$Mw~r#=&OFZ#E*&>7-6-{Bw+Pe;UbI`b
zdaWqLRovRIoKoNIEQQ)*<d0AZX;_H$J%c}7{hZ)XZyr7|vSsf{R_tf1p*_T^JX%6G
zk;`nm%dh=@!&~1u@WsuP85IB5Zi+c>dB!J|pIcw4GJBrxCEs${s8NWKP;u&OLn$nd
z$C#>ISxxqD=L^UFTKD3E0!*-D;Y*1njVrM1elC4gsJx+)M@(iV=J27a)fCG*f<~Yq
z4uOJm^Akq&>wW~jv!z=6R|mE@7xS~%<P;5++=G*S8GLG7+gd{kr#(!e<Ax7amp1DS
zjd$<kdr4&$C7+7=-htHmq{djVSBww|wiJE0HT+y*l496m@#B;81wek$%oDUpiQBs#
z)s(?j%>soEHsc@40H3yRX5{$LSPJZkHPI*nTveAfb;u}x=!W?HP&^Plv@dOM2=6zN
z@4wfYq#@6!C3YcOFt7Rc)kN!<UYFmujqTFdK1-7Ty*Me4V>Ezufxb+POq+lr8;@~C
zdsnQDP+QpS;UM|mxVseYQ|cek!}+L}19}g{76Py)p8`J^$P9m1r)hBb#7-`Gd&fcs
z=VXe@{|WjRU|?rGnIb`C3Qn1KS4PuCf~Fmnczw+7);ZZL4t4x(0epU~n7Qs8|7Uh=
z71SvijHUX$Q5XKUzTbGCcRXQb@j#;(I*UuKUvIWURa&3sAKy5Abj~7IB6s86*AZIA
zI~6q1E_?J_x-p3jpC1sntL&#N*#j~44EA+J3xprE{tV-7_O3pROzX225s<W6vm!s5
zDR5@ur>`-JzlSid6)3-nXnpAq?YnE5JeE$8idU=iX{NcnkiB6JFki+(o&`4NpLH{y
zOn`XSq#k~P%*6I;ui){XM-2*S%<loxbqdU1aqtSaPC9^(Wu+rP!z6u;mUu%-?(*-C
zUI%PNn=Gu6JoRhZC5s4H^`%=TPw9P5(!g0w_{`;nMVt`tz1IAM9BSVSI#g{!Qd?RU
zvM_g{uiq73e5~+UNc$+%15MGpN$N8lQ>v=%iR;5<h4o$yWZCOmRo|(y^pun;dR&4x
z_T(Y#g<+)IK!%BSk&@|j_LJpdCOoQoBeT_WnIHkuPc1KSiU}nSzMj*co{jV?Jy)dX
zoq#+VB2hV?IXKl}vY1*&ZH<b1yVY+3sTU%7-w=@Fz3&&zq3czL@6Ok2_Ql!z#CO3i
zciw@4LO)V}|NIj>F&gznXysX4@$0N9h1;8`vHiEamy8Zx9`|CrHzVz1JRV&)dq`Hn
z;cESa%IWQ(YvX(VEWOFR!XNJ{b4d9q%&T9$JBhgOl7>&6jo;)|6!_9Mkap%wlk;&T
z-b&6+;e*FaktLJfLGNW~cNtc5RwqFQ@r5f#a^D1%QPo&-+STaK+tD?WdPj%jU|&_C
zIUKVLy)vD0igOCHo3W($CW4t9hg*1->ys;H_|%-Q!X_yzqZc@8i^xeYaJo4<d%8`Q
z!jcR9er&CR?$eG=i6*=p?~!zWHlCxlgEl#cO1t+7+s#Gh+f#F=^!HyH>@}k}8IP+J
z!)buaJpdrV2aAKPBh2S68)-!!jGf!*?P<uqL+;+s_onw{6*JKvEL`sEw3t6Ok}Fnx
zjmo1mcFJ1JWqr%NXq1vb9o0((tt5gg`(}-{8%_DE_?v!#E*^dw+)&MfGlpkqB)|)E
zf&^~+k$tUu=)Tb|3pe$?3{DB#e$-Wm8hdzj7nQ$+uG>B??3Se$)x*T!RaZ)w=rm*Q
zCY5xd#26fsn&HY6$q6B_ekCA!Q~z=KOJnv(foW^9XCzizf<PZw-VB~!>;XLy>5bGc
zjJVHh?{)CpZ6W>4VM4c;TqQBvXLx^66Pp-+Wya;?y_!#ruJLx##lz0e=x*f$2X}m#
zG$zto1E<4^_Ch|3tz%24Jgl%1-efDsZOf`MyLj>5Ke1MujG%Z*P)JS824<F5Bc8i@
z0HTLaGpN;7J*xf$g<wq?m`D?BcDq-7n|<aDDQJE^Q<n2EpwiBwcX83ND*uC}AJm3`
z;(eakD56%KBH=;Ox8ZQ+E;(KJ{%W&a8(IhQ&DjZvZ4BThB~__P!NaExB-PN62BC1K
ze9=Xv?M98GJJTkwv(xhv4N1=34FV&!UAb(jnY{4o@v6E!YWQK1FK8YElk|yk?rD~u
z5~`r=PYS#c^gjVI17CIIWO_vqy5Bo5O%W8}-*@TErf8_2sXAjHJnK^H^BagvS;?hU
za<7h_xiGhw5G-rg48zWS&Yt(!Dg%x+{wO$mub2-qNZs+h_Ko&3y^NLnpe8hlGvt-g
z)0<R>F=1szXtgfn0^?{29~frX1m3-jWITPP$fbb#W$Ib@oe`1Jjr?HBUKC|u9u_{+
z%S9>=3`OGVJ$aYCLa&thQI;gOT1W+^8CkEi$gS@ZOZ1dlBA<=bmV619o7F{Qg$Je{
zQ7hBa+Yu-k>Y*|v{J?;4*YvyKQ8chZFU;>t$>|-UY1lCr7blx0_<lgQdDCJ-dT47y
zRbo8s3P*E#l(mKRLbLDIm+6GPZG|rUy7X_%Z|0c%7;X}t1-pgUeG<yMMISjf@#f_a
zr}0PaH{;2#qJ|%}ucq^5SC$)}5*93l-+dw6PSJ7{dK(~?Q?_qiq-SUL<D%a-O6ACb
zd(HY;oM1}a_Xp#or+cBznq5nzBO;GT=yz<3eaddKk#yP8uhj||G%Vd?FH9=1mv?q9
z<f@u^jDKoJ&qEU}2%{)V44W!v;R)gH9{0OL{;{s9J2qMAz7VC1_wh7}CKYey9KP0>
z)CPL=Czq-*R?e1^wjO;n&pWY^hmN#gd4_okmbP9~Idj^8XlivZC;5q7-N$+@3GWb?
ztk8nre{g6{(;9E+4+pB!ykn_*+?!O{RgkXWC~NQu-K^}WLrz}R4>tjUAG?r#SmXBg
zy{V98iI$$^$5vU%Jq(&zGB>JXqVF{^$CBoa4$}Os3jr~OO8%T928)aC?tRTX``#(b
zJ-L{o3u|4kezMm^Jvi(O-tacS67DLo<7>Q7|GJ4RVV&xxty0`4|Ednt@$Mc;Bh7}0
zMG<6Nhsy1zDko(V_WDY6iez(Fl01FB6^1x&?8B5Vw@s({C;2{Q%oW|=$l>d&FyWt#
zsGmM&(0S3rNRp}iQTFhun*F`>3wZ7%(4C99ki*+`%6`hu`}>N$Ny!tbsn9xMhI9&?
znbghotlS=|EUvP-MG=?RK6Qbf7X9H<1@TLR>FnEMso_+_v^kJGy+PcSY7X-X(*2f(
zHO2-F(ePfAg>k7)*JcyLJgHA|?x40U-<M^S7sY984~q1<IJ>~jjd|kB>F-M0vNwP)
zD`HZ4x*v!Zd9djc&^~r}6C#?-a9&p@uX(66_<Tm7oV)<EAiGQA!`}JMpXpm#eetYT
zH<P(FuIke}d1rnq=#8w6WDh8VkJ5`$7OU#AmIiEc?$>ZO2(wjW3XQ;thn7lo?NXOW
z-iHwo-5)Y;e6wSvbDqZO^Qd{v-(R2MwxIZlV;pDVgY3@fp12=O&&GSd>*wg-g!Nji
zb_rE=Kz8WZ$(`KU6qWi_d-)jO#Zt@Z@o79-z>GxG{KOL2mf_uX;3s}DZPL(f=oKoe
z;Ke7q*Bvvn0j<p&OVK?3R65vx(|y-H^keatJXwNRA}y1fF4lraW3aJL26ro#ob^cd
zj#&c`H*lt*9bfD#4hm^%uxLrL$mL(hDt$iDGPM3=ujpqOLuRWtgWL*|4LDkE4KE=~
z)hyQ_gEsx_+39<HcPfhC`v})}ND2fl$K9~9O?F-DE0rgsnpHv5$zM0cwgp6uK2e$0
zl^|o2Fgc8L_Ih$Fo>b!8RW$mYxo)w$IV1@^HHrs!^y_|V#51$D;S<;`FIY%1R4nRU
z<kv-)8@U(sVmq6gMe+~*EDs+01faVWYHWSNQJ*PQt3I)~iv*_vqA6y2DYY%@GxYRj
zc-X{RKsmS@P?bUh4q9W!2-3-B1*gurzjgM?N^QNTZdfYs3`H2<tIG~LAU9WM_KhD_
zDp&SjTW>#n;9bW9>GeK*v557t)-@&nMDfnxH_~Qwtq00y)K#C`$Qxd8N!=&k@A!Eu
zH@dU<-(;2kzm$JeRF>6|Q~I4%`VX-9m(?GU(D*!HZUB^*=l_3J35kgKA3%5z$h6R9
zmd6~K)v@|jtI>fAnX37nmH8hOL@uwtP<pP_Q2Zl_@~?~<5&+1}*wxF?4DhQSCNljc
zif}QLbU^06xU@u&^^z{@0*Gq=%BvxXm$@-#D@RucX8`;X)<_iz32Ei*;(7_uh|Izu
zF%^+{tY2S1VB}a@R;I3&E&$k7S^fkJ`tM{>64g=Fxh%$sl;zSIS7f<N7yc#7Wut$|
z0zyJp{*Ns1%gP9UW|#hbrtyE%%ay{QS46q=vA;z@D&k+F{Gk^3WmU^RMfvwYQU9AL
zS4ubhEy}MV5Pyln{hurZzlxgqCurt>XCWQAzkouoh;j)z`j;rM%i^8?be2C2^t<W5
zihuH468@3?`|o7AilTKzm}{O30$!#M|0NCb+do|Q(pCSo5$MlSr2m~XSM$?Xq`Bt1
zSJn~Ilm8*i@23A!&7X<U|4x>xQSFK>*PNFd`ln+4a9-H&rvH)!biL$=GQz^l1({!W
za6^U@<Uq=osbyCHQro}1LC(t51)%rK^#Gt>W(R<N=^Ft0H97$N`~Sed45t4_L0HIj
zEBu$teuW|cvbYD*tN`RAfnWdpCUXA@4FK+6_-21{<Gz&UZx8(MxN-k77yy}szGTDm
zn;Xw>ZqVOE=rwN8|AQNH;rx3=LVt6E{T>*0ZQ$Q}|6k^DY2M#9`DIL`etsDW@N536
z$UW|I8h<JV1ia++_lRN$SA?yD#ifu)>;Kc(e>e*8Qu+Vrr0ncq>Ski*3}A6IHCH#&
zz7OK$2694>TbbD9(+lKA!-Ay#<14b%usHIO27pDJ4-5o>km-F02n>XC!`XpgW+0Fm
z*-pX1^#5w2?u>ABG&2QoNg`}r%#f0*OK5XSy4l(qBkb)jMNzl3aseR!{uT+~=3-@U
z0kE|)c64xbv^8_)0BBx5G;y#8KsZ6%ARb=u|44lw%n1gtXqg#<#Q-o)9!@ALz{U}Q
z+yc!I0QY}(xupN$%bw0==2$?aq99nnfBpcVJUmG6Gza_-4a9xvOP4<Y`+w3Pm;U=V
z4G08XrNQAa;MKlxI1d!*hJW>i!@+Q*g|E=K!PjWKpzAa^=+a59^t~(>bcMzXzVxEM
z+5wTItMUQCJeOP2-|av=mz($BGzb)lI(?PKbLqE#w*$kj$pYj7g0HpX<^^6K4|W-V
z{vMA9`TXe`4Su<pue1YQE~UR|Fd+Eae4$9CUTp`x#Gk&>7Y;?DKVGHra9`Ck5C*z#
zb6&{hLF{i?kS4k|9xv>gZvf#i7&0>d)fWT;BcZ>q(m<f=Ja{i-(cgW+Fz{8qfWT1T
zbsi8T#^sg15FY4t8uw+8y}|>2O{d6ZbQy*JZilS2d({s>5a>1gf{+XH>fAucv;Q?6
za9^(6zj?rUxv%*j2nyx7>IWbw5BF6+0P%4Do3#bMt``{m+S&)fV3(Wi-}8mSF1Luk
zX>eZXRhdD^AaSiPjQ5(2z(C;TcKY{tyu6@mbK?bGTdQE?4sw+*7|44~=F4Dzl?U?i
z{55-k!JupQK=R<d$^*{J!+X`1U<ed^orc_DuFMUL{GIRWx&$Lle$^+zNZ+`sXD|eI
zEjEF9xUa=TFb~hQcn?PIGuOt0a$k!j$Z&eOE&pW?B*^MDdw`M4<JvsnJlAy!hhOta
z2+|F%u4xD__qBG&Re5c_aq}SmT#=6l4!fpj9$w^%yV4E{K`Q1N4SsEIP#Ea)H1wAa
zpfKd?09R?e*Y_DHFZ_D!gn%zkEq{#%hrq7s9u7k;q^s?Cq42A+z>zWbs_v0>=`PQ^
z|KQ>3jIctUHLwH(09<NT-e$iJ2wbWT4wnaLq<t@coszLPcR+qa_WJcr9H1w_BLW9Q
zCB?zKB5;T(@=PHDhVjC{Vj@sDGDRT*0ty2D?<V>HK|w4RSA?_cud@kqIr4I2F)~Uh
HNn-s!kSPqG

literal 0
HcmV?d00001

diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
new file mode 100644
index 00000000..c33e457f
--- /dev/null
+++ b/doc/interface_functions.tex
@@ -0,0 +1,1107 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage[utf8x]{inputenc}
+
+%opening
+\title{Interface functions}
+\author{Martijn Wehrens}
+
+\begin{document}
+
+\maketitle
+
+\tableofcontents
+
+\section{Introduction}
+This document gives an overview of functions that are usefull to end-users of the enhanced Green's Functions Reaction Dynamics (eGFRD) algorithm. In other words, it lists the "interface functions".
+Basically, this entails a list of function definition plus their so-called python "docstrings", obtained straight from the code.
+Note that functions starting with an underscore are actually C++ functions ported to python by boost. 
+
+\section{Functions}
+
+\subsection{Functions from \texttt{model.py}}
+
+\subsubsection{Core functions:}
+As mentioned, all documentation in this document comes straight from the code. To obtain more information on how to structure a simple script, one could take a look into the sample directory.
+
+
+The class you need to set up a particle model:
+\begin{verbatim}
+ class ParticleModel(_gfrd.Model):
+    """
+    """
+    def __init__(self, world_size):
+        """Create a new ParticleModel.
+
+        Arguments:
+            - world_size
+                the size of one side of the simulation "world". Units: 
+                meters.
+
+        The simulation "world" is always assumed to be a cube with 
+        *periodic boundary conditions*, with 1 corner at [0, 0, 0] and 
+        the corner furthest away from [0, 0, 0] being at
+        [world_size, world_size, world_size].
+
+        """
+\end{verbatim}
+
+\begin{verbatim}
+def Species(name, D, radius=0, structure="world", drift=0):
+    """Define a new Species (in/on a specific Region or Surface).
+
+    Arguments:
+        - name
+            the name of this Species.
+        - D
+            the diffusion constant for this Species in/on this 
+            Region or Surface. Units: meters^2/second.
+        - radius
+            the radius for this Species in/on this Region or Surface. 
+            Units: meters.
+        - structure
+            the Region or Surface in/on which this Species can exist.  
+            Optional. If you do not specify a Structure the Species is 
+            added to the "world".
+        - drift
+            the drift term for this ParticleType on a 
+            CylindricalSurface (1D drift). Units: meters/second. 
+            Optional.
+
+    If a certain Species should be able to exist in the "world" as 
+    well as in/on one of the previously created Regions or Surfaces, 
+    then two distinct Species should be created. One with and one 
+    without an explicit Structure argument.
+
+    """
+\end{verbatim}
+
+Species should be added to the model:
+\begin{verbatim}
+
+    def add_reaction_rule(self, reaction_rule):
+        """Add a ReactionRule to the ParticleModel.
+
+        Argument:
+            - reaction rule
+                a ReactionRule created by one of the functions
+                model.create_<>_reaction_rule.
+
+        """
+\end{verbatim}
+
+\subsubsection{Creating regions}
+
+\begin{verbatim}
+_gfrd.create_cuboidal_region.__doc__ = \
+"""create_cuboidal_region(id, corner, diagonal)
+
+Create and return a new cuboidal Region.
+
+Arguments:
+    - id
+        a descriptive name.
+    - corner
+        the point [x, y, z] of the cuboidal Region closest to
+        [0, 0, 0]. Units: [meters, meters, meters]
+    - diagonal
+        the vector [x, y, z] from the corner closest to [0, 0, 0], to 
+        the corner furthest away from [0, 0, 0]. Units:
+        [meters, meters, meters]
+
+"""
+
+_gfrd.create_cylindrical_surface.__doc__ = \
+"""create_cylindrical_surface(id, corner, radius, orientation, length)
+
+Create and return a new cylindrical Surface.
+
+Arguments:
+    - id
+        a descriptive name.
+    - corner
+        the point [x, y, z] on the axis of the cylinder closest to 
+        [0, 0, 0]. Units: [meters, meters, meters]
+    - radius
+        the radius of the cylinder. Units: meters.
+    - orientation
+        the unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the 
+        axis of the cylinder.
+    - length
+        the length of the cylinder. Should be equal to the world_size. 
+        Units: meters.
+
+Surfaces are not allowed to touch or overlap.
+
+"""
+
+_gfrd.create_planar_surface.__doc__ = \
+"""create_planar_surface(id, corner, unit_x, unit_y, length_x, length_y)
+
+Create and return a new planar Surface.
+
+Arguments:
+    - id
+        a descriptive name.
+    - corner
+        the point [x, y, z] on the plane closest to [0, 0, 0]. Units: 
+        [meters, meters, meters]
+    - unit_x
+        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the 
+        plane.
+    - unit_y
+        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the plane 
+        and perpendicular to unit_x.
+    - length_x
+        the length of the plane along the unit vector unit_x. Should be 
+        equal to the world_size. Units: meters.
+    - length_y
+        the length of the plane along the unit vector unit_y. Should be 
+        equal to the world_size. Units: meters.
+
+Surfaces are not allowed to touch or overlap.
+
+"""
+\end{verbatim} 
+
+As particles, regions should be added to the model. 
+\begin{verbatim}
+    def add_structure(self, structure):
+        """Add a Structure (Region or Surface) to the ParticleModel.
+
+        Arguments:
+            - structure
+              a Region or Surface created with one of the functions
+              model.create_<>_region or model.create_<>_surface.
+
+        """
+        assert isinstance(structure, _gfrd.Structure)
+        self.structures[structure.id] = structure
+        return structure
+\end{verbatim}
+
+\subsubsection{Adding reaction rules to the model}
+
+Function set\_all\_repulsive is called automatically, but it's docstring is instructive.
+\begin{verbatim}
+    def set_all_repulsive(self):
+        """Set all 'other' possible ReactionRules to be repulsive.
+
+        By default an EGFRDSimulator will assume:
+            - a repulsive bimolecular reaction rule (k=0) for each 
+              possible combination of reactants for which no 
+              bimolecular reaction rule is specified. 
+          
+        This method explicitly adds these ReactionRules to the 
+        ParticleModel.
+
+        """
+\end{verbatim}
+
+\begin{verbatim}
+def create_unimolecular_reaction_rule(reactant, product, k):
+    """Example: A -> B.
+
+    Arguments:
+        - reactant
+            a Species.
+        - product 
+            a Species.
+        - k
+            reaction rate. Units: per second. (Rough order of magnitude: 
+            1e-2 /s to 1e2 /s).
+
+    The reactant and the product should be in/on the same 
+    Region or Surface.
+
+    There is no distinction between an intrinsic and an overall reaction 
+    rate for a unimolecular ReactionRule.
+
+    A unimolecular reaction rule defines a Poissonian process.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_decay_reaction_rule(reactant, k):
+    """Example: A -> 0.
+
+    Arguments:
+        - reactant
+            a Species.
+        - k
+            reaction rate. Units: per second. (Rough order of magnitude: 
+            1e-2 /s to 1e2 /s).
+
+    There is no distinction between an intrinsic and an overall reaction 
+    rate for a decay ReactionRule.
+
+    A decay reaction rule defines a Poissonian process.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_annihilation_reaction_rule(reactant1, reactant2, ka):
+    """Example: A + B -> 0.
+
+    Arguments:
+        - reactant1
+            a Species.
+        - reactant2
+            a Species.
+        - ka
+            intrinsic reaction rate. Units: meters^3 per second. (Rough 
+            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s).
+
+    The reactants should be in/on the same Region or Surface.
+
+    ka should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
+    the function utils.k_a(kon, kD), but only for reaction rules in 3D.
+
+    By default an EGFRDSimulator will assume a repulsive 
+    bimolecular reaction rule (ka=0) for each possible combination of 
+    reactants for which no bimolecular reaction rule is specified. 
+    You can explicitly add these reaction rules to the model with the 
+    method model.ParticleModel.set_all_repulsive.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_binding_reaction_rule(reactant1, reactant2, product, ka):
+    """Example: A + B -> C.
+
+    Arguments:
+        - reactant1
+            a Species.
+        - reactant2
+            a Species.
+        - product
+            a Species.
+        - ka
+            intrinsic reaction rate. Units: meters^3 per second. (Rough 
+            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
+
+    The reactants and the product should be in/on the same 
+    Region or Surface.
+
+    A binding reaction rule always has exactly one product.
+
+    ka should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
+    the function utils.k_a(kon, kD), but only for reaction rules in 3D.
+
+    By default an EGFRDSimulator will assume a repulsive 
+    bimolecular reaction rule (ka=0) for each possible combination of 
+    reactants for which no bimolecular reaction rule is specified. 
+    You can explicitly add these reaction rules to the model with the 
+    method model.ParticleModel.set_all_repulsive.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_unbinding_reaction_rule(reactant, product1, product2, kd):
+    """Example: A -> B + C.
+
+    Arguments:
+        - reactant
+            a Species.
+        - product1
+            a Species.
+        - product2
+            a Species.
+        - kd
+            intrinsic reaction rate. Units: per second. (Rough order of 
+            magnitude: 1e-2 /s to 1e2 /s).
+
+    The reactant and the products should be in/on the same 
+    Region or Surface.
+
+    An unbinding reaction rule always has exactly two products.
+
+    kd should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (koff) for this reaction rule to an intrinsic 
+    reaction rate (kd) with the function utils.k_d(koff, kon, kD) or 
+    utils.k_d_using_ka(koff, ka, kD).
+
+    An unbinding reaction rule defines a Poissonian process.
+
+    """
+\end{verbatim}
+
+To put this reactions into effect one should also call \texttt{add\_reaction\_rule}, e.g.:
+\begin{verbatim}
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+    m.network_rules.add_reaction_rule(r1)
+\end{verbatim}
+
+\subsection{Functions from \texttt{gfrdbase.py}}
+
+\subsubsection{Core functions}
+
+\begin{verbatim}
+def create_world(m, matrix_size=10):
+    """Create a world object.
+    
+    The world object keeps track of the positions of the particles
+    and the protective domains during an eGFRD simulation.
+
+    Arguments:
+        - m
+            a ParticleModel previously created with model.ParticleModel.
+        - matrix_size
+            the number of cells in the MatrixSpace along the x, y and z 
+            axis. Leave it to the default number if you don't know what 
+            to put here.
+
+    The simulation cube "world" is divided into (matrix_size x matrix_size 
+    x matrix_size) cells. Together these cells form a MatrixSpace. The 
+    MatrixSpace keeps track in which cell every particle and protective 
+    domain is at a certain point in time. To find the neigherest 
+    neighbours of particle, only objects in the same cell and the 26 
+    (3x3x3 - 1) neighbouring cells (the simulation cube has periodic
+    boundary conditions) have to be taken into account.
+
+    The matrix_size limits the size of the protective domains. If you 
+    have fewer particles, you want a smaller matrix_size, such that the 
+    protective domains and thus the eGFRD timesteps can be larger. If 
+    you have more particles, you want a larger matrix_size, such that 
+    finding the neigherest neighbours is faster.
+    
+    Example. In samples/dimer/dimer.py a matrix_size of
+    (N * 6) ** (1. / 3.) is used, where N is the average number of 
+    particles in the world.
+
+    """
+\end{verbatim}
+
+
+\subsubsection{Handling objects}
+
+\begin{verbatim}
+def get_closest_surface(world, pos, ignore):
+    """Return
+      - closest surface
+      - distance to closest surface
+    
+    We can not use matrix_space, it would miss a surface if the 
+    origin of the surface would not be in the same or neighboring 
+    cells as pos."""
+\end{verbatim}
+
+\begin{verbatim}
+def get_closest_surface_within_radius(world, pos, radius, ignore):
+    """Return:
+      - surface within radius or None
+      - closest surface (regardless of radius)
+      - distance to closest surface"""
+\end{verbatim}
+
+\subsubsection{Adding particles}
+\begin{verbatim}
+functions
+def throw_in_particles(world, sid, n):
+    """Add n particles of a certain Species to the specified world.
+
+    Arguments:
+        - sid
+            a Species previously created with the function 
+            model.Species.
+        - n
+            the number of particles to add.
+
+    Make sure to first add the Species to the model with the method
+    model.ParticleModel.add_species_type.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def place_particle(world, sid, position):
+    """Place a particle of a certain Species at a specific position in 
+    the specified world.
+
+    Arguments:
+        - sid
+            a Species previously created with the function 
+            model.Species.
+        - position
+            a position vector [x, y, z]. Units: [meters, meters, meters].
+
+    Make sure to first add the Species to the model with the method 
+    model.ParticleModel.add_species_type.
+
+    """
+\end{verbatim}
+
+\subsection{Functions from \texttt{egfrd.py}}
+
+\subsubsection{Core functions}
+\begin{verbatim}
+class EGFRDSimulator(ParticleSimulatorBase):
+    """
+    """
+    def __init__(self, world, rng=myrandom.rng, network_rules=None):
+        """Create a new EGFRDSimulator.
+
+        Arguments:
+            - world
+                a world object created with the function 
+                gfrdbase.create_world.
+            - rng
+                a random number generator. By default myrandom.rng is 
+                used, which uses Mersenne Twister from the GSL library.
+                You can set the seed of it with the function 
+                myrandom.seed.
+            - network_rules
+                you don't need to use this, for backward compatibility only.
+
+        """
+\end{verbatim}
+
+\begin{verbatim}
+    def step(self):
+        """Execute one eGFRD step.
+
+        """
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+\begin{verbatim}
+    def stop(self, t):
+        """Synchronize all particles at time t.
+
+        With eGFRD, particle positions are normally updated 
+        asynchronously. This method bursts all protective domains and 
+        assigns a position to each particle.
+
+        Arguments:
+            - t
+                the time at which to synchronize the particles. Usually 
+                you will want to use the current time of the simulator: 
+                EGFRDSimulator.t.
+
+        This method is called stop because it is usually called at the 
+        end of a simulation. It is possible to call this method at an 
+        earlier time. For example the Logger module does this, because 
+        it needs to know the positions of the particles at each log 
+        step.
+
+        """
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+\subsubsection{Simulator time (manipulation) functions}
+
+\begin{verbatim}
+    def get_next_time(self):
+    """ 
+    Returns the time it will be when the next egfrd timestep
+    is completed.
+    """ 
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+
+\begin{verbatim}
+    def reset(self):
+    """
+    This function resets the "records" of the simulator. This means
+    the simulator time is reset, the step counter is reset, events
+    are reset, etc.
+    Can be for example usefull when users want to "stirr" the 
+    simulation before starting the "real experiment".
+    """
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+\subsubsection{Get data}
+\begin{verbatim}
+    def print_report(self, out=None):
+        """Print various statistics about the simulation.
+        
+        Arguments:
+            - None
+
+        """
+\end{verbatim}
+
+\subsubsection{Additional functions}
+The class \texttt{EGFRDSimulator} contains several functions which might be usefull to eGFRD users in very specific cases. Because of their specific nature, they don't contain docstrings. 
+\begin{verbatim}
+    def get_matrix_cell_size(self):
+        return self.containers[0].cell_size
+
+    def set_user_max_shell_size(self, size):
+        self.user_max_shell_size = size
+
+    def get_user_max_shell_size(self):
+        return self.user_max_shell_size
+
+    def get_max_shell_size(self):
+        return min(self.get_matrix_cell_size() * .5 / SAFETY,
+                   self.user_max_shell_size)
+\end{verbatim}
+
+\subsection{Functions from \texttt{dumper.py}}
+
+\subsubsection{Getting information on species/particles}
+\begin{verbatim}
+def get_species(sim):
+    """Return an iterator over the Species in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_species(sim):
+    """Return a string containing the Species in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def get_species_names(sim):
+    """Return an iterator over the names of the Species in the 
+    simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_species_names(sim):
+    """Return a string containing the names of the Species in the 
+    simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _get_species_type_by_name(sim, name):
+    """ Return the type of a species with a certain name
+
+    Arguments:
+        - sim
+            an EGFRDSimulator
+        - name
+            species name
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _get_particles_by_sid(sim, sid):
+    """ Return a generator (using "yield") to loop over (pid, particle).
+    
+    Arguments:
+        - sim
+            an EGFRDSimulator
+        - sid
+            ID of a species
+
+    E.g.:
+    
+    myparticles = _get_particles_by_sid(sim, sid)
+
+    for mypid, myparticle in myparticles:
+        print str(str(mypid), str(myparticle))
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def get_particles(sim, identifier=None):
+    """Return an iterator over the
+    (particle identifier, particle)-pairs in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+        - identifier
+            a Species or the name of a Species. If none is specified, 
+            all (particle identifier, particle)-pairs will be returned.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_particles(sim, identifier=None):
+    """Return a string containing the
+    (particle identifier, particle)-pairs in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+        - identifier
+            a Species or the name of a Species. If none is specified, 
+            all (particle identifier, particle)-pairs will be returned.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _get_number_of_particles_by_sid(sim, sid):
+    """ 
+    Returns the number of particles of a certain species.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+        - sid
+            ID of a species    
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def get_number_of_particles(sim, identifier=None):
+    """Return the number of particles of a certain Species in the 
+    simulator.
+
+    Arguments:
+        - sim
+            either an EGFRDSimulator or a GillespieSimulator.
+        - identifier
+            a Species. Optional. If none is specified, a list of 
+            (Species name, number of particles)-pairs will be returned.
+
+    """ 
+\end{verbatim}
+
+\begin{verbatim}
+def dump_number_of_particles(sim, identifier=None):
+    """Return a string containing the number of particles of a certain 
+    Species in the simulator.
+
+    Arguments:
+        - sim
+            either an EGFRDSimulator or a GillespieSimulator.
+        - identifier
+            a Species. Optional. If none is specified, 
+            a string of (Species name, number of particles)-pairs will 
+            be returned.
+
+    """ 
+\end{verbatim}
+
+\subsubsection{Get information on domains}
+
+\begin{verbatim}
+def get_domains(egfrdsim):
+    """Return an iterator over the protective domains in the simulator.
+
+    Arguments:
+        - egfrdsim
+            an EGFRDSimulator
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_domains(egfrdsim):
+    """Return an string containing the protective domains in the 
+    simulator.
+
+    """
+\end{verbatim}
+
+subsubsection{Get information on reaction rules}
+
+\begin{verbatim}
+def get_reaction_rules(model_or_simulator):
+    """Return three lists with all the reaction rules defined in the 
+    ParticleModel or EGFRDSimulator.
+
+    The three lists are:
+        - reaction rules of only one reactant.
+        - reaction rules between two reactants with a reaction rate 
+          larger than 0.
+        - repulsive reaction rules between two reactants with a 
+          reaction rate equal to 0.
+
+    Arguments:
+        - model_or_simulator
+            a ParticleModel or EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _dump_reaction_rule(model, reaction_rule):
+    """Helper. Return ReactionRule as string.
+
+    ReactionRule.__str__ would be good, but we are actually getting a 
+    ReactionRuleInfo or ReactionRuleCache object."""
+\end{verbatim}
+
+\begin{verbatim}
+def dump_reaction_rules(model_or_simulator):
+    """Return a formatted string containing all the reaction rules 
+    defined in the ParticleModel or EGFRDSimulator.
+
+    Arguments:
+        - model_or_simulator
+            a ParticleModel or EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\subsection{Functions from \texttt{utils.py}}
+
+This file contains functions on common mathematical objects, transformations and formulas. Some of these functions are used throughout the algorithm, and some are supplied for convenience. 
+For the user, none of these functions are \textit{needed} to make a simulation work, but some might come in handy.
+
+\subsubsection{Mathematical comparisons}
+\begin{verbatim}
+def feq(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a and b are equal, subject to given tolerances.  
+    Float comparison.
+
+    Also see numpy.allclose().
+
+    The (relative) tolerance must be positive and << 1.0
+
+    Instead of specifying an absolute tolerance, you can speciy a 
+    typical value for a or b. The absolute tolerance is then the 
+    relative tolerance multipied by this typical value, and will be 
+    used when comparing a value to zero. By default, the typical 
+    value is 1."""
+
+def fgreater(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is greater than b, subject to given tolerances.  
+    Float comparison."""
+
+def fless(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is less than b, subject to given tolerances.  
+    Float comparison."""
+
+def fgeq(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is greater or equal than b, subject to given 
+    tolerances. Float comparison."""
+
+def fleq(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is less than or equal than b, subject to given 
+    tolerances. Float comparison."""
+
+\end{verbatim}
+
+\subsubsection{Conversions}
+
+As these functions only contain a single line of formula code, this line is also supplied.
+\begin{verbatim}
+def per_M_to_m3(rate):
+    """Convert a reaction rate from units 'per molar per second' to 
+    units 'meters^3 per second'.
+
+    """
+    return rate / (1000 * N_A)
+
+def per_microM_to_m3(rate):
+    """Convert a reaction rate from units 'per micromolar per second' to 
+    units 'meters^3 per second'.
+
+    """
+    return per_M_to_m3(rate * 1e6)
+
+def M_to_per_m3(molar):
+    """Convert a concentration from units 'molar' to units 'per 
+    meters^3'.
+
+    """
+    return molar * (1000 * N_A)
+
+def microM_to_per_m3(micromolar):
+    """Convert a concentration from units 'micromolar' to units 'per 
+    meters^3'.
+
+    """
+    return M_to_per_m3(micromolar / 1e6) 
+
+def C2N(c, V):
+    """Calculate the number of particles in a volume 'V' (dm^3) 
+    with a concentration 'c' (mol/dm^3).
+
+    """
+    return c * V * N_A  # round() here?
+\end{verbatim}
+
+Conversions involving rates:
+\begin{verbatim}
+
+def k_D(Dtot, sigma):
+    """Calculate the 'pseudo-'reaction rate (kD) caused by diffusion.
+    
+    kD is equal to 1 divided by the time it takes for two particles to 
+    meet each other by diffusion. It is needed when converting from 
+    an intrinsic reaction rate to an overall reaction rates or vice 
+    versa.
+
+    Example:
+        - A + B -> C.
+
+    Arguments:
+        - Dtot:
+            the diffusion constant of particle A plus the diffusion 
+            constant of particle B. Units: meters^2/second.
+        - sigma
+            the radius of particle A plus the radius of particle B. 
+            Units: meters.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    return 4.0 * numpy.pi * Dtot * sigma
+
+def k_a(kon, kD):
+    """Convert an overall reaction rate (kon) for a binding/annihilation 
+    reaction rule to an intrinsic reaction rate (ka).
+
+    Example:
+        - A + B -> C
+            binding reaction rule
+        - A + B -> 0
+            annihilation reaction rule
+
+    Arguments:
+        - kon
+            the overall reaction rate for the reaction rule. Units: 
+            meters^3/second.
+        - kD
+            the 'pseudo-'reaction rate caused by the diffusion of 
+            particles A and B. See the function k_D(). Units: 
+            meters^3/second.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    if kon > kD:
+        raise RuntimeError, 'kon > kD.'
+    ka = 1. / ((1. / kon) - (1. / kD))
+    return ka
+
+def k_d(koff, kon, kD):
+    """Convert an overall reaction rate (koff) for an unbinding reaction 
+    rule to an intrinsic reaction rate (kd).
+
+    This one is a bit tricky. We consider reaction rules with only 1 
+    reactant. In case there is only 1 product also, no conversion in 
+    necessary. But when the reaction rule has 2 products, we need to 
+    take the reverse reaction rule into account and do the proper 
+    conversion.
+
+    Example:
+        - C -> A + B
+            unbinding reaction rule
+        - A + B -> C
+            reverse reaction rule
+
+    Arguments:
+        - koff
+            the overall reaction rate for the unbinding reaction rule.  
+            Units: meters^3/second.
+        - kon
+            the overall reaction rate for the reverse reaction rule. 
+            Units: meters^3/second.
+        - kD
+            the 'pseudo-'reaction rate caused by the diffusion of 
+            particles A and B. See the function k_D(). Units: 
+            meters^3/second.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    ka = k_a(kon, kD)
+    kd = k_d_using_ka(koff, ka, kD)
+    return kd
+
+def k_d_using_ka(koff, ka, kD):
+    """Convert an overall reaction rate (koff) for an unbinding reaction 
+    rule to an intrinsic reaction rate (kd).
+
+    Similar to the function k_d(), but expects an intrinsic rate (ka) 
+    instead of an overall rate (kon) for the reversed reaction rule as 
+    the second argument.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    kd =  koff * (1 + float(ka) / kD)
+    return kd
+
+def k_on(ka, kD):
+    """Convert an intrinsic reaction rate (ka) for a binding/annihilation 
+    reaction rule to an overall reaction rate (kon).
+
+    The inverse of the function k_a().
+    
+    Rarely needed.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    kon = 1. / ((1. / kD) + (1. / ka))  # m^3/s
+    return kon
+
+def k_off(kd, kon, kD):
+    """Convert an intrinsic reaction rate (kd) for an unbinding reaction 
+    rule to an overall reaction rate (koff).
+
+    The inverse of the function k_d().
+
+    Rarely needed.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    ka = k_a(kon, kD) 
+    koff = k_off_using_ka(kd, ka, kD)
+    return koff
+
+def k_off_using_ka(kd, ka, kD):
+    """Convert an intrinsic reaction rate (kd) for an unbinding reaction 
+    rule to an overall reaction rate (koff).
+
+    Similar to the function k_off(), but expects an intrinsic rate 
+    (ka) instead of an overall rate (kon) as the second argument.
+
+    Rarely needed.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    koff = 1. / (float(ka) / (kd * kD) + (1. / kd))
+    return koff
+\end{verbatim}
+
+
+\subsubsection{Some convenient functoins}
+
+These functions do not contain docstrings, are sometimes self-explanatory and probably not needed that often in simulations. Therefore only definitions of functions that might be of interest to the user are listed here:
+
+Mean arrival time:
+\begin{verbatim}
+def mean_arrival_time(r, D):
+    return (r * r) / (6.0 * D)
+\end{verbatim}
+
+Calculating with distances:
+\begin{verbatim}
+def distance_sq_array_simple(position1, positions, fsize = None):
+    
+def distance_array_simple(position1, positions, fsize = None):
+
+distance = _gfrd.distance
+
+distance_cyclic = _gfrd.distance_cyclic
+
+def distance_sq_array_cyclic(position1, positions, fsize):
+    
+def distance_array_cyclic(position1, positions, fsize = 0):
+
+\end{verbatim}
+
+Some vector functions:
+\begin{verbatim}
+def cartesian_to_spherical(c):
+
+def spherical_to_cartesian(s):
+
+def random_unit_vector_s():
+
+def random_unit_vector():
+
+def random_vector(r):
+
+def random_vector2D(r):
+
+def length(a):
+
+def normalize(a, l=1):
+
+def vector_angle(a, b):
+
+def vector_angle_against_z_axis(b):
+
+def crossproduct(a, b):
+
+def crossproduct_against_z_axis(a):
+
+def rotate_vector(v, r, alpha):
+\end{verbatim}
+
+\subsection{Notes on other files}
+
+\subsubsection{\texttt{bd.py}: Brownian Dynamic Simulator}
+The class \texttt{BDSimulator} can be used in the same way as the EGFRDSimulator class, but performs Brownian Dynamics (BD) instead. Users who want to perform eGFRD simulations never need this. The simulator can be used for comparison of the eGFRD algorithm with Brownian Dynamics. 
+
+\subsubsection{\texttt{gillespie.py}: Gillespie Simulator}
+Similar to the BD simulator, the class \texttt{GillespieSimulatorBase} can be used for Gillespie type simulations. 
+
+\subsubsection{\texttt{legacy.py}: Old redundant functions}
+This module is called nowhere in the Python code. It contains an archive of outdated code.
+
+\subsubsection{\texttt{multi.py}, \texttt{pair.py}, \texttt{single.py}}
+These file contain the code that handle the specific events that happen in the different categories of domains.
+
+\subsubsection{\texttt{myrandom.py}}
+Contains a few convenient lines of code used when using random functions.
+ 
+\subsubsection{\texttt{make\_cjy\_table.py.py}, \texttt{make\_sjy\_table.py.py}}
+Generate (respectively cylindrical and spherical) bessel function tables.
+
+
+\subsection{Function from module \texttt{logger.py}}
+
+This module contains two loggers. One logger that logs in the hdf5 format, for obvious reasons in class \texttt{HDF5Logger}. Note that this logger requires the module h5py. The other logger gives output dictated more by the nature of the eGFRD algorithm.
+The loggers are not (yet) explained in very much detail here, but both function in the same way. A logger class is made, which takes input on to which file to write, the logger can be started by \texttt{start()} and steps are logged by the function \texttt{log()}.
+
+\subsubsection{HDF5 logger}
+
+\begin{verbatim}
+class HDF5Logger(object):
+    def __init__(self, logname, directory='data', split=False):
+
+    def log(self, sim, time):      
+
+    def start(self, sim):
+\end{verbatim}
+
+\subsubsection{"Normal" logger}
+\begin{verbatim}
+class Logger(object):
+    def __init__(self, logname='log', directory='data', comment=''):
+
+    def log(self, sim, time):
+
+    def start(self, sim):
+\end{verbatim}
+
+(Note that not all functions contained by this class are listed, just functions deemed usefull for user interface.)
+
+\section{Todo}
+
+- \texttt{sid = identifier.id} gives the sid, but what exactly is identifier?
+
+\end{document}
diff --git a/doc/interface_functions.tex~ b/doc/interface_functions.tex~
new file mode 100644
index 00000000..9181447f
--- /dev/null
+++ b/doc/interface_functions.tex~
@@ -0,0 +1,1107 @@
+\documentclass[a4paper,10pt]{article}
+\usepackage[utf8x]{inputenc}
+
+%opening
+\title{Interface functions}
+\author{Martijn Wehrens}
+
+\begin{document}
+
+\maketitle
+
+\tableofcontents
+
+\section{Introduction}
+This document gives an overview of functions that are usefull to end-users of the enhanced Green's Functions Reaction Dynamics (eGFRD) algorithm. In other words, it lists the "interface functions".
+Basically, this entails a list of function definition plus their so-called python "docstrings", obtained straight from the code.
+Note that functions starting with an underscore are actually C++ functions ported to python by boost. 
+
+\section{Functions}
+
+\subsection{Functions from \texttt{model.py}}
+
+\subsubsection{Core functions:}
+As mentioned, all documentation in this document comes straight from the code. To obtain more information on how to structure a simple script, one could take a look into the sample directory.
+
+
+The class you need to set up a particle model:
+\begin{verbatim}
+ class ParticleModel(_gfrd.Model):
+    """
+    """
+    def __init__(self, world_size):
+        """Create a new ParticleModel.
+
+        Arguments:
+            - world_size
+                the size of one side of the simulation "world". Units: 
+                meters.
+
+        The simulation "world" is always assumed to be a cube with 
+        *periodic boundary conditions*, with 1 corner at [0, 0, 0] and 
+        the corner furthest away from [0, 0, 0] being at
+        [world_size, world_size, world_size].
+
+        """
+\end{verbatim}
+
+\begin{verbatim}
+def Species(name, D, radius=0, structure="world", drift=0):
+    """Define a new Species (in/on a specific Region or Surface).
+
+    Arguments:
+        - name
+            the name of this Species.
+        - D
+            the diffusion constant for this Species in/on this 
+            Region or Surface. Units: meters^2/second.
+        - radius
+            the radius for this Species in/on this Region or Surface. 
+            Units: meters.
+        - structure
+            the Region or Surface in/on which this Species can exist.  
+            Optional. If you do not specify a Structure the Species is 
+            added to the "world".
+        - drift
+            the drift term for this ParticleType on a 
+            CylindricalSurface (1D drift). Units: meters/second. 
+            Optional.
+
+    If a certain Species should be able to exist in the "world" as 
+    well as in/on one of the previously created Regions or Surfaces, 
+    then two distinct Species should be created. One with and one 
+    without an explicit Structure argument.
+
+    """
+\end{verbatim}
+
+Species should be added to the model:
+\begin{verbatim}
+
+    def add_reaction_rule(self, reaction_rule):
+        """Add a ReactionRule to the ParticleModel.
+
+        Argument:
+            - reaction rule
+                a ReactionRule created by one of the functions
+                model.create_<>_reaction_rule.
+
+        """
+\end{verbatim}
+
+\subsubsection{Creating regions}
+
+\begin{verbatim}
+_gfrd.create_cuboidal_region.__doc__ = \
+"""create_cuboidal_region(id, corner, diagonal)
+
+Create and return a new cuboidal Region.
+
+Arguments:
+    - id
+        a descriptive name.
+    - corner
+        the point [x, y, z] of the cuboidal Region closest to
+        [0, 0, 0]. Units: [meters, meters, meters]
+    - diagonal
+        the vector [x, y, z] from the corner closest to [0, 0, 0], to 
+        the corner furthest away from [0, 0, 0]. Units:
+        [meters, meters, meters]
+
+"""
+
+_gfrd.create_cylindrical_surface.__doc__ = \
+"""create_cylindrical_surface(id, corner, radius, orientation, length)
+
+Create and return a new cylindrical Surface.
+
+Arguments:
+    - id
+        a descriptive name.
+    - corner
+        the point [x, y, z] on the axis of the cylinder closest to 
+        [0, 0, 0]. Units: [meters, meters, meters]
+    - radius
+        the radius of the cylinder. Units: meters.
+    - orientation
+        the unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the 
+        axis of the cylinder.
+    - length
+        the length of the cylinder. Should be equal to the world_size. 
+        Units: meters.
+
+Surfaces are not allowed to touch or overlap.
+
+"""
+
+_gfrd.create_planar_surface.__doc__ = \
+"""create_planar_surface(id, corner, unit_x, unit_y, length_x, length_y)
+
+Create and return a new planar Surface.
+
+Arguments:
+    - id
+        a descriptive name.
+    - corner
+        the point [x, y, z] on the plane closest to [0, 0, 0]. Units: 
+        [meters, meters, meters]
+    - unit_x
+        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the 
+        plane.
+    - unit_y
+        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the plane 
+        and perpendicular to unit_x.
+    - length_x
+        the length of the plane along the unit vector unit_x. Should be 
+        equal to the world_size. Units: meters.
+    - length_y
+        the length of the plane along the unit vector unit_y. Should be 
+        equal to the world_size. Units: meters.
+
+Surfaces are not allowed to touch or overlap.
+
+"""
+\end{verbatim} 
+
+As particles, regions should be added to the model. 
+\begin{verbatim}
+    def add_structure(self, structure):
+        """Add a Structure (Region or Surface) to the ParticleModel.
+
+        Arguments:
+            - structure
+              a Region or Surface created with one of the functions
+              model.create_<>_region or model.create_<>_surface.
+
+        """
+        assert isinstance(structure, _gfrd.Structure)
+        self.structures[structure.id] = structure
+        return structure
+\end{verbatim}
+
+\subsubsection{Adding reaction rules to the model}
+
+Function set\_all\_repulsive is called automatically, but it's docstring is instructive.
+\begin{verbatim}
+    def set_all_repulsive(self):
+        """Set all 'other' possible ReactionRules to be repulsive.
+
+        By default an EGFRDSimulator will assume:
+            - a repulsive bimolecular reaction rule (k=0) for each 
+              possible combination of reactants for which no 
+              bimolecular reaction rule is specified. 
+          
+        This method explicitly adds these ReactionRules to the 
+        ParticleModel.
+
+        """
+\end{verbatim}
+
+\begin{verbatim}
+def create_unimolecular_reaction_rule(reactant, product, k):
+    """Example: A -> B.
+
+    Arguments:
+        - reactant
+            a Species.
+        - product 
+            a Species.
+        - k
+            reaction rate. Units: per second. (Rough order of magnitude: 
+            1e-2 /s to 1e2 /s).
+
+    The reactant and the product should be in/on the same 
+    Region or Surface.
+
+    There is no distinction between an intrinsic and an overall reaction 
+    rate for a unimolecular ReactionRule.
+
+    A unimolecular reaction rule defines a Poissonian process.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_decay_reaction_rule(reactant, k):
+    """Example: A -> 0.
+
+    Arguments:
+        - reactant
+            a Species.
+        - k
+            reaction rate. Units: per second. (Rough order of magnitude: 
+            1e-2 /s to 1e2 /s).
+
+    There is no distinction between an intrinsic and an overall reaction 
+    rate for a decay ReactionRule.
+
+    A decay reaction rule defines a Poissonian process.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_annihilation_reaction_rule(reactant1, reactant2, ka):
+    """Example: A + B -> 0.
+
+    Arguments:
+        - reactant1
+            a Species.
+        - reactant2
+            a Species.
+        - ka
+            intrinsic reaction rate. Units: meters^3 per second. (Rough 
+            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s).
+
+    The reactants should be in/on the same Region or Surface.
+
+    ka should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
+    the function utils.k_a(kon, kD), but only for reaction rules in 3D.
+
+    By default an EGFRDSimulator will assume a repulsive 
+    bimolecular reaction rule (ka=0) for each possible combination of 
+    reactants for which no bimolecular reaction rule is specified. 
+    You can explicitly add these reaction rules to the model with the 
+    method model.ParticleModel.set_all_repulsive.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_binding_reaction_rule(reactant1, reactant2, product, ka):
+    """Example: A + B -> C.
+
+    Arguments:
+        - reactant1
+            a Species.
+        - reactant2
+            a Species.
+        - product
+            a Species.
+        - ka
+            intrinsic reaction rate. Units: meters^3 per second. (Rough 
+            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
+
+    The reactants and the product should be in/on the same 
+    Region or Surface.
+
+    A binding reaction rule always has exactly one product.
+
+    ka should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
+    the function utils.k_a(kon, kD), but only for reaction rules in 3D.
+
+    By default an EGFRDSimulator will assume a repulsive 
+    bimolecular reaction rule (ka=0) for each possible combination of 
+    reactants for which no bimolecular reaction rule is specified. 
+    You can explicitly add these reaction rules to the model with the 
+    method model.ParticleModel.set_all_repulsive.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def create_unbinding_reaction_rule(reactant, product1, product2, kd):
+    """Example: A -> B + C.
+
+    Arguments:
+        - reactant
+            a Species.
+        - product1
+            a Species.
+        - product2
+            a Species.
+        - kd
+            intrinsic reaction rate. Units: per second. (Rough order of 
+            magnitude: 1e-2 /s to 1e2 /s).
+
+    The reactant and the products should be in/on the same 
+    Region or Surface.
+
+    An unbinding reaction rule always has exactly two products.
+
+    kd should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (koff) for this reaction rule to an intrinsic 
+    reaction rate (kd) with the function utils.k_d(koff, kon, kD) or 
+    utils.k_d_using_ka(koff, ka, kD).
+
+    An unbinding reaction rule defines a Poissonian process.
+
+    """
+\end{verbatim}
+
+To put this reactions into effect one should also call \texttt{add_reaction_rule}, e.g.:
+\begin{verbatim}
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+    m.network_rules.add_reaction_rule(r1)
+\end{verbatim}
+
+\subsection{Functions from \texttt{gfrdbase.py}}
+
+\subsubsection{Core functions}
+
+\begin{verbatim}
+def create_world(m, matrix_size=10):
+    """Create a world object.
+    
+    The world object keeps track of the positions of the particles
+    and the protective domains during an eGFRD simulation.
+
+    Arguments:
+        - m
+            a ParticleModel previously created with model.ParticleModel.
+        - matrix_size
+            the number of cells in the MatrixSpace along the x, y and z 
+            axis. Leave it to the default number if you don't know what 
+            to put here.
+
+    The simulation cube "world" is divided into (matrix_size x matrix_size 
+    x matrix_size) cells. Together these cells form a MatrixSpace. The 
+    MatrixSpace keeps track in which cell every particle and protective 
+    domain is at a certain point in time. To find the neigherest 
+    neighbours of particle, only objects in the same cell and the 26 
+    (3x3x3 - 1) neighbouring cells (the simulation cube has periodic
+    boundary conditions) have to be taken into account.
+
+    The matrix_size limits the size of the protective domains. If you 
+    have fewer particles, you want a smaller matrix_size, such that the 
+    protective domains and thus the eGFRD timesteps can be larger. If 
+    you have more particles, you want a larger matrix_size, such that 
+    finding the neigherest neighbours is faster.
+    
+    Example. In samples/dimer/dimer.py a matrix_size of
+    (N * 6) ** (1. / 3.) is used, where N is the average number of 
+    particles in the world.
+
+    """
+\end{verbatim}
+
+
+\subsubsection{Handling objects}
+
+\begin{verbatim}
+def get_closest_surface(world, pos, ignore):
+    """Return
+      - closest surface
+      - distance to closest surface
+    
+    We can not use matrix_space, it would miss a surface if the 
+    origin of the surface would not be in the same or neighboring 
+    cells as pos."""
+\end{verbatim}
+
+\begin{verbatim}
+def get_closest_surface_within_radius(world, pos, radius, ignore):
+    """Return:
+      - surface within radius or None
+      - closest surface (regardless of radius)
+      - distance to closest surface"""
+\end{verbatim}
+
+\subsubsection{Adding particles}
+\begin{verbatim}
+functions
+def throw_in_particles(world, sid, n):
+    """Add n particles of a certain Species to the specified world.
+
+    Arguments:
+        - sid
+            a Species previously created with the function 
+            model.Species.
+        - n
+            the number of particles to add.
+
+    Make sure to first add the Species to the model with the method
+    model.ParticleModel.add_species_type.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def place_particle(world, sid, position):
+    """Place a particle of a certain Species at a specific position in 
+    the specified world.
+
+    Arguments:
+        - sid
+            a Species previously created with the function 
+            model.Species.
+        - position
+            a position vector [x, y, z]. Units: [meters, meters, meters].
+
+    Make sure to first add the Species to the model with the method 
+    model.ParticleModel.add_species_type.
+
+    """
+\end{verbatim}
+
+\subsection{Functions from \texttt{egfrd.py}}
+
+\subsubsection{Core functions}
+\begin{verbatim}
+class EGFRDSimulator(ParticleSimulatorBase):
+    """
+    """
+    def __init__(self, world, rng=myrandom.rng, network_rules=None):
+        """Create a new EGFRDSimulator.
+
+        Arguments:
+            - world
+                a world object created with the function 
+                gfrdbase.create_world.
+            - rng
+                a random number generator. By default myrandom.rng is 
+                used, which uses Mersenne Twister from the GSL library.
+                You can set the seed of it with the function 
+                myrandom.seed.
+            - network_rules
+                you don't need to use this, for backward compatibility only.
+
+        """
+\end{verbatim}
+
+\begin{verbatim}
+    def step(self):
+        """Execute one eGFRD step.
+
+        """
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+\begin{verbatim}
+    def stop(self, t):
+        """Synchronize all particles at time t.
+
+        With eGFRD, particle positions are normally updated 
+        asynchronously. This method bursts all protective domains and 
+        assigns a position to each particle.
+
+        Arguments:
+            - t
+                the time at which to synchronize the particles. Usually 
+                you will want to use the current time of the simulator: 
+                EGFRDSimulator.t.
+
+        This method is called stop because it is usually called at the 
+        end of a simulation. It is possible to call this method at an 
+        earlier time. For example the Logger module does this, because 
+        it needs to know the positions of the particles at each log 
+        step.
+
+        """
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+\subsubsection{Simulator time (manipulation) functions}
+
+\begin{verbatim}
+    def get_next_time(self):
+    """ 
+    Returns the time it will be when the next egfrd timestep
+    is completed.
+    """ 
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+
+\begin{verbatim}
+    def reset(self):
+    """
+    This function resets the "records" of the simulator. This means
+    the simulator time is reset, the step counter is reset, events
+    are reset, etc.
+    Can be for example usefull when users want to "stirr" the 
+    simulation before starting the "real experiment".
+    """
+\end{verbatim}
+(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
+
+\subsubsection{Get data}
+\begin{verbatim}
+    def print_report(self, out=None):
+        """Print various statistics about the simulation.
+        
+        Arguments:
+            - None
+
+        """
+\end{verbatim}
+
+\subsubsection{Additional functions}
+The class \texttt{EGFRDSimulator} contains several functions which might be usefull to eGFRD users in very specific cases. Because of their specific nature, they don't contain docstrings. 
+\begin{verbatim}
+    def get_matrix_cell_size(self):
+        return self.containers[0].cell_size
+
+    def set_user_max_shell_size(self, size):
+        self.user_max_shell_size = size
+
+    def get_user_max_shell_size(self):
+        return self.user_max_shell_size
+
+    def get_max_shell_size(self):
+        return min(self.get_matrix_cell_size() * .5 / SAFETY,
+                   self.user_max_shell_size)
+\end{verbatim}
+
+\subsection{Functions from \texttt{dumper.py}}
+
+\subsubsection{Getting information on species/particles}
+\begin{verbatim}
+def get_species(sim):
+    """Return an iterator over the Species in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_species(sim):
+    """Return a string containing the Species in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def get_species_names(sim):
+    """Return an iterator over the names of the Species in the 
+    simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_species_names(sim):
+    """Return a string containing the names of the Species in the 
+    simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _get_species_type_by_name(sim, name):
+    """ Return the type of a species with a certain name
+
+    Arguments:
+        - sim
+            an EGFRDSimulator
+        - name
+            species name
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _get_particles_by_sid(sim, sid):
+    """ Return a generator (using "yield") to loop over (pid, particle).
+    
+    Arguments:
+        - sim
+            an EGFRDSimulator
+        - sid
+            ID of a species
+
+    E.g.:
+    
+    myparticles = _get_particles_by_sid(sim, sid)
+
+    for mypid, myparticle in myparticles:
+        print str(str(mypid), str(myparticle))
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def get_particles(sim, identifier=None):
+    """Return an iterator over the
+    (particle identifier, particle)-pairs in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+        - identifier
+            a Species or the name of a Species. If none is specified, 
+            all (particle identifier, particle)-pairs will be returned.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_particles(sim, identifier=None):
+    """Return a string containing the
+    (particle identifier, particle)-pairs in the simulator.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+        - identifier
+            a Species or the name of a Species. If none is specified, 
+            all (particle identifier, particle)-pairs will be returned.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _get_number_of_particles_by_sid(sim, sid):
+    """ 
+    Returns the number of particles of a certain species.
+
+    Arguments:
+        - sim
+            an EGFRDSimulator.
+        - sid
+            ID of a species    
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def get_number_of_particles(sim, identifier=None):
+    """Return the number of particles of a certain Species in the 
+    simulator.
+
+    Arguments:
+        - sim
+            either an EGFRDSimulator or a GillespieSimulator.
+        - identifier
+            a Species. Optional. If none is specified, a list of 
+            (Species name, number of particles)-pairs will be returned.
+
+    """ 
+\end{verbatim}
+
+\begin{verbatim}
+def dump_number_of_particles(sim, identifier=None):
+    """Return a string containing the number of particles of a certain 
+    Species in the simulator.
+
+    Arguments:
+        - sim
+            either an EGFRDSimulator or a GillespieSimulator.
+        - identifier
+            a Species. Optional. If none is specified, 
+            a string of (Species name, number of particles)-pairs will 
+            be returned.
+
+    """ 
+\end{verbatim}
+
+\subsubsection{Get information on domains}
+
+\begin{verbatim}
+def get_domains(egfrdsim):
+    """Return an iterator over the protective domains in the simulator.
+
+    Arguments:
+        - egfrdsim
+            an EGFRDSimulator
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def dump_domains(egfrdsim):
+    """Return an string containing the protective domains in the 
+    simulator.
+
+    """
+\end{verbatim}
+
+subsubsection{Get information on reaction rules}
+
+\begin{verbatim}
+def get_reaction_rules(model_or_simulator):
+    """Return three lists with all the reaction rules defined in the 
+    ParticleModel or EGFRDSimulator.
+
+    The three lists are:
+        - reaction rules of only one reactant.
+        - reaction rules between two reactants with a reaction rate 
+          larger than 0.
+        - repulsive reaction rules between two reactants with a 
+          reaction rate equal to 0.
+
+    Arguments:
+        - model_or_simulator
+            a ParticleModel or EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\begin{verbatim}
+def _dump_reaction_rule(model, reaction_rule):
+    """Helper. Return ReactionRule as string.
+
+    ReactionRule.__str__ would be good, but we are actually getting a 
+    ReactionRuleInfo or ReactionRuleCache object."""
+\end{verbatim}
+
+\begin{verbatim}
+def dump_reaction_rules(model_or_simulator):
+    """Return a formatted string containing all the reaction rules 
+    defined in the ParticleModel or EGFRDSimulator.
+
+    Arguments:
+        - model_or_simulator
+            a ParticleModel or EGFRDSimulator.
+
+    """
+\end{verbatim}
+
+\subsection{Functions from \texttt{utils.py}}
+
+This file contains functions on common mathematical objects, transformations and formulas. Some of these functions are used throughout the algorithm, and some are supplied for convenience. 
+For the user, none of these functions are \textit{needed} to make a simulation work, but some might come in handy.
+
+\subsubsection{Mathematical comparisons}
+\begin{verbatim}
+def feq(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a and b are equal, subject to given tolerances.  
+    Float comparison.
+
+    Also see numpy.allclose().
+
+    The (relative) tolerance must be positive and << 1.0
+
+    Instead of specifying an absolute tolerance, you can speciy a 
+    typical value for a or b. The absolute tolerance is then the 
+    relative tolerance multipied by this typical value, and will be 
+    used when comparing a value to zero. By default, the typical 
+    value is 1."""
+
+def fgreater(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is greater than b, subject to given tolerances.  
+    Float comparison."""
+
+def fless(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is less than b, subject to given tolerances.  
+    Float comparison."""
+
+def fgeq(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is greater or equal than b, subject to given 
+    tolerances. Float comparison."""
+
+def fleq(a, b, typical=1, tolerance=TOLERANCE):
+    """Return True if a is less than or equal than b, subject to given 
+    tolerances. Float comparison."""
+
+\end{verbatim}
+
+\subsubsection{Conversions}
+
+As these functions only contain a single line of formula code, this line is also supplied.
+\begin{verbatim}
+def per_M_to_m3(rate):
+    """Convert a reaction rate from units 'per molar per second' to 
+    units 'meters^3 per second'.
+
+    """
+    return rate / (1000 * N_A)
+
+def per_microM_to_m3(rate):
+    """Convert a reaction rate from units 'per micromolar per second' to 
+    units 'meters^3 per second'.
+
+    """
+    return per_M_to_m3(rate * 1e6)
+
+def M_to_per_m3(molar):
+    """Convert a concentration from units 'molar' to units 'per 
+    meters^3'.
+
+    """
+    return molar * (1000 * N_A)
+
+def microM_to_per_m3(micromolar):
+    """Convert a concentration from units 'micromolar' to units 'per 
+    meters^3'.
+
+    """
+    return M_to_per_m3(micromolar / 1e6) 
+
+def C2N(c, V):
+    """Calculate the number of particles in a volume 'V' (dm^3) 
+    with a concentration 'c' (mol/dm^3).
+
+    """
+    return c * V * N_A  # round() here?
+\end{verbatim}
+
+Conversions involving rates:
+\begin{verbatim}
+
+def k_D(Dtot, sigma):
+    """Calculate the 'pseudo-'reaction rate (kD) caused by diffusion.
+    
+    kD is equal to 1 divided by the time it takes for two particles to 
+    meet each other by diffusion. It is needed when converting from 
+    an intrinsic reaction rate to an overall reaction rates or vice 
+    versa.
+
+    Example:
+        - A + B -> C.
+
+    Arguments:
+        - Dtot:
+            the diffusion constant of particle A plus the diffusion 
+            constant of particle B. Units: meters^2/second.
+        - sigma
+            the radius of particle A plus the radius of particle B. 
+            Units: meters.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    return 4.0 * numpy.pi * Dtot * sigma
+
+def k_a(kon, kD):
+    """Convert an overall reaction rate (kon) for a binding/annihilation 
+    reaction rule to an intrinsic reaction rate (ka).
+
+    Example:
+        - A + B -> C
+            binding reaction rule
+        - A + B -> 0
+            annihilation reaction rule
+
+    Arguments:
+        - kon
+            the overall reaction rate for the reaction rule. Units: 
+            meters^3/second.
+        - kD
+            the 'pseudo-'reaction rate caused by the diffusion of 
+            particles A and B. See the function k_D(). Units: 
+            meters^3/second.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    if kon > kD:
+        raise RuntimeError, 'kon > kD.'
+    ka = 1. / ((1. / kon) - (1. / kD))
+    return ka
+
+def k_d(koff, kon, kD):
+    """Convert an overall reaction rate (koff) for an unbinding reaction 
+    rule to an intrinsic reaction rate (kd).
+
+    This one is a bit tricky. We consider reaction rules with only 1 
+    reactant. In case there is only 1 product also, no conversion in 
+    necessary. But when the reaction rule has 2 products, we need to 
+    take the reverse reaction rule into account and do the proper 
+    conversion.
+
+    Example:
+        - C -> A + B
+            unbinding reaction rule
+        - A + B -> C
+            reverse reaction rule
+
+    Arguments:
+        - koff
+            the overall reaction rate for the unbinding reaction rule.  
+            Units: meters^3/second.
+        - kon
+            the overall reaction rate for the reverse reaction rule. 
+            Units: meters^3/second.
+        - kD
+            the 'pseudo-'reaction rate caused by the diffusion of 
+            particles A and B. See the function k_D(). Units: 
+            meters^3/second.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    ka = k_a(kon, kD)
+    kd = k_d_using_ka(koff, ka, kD)
+    return kd
+
+def k_d_using_ka(koff, ka, kD):
+    """Convert an overall reaction rate (koff) for an unbinding reaction 
+    rule to an intrinsic reaction rate (kd).
+
+    Similar to the function k_d(), but expects an intrinsic rate (ka) 
+    instead of an overall rate (kon) for the reversed reaction rule as 
+    the second argument.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    kd =  koff * (1 + float(ka) / kD)
+    return kd
+
+def k_on(ka, kD):
+    """Convert an intrinsic reaction rate (ka) for a binding/annihilation 
+    reaction rule to an overall reaction rate (kon).
+
+    The inverse of the function k_a().
+    
+    Rarely needed.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    kon = 1. / ((1. / kD) + (1. / ka))  # m^3/s
+    return kon
+
+def k_off(kd, kon, kD):
+    """Convert an intrinsic reaction rate (kd) for an unbinding reaction 
+    rule to an overall reaction rate (koff).
+
+    The inverse of the function k_d().
+
+    Rarely needed.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    ka = k_a(kon, kD) 
+    koff = k_off_using_ka(kd, ka, kD)
+    return koff
+
+def k_off_using_ka(kd, ka, kD):
+    """Convert an intrinsic reaction rate (kd) for an unbinding reaction 
+    rule to an overall reaction rate (koff).
+
+    Similar to the function k_off(), but expects an intrinsic rate 
+    (ka) instead of an overall rate (kon) as the second argument.
+
+    Rarely needed.
+
+    This function is only available for reaction rules in 3D. No 
+    analytical expression for kD in 1D or 2D is currently known. 
+
+    """
+    koff = 1. / (float(ka) / (kd * kD) + (1. / kd))
+    return koff
+\end{verbatim}
+
+
+\subsubsection{Some convenient functoins}
+
+These functions do not contain docstrings, are sometimes self-explanatory and probably not needed that often in simulations. Therefore only definitions of functions that might be of interest to the user are listed here:
+
+Mean arrival time:
+\begin{verbatim}
+def mean_arrival_time(r, D):
+    return (r * r) / (6.0 * D)
+\end{verbatim}
+
+Calculating with distances:
+\begin{verbatim}
+def distance_sq_array_simple(position1, positions, fsize = None):
+    
+def distance_array_simple(position1, positions, fsize = None):
+
+distance = _gfrd.distance
+
+distance_cyclic = _gfrd.distance_cyclic
+
+def distance_sq_array_cyclic(position1, positions, fsize):
+    
+def distance_array_cyclic(position1, positions, fsize = 0):
+
+\end{verbatim}
+
+Some vector functions:
+\begin{verbatim}
+def cartesian_to_spherical(c):
+
+def spherical_to_cartesian(s):
+
+def random_unit_vector_s():
+
+def random_unit_vector():
+
+def random_vector(r):
+
+def random_vector2D(r):
+
+def length(a):
+
+def normalize(a, l=1):
+
+def vector_angle(a, b):
+
+def vector_angle_against_z_axis(b):
+
+def crossproduct(a, b):
+
+def crossproduct_against_z_axis(a):
+
+def rotate_vector(v, r, alpha):
+\end{verbatim}
+
+\subsection{Notes on other files}
+
+\subsubsection{\texttt{bd.py}: Brownian Dynamic Simulator}
+The class \texttt{BDSimulator} can be used in the same way as the EGFRDSimulator class, but performs Brownian Dynamics (BD) instead. Users who want to perform eGFRD simulations never need this. The simulator can be used for comparison of the eGFRD algorithm with Brownian Dynamics. 
+
+\subsubsection{\texttt{gillespie.py}: Gillespie Simulator}
+Similar to the BD simulator, the class \texttt{GillespieSimulatorBase} can be used for Gillespie type simulations. 
+
+\subsubsection{\texttt{legacy.py}: Old redundant functions}
+This module is called nowhere in the Python code. It contains an archive of outdated code.
+
+\subsubsection{\texttt{multi.py}, \texttt{pair.py}, \texttt{single.py}}
+These file contain the code that handle the specific events that happen in the different categories of domains.
+
+\subsubsection{\texttt{myrandom.py}}
+Contains a few convenient lines of code used when using random functions.
+ 
+\subsubsection{\texttt{make\_cjy\_table.py.py}, \texttt{make\_sjy\_table.py.py}}
+Generate (respectively cylindrical and spherical) bessel function tables.
+
+
+\subsection{Function from module \texttt{logger.py}}
+
+This module contains two loggers. One logger that logs in the hdf5 format, for obvious reasons in class \texttt{HDF5Logger}. Note that this logger requires the module h5py. The other logger gives output dictated more by the nature of the eGFRD algorithm.
+The loggers are not (yet) explained in very much detail here, but both function in the same way. A logger class is made, which takes input on to which file to write, the logger can be started by \texttt{start()} and steps are logged by the function \texttt{log()}.
+
+\subsubsection{HDF5 logger}
+
+\begin{verbatim}
+class HDF5Logger(object):
+    def __init__(self, logname, directory='data', split=False):
+
+    def log(self, sim, time):      
+
+    def start(self, sim):
+\end{verbatim}
+
+\subsubsection{"Normal" logger}
+\begin{verbatim}
+class Logger(object):
+    def __init__(self, logname='log', directory='data', comment=''):
+
+    def log(self, sim, time):
+
+    def start(self, sim):
+\end{verbatim}
+
+(Note that not all functions contained by this class are listed, just functions deemed usefull for user interface.)
+
+\section{Todo}
+
+- \texttt{sid = identifier.id} gives the sid, but what exactly is identifier?
+
+\end{document}
diff --git a/doc/interface_functions.toc b/doc/interface_functions.toc
new file mode 100644
index 00000000..9131d2db
--- /dev/null
+++ b/doc/interface_functions.toc
@@ -0,0 +1,33 @@
+\contentsline {section}{\numberline {1}Introduction}{1}
+\contentsline {section}{\numberline {2}Functions}{1}
+\contentsline {subsection}{\numberline {2.1}Functions from \texttt {model.py}}{1}
+\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{1}
+\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{2}
+\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{4}
+\contentsline {subsection}{\numberline {2.2}Functions from \texttt {gfrdbase.py}}{7}
+\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{7}
+\contentsline {subsubsection}{\numberline {2.2.2}Handling objects}{8}
+\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{8}
+\contentsline {subsection}{\numberline {2.3}Functions from \texttt {egfrd.py}}{9}
+\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{9}
+\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{10}
+\contentsline {subsubsection}{\numberline {2.3.3}Get data}{10}
+\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{10}
+\contentsline {subsection}{\numberline {2.4}Functions from \texttt {dumper.py}}{11}
+\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{11}
+\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{13}
+\contentsline {subsection}{\numberline {2.5}Functions from \texttt {utils.py}}{14}
+\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{15}
+\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{15}
+\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{19}
+\contentsline {subsection}{\numberline {2.6}Notes on other files}{20}
+\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{20}
+\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{20}
+\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{20}
+\contentsline {subsubsection}{\numberline {2.6.4}\texttt {multi.py}, \texttt {pair.py}, \texttt {single.py}}{20}
+\contentsline {subsubsection}{\numberline {2.6.5}\texttt {myrandom.py}}{21}
+\contentsline {subsubsection}{\numberline {2.6.6}\texttt {make\_cjy\_table.py.py}, \texttt {make\_sjy\_table.py.py}}{21}
+\contentsline {subsection}{\numberline {2.7}Function from module \texttt {logger.py}}{21}
+\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{21}
+\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{21}
+\contentsline {section}{\numberline {3}Todo}{21}
diff --git a/samples/template/README b/samples/template/README
index 3a85ba66..9ba19558 100644
--- a/samples/template/README
+++ b/samples/template/README
@@ -4,3 +4,32 @@ General lay-out of a simulation
 =====================================
 
 
+
+    # ### Import correct modules
+import sys
+from egfrd import *
+from bd import *
+import model
+import gfrdbase
+import myrandom
+
+    # ### Define model
+
+    m = model.ParticleModel(1e-3)
+
+    A = model.Species('A', 0.0, sigma/2)
+    m.add_species_type(A)
+
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+    m.network_rules.add_reaction_rule(r1)
+
+    # ### Set up simulator
+
+
+    w = gfrdbase.create_world(m, 3)
+    nrw = gfrdbase.create_network_rules_wrapper(m)
+    s = EGFRDSimulator(w, myrandom.rng, nrw)
+
+    # ### Place particles 
+
+    # ### Run simulation
diff --git a/utils.py b/utils.py
index 685cbbd6..4f746960 100644
--- a/utils.py
+++ b/utils.py
@@ -28,39 +28,39 @@
   
 # Float comparison functions.
 def feq(a, b, typical=1, tolerance=TOLERANCE):
-    # Return True if a and b are equal, subject to given tolerances.  
-    # Float comparison.
+    """Return True if a and b are equal, subject to given tolerances.  
+    Float comparison.
 
-    # Also see numpy.allclose().
+    Also see numpy.allclose().
 
-    # The (relative) tolerance must be positive and << 1.0
+    The (relative) tolerance must be positive and << 1.0
 
-    # Instead of specifying an absolute tolerance, you can speciy a 
-    # typical value for a or b. The absolute tolerance is then the 
-    # relative tolerance multipied by this typical value, and will be 
-    # used when comparing a value to zero. By default, the typical 
-    # value is 1.
+    Instead of specifying an absolute tolerance, you can speciy a 
+    typical value for a or b. The absolute tolerance is then the 
+    relative tolerance multipied by this typical value, and will be 
+    used when comparing a value to zero. By default, the typical 
+    value is 1."""
 
     return abs(a - b) < tolerance * (typical + min(abs(a), abs(b)))
 
 
 def fgreater(a, b, typical=1, tolerance=TOLERANCE):
-    # Return True if a is greater than b, subject to given tolerances.  
-    # Float comparison.
+    """Return True if a is greater than b, subject to given tolerances.  
+    Float comparison."""
 
     return a - b > tolerance * (typical + min(abs(a), abs(b)))
 
 
 def fless(a, b, typical=1, tolerance=TOLERANCE):
-    # Return True if a is less than b, subject to given tolerances.  
-    # Float comparison.
+    """Return True if a is less than b, subject to given tolerances.  
+    Float comparison."""
 
     return b - a > tolerance * (typical + min(abs(a), abs(b)))
 
 
 def fgeq(a, b, typical=1, tolerance=TOLERANCE):
-    # Return True if a is greater or equal than b, subject to given 
-    # tolerances. Float comparison.
+    """Return True if a is greater or equal than b, subject to given 
+    tolerances. Float comparison."""
 
     diff = a - b
     barrier = tolerance * (typical + min(abs(a), abs(b)))
@@ -69,8 +69,8 @@ def fgeq(a, b, typical=1, tolerance=TOLERANCE):
 
 
 def fleq(a, b, typical=1, tolerance=TOLERANCE):
-    # Return True if a is less than or equal than b, subject to given 
-    # tolerances. Float comparison.
+    """Return True if a is less than or equal than b, subject to given 
+    tolerances. Float comparison."""
 
     diff = b - a
     barrier = tolerance * (typical + min(abs(a), abs(b)))
@@ -195,9 +195,9 @@ def crossproduct_against_z_axis(a):
     return numpy.array([- a[1], a[0], 0.0])
 
 def rotate_vector(v, r, alpha):
-    # v: vector to rotate
-    # r: normalized rotation axis
-    # alpha: rotation angle in radian
+    """v: vector to rotate
+    r: normalized rotation axis
+    alpha: rotation angle in radian"""
 
     cosalpha = math.cos(alpha)
     sinalpha = math.sin(alpha)

From 0969456205d77aef8ce046643a0e43cec00cbe64 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 13 May 2011 12:10:53 +0200
Subject: [PATCH 0029/1541] Deleted .pdf from doc.

---
 doc/interface_functions.pdf | Bin 92315 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 doc/interface_functions.pdf

diff --git a/doc/interface_functions.pdf b/doc/interface_functions.pdf
deleted file mode 100644
index 23375729af9377b1c371b3e36a732439af741ba7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 92315
zcmb@uWmH{T)~yW$2<{%--QC?GxJz(%cXtVH!QI_81b26LcME<wdC$3(`cA&8RK1s9
zi`|%eZCYFXnSJyz<|dL66sDr1W`rObpYEB5V8ErtwbC`k<>Z8*ku<P0vNy)1qi3YU
z{qX}qBWz-BZ(xf{BW$i?Zy;!(XQgid!Oaa}XK!nuV*%m37@(wWwZshPbyh(8MBfy_
z7#(9?WM$Ee^kH0wl=B!58cI0ZqP*HTN&)(8>MT-(s5-~|BPaG5kC)SS-_4hdGZi|$
z68{?fjIsuX^ov}|>IK_ml2(n;*^y)JhdT9hgYDdfP&MjJ%AJY&Gt&ZlBUIR<wXglQ
zy()6ZAa}x(x$85Oy9RPfspjtRy+s`y<Dl|hRN^QDZPB?r6tSl9KJE$nlpnTH-I3G8
z(hXPy&*SJW`#bg0_3tO$!d2_VA%ZzZi}iby^tY6p!ovC1YojWV^qpfWe4*64!!LmB
z1krOk;lol^jYP@^RpS*Ttid9AztrSzhu6-z8SrHlXM-ZSpwB!5wgPUT*rexANI!o~
zgObb6QPi`w*YzZIfmo(08|%4YUe;>Nv?PRYi(hKD=(_jy;rlpP9<nh!PvVDX(2NDK
zc+x4Jj*Q!es!8=>nJQ;Yc<_`&Lc}SIKFpPNc}52J3?CRcMmsO_(s|<Jo;0Qc7E(u^
z5IN79$1^Z6fz8Bet*oV&D9S~#Xw@{LtO?kVH_-AWcu9_w-p1@zYbX*5qDooyXbjj6
zKx<RBE$n)CSHZ)`1i@I&=WoSowI}E`5W;C4?2Pc#l7-A@sAH$Wbeesg(EXK^rrQm1
zJ87=Fm`ke&AQR*QxifUan_-dk`wz#rxv?Twfz*gu`f0K&qoZ`|lwsEd{`1hG)}+&x
zpW|&~JJCIOxtKLrKAToAiI$2h33r&GN`t*U6@l31WnJ|rj)acB5`^vh#wRVHUzN-d
zp}_HZGacJ#zO&ZSN?WeAy>sRlCNNS>5TMfaI)kwj44filp+-2x37S|p85WBzb{Lqp
zZ!~qmR(r9O-I>_I+(NaZydfyU6h`<spKF*}22sqiK-$NQrlvw)xnqH8Pq4J@43j-$
zT-)tuJUmE9Q9@F%je@Z^JI6*L67R;tmOaip{t9qmWBg5r(kI3oK(>`MlTMu-(<gEl
z)mxl3U^$XdL8ZuymGPnbtALLhj=uE)9t1OJoGa5eqU4xvj160$ezRj$VE$$ZD&A|K
zP{6pu`bA7&rgT)uBQ3p8B#Vuo-evo4tilfBThDCFgC>+ku(P|{WR7KObeB1-F?Ys&
zKNY!CX!QNGASeC6VSzluxV~T%>5tq=;oT-HJS+VnN!CR$9so?)#ZxhoufZ|^I>N5k
z*#6^_v{u9C_{iWF(f4@01h<YWpl(4MD2v`jlvsX<8H!K_@uinB{NV6N<8WTU^4f5#
z-+|2?)u#x%650yfL-kdwhTM0r?iJ9rby#dAU|2qY<T%#wX)Dz)ebCLQHTe>u_}Xt&
zasHu*)l27PR@CPTb_SRVi@Td<(uJR>)~M%O*K6l7-1pH)cMSs+?V#)8+`e~%u4Eq%
zq6&g=u$YuZ2+9Q3K)-K!o@#C`1-0;GN#hNc=wcJLrX)=Iu@I5jc_wc^cyW#kgFpq}
z5{|yJpo%L1_c2w&p()Y4d)L)Lfe6^nC7xrSbC_AN(F8w^n_J$}%Ts@QGSVMjFpsOt
z{v_{Q5IOtED9Td?%a>`U^-QVxVd)n1J983Jl+*g-#%+crcAl5CfG8r&Sq9)0&@>Gi
zY~p(Be%g?-kIi>ny$|Q)WJ9*!pM00UXwO=`fZ!?6gh3cs>i@~Ox2rckLeT%jNd*^c
z16&#z9U}t>8UZUydjm^*JKR4&DhEL$XJBXLV5?_fhfDWAFGv~ao9OUcIpeC+zP-T2
z#zale!i>wxNJq`erU~)(F1ByWaq0f&uerH#|GeKHzyHN$;kSFd0s4)?bWFI6f4uD<
zm&~|Ke_qlv<1+tw$%@PJ*Nd#Utbbjy;j;aC$v}%s_s8du!+oPTjf}08p1grQuKL@5
zBPfhZqhR1{kE{6x`2YJU{<zy;ALGyMfsOvp-2wOCZx3loQlH<phqki{IQL5+vvO`q
zb(m(57;~Un-e}!9uDS@^usA7RV(6IABQI?^O!9203cplBae+}c2CKj;9gn;3Y+*Ub
zYE+X#wU*h0X*u}PIR>q~V$GqmtPgIXVs<=3Q|=G0xJ*Qs8LXdG>qua4j~F<G0!&CU
zbXCNOn$;Y9Ii(^sYMp`Bsxl*7LvQc~S{}XTIz&vul}r#uVt~somzz^1iN|uY!sof-
zJ!oyOz2^gb1QrO4(#sf$q03GV1I&vU)`4IS1m$PC0r<G0SX1)Q)rdlR&b7>2xOBuL
zKjm`|qpwePHi`?K^!E?qdpj3n#be`z>7lTLYH+RH`k74G+h(fU5i9n@X);AV2UxYB
zfmAnmH(p1g%ual$5_G&l%^@~@eoQCD-=4dcMTh`iGc-1^|3W<fj8vkY!i#Nn?mlqH
zoSX$_dFAqM6eMITa<+v9eGWM(=Cx3PG_H^4eIAw)72ydB+)jv7CIL+Ij;V$mNyV_%
zdtdKB|8Fz`7p1hsX!RF0C*$;%?;FpEd1MgVl5hCBUy4m%O8v7PBxVczN@lXkfJxms
z>*5Y-j*4&O4AkT<Ic+Vz499Pti*F5g-4WhICy^8;8F^;dhWLd~3l@e}^I~jAI#CI_
zZ?PZc6M4e8cCz*aOaZC;sdB~CW4&Y?CDeq$fZ@RSy63dUQuUXh<jP57*E8x@GH(lj
z1#r*l@Yv3w<YkvC@t~mr0Ej(qdgB!Nek(zHktRn1vl!sm3D>lSr7A0eK=}xQDt*p8
z$&!8l^t}m9bFK!nEMcgf7e%76OdIyDrZx$vjdBRob=O1BE2U>yVckO)WdO<Z1N`+E
zRuzrgs@2zA52F>gEuh9RU4_&!h=*gjpi1UTDxtX)H|B&~i{)DDTbd@%A=AS%x?8~)
zpcd_ByL*^W+q|dubL-Dh4|i^#AXLAzAh7zy+qjf%XawvXxY#u-!btT!yz?chKSN(Y
z9Mbl@>Eg6RD(Z8RiAp~bM!--Lk3<nNl#-9jR2ae^*g6o|3aT!f6^K4iF~=%pphAlR
z8BB#6v>>Q_r|R@U+GZxfk%L@f_^7&8BO}v@c!ASi%4B{+{-Ft$r;$vA7JoTdtfb5&
zMOewF`!2j+6&W%cGCH77YR`E&VpT4#m3!Vdm$Y5s@mnk$aW#s9)2mg^1-xdxH=$<s
za%yzBj4UOdSMTZR)WfM4!6Ad?-|<HGvk&|w-{^jT=br%g2NU0r_umrkXQciEasMC`
zjqp!2`wL;ehpj&#`2WEcGc*1FnA+dK)`+r{-4|N8wnt@JZX$;IZ$X{;3|zHoyW@IW
z>6oxNxIRpNM9N@G+jFQnJ)rNyr--Lg{ku)?PL@_!&K<ZLTbv}jMB0tqdO7J!L&Eaw
z^(3WWRqL&WL#i6l*CI8S+Q0+06;`SDc%YU9+burm4e_@hnNrkcFIp0yDL>d$;T!~E
z&hF)D3FXdh<<Yt!gs%&pc}^yQ!&o6iPa<KG%l5K-$wDP=<SCcP#qqSspZo}5D1{tP
zmQ-t=kauQ7z*fNrsKbiV%DW)(Eg?|69~%XqY<7>+I7XdeZd7ZRy}4VeWREnq$7KiO
z%-R#CFmbY;UPJ7>o4+PR9_|Ept@?Up!&;?@^7D-eoJdTjj9jTP+%EW*U^N^GU&;Vj
z5E2L=ybjzxZpO`}F<UINvrw?*$Itm@^z_B@ARj`&hl)A<_2Vc?Lr?u<{V!F@LXVUn
zU#tu`KP4ktiz*UlHC1V`uJCOm(tDf(gfOT2-O<pG&VpbT3NL(CVldiQ7iQ-`frCp4
zjIlsk0@8?_gL7DRJmF&W$ru4zt*Mou7Ef;m&C_x}TOrCG2)0c06#jZ@>q-U36!|hZ
z&0dEisRV31K~*AQ8flJARg5tRb6@!tfW)`2z+AoeI<z=PD{EGMA%k^ZQ!yYYz8@iJ
zgM>D#qsCN@!iQUH4Lmst*I=yRpiFO{(o_Juj;avg+}D69CtL2E5S~MP)H|3`gJ}rA
zUV+$os+d@r^qja8bI1#6EkD+Bh3i_svcl>za2tEAli4e)(~II8#s<jq^ZDgbTfh^x
zac0FMf=kUue@M2Y_I-kD0x~r*!e;8K)|#YOjw-c}NN{JTMmKAqZlTNXJ}rsVEJ(g{
zgmLscyXwT5wdctEg=YWQ^#6Lwf34XcX5gPR`@=K*_nQ4<`CqsE*P8t;q0;~1MgDrf
zzsgTKTH4<&KYNs<thV0##iKG<Q#a^rxTuGUnmwxMcrLFG$l^R#p3hg&S}95*7csKP
z$0H6Tu?5>W;vf)L1Rmio7Ar$+mzorf6_EDCY)0a$1~oU<NLftb)o-8SiHjP@TZ72T
zLKiskC+z#SBNai$)cNvMO--*XC|31pjBgtsR=yzO<oP?>h09_H^$sl0gDY92Slmvc
zM=mg_JDQsG-Yll?GCTPyIf@EtT8!2+VKBHFy2uaV^;%Xh&z4o%a8<!XT19t*f<I2k
z(S=v@eA1SX)en8`DsAcb+VEiBOJtU$fU~=K-eF_ooDsHfWDBnw=MQL&kcp(X<+3oy
zG?H8mD0);|`~fwl@UE1Vqs7urBnZ0D(@<_4%XYtoVHh4271j0TkeaRR8ZJ)<%n^=A
zI(&mE6U_Hhb58X})2GAO^dR{G=GOA#{A&G!iz##I7%~P#HKbBn9^+KkqAgL_!R8vu
zBwo<L%p?3bY7}19QaB0cPV<ybvwVz&T`7u%HP3Ad;@OPh)dTjICqs0;r?~)wsKxLW
zo)Lw|wliPM7}MCCm5%5q9!kYEQ`9B&`#IaGgwjcniLI_K;V&6NQ|P)l0d&})x}C4@
z<roHtaw1BSxz0HH>IO<s)EX35?a8o<o~t28z7Koerwl}IjakI`=pAu?B^B*gkxDm%
zQ4AGRzt^}BXQ~~PTEyaDzFRP)f~@5%^QJp*R+D+HaNQ3IM*ZA7l}Pt6wk!(DF%!Ho
zgSCv%C(d2(>>o1?Dg@Wf^Uf=pCxCxjE!&q6pnx$*<)SvHM%^Sp35e@hjTGDhk|;j_
zC|iBsfx)a6+}fO`v;}>BDUN>)9*B|gp<>{~^it2abM>w=2o?O>xHDfWKBg`W4GHY$
zcIB_caNfR*7q@992k>#ec58^MwwHU`!fRjN(TUN1vjI*=kU`e9BkS%@CganOehFuo
z0*huvPbXU_M-Jr~3#Wuf;6+D=u>G3j#$Pc}UnBt$0cjS5UI`^6#1HpcPuJVpq|jSC
zK3JEu%l<LSMQh~Tp5eN5NFmXm+mX&d4}t|&9;vfMS7Qs8108n&^FeEGb*7GpLkrQ+
zT2-K@U&4)PR{VmbGu3juobXgCKJ9QJmgxW<DsPziWTaCC(0UQVsoElJY3=mXOY;(8
zRrr~zWe*00k-2|87!)Q0_!=rusBcKEGFCaUHhNx_LfZc65%slj&MXMnbH2T(L?Gp|
z*?kk4>%qx(Ax)fbaLoOzVR@xjkt-h?r+2K(tWJ+j+fFGQyilsw^r&<rqN=QHu_iHX
zoz1E{tAksS=JxQJf83S<p|fQ!b?PbyAib61fxiJ2n6urLpT18h-((!zo>4t(ZJ^nE
zx4P!ch{{L1uKNU%%E@=(Zm#ZrxFh9kM5Mx)-c^Xh*ed-j9hKe7{2Um&!s)|u|5Z4p
zOs*_2AcWW_Pl&Yi7f2d;i?(0j^^cnAFE;%WuRrMZ&o$qVlIy?6>mSSiy5+ydD~&My
ze`Ja1e>Ql3l9ri;;kPZ(NkXUXA}w6tnF|DL0bxXdLFGG4_9@92fsa`Huxa%={%zi%
z1at{Aj8@v{WtfuYG2@u7`(n4prcSRjp4An^Br8i=>(B$VFnU(>cl+xxf;PvRpmbRq
z<6m-D@8lhKMRe?48+`oz@Qrv#GPro4`e}31Ka!yfM>|}XZJ8cTY)8G5fS?Yz8Bzu8
z=JrHxl_7X+^;za770nf$*b;#Q(JMlgcqG4?ZW?IPoHN(S-bWH%dIHRkv@nJ6G=6R#
zEDxxq2pIenBQrf$pg(?wp2kI=%iOIGuHsDQ7xJy0E?Sq@Xl<K*20Ud(?huO0aQ~~&
z98=a}?mUKRfZkYdWg$DU>}A^M9wp%B(~;0FH6#QwDdSG@y6zr;p$sPg7)jTR(zXU^
z`f-t+<2|Hpf&oVw=@yfHE2q{Glas?1p-JZ)y`P{F6trGA!>npf@kfgfcf^C{B4xCD
zKnheRr~~maz8plmNeD8<WZDH&MW0=a{U>~wQs$X?b*oWnrSNn<%PSAmQf8+ru@Iq(
z3bASAC^1U*epxeb8vvl=9e5FG0llHu)V>VR@*`a+0t$+dQDRt9`sy|Kite4A2(T!<
z{H1?k;o`I(vkMB*m&T=+lFnj(JnZ2-Fp|g-QxfOc)&Z_eZy?*tM`;<2&Yed^)vU11
z#sj(4j1*V-u5B)BnRYR#Q}~kyM$SR|9i|b1Q{Q5*{ZfHC)`gAm>gqL{R@JQ_O!3tr
z*r+zEpOqYekY$BQW0Q0-Pjs&q%PNcFe!-NQm~4I3>VAUy$tTQPq+K7>h<7p$j^$1?
z3YzDV(KB&6T#<K2^!V+=jDzv`Zp$q=8EY1U@m6!IH@9)k4Sp*ft1sTyj~)!{@aX=|
zdO~??10&npuw4=NYk!w7{m<paujTu<$mT8C_}^4CKbHTVe1Fd!{cQ05)GW(?qFH5i
zt0`I}&$Wu++gj+u-Rj&E!YHMBJSl#Dbr;^R<SdRD6w(?!x74rLB=vR&a-e!(*v{;Z
z?(XFoV{@aZZd+kr9SlFA+(*}lVxF-ABl1`iTLN=>?NUZv?R<K%W`%e@2iO1>C%*<o
zQA_XWXk>38ZpxLZl=EsKh{K>7HHaKh3q!CX+}TFK@l@AfFK4*qq=ghXF%_~EwkZvd
zSNhQFOS@GXH;wjq7-$K))+p}!Afek<@}Wq}0&P#<prV^nI~u5dR)rpk{{$Yz*DAS9
zBBV~8mdcA=O*i}kI#P_E7Km#s`t~VV46%rcx_wOs0g+GYJubg1p4{*Sbw+RUr-*W`
zZ73a64#LS>`%DNn6f%J{w{-$akPxyLnKM=t3DJY<1H;&89Pi|Uh~u-fIc<@4NW=Dm
z+{<;Tn=Jm=0VM<6bGaMPXx+Bjd&&}pV&<hl=L!z+k~XW`FEM!NkTpY}Ktf^{D;$=j
zBzx>VVXvTjNFKfwp;Xi+nbEnH?6hRnN)Ocm)$xn=g{@ib6yg*&FkoJhmQ#HC1oN<S
zNN%Zmtv#Ggwx;Jcadm89ZDgDaM?}UN@;<tR7vTC*p09Y*^jybB!V@v+Q<aMeW?w09
zCKjl&Wcd^xVGY89#4s*(kl79&J|rOQ=hlAA72vJ1yBukc20OLSsm&05*h$#$xy&i$
zmaUK)wh%1Zgw>tWqz4I^Feo?}L#xW9>_WOQVIv|bS}prh25!|7z{B6;>=vbI-^4y%
z9Q$6wa3@j9^`Cr_8+0VE%FdXK>VrC!o|bOO0mTvd2(W#Tt6<#NV=yEoz$*hWjxeP+
zg{7q<Btd}!GCL8Ac6upqmXF=|F2aocOMkYWC<H%Sf5LdTUeJ=N!GyVz-2B6mG^2i9
zEK=}2QYy5=0ngN{PCo1_UjFA7l&PUjvGOzdmbo>x&9U*T!qu3^*1o3>$(ye3CtXfc
zJ1>*$*EDUIXKfbrVufDRsZ$&<FQ9M5f_wn^h}uUY@vE!%x@R2UN%WY1!G)hom|t_@
z583_Gwod<N_VHgP9Y2=;zvRNt&g8GEiGlgIn|5W&5>`vXaP3FRaP8C7*-VMKg!H^H
zF4IC`pvH(dGPypL#LAOO+vS5n277Z({b?IZVz53iYB60d?pGszR`p>^9BU5vC}nMR
zH7gvP%at>(C+5pcTUy)Zh<j6YlLqDXS({&W2Guq9<ht|dF)9SflDS@r6jfVm_iBbu
zvZAUcz{Q_V%9mmD*)dP@1`rV#9>0t&X=BZ)+Ky(=462QG1KKNv2$pG3bGbEB9ebJV
zi#-B_ThAJ+gQf=foKbRR2&Jm0E#(~d;Mtp0_)E(WaPjOB7i}UyBa6uAk=lMn5MM)p
zI#Cbkf7_99wzGPMKaJy*xYOtkh_>5Ig?0!}h_6wkk$NQcw2My^i_&a@b8$g%_KUzt
zXN-4-p$9S<-NbR?l=9~A)Z2f*_~8D1NZ}T4s)aY;eR4xEthJgtDil~SqldIZUry}8
z*^$B$hugPW&f?7@6?lXGqR3SSlgHxsVn(mogImGikK%V)W#aKD$F&mucc`~71IFxa
zN7H<a45PK|j*5VB^J(2G$!PlzFx}$YS|%aE5RZ2)vO+qw_y9h#Rg}X1{C3L9$~PxV
zEtPWy2^1(6%(!4x7jQ$D#Mc#g41DXF870-+-;;(P1Yb7tCRw!R^{W%!YqRP5Khjg5
zVCCc?6B5rEMWghlZ>H!(sQaDnfl$Arf)m(^5sgtZzL;{nIP>k&oZE=RDNAkvPm6ES
zwcO{hssDbx;DF!^*2%yFktRWq!p6Pj305$D-}qhc!f?|3nN$~B+ppL=K<6!(?6w71
zF~=(J2-?8~2-Bji)*$hSp%^oW-h(HkG1tBUEF=XBjHg)eX-gHToBhg%V(Frw)PJRX
zOT!Q%sR~t<XdBeJ43E&VSe3G05xs16{z?_Sa_iG{-&yP5o0x%t1>zSjJ+qst)zS9u
z^U0%Dm%Q!D5`ZKtG#6-Wpk1Y#6C%i*%Jx?YuXjutU!a%*Jftv9@ipvxFDl1k-DE`_
zJ^2p`wXq4?w(+jq9MLPNDwdBLh~IlY%FsQ|z92a}6#|H(w^a6^TZ?_MjKhme_7?u$
zNHL9iAKJo1D#hLcd>a+e?738kZXYO2<XHLWm5E{G#?RqHvYGUeY>aW$4nAWMT8A-1
zDhux6eh;5U5y~V(ulKl-rW53bH*HLxKl(Cva7jtb;^T|^-3HdEM7&~AVOp|9(|y)p
zZn;wqinP`KC;|g*&xf!uHJaY*c51Xsb#795WX639$Jh&%Y9eN5oW$IwYig2k=LB#n
z@8-c%x1&@C;d~Q5JxAd0kHYtT4CcJG-Duw$kzEBXxg+XpX==ng6hKa~JH+@x6n3mn
z8=A9l1>+Os&yZbT1tBGMuVDqHEvSP}WaI3#qS6dQnIMygcV1ORIZ*JNkx#UgrSdeg
zoVvwsG7-cXDe3Z;Bp+OAXh-+#w(k{+mqb$}@f+3cqP%rmYzFwHC!rx#nfIaF>|;~5
zN>LHDhVR~OPVE$K>KS31A=dX7=zKtfFH}Bd;GW;a*`yle<D{dkE*oATeTXu4DX(Uh
zk%TUl+bYk=W1oH^H7uIuY-3U6KD0qXL<yQuc&d-!R<;>w7yv6WA-JBkb90fRc!l>=
z0{Z}b1~&Py$UKPs;jm%I>Z<kG-e*k2Am%<E(|li0#`UN|f&-LYInv@pUN*`{E;Sch
zIXqZTMs>9Aw4Rv+IlfpDe!Q)J|H2+)<TI*%KTTUC1EMYJxRzGo>EivZ?sOUTiU?J6
zd}q5v#SMNZY8bg?hi35hj*TJeHebK5>&cZ4jJdVN@_7CO4myt!<uCS_pX<0^?=e3b
zaz7_?^nYe`zqiM{rR0C?QUB=F{aF5cd(2zu_>YDm{V&>tzhzDteo;`e(fxkLUZ%8W
z^_H=Fo@vA1kfouJ@QRA9v0JRbnkdc)Ep{;rQ8RacnD1wnXzB0-%>d8WpU5YZs~lOl
zTX9-TbE#wdvL+ZdfKjHrVOl*v+(|E-sKeN#Q7QvhPV#~Np1v%1oN?xuq%EmOhm$C~
zJDh@}Gj-l)b!IT)YgBt%lNYpEX|DJbgrwZ?$vU7UB&8jBbXw~eb-M+(BucC*T&4r2
zI@-tV`U<CcJhA|P*?>Gl6TTS<j<fK)Bs1Q{JK)EvgkzhMc^ZgEg|t%*B$dyd{b(fN
zdww!(2KSNTh<a8pxTfHM49<r0m7g~K{kp)){Jvs8?ZPK2@?pK_jWR`@Nks$7dls3A
zMU|z2Xu%b}e{2p$ZJ1pT@F*RY1E8p!MgsxRvBZIAPimqy6#}QNxB6D!rM^~3(6=qI
zxlE^+2pjoolc`C)!OG2QNu$r_4sp_Zb#-Ov;HekqHhxX1k?DYzWE39LuNK(<L>)fo
zOy^-ls8Nd^5o1h_O>J1RbKL^pS{>v9GRZ3?102t1Y>2m`U^T^08v9ySY!E2FNV|X!
zl1{!+J78;RzZB&<1G;g3!$zC6EUziCss;>Ms{u`EC?hsoB5!r%8m>S~B55)#|4A+k
zF=#k-uU&>`iVxl{i$nE$OzAKmwdqN<GU_<Jcz#@g{@$WxKa2|wxTt6Xhe@zGF8o<$
zdLK;D5yx1!!QqHv^tHGuGXi>N^klZRY$5dwSna&Lw)dv7iyF%k*Az!@0|KH_$rgF_
z*{hJ8aslH`&D^(x$LoV8<mIuk!&>eZB?6O3BD%ctCqc)~_pd@jA{YWlnWW$uOo3n+
zT}*hI>c(y{su}ej2gcf>nRNP0EU5YGrcj=V9&NF@9ZXH9?5ngZp-u2S$r|raCEqJ&
zf24|26VL0VuE-!yp*PwO=8O}(V%CepwCET|D>u+ej5C|*LXV^fkIu<jhnI}c<w-77
z1Z2@BC!58>%^3&O?|Vgi&cm(cwdTAGvj-;kf<Z#^Y<zmAun6}MAt&ZtF-OnTM|ZiK
z6M5Pi?*OeHO|sAK^@sZQZ1=M0{aH>?t_^XURn`fvzt7Ro-75a3e&!?ca~Bh*v4_Bg
zve48qrc_^m6+5<>oQvG6lhB-6Wrkk|CBU&4t?!dOj<l0UINTj-yj`=kl3oBqhuDMm
z$p%sA7w8QPqJg}XC`LykD`uk(KvXHFp}#YX;osKJKM3$oKAGV^s-OSHupi6+HN*aI
z==G20;P27u7o{{EEi>cqHX6#5mLlH<89eTk!5$Gl1f#D|f%FTotU$}y`_((jAT0&(
zNz{&%6E+jpY3&_xAOwYOOF%PvAc#R51saWFUOLjbI^i@*i%-sfPU~5`h(Qn8oKJ3|
zyLg&b-5%XalFpCDiP+;vu*o0RCs}|*ts{pqOcxVo8XD0byO|BYPDt)-E~g(6VscS?
z+HM@3z7l=wIe3xTD#6)*R0}IQi<!O)bd-mpLORocKHlVOPt)XZ(@92|49C%4OX&pc
z(9Q@(cQ0yGI-4lgPZ0|sHX{C*WVRno2!*@notrMU;lsVvsYqp$3&P)-H)$w(^#oP`
z*zYKE*C2F=-y8K7Y$d|K1c;B+_;S@U1h**=FUsLKhR;W|=`AlWGnSm4`e5~DtX1Zg
zMDh@b`BGkp(fVXY^*s|p_o-O1iqZNpNXTXv<em-qeG)t7o1cBZRB9mY_?}V9Z8%kJ
zswgok6E)6RYQ7)K3kiCX55ZnvzIV)fquj>(vBsAi`0;e=*@|b>MHLk(__E+b6H0~U
zMFKe}PwQR5bQq{N)|QtJn~@o!Thlgg>rQn@u}YP2%1HpFE#{EvRTihH+D<khZRbv?
zNu{gSVDqQLE+bhilKl+*%PI>+!pxg$p7-CP5c)%Kw)3e~XKDwCkn-EEX)q?*WjT;a
zIx@vNv_E1Xlw~S(v#QqPl^;QPyGqGHJq4?3mZL!o1}aKobT8gh72_i%&4OSTX>-+l
zn`yc>>oK3WQ%~O*&_ND)0GRA5hVW52ZklBNTt5=X>yh$m4ho_zMh?5J(a$3oQ7IoM
z(Q_S5&|}U9T%B<AN_>YB)Vp<44Ta_zE%n~bS3|+7cEyCDo*x2tQLt&|vaStTiP3FU
zK17{f_Ox)9Ld!a021(IoU!tAI9BOG>e#wb@dyhz@45nvsfw^O`*r|fD#G(R1-FBAo
zfW_*Sd|6DJza^|VQ6+Zh8CY;i$^7u~#Tg_+e;6XkZ7aeQ#Sf)tw*WZ=JP9p}_NXig
zsMvEJu84HlbSP3D>((!7_**~uYxKFfw`Zl1eFNGvmudO?xr<a<2r+<wI|5j2lB(GF
zoIaAdfen&W97Zmi+cJ}buVrwAwB)Jx`*RZ~0~{pbhJ@jA)-wQ~rL?N%>|~9|Y*x0t
zLQ=kWLvHCPj7T`DQ4j)W3t;4@0@`4FWdq{9K$z=3-4~xwW@F(|SWpTL^{R6c^!XTx
zwHj0?FikFK2f)BC(zC|lVC?efxNr7dp(gz#wg{ox|9sx-hT7`PpCN@G*>HthOf~>@
zeA_QE+T;o&UHkC6v7B+E+jqzsayhxxJbBIFqVM@NY<Ii0)m?>(Hg3mft*SRde$qZ2
ziaoPMPRaA#(>7%-Cz@p^T`Dscc+$Zsf`roE!BIn$jBL5}AuoXM07WByLD7GkHZc4x
zZD9D1(uTiN^yitaUpEo{jsN>k+4`$Ef{yjKo47m5D{n($P+nu&I@<;?*0NLs8Sie#
zmt1=Sb>|mb>w5T%C_?D^1_|#cAJ0ToV-Pt``vRA`DoKWrgyaal2pw8fTN`s^Wis)J
zOez;Z2?u3UjrdUVz+&;|6*?c!#q3KQ_+!o$SR&M`l$PRAZkNbT!Q2{1Imqt6D&b(N
znv=K}bK65t@q2bWG~N>h`!e+wiXxOe%^bBf@U&e~isq!7VClv65vm}DLWENt8ER8d
zTz<XLQgA#mAu_`_H5L!c(d0UhfzF?Eb<dT@!gOus9=pDWVPL+h$5@Mxuv7~}QT;ZC
z7$B0R@H~EAWfoyrVRag~iZMHi(WNhM=K|w5<w1fO;iVg-#}Kjlp=#+~{=KY2dKQ94
zT0|4Nn~iYWoym|(UhmyQ4st<=k~OczQx115g$S{OCi5z=m)+=Kn<kSki&4PjQ}9!-
z!6;>-gn*|_qITw2LsSrHI3I?gdpz;%7Def<a;k`s5+*!Cckhqbm!K~;jq-t_kB})+
z87&l_s_xAW47%cMutGenp>Gt9+Ug9T#4vIwrN5rDaUM4^8=+J%hw-4IC1nG=w?QBf
zw~o>$8??cU3+j3NEGyGV%nC4p4=c@egqI06g{dTUZh7&zd0ULzEf%<$yDyYC?^3gq
zv0G~h5}N&_TDuFp!HQ*eBGIo{D(Vlx-|7S>2(C_CsD%ojry41m!Y_&#hg!5l9E@M>
zD=3yd?jI6^C&~C(b0izi7V+_&*-?(4RYl(3LbJJyT{J_!j%YU~wH1@nvH@fF$!g=p
zDk<G2vQ@qCu{pfGDmzifPIGKo%BO7&Q?A=lhsVy7)Z5lH%p*V3iQ1*XL&~8~MkovI
zl@RjWj1}Xkk{JNQE&1<NUNS&bQW4^i$9!lA$jHtc){oHR*qtNdUZk8OfXm4={Cr_W
z0I^~;ZF_Ebq%Q50*I+{Ez|wYK<Sym<#i=@&%^HcF+30B@H~Bg!5ax_3KIKzWHYb}h
z?%S{)sGX=EE~CGIZN;Qq0mixqY9`hMKStN-RazNwa9tl+ungM?Z~;^+WPG?x5TBEy
z?qGdN4Z^en*~dxMd2niJiNr8#4H2R4tSQrac^w4L17|FHVml0hN6zbMn2y~WKZF<*
zJ?faMC_0*}=#2KTDo--hHfg`FeZ)3cIdmKN%n#!*kR@*a5Tq?MG-fcU$|=>g77pdM
z8$F<AZ`yC8`A%A#Cx_d+|DJxD2iP!hGSPMp9jp-Y-TAzC9kM=U9c(rrknkulh29)Y
z*GYFx)z$G(@u89RyMbi*J^G{x<Hm)gBiV2&Ekj*|Dee-(Xd5a_LmqMZF-;&{z=V_;
z!}Y8r|4<$bh{U$6%v*Eg4zI<zJe~Qa6@j*;JA~tM3SdX8!hqfP#e8S7;gE6B`j;v6
z!tb=>9>v9S@JrPtY(cpecpPfk2Ok9dw<ZxJ47I+nDvbN+rUW*;0GcvOb<k^z#;LL6
z1ulRM3j2mu8qhxR!5`(VpiLFA?b$15KTD4xk3;eRk$^k}uMWzYi0-FVgNMi`ZPc);
z6u^g8h0#R1!{0*!l9HJGg6IFXvS;{PWzX=xtL%R)|JSbgznzm~{MqCG86-0?vHf;a
zctuGnZ0T)IZcjNWHMLslT4zBiD~Kur)phy1T)hOXDjP-c4(@=#lD77OoE!(?fu%s!
zHRDT?%h|z5c<kpM{d7b$+OG(yz(UBGNxn$2xB=k2NgzG)=WyH?rYN$KUC=Bg&5Yu$
zrL*oWnkE;1UI9p^?PcbIXGWiU_5cLF(!${T1LREeky@$|VTmU~&qgrjMQI$o{|*LY
z%*9(P@)elYKT^<`B6~(dm57Go*}ZhD*QiMZmGFjM8ldR`w&RnuG5f|4h?rIFZe0G_
z(x$5&mIu{#J6P(GL(p#ZS`$EFm>p_D!+rL5+o`JwBpH4!Be&0HVY^Lfg38`4A>nB6
z2&ImT<f9Cd-*w`qt13t&j;UbQ+gb<`+)(0^K~v03W0QTr$2(F_$OLfRTXgM1p7*$G
zGOq-k;AY`R$35nSkP(s4aqf$Nx77n@K!8wXDyBXusf^vgKFwKO2o`8Z(HL{eqt|WQ
zS+t2%f@QBho}N6=)Lvr|nHGT-((@~rI(W`3$ou@wS}{eqsb%-Wo$~I&$EQh~@8&Mo
zvy=5p<=EHV)|>$irc<*T7#^OZ+3!YGcif7?TAp5}Y$efp!1U?RPcpa;KG9L4)qf)8
zxU4w3QUrC~a71nnbeenFa%g-#<H8(X7f-m+PVY|d>?qSZs&ulyF1jyxYBzRv)iJKH
zeuB<%t2-DFntC0-a!H4NP5T6aTV+ICPaB~Lc<9AU9Hx7T7<s5q_jfV99W(mJxWg}F
zvL6rVKb4q_{}X)u=FsWi%+ZhK|5{A{Z_N?o&j#=>iLw6v1bvT^=37jL<S|yk>tdR>
zsfz%naM+bkEdMrgl+a+o&&WEBpiOV6`11U<9St+tU|}zouATetd-@jSSx(Q1<&Fv-
zgvVS%wqJlB^ridSA}jYdOJkv;n|pGy3X8Fu@_HP{kFaC4##jEzP?}y5+-kQNIiK39
z&7A`HDYp`b@-*zQkebnim8tW$aVIvz&l`&d(qo8s`%=1T`Whu6E_*Ig15sG$p;p&9
z0NHSL!}-TPOofb-d{YP2xTo+5f>GsGjAD&`mzxmFGN@fQ!==NSwbRd+>$IL~J?=zl
z1}S%G$UizWun-lFQu8#jGecqQt&l58x45B@i*Quy&Qqk6Mk{^iQlLztC?Ky%cE2f?
zmAQ&e29CIgGKJk_VVpd0a49O5PVMF_Qx~JBrN~tH7$JE(%Lt<MZqJiuQjoJE>$QRD
zSezO1{`<MW(x_%T)!=yAKxvQc07>*IjpD3KTNkcMP`Nm_Va(MAh7{Vcc2dejjDXrG
zFf3az6j#It3kTqnIV7ni!rX<!@7;%LT-W^LwRR9(GT%;l6nF01bJ4Mc2MdI8ES8)o
zNzajl8dYfu@O3I1HA&)_Tvrrn%&%9UVO!AI-H?0bM+AoY_e`ux<_FM)Y8W&z=L5Ho
z;ZcU9g>lCvsa5)N?5-4GDrI8!VyUmpnp-CTw?XRZHxOgA9;CSHEEiF3&RphL+>|xh
zW@7FX7rbz1o?aL3J~z(s9IY;C(mu=D&Vt?1`;&q(+cG#lHuf;9xxY6u_Zt3%@O~~4
zel5H|9@~Ew-k;MF|7AYS_;XzR>#F3hUF^349mbzG;y-o8{1#^aZlE)x)EW7vtJXaV
z8R-xtOsFK@JZ!ZS;zevV6P5;x08!c^qRQwK^O=r{5GkOdB46gjbg1tOSF2ypx5kzR
zY_XiBfnxeUr&?@$B?XcVPK`$e+$R}jcG5CBT^8a_iN=%{gYdn7>bniwa>KpI+TsU8
z@VD2`C(t%+B~jT&?Y$xO(tYNw8RV?u|NLyg+rgDAHdqKwVkk1vUBr3WLk53F9#lQ8
zv&OYOgPy3by?F$I@*u!b#-F8b<p056J9kCjD8ZKUbLu8$D((uLFDn%094s$T7HGP3
zfot_iI4mHP9#^uSytM0A`n*2VAeX_=+7aH|mbD^Wm)Kg|_<@gJ-Z-EiR&}***6-uW
z8ZDo|>((9^+T)|ScIgRfr)~qW-#Hg+Zh345>E*dnuqQtd=M|FRD=t;KLXB@3K0lrF
z7waX9_40KTt$^%tU3GG0V3!6Yt5NDlZrFMcatEPKcsv#7a(*?k@10p*No-EX6Em_4
za}?~jXh4jxB*s7tuqdvIUFBhy6#K9vPHF1<S`@MG5tP8@(LNJHn-Z@FlVe#<1b;ak
zmNyh3>{`lLu(=6Zz2>A4A?xH>`sQLksP3$!$lCJ53fG4-S95i&bpo!Oez1Xh$cjJp
zIsve+d6&(>@%5JD<;zw=!K3R}U#>;?p}OWP4NC!3FWkydeyl@3xbJoWeyt0j6tVAZ
zG8q+UwG3hkL(p>`^f-1)<=BxhGM!dTFC+NiND^?uRA(5$aUjwu*diDb(L=gh2?|-<
zJ#b3cVx4IQzPMOTVHv=ba3mZxx-~#Wi`O5x0c|?xp?=K-Pvx{E@dAj^oICo341YeR
z@M{_V@s$6w4F8M^eouys|6@k~(I#U2IS2i<4FB7RmFX8|l8*N6V9Af4e}7hNMrq~8
zQQ|*h05MQ};pv8lSxbioz;}VuR!6wwC>Cb%f}gW7wma6ac#w*sWApbV00p>X`dZdJ
zE>|roELmhL$wi|B4@})uCK!oKQcJ6Gi5MxBmP~IN_9~tUB{@Ag`->}<Zg`e>lyrDQ
zqsraI#i9uVKRX0oJO_=eRNx#r8Ydyh)jZM>xnPdmS5#DtWFeve$qSC?^uP+MG1cx>
zBT$vJyvRoZ!+?%oj|frXK1P=Csfog<Rp_r^LARl%0cCBer8VM>%8|A!-=MbC4~}G?
zVmHaUe7eaOwmKUoK4lCS<ud|Zv%Cx$diF<BWoBu|ar`a-m;Ly4X7O`2m;#Q!Ir`~_
z@Nx2Me{AZ>3Uz5<;GOUoWj%L<7<?b<vio+iy{$MEP})jpC`(?{j`3W{a=CPjItjBw
zMJeQ&nM1XXNlJzLt8u87iM%A-_pDRr8+SO$(2gX9oAwPaeAg~;m&T|s5`2s7q(ke;
z+lW_PF4xbf;c&AH*=E?7OiZZ`p_J&?G0RxWcc~l&%VACZ1(w=KeQ`F#(4wiMH!PCa
zP4<>HJxFM!FW&;-&s~fks-iqGUm#ggDe23OI((WW5$(?5iDa=Cp(@GFm9T>n{5Atb
z$DrNSa1vW`nl1*HF+c20F<<hpQ95j;#$T&Uuv|GecI`nvvaF`EeVtS;Q1mqFS@uEt
zkm<Q-xu<AoBTW-s4Ln+1Yl9*n-_%+;A{IQTy9zy6eNlx=RizAPpsX@JHa)+%ASWvY
z{{&O!fE|8tKx2NE;yeEgshQlmdGN3yHA5WZ0vTr(GS+6kHfxBgVPAFN`H}oRk6!eO
z<@yC92LE$#B;c56dQTt=;Q+=b@9UA~;I^!(_5h4v`rufkviP`<M6xmo1xU-;22jP8
zuC|^kXmFSXAMN%P1KjdW72r@;3%q+(oJ9q;=X6fV7%J9Bb$p3ONBT3-mu4rTgh?Xp
zda%C`o(5yFQe5E9bW(pTE1Dw!Btj#~Dj+<1ut8Fl#GF-R4M$>^fQN5v37Um3$hwoQ
z#jwcC5YPv@;c9q7Y^<E_iRd2J!`LKp1}-G&vE~Ff2iZ!9A4tiGI+v?uafB8{0l38w
z#55EJL3p<2W??GsoB>1x1wWdk`M#k!(!%v#fFA3Z^Aht*IRqg<5%7u)f^(YZiVY%F
zokrUVkOW|z4Xsl4ZPh#dd=~Zr--=yHxYW#%^P=H9lTAUq5brf&G;ViR?E2#?j9Tj&
z-Cfu|*Y4HIKDJA2DwNBs2-U;hF!=(TG!#XgkL)YMot~V9WngH?#qY0UiWo3@2(#Fb
zKJs01GBg^88!4YPD8IfFe6d;hI}(}xZAtJ0GyjA{rvIoU_!|;`EdSRf!C%hg|F3iY
z*0^H&VUK?AR4vob5dPD<u)ck+-zDXUlKRJ`x4F(eWrfx#>FI9isUcuk5T9BTTJRf-
z#6c;|^X=|V>Ck3v9u974D?TVCVy#2WyVS7^o(#Q=tBcM7Wc2z#<9UL%S?ASnxnZDq
zCO2K!-*z)DN^hueNrf9%I$2@-%+!`^;!rrVvR6VtS8$_Eq><<7r%rIT#z>T98$r?P
z*`2+!0eMH}TUSEFFozeq?r32Ssu&7rQHGZBGjyyZI*~>Y9GPDpb}k+5?QBfGor|={
zh4~wcR;mKz=q%eoVq#;jR%a_DhvAgOG||97%A-}ImqOJ8@!ZPD0hS!uK7<hk6m0f#
zw0~Ma;fNsT$FmN>N~FLe1FjG(<`VM{oM(&l2elsY7FNo?N07xsz+<YBTkx;~6}bM6
zty`L?`wesSoA5eS%&4RUbZS0rti*^#e*$emfn_(TdFB(@6iCiGIiGr3jsI98XUmle
zt#lodL1#Uf&!B{=ujp#WH`RwLQyG-WZWqeJ^B~Sd)2+BRHlZjOtzr^1zGCB~_6pd=
zZl>{bT^_tzQs>d+v6{S~;teNen^p(l&l<rGr5Lj`bs}D+Mf~|QB9%GOV_R#IVo^Jo
zjmd|(fj1YXQy&E9(0QB6HXbZ=^i3--Prd_b4t<#cu`WQPN?JUlg6lX&IZyQoTWc8W
zI#6GIH$r~WPna}&#!n!zjRjU4EBxpwdK=CEvRZ^4s~kKlV{(L`l>UmJ;!Kjwv@^|J
z7p9%Fq9ma}fqpZA+gp+l%qwA!SK}z?8}O_ne$@<*aeT`+4jM6B-jcPV^5MNOzB#rh
z#}xFgK>`x8puwOdWty3;5}sdXCZ`?Zw2QIb4CHRUKi?KQ+O2FkT%Pz+E>0W}J_11^
zU&_K>z64mSsA6kp`F9n+cOc}oM5JH*XAIIIue!5H*xw-QOmT0UPdpd<HZ4?Wsv<eV
z`9(o^6GXm87$(`ZBn~L-q0hZs|FC^995qTyq={xk0ixKHxc!L!a5VDJ+?2G#p)@X;
ze~u@|FfJc-OnFE8wX!&V22@&U1rw%gToq^8ngLxgZKa0DQc>C^dwWf6#SO9O<bh^}
z<K?3(OYTPCWYSIR<d^vHmMXsRVUJJ1$4*%Ek!4$*JKxt~;l)4yib6jZ?Y}f;KP3Fm
z6#9?4Hh-tk&n4MEjM-0S>@Caq^XUG6*q?a|^!^dE{DqspTHn8M8n#SH%I@vx$6Lxr
zdjL4u`%N1yRe%GJkl{qqF1x7~I%gi=xRQu`DC+4^JV8H-4sT%FcbjQ(<?i-maO*(q
zmDrktE|`GlP;w7z47RiXhC>z;$O_Fd-(=5;M(B#cXdTv-$0&7FDR|^^{WFKPT?!vD
z^J>q++QH|@GvE0;_Q*XSXIdGNj~_o)kg5{&#=kF2@Q(q8AI0s9Bb`c}&^QtIb;+t<
zAs1BUvTlCWB9!lObeI<n7=aflZG>(9+IsU2&dou37CntzpjDqenY?t-Qz@+bsHxlx
z-O4Bt!E<MX?%WA~rhA7~r*<H{woOpynh$B#X7%gVx}Gy9m}=W;Nsqt;AjTI?t^0<_
zkGAF5XOUsBhGNNlk&M>?t5Nh`yzG$0X%)CztOHTIz=&aIOe2FD8K<ib4aK5YkD1aP
zojsseJypdHu~<gFsqHr3F-CJdMiC{louoR`+0uij9&@3>6A0sdD1hTle9#_<{jRNq
zIo`fN#oL(`Nhb&w#vNH{|8f}TX7*BKUyv7J8HA6tiNP_YjLs!)H<RR3&L;nTeQ)Ge
z04|IGAQNcLM4{}>jyb-3s`a452INyxmlJA73%N|PT)_~WWPQM=8y<t&9eoKgpdp|<
z)7SITS){SOJb&{<u{jgA3H(W2{#Ws&g_AvW9<x;Dw7DW%bH*TtN4rKwh&1`KPwiP{
z2q;-<UocFxf!Y&Dkl`2jyl1YQECukvW?ZaLf~SEJbBf7bxMI~}yu0nujgpX5N^WI@
zpiFkrkoi6(V6o@QGd`8t_%6o4Nkh!5bsUi-RnXTG(5!JEl8z;s-e)INsiju9s`;cv
z@2Y#a4`BB&;<d73@D;yQ4w_|6&lC^ISc^J8`q$WM8yHN;tjwwomAXV6Rm~35xb$f3
zbI7a^d3NxA6M{IlS@Uf*z1-?Ym#pGDSIX=gi{$%aeQRUFn)O~-=Tp3EGc6Va%|N7d
zM0|{-6Q+hhYUg{zX3Mj{_MtWk@+9MSD--n|T%U!SulmGru4;4&<~?%niwhDwH>8fa
zFF(jrk)b2vGvCvIuS7X{lKFpqsYO7&K146AG>B{agkF!}a^IrE<~Ji*u)U01W(E70
za+M7h9=J=4LC&K^`08xS#dQx`3w&|$3lH>jwDD{D{H@2p^dI#Y{!X8tE75<@=f6hI
z+gba+A%}(S_lE=Pl>c%#f~{W}H;E4dKutvBd~3Omb&hI-G^4~YO^NC#mQ**^#)?jI
zrLln2T?$iKZ`sz^_BawpQAGTfbk=)t(*+T&qFpwOp+<AEoUkQ%(Rx<#Z#+}6ad5Qd
zFW=K$jN*uF$%{^l@1RgZ+<b$R1kQgz^aCm?$mnG4CySOSWTqdiMXOuZi_yKL_4Z#U
zqFz_(ujnD6Ie(%BzHly;sYQwlP{J*YfI#e|-C%VAq*mz!5>{sfwm~DeVEJraM?Kzi
ztB&N&8fwnkj$oIUaA%ra)YGAG<Y329Yh{*`21hYe?ACs?DKQP2W=e&_Q{sl?dthw*
zxE;zBM<ED&b|YRcu>TD=VITRrXhBYUNd#(oi^UhZ7R5nH6t~w4_B|$1TyExE+r2x^
zOD@Q({)lX{+-okRE09E_oYZAO0y5cXb<A9Y@$R>_K*{x7-em}OLbZL#4=>1B3D>2B
z98s4oE<KJtH(s{!J)jQORo%;Z!^d)R#$PsYNXeYEYYCchL@nu6%DS2YACsFi`GLYn
z4sZ&|{ITbtE_w^<@X@6tEDP60?u;!3K8p7ejzGVpjzim^fUBZuezl&}@4VfZT;G?*
z1f`pUd5}Z!QQi-v8ysbvyA|?@#X@QD-)XM(9KSVXfk_!uepXvjioX4lbE1cw`0YgO
zZDO5>q1Mka{lt}8s8__P=nziTQE7{HNzq|KRSaf4v3htW>3Sokaj16a)UP(jz5}Z+
zHUdFEw(c~05nN6^hUXy3gC#Fm9GL7-q7@ot$nkbjC;j+ZSJYqWDmp2&?~8c1j56Q&
zixxvlLP&^aXAulX7Lzf0KXFFY)D<uh{Q({W@t8Q3O^sk~gF|5f(KH$XB>J2;^8*@R
zek!C99|En28wLfU>$F5D+9V-({K8uC6`6%t{P$V<Bp9%Wu@|%Aruz4xx3v@TQJUa(
znN9g_sfTt~e8MS|ZZ*mIb2eX*%~yIFg0y%xTMvS7%~`!ma<9=D8q-c+K7tG5mb!{V
z<xdsGz@;niMOvbWcmW!F>SX^N6>n!g{-Lv9qT+`V|H-H@|L@ABAIpEQT>7mbm-%O}
z^`|>wq5b_J_e6Qf_ASU=d89ydf-i`0S%8a8rcP;AwVx0YQ1)=vC)9;jarPID?Wo{|
z^@DdzOLm;1rtiM=ShI^fx8SrrH7rM7klhbbN>$TBTioEREMFPFed-U*x^bXyO9l0$
z9Y{!A+xnbvwitb;DnC|}gA0dZ?&m+!Q!a>1nU9L(<G<k>tOt?AD9WpdPx_+G6IO5=
z$SPGL=Z0(&JASge2smgRlOu=Lh6u~6Kd!FMc?QoOoUW9sC|9rMY4<Mi)n#%Eva_`H
zAQwt#kV-c=fyYofB*vGwr7C%p%Z)BWRo=@`B%L;#rIC?Hz5ryvU~C<J9kbL<QJrrm
zx7n`5K0^h2B%ylwV}J>}xA#->*!%5o5L_pu<aZ1+A>WxfY`E@KJ<e!a@<@>Lf@u}K
zghMmBm5^(NX|X>`5e$2uyOrd_9v&EhG|BBuf1!1V>wNdIaT5&>wnQ>eR37<VDwHsM
zNg+P~lAD6JB@>{mt7ZKcZZ>|d=sOS>!8o$QL9r`>sJ-4cv-ZMVDS;K}Vpe2TJs_8e
z_tBCk$`ID2`=FivvXbJdPr__6QTZK@Zmm0+`72O<Pky0Zwvk7nCd1kO@qLiT3BZ9U
zqnc<yGLVDO(3r!iXu{=gS-~x)ct^2HyJS*C2e|xFxnv%N^{Lt`RWFJ0c&Z0setiwh
zMMe11T4zpV4c~<mQc%6?c&9Mg{l3AsE3je!G!-b~vz8<5!67Co@W)7q`o9C~`~VZp
z7l7t{nWdGAr<F^CiZLh3v@l*YG|9IC@EFzt8#m^SA3*F2CpfNu^O4~YI8OoO@|$9X
z$f#!lbdfot-J&3aDiauT0<^Yv$d$#jrNd==Lh#AuC~xa-{r22+{Ow~HroY!iKKEl?
zXZR~B9c)UnQ>yFeO7=6P9`-r)(cEso7G-%rK|>+52+rmN4eP$bFTUC1&7A)`S^up+
z!~7rhXa42@ek}igDeIq2%%8GmWBw0ht;7}kHgJ1#rfgiEjSwaRmrLqOEah$!o!l5a
z(}NBz=!+nXWDUs6Hdt}D8HRwA?xEahmj@E;@#uKr_<z`Y>!7-tWpNY>A-Dwy?i$!^
z+=4s7U4m<HcPD6Y2oT(ZyE_CA?(V_e{kMUf`+fJGQ}3QruihW8>POXXdU|?#&2;zl
z%&awQR=U=dBhsNYOTm~+0>Eh3!atay$c9UOQYbiIx7xzUlWg~c{HahvoEYnoFk{;S
z^&aeEYO;`&-?{#ryr+h!k*Ij_-TJWnVc#8w$H(MjzF&`;kKFx+aDJop@9`kp#XKhq
ziJCZt9^Io9@=&bd?VP?^M`{HeUh92qdY6@@@%rI49rq~{eUG&o$vW2j(vma^C-UZ1
z$mLRmv}yt#lqcF%E4HLdaB;)&m*jyotR-_q#2f_5^+c<v9lo0^+Di6{o{Gvr*(5QE
zhAC(_(-DYidlkxl&NgX<&j2q%gkrL_VCLvc=}OE%xX-r1hrnfcw|*x$cuT7sYI>*{
z6BJ*VWs#eQR|;u_{vQj$UOz_S@y#-XrCr+P1I-K&(!ft+=Mi1T>C7u{T$<pEc5&mv
z{K&-U&LJ=*#dgQ`n!jC0X52yWk4rKHv-r5m5Ic6DaOmfgdZLO6Y+8w{&q^iV06(Op
z;@2>OU31~nDNmgHY|XiP)>;r4J)%p(m_E9(+e7ZT957d`uefV!HKE1z%H<Ty7BEWp
zqYr`S|B4D<g_#OeW&@`kuue((jYSs2_*r?@y&@PnO&3$w{%xC;TDFto>$kE7VEt|}
zkqi<^m9{Z3MmFgSC}@mYWZ&ZxnQ&;6yh4Q&SmyFr4Qn8*T}5A+F*AOZ&A7wZZ+JzS
z{rcRPXviXtSL@^1Ml`xQG94~;@cc+AbXA~#I_qBbBAO?!9rlinq@kyE#`K5`fs3xK
zpKAfN{%9OV2ICC&Sdx8_UZeUAmB1^bW;#UI9gC8XfU;a4>qy)g3ro}A+-BxYKh)!U
zbv?ZGG|8}kP<sA?=MNCT`<3>?PQAER8+1B`!Y+3r)4Zuqa3x)E{5-+<FS^b5GbWnt
zAGh4WYLjcE$VLdhbp}GZIy;~K!~?g|D-&%2BIjUcrS>d2%@#Mb)(g3lQzTj^7>?u}
z*M(IzQI6H;a~T2B9kVR=vJ-0t_3sk4n`qSfe=B{1ff{Ht`zkiE+dtASiM%)*deg1&
zC5bhyI(JcNLyWQ@<w)~O)yb|@*`qO2AvcT^fb46)!=r#li4##;IGVGWL$cY}@fg%V
zYcV^kyOSG5az{{H7KhT*btBu{X0&V0_mZFCqy1gRWh}m4^y11ik5k<PHpA<^XFPYV
zD9zp7CabR44;&L%ZUvP+jg0vNxeZH`j#^+U5bBEmV#f0KmBzoGvHa6BFP8u4nHS6d
zeCG9B{Qo(${p~i(KkoJZTay>of3eO1(zE^BuNB0C&PU8-LvFe(>4_A@Lt<GX*(clC
z9y!o)tcw1yUr78~v{VpGC)bs+#iM{y0F6H+1uovE$)-;8L*o9y%2>r_G3qxzVvYSU
z8ag+O2Hm%HL~F#V`{ffnQr`%s5_zGdsMVuQ$qJhCF6*gIl(Nh34xlYyksh4y4-aZ$
z8)jj`$=rPK=21AI_zRo6rP_)L%WoQ66#DkGPR7Ug@nsKI^DkRdy_<+;kv2uKj?WN3
zLr|aY=)<1HhBPZKq!{FRtS8@QA{@bKNez7asFZsG?WUq(`*prQS|OI@mcaEob!W#@
zMU&Iqv?#H9kS_1KuBy8yp(+k;a#Hxa+t1aIPYqR;sw|!A@zO(S;Df5DP!LsKvLqPY
zO0Rsr>>_M}-8T9E{$$xmX|>bWj9|x#(9$pu&`BXCC$Z+^#b>lckFd6B7)isVp9*bl
zIOWhUtQ&+v1M}x9nlhS3-W;qhno6<Kq=~@LN4p&ytBNv;T@BcDlQ&9gjzNXx2d>HX
zNcIpJ+9Yli_e|j|L2`)aoqw$NXk8^dK%3!iBR-@BJ6@yT`y~Ghg@j-d2ZeKiq1kqX
zepyObtFJzu8;*9!;jA7y;%9d(yqvUKi<|oc+!!B$sL9xQpML{Nh#wMU7Dtu_{U`0A
z%un2M`-qqVUH+(M;c2{*<b_PrH{v1!+5248a~MeAQWd2r2gdUWy#`%g#lwydlg<Su
z4^=<jh|c97nHcwtyGP60%5|+JX*UpC+sxA;oR^wp?ubX1^=VDwWj+34#7^Kh>7hKS
zHMnKrHwXWT3BP#dgS6c5&yKn=COCF8-=nlGMV+!aF5-48h=y&p$QHAaXAw&^xPAgF
z@I5{T=e>K~Oye+=odIg|8_D;u`&r@<=9wqXO<#P3(s@Sartk$2DzZwTH~_0PHxOT`
z4J06#r=iM9tH3)hf)-irv|Y*h4oMdk$-|-GqWCNY%6<83P=7kakq4ZuUI}N%LzLsQ
zvy_CLOGy#0{0eVZ9}G`U^2)aMjyRPnmR#c50-8)9jc(J9s{W=((A=y$Bl#`7=-1EF
z_f^I0bWhHJP&vq^C_+}Cfm<^_2FiZO{CzwQT2)7Ho{X~w+h+ZowF8wb)4c7?n=3qO
z&g<4%AH?uw+@854_=TBnb4J3Qp#rMUrXS6FaQ$%jk?uabaN^-PsiTUk`I*TlQK2V8
zFul=DiZpWvzMD^a2V_#)5tzRUndiNIcaF$xC3FSJ9L|{T#pzgkiJdol&8ykNPxlSt
zc#)6huJaxLf=vGkYb%m(gDZ+9H6VB|RC-PJzL%GJ-_Y!xYXcJ#HR&RPYJxP_><+17
zEw8w+tH1IzjqoLm*(8ygo;8cNH8G=x5!Qll4o)%dunFwmn%MmPZ+N5X%~m8j7Nsc|
z8hrovVavn_s2Em5EM6hDNLmg^kB~nZ`ToVEk@bIF3qD7y|F#xn{g2jy{}frDi~lc?
z^>445{^P)+|M31b>%Ukb0+~S1-2Tmt1p~^ePlwQYT$Ui8lrxkXI&Hl#rTm_gNK7eL
zd9IHAUOz~aab#tyXY#R`5m&t0%;+=<!o4gYa|M@RlTfP&6L4s-ll?waf4!(CB?4Tc
z_DmNa2(C5x<#I9Zz3$3M$IX7fYp1lIVh>yR2PwIU^nsm>yy*wt^4_4WzTRTNc7@fm
zhxu`dge!N$9g8|S>LbQG`3EH)l*s6xaoJzpKjBE8oE0%uIm~_Er)<{n=1n(Yx2q@I
zF?p?Cv^AV?6B)l=T){T(Z27%jZ~Yb?{h&y{CyI%q9mO3dY%f|ky%Vt8x%mZ*<<gG=
zwM`-3NtW~-QcRq3$R$Coa%*=Dz7e%#BL$6`bMTv3Fhv(n+6R@!_RQ}IXkx8COwfux
zWPH3zr{Mt-nNhai0*_p=Vl~Q`6l^oytErfAZ|zPP&)Va^P-E%TH9=^=*Y<8&M^hPT
zxMR-i!=hR<A*DC?C$3Tv-hHx?hbR|zhpSQT3?wxSLRDZW)?M6Et5H2XxwXVUQF3%m
zJi|V@g!}f|4c(&-{lS}on};_Wy{NY$s+w;WZDikZ_Jl8za0Ow@M{buR*FXukvRqTz
z9@UwjSJ=<yJ-QW#SQmc~Ur0o{XUoU*Gjdw%ElYKE7hXk~O7W{sna{b5>=RVPTY@7o
z_y(s}KjumZe+x>Zs2_ecM=h&@EK}wD7MWU=ip2p}n0k~;1g+|;t;~mY)iQMx6Kc19
z*-)5TD;1vCZE4X_JnjE;mc=~wyrx#v%3Fuf0v&igZ)P^eIN){Tv{%Ei`+b(S(B^8W
zzi_u$A$l2ncpGNAq~x$;sb>l9Cx0(`syJFE6w(qiOG~Q{+<;t{YASz?g*!exshVkY
zHja?D-dj?}9^hcCmm#4ZGm<0b0dTQ{L3SN7Kpql-A=U#DxmqynTcigQ6DkJ<^Vw}W
zMLoSU(p$OV{LgB+CIT$)7s7XT3kih5afvI!ZwBsDOG=WZmAF}owjJL(!8Lg|B9L2g
zXb5^tekR_@p@7&u*OsWv4Hn3GFw)|O&giK9Io9b(y>Y=?0IMtz20RRuH}08>GWHS`
z0PPys!PKr@J?^T80Yj6Z{XlE1GUFFDZ$Lv|UpV@+yeeWqn&R9uBV3-k6+>LOzd8Y;
zkeX(ghK%g1R&-`mGGmN;`G|d{yQ|ZcfnA<uv5<8>IVxB#j2SKD0_)i$)TVBca8StW
z_~=aDO;t%KzE#qCZd3EYVN9Gu0|PPe4nPWZzePJ^Re-as2Dnj_bo;nn5mnP+VC6do
zb`_bR9(rvE4oV^X&`ptE(^~*@?6Om^GCB1}39PH`lxurdva??@_^z!RU|QMJN_viO
zU~?A-p&TwF<}e`X_<UlfVd$~;V3qGyD;D>n$o;^r_vE%rDz0JH;P3C-e2Cd4vg0WP
z(rYTuSK7vNJe^uYlj&+|e)^}G_UP46e}uzMys&bV*LQbVn_g&Ux?gZta=0-@$i>2~
zWUE+{;R22%^vO2m6;rZJ(Ubks=&n4*y#(%EZ=iAf=(z9X#3kPdVcbgv=dKfc;NiPJ
zfDTODEE`J9AGP;%v^{O{@^FZTNgo8R5ZSEIG1kt63a59CP(th+^z`*b1#Z*wNw^LK
z?lX5dU};Nkm@&(Cz~|rx*Q*)jG7SS@&5VhUc@RH&TKIHPe{`!=NJ)+<?%G7+@~if>
zN178JlhP1*R}V7-T;$)jsF)w!n`Su5z@&dGxF#emR=OP}S7*A2UE(|)qyx_yS85Yt
zOuVpCSiDZvSm=}Y&ORqCx;~Rfp0_!^$on>xif#f9(Q(ht#p^@;ZmBCteRZD9F0E{0
z+Xu2#dX>hSVMRKx^rQ{<ZR}#udwV%)bIff9R$$u~BCgOEv1simKm2;N&7ySO6z<@l
z)3*ozd1b)*zuxqC9ti&X`1K#%^!VrT>#6uZk6(XV4g9MoApd$7$iKH<__Ol^R-G9L
zqyrK%f$pX<(zDR9K4UMmm-Js$24-eD(1GzlRysC9W)=oIhEGqr1JxRq_0L)gB#nWY
z@c;h)Kh?osTK{ur3s#+lo&jVNc4js@MnYzgbG~3~>`Zh_gp5FT5M*LvrDOO5pE&-W
z$H>MAD)++ol=tucUP}Cdpv_A!GMSkeLH_gtUnp!WPc>izvVrJqjPy@F#0I2eCuDv0
zCsqbV5QUwd2~<CJ(1E*5j4V&(pX<&}5Bfd~AqzVY<d;DD=YLNuY%GjV#o3-1UvM^%
zJ2DfpFtUN@Y)>3)OrRn!7X|{^p2;t@c!sRc`g*DPi|+nv{oh;l^a|38(3c+Z2WMaf
zU6_&iscuiYdZGS956?9Q^(6K`8hx?FpOXK@&GO8_#QM~BCgx}OY@rvvm)sX!z2MLA
zFU$YgNb%HrnLrZ$FZ}<x2L8*kpqG`O2Lg~~pL-?qb02wuY>ZF+^aV1oK1E?h`lpD@
z408DY`C|q3M<%AH{{NK2$^eSigsjhHp3>~k{{OTm`l%m1lV1eBz$ccM%lw7?os03g
zL%qOf@qd%R_*}`q<UHm7JHNkQ{{?@!A`|OV)nDKX<*8|)=W-xb{At#6G+<$S3M?$l
zPl1s2x%WTufzG0P3MPMRCktqRVh27AbkB00YyML9kMx)D^CvVttL^D}pdXMP)bByU
z|0G$S$IZVQ`aiM1(l6HgV~uCQFZkcA_e^~$@rU|+tryB4Q@nV>lR96pXAZ{apvd?V
z>7UK=_uLl+F+X!Y!@vCO&l(*xc7PP}tQ1C8PzYszhK#_caLNdZ<gCvlJ!njL4zT|W
zLAymkoX-YkWqJz7&n4NOMv><dARl7`F#ti!WYE7S`afhdJb5nY{j--VzHq<be{nHA
z*X9MjaQv0W_+PUAxmN!v<xiddwEC%L&n;jCf?SXJ89t?7+RDn#4)TIO?F6+E<c6SO
zhY948Pb2Kpzys=|tn45eOhESM7P5g{lZ}vtl^N98Ku5hi4IVEHY@iMb>VGUx8hXLm
z7}-I&Pv&4{V*m+dV|fbiFBb*^L66X1&=<(U_GGb_x<6_15B9A0zqg2)>1i~268dDP
z=l`G%0UGiDX5T03pE560_9xrFP+qL^T<%%+GxnU%#QbD^CQu1B(763n8&KX~KKAFH
zG^{!U=!Op?0}H4@PZ$&1vv&Spz$YpH__2bzI7ru^nt^6H&+vu93Oc=l1ysv_ScVle
zzJjd4!UD1q3+UbGC$&G>4m3jojlUo}(}PkVS)g1{&jwkT{mGtB`7iQbO8$|}@DyyA
znf^=m6Bp<Q`d|RdOA%0lnf=Kv{%Y`l$Now^iD6;{eU0f^;0wk8a<YFY>M8%ZvClMS
zQ0!uRPP09Ic<HI^vm&3cmpsO2cVh(2jzCI(#{bHDancvQXZV+~{;WV?)fqwI0;Et@
zAjq7o&yz>yr|(38!rqfQK}rJAK#F8wds5E}4!R1+xq$RfZU*viP#k{de1YuDOizyS
zHwrT-Vgm^oK%wJl^1}v#|BU~g@*<fDG-Y~f<I`1Ma0XD90y*BZgctftsXz4RQQ(Eb
z3K~V8#)0Ruf8%F*=3xZY@M%K#G);ZMpE>{1&EFS<FOQIcgg}sn{_&+k(9D&AiT)oc
zkS70uf;<8U@~fx6|NXtAqBsKu4fV-lYeyJV81w@<HYlHl27!q7bSp<`D>zitd9qq4
zirR*T=;ecXj@$<66Z^-e%$;tJoMzMFstc^d?;5J1sz2e)Aflk=8t5Taz3#w(uVl>$
zalm@oyU2t2C24;{F*uY#%!S}IcwK?>a&tR)k@i5HfL)*3TAx%{XUahSY(-3wQo{H~
z2gU)sY4LFaBX%I9ppn;e_3|kTA?rbu>lmNLNP}jnf~a#U2NN_i2haC3V1rcP8ziJ)
zjd%wKiwr|w!C(&_@AbZLPgdn|lvK|W5&Gz^-|Y9!5kVYIPwzWoSl-K;k1k+>S?{J7
zC(*Q_8ANmxp#<u^3Dq7vdu|R_ql&AmgS#9&V;^1R9@ki_E6UIB9HFKM+a_MEL&<<8
zdME8Yaw@=`0jx8$=N?T+)^yEG4XAZ3b>JXM@B8&P-kWTIGssul0IQ(lappLDAF6%#
z1|HNQ^sPMMv?ov_<rQOf?=Djw_7zyF%N=De?XGh7v_?D`k5~nA*7P^PhxL5FV#2)f
zyL&j*Khhc?-IHuHRJy<bbD*>EDvORTqkvsM;|+vcMu1Y8N%ZCdBSZ?+Rl;yBg(H0h
z_AUs}io54`GUab$3$7ycz;GW@3tpJf67;&2`XbQ@ym0jq841Tr@q`r|yil$s2(Oj;
zK9Nun-2*Kvc-3+hvXuH>pb-~Lsmc?^MolHu6OD9eot5w8<0BDW;1IeQ9DDd<nU&3h
zL0QFZGLpV849hJfQ81q;p<wy-p${_AZzYSCdkxRJwqhwyQeOV|54@rR{XEDFiUlB`
zw9A8>F?E6D_rB|Zl^+qd;GO^m1@@tdUiAI+1JVj_AVa{Cg=n#F8CuUGhW^3H9PC}q
zxmMgU0i$3n<T{6sXZRP$a(EHtQn;R9KQA7kA-$2O2zFodD{bAma(klmAe^bQVv^3k
zv+;X0fu4~xQrFw$@rUv|dtC5>BOdJ>eRI}5OcY{m4cY|&mbY^An!ju7;x)hU+5^rE
z(K**+*JD#sMus+$r6FR^J8i=NJ8#Mrs3U8e+lN$9d1Z>89*qZ&bH0Ns&*^#C6JaoK
zF5VnUxC-sD8lp+6bDd5P)VejYBlzJA3<T?7W<2?#A8n_{!_}{RZNlISCT1_Qw`;K)
zjvDk2!ha4DsJkf$lS)J2t;rdsI4&$6=D0GWn5O2^I32Lb%tJl4n-!-vbFKR*eb>OF
zmKyEdy|$UXrBP3i(r`zzPQcBVA1bOowS{2~uhy?G5_U3XMtEIEt(3244P|r{%&8;?
zG2f?BnrhD`N3u5huD0{-CO0M(&G8J(&LBDw!|1jB&m=hNn^lxDnFz}<HCiM_0%hgt
z$*HFDUpK4uvacp#SHtiY?7Kw7fJm1)rtW=3hgDgZ>Z>%6**_r!@VfY{Pkr3KJ2ILN
z3HberRX3s9G#nEx3e=Y2_SYKa^|TXpIR^*xc#qj)M*1M6SUumH1*??(dhOQ9Y(KDT
z{oBMjw<Aw9B6oWi=#b%jnS<pl`I2z+29*y^4I}NBpl4Y8e#T6zwi9IN)<N0Ibqk{`
z4Vf86T}{8-99R}!Ns!`kDN1<t%oMNwC{=SL?@L##HzlD(moT)6_%u+3C1Pd_#-ae<
z-Hl}JCB1H;_xsiRI|?g@<9peaf>?-#4pZ@SYLj>@9W=TgqxA!yZwIC_>82A(b$FVu
zep?9^#baT9@L_N5*`tra7OFpNy8R_Vs>=!X;9UjfxUPaR5|*emz4%HY8u0qSOu+>R
zB+yQzjFCrSWU{$Ox2MKxwwbau{B7q}Twjmwn(H)bL>bd}0oOZ>G%u{DnbVKi=_VD>
zO8<@hM_zBh3H7uH%YKB2)1vd9-xq2*H)LgoGI~)Fo%vwd^kn!J*Y#4ubR2=ZynSdy
zxWrN+Nr}TGj9SOFtzOlGAGd2o;59}9Jzk~j2Z3OHTwOn_$R%TmyQeeU?IZYVuA1JI
zmuZTmox%~h?XIQaUc9Xzusf2+T3UEui%rQQq}=@)l+&^mkKaGBKNilIc6BE$nZUbi
zv!<Is@FgbOKHcOfXp>TdgvBFXbt9cRb56hO4J=O~nL$~3!8-c^!E(FGw2OI=D-)kX
zAe?39u>D?HvxQRZxXa@FX1>d}DK!k4s*zvA)mnH(>RUgNMO-2#$<)n5hbVu}muTUd
ze|M@^_w?)(qpt5aM?%{|9*5Q}L67Z)<LhW<ys5oe6+EI_2u#2EE;cT0`3~E6_-p0+
z!P%p;;xD*wypt-9;8ml!1l05OQr?pMLN{u&!!tr~=cY}mG{S#}E0Y*WL+2@6GOn3l
zrNlxnMeKZ>tQY}x7-7D3k&JP#8qj~1P{(n{+j}p!&az#m^5%iUmArCA2HbhwHfWSW
zZ2AB-G_{|SgX|(<w)YZK{<2M^DRIXN>NBM)jSvNHL8#Lzuhqap1LyIV*HD;E<@*uK
z<JHi4$=Zd#=iw`8QTXrEh%S9i%1V-5D2#B0(Q9(&skwE@$K%-iD>QvIiDI^bzgB;#
zm1cpswrLq3AzLxzhPJH&Th8-qSaWJmS+d5miTG+`1lP8tJ*M%R&?S~YNgLt1^_JdL
z!;kIFPKBhdl$8)OPF!oMC=6U90wD*JB6lH1^TT*KgRC2Mp4Kgks0K~UHkPFmKUILA
z7;C$A4}2brYN0oS&@zOpn1KD_*B`?29wkBVvGR*Qs9E6D6-wlKY^v-lI)&W9!F8Ve
zI7c3rB?%HBIaN687P|N%Xb3Jb#ypb_&*QxB<v+v6Je%EmYXs)}_GI4XOm2@)Ce0#f
zcp2F(_@pG&#j>c$T~>J0i|B##q;4h7B!2_qy2Kd}!UltVo6>8%&`%&j(V-z&lG4e%
zYp!CM`-^sqAtj;E)<{D~2vgHu5kIt*v4+S41&uGY_-9Td-$yLSo!E8ZYNoLi^<8l)
z(R1!(N$%=Fnrmbj_WF<$?7O|94Om%iH}|FuM!Fh?NwW6^dvaMHXKa7%3ZqR`%^Xp$
zWI6YPi8z^KmjuN}aSBv?%Zb0eMH!r%IIwC9FY+bNt$v#lj{A<>O`lRzbPl7X9P#%S
zw2-obtNBkkFmN~;@sHUV`0ADGeZ=TAoWZxgY9*0I6ZXcxu=}~n&{6M<)u9Z>h~pbv
zBrpLPeRAtRY01@*l6~!dlr=W~o>ZiAd(&J{q!`w*(=6-pg-2EiGT-hHjo{=F-{;F7
z86{Ew04xmLC#o;qLBp@c-=BD3UuuaVaFiHUmzj)zfZY*>{DhM|vHBYkufi0+C97-2
zL-oT=`eE>bGK0!!_40jEf}yY?S(4XIqfuh$Va>Ww$}}yeR_^EA_MatU>!^*YZm$o>
z78<{HHuYX^JcI?1%GUC!*=Rai$VJ4w!w9IxByR7P0;<gG7mh+Tz~`dy16|5Kog2t-
zYd6m|8KqY^EwH0JKr*-qbk6uDjUnUUgs9h@BmNkUPy*a`pZTS5X$%fAw}TN_k7*-n
zg}0@L4N9bcrHkYwFqj8+82wO(Gh*QQp+P93C*Mic(qWK5b_!J&NQ1Bx8mz0Q9(Ejf
z3dkK*DC=Sixl8h9{0;i%Hnd?we6eBZSg6w5^E^zhUd4jZwGVFn?|PN&ja^A%zvHzZ
zj>~h47>{wDyT#=Qhrd(dXM?7)9{SuYZl>QF;1-lUia=#m0@oyXwOjK!B)@?PuXA_}
z_sFEMbZ<q_Rdq@5)HK3)gU+~h(?2H!qS>GH6_89U&R*v`O5iue+U&_CF_j6PVl3KB
zq0_y5{Ymp~DLkaeR?D9JP<0!ZI~mPjn?k3YW`EWkLAc47fKNnYfrXt3nWT<%byIKZ
zXQO`TCrgau;gQzfx<RkGnSIa^l^Z<U3vxnfyoa7Otk<ZjUqv{^!8z{8keX{OW?e_{
z;T=!Sbt3t+Rd7rO!4}Oc&=)$~i;abl>E>&qxOAS2)}?bs9VMoD9p0XOO&#Ux(JzA@
zZx{8N6d0OGKE8POvtH@c$1#qSBN*n#>MEkEL{+`!s+Nu{rwa7<)Y9Ttc!*$VHYJBw
zinnm2n({xY)r!CF1gCT=XTE`mTx^Lppv>nPUE63($$sr{(Xe89-J+gfC@oETuQa;5
zjk-i1iE(7wIjQ|xzGSWGa)o!QC-1YDRU7!y$P6M^_^!gxZxs?s{{Frg>D;$wb9#R0
zkGwxvef0^bjnSP8>1@osS(mRcHtU+3=IViy<p?_?uAK3c_xh6<Lo02Yu!WLFK7D38
zOub{KM>cp5F7h3IS7(gHJE7f7!JBh@BJXk)<_w~|tBR3Ht#WMq)r_;0)}p;8U?Yz;
z#md95cC&qnNFb-QZ|i#cR1)(hi}#`)Lyk#}^vyaO00XlWZwXr5_Ju;#hWFEuTed}5
zjma6D<%<a^wWB?IN-YC_0HIR0@0VRn<d8E(qXanTP-n=PvDa`1YH#eh(*#)0$>l!%
zm@sW=?wE?q8G!;l|4x}+W0*%Cn-{ii!CkE%;c}**`I7y1A5n@U(b`p<$#AS4SLyJf
zy2OD8fMm<$@>y~=X<Oz@=q*?K_>szW)49o#qTNVzf-N<PKtn$&%cVD;VHnOr<)K7j
zFGWj3`en~+?9^bL>MMU8VclGDustGnRT>GbCHUnEechnNxRUpTvmzLR*a;@8F>p-*
zeYAJk<A%3yN?<G2t9w0ViqvXfr}NqipVUu9D^FLGu|nmrsTvD;=xHUnCd|Z=>6fo7
z>c-2a-C3h)GJLY-fSfH-Xr4Iz(C&UeiId$)dPM!cG3+qGP>pXHLu4%lj1sf(jX_eD
zDK0A=-8<!4-`A-NVIM^2tQ{GFHcZ;)gH7L(Lg^WKrzG8VZq~h*fB){U(AbkECfL<n
zok$Rc6No7Yo)4*)#2yXINn76Y6M~+%?L&?qztcr7o6jOCVMaysclR<7B`#~=zmpWW
zO!wH_YO{n!aTJ9-*mQemD7lO#Zo3G<3)&qQ*qRT#Y8uJ-Zp+DMLa)?;g1PXek>Epq
zozJyQ#8vovlGQHxPq9rjeQQ<ewK8m_M+<3`ked@k{9+PYrt1V4jSl3N1>+1T*^Mll
z`?5SW+e@S|twp6Z5iU_*5YydbGuv&;cZswuwY43T;Dqd#Hle<BB}S1TADS*VjiN0@
znd`|3aIZJFARi2pR__*3QF=~rpgeS%gzwnuGugs7eg4i?1Pq`$jXi6aOazGLuO%%c
zqegAWT-&UbW`5hhbMN^kjlEkrv)d>}bY`VBlA}y(6@d>!f1I7kGe-7~)XMCJS~Oqn
zb(G6|r|iwG*i08}*~F)m6avZpRUzE)6uGhH{VCY?TsTg977j+vjEIF=r-<G@pEpR#
zLA}8GURoT<au2$AP8MH^#?roO0z`(sO??OHF83~b!Umfq2y+Gm^hEk&2rHz7T9a-G
zQ&x6N)lgZt3(8f6+~mXK6U1)<Ulw1Lf8iZcThWX+_^t9m-lo9)Ad{QegXR1XWmGq6
zXzjyDOE2v2@SXtYPMwb|tP;)|kN!P|Sw7ZX?*VY!7SZbSV+U^;E(2!`olVww2l><4
z6`}nHBi5xI=i}QGY9njl$0x#6E}(-9SIXX^s>cmAolLyjgOm0!URoOI6H+xIoRGJO
zk}pN7_!<eeeczDXxNIr>-As!Jo0Gdr=m%5eb>&t}3l}g>p^B7-+KmL&DX3*01_}G1
zDC_~~c@+qla6W2A(g6#}<>1b3&!yPotu0*@x}5DUE3ZVSQ1W7BfDTi{OCnB3Ms4tr
z-?QbS?`^i)>z1Ff)-(EW)Eh$S(;D1{?;xD+ZHTkh9bgr5PNmlXwNbapt^^wZ-r+pU
zIi5V8-djL$EYGrSG0Q_uK|Rw~1fk{46rY+`o75;!<~&fq9h+*VUNbmPej?!Lyi}PP
zzStjHZJ3m5D>StN*B!RXOugidGZ4bzi@I!bt7iN;O(J_Z;AWFYwU|-v^i$0eexuY(
z+<Va&q&q|D1qHc??1e--V?9aZ5JuLp3;)6Ug|VY|U%-A**y}hS#M+=gKx8jm$^w#a
z1U{z|<9++aq`sZ~5ThAV#lyB9$}g=Ej({UJT<UzDKT(H90)y__r0-&2Ay&s+DKsBf
zhIX%`fJb+qk(=)WOUi_(#<@PA(4l}S+0)t1KBlwu8h$;TUVVvf#oCZY4AC<O8Bc6G
z=?K+Y<#I6NurccG+u%yVRqr6~j$$iG^}|F33Y|nT)%hZspZrde!}KN`>axn;vYZ5N
zmE!lRBnejQBIgE8=<Xks`2$eaiJZ5@Ir0kq4}D`Q`oI6s7ko?5U2!|v%pP9^gOaem
zRem_u5F4Jw?yu#|dvMg6G<g}@W!L`>YL~yhz?M`xv*Eia_Bo}8?Cuhyv-*lwx((Fo
z;T8cuvt59Ui)k*k>eZWLUhlD4F|yP&1i$SOi3zCVMw$}Emd}BQX*z~3Z?<I%#=ccJ
zW+)eupWv0n7%$nxp9fwF#u`Nzc9GyVlJTj0SuDM0AKag#krZH!w8;(}0UljvDs0MY
zO^sD0hvIT_B<`Qifq|co5iP0B4;Qra=4g^^Z!6_E&H%@4nx$)$N^?iu$Z|fLwt7$*
zfZv^r0gCtzLuNJOm5`Dm$jXieXrc%VJlrz6Hsj2B=-x%U3(i&dF}Fx5{^(+n*cYMc
zP;NQ5zw}O!qc#$>IT?JV(c!LPd~;=sOs0?=M=zeYKTZ)c7!4VKe9C3-``b#dzf9<@
zr~0JjZ*_X^G|`!A!&)dtF^I_&GNMgz169F{1kLN8n0#V>WK6i3C|6V}Sl~&i+<s-4
zBHk7kcFq3L6{W#Eu0M8ox8#t;^~Nq3<vL~CZHJRIsncb=M(vY0cD$Bx>|4?D5)cE<
z9KQkJXj7aU=~M11H5m(UYGtI|I`+$D1%jneNVl?9Z3O9HVA-41u-38@$vp~6Qm4%Q
z^QfF8T6`{)1rYEjow+I*j9VT!3~&N;*)rZ{-&lPllnXNqVu2W=qMthN>nSgk<Zy{E
z$wT%3g5%HCG}(fjc!w9>D66jE0M}%J8qZ}<+sN29pbGbnLT(Aw04lPBH$=Fx#oY%<
zI=Qx*H|?Rl9#b(WX(wd?&Ny#FAZX%(93om!itu!LW~I&XEet?)jzIXk8n3>VyK7Q0
zfFx)a<x(liy<E{<u5ITo>7pxH>~S<u__qB!He2*|0a|sJoi0#T#OKxG1cNN+#w%H#
zq)c0CcMVhc6`SJh32mN&29pB@K(z#0yjlJ!+<?Z(PRDre8_-9_MUw;4J+UopaGW+)
z0^$)0B(~?E<|)0qPGI16&8|D4$pU#V>?2((LxLX#wi+70Pav|_v9AWYz00e#v~*vm
z9wh(vD^e_+I|J52Iikr>uIgHLK&A6{sSL4C;uUv=HDW#`=B)|&zJ%*H$Lu3LM~yU(
zRC=Ei_YnRrnr{BiPh<n2kGz|F4EYiixzi8Bum^NniqP-U<ebB8OxT}V&y}C1t92l+
zSV$MbWk@AcewU$0N<Pji)2xc}adyvM%wNiA)`vBlyP0$X@O#&qaArN)@YGydS*SU{
z<gSshTEWIHGpF0ngI{F4<!v@gyQsIm8a@-T=Kg_5p?IjDy6>{eH964L8P_rs?iGc5
z>MMEl-^>~qktIws+;_YvAFqv*u_GjK7F$%`lyPdy_BT%k2t2s0-%lWoJrHZ7Wyl3a
z2M$cXN%c$%_+*B`UGP)d#Y6aJ*N^k}#6)X=)&u_BXS#1axh2~3jZ2<!Ob=Jl1-%}{
zzt23}eLgu9OdTX7B#3!G9OaCsG72*4PMX0y>^m;1aff^^PITAWr+;+1lwg+9?qPFs
zUB|mGlR8NRbJJKa1BwitP9o3ZJ1n~T^3l51=J`;|`fhFgz*(j7-(=XsyrY@#v5(js
zxuAYCzIpPolKlPMga}ssYsGhnHSwJL;AdEV^Q}ml!mKy9=8Z$_m8Rldsc(jY*IYL@
zz9XhpY`hwxo0hjiRMpd=YcS^?RS+x^$At!8<JmI$)wXH=K@mENAnc@T)lZkhGc->9
zcf0iT$3dg)q(uvkICW1<Rug*jG1q`qNBi?Zdr!puWTrCtlamw4MmJsk<U5f$AhZIk
zkfc6Y4dgJnPD&Y_>*4O}$*h9yHW}PP>YU78wI<*3d#o{m=DQsiMYhoKnXh|kj9j=l
z71<xYYka~&d9+AGUPNg6CLQl{;xK3UYMg;!)n^DuhZPXZ21g|nhAn7&KQi(2I7@Tu
z0I4jKA)sBDY6!<=r%f~|F?NeL;DRU`&{giJK04@+BhI5wOQOb)U0&hy3yH#I1HD@z
z3Gj|q5`JM}2C!Z+&16D?`5imE6)%r!5_4F2Jp)Z3d2t=+el=&ir8N?idK*m1blf;W
z55pr&znH}tXY`v&sq%A00b{6wvtyr8T|{lWTDN2(o4j*~%Nh4bbT}1srJEy6m}W?n
zt`J)t8=0HE@z7o^d=>upcXikJ9Nj0`<Hu+@lawV8z3IIo%Z4P$w%%5g52N^>j?OTq
z!Z%lrg7qx<*s7B0?(SzUvyo=*w;wJXy9h*MOxd=4%9wUi1nIvrj16llITu_{GHv+Q
z)K0*;>6jH8pm0IXo`AJAu9^D{I*xEE+5$Swhr)mh$qz~bquImNSrW1b`1Wsx{Q^n{
zG<SlTLt9VR?Sp^z?RhV#?CqP*<kVJuTj}DS^HaO@3gO@YqJMmIk<$J~#DO2~`w67~
zcc1k{_R$`lfCRsp9riUZ3cw9QOEWiD_to&HiWvUWjofHobM{yEKWJey!jL+y9A<@z
zySIX5wjQ7XWs)CHTVSYCw?8GI2tc(giqps+q<en0jq}=JA5F_r%GNcW{`s@n({t!O
zpq<e-RDjrTJIEJdNzl7s5H9wuNZOjnxA}?83Vc=VTMJDx2w*lTlNL#E>6DedwDR$Q
z8+cWkIS;cB<^T>G*KSxMXBlxF4#CclY@)axX@y0v;=P)4J-UE(qbhMvC1;%ESk?xt
zl5?gcFCRR2-a$|*{4AnnqrT$%HfQRSULEYyy6ZUKjw3Bwit)Vx1KmC<%~OrH>@MZD
z&1S$VI;Z|vsf4Ui)n>8Q&kXK|BkGrKG<cWXX{_5$Kdhr`TIqc9(9xP)zEKL=^~H0~
zgDo9eM|Enl!(A(=3zyBTm)k5yifD`F=QUnox=BLjleX5tSVfe=G?vtA(y)gGS<qy@
zRrmoM{3Xd}9~BWdy;~9eVS^Gn+}&dC=E2+Czda9|=X+%SnFk4wG#nDPWogn(Ygg!u
zf4kjvcl8^0sPIZNdjIcRCr_U5VeQo{MaPSIJM785i;drZA2T9Q@qf|P1NaQot5%Wu
zU<&)T=8K$jO4Mh?Vkpg1#anQ(gmpwl9V;lL+8o+s=LKtW3(usoS@zfW?@>Zl{Vp`r
zE27cW`=xJ$lxr6*S@7MYjjCH0XJ5R*RDd9Ho^?s{QB5<Yxmw)qp2MkX-Jvt#Bjq>J
zX;+DHOU1UDaz74ggKF{Q$VLw^y?20=OR*&ZrrOZ^^4#ooU(Ms$k5C_POfFA5V<TS~
z5ZNnWdiQ8ve5)8Bfv|Vf*#9)PD&SD7D4f57EPD*cv=K-X3`>`<muM?umtf`@hOag(
zra5;LAHm6Y@4M}!v5X{XBax-#7o7}8Xi+WR?VCvzc{V}UoiXzkpDN!`0EsAW3`yK|
z1!<$}^JpYNl(BQz31wZkSe8$=ISYdQl&`@rICzfOV5M#@4;x_Tz1<j<m8{`F7v<wC
z5{KNx)YY9kAkmr&yq+lr#zTCd>!8WD%f5@Y8^vvxlOVI(-Z8b7fUKk(ZRK_=mdL&J
zPq{Qf7Zt+JV<YxYBQf#l_@cz;1D%aP>&o%P3iB44mQEe{j#=5I4B0IOiSUd;3RH-g
z3jHF;&h^<zaP>_Q?^F8|vk%(RimT{dZ^Nd<`b>|%YT?F?wpZrPkf&uGTz7CocChjX
z?ze|I?M6f8IG<h1-`&kw(Xmix)CxedeKm#CAz7EEYwir?kjxUA3P`jOm3Bx}*hN9w
zc44iUWT(p#Q*BdkBN_uYdCf_ar{+pd-d$)~Wkp|NBC|BOU2MGL>`^Cm-^cHI7M~P`
zLvbcHPc}IQ6PS4>Axs8vU8ZEp;oY_~K<OSFp8ML##d#m}?V`I|Imj<aT=U*KVkj)-
zbI5lj@ut_cA0*!NhC2t2)o-9*7r?^V)4Xc8cD71N{iSxCWE!KFou9`ceOQHhrwLvD
zsdk~eau?39C#WN0+HuSRXAzG0ka;TrOSU4dqcl)8z)6g&p!tV@rzFL(dSL44yq@XX
zIC3R{;k8#DEm_k);_{Ai%5>#bVkP)B9V85K+_*C|MmN=vw|+vRQaxyxbShCbU5J;S
zvLwri&&sR@)t(s;)m1c5<jTnLmVTvVmUd%pqQ6Qhdpil3p~iJz(0<^!=EO|C5aO|=
zX{c|mQp(T!*wd!C*Ih*@Esc3LC12xh%Y(-C0~un^4YB@&vlo&sf@Z?tf(>I@WKP9K
zKF5!d{(#j9lNKvJZ;k*k(P@yJ!>rtiY-}g%YNxc=ld>B+iK%YIH}k!XElMXTS~e!y
z_JqYopBWBM{C-rvPJxo|d#e9Qmo7{J4$2ZKDi5Sha$NRl`-EFguwcq+>l_pQjSxNn
zC9H;2xyhR(iZcwV@nhE^llXfaV_{2;qn+ZjGZ=QP9js=_F$1$D7HezydiU<^G4ZTn
zcfxF!=+qVrqlZpi-FIwgr$6*5Ojk^%PNHQIXv@rVyWSwU+h&2jX9Mpsa#2kcJBi5_
zTVD}h3ZKdnpTCvvjrko&QSJcyox2y_ycxRU&SDvy!UCM)SDt+8Q2nwUw%uTgz;K{f
zp85T2DDaXGhZ<jNI~Tvnz5fLi=Uc7exlvG2yl14CwG?1F8X7g;UndoYR*fsm#2YHT
zsX+0UQc^(V);nzxcB$&AS5^3V%s(=`Bvmz9H6V~$@nN`Y$C!+^4}*jzH91B)%0?v#
zmNp$Fzdd!lT1r)c){;B1XBK^y@neC1v1Z@Z$zFu)+8GRu%7AG%t6C>Yq=7F^6+3VL
zcXyw#AB5Rcu9T>o74M^IeAQ#5#T)Ea87OtHh4K4}+h`erOWloOMUNIF6?54MsGA;&
z<9d*xy6fXU(Or`m?nK%qd{wO9jcD?f3Bd+%<ytf}_Kcn~-j`Hk*Z<sfPun)uacmuo
zD?ne-$(WKc5JYO%T`REd88#CDm;D(7=nP#Ik&}HT-QtuZzkpR3miG&lnzEr}Z11eM
zR%?J7c}B6TuMGIh3_W)?y<c3Je%RF1*dcGDhiN=i+Clik-e5(14;-AYt<j=Tb@g(e
z4E4>frLR8~hjY|t38qsC#P-;866V4ov1@kQu`izVLeMo<h(Kd>8!SA69?zC9GkBu&
zRGPEO`REgfkg1uCJ7qyQta7EflI&S~=8JFyNewW3KWgo?3XJq#Eg{dO99h$wN+!Nd
zR#+tYU8`$Hv$w#a*RSGkl>s$Ehb5mLBjdT^OWjJ=NbBxje!qkFxF0uSC-a%KCXs@j
zhNn$0Q8LxUFD1Q`f<SB`M*di4)%rb{N0FQ_uG!G<Zm^Avd&Vf@Qx(7Fi_1bq(ZInF
zk{%K>l!U8=Mv5t7G|MZmX1ApJm@lrvzxXGs61J0eE#e(C`EOu00CW!c15T4BB`DJ;
zgE324XJ7&*T&VtIs=n3wvn4PkNmv@^_Zd4^J4>d*_)I}aO4(d(wmu}qDh|=LJcSA)
z<0`8z+Idk~RhYLmu%-=b`d(5@Sn`(mgLHIttLeJ6!uL&TxuVU}*ySpfft+y5%SwuX
z@=$rGSw3m~=?}WN9#kFtx4&gIG;(=@S}T3KSPUlH9NF8zLsU%CaOm0Bg7QpHmX}%S
zmVC%-(nk!vm&#As)PMO-h_tHaijtoyjkR*PBkQ+aai#P;1kH7OuR&J~slIhq+Mezr
zzety``!x?qv(Z~}0sJ<e9WLqfslmmWT_g0tZ-|AG-mY8nR}0v6|HW~x>>;^C&cbC#
zQxSc3Rr?HOjQ}KsPr`SBS&y@lm~%UzgBPIR_<SU?PM_EkH?hcg7ayy?ls46I$1Ach
zxPd^IUy_(auK6Q|-0{08_h~My<l%iZI>}hpX(DaDWeVJ1u9wv5RwJGl!3P8TKj(-x
zMoxDetH{%KT$;neU?3qLQXMmsdlXAifkS>Kv^W<WMP7GDRE;WGN>!pd-<B6)7jW5S
z^=9yk>>A@#oi_Y0JvdH7=Ss*cW_3Nz<SF-u*|640of{}*F>_6ZR277-Yc%C5HLg0E
zKe7~=!oWdiCX0=ZI<cH4zeRY(@yT#Ft_eT7A6|oa1EFx%tVNKJF*?TsGjJ_7d6;D8
z1nt2_Vi1rMSpem*fvRJ|_<N_m3jO!)7t<W|yiayem8}kO{pI$)IW2kdfeyWl?fUK?
z`GoR9YPT3Yj&%uGSv@)+4rtrLT}BG#CjDf&6N(`GpsGH#Tt#lCkAl|JQ=jTlvRmbA
zGh!n@S8sS9Q56`~Us3}5*DY%eK7Ud+k4`6uztP1fH&gdJ9+Z%omA*}<5fyAP7CFUQ
zwEFl}l)*K!JUdY?>{{E6zih$kQ*QS1KCr7<g<Vz?J_!@bO2FJ`Ywob^C$N(uCq$TA
z$;NdaMmN0dJxok5=0SP^3QXZZiUOP;k_Y9-d%|z=N0pnyLwha-Cj51=2cdP!WbkM_
z*`odNQl467Q=Vz`+ClFs_|m+~Y?FVkvD%UkbFd*qET)ChiVRVXw0%sG(xYozr`T-O
z&&jA6PW90PFXXZAdwXIOz3rUtXA+aX<iOo_vp%3Z`1{eu_%xX9<K|d>RM=P;1c?Hi
zno=)M&?|Q%QTqY7jmPf>J+H}2W;`hzi^bw`J|;@{RohEkH1g_y(0ZFWo3-6lqDc8`
z=+Z$oq2GU_3qr+*>}Xd6=~ZQXx{*A;wiCHIYx+PbxHP*WDUiWb9sAw)U+Xl;8+*&2
zP9Ka9J{bx0WeAzF;qOQe_f6=Yu9`?yb=Oa+x<b6+63H6$FG~_HnjmE1_Ih)3L>}u^
zad>JHS%IKI<1WY+uv_nUdzGYHIld>e>fO|lD4de~OOWc-=?<J3@42^U+@5qD;rq|8
z#a3XPesW6q?j^^ZeGG`_W3~n`|BUM#3P-&3!!@v@=>JfMmks~cm7*c^q)>mK|4gdl
zhb=6@9K)O|6LKbNm8Uz4%7>~#VB(x+e=2Gc9@drzdH=n5XIh=G`xsCe>@*E$FkV3@
zu_ZO6YFVzq@t5Zw7a_`*Sz*u?0UmomiRh$bsaLS0>%E=bS>0g&cYr;Nt2rdW6(e4>
zogU`T71V?u$xdaP+oVh;oFti>+be|r7sL14x6o1up%w*%(h>HAOsOACrqM&@5KZmC
z!{nV=@?^z#&_b1F9u96!VEpk759OnOKSEAN9?t&r>tAetf6MpfV2G!K=mZUH^=wS6
z>@00SJNZCqDIIeILVz-#gq)lRjesP-3J|pGPuNVy$d-`lg@d2p(uq)=mXRJvNXziF
zfgA`rPKTX|<r6G`&sNXC!Va`462vN?V<l=}Vq^?Tva!Gdp04whM+<z)6tmMYGtuL-
zFfucE+EplTXJD@Mw3`|hpz@~>XfHWPhOv%~yn!7dC4djW4-fzd0)zn~08xM>KnfrY
zkO$}hbOCw*Jxeo73lKCn*8%7Q3;>1zLlXzkKTCTXfDynLU;_9IFawwaEC7}OOA7;l
z6~Icz#=yeNz|igmvw5l}z{<eJ#8Mw%ZEtC3ps#E8LbL(c0&EQ&3@iY)CQblbGaXxF
zfE~cj*v7yBVCQHFum?B*90AT$FRBqX0ksEoI>mqgbTHdLA4d$@X9;8mHSlHE<<pi}
zR<?hn{=Ux=^rp_gebz-$w1Gyn<y?0*3bG8JATl|F+_W$?gt%jk-#C_USsRw9FW~|(
z<{;vGB_Y`;k+>+y=mMD!*Vt{{<IVi#+@@_)UGpYN%aVOk_p8RtybcP3&~m@N%m^%Q
z7#=}*!c1~=7!)wxt2T7rG<fXK-rkuJ<rr8$u)t21!J!B@ARuA9z>!gad_+JUB3MFR
z=#8x~{|+-C7~Q)AEwKzRs@Ig*76#r>KUB5N(h;xll`vqu5c^;eJ8MrNvyfrDE=pjH
zyjaHH1v`9EJC)}p1T(FD3$6X;OIsv*npRj$1Pi6tR!dmXC)`Ion=cv3$2njcPSNvV
zjY6jAs4Ix2{<AV(<FZb)l#9KO0eO#Rbca5?Kh)XoK0msOKfbN8@*<gkWQE*V-tzIz
z0RK#BN{M})ng>1XnGh{Z^dKSpM$g+zU5rQvh7#<qgrv5DYaZcq(VK3S83?oY$b-X6
zn=)DFo@%Y(`!(PZ{*{r{k@$y?i<^gOIj?YoM(iE$a`#L2mf){DuC~)wEWq^Wd9dKy
zC{|NFTM`}u;&De|4G=_DG5J-Xw7rGZYvq?&A*I{Fq+!6qD*fxh(=4322|Y+*eF5Oh
zBC80ceCbpkpK=2!!AMVcw^)OGzzMH;NMXRJ?$d9<B5ru>v|zwS?*s6;z`P0{h+wdm
zx^4h|V7$XEGGJik*S;+<4@j_Z51`|Gx7%A*DKXEq&Yeu=T4b=md>+3zB?h)2AO2cF
z;y)UU@FZG%w?ly5zL^o>ne{~wj8NpRIpg6514i=>06=c6JtZh<f!Tq*&m{aR?bx-n
zo(kb6{VSDTlRz)T|KYsO$v58UM+@u`=K2ZFqib(gwyZ^p+g0T8n`KTuLLVfsjCSqA
z$7tgXA7O#W_@zgHhvMS^i`AX3K)QttP4F>*vLFDkr#T7LbP?HqtsvMgK!{KfDqCXq
z?sFDARtOpI`sEL{<6jC`DHs%5xthePy6z5L>$sE4*%N@4`+2J06Foy@%BR`-;T+^0
zP5R82LL${`UiRM|nLA$Nv_oP0GB%Z<eYKezbKsb)V5-x%kL%4j&~UNbQ#<G0_!9Ud
z-Hm}Cz*g!ba1_R}Pm?=E#NReHWQ?{NnEM*SZO^B7=|t)v16!jw`FDg-*Q1-b{z8eR
zM`3yFmWRPZugS-y<0>1TvG!8uxQ|t&nLkDuCDy1W6#{{}0Aho9+eiE^(!9c6>kKot
z50|};2sXm$#9w3#Mre*oZ@T6=UE=!mtZ<tltHx#!s((w5hpXJ!G}F)JQ)(y#IC0G<
z6=7$D<y%5GX4J#2)YeIbu8FT0w#Z;8yul5BK&5olRNF}Wxr!?<)uc<28UR;jl5Q}j
zPoN6FD*rtXe{QQYOyYH=e4yy`?=H69ow0+!p+v234cLZDa;l`5(gk6Uik!qTZ>8wM
zZ+;v&2Xpb{&j4hDqtJA2xch_0*0_=mZCfBbz~v*?mxaYp-_R#)C6wb}`+cE1<ukLH
z6(LZ@h_gi$mFL54#(|R1&p-GG0p|y-W4yz5%h{2QVaTe7Z04_tCnsZ1X_B^51TdQ+
zafvRG#a)YuMjzYX$z=`13iZW|?D5;lL6R;Qp0U%)CqHoIeN+;6Q_dJFdX)=LzacG<
zm<&KO+&6@;nGX2eTW#yr(F~h0SwQt^qcU<x@<Lo(8s$WZW|>z${_3-e`I-D9{E}Ii
zt}mXnn5BJ*^G^EgIgR#;Lw!&Cu{@CwQT=KAb)KCcfBm}B$;8J`ppQf3)+yC+=N1S5
z!WQDwgm8mfBszx{t{yQsypBTqG@bAP5R09H-}}im;ita%a?k1zhM3*`ul}6&{I(|j
z8&_HNc&7?Gyp!hib@M1vJcifm^*zPkEzG5XzeEnrYf1|^3d^S`TSir6d`P<|rfxCC
zp%3Az#4&q^C(K*ajQOSOi>2j}g$uJ4-2=5Z^gLag(b2)wsz@grHl=Bm<y%g{ao>OH
zdId@B+^uTSV1+b{t;||a`R?+yNlGUorUZjK1}R1bmtay_LhlJ=XmRhWleyw%awnO<
z9*uz#m#)v^%9=mhQV(Cfw)qKl9$PrV*b9xvm+hY+P3$&cHji<hK_J5|4tJ5YZ#82{
zQ!r=X`1MmskV|b=d+3{y*_jDR{Z&QyI(0n?Qqk*luYUKL+@A4#3j_B<ncwlBf2dPe
z)%rS}ql6<4N_t}4N&YAs8Va}$dBZ6a8h*F+&_l6S%YIP;qhhblvOQ42i}P?DE5ZbY
za{YdFsm1bM<MM3MD5R!}VpU4BsvAEwOc>Rjt2Y87K59cp_?me-hXdxl9&Q-ZlnHMk
zGh0-E)EnaX1k{b3xvab_Sn983c<{UNa0kEj@V_v3pL!^vSAFJ}NcA;58T81!*U{50
z8F6;$i;Z&3nwY$kSUYK2F~Hp>fG{K%#O~EYw1%E+Uo}i_yVb;FZdjNS-9qRJB^a-Q
zM^&9`VRBsH=9!rhp-4~Zg!n(Col~r6QIut`ZN6*Uwr$(C@4L2b+qP}nwr#UtrPArH
zbam26|DLaNc6M@-G1nXmEWR$MlThUNz<vI_+dIaHaI^}`Nrktz5c@JYg_YH6Xk!Ko
z`_HQ#!|PhK!6H#malxfln=25yQk4a8UGg-Z$`*Mlq+(?Br7a@gqrY@pP<)r+Uo{&~
zfWo-|3|Ns95zkQL5j63s0+qGE9(|@A#A2Q@+=C7$q$*(;H0yN0s8iTeVJF3by*SF2
zN~-KY0Vt>?yG~e4VW@RNs152&_ZLrattH4zq+TD7HS_wWus7$URE@D&!r9(FKH8HB
z2}o=@9z-zk>Qq|ji7oz0H3P93f{5Dj(h>|LkCI8%pv;0b1#sIEs-A>E8m0OAd5;NN
zMYVUhX%Qc8s}s_{GVzwa7_Fe?9!H{1R``gijIaLDOl)C<udsug7~7})s0KTl@)#v=
zu6jEY$f;=Xfzz~udeZJ(8BDa`&cA=?9r3noQQJH|k&Or|l1DiN`O(iYp|s7^+LxC7
zV>U5P@72ZK@igDEnQs*QMKmxUhmfU0h=va0VsT|_*_wHj$G@xZ)UEzx#D6M=U+DxW
zHPGypFznK*&T~*30aM`B{*heVWc2&1O2*>n(2x<()jIUZ#3VjpC|z=5*_i~q1u0Ty
z8!E>;wq;%VXmc@Vtb9?Yu=HcNCu<M#Q}Q=h<dr*`{MneywIe#P{A!soRUR!yo0QnV
z+<${OwDeSoqi*qeUW6>m%qmk3A;Z`E*?IStnX3{lXQI(hou0`o{0*b_x{q@6H*G-?
zFDKQm+DoVN?K4#9Ho47*?|8ZlUW&_q6$!?Yf2dU1KQt$M`l!i<7UzW|KnHK~Mh#(n
zg+$E9Kf<;$3xJn7LqB*Q4a*4S{3}}>DH)P7oNV#yR#-jqDg6N9q>}ldnX<v3lWo~L
zDNgBh7x!1a*X`k>V56O%o<^~=2t$8>eez$wyaOuA%inUPEH+MF&-P^E$D*hr{7v(u
z4^`dX{X}r|LU*xj&1vLFO7p>)z!cSn!;?<4`Jnu(i~l-Q3PX0)O0PWEZ<qb=M`kT<
zF}7{V=dSbcl!?m<MYn(VQ^gOW&43s7)L>RlBN2tNRurt>CAe;G0|^<^t<=N_3<xI9
zkVi067<0=aAA$~)b>kTwWSSW|53LV-Q%O)HhFjuDY2k{P2<g}dqfo7KQOQ#Kq8++?
z5{k=m#h+;>h3^EE78MX`!V61GLQiaabx`J2#ub+z0t89K)vMzPwvR(m)<yH-u$oWk
z?qZP`KcRu*?of<YpC}|41sgHDNw1zUFIr~HMT8DuD+SEf<5FoUB@?=HD7x*AN!iZ7
za;l1P8&+XJfvAP9zy-V!B+{IG+T-Znnzc1PZNiJDdY5FyCPD-EJ`n0Q+ia4u)A#QA
zuN+52u7QPT1XwXDa>u+1U{@EO_M4}FL!==K=+7kRkn`QWzC&X9f31&L=s0g0Yzn|P
zQibG(q=f$sp{9gn038K^z$45aWtYb+v#h9dX4vHp8~50=p0K9>zWX0e!*ry}SLbOJ
z)DV@YT3E_iuw`A&=Xm4iD;^rmA3q8+_3JJ+=SUHP%OPU*m)>Gjg^LZbmB9n)jETN8
z(=2vPE`|icG>8skM2<BuUvy>@fvehOu{5FIS-aZH5m%PJLH@dJ!J0TZL;Ip<5vJmS
zRaR%8Wu$whcSs@Ol8jYJal$qwdB28?H8e6L$7l`N9=Ke6(vEtz#&eve%C+Ncn`fO`
z4wdIC(O;_M*4Rm*5_&J=fKRVl`*pNXHl(K4@8=g*tB|1feHYXeZGwd&axT0IG%<-w
zd|tb75yeBXVaZnOzj_*0>eRkw6vFw`anJ`5wJRS{KC7qm3UDO8jT09S9h1{}(Yf$p
zAgSKlfqU}0zuklgXP;O4CnJW8tZ+;wzmV6Psx6N4^60qc1|{c%<v#!k7fhv8FD@=I
zOlch_(?1|y5hZUfxTn>MokM1*=66Z;`R%RJ_wL`H<SL9ft@Qvw`?#^n9pK#Wxmi|A
zQ`@~LP#L^`S~o4FM%pzyL0Zdr@5nCK8hxgMISKZNdjGhu&QqUxMW*XH6Y3c+PsgNf
z|N4y7J7`nE>$xHD40NP%hMrv$lQ+fP{*5V0l0yM*Hr46tJP)r3h>JAZ2WEi3eRj1}
zH6r~Y(ZB;Q|Nhq9(P7usXx-^G@mOsX1M|i^<<muL{iEOz2mI~jQ(dP0r0P{=P!)nN
z#e2K8c&9vI#noosc)c;j>aBsmPRtH46-LlAe#4nwvf;8PM%!BAEl6^**eKIu38p}3
z+i_nPo`X!9`_`kFG9-0_Rq%4swp*%OiO?`}3hb5F#Le{A?qD<XF^~vSs)!UcP6F<9
zc>2jCs|lbsgBlqgYDz0krm#&SS+5fa@%jqR%oR%{yO76<D6!@<NrkJp*4;YF$4MiW
zSW2P}f-B6&(rAdeReQYw@mxW^LaKD6FZge0dd60ygkM#a&KT7oKnuRWXu4)N>7RIB
z2`^Qj+f3T9v*_;a$tx982F<fIjGNk+a3zOGkdh+VL)iRQv7>qnd1gHai%0!$+c~n4
zlSwM4?)4WU&WGiKTxjIRlaTDZqztvSqZfKfk%eGr?TUe{WW&6h@BU*&*w_ho#E{Je
zkM+z$<wM*q0NW1*OWy*;``Xt<Kr5`sXJ^exOM^=oE+tXeFR+))!7k*G;~LB688K}|
zmV)335O;+bbk}m%nbhmriS3TA{c4tm_L9SE^aUJLgI>A@CE0-nLMB$B9U{h_TT+2f
z#8UMp)^?6zUSe0mIwBi3rOL1TEQOeVLwE1(!h=jfi$%@?Y*@oY;h_?=gO>~mh?14F
zTrOCkJ9Q|^4pbxO&C||uRG?JeZm^(7KBKnIVeWT6;#1xP7)02v-JxHN>m)G`p2i+M
ztF|5@DZD!o`^de*?JVPT=*q{XCicz9HGd!DoTt1VU~hf|4ZP9KM0HSIUhXJz&6BG8
zw_}-O31wYgbBIM*ybB%CABoox{|#AG_15)w_I5JFzqmvfkNAaTUVSMXqR!?^ZaU`8
z;bMQ#s8vKxqp8jH`ObD$&@>uy`xN%BIZiB!2(?pCnhg9bj9%R_3~TI%UB~yQHai_`
zsuS#&*j@?4MHf-sgT6rX#a>4=1|ozuuOF{3`*Cc%0-C{d37YXxhH@Ihi8^7l;3!ae
zEm3^2L8N|Gu<CS;p*~F<AZxP)!5%)eA+m>^VPt;)eS?gflB)8pO1zklMD{JujWDu5
zn0vV%%S8$_XmTEk%4fSkuN;x`PESvanQu~&v2KgGL#W1>ab~n;D(gMi-vm;jJHN$5
znz?LG=udE&7W#<>^u~+#A?0P-ol%sP0TE4)yU3M4i--`6=r8B-eJ;Y3ggcguahKIn
zqO7Aac13dCTy57-p-jk0@N3w5v`uxQ@H!6_&%MP}8io|1ovbsyZZBw=;ic5x51m{a
zb=kJl12S)l6X@h#K!!`$pUVW_OBlXkI_rR9PrGP5ggYKqo_=V}n$&<|`uQkbrLdWO
zNQiat8U0Lo8q&z)>bp|m+8GH@z0km*ym}PXj&LZgfWJ|dpW@2i-+qU%lT=#RA0Ifh
z0q-7}8=m@JHUyg+whhZ?AVpxzn*}9a)0{?xE#ldkJKW(;343x|G^<2}dYr6dz`mHj
zL2j4CS@eYK`pxL#b`p^uRFlZ$ZrejyShT!m+|4hPGk>Yyeu{tCPB~R8qTpBYM)jr`
zaHxr;faGi{e;;|)eNk%#M|&ce{+BscY)pBT-m+YKQl_P!`W}+1CjvfMQ=1eoCQjFh
znzkg}i!S`7UTHBOb-+h<b)({T|MXgs)gIA{TWS{I^VwYeJ-zE*x|*$i?=RA;Bvb7r
zBSoRhN^N&A?a|7uu&a^s4u%NkVIo=dNRoRyl&IT&I46NWa1c9(gWHKR<4u&)d<pO|
zUVvm|x19yG$K*`L>b=t`Y_Oh4$d<}222<0u40+SSs(yN=%Tckp-$uzE0%W<;P!hn~
zXU<D0msqxg+9Jb8MQf)FMq4P12I6Flh_zjCHVO8$6f(5Sgc7Sv16CP2!#uGGzf4=O
zUZc3#GIa^DNOoV?$&E$(MB2+_EV|HnSfi9%^w(G$jQ)!Hwh2~=1c>-%p7PvRayQ4S
zT63#vPMR`KBQ5ilzT7@>DYA_n62gl#Gg`kk!U+l~UI9`HQW?){A}>{j(q;|qV*zUH
zaRb&CQQo;TSGMC$dhY+(cDmyD*c0C!n<@F5jkkd{y_3kI{=2@qt+^kpnv&?jOcPwR
zh{#bW)s12Qc@il);Uk*hV$q@6HjHCwh})<It}9ZPVFPxcE-{?UP6&q^9#&=jl<<Qk
z2>wAlqQT}pzlMNR$n=rJyd^?7#gVGI>-c@2x0J&{G+c?P*m4^TOGc@NY``*-+t9xw
zhqrc=-iGc;a@HWyXgP>L|4DG&PY=qN=a^2tanT`Cmk;NPItochV8mBc^YG~eR}>e&
z*$rVdWIb0ZoO^ck5H{-iFbr5?+g<lu1j*JDa01adJ2EVuu>@3za)0ZOE0BBmdHs;m
zQL<LZ5UmFsW~a%_Js5DFa@$ZkHD~qAz@cr{!yT>zMHS8D;kF^iFHrYOI}i9wfS*9|
z68#Y{O8mOQawG%BRrAE2oHxm~75ml8zm&DO*_7sN><0c<6s~8yg-u%mO95fp5X!)!
zbeYeKz}-r(FQ_M{HGXT7a<4egEMrJHH2LsCWG20hqg6OU4aPIC4a-}R)efxh*@3NG
zV!=$N<NngzJ?DBfQ+>E3qbDk-l~J~dr)}SOM_iug_KT2Kz(1?aw}aNf{>#lNVW(m!
zF->@fReE{QSOoG(fFbLFEOsqDDB0+fnMx^Ty5`=JcRwS6`?9rX;#A0`({E9^+vi|0
z#KT13Ix);M(r}zzgvGIyoFYrpnG`={xu&jdDp$;2YKt-+_&I1I+`QHSY~1&G{uf~5
z^y|Ob>&^auI-dXUC|^!cLs3KJKT$s8e~<G2?biE8^8bTL|A#<=h5rAa<kNHfUrD~u
zKZY;ykKZf*BlrK4*8gw7{y%X2e}VP?N#*}5hyO1G{=cyI|1??uuYIiS|EDJZ-*>Vx
z{(Haw$=(?l8UB0t&cO5^=kfn2IcPO<#@Xt5!P&HJGu&)hU$dw)+_bRXWW{2Mw&|?L
z+>{7pd)+y`a>+ft<VuLI_wk*!(siog5FHCoRz3@sxr*{ba%q`)nu3|)22gM}F(n0H
z0!B`Rz~*Q#Bbu9AADB^{n!^|a);~Eh1r!H}=H>PJdZ=r>uWRg!2Nu4*;=!hwn#u-L
zE?D|SaR3Uk@rywl326av7cz6on;wNR60-7($gT&STMq=px3+<m|0x}W%!6?T;_LvD
z`Lman4oHeNG6O)AmmW-meaM$kWFvD8ko60f*|zp;H-UO~_Cx^1|4f&@<Od&5>e8};
z3xJ$Qfn6A|J!;tpPxJdvaL_wQqFq&u3S;ww@f)k~E4MK>GO%&z3w33ErIY0!1K`eu
zoL6}LOS25{qm{`$H#9JO@@rb04O>kU6>KwI<quHe8%mu;Ougk#Dv35Tasr?vWJR{u
zd%&-i_)B##*zPN#zoeX$psZ5({hIzmRcdT*a9MR>@S9uyi}D+p{(Be76@zvIfKvkR
zna&5r=kxQLxbv$awY9P~Gc>RQ(>E{!Nbl^-{N(r9#)CHmcV`HuzLo*74aolr-ya3j
z;xdCr;|DM21yJG=WB-dy4$kGL@RmE*8xGt@{t(Iz7**gK2Hi*g650kBb?{3dOA1gp
zgl7mwFZn~D3Q+ij_mM{N8_H`+`IR4=9`Q?16PqsS8wT1}_Vw>!#TNl9K;Z@6$6EY`
z@7duD1LjYD>~qx5+^EOMFTqP}R(<yKX!Xx71lA@WB335f_mnhVf%MNnY&OuZ^qc+d
zuIq(df2j2$-<yK%2l`K9)7#?A2Ykm5%WZB~cI2VnA+O}r&j7stiSLn*_14zl4z~HH
z+OXKv0o|9p`8&E#n$a`554-+1y3d-?W9mz6^>6yr&%C9T0rVHuZ#_pRpCNC?^$*o|
zJ;o>Bd91-pNDRN0Ro*#X=UUn?*~Ob4ZNtC4Air*GS3m5tF9t!~&5?_Gk9>r1zBQ+O
zM?lUWr{`aCamm-YdD%>JL;r4qn*Q-m?v!t6dO9EHPebne;5469!><tkYVVclFS+Z-
z+s=>0oBWR%_UGtJ)-;a4Z}wd%?2N68FN@dO#RIxeR@kN98^Pjr?d9YA_o^W^-XYHq
z`_uddr1RJ7)$gl25@Nm6Yk}E&+|zyNd2Zx1?B2=V%X_V)5&CHCp#9J4<?sE(H(jQt
zS64WH9@pHTo6~}92D>;DODFO6TDN^?P-57!u=Q8=;E<bkxVOGzH~Gs11r6|wXpiaB
z2^i-h?=f$}R&?&tFqhj|WF+(-I0p-8yU!ZE7bb4sJqum4G0(3CGIt1W0b8q_ULF&0
zm8|VQRB{WHm}5QI+~aBmNJ>0@x<p{-^A0vw<1hz%OG#sOs?e}CrTQeQq7qKz@J7%&
zu0j%$e(JeUPt7pF7Wq2e4OXrKp0q*ZQeKPReNiGTwq%AXJNf<cya?PhR8S%UKQB9c
z{~Fkk^hypOS3)&?<gt?ACwZYurk)28SX0`DauK29ow{@1=Bva$B&Tzm<m*iO#Vqu6
z2^zGf9n$1Yl@TRg0ry^9U`5=H=uMNPAMrNc-FKq0&NH#9tHmoJ#G+pY5)suraq%3{
z`{Pm0nZ+SgSI}aHbZJjF$An4wWLHWDAZGQE57rcd-v^cEAhBC~W2MeXf!T|~<Yb$*
zQP*SQe~6r$X^;;4<vWWjtC`V@qbPqFscNB4wnbuEVl2T8x(JH2HLDk>wf8Q2PjioO
zna6D-$f7CIa)HH=1NKbH&<^^Bdi8)+LW=NXf?$s?I(ApY69rV4Y3122j>kV$OWa0y
zel|r_N_)Eb#PFz=K{^<@B&I!nkV38mi59Vo+@nibA$0BO{U+jxLez%baV(PxSy$8x
zz~!9B9I~R~Q`2N!AelD^dX;I3&S8k_-`M02T_!<A8eAabTr?pz6pdmcvPRM$CV!!z
zggzciVxU2!02i$c5+hmF76m9}OyDV$acw^)iDX-ZCNFFn6fYfCmf>$}^6yd3)9#1F
zwXKs(J@aM}Ey7nU%fLd=!Lm@2keB;!lyc!^)xG7j$jjIVRJl&x8OC&%f*jVSp>KyD
zW_=Lkaqt-nBVgM&hg)6QBS}*7zxc6?bV_V1nG__+JTLUBGo<<8h=RsG)TzzvP)IU~
z+pz}6DrFY&OzUEgjb(>}I;<)A7ua+)qSln0qh+|mfC+19WJ7r@?h7lbw=;b)Rs>32
z7T}^Am@6RKx1<hnET*>_r6AbTj>$hMA~xH{7r1-2so@_OMN4`KxSAtaqzzK?q>#|y
zj^)}Op_!4!rGJ3hj5R01({HGWcwmCnRfMjOgz#4v?0PkOFu$Iv%}2yp<!EeN)x?2U
z2yj?UM@ECZ<9j+}q=EQ!E%xJM4NdR~YNDGH<5g7#>}d1D{?s?dk}(0K>L??xCt1H*
z>M#>+)kec_OJF@#QO6)!TViuE4_{CiQBs~>fyO8$LuL&>6eF!|p$=kPutQYTS<48(
zmG^XvY-Zn7D+)AD)Z5%bjP@LcE1+j8gMA_<G<bCW6E>LVVsn?YF`^RqbHC7+>$)mt
zWHOP<utD8jhkPDk$9;D21W!&oT_Ras81Srg2_SvW@Ch^YVp;`CUl8=T^=t5ik7L3*
z^|dk3%?Ku-p5KZ1${aErKG|@MlCD`&^RxL{?z{gfY=DGuU6uO^Ibkg$yUn>zlGqy`
zN;rCVZ)CI!X0vd|&1)o*B#@?{$n_``z=XlHaVCwN%*G&cLc5+$h)mcX57LlqxAiq`
zY@L`V0iBE9;0$(394U4~dI|w%D`jTnUxuJ4>qto5f*XbCLu%#ewx~2fh6*KL!KOvp
z8w0qud(5}FtZ*fl0{H91d@j{1F;~fn8r<wr&+|C1P%n{KR{Hncxc`Lp2|D=D3$~?j
zOP}i6C8x{IdiwgO=Ak=uotmOP(?C4D^mxvBmJi%R&j(_#y6yW|NpWhsUqa8$YrVSy
z5>gE_6%pWPh%ZKxOSsegN~_2Zhog6s9vgznA+El)*_zk<-4(1MiX+#_q5Ni3eH(HV
zg+kI-ZG%X-eI&K3j_2szpo}pt=#==2S?hsvC9Cgc{ooS=cjZYpYVipu=jMJ${k-`>
z9`L#Zk$kIF?v;St8fUeGkJK_JC8<pbby+p95#Q?0LyyP#qW^;A+#0@V0V44&Wo%Y*
zM&Iq!u2A5aeD=ib#sRs0(U_0KACxM&n)P^#&XQs#fXXG2o@{o~jlYhrTd%byUG2<+
zwhm`f<}mB@ShP5i1dZZ1raX!kCYxZ!YAcwJdw3dxlKTBco?b14U7OdXt4)!x%i*E}
z@V<OlkvGj<B>&dzUmF2uQY3WZ0sVW!9)GAw5{hD*-1c!H!L!<m(@YNUFAoRaT7%ZX
z1mw}E+FdD!fvYxpNLG{#P=9c3BOn-Bln^+p4%c(eS^mi~d~F8QcIm7P@Bu3$C{UMd
z)<GhUDEMHGPz7=I1uV!Yr2OCQti50&prgSMUTgSXDY;%`bEXEa##MG^*UKgMalnF_
zd@6h~RceP`+~eyXL5((kD#0n2xRz!W*C~l%QU=-(<3Tlg%e#zt#Fd_p@ikUVa^=Oj
zh5XGu70dIyspTlDLA@w?#cnuaj@U;BNoknKj~H6!+c1QyZuW&%DgQkaaD|~(iR(>)
z?bevfVpJ7Mq@CtLAVjrRg6j*!YTR9gu-{^62M4I>r4GDWVlM60?I%yR76H`M^;t>`
zxnCS_NL#>Q`M{o;>z&4PjqNb@X!I%Ytf)gjD=C!6Kl{4Cf`kLM*2J}raun-|xhcCJ
z(gvrFz&#5Fcdu^mt%3Tx#QDiS!&0b~fgs=#G~i~l-6d3wH^nV&4NDX?Sh3xdBSD+G
zSIKA<rV$QAlXxB`!}-*$Mg$T+35giN0{TtOGE3osOo(u(ghXqAaiCaZjzF3^cSLCR
zv3yzt3YJs&G@8nWj!<7e+^&Sd`P*NC*@=bGx7h(C4RZc~!bpZkVs7$U+&>d%oSgy5
z`B!PkUdkSE!5H<3&Xid|)_=ZE9uQjqU9$jzQb1UKBR|wd!2_`PGVzA&6t)CY`xkei
z9I!(aN@ZqB_|ZAlm*KjLcm86m6$NP=Mx|Qa#CORi9Sdmi)TbS!xM&opB5^J_Z0xpK
zF}@ha^{UBS$l>)+sH1MGS$Gm<;B~K%rs;@f6fmAwbfBoiE{N(bWt$yr?Te`DCG+9z
z^)xX1c4$`pa4(zMW?Y_5D*r(ELUzjU%xHWTYBV1w`F3{rLX*t%e4N@0xVA3tt8zd9
z@4iq@p~qr(-48B2n2Su}pAZx@-59`xYG9H#59-Bzb0}H`$(&iS#%41^I7gxkkYoWq
z3(uZ2Q7!Vhw?@|l_2vA<9=NmuWx1OXI2$h{98b`<hDi#PcYeg8g1PgWKo{FnzL^HC
zI@iD#(z>t@R+=9C8fOn4g4_j|QZ-6>Z%W+DG2iL667-UT7}rn*Sah6llaOH3@8l`b
z)9)BD?|m6I5dPO}0W|QH4^0SZ7X-=guU!tHc(Pii<Su6DGid&&tg<CE`hMUiS?~_C
z<PO7=!m&^bv!fr~-i~TOaaNf*Ef9OsT(!}sK9O`a&5I!R;}{HBfX67%Rc(_QB~qhE
zE)ou#C|`y4xGrfSMh$D;&Ei^w(QIfwXPg&aW+V|-aODR|=l6XMlTy7!3zE%H_0>!n
za<-*cC)$N%F#-5}4)?2@dZE2E6EbAGN;{4uleI+dQyD|~)HtIEwuOb0SFL1!18r1v
zbAM+V^f5Q5pD~ra?YJo;=^qLB$p}Q#BlaEs5#gC@{v8n=5(Z8Zb<o~s#0hrcm8TFX
zB0O%&vj`{SYv6KI5qSLk%YEcw+Yl1U*juqIj2vNzFoZ(@@!(3bq7WITLHz95rcj`j
zGy4{=TsdfU7>s`3E)DLPPGc#yZbn6VQfZOo!WK*%71s-S=NN7p?X#y)00bHtS<n{K
zlUMepPo*SQk%hW&{X?lXxu24|zntGFKuj<Z`O0@k(_bvVy#H|^<}7H>b~pg-c`;u|
z3SGs)uP*JQ_B^1uVO8u*u}^f3H(vaxRU<EOJdElaZMlDl&x7*7;)}sp;g}QgBbvAR
zGcv<&`+UM28OHIH!4qt`-Ytug!^U5g*J-GwuU}A?>H05n7hIj&|0lvc`X(v6=6)oY
z7Bdwzzp!bf|Kc{<c&VA)=@^f6F!O|*<g@i}idlP9BPl5qXmi`<;aVy^(orCwFYKC6
ziKtUWnJ*T}dN!u*YIR)RR;!a<E7(a_u<#Ql3QWE7250pMmC3uWf|pzzLShXK4!5=9
zA(RjrBjns5{F$TmZ)qxJ{7NnVn|<BkTyk$Fw}o=f_8dNr$8(-Va_!J2vbV&2(1<i4
zsXrWyBo588lkZ@222;ttrHs39LgIm_vGjq36b`Zv`aH^EpsCCtvT{juU4~S+-*ufw
z88`}3i!VmGO+Ok9X+;<R^;%@v`>}h8f3Iedp#u_>e+hJamVX8+pG=2pQi~Bab-chO
zi1ms`vV0jAN`Dt&IFJ_3ZP@tPZqYrfw%mp4@_oK1Lc<JYZ{@?k%OGJavMZaSBbJpB
zKljHq{I!iPg?xf)CN`*fM6a}kguZ;`npodX!nXnksk%v*5~&s1{SOw9&}QZHk+2CN
zA(`|hYYYqiqM2C29J=%j<a)KuxtG!gC$;MLLFyp`zMvg}>OyzK&CqRf$sAj3Y;xrC
z4yE<HO<2DQVNLgzc!6I1Bn<A|UlEYb({@r)6~Szda;s!-Ua6?CHkpKhe%dBEH~3YD
zm6dmVl-C&qVT_)MzaLO42owY(chx|g?q1^rONp_>y06xMo;mNxK$*bJ@T?>)GbLLh
z?ny6H`brhja7If<%dz?}$&l>3P^0KD<{$vuXh6T`3-_6-@DFgbB0}ty!`_4sYJ82M
z%?WL{?aa>WrbelHIIYL$K7Tkc)n}Q(<6F$8;)vqA_Fm9BZ}{W45JA9B_vb50NR}Po
zO2=`U^L`@m<)C8~c&`mf_YVb>Uu>Mw>k;(c2^Wo}M_0r`$~NcPcK1nWkG@O&mHkwZ
zRb`g4rn}pF?KZ-=szzLEF?$OLqe_OnSc1Bgj4f-qVmiXYLCOjZK^7KTbWF9rTdR%n
zKW<>Ku$mPgWPnsi(E;<u=U33C)d3%~J*dksxmmZK(FymlYasimIFflfG7;ykV>d*9
zTGv6CKc25Id}bqF*&40CzBvdAo_*wf{FdVUBC2i~RVYCK9pROGnnf1qP`&dDPw6Ds
zTpl2mU`?BbC^d6e-xO##<(wWZxc^M-ZPUf`GvJeeuiLioc)wsRRc#(LJJTsldh4&p
zQoWR8e-@SsXo_oB)wkg-maj+fTV2So^7m5Xn3WWNy3|E28z`y2w*b3SMW2$7Hp>yy
z5RV9i4Iq99FEXnVb2ttoC%q@DCX0lzF``vlA5f^4yr%BR$TZ&eCWplHs#KJ#QJVD>
z1U5l)TE(D0B%=>Z{@I37uJ=+3&<mq}?x!tW!C88y?+mv&U8do);u*}c!jo8QB^=jt
zI8e{Ks;Hq9i%VuTvPP)LMjuh2eTVr29Zr!y)}9o1o*D@0WlD|skp=J2LGxi6ISs*t
z4N*w4aXcZj+7f3HV9<G<wwnUeuRV4Vni@$T1$>%%79`M<duU>QL=Sb&HNP=*g?a#1
z!JGO(WvRy{d?~=+y`YYjZB?Vj#JCyYggYdpuZ_}7Vb~ffd*i6ahW_4cUDdEeik{=j
zs$FsIFg+TNjMI|axG-%(E`?ZZH|~4WPAz?pi#oFNmXH~F7wQ&r?*Gpwl-feQ+p;U3
zB5=S*K*A^VU~?mNEAF^VR8ZH#aJ9+4Iw-gISdu}{Gl_!x!AnxmkZWWh^lpi+y|s~?
zC~o0eGk|O#x+|q_mAD6_C&Yz@x^7&NC;ab^Tf~ps*Nxg|m7ZlpSh^?aUMTqGAw~^Q
z@;xqT;RQv<u@42hB4=cRBfrVQ)Z1=%uryyA8*Uti;9QD7gysd!nQ=*|W!wej<<)xk
zx_{to_H28rfMvAwTnRX3JFafAtH18*d~5rHcJ`z@F`9@G?i=Y0$1H-I!I>LA^}YbI
zxj5kA5Y^|%{=%3s?oxUXHW^F}v!ro%k<<_-VagcGo3)$cZ|QqDk?Dub0FPW3?d)cp
zOnU{eJZkR7O&J|z^4FYGq%cD!Xm-`T+<W3zhZJkp20T!=jlDEBOIMW#WZBi;_rA^T
zyu8b+O+#+CBkr;@cZwyJ2FhnR|1IpVH$FNf3M;*RK#k5ZL6P`QWkmb&XB9|DB!h`-
z5At4srI?NVvP^`YSD$WkwO0&UW!*ZqKHnyIMl9P1#!bF-SaS4U#E75WbPdxk*s0S!
zk5H6=@HnXriMpq=j=P(g@e!<dOK&2epyX@<8%hem-kX%9@;cUI*pWB94Ob}-$3wm5
z$Xw_=^xnccuJK5UxsuVQVZB$yAaRJBO^c6hEdosEG7#nBa`8!@zwD*b^lCl;e4A!h
zG=faWIn>-9KfiiN6ejtfC(*0TC{0==&I7B_f>R-lPTvpzdU;-lQ!cN4Jqj7YOSsSK
zpBo2e0QeQvaX_LTh@fpOW8UCCNf3J5mXlR8ybjWVc&r@mPP<x4_vxYfxARY^T{55X
zt*#%<BjpbY!<kn}<;Ev(Q)sY5ayKQ;B<nRBg4;kzLKAY3_Q;%UV%2wY=O!cQ`jfI@
zx!_EKkHXHLPY$2qEOqsjjyw${p?Dei!LT-6qaV~b&ukQiM*j*)A0g=Nt9)QUt0<l3
ziE--EjZKvhKgM+RG@Y5ql<v(#AK|sb*@5_CK!WYi5@DLUVYAE6Uj8&zTw0n9y!S39
z?;Ea<`k^^@eK{9x#6?rvRdyA&KocT{pm&h*i~GVBme!37yQ29RPK+q{wJ+6w&}fe0
z<+S0T*U~aypcyqUwh$)z{oNG<bRu|i@DSc%@(TXT5TF!K*!a3~8?+Uy-|)t!Iq@S|
zzS@yXJET>pRix^#P96eaVtKXIG@ta5+ny5VZaQk~U_pBEWPjK<i^xd*zi2R%Rny5c
zv!oD;0>e~uRMCl9U2Tx~h_kA~>cI6(lg_-5&Y(m&*uhlGL*QewYS~X4@nL(Gg67l;
zg1~)wPBUlx^Y*GA!A79u1iBl+>7zVIaeaM6L3zcnTVo94-R#f1Ua^VpFshDn1u>oT
zE@;)gbVRI~FMax-eDGb#NCOVUBuJPOvr8x(cS7G#-iMXE4`Tjcwrx4X=SSpwB$<T+
z@3N8o8V3x&B8LRp9(3lC{_b4X9p_JkLrA>9u8LSGY-WRIXGfGH(vKDXjMF<y`2Z9a
zwmq|~M>XY)*LdvlW;<*`788Y`sM*H@tib(b=l6A<2a$`u6s&Xk4398}ZPi*wXM?f<
z?y6IZFnyi^`)k;G|5YPB+LzR`gH3+hC-6T^Ljn7jh}<qotq69R^zTbha64K|DLP7M
z+h5{19XuTD-3dzo@#$PFzlzAMHMDMAc_aQTN0E<k>OL5R6ze%Eaj{@OsWUs+*`8qW
zS8@&N^6|wm;S4UOsfumFlLYo>Y*&e(pVjUVC(I!58lu%ycS=&s3A6&ws>aF~3Fg#V
zFHd`2Wp^#@0^$IaKJgvOhdyqYE}Y5v^p#^`JVBeqtv4{*4C`6@1tchur}3noc4#&1
z_TUGzqrnhIj_hYm&rPkRX4qak39eF+&r&iy>V1;R!TS%v-zYS7dW?4xY(hDJ3zmU_
zT9B)1^ikr7ML&<al}6zQk-D=34$zNdAXz-NU!Bl<f@!elU@^*nikK&E=ufEgZDQfu
zgURgvJfKp|_A0M@gI0qxd5^$P^FWRpi-XuOMu_Dq`$=bM0xPYUvLdiecWrIgve@E$
zkpMaUsM5?QO_y{h1EaEW-NL?&J*YS+_!J5$Y6js1Oo*b8ANT6{sG-VjGh<S!1(m)B
z_BRZeGms~WfP^@?827+N<JO%bd*@4~=h$cNJ$~buxKItXRd?|Eeo8f0o@dh)Xp}6F
z(5~<-cdhXlm^UbfRiN%@z@;cP!S>Y98dK(W0V6H5m~iONJ~Qm!Q!!x({1GSkB>Yq#
zTQ#QiG@gX$Cmoh!mvHh3Xz`-XTrZk`hJZA!clfir*BHU^epkAaBwJC|{?<BJjq%iP
zaOpzn<U>Rf@@%L;j_}t26cb8zitxA=CalzRrH7NALj#`gd1ii=O|fV9;KWHsdd6zx
zgFVctgn#bnt!F@{g>8s`=S)Z&!?Vm1D6l4tDZZ=4jzbWjGS(dw(K9<a?%jilDoEKN
zeYno)(2*^f&FPO*SXV;DuA%T|>dKhr%ue#{-~+YspyB%;feQ3va7Up5id}}>H2<|;
zS7V%tbG%U+N}nJ?GAL_o|3TQdwE2}TIja5*b{_j}uzT^&PH;@5XN)+n#D8T>x@%e%
z?(_|hcVRB=DtIBrTgBWu(>A0+0vA2(<)fizZc7}?M`O^F3(%bMa1^a97>dM3Rg9gn
zV2J2fQQzZceKb#Xrs>s3%V>Rnz{pBE!po~#tGfEnVQ_{(b3qdlidk1f<6_8B{e3ge
zuZT;*x+rk-ZFG%%l2r-)#@I^KM0f-HjK}T^wcdkK5Jccfc~MtW{-*X(gDd8BQE73L
zHR(iC=USN4DISNB6_4;dRL3P^MUqTq5TZ3F-#e#%65|!SG#6{Y31q8TbOr9aV#;-j
zk8Ou;y?2Jo$i&Bmazr_b7cIKnaSj)EjX~E+m{^GW-Qaj@5fTDuTMCUuA{jJGNZrh8
z_Fyg+9BU=FTW!@K7wkw5Bw|3rXJN5rHh3^GXeS9LG72||GN3=`Nk3Vy`cDbw#ES>E
zNA#Xip0wJ_d8dL*1$ruaEHyyGA+F%q(%dTzF=9Ll37_cav59$*8xjmnvGs#&eWso`
zH6ZT2wi;p?D_NoWHrC#mr?$n;1qfW6^0X*b7lag04K|pJRhQe4(N#=JiUWL539KwF
z1ZlaI+3nJ1gX(uWgx<;{g@2kynC{BSD&Hj6hglFxamt$|1KR1wbA@LWZtk-R;8qM>
zQT$5awtd$pZw*fU+hy&cv0Oz)+=SxpU|Vh*G$Hi`QKwyHpTDU@j~Onro>15I8(?D@
ze?FX!O)4JmOH@Cuj#2+ug8~@=Nix*%le=@RK`^l6G@$;f5nDx?FZ3r8ZBd{ai*FyL
z3MCP4FJIPao_^}(9O+%x?QRpKoJ(?rxlSv~1<<fuZ`$GBeXYpOS99%z-J;2#Riq>U
zaq-^@wpLPtn%Nw88>X+u8=YXIOzslLw4qdCrXA@+^eB(hQ2R7<m<>Vp>B8MehYm<%
zjd(DT3}WdGN&3x;C7k5q#@6NE#>N&~jxT+|$tK}l#s5K`A-0(#z^I#y;Y@0RwZ^w8
zTw(JQl{@S}E160-?4=hT8`L3rb&p2mUP0o5+}%5DaDId8kYY73T7OmXE@WgxZy!Px
zvDCe9<~1J-p%F>l!C1UdzYaa`=?)?Sp$Evxj_vRjD07JEuB>1JJ)=s!SuI7Rn8J<R
z!Q_N{?FoSAkV*wtwryW_lty!tBE!gS?t=%ffdY9#n|YT<fr-7Y8)(>u^vuvDGx(<$
zug8qd?iHVk-&vV54>1hbOsYs!ac|}e#~zYWDDv?AITj4T8<L2qi?=>PQqj~=%qsTF
zK?yD_J8BAz_iaM!7+oF5R!g_)CtUwHyVLS}A1$g~=mwD$f=~&$v2^sSpsuV{0dkcV
z-M9|RP4Ac#xx{(HX$F>nGc8!=FnF82jqg`T_A1e18vhJcs4HFhda}~X;ub_6bo<6I
zXW-f^CS9<2sf<Tr%I}k_+$W~Ry=nx7G2Z0Hw%_^i1)FTj2^}QmA|)~P%o0L6S?{pa
zQ~W-$S0p?ok#7fIMjp8P*Uu*i7u37!Jq~}Xz*VmJk(d{9q(pB<@Xa*j9iWzn;%v3i
zvvqk{BFnfFNl>_RInUTJ>O6knb`FMCbu4*<wY>Rw^_wcgEzRsq;+<UE0m9`qxSk@c
zu_8*a<Ml)44A$i2E*~jt-Xi>U5Yhs>l2^d22l4g0?!hW<yG52b@4;ds4w#&;oAt<I
zgXC$Qm2*=PyF?x2Hy0z5zGDi_(x@pq4AD=sY%;r{<6mYY0)wW8mUM{RtsG-XM_UNk
zpZ_C(y2oX>%^dgoPi(Q#8%rw1jV=s4f0t(y4jMjO<rG+-t6kv@5!PS&rtdS=V7c_c
zqFuOLG?g{2`6b$RU&IJRvk_oaJ3SE}t(8rwh4lxMHWI5BGLz9ALaf&m9)HS&r~k*>
z>(}TV%(}doL*%H;);79GZ;4UW!C8|qJ)^;USM2D4aX%E)Ku5<{L3CDu2v=S>^=1=w
zrS^GNX+usUxn1;u%|$IpES-ZRZ~IOmH)R}=F6`<nzT!$*ovCcqD1P9JN(k~{?JCtC
zCVV$MX;h<uZGNJ6P5_c>H>Lnd+69?z;+nkkAUa|(xPG3dRlj!O?(lq#D@Lh0$Mg7R
zTOo=Z@ujhbcovG6Z-J1y)t89oezNzfVgo7&BCTf!Z4YiRKh||3Z*pVEe?@2t@mO4@
zsp2YpN#-F>?YkhL#M8BeVE-tkLO1FnPYB)>hWVn~al*=MkEtv<(^Qn$6#YZ<wvhUp
z={uSy*!s2ud3OJi4%P{dHMuyHK*DuwQGwR$#OnGpB$7YSD9BB4;K#80*-b=!M=-}q
z*JwUoDv5y_WLjO0c7B4HM&M+zOL12&JkR|Sk+)UfF;|vlOHF*X&(%7G!=42|kpj1J
z2N`2|`)uENW%ZgirAsW9cRwlkZ~9&YK8=yZ;RIBjn|R(PAA3Ma39DyS*m~%nGbkPN
z{>5Y`Z^MYyyQZr&>}<xdM2MbUqh%Gkb^|>Sq}4BNT9D9`JITPxSx^ILYcxu{cG2-s
z!03OP&G1s+l$}I=&kxN+;?DxoKuP;e+3l6LJZwcI56#k$<g(K}OdK}g1LaD4AWS?b
zo7ugsj^er0NP;Ox83Ij5pk%OJ#F~Ol<S@l+u|gx+*zhd&4MJSJfLsb=h@_$I)(1S#
z<VZ=3fM=~T{ZZY5j*>ezP|w?2JaZNN?e#RNL`f4%h+$Xe603*LfZ;uYs^N9h;!HiM
zErlB^I5(*igA^<g&cCRnYB+Bglco59v||vP+-Z2QT6OJRNq{kGCK+AK;n-Vl6EDwP
zYkBErdFcIPZ;WcH89GPzXtr6~YRxhCg8Odo!(1PoqmM;o@oPAO9dHOK6H|Zm9*cHX
z>EEAf9ooSWd6z{4#<vKNBa>hC6+S_W^(y)PzD*Yv*czp#PO3%@XClP8G8@8hi5@0X
z1#gAu7af7xL)W~E(iBFQ!Uka#6IifB@Bljm1j~gfTcxRy?_e3vd0Ce*f;Xej&+haY
z+a>UWy;q48@F2Kyi49u_;wp4}6-rM<gKU!k)eBl!GgmUa!OPVHVR2KIZhP=5SX!CD
zT0~^+zF>L=*3PgUM#0BOemvFKrsv1P8|I`NSzlf9yC-cqOQFb|@&x+V1b)a4$p|i_
z_TuKLQNZ)Mp4l)*Z&M>wA1|5r_=HY5XoDRCFIy3s4<27+^z0#mWr7jn3K^fM0V?r~
z*-24|mx_16RoS{L|8>8wY@>!czb2TF4P>)hiNm1JvKO%$kb!N@%-S{~-F#K9bvfO^
zskjaa_1)XJmM9dvC=3#b2}8uybh;^m9L{ifwsbO^@%@XP<dQ{rvIjqWmlckvQec6N
zL9D-i-F>FFTD!PnuB@?w@)Qp@;I_n`Ted#LfVqdjh`lEH!+d2!?V@(?7P!AV*ldCO
zhy(vu<AHzQ21=vDZAF7M{^TRGeOM^ykpt~Xgo<;ksK-F}()MaPqi(30u6dg0Y-^0P
zIGqBVXo;F@7*lLVMDNbN(>Z<EYNJi5(+yF~_-L$%Mk&m*k2jeL5KSY_Phcd%qsh6D
zDMpVKnZo!gcB(<SG*A7fQa`wilMUESFDh^pIzn?`rT@Aq411!-AGRXspcbuSV9CHc
zEdnT(6**)O$@P3Y8<^1gjC=oa5xiRu)+sAuwiR2yI8*%|hWs#cz3g*8#Lg&rEC1zB
z9x~nr_I-0|6B42*2*(mNS)@gQ=d%rsoR?$sOPsA)QjRwI`uyojl|I0Nt&=`Ucv#5<
zffm2!dfrq^mB%ZHNQ#mqxLWMQiOM&|VoJbay8rOf#{LOi+Z};CAd1sgw0DPaf>&yj
zBy}kA7EVvs1n%qt$=}}A!KuG{)uqjmZAYcY;CGy*jafLEiTQtIWxNn3^7V#oIePXr
z@IkA^OzZsC8!6g)!}p%v_CANr=m5IU)ae3x*nq(2sY*e4!E>(8Ye@r~5Mn0hFaC5Q
z>|G0R_q{~m6+k_YDJ-ZSBoJ$3rc*R>5z+<=i^`vLz4l{W=c3q~lQPUWZhlEVkKKWe
zpRktqSuii_=Pzf620(eXQK)MNs)5QrV_>VsR$@$kl2Ri^id0-r^}fz5Zztth5Vsoh
zZc9lNqP#R6Oc_vGkOowF_MhLlOjTY^(PnHG4wA0bfUFW3CTHRez@02eCzjP*JYPLs
zoODA$;<P66*kj-+ft_PguzTYrpUz!IyKosuKGXNE_A%L7Vbm?<OlV4PE_Hq|I~t{k
zXw){6&m^i64^ZgM!_idf1A#{!DTS<R>W8IYC>LGs3CiLI6)0nKm0@!IEKJbrGN+k3
zzhTg3;Du*JF&Zpn_E!lJR6r<0T>rZo=co)bg)eG+?h`lMW@x#;bP=*;K+k@dA(~PL
z_}2poTS!!~5skV)p_y+}B4L^A++HE7@0E)ScFW}z!2NRj#G9B|L=9Em@y<xGVqRBi
z(8L=JK+(tIfPAELUeG26m2x|a)@_v{y!#}40<k(&bSgJWgT6B=l90l<UL6^3?QVcW
zt1wY|$>W)Fh&_KRf2z8$$nuci6ac4V)6F9ekHgQ4#HM!%jc2fzWsCUcS7x%dTMqQk
zccXVO2fk)xQ~WUX_$k<PdW+hk&)TK}70(BX64G&I<_@lPaedX)dn%x~N^{8Fp)RYM
z`D^C27t7DjPhjWqIVGWvxw%Ada3Q2}Do(hk8r~{Y)c_wp?6VHNkE~(H1g^5g*Mu9V
zH<q~;wK%_!3plxx7;f9;M6G`C(R!H>mBq_=qJkHrqE(Jz5iQ~=I+Mm(G(Jy3h(TTx
zR}^=&v}RX%s?(i*Fg6nvGCX`jDnIP+>H)Lbm90;&^EDIeQV6ByaY8&4<=zRtGH-|#
z$eoIF>|TJV?TvQRr)cZiTTB+t7g$ECo8jU+3h6?Dp)w9hSB&u`r7%evj%RkmXb&07
z{#kQ4shXYO@j+O%AMuG#@iYoaz-C~v9h^3L48OQT<a$+xp+*}Up_;dXWcn=5{iL;}
z8=e`nLlp@go*O{8a$^d8QSoqZFgv_Gxyt{T?vaghxUtA|Oo#iY0CoK?bq@jJxj~9f
z^kVAFrEeT6HO^ykL-NgWv)m%H$uUi7{H1U+CxNFK9?759uDA>$BYD_GvC6A6>Bcm)
z#xZ3E9}Wv~_udosx!X5WtAK%g2x**o)Y#t_hax0bdmD$`)|K994P-xJ{C4IQ-|BU|
zPwVHK)#B7#*xH>*ia!Ci#mt@WtP~<(L9=7_brUpc_9V`Stp?>R^1k%ImbQMUuLyq<
zfjPNr5AmEs7p47nFP2?!$Hx}sBn?(P#QZpU1q{TeLfGs=%o&8ZMc1uND@!CnQh$q5
zTATrN+!b=sbNUxYP91XUo~vV--{h@j2G!=7S@;dBq#)8y!e|mXaw?PMG(hu!%R`I$
zxGP8d<J$a&3^JzDUH2&9U8)m3z*+-4a^NY1*hb26!XB3h@mEKeMHpf<MIfXi7Z-tp
zDgg#AZ!U6<sVVYQ`y7SedVOFvu*tC>F(tjSS!^pVF=#`Et;ZsNDU5TK1TTxFD59@;
z^M0N=pkvvbV-0L#7M>+v<LHcUI9;xI(tgq&kDtW|!&g~lvhVZx3cS5^gWV&pux<Vu
zX-SB)81d5hs%lq^>|T_w;`R?m6O26ZC-@D8yf6mWG#DMrVIMx$aF=#7S<6<2m4>Dx
zg&mp6s|yLhzhfrn-;Pj7x7u_0j#E*6;Biil$<Tt|@@E<&>M6wQlH2YkAu;Re>5qa;
zs52<0a|k@UFc^JJySGPN+i!SYdY6aDf4D)CTO+WMKHKrth6D6=Rt}|g^byg>j4)6J
z@KKiwVtW)nYCKM*e*`r`QV!-JtVnlDjA+$ajDQuLgAj$m&#pSQ<9<c$;PO##zfFxT
zvr{>xh<TR9RX^LidJ_)*+b>iCIZnLBMk8E2rmM46f^~I+k)!e0AfwC-JpwNGZ@!4;
z1sq^;oIAkrd4QaZ6p`EPv^2bpx5J60nI$3@)EIG&Qb;HB>4vljadx74q~1oUqLNlR
zUK$<jR%%3{VHYP4=KdcZ(`;8G97%Ghf0hpgPpt4H8r#_Z+c(W&L|IOkP;{G8$2>0I
zpL+jF>m0YvjMpQ_$2Ul*-eD$;RxhaLlY*QSYcptz<rh{^k;|YfLNYpOfmy2x1?TyR
z#{90lyDm4b#15ka@`~HNynDy05CjW>h)YVEE#26*udzonbP8Hm@`O}GU231=<hzrr
zA>EZ{U8&BskZ<$o4O;lu4X@~p@Z#@qJ7P0UDj~Mj%HcoFmh_#r@C0#~h;=D%Hb4&f
z$cZ~3eDUODs;mirrpdvDMYarltxt^SSp%=cI)7Ny_Qe&twbgH?-ST-3Q}2WN4EZp2
zLX9Xi_z-&jMNF)Ik)|pa8j={PCv3rQPxouq=%}?W%acOlfrW+n9`*CNg|WjfNbCA+
zJts3Z{HmDpB&|Ozul$qp#w}wj92|FN2r34oY$P={>_?UEuyjRfW&)YkzbqFDTKDhp
zl+&5*t^SA9hD9u}4k9+S;zN+2mVG!y%LvD4oS32!!R8&s_N|@uiKBkyl~CKRP#F~}
z+Vc>8hmUu~w}xMVGGCFD1Y9fUn2BFo;cfR?@!(c)-ct~{f~0HXiE_YVCnJd3SPv#G
z=g$oi1#qfb90~@{MGId*@MK=uatz8pHzso)4{?h0$Nhl;?S}{YidV1hHO6^mQ#1sA
z{gOCra><q@8s$a33x+4{MF%Dw#ep;V7=8pzoJPP54k6EKN#ngd(_VO*2xOQBMQk~B
z=@LaOYi!`Qk6f<;_r3LB6UjNOQA>UmF%2(}bqY*da5{@qpDH8A=ON4ECL5!NJ~x_@
z>8*qQc|@{psWBXV64!cF_->)q0|*cmF2n?;AWO43cs?DX9T_RMo-$5_uav*HIKD5_
z3Ssx)xpA5V^pG>N$rFGF-SF5pdS2<ks7dyVn=>#(HZip7ou%aEIT|};kU)Z|Cc|jU
z;HV&^Rs~BtI*|ANd~`MlrXqW3F(On0?t_d4e{SCJcd^=J#NDSnHG{-Dkw(K`FeVOY
zKcG_&c=VKE*Af#4J?yjSm)dNmr344okm};-k2bIcAGiKFK{y+dbsr8i1vk|L&fBm_
z{cE%<vO?QE=eYCNaD?GS3ywqe=}~r*PUlR}uVyO1O=B*&2*$W;2-V%A^^%E|=gC1E
zXcPyA)1L_ioFaAn&4y^Yv6k828-xIM0~9S}5-qL8^c!hWsrR<MzuEq|4CGA~W_kGq
zpKp_(V6Ap6LbXr6dm14A2o!ZNjlKeQ%Cui(swXgAVeJ#Bo?-W456quWi#}HM-Se&$
z5jrL~v3gR?8V)vN{qFw{(%vaLw>Rt4PO@V=*>SRWY}>YN+qP}nwr$&Xc5IuSf7M&v
zRbSWJT|K_DwZ>TEIk=ybIe+(@*R>uSz}PibuBJLT+$~5|KM*IwUGf9lI^w?Ksme)~
z&9_0@ny^wI7(|v6?T4xBt&PO`xjQl3q8QAdh!<-=%A4oa`=boAh|{6DR!0EBG?ztK
zP+{=eEY<CwNRGq$1D6?^GDvGRB2nE4@Xt{Z?IL+qwM}J(fcv?tA(j|^+S^Vz4w%9w
z>RH;ddby|kg9d#ZOO$2+f_Ja<iwxR*5S51KASjPofK(K=k;pLdwO1Yv$R={E6xclL
z1kdb#nuzPUuQ(pRDG0Vu8<?cp5<5H)2q)~L!QZB{8SWXD8c>poRe%p4A;-*A+K6;4
z=Z{*2;MO@{LO?;t;FnT@sENJ69T~<T9iVV&6*PT0vf#Z=tls>5!KMx-^1aZAm-&gG
zvLq=ixgnf)+M^wH1I6-QLm|1_o#<z#(JvWp;<3tv+yZj^r|AQOaFV26R~rmI{WmT1
zWAdyF?~>CPtZ*cd7|`c_Ws9{slu;*#>^p6fC-`xe#Bq1;2j+IWV=iM&a~~-ME;!#}
zomd-g2bCCVaxSayB9)LU7M^Fj!v2}zJAwTZP?r99xdi9dZQs{QHU(&8CZAFZiXwng
zSm)F!>&*+w38MV&jRaT%{BHne|7C~A<KTd#{=WgtRHQ|O75>_KlKb!YWq&O^{heP%
zL&J*4%EbDA*m|P>kN9Ow|Ge}>|7}tI-|=OFe*>6_{ujVZhFb0$Vx~Z?_}_rc{)SKc
z3upEh(d?ggr2c}MnYh}Rd{fE(Vw;)&*TR&Q={MZ$KS7+?SUB2K+kTVIzA*u&-{`b|
zMV|fb?cdSQ{$=axZ`?B%YFBDELp$q#S;6{i<4O+lf30A#{+IjxZ~xmrG_$NM-)H)d
z4J`U^aq&Oi{+WKpK*#cT$?Sh(nT>blSg>3ls#GQ8ORC^DfT8b4H?IqZ7Zq60iKv~R
z(f?^4dTs#64=qS?wnFG$M?d04oJSEWqR=7#^tSP^HQjw>{Q2TJeb*9o_MCCVsMlwN
zTBjz34i>-#dO-;l>t6!IMx=~)3m^bHK|xgHFWA#5i{3!Bftd@*qo9E2lLUtt1NH+x
zrOdC6OeIzodZyRqRbN&F&6-C}__SCAV&;}dM>fiaK?mr`iPuGj1MAPF56BQg;Pqqj
zkA{s+Uvh5g9UpRVETFS+n>hU-9suHmeC8b=p1hffoNQm{*(r3MldHP;=p%2nE^vw{
zM97$efCL~CgiIO}XYU?}KNHY&gEE(VGI8(T0k6%iUD56Bq#Jw1AJh0B%9xkFc28g0
zfJ6QB!<fDx5;Ria6tCNI<OAEQ67W(axY6FuFr9xcNrWjG=CA>MzNm6-UP(CmMxhTb
zj)7SEH*G_-9f8+Qw(&{q-%tP@KH{=w8^e!2w~nf_eqseacAZ|mM4w6DPzSvmjXBhi
zaOglK{qV;}#y@z<rf&D%EDUxUV9A|H0Lumcv7<t<k)3)=M^XR|%m;wH2H^_^?;@rX
zgN3mt$qFQ6gb2-|Uo*kITv`C^BjJ_g6-yWRjX4|Z;<@$)hXmn?LWhgqMgb>80KWl~
zL#Fc1Apqd}@TCFRf5pVt0SNfCtOD|(Ip*%bL#95*6}jpA@I|J+@|KB3>|X~7fA-Xf
z)w{e1e(~hVBDneTOs4~Y<k9)M{CYZVXrz7SQ3WBvBbTmKl2rmtK<@4R5<WWiA0(LB
z>i$GY`1lIWlucOn<Jm!onvh3A7jCp!25UqZ#CHSfC%m6qSQ}{*m_Jpzz1!1`7hSjv
z>`d+`I4b|1FRW)#NjgameDAvZqnGAC0d~*K--$>+1efe-O=%3maII=>oci2-hr9}<
zu5Vd}y{@WU(8a;Ft(@WZA*(#4^n@`hA@_6&*<V4Um|jU;8VL_8U$-=E*BsHIOjw2I
zai9>SY>UibH+7|8Mz^^kqY`5NTmPdqRXW88_t76{s3V~tlO0!x(XzE}Sl8*e_hy+2
z3FngPdWFT`UM9E2515aC@5$eIH3zC6vT--`=W*@bDydD1R;S6W%N39{JSnlj<>mQG
zXBUS)w`*(JK_1q|`Oo<?OP)^$BwcAKqqjAzwjqbkS+;~W2eDkDV^7|#ko1BV^Zs!b
zqG-)V)uW>76UJEY!ZRK}>pp1-+O26CgW-^=PQWY0mr299?GVFps`07)h!YJO%x9{-
zj@S;NQ{y-)-4Jz~77>LS{Bdct^vJm)6jDrbEL~+N7t4Il*(l}*Hg(Oczz*TEjbfNe
za5I`%Ha*BLuLKBOQF11g3~0X%6bUK!b9^k*@<dy1pKy~4)1{lZX@%iBQPXw1JTX%m
z&o?r==)~uk2b|ACsXTErr|z%EWxDbkPCowSn2#XMAVq#R8hlS3aAq!B`{~1+(VxYm
z^Uq5sY^cYh*u5{|Zy1F$(0iih6mlE3u}{QOv>p@L<s9;;izsvruA}BB4D<|=I!dz#
zp*Q5R)p;fuTk>TcGSc<9foJZaXfgR%K*WAj7=&s9IrZNvFWKA3Sizc*Maa{H<7%Re
zpAwlr{Q!3&6<W!f!s4l&(zSuutv%V1!DH4Iiy%8-!^!32<!I2eyftd@={i4^M%?Jh
z6s;dZ?S+9RwU?clM_g*i{P})BY1KCF-?es(XH3Ow_(|6d3rQHwQ4J7bf8p4tFF~&~
ze!XgH+^y2@Hd6CH9hm*8z`yzxIq;?g%Hk*s!;aY{YlUX^5q)S5-l)ms9^o6U=gH+)
z)=3WWvDR^dkr8}<M)-yc=2X@(A%y}^yia4>39<%efx4^ZpZH`UkOmZOFF<$&-CWz{
z4UNLN+E@M~U*EOgW`Xgp=$BR#B{+Tz=Pwk~A6QBn4&&qpBwd@XlWZ&v(vxzpnX}2w
zM0kd8L#bf(kkwf!M2@{ui);s??Xk8%x}wqzpk!)p9fh33QlNuMU8&!+pY8B&(?;#n
zSv7GbK(xm4qE&0pwj|Fs9B%F0w1YP1qD(L5X*yT<lqH3Qj5790>Ja1jm;%mzF~OE3
zJIWHnE5D#tqpPHybwp2XOk4RhbTR|G1Si+_ke9a>3hsKqwE3{<2<>o4&SO)!1#sq=
zW|9<o(GQDdJyK9W*XNSpD5)?7cEf-d*sa(VgY7x_d(v?=I}vRe1aqwO$Vj~mr7rTh
z5)r@iHb)2ar6)J^#r}-2c-Ud-J?)Oh!pRESP1t?j4owe}2jyj|sk8L1sWZnzTAax(
zJhWC6f)km&6~st8K_88ti__^OhV0k7{>MgD-a<I_?0bWZbyDpqHtH-DP6Op(#m!`h
zvk5(E#sN>dq)9(Q6N2n+5w%^Cm?L@il4Zx=&fBeq1{Q9kHZI=XM8ivlnOKzfwpn<K
zGo;iM?#mNITI!YHug~vlko9A&d}dw_f7E16L(k;N2>)2m@JVe(L!mD(V_Yh+rK_iM
zSt1Nl%SPMac|gS5Ot5cT7jvS?_~w>bqO^iJ!j7!yxsqi*ns-%YV}K=?fC>xf$ycIM
zR?tgb7+;vuT1wHIJkGvM>~V_MaGX29D#}z6ZK+F-FY2{|c&1#YUe7;yyb&C5tNrj1
ztq!m=L29C<vyg#HlK3Xlf++)C+??~07Lzo#CriVMdYn57&;JSD&^f4stRAqm8hZ1(
za-h^{O{{ZKHaZB{DVdO%`1q}~j?bBjrCMobIroyr|8^D3Xz;Ej(30T3s=#X{oRW*|
zkI{xMR%x!74T3hW!zO-d)z)!;zJ6VPY6Unnm}<Z4f(gjzjw)N50)nuu7K!y$wrKYH
zDo-mB+jmJpZKBu@uD$Z=gYK8c5(WSslR4;l=9i)D4FG1Yqw8XoUNYtSNf#a#NhuUM
zy*21G@T9sxfCF=QRv|$nTs|zlA$glEx}I@d4Tgz1Z7>ZVO=zI-5RDHquPRg!@FZfP
zP^ceEWjS4mU2R_^VZqU1sH2EEv9i{DOy;a*)vOZD4_62Y)YxlX{L@Z!6`Opb-9BH&
z%Ds)LW***El)<Wm!Iclu%RMMZ$)UyOcjH_Fr<aPG_O7NKjQW@CrS_VZKYOxm=OExt
zYe&8ZT=z~ln~Z7vz|oq16}wgR<Uq!JV>iSBZgzKXiUkJp@JvdX>=>4HRa~*vz>JS?
ztFs4yhMn9kQnk1k_vH)U;p5@d^@2+2B$0ArbWhP4l@ch_ql#8-O4^!7NvoNphuJ_j
zk>0GjVdzihnTw{;C<0`AhNF}_g>4nhaGpxBWbyk)e}a0k<U0h?i0dEibltvx#^&=x
zi808iX$zMbiYEAl>7uR%cB;G#P3S9jP>$gaA{Qr<|4gKEJEd8)wa~w`y-sOVq!>io
zfxUqs#v6cl*DMTk;P+e|2z$`Fv!lg^%?!TzPOiAU<OvH~4VwBUZ-M19q46hkV62Y8
zV5R)DwRpd~Si7BQEmzF*Wk!D)RH+s63{s3*0Y)%`aHo^Lr$wt_VKnY~sM3QIeQPa|
z%(SjGq4ifF=^Z<^!CRma;yYHu_MTQmdtuMZ^z+D0N4*|3i>E&0T8$mq831CtS+Xii
zlb$%w>PxvQKA6Je4}q}nYL?tZZKWOcmu30&Ybv5fkhe0|Q%W%H;<TI;>m!!A<20!%
zJ~vdc0Nj5P$HNm0k<7fOx*a&HYO;8_$2R+-#dkDv=|Vr>{9eT*iV3SgP_(wSCHb00
z+<+#B7D9jYArN0%U~-xiUfa@2hq#x8v}niJ?WKh#&~EGEh_iulkY>C=jExl<@?D`N
z>2#$EB_OC{N>%c1Q-^Y4O~vV^#VKCVN$$;fbwqR7T7aEU)3@qfPf_|kDaj(5{CR3*
z?w(OT4<YRszJd^mXtxjgb*CFa1bY1AKCp|L^`jvNxZhw_m;Xln=<@7TeY?+P7J>$P
zwEt{Jj3d<g)8$YjxxO$)=ToA?KY-}t{vsq}eW+7|+~x&y``AL;Sv~j*+%4y5WZ7$L
z%y`f#MUgFo)lJU&tVJsP&qGnuOt=`}KG-x$LIdRMWoMuD;|<8joQY-i@o=rC<vRgI
zY59SQQ1XC6ulO;wM$I~zCKaC(+_Vt7VQ$bg%-xF}N>2_%VGwVaAaEDEyMud}|A_KW
z)wei`{b$d`9#ti*>CDex`)puO_JJL0Y)qG1%c8VSBd<OpGWR=5#wRN@VCE(oa^hD4
zIM(|t7zhyxk9%?qoymo?4@TgZqD9eJ#`TycTG=XpE{RqQj*W{PoHb~t&gC@$D4-q8
zph}q@s40mZ11Rll9<76jRg)(>L}yo5a^Om2xC<xO{g8L3nHMper^*r#(dRXH4}Mch
zgaLexHbaZIIXC%T^>U+2hLSXr?In-zXRpl4k5+YO98!f7#n>5GU!*Wob6*d{i+j&d
zj&+kZ!Rpb1S21EbpCypNk)WH7VyAw20JE`^wf<#-ftcJ%$y2Su#4I%BB;yg8t9a+}
zhGz+HR#O(Xp*4E;5bq4N!IgZmxY`@}>L;dO<?<-gJ?9mDZ$|s<$Lw=`Vgys)z0*h|
z;`_iVCk{-b+S(viH4PuMQ{r&PqmikmH9Bq_%7%Ko2ZFv{OsOg9jDqM&QE}AGUe`Gs
zCR6By>c%uxcOOyL*w#If=bGn4PiWh{Rb_XKJ}7KOn|27PU`xu7+B@FY7<O~=<y`lm
zDX-J)e37V+HMXfFxbbMPDp$%Stqr;fK~GWIH)D8EslitvvVAGL5DYF%Fo97A+mlOf
z6#MzayEiBfiEI3!Rn*<>oTV;D7wlhtiesz*DJ=_J^?n)nvl=0UZc+biT}ivtB`!7~
z*iZf76O@>8A)SyqfSA(-A;tZmt{>lWuvQr){t6f7ER*Jefq=Z;(pj9VbYhR4N3n~t
z8zTV<C89fRNPv(BfXgFmv<J$6x6w?&GXJ8b7gkM{V17lN*ne@Sx=S9D!9yi#&H>su
zsP++y9N7<I^pRdNakB(-119$pCtRu!DQ%VeW%0;V?~TtD?#7hGxU@jR25>&%v%Pur
zH^MyeRS}9)1E>Tl&#x5s=s+}dm(}*13fT@~<<;t_-g2q23YgBrKe8B{-CAs}f`u8C
zHcmy|)vNMVJbTy>t_yRB2{PCCCh!Len&sV_j05+A+AcgC4)W=Mdb>$6B6SzIwHGFf
zSnvb(u?rXPa^}>ntJrss1YRCg#CnJcaiE^ALaU56K8`|axkV85oi+z+7Z=w)W$&>w
zgh4YwW4>>YZP7Vt_I-{Ho~NbOV$)>MMnqX2h`m(`%pv+W8xu+DNGp(|O>PUNiQRo$
zzxwU6AB*~Nw34&r<#w+JKSS|PkhAM4xS|6jeyY2Kv=N5us_cis>8^2ftax;4_diP=
zL(GUb<?I}=NHLcwN5v!o-7Mrl$-f3kWMjU#tVLM@+$)_<6AMYwc<AjBHAEYC7r2y)
zMow*8CpBF&vpO4WJ;d;vvb4F~pR6jS&+uwud(zrn3ouG}QZGl6rXTrx@V{DChTN@E
zIz0r|lCkI4mqVbf`KLsby=o{ll%L_&+&Sgr?gy8~-<xOvx~9l)Jf=TC1pm4pr`QyJ
z`5{zYeo&eCC+IQxy!4o<D}Iz;nm<?bN_ya;g)xc<JSzTj?i22+jlb-F54u=szY`Q|
zJ+r?BCjYmfOI2J@OzAIDzZ~s<L-(O)_&eQ)^_zwBe}?<~hcOr9Ke2uOHRh6}R{oB%
z{!ZdI{4etUH+BCzmimj|^UwLw|DGHDEhhSx+=%X<j^Q7<5ew`8<mA)g(fv2M5j`C}
z-QT!9|4D8X_njNPJq;U%5{ZKc&JNQx(WQHiO3^-25<uVm6w(h$?N#~ZeyLa|6ehFE
zN45HNnOyhV{I>zAK#~~AN73b#m-TknmltlfH`lbi)=|dtUIw$o#+VW>obV$+<mm4-
zAjqgW0O$!znKA&#sDK_FP-J-VUooOVDi|ezISY%jK3YC#K0-hwC@_MIFb#;npy)9l
zex$(E));u^cu$%IkjF26$bQ60z$yBsTRGJE!Nf`6D{-6<c$Da{#|WW5lTVOjIzQxi
z#qdJ>`DI7|gs%$#adOanfq6Zc4fy)v0T;XbS^&Dc<$du2$7n!C=p@Dfp~G3|LeZgj
zcsPJ{d5tE3eoB3!6?s`&Ve$M{)A8(X{^~0D64UpD7})tji}CybGQk6(A>QMGJW)Pj
zy{5K4#EXL8c{5)M2qHw}co5MNfam!{A&`lLaDX=!%yD)5;X)A$`5EH>d!w2N-Th4$
z@J~Q3O(VPaZMFO7h^j8c?=;Pt?e2Cjv@e|n?uixHKpwD+SexI7gYa}+-CtDibmJlW
zqC*HG5n#C$Ksuzz7Bm4jbm#@p0eJvG5MXnFF;g@VKJg<ALJ&PGqAWhd@_5_RrDfoF
z5?#Sw@OymV=iCLbcpP7nBtss+&q#TIz@Nklpzs0S@PWYa1=%sO;-3(S0Kf;t1`BfD
zd?*0CZxBC=fV_6RtyQ(NCEyfg6o8Ru#zc5DMSsdD%E5iXWf}tn0>znd<IwCWc++R~
zuuy={@k)<`%hnYeMMxW2YS;$I_SPdZz5IC9imp;sXog|Ljlz*;<>`0>-lP6H&E2yy
zW#WD!Sl<oJp(a=$m(*SI9J<PXuQrT4rv`1KHVR${XR$I$2cv!#wGghpW>|vtb}9Dg
zxqT@w9yFB-jJ99?(im-yV{CBm|CGxp-DJIve#}5eQ54>@$n*3#=QkC!P5-6(IS3(k
zBhM>5S5+?sBOv@dV84)=v4O`7a(#hnvtM}GUfX_nzz<BOyegz(2PHV8Sa9$6DWQ_9
z(P-~V<9h|grpoUW{B8h5GUnz<)Wf(tcl2X2af6i=3yl~}8B8yrk^J+W#QZx1D#cva
zp}iXnPEClV)x)(>3Lte5E}t=y9QM{IE_fX*Cw(dZ8Li)f%R=2Dk>~>TaR|AmCj09K
zW$SWv{UyI21iN$58_qs8OFPxw`o!0eKXCta*e}(_u@Q<1$e2xBEFQNu6*vYXjvHMu
zB`p9&Jn<n5hn9diJ4{CO&UUNDr`WjA`bj12S{_R+LXvP#PspH3Jd2QGdJCKSi>CaM
zB=WWcosXi6Fm(y)zVt*kc8G6^$2+{NK!Uv6>$WVKNsp~azpkckV^+_!?J(tBW>d)m
zdZ~8L$f+2jHY<l_#3KV95*H`Pu}B-^%I*j<gVrqqg}72%1}P8S0Vfg;f8V)>aa%X=
z50o>oeP6*O7mUymQ<UcH;BCe(B>%+5)@0nX(X^cxuu;Y+Qs<*bNPB}>_(6;cl69;Z
ztag4>Re4#@4Z+2(EQKYClX36VU8c9~u?MD*Cv6xtHu(aKe90!eT3G#{&MQ`2fyWtg
zy;RvlXRMT2;i6KLaM6U4C#-OE++?;Wtd-3uSSfP5^>}k;j@dO`dG1@s69-}#oj-I_
z{=j54YO|x2Fx^c!Tshc_^|)7OBYYEXmR%>+r>37%Vq#)5Lqj+zErSNC3K+<%$<o+v
z_5wAfax%HR)<&`v|5W{S=6rG=<e*n<>xA2AgrFydFpU)cLsQVHQ(Yj7rI+;&OZU52
zc6g6H^^Ib`#FzcCcj7E3CGF)VYsHsuft%Mef5j<CbMHs>^<hckUhH{ZFn$Kg+HLj*
zA^j~qZ8@KH4}jiz^9>HnS+cQayG9P*G<|PdWep=!^HWCO&=#m>v-~Mko6h#@YqT&V
zUydJFAMET;{gtAUJ%VWX@@S5%J$-3eK{aUT`(Vswv#qLqPsf8|lV!(JB@;!Xe(IS1
zeJIE{w~<#piPz`_3ScP%oCDU~<NaZRuB$NH9-7srX`tvIP?i{tMyuMd(&-#2HEd+Z
zBHA~ha!U7Yv7;P4bDJFZt(JpL5ry^4m%RgTT2QSu;Dv;nOAuYbLKvb;$0yYk3o)-0
zuN#Gig=Jl{@%6sJTY^hVBRIIq>ia#RtwxUgQ-hOPVW*EpXToHRnOpVbYgzP83h6cm
z?8n~N2(mL<IN@4a`^~p!txme>VBYz50<(&q9Vsa>vL+L1#|zl#U2H>MCav5bR14E7
zW4*TIh~ipQ<pRs;AgA0eiaAvsp$>Q1bQDTvRH|l~{gQuPob5giu_4V$1#k&@Kbt}3
z{IH%Q>-rj?)=XCmVI1y%(S_D@tlqnwwIY`%HYP5rq?@Y?jltedB7iWbFsQ#Kio2YT
zL@N4P(cKnE>aUa(2s*b6*RJ7Z?Jk(F$w|KUcLG(i_XSbpA41HMh9_+J%cpmvMW=t6
z1H{+O{5D#%COai-Ex$2KM?$44vq0(DqHkSAC~XUv8n>2I30FYTNxri#RO2hHP2S=c
ze8yvqFQ-717EG-G8GYKayzUcj#o{a+?xRt3fU62pZq$~>u3!6xaSdnS)UvwAIytc@
z5snFbrD0Cb9afS^M3<y0<h<_QTA5EFG@33!a^<@eA74UtmU0i`A|G#Ho#77hBjw_r
zEr}5`lty!pZDz_AbtZ>3l5+yA&YH9`USN`t-m6ZmSWf|rsanug`hPmnl+Y_K?owtk
z>V9qU9XoVOLu}BP42Xb&jz1P+z(SQ`JJJOlaEu?1z#u$vk)V5~Q|i|+Ofe1d2pNwF
zI{DPB0)f{^d&LqbbK~BV+)1`)$#o!l54TC=9gZIUI79T3qe_t5WnM5L!KqqOOw}O}
zC=27lZtK(rwrn{%xPC-0WAY@7-!2(pu=hl>^A=J`qB!wEU8+9hcyUkN+Vo*pd!Z|)
zKJE0niXJ@BO!RW`=<F789O(8yf_T7?=3y00w#`ZYCYdHojZ7D0G~sDd>`x4bwW+r8
z1x^N&1E0Ah(;NQAjz@K<{52?vbPl;qWEJaxOMsG>B5x^?5S*curd)|i&jbnyAM8v6
z3CTpvY1nd->7AjZd?ATPl$23|i*)tAs|=AU-+;)kC**Z!HLS~W5(<lv-ckBPFEnc5
zas5SH5{oUaQdz!GGpdsH6xohr{Y;Nt>K9(TgNhhl%vQQMzQqH&f3B5Cb^MfS;D%X|
zljl}OQcRjInr63ozLkgCA_t`5IwJ1*`CPlJE126V6}L!gqZBlwVK{~-YX9Q0=b7E4
zU@Xt6VJpz&TuO^vuUhDm-HlepZ(9~d6Np^Ot!Av;_(lDwB(+Gq<&L@bX><D(8Pbj8
z_jd{507K{i{g4K>F$iZnck~Gf@3H2`mk*A4UK#iZuH`y-*Dq*me|8emo2vRRu`#Nv
zwF&HchcB~KSN0>Xf-RA$^|BI?UnM|xtEwR!3_CXt^z`A)RVfE2ONsi;%*lgErpfiK
z7*>47bW7%#@A$ERlz_bx*!CcqNbX0}oALd{_3U?L5t`_V)giQb&A3k8DRbtEv7C1W
z+~jcNw+fd2_GzOQC}^8paU;gwLJD$3L;G7V?0dfm9p-(@^K?c<4obJlmpX69y|aTI
zf*6`=*cQHJ+sNir0z&i46F;0IBsMS8S+OA-g`*$KM~_#8JD!u1Mk1Z#4cq)*f$T%v
zbJW_zn6t9ODqdJtPRP7f>auLQo}gBVptp*`J!4Up`<k6;)`$J&^?j$QejT8nWye`o
zk57sS6TMjSr==1Fr&8=OigKjc{|H=%(5Q(+>mal9r1f8WbIfjw!wTT8I{0`@!!<wq
zJPl|dn{ODCc?Z|t?2_{ZmmBK4e~^tm#GnOpPiZVfobt+Cf*f0(>bWGE3pjR`5u&%Z
zNBZ!ih8qjOO3GYuOMP>!vC~V-#_8B5&8EM4Pgk;BGjY15u;b0(7z!J^Vg1brrwN0a
zcqkILYHDN4{c(LNfum3Z7{C8@5P+RW4w>mhd;5NzARtywh|tX)VnSWN!&RbpH4%t@
zi-wIQvh{7?yomt`->!vPcbsioRdSkR+tzvw`$T~`!3s_9gJk+KYm_PG*@p|uakoti
zfi^VZ%|)ry2RG__C;E^P-Qm<=sIBz#E+YQtSnRtO+L}t7xYdWl1x%MKRqwQsCk@-X
z5YAIi2b720J@n|W9DVC|dr#R1fxc^IUluF471q);sC+wO3!L?8!$}!|>9&HgkjZde
zhBIK5UDD-1FMGRpZU6{E&wtY#eqWIPKQxC@VhU=1YYv(JJ^GdYZ|GN=Z+{yj9y7y#
zJ_GUH1O8iw8{>Bm`9BqI^xtZ?|1|?4`d4fCH$9u_-&AaWZwVd$d3J#Hua@s$dceP2
zYX4}3|Iq_7vwZ*VKV}DL8EOCR>;N4N<KNk>|6vc9V2(M=j!ySYKIOy7rI@@8nUx`q
zAT+h15dFz`=qdzPPb2ggl8}OG0E3{FI73%RB8H8<FOg!<up^=>B&i0`$^US2=k)2x
zJ^eBK(Oz}dRdsdOZv8`(8Lk3m;3gQG#R3O)z&8mXb@v1q5ddBoZzT@~dPE~-h@ZuR
z9Rscjm<Mqb*~aI?5OcMTfmqE?paGEQ5LnnQ)~A!BC&q$7-2iZ<Mu&>8xE2sHvKh^2
z)NRI8qQ{?KSV!wOY>h4*;L|Ent`9pFr2SJbJS>bKK){Tv4>y)i&Fr%(5iyhh4;2q6
ze%)Sfxi=lF5@<-8jD7|ngBbYW$p~P)6yKqC8-sbBpW|OY&Xx~hbtQ_RA{p1crb@jJ
zOeq3>zI6KaL&EO$YWVc|>QKEc%UM5TVu1w3&@5G}65~XM&RDJhN}%`n8L{}SHnSj}
z`Uv#IVD{x-fuJ)Ok#L{|ug+Beru#Z%x%O_6$sm0s+OBq@IuYVu;g}xLLC1Tq$eQ1g
zrlb!I7XWAnr%UEl%{_ms&HtpE$dWwb0cQuGVI&4(ph`v!P2wa-r31_31<>WU0R|8r
z3Atfm3MOU;8p#L+LC2zUd(`3u0_@?huf0M9zP^?w%^#{i+VA$BT}nbihy)2e1FR@*
zwIDJP0u~XFJO5Ic>u=FWnM`*VrYrU`0VSYE3;LzQrnWJdtBwsl(dBf!;q?|5d?YKB
ztJZn|hPyxvVOMFBKV69$-onTy?XuY77Uza1S4(0((TWI1JMl)dY@v54?7kD<ws=)e
zMN2kyC*#JC`|uF|cIF_Tk5RreLS8!+zJn3Z%;|>f_OzH^)(qp1YD}X~3VDR%EZMz|
zi@dx<tTgI-4_ZI7Fz>id_veDYlUR+IFe(Evs^z@;pvx7P!Dt|5$QYYfTG3v#w3zfZ
z+KyS06e)rL{ln7aS|KLNMHt_7d^y}t*{rSQ&{NZ@b(5+L_22;C8O;>T2{?~|BI-;m
z#GsH*RNFqV7!OO>Qq+Z{&E|_!E5=qUw?MbtC^@g-3tpshI@?N<l$v{iRX}Ckh}Bg?
zaDat<p^gR^(M^*!6FHUeIw~woomsv4^ch4)0x=22aT=bepuJ$6OT#nA*GXy2t@1e4
zG`#wu4A%-Cjf6$UF7MJ&g<&e2qaZKp?v;IwAa|e@q1jZYHM!;0GI!ojfB(#DoRHtv
z*qTCAOrvP~kD2Y$f&f#}liaRL45p(xp?A5VarDxuI=Cfw+mZj#sqG#rw-~0OUfGAu
z&-_CueoVod;u0sukI<+!_@#wcRm7+c`lVGY=Od=(M_2o2(b?-h*TbNpag_auRrb3<
zl+9yzqoK=CYNv#1QD^U~Qbn*<ZBh>b)oHoj0^D)yY8ClZ7D(jX%l6W2UnY~BiV{aV
z*fCmlhw3P1Ocz*c*`F(cmL}t&)9gzeiA9ecG7mAH64!y@>%znf_oU6^rvh3Z3QXv5
zX6;a$R7?YTdpXX75al!a%(k<N%9%zDUn$etX0huF&ikkNRNRzk6%ekx)l&sq{^JW0
zxWDLRTw*Q=O&;FC@64IY&;{#af(^=uRq$Pnhqcq@{fN8#p(4x7=sJE6b%u7$85CK;
z><!(e|86c<23BPew0&PCa$Pu(;jHlQTW2iN)?mC@y-htsWFjMuEnf=+8f}rLB@$h;
zP)6;vXEWurKCQ$to8EPeB>ed$5h(4wn;vmdDiwJGaqGnMqQVWEzi)8g*hu1>MX|~)
z7b$86Ji1OxcK5TYu==iR3(9o(K2s}g`dRqdNd0-~36zLjdf#4CmJLIs_G>quIBdkZ
zT7OYceQhMNEis8yis<!mknNNF@);Ligz~OJn=40rSk!EGD>d5;%p(|roeX9fXUnE%
z0aj|eb#iM$oV`A}`l2OgZkt#l9uM;N@^1W?VP#M&)@)iqy&3TdCB#!^8<S!w7_}-a
ze@%<doGX4C1pADo2Zd`hzvxUw?X^G)9jL6WmCYG!X|*Um;xZ4eLs`z@{k#louG-|t
z7I`kFD#pr-RmAR3YBieR#aP?Q4RmyygYdSf`EL-4+mID`X-&QhrR~hSLsZv%wO9IP
ze_af5@?Sz)6-X>Ond#@lhgTUE2~r*l+&BA5ejPsE)h2GgHC*<ETIXzPCZ8RGawp>h
zR)8>15QRsQ4x^Q-9&rHfb~m>_51qLg&G+MHcX#<q`rlr%sSyZomdEGVD4!vWRGt<T
z=7#sjhvjLOt5k$r3o1TKOxgBWxE=yil9ZVBUir3bNKo5{G02Q{qc~;}z!KOT;ViMn
zMQlE#_jl5JNCYj~z9jZspB`hB8^>O3>8&gEboHA1ttKx(I(2z+OZq(6I_yzA%|FMI
z?q-Gc-;vku_us6bdShiAl(nF~MB8=wn67MRivdJ2Z;<DIm8eyj=@sW%``SHTHdw6b
zwy%)2X8Bb5k9pS**mZMaMOK?{ui%N2H)2$k?chF)iUdu7NeGS3kDH~<e(-hQHzqq^
zo;C>h8;|Q{Kb$SNaZj!$u%MzpWn`~-=U$F*F2*i{jHLDOJUpNnTPq-^84o-rqn@iT
zW-icw=#{D~&`}<&=KTq84{jT-9NyzETJcqF{I$C`+R1EX1RfWiCRp9eJo)9>EK`*o
z*Qk5Y(bnsWj<jsQSJvemnW$CSl+IDQQ?EBBfkUHdJKsobEvM!hsy5%aDZNweI;O_Z
zIP=ooq<Zf3Z_2Iz7i+Gpl%%+%;CH#DAo|};ozgP>SHblyyJh<SGj&S&mn`@1-dv{d
zNc?}*T>mn6`WIl|>R&3X|F4{u_20^AS(*O1#G<2R`Jb-Zf1b~zrKe+N{7(V-ZiWgO
z>vfcum%NzH&dEEMmoqF3mlzB!K|8&hlp-;}&dzY~zgc<@9=MLSCb^D2J@em$r_0nB
zjTI}a-R{vPC9BGMDXbvqz{LDBHd0qrS3m%+5*Zj*R{_o`EG!U378b5FeT^=g@Q6j}
zopS(uGPARP;9Z_W?(6{8)I-?V`fQ6V_&nhme`ho1n9cy3?yuc`E`YmHJj&`&^u#`K
zsqHW`2pRo-6M#8@bu}PuZ#4h|*jNCk-kCN(N`7qmRAupqqyBbs@+qtgWbeT;u{;YH
zcugi^B_@aWdD=D-hdcUmbOqAf?8yUg_=*#S0|;*bW@UW_pzu`^sTjkf!Gy0k_zJH0
zlA^l!vy)?S_^kZu?Rfh2Jc(tA?eR$rw10g52i5_E#FxUiO6m){?8kdE3t>)SW$>Q2
z`@zN}mIdWNW(BqnK$Ca6#b$wJr*BeO(<LesfU`2(PWJ>4@%Yygz~x3aa!r{@==g~^
z-RHE-*MS0Ky`$aoz3nIanfB~g-?=sV29C12wGSX>OZWK>&-Ix%_s<Ws)P(r&Tl1w+
zjGo@fA2jxkjCZ_1+PE~kpwG2GEHWv4w*YdORcOe=kw&mRfB`N=0eT?!!|s;_Tw4Gu
zcD++SBV7P05UoSddR{+aZU9vXx8b>c6i=-O#zA!wz4*@olv0@o0Cf^Q`7;2NTA6_l
z<vsXyxC;Mz@cMp8>_)&%k$!;j{kgCWpTfHbV+*LlxDDT;R>=%(wEX>rQ|9-l^KY2G
z)l}uHm_SDi_VqQ5jWv#q*Ea9#Q-e3j*dBi@HqW>HdJR*$@ohp{Qv*BG{ZrE?(@{2P
z?3HVN9$x}9*m>96e_DP$`QJDHsF>Qd9)KyT0bupP9qCTA`7pF~@R*;N0<}s#;KoZq
zd}f;LjtK{QR`q}aAa8Wb2OzJld+=cI{Yb{#|MMFCV+a1MIYOuVL3<qPc^bZ^qPeWK
zr@!XLwh55!;}?)c{RbGZ^vESHJO}8TH;>Jxb(m`p2phoW#^)a}=Mzh|^Bv-thsZFb
ziT(XQCZEe>^`F5&*Qf>{ou<IW0IYyte?XTH-VZ^G9hmGv*gl3=z8wt1ui5;2Kxli=
zU06BIv^Ku(hvz#taFgdc;p6I(-uQ4i>)P6Y)?=-obbcGYNr%>p_P1ZrH{7hNtKW01
zDFEy(r_4-NHS;hX#-B+)F0Z_|B%GXTj+-4ecE&a=HGIEXz;<9;+<iZ70W$jcF7o_d
zIC|Je7AJxBU#FS;gpXd}z?H5ZKv{c4JHG&XE4aRVb`YMsOhJurLE1jmd%rgO5fSmM
zxs9j*=)qieIx^087JE^zadlB~s&-^szs}fUJI24z)K~q`xZ#gs8hF&S093()RtuX2
z62Qbzq!fGTc*IniiO85AC%pJ!HO2fKNPf!N=&qQ|c$Q2I2(1Ti65qKI*o9x-D`O^e
zLD`DFb9~iZnYLx0tP2&mr<U&5A4%9^x<zcw(m8*mW6BvC={ImFR+n%edF-%gCrZiP
zp}k|U3RL?V%Udg<!&O%~6!|L|xcq=2Ze<%XPQE3n8gZnKSTIO=7@gs17YV42C`ZeY
zf~yGT3!o;YCW3!LwV}mj`E8f1Mtl+Qi#~PxrV>+3ZM%9H0|5vRL%dD3bh6&ejowV}
za4j>5-AcKwxQTJ?%-s|3Fv|&k^5@X@2Zlm{fA+5PJgaYYf{<b`D{72crCeW)vwszA
zB8>4KNn+cOG|HqLD<ECaDO%xt5~J>GR~(5%Kpc~PL%^PQ+G*X#j2Q?z%G&FcLL*h8
z9qDTMJEr8ec2_jrOB8yYJl_#WdD30m8wtc86ni>sVbed&_Pp9xmnfQ_v=3Cw55GvY
zr13V<ou^<@13Z16W3k0n+CVCW)My<B@%tX(>9w~Qe!Tcv21#4NE4r3Ji*u<(qUAB_
zp^+I4MsTdxAz9IelF#Mi4NWL1YFKme{OMUl*Sj%hCFyU!!>*=ZuA>1Odn@3~#wB}_
zPT<N<aV-GVJP2Sv*5FI>p^_USg>p|RrrnocxVno{I*Ni(@Q`yr&KEu+2o^SchiH)E
z9Eaw$-0Iw_DX+K%j2_GhTmwJS$3Yp142T_8)A5;%rao5@W#d3fM4=tzR9tY#Z4$EE
z=899y!d@{V_~3xB4#O$T85v|enm|YWY@E0t>aN=j*WU_fCFZ7<Gs&rEUVIOr5C>Q}
z$We*(PRkbT@3c0SC%yY)yn1@RN`>!eJ>iWAKNL)$QV<7;Q^A8x<8~ya^bQnu!Bi-O
zk)J4cEF^*}D>4B~*<>dfuD~rz^SByC^Pten7{xN}IdTWx{r&@mrQoU%XEg-0W>ZFK
zuJ@I3kW{=xc4tDRY;+$;_!2a8gh{k{feEkVp|m43_HLO@u#6)c%J{g#u;D$>RCjX*
z#aao0dT*-wS8JG4blUvq!$qMLrYgR!om$1t7!%@TZH#m;7DZy!`hrN-2)}tX7X<XC
zr!ofVXf_NAX6Y%O#)+hxB){Hii{z3*jhB&UQemv$;xp@>9TnD-XBvL132M(nM6=(=
zqCF`S>MW&%o2hLwOE(24HPk0F@fCGKRCb_N0w|5YDt5UN(m=p2uCf|&996cA8Mbl}
zUEC3G)qN<_l?jbh;FHpawaYmQn&JRq|I*MpVSUz5r<j?u>qH?dF7Ru_<<Ht*-}QA0
zp0|Qy2R<~1+@BN7^e;i?T}h7gq=L)G{J`{><6}2&0jwlNHpND0m%4HMr%Hk};ewO1
zpgYPBW}NdL8N=gW(!_%lYN&3tB{??FY;Sr$4-2^&t){U7NopQP0ci7sF-J1>$u~GF
zCto_!w)n*tkF4Sd(^G%--M7rmAbf=6$mP;@0O0#pf0AE>9L+%+!U4gr6^%wBk0E!U
zIEMS9QDzR+@TQz2o}JUhQgs6g;}?Nr&+@j-Vv*GK@uq;vlXV&)iX{%hPT|?xq*l*J
z`teV70U4|iglP<87>1a*qgu2Py(1CA^a~$588p5icg1W3N<jT6tnBmPGh!B!m;-vP
zLoX(Rp{M<`UK=k@c(7S)A>_r}wX5;O?>K!(I_)_ub2=!^BuQiXi11Wt(=n0-Hu^Zr
z)^Wrp$<s*585*x{TWr(CgbEBS(O@otvoVHbKgE9qu>1Na7(&z!0eL$xl(m&fB@ii_
ze<`&li&fRQc9UB`lvsFR5T)KOPel(0IWc3m;8z%T8<3P`7X#GAGi~s$6^Y|G)iX!Z
zP6vEhdV614q3L7MO4jz7@C`1-1aacd@b~76Ip#K$e^<AcS-IN@x)wgAoCu`Zw$9Rz
z=LQyzE}2Oy#DK>;w(cyH2ADU57QJFO+Enba>2_(Blw!uVgG{seoV?dZ%SeUwSDM|{
zv}Ea$pONgpC-g38n4}MXo2cXXlxRzsOGqd@%PV&t<WtnnFn;q@A}oPY3EtmU7r(P%
zM^J9;leiuo99%T1L|UL7-H>Eucx<NyA}qRgg_qbJA`btyYqj0+capXUarGpsicR*2
z;Pax&IgLl&(ZIV^bv3<2hx0Q?;f}emiG8Uw87+EPZl^<`Cjv{$QK@Bmma~!+P3zrv
zy-<`NUKAweC}~(f4D{!&i5tPoTUfyUNMM7^5X@Ac+Z@})(L*r}&;Qm!Ky4A$aLoM>
zGlG?pK2RPaJMHf01Yv$B(cwYYx1p~BC{wwHYyHAUhU9Y&p3k&Infm!#aY<m?z;FE$
zQvst2&v8WO^+PK!w%!EN4Oiuq*N3DTTruP-2Kmeurucq+LMB=Gz@JaND<$A%nd#WE
z$Ze_DPx>vEi^&4JZLOPXT>CaL#yMhkf0P>zdzv9<%QYmpe4#oa=6=^G{a^xeYKEtF
z0RXJ3sb$c)9YSBN0X({u)iDtJ0F`T|kbXnWEh3u?$xPa%8IM7b%$79kLR+j$qe`qf
zMUZ?a{-?T97!ryY;S$rUqwRVQ(Mkj>hhU%%@^)*gSSPW7gbZ|h2ON(52r9ee;3Qcx
z>M*bLEC@q3U8(yLc<$VvWz9<t+`|`-1o$SYFOTrJ<`P8uAJEn%_X9DbxMo|{d+^n7
zmNA5n@mvAE$lG4@U@P<n)5N%bE#mOj^+iEu7d7y`O|@o%wFoWzVeHDFW^ErTdQMo3
z`E+24!)%(s3=pN^*YC13^N1eGg$1%$q9<bvvX$i6Fuc5<m~L*F#r-_#956xW@Ml=Y
z03dT-`p<gZfsWAP3xIbZYQ)AEc}%rrM+_(VuA{$KrFdy`y>dL38$l6gQgdjsSv>^>
z@|u<p5ZDX4z~Irj1e@|Qa>ZW#Bj)>eF~6rX*puZs<><9h22>&W-NfUve|C7R`<~S!
zI`Y$}mTeydrA^$e3r8gam=nn(gzT1z&Q1@bk5*brl_&0+z!;Cn!hMEiDf{!X@rP&G
znh`&RSil39;lBNTTo$jGtm$SYzb&sfopT6)KNlf9zG&uUa^Vdl<6@0DuLqU{>`PGv
zqO0v1r$wSvkBxh6k~IU~J91~wMN!sIA;G=4j3%epH$`@Imy8QT6(6RBajM>!U3s-1
z6;Qi!gfg0-^^T@$r&UzJN!<ptbjL}K4X(KqxUb`mHo(WBC|B0vcpU@ZXK$(54u5{Q
zOmcRn92B_=icUD;H~Gc1*tNltEhq!3rR9B=DqDo@iZ1G3*vvR4U9+Y0;wp(&|0TfA
z7xdQe`D01^L^y5dU|OUF1ua-Y%Mm;~fdo>y+AwR(FbaYHhI)~?T%g7gix77^7t-KK
zx4i)3;N$!Jk8lY<I<JItj_PNvpZ9VL^Z|ug@0dRpcG;qM05&s!`D;Q+#C&9^X_kl*
zjxFkg@9Ldo9+{-6W(IspB#hyu4<cf8okzaGb@GPfsi>d6gX*#+CU#UOb#Q8~ELOTM
zbn7CwTgqAJ8KaC}<nQSIVJGb9{+um`b;&D}9^*CS<B;ROL4u$Rw6Nn^gHYDq?0o@w
zLO&aC!Y?%ZTw^JvhKe2k5_?pAiqkr)@gmVM&rWOMdIuE>En#dEPt@wBtt&ge$qVc+
zh)-1gkcg;R&PAa`<+>E-p!Y#d;(K6*Yc`p|%}^oC>ZGxcM?k8rWI0?INfAxQ42ROX
z5b~=OGgj^5@QoP$!%B+bYD79FC`tdwZ8*<l2mwnA9I78UW7K>TgY+C<hGLJ^yxMO*
zg}TW>dt0V=RmdKDVI`~XOi2ifXyYnl;L4)FXhXf~eo4OARy?rmu(|#+3g-h#z!D=7
zQP@X2oAPU*TLd9VeKyU%ufFMHvn%nao-2}j*;!~tivUbFa=wl|f7K|-3whJ+x^iS5
zN5=goVC7&=&|ykLYBtfgJU><a_vZWuQGcG`+ep6~+}%2NL$i$--0A6rr(~qA|E-rE
zWH~CXw>eR6qA6Y}+rx>nSZ%4|AyxGw%c{+NK$!>7V>`*=V=@-bk(taR7@7SIzj!b2
zJJyYap>E}JGLe9!7;5<;^rHQ=vge!yKCo%Bg?EJQ>(wr7RtXAuK0z0!R<Er6hkm-(
zuLMl{;r+;IidhQR3sdCQ<|~vfS-aE4W^Kl;_yeblWP%Y2csy`2umH6jFCSq$vugdh
z_H8Q#m3M*zo!pp-*c%Dw(OH6;2bVeuL4?v8lLy=F*tI;Uwdf98+Fr01QnTw{3_DJG
z7K!UCJT9c-Rn#OJ9s=VF$H&gK?|)V{)mTU7-e*luuf<wlHgJw4D45$F<@G(?M2<j|
zp7gsxDhq@jGvD!}941CE90qZ3L?3`gcs4k2D)6w@DlVR|ewRBE>*3dSEtf|*o;$Xr
zzq0YJyjQa)AGlsK<S~YAqiMDJA>e8%c+!u@O=VlLErWtP<D!@2$t{aBEpSc_&j9-S
zVJ&2b%on@DRZUtcpD`JZNhvKVyzV6rP%dTq#emu_&^8QTCzCBAy$Y3~Kq4o{sJ^CJ
z-oxAu)81QYz6Dwk<Jv-FJrrX)L&0KoMX(2<$nH>l_J#}xN`DAc*bE~aDJBuu!kATQ
zxxtS6-af{IOj_I0K$!72(X$vJnN_1!$__*6&F@4Hu8(ilaQ~VvRRjJC^)eg1m$KX;
ze<mypr;2U6D$$g(qpI1y)rb8FoA%VfW@quc3ceM@-1(dB{>AP-BpQ1q8zZfi^SesG
zPr6gV5yuaC&7^Kn)uSxi`wpDedx+Q}G6mB-?e2XG$7oRTvY-xbrYm^e2v*PceV7*f
z_sG==MxoLxY{6ofB|d6%FdZn^qw~V>ZVg$T3s6z)w9&iJTRf+lL{La7`(j!ObI$IA
zKglMydglNh+_J_<?(HwS^*BQFG%$2F{A)zJcB+bKyjk24{4)YYMDrGjoBADG#k3$b
z%lf{vVE9awvz1J{aIAHMLmFHL#4p(fUUS+TBv#Q~LRo{~JT`|K9jd`P$Rov|5ZQ*r
zr!Vvbg~l|J^57Y?e=;d)0^1dpLz~3++$EaEwati#*Qh;ci+C6jo#%=ucvdo3<~)2*
z#00J}?1EedRq%8YZKuaL=QzXgrPE$Do-YuD6q1VZ9%bmeH{GHFP@>IpT%6I1*hHA0
z%#+uQyAf{+Bt=8llpO1QaLu>RflaHV=tv(hrmkTlJAOZyqYfUfOTGiAJ8U&O4MmTU
zOpSV-4MkiJVv@^7vU$led|&igt00R-Wq-o6yBc;jg2bJlhz?FxvFF^{2(>j#{-I6U
zC*?`eGCs^R6F^L2-QdEK=j`%?Bz)-v%)~q)u7*5gMb+rCNuPL<kc(ho72&;FFEZMQ
z4776a#c@sC_h}gG?YR&wk!u0ZEgtSqmE4H3*F{Qlc!Iwv<9*}^yC_Hhh6Rm#25X5T
z_>-%u-p?PzeSQ$kX4S(gfTl;VMjm>4FDEveT<emnTeZVhs>(((s?WX{tpPw2Wy^Fu
zxHvoHq*f!k`c>c2L6!18`J+$X{L&E4jht!Z&Ml6TBm`n_##T6di#TybP$lplOi&1`
zHi7iL%=l?;*20ATJ0^hR{&@Vk1BDV9PVn*u{1@6Loe2wyk$vBxCbT)*+;+3ca71&V
zutaL-d?6__ao7;|doNY#E5FF`m|v23K~}PC_)J6f<XzN9L|{du=h=FF4C$a>kUNvG
za2OjhsYJ4vo?dIp>eY|Ibx}lwa??Hx0}P*OAv)ZX>|TqIXjEpFUg)N_{x?O%&`9Et
z>tx~6cD#|h`{6qDSK{Hf%6U>HJ^E)2`NB!ZY!B>elF@NMTJ2nG^eX1PO7Q+qbLeE_
zO922_s5pkxuAbrGPzR*@4SB+V)dk(q<lli!uG5oavhUR-p0#{FQUTX#V(V02&Sij*
zFGZLBe{AS9dS1&+Nsh69@g!voKYWB~C<shP)(_n=m}ThpM3Jnir5~}sab5MR9c*RA
zOU^ss!&pvF>w4(6bS4{)xoDW37$^^2iayjcc+yrI#PSVL=$>1+2hmmcv2`j>)r$+D
zOuUWG=KtthwLNEPsaA@lzT}c+GbI;L6bv}d)NT~4smgaH=RWL#t$WwAnb!J5q#_$8
zcNCN)Fk!R(-TP)S_^cW6l@$3A<eQaQ({VtnLB0(2QqFONDj_te3%5mG1kA?9+iI}4
zpUT|>B**b(l(sf*u$67qmLHk+_=44l=82XVbE94y*0_4ow9VLJWx>Q5^g4^jhiKxD
zNB|q=ZRxp$)8c=dZA<VKIF~~9xMp{H=P9*QB~bFmD}7~dvAo|Y>3rufu8KPSwp2^w
z-nRkAZ}t2$B9InYb<{-TXaKO=nOh1Z^cn2Z&t_aAKNh7)#Z@lILHrVs2y`1-p=mfV
zOqxcZZSewT@>D>%gFH(!*(l<rq#3q{l?}`<P_Ys($d_N_l%BvOtdph8UQm3b(I;!l
zEGxZ?y0u|kx#rxw{k*9B1c+{n22aO@(>qklqiUm>;ynO(C`w=cYUsusqT~569s>)F
z=NT?yMrw4bnRAlHo!>4;#G}&YHBY9e!@A)3+MmO;XO*g`*03Jhj7^V|U=t^pb5!a*
zrcpFWgLOvrtMjcX<LtI;nC}uC<d&b_>5Zo<S;%jV9gzMgJKo-y+6g&(r<;sBC({UV
zMO6hV@}UUAY@Nn{)wZ>B2X9WPO@3>VG9(_Ci=8bs-LuLyZANv;6_I%9ZcY18h;k%h
z&=+IteHL)L`ubk6^9}4pYWtUajc#Oj{r@QKEx@9Vmi}=NL<B)Pq?S%$19q2??(URW
zy1QEh>6B1u3`#(dk_HLsmPQaHrMvXE=zH%~xc7bU|M{cO<L-FQnK?6a<{akxJ)e05
zcqC0n;lmK?Vt<AY^L>C=G-9C;Q~PM`%XoK#3}<z0{tVF}t!j57-qY$%Sf7f$XwIwh
zMS5n9?E&T8V&|lr`(d~waTB{1kwHfvs4_f*>EBmW>6CBYVR#~|Y479mU>tv>6bOr<
zdAU2i{kCYu%4p=Xie0N~q+rA?b#^K9JGNst)!HbE*eVa8jFlpUCx}H$VO&tdRLXt4
zFN`hE49Y#;y4E%6ycg5ye@Bdg&rQ^AR|!{REVNT0cxL%cVTFb1Ra$?Ei)i2aq(xbp
zH%Wk<1lyRlhRf4}eC4Brvq$Q_kzZ@`{SY};z7Z;eQO2HdV_nIL{n|r{g_!Yz%9<Vl
zt7L5pwa%q^l-j4{sm)GbWeywzw3~IrWCH3Bs=+i|YEArfi2Dwp!@~X>UU=5EqnV7u
zID=SNrx+se`w#JFDZ|jb#^_8iq+WSR%SZ0^%ff99{Fj3s-R+uwm#<!OTMe_8D<GK0
z-AKa*v6XPwE~|fl!k0B2`-@J%9f5r^#&rrt*{Z^rH_tt5vNC$L$%n*MV7~Ca0ivPB
z18x{$oH^pGQnFXLFDV8m+^Obm;>YD<P$I02-}L+=zdZRk4+YHJRpcUihtHtFJ*{#I
z(MD$aO;|S$(TSJOn#$o$EzORpTFz`SpL{k2d7Pb;Dqb+iHu2dh2P3lRX#)Mp#N3N8
zm!_84liF%$pOTCd+KKyV1Mx4T6LAtTX*62*zDe<VUswda8X!@kk1WJX*s`A~Bf5XC
zR=H_1G|H$Jdc&-$H-PCCg_2J|q2~k_3oGMSdD)Glgd+!h>$SKl9m(n;vrthn;FyhY
zlJP-+dYjk<pukZiI@_t?k<}ou*TCxe@cdT5n^KJ<WmZ`1O4U<UOz|AC(1av<d|A8u
zhB4!7Y2gmr#Ks3jnu2@rbGhaXtBCT=Btd_N$ont!PtsLlK0Du5ZKZqoBns*^)CNkn
zmKV=`quXH^-fA6|RqN@IzOFwXbeBJ(OV^uA<IUT?6;T&uTGz0rkDj8kKWvn@=<}SY
zDLn~J>6Oln%X|f(j%ip`I}7@*ATxG0h_^DhrSt(URD>qrLu|BX(gK3qLv5dMqrKE^
zb4~LN1NslZog;rO)POO5SBRPuGiA~UDZihm`+%={;NCK!8f#uL_Q$4YTivLuZ<^<t
z?oNFrCh}YV&J5{d@^=4ncZotB++j>CW}{oOp>;Pr5iV<YV+LT__PwIyqhR5qR1k%!
z0_-8Ja|m>}#agd>NPlE-A-($OBU$qCA?ebJp|Lu3Y-5=Q65B~Nb#4cIj!sp*Guq+`
zmd3|aNM{v0Y`){5xSpyq9A_ngK-(W1mO@!BlF%l`U{g~VeN6K7i19U>kiUk=`Iy53
zT6WnT8>s_H+}i@ljMNp>D3PVyDPM?gcobQW`G_e|I8RglP;)c$kPT<hBDUtxE0(3i
zX6<|$R@lz2Wgk4NXfP2($X>$(@<TP}T>D^ou6mIw5$!Xac8kJ^Ba(;eUXH5(#Y2xJ
zwF>u6n*<*_TqSNx6j+ds>5|gcM3CAysN=adi_iTaIU?T0wKWA(TV?N_pd8F;Kaic|
zX$_@1?UCS3JPG`C!IX|CjZup0;BkNCe$u-{=Wc;`KB*u}<`_SLDA6P-d6grk=N0_&
zp-}n2X%`-T|4EiJt(*k>XRWGB2%bzsAa6fieJLuP0bs?kUO)zYCLfL0zp8Eh!gXQ@
zE`2LVb-T7ntE8D^X=<V2<7m(G>X((nn=e=AF*eIv@zS=9x9)tMr!C=S^N|iYHLsSe
zzGr1=C0*I~6jAs*>FskLJ#;xYg~&0T#QJ&(3v{)3o3Up`lXqa!ZqHRP?#dG{>D;)t
z&l?T5zE!L(qRWbB52XqEi679;7b|@9nQpPW7pHSjW`B>aukFNLn&0VW?1@0fkdkO7
zG|kp^XO1ZRplA!Gflt}~^cERQrica)0}sYFF4ehvw;{*}x2;;kDgHx!!BXfT(|g8q
zCrxe@0><4JXm}5lg3}&ikVTReD`$Tu>bQ$W7}TR}%$1|2@Hj#*+HR<<jHokccRZEH
z84!&VAo_Cf@ZKybyWF=OpT4D!rwHcgv>fWXr%pmRTo&)&77O&~!q1JJ0wEHr*dG-8
zV)B*R1e#K~gql|3_ARD5zFUZFzk9{`e7xTc_T7h|ArVEt_^tA@MHJ{bvLsfW=XM6|
ztsRdb#WcQjrTIafXZbXiLLn`jAtmxTyQDT-vED_w?<Kk`su}Km9rT1dG>-YZi=a_E
zppf!Mo@dfK(+9I;<}f_F(RP4y(}GGXjEgXlZkQ@pO4=#&o>*l8t(fuXWW}ND#8U~6
zUG_D`hgyOn=yL9DlTD@l$|33aUVL<Svv<)Jh@2vVvrIe8aAbK&<fI#qT+2Mcwwb9h
z29o)ehgfsi<yuXiLpO8s&uE6SdUg%gsyb{$!3{R=Vn4(nd^z08-x_~d%O?%SZ4Ny;
z1epDh#4_`g!ftMU%gCbyS$yder{@{e>yb&JS|{Y#`iXdT`JM6NZrV+%Dg*L^kk!?E
zVMqBezUWN6+*F>TT$XhawTJcg7G~y6G^wc+8E)(%XXc-M+L~AZeKl;7<6LKyKM7e>
zWuQt8ue@9yGzAvNs+D~YChRW?qIuo$C?IT&Y+fuF*4kM+vc)bi#?2sP_PJ7Y8i;jo
zg-@TubM>ufVJiF{1e**fvn(pg;4$XwM5Q*zq$@2MsrmJxu3OaGBRnF4Y372;SKGup
zce~Zl^{5ORWI6}v8x)1)$Lf!k8<|)f%qlC?Fo&ms2K`J}TAUWc%xA)H8prI#*9tB0
zUn_~u7g8BakW=D@Ruh9X+WB`hYGR-h@@3(+90w~oD&KB|B`<b9E24H(ell8;SMO6N
zC8>>mP~BvG(X6OS2M4?nAK(^izCa&3Zm5o~soV3s>tOA*P1O~>ojJ6KO0}-hY25cU
zR)h14q01dgxQoYONS9{?k*MGp0<L~Lkxv47iH+<mQZnM19L;<#e9_BnX|xkzI7#IH
zu!9xTe3XQgza4QR5)dxF6lanpsoQj}^f5)UhIce6*5_$?3r`8dzQT=zJxY$wqV`Aa
z6L75lRuc@rRY<JuE=_AN9clPJ-=e|CgMc5wCx@$~M~tUd1!)<|Xm^#c^Sd6P0pF3e
zJq`^mEs}qq%&@B#LnO+o1f3A=dfz;9%If~5Fx_Qjoc2{h4o<Y*tdu-z*JvSEY#HRG
z0KQt&R(a}<wT1X0UpU`DTA#;~o9|$Y`64xq**ij~ZQnMxGJn6)M-h96W`l`6`C1(2
zx=*CS8e~fw^9w(cT8!(VwmrDlT9A~m1oxd3RobqRAXz8Vg#^G|fN#&=Bqo)dm<@mz
z?sX-7uJp+^q9#B!e9aZ%(kDdJIY}AvSm?vW+CAojO&;SU0Yl{L@1`-2ZY*r;8cnHd
zpX#7|B%n_BitaoguHn~=O2e+&!BQxFp`5=XbwQe*D>oM+%bU9CHa*~GI~UEsMAYU5
zp!hr<Z}Yq+(w<J4-1_d5+XYGO8WXIg#;o+>2`s@9q%E8f6x8;FTH=}9w)MzJZ5N#p
zw|)J|NhwNxKlk>OY7=>mTEH}$2=3GyTBEXeK3R*o&4#11A@UeS)%3-p{Oc<@mT0>z
zg9QWFbSGI~R#~0Si<qdfscIbY!FAprj(XTJKOXnRzVj#U@CwCDy}fMps@}{0wRNVG
zN@6IDX+*c0?8=JZYaa~V$=5!4&Lr;AY`O_PrrUQh8Z9A3mR(O*YL~vdI}=p8O@XG_
z@<qrEV^pZ!a^*<W=xzFv*!U(F=D%xVI5froSWLuy6gc4N*YdFYKy+AldhPh@`>~gb
z4x5QAbOK6_PlcP3=?uaqIKCx?ZC2eM{u$w3mhPUN(66Z@?fmncpHQ7ueD7Jpns7N~
zR{;Z?Z9k{j`+c4L^mc8$s>;2KQ6mkH9ElA=ivowRQe0AUKVT5ZA(Nfs<&O*7JdIeJ
zaP}oaU&kPbS492>ed|UQzhHH>iy~eaobkTEG3lEWj1J9Jmxr~CXe;C+@*5qVA)@RP
z&q#>W{R$s!Zkr}Eygi%D44qYr@O-kXK?~q6Ii=<_>GAdbHjt_xYl%A{K6X>Z;<bvT
zp>}%M_fwvmbTT@MqOOXr^QTR+FZFlLgI14r<i55dahuU?DELp+RknLVaO_RC*6jPZ
zM*Bs>Dw8NPEDGuwY6{o+o5Y5w6VpW8>3Z-KN=!Me3{^*rDceLh;T_I2M_(5gjp}FK
zQANrtd|#UJR`1G04_H|h6XmkKVXvxC@&E;rkMN5_7pw>M#CGV8?I2YMMuolmhU;sX
zaeIZ$W**m5zNMk%w8r%n^}`S3W<(Tu*)w`gmSAfOZ89C#pUUjIX|fYdFE{Vh;;*uE
zz=b2D`L*ahg30b>eY?pPOJ>aIpCrGiti+)#GSt}l@Lcy+NRt+`+dMwNl%dD#3HaQ;
zCkM#F+7Pjp3tneGOTd(};wOg5JNH;BIx~Lk`1WxBUjCz`)z4s*A=8ad`r}WS!4s!j
zB#N3=Z5fyy<u$_Csha$itFiRGBOEC1maRQ{N)SlD3o7MWp255_f${D^)*P7WYnXZw
zy+P;;m!DC3>x0!igzgW*hht7_lC{#T<DiQvB(wrDc9<t)<eQm#V2}dP5_k?qW7{{!
zpxMTnW-5jCC=Ky^Q9`~e&$rnFTd;Q$=}G+|Xqbv+a-j`ycNS2v{N5r;-SW2TY)~5A
zQ9wtRXz+m)`BI>(R8DAtwMN&y)lY5VCtd*u3EObYLxlVigmKjg$0DRHR9}gfA8{jE
zF<w*IHZU8t;;naDdQ_CXmZ9<FOZ4o4TywP`Vw#sMu4Auu^|GSn(<oz(h$VGqv4Ve2
zF86zOKX7_=OkQig@qMhUIIucbDfw;O$E48;6}28BqR$wyyD4sA%Y_&oe0c<}=oV}>
zoFx)0W}FEPGc<RKUL2#z;1zry6g*O^nn}?I`vO1oZ}jgXU)~<8tramL^ytiF27pPq
zv=An(iuO-vVyRmZ`a|r4w-JwjHWQMyj7Iy#25|XOiW{ZR)m%Whh9w<FZ<d(6F@~dl
zF7mUqaHShQg7!|ER#%j#n3;X*#wprwvtV46eneJ6=a*GN5Xog4e1hfAnvH|TS0d1~
zoFd+Y7H;GqqzGfMaV_gB_X&EmfpgpbMPge`u!O@vhf&qr7QEo8XC+vs5uZ1DyYXo4
zF}>STY}-DOrX@|I*$gjd+#T*g+m<3te1dh_JU(=*H*lP1YBdVuV+&8aDYZ9y`3r61
zNs$#|s<9Ara&h02)L_J@T>M<a2>`px>(#CLu(Csgj)|oP5}!#Hm#AL(kD`<OnRaHS
z99nK|Oy+0D=aLIJxQ%b@gflAh2HvW<&X(laSV|gnZ@xy5k5U(NlEpb)xcf>@<%T&}
z%EwJiZ);h2iFOfbt>yMpqC#)1faD<L#7(ufD87vRgKrKWYGvmikN6t5#p!67UK}@r
zdH3rZzPLcB*JL?$c}*G74{m&TU2Nx!y6#-Y;f57d>}+L3HY1%QW1c-guYUOXXgA@u
zbmY6z&m==bZq93j=ip6kwl7h-q)$d#BaGm#TV=*In^yP?=sUNtepE)9?e-;%a+^!*
zu{?+$n`Npiz(SAG$4q@i`%P`Hc$ldow|(ZuW54>L`X1jXd%Glay)8qt)_`#pAzD2$
zERW3B12&|^2C)VgHEd~_o(bLkKNrK;PQ@_&(iM#=gY~}O#3}LV0=eDYo!}-gil2!$
z5wnwuq<XOAA~HUqv9G|gw%wpX@zcP^dgv)+)kjD!2pS}YEVyU;owUE}{afPWcK#@y
z51Be6J6w#-^SU!aG>UFUXY^5Gno*Mc;Cv%`#5|(tLGMJE#cZkaYE4s>OgdlI*Powx
z%7MG1wHe;UM>T;?B|nU&Z?HoRIBE7aS533N|BxLaXW7ML8r1F=-u&o8Ufh&V7DOB<
zHJD{!U+dpqVFa#MGPm)xagVVLmEZ6b(;c&b@LLvl4S$kiM2x6Rx{&H5XuUjTix-t#
zbaH438K~ydBXd&?S14%>4Zfhp?059ecqN}bd2go(-+XpudoM}e{pBiuV!SxEX6B6y
znWt8jKMJ3gQL=?M9~j-V@p(OWq{%Cuq&DxSTpq<;^B_i^ZgCqpJ;pVWc_N@=EoG=b
z%A-o_!jex(9Iy2y;KMxz9PSZ-x0TQB9<QLH0FGot0AmrcBZGIA)1nlnMvVLyuO(i4
ze#cw4Q>9;)^nHK#ye;E>uy%;{JEi%E&r7YX%WH@4P{>t;KdR2w4KH%)Q7y*`(|%w*
z2o|ppC>><jTH=+!(9aR!oGstlT7Z{~<PN|C@@S$)n=6Y_Chq5Z<Xbe{<H3v4jvhD4
zC7Wf`VaDE0%upUxVAw&c40>`~<(*1`6GMTDe0r_M$CoFxvU?=MOG<QEwdPnSeVZ*k
z$X9;~TJl?1*JpVG16sldjA9uy?qo*olKQs}bcuht*l`xt|LNJy75^-iI%#V9M-jqa
zK&&Z+Qso3~R&A&>Rt;wlmK|^D(j%Zp9%dyr!I<kP0(v_wFMoqL%X&Bvw~^vUCvX1(
z-`S}xU%c(bS=k5Bd_Nk-hn3y(2lc7W<y*Jj>fn3a?K9z!VN|G}loowvsmYp|s7l+L
zWzyb0sa=qY?GN;SZb`!AFMr0`?R?=)T+BvbNT11)6QvU}Y4R!Jg5Qu>P_pg`YI)@|
z+r%4aWsIB5dk|EPyjyA>0DG30-6zamDw99R57}$akyZ7as^kmaDzLw4VF>9~Vv8=%
zK1FGYzFp)o@8(Sw1^qc4zL&jz)Vb-*^7e@Tj_Q!=55;Qx;yL389(e!z;psAk$Bxp;
z-pq9wTQGqYXBBF$p!X+vvs5B%^%rN~@^5W$fW6k&CD8n+Bkd)P*DNum;+{SC6}lIl
zgiZjGhiK8=Kot)m8;6ZRZI0+-IUO^%H!{EGkh;ymS<`^LA!pCMD;c1vovItU;~yN;
zEyDdR(wtA_cSx-LpL<3_v7)S)Rt=&A5d)wS9OAuEMSl74yT{_(_b54(ccr`*=`?RI
zlk=aBTPd;$+t=Ok!~W5^d6PhDyh5umvpRf%Z}v`AOrbZ^rleoz4&l+sgL{4Jt`Uu*
z)E1MWB^@V|x7m{`XaMioU{Ilc{^VzH=Z*#6#CBzxa66)%m6D=ULDl1_5VRE0WBr^0
zwVgw;a~=%$8L_vuXS2aKGV(GZ1j-!TGmD6nx-#V3oO-l*p%=`1;L7tQct-AcqJ2$M
z6brY0)tfP~F)dPKO!tHvM2J&#43ZsJdm<JxJFD;Ln-%8jxblepE}<Y*C-gPzcY8jT
zWrF8)UO#HXHFLt8H$F7LTixqNgw(QCv53a-IdvAYkg@lX>tnXY%nU;`X1<9{DH%pb
zt|yhDv;5Wzvj`ETgblWo!oKtfGn0d#?k6v1-HqV{mW42r!YP|`U!EVb)|ouPuU#5V
z+NJ$nsY0ZFcqYHj5~gc^{<8F7R)lFE`Gh*c>J86Ko`k>~D~-E}hmuIx>gMyHC$rn8
zy9>94$emS_4heAg&YE=n=awDgXp10v-$qeYwQS%NEbIOAnU;l*Gvj?9Q>{I*J!RVW
zoEjqdHZqAx&ACCJ`R46n`X|=hj&1FfTWp;k`p}$t4txEXbO5&~ebr%-#_hYs)E_Q}
z6ZAd1hhAx&CNF)f&401|`OGL9Bl`T|cegncGw)71z|X+4aX8&B6P1=^sN`cWujhcy
zoCaofV;2Wtk@ege*I-q))Q#-M{)s^~<=tjMQCz}ebsb#Ky&ZQ>^TdURrgG25G>D^3
zN4s^Z1wtQaC$k-!PFy%2Hl`oD=qQ>Ec=g4gK2|f|LEJoY_0v}6E0?auT>D^Xjgf0e
z)v)?PzA(dp`isB~6@nbZ!BS0vWoDSB(2Lq1eU-@@*mpkP3Xz>H#cyj51mhTM?taP9
zfupVIY`{E(-n5r;j+fspujW-hBS0TKgsXjOL0P$9Q$0bk%oz+FuxzHuI8tC_y_MNA
zQm$>>ed?Px0+8TBQ~2CcCFJ8kA9dt~fAkodqN!~ss~{>4?M~On$?<T0i&HCwtyar6
zTcv@Y@BrO@y2~#|{W-UeY|#tZVCT~yY`Q|JP#Wm%X^A@630n5tz2r`n9f_~)*{>mz
zjG21=RpN6Y49UskR=`p{6AIC~TO}#q<Yf6&m_%^j-ih6l+3J(-yC3QjRUz^y+nH8Z
zVlTA(Md*~Ou#)J&*jTVsu$z{#=5PhYIic-nH>3Kh=&6Jp<$F9reg)diyhy{efGCmO
zj)65hq3Cc?R{rt1?r!kZ8>Pa!Esl+L@?d(>J*fyyr#7K>W-L!A`%Q^_#^=;_pzj+a
z9hv2yG3)2NXxDR8gtgkGzl`I;ILWYc@w}Bk4+=d`T~Ga9)Rcw_v3{UwsPS1M;LAmy
z?W2s?_|3?Iez~OY8#Lw#PL6>Ix+B_AH3eNN7mQQ*F$AB`>hd$@m*tw*6a8O2&rUe$
zUA!-L<akf*r&F$MUAe6t*9Sr|3{ITnC%AkbG5JLTk~tS-HQ&h?Cy?jW@;p<lhnW#p
z?^}QzKa}n|F&<9HDCJw!?z6DQG(FjY_@d?*$V1&i9L{1hoj$y#!dmKtNEi4>IhVHB
zvVV$>eAqQ|`x*C7f#jZGOooiC9%a0`Dx;o6j(%xd8DPIzBZ2hlxpTfIlPjZ>1sPAu
znr@f?1+($o&L<uY2?P3z@ruE?xrM^>{q)yE67;M2?QF5LSeu_u$Qq(#bfA%{XXMV|
zw&||!O3KtQHkO0Pt@waq4Jod)wS3L}TnCBd(U592Tl^aD{^xAOCtWyc`^P2FJOSTa
z^$ye9kEtuRL6S*!nbVPOI&L?F;{7&p{Oo_cv&<(IAhOU9FG&r@BUq2z>7LtEwu7b9
zZ!khU;$L}1*BguxoaWL-7FG|+cqf~0y~pW{`m~iaAM5yr(6uw?gup#TDqDef+t_{B
zR$pYI;zfIrdf%!i;>gTJY6KfIVclE{%UEz6Yi-2))9PqMLkoA19NmfDth|NY7uga=
z5syXd2qES*HWwn(k8Shtvb~cXvAgF_-q9@);g&O?4@3iR2H9yRVk~LPec7XU$c<k#
zer%X&{@^wGx%m0hl)2Q#f+m*6j>65!cp3`yB;p9l^sjccZAoZ@%1Yhz{J0SlUk*8^
z%wGzX>2lF8ej{E0%=-#3tC|sVL9nAu;;4(qg=^~t6n#q6HD2c@%(NLv)t3+N$PoaF
zM=Ob}9<{0^d&T*TYwz7cmQSebI4%hY2rM2+mP)gwKVRO%i_rB1$GjI`NXJ+b`BuuO
z9VD8AT2h_xHGB_|&-jj}8V9_*DDvrp@{GrO-HCo7OeX)Tz-N(dp*)rgy)^}JuNv!>
zj655C1d2qR_t@6>Ts9M|zO;;0kaov*)!gK0<epOPPa!eTS?RyIGX?wO()Ry_U#6rX
zBBLvQd1p%fKi!$S#4m#&uct#m05}l%2TVWc@~#uYQTi87J^*_8Rou+Q#LV6m*#nG(
zL;JT^)c<RkerYZlF8OOv{hCOOGackrc7%(Gm6eH=vx%D>^0TX%vz3btmob+y!o<eK
z7U5#aW$cXnXy$5bX72ir&%aUiO^^s_wn*6h-#BTPSG3HW+z_^xK>t?mW?beDZq8g5
zTo%q|2;`{Oq5f^nTwJ*9kXPvK-Rz9boL#IekPvIXK-L_&91+fD_P;p(`t+NhBT_a8
zQ?CDn`u`jL{|~@_D^IT9Gx!s*&5g^=-W18r#KGC@U)cZG(Eop3C;RIL|7AIVt2g+0
zVgJ0d4+cQE!T-E$_UG*~ZXmKk!+(3bEZIvy{pV4K)%RB%GFY%PLCEK4BvBP_$<Gq3
z?mPi~eAaB*oqV58u8h$%yo^g`!t6-Ix9sU_(`Zvx-(0~j{ma88TaAq!7t4bEyjv~?
zM`<ow3s{*jaJ;5V(-(1@c_(qJygTYQ1J~*Clyy+p&=3S9PY4I3=`do4g$V}PP}FtE
zvGU^6khfY;G}Pm@l;gEb2{7h7J;107i}L8Lb6<sm5>a?y+^CO5zoPgt43ck1c0Lj{
zMkN%$dd!qyhQh-^QvG8gnAwqPBb>=Io67WAmU0v7W4ar#K}9l3!sAdn{WN4P)6?$n
z!p=XZzJ)M(s*0l;6UBc;k;p-#4rN5cwUlCdhnk^^t)Q~|lXmTBQI~<^Gs@~A{Y5|L
zMJ&zgljek<6puVynDGbEg=w||ndbcO@<{z;RHWGmr2TNQIm$>^N|t!9?{*{xAmBML
zLzj%E{4xHMFlUS~bYzqzk9IlMM|<rcL>!0{Rjg|ONj%>Y4&aN9BcsF@asSD@9=nox
z=OTr5gVx9w#U|_y`i<A<s>O|4wgK#K!o}vPfbcF!7M2^*H&A8FbKYWv5TO{d1UB<#
z`Jt5Gl>lmEgfgqfpd@A-qs4gM7>-50M{z^)2k=6I6lJ>?iTnQu#VFJe4=Zr6F$<Z{
zI=}f1<=rq>9!emn5x@vJBvr>~vj0hEw$pTM7?&_{L6fNU3eU`8yHWa47n)HEmo)3r
z3AU;tUVum!B;kjIjx1<b>HJG+e&K?j@9XTq^0#RMSpfFCENtw@KQn<u;ljcTVM2zO
zT`ND$rS6z14Or4}M_9R{#|DMe2;?=Wk!3yK>rm6ZZS9u(0{%FnJzJ}XcI#_?sh9qk
z0K=QE`-hRLyxOEzq$l-_nFmn?N07}?-MhPCa^!*!_sb0B>kq!ZZ8I+r^lH{OVm3W#
z?Ov-g)FjHoxs_XkO?cmB3Jjf0p`i%30tgN$rR7?e9TwQiVr!_E4al~=coLcv`6<28
zAKdm5C@SbXbY}Y1??va2IFuB}C%T<G{m0$}Xa2Zinl1A<abhLUFK9dP-5xY~ap{MC
zNU3-{c3Qje#J=U#a=Xo&GIl02x5bYXpIF40Wr`)ocoBlyRc4cdh4qtF2y8pTqxfJ^
zxq0>YP`Bz^7X^;%<9Rk~EXQw`xR*uK#;2Z(XRy8I)yQs}eXf*Wo5iAY#u4&tzRZab
zdwVBGPwndk$Svw96uSa**e6$@%6JIZv&SMHdnlHj_ZuI2+}@+b&>w~(w<`&zs}kJH
z?0B~{xV40m+!W#y?6|5Nv6j!?(;X5Kb6a$Mw~r#=&OFZ#E*&>7-6-{Bw+Pe;UbI`b
zdaWqLRovRIoKoNIEQQ)*<d0AZX;_H$J%c}7{hZ)XZyr7|vSsf{R_tf1p*_T^JX%6G
zk;`nm%dh=@!&~1u@WsuP85IB5Zi+c>dB!J|pIcw4GJBrxCEs${s8NWKP;u&OLn$nd
z$C#>ISxxqD=L^UFTKD3E0!*-D;Y*1njVrM1elC4gsJx+)M@(iV=J27a)fCG*f<~Yq
z4uOJm^Akq&>wW~jv!z=6R|mE@7xS~%<P;5++=G*S8GLG7+gd{kr#(!e<Ax7amp1DS
zjd$<kdr4&$C7+7=-htHmq{djVSBww|wiJE0HT+y*l496m@#B;81wek$%oDUpiQBs#
z)s(?j%>soEHsc@40H3yRX5{$LSPJZkHPI*nTveAfb;u}x=!W?HP&^Plv@dOM2=6zN
z@4wfYq#@6!C3YcOFt7Rc)kN!<UYFmujqTFdK1-7Ty*Me4V>Ezufxb+POq+lr8;@~C
zdsnQDP+QpS;UM|mxVseYQ|cek!}+L}19}g{76Py)p8`J^$P9m1r)hBb#7-`Gd&fcs
z=VXe@{|WjRU|?rGnIb`C3Qn1KS4PuCf~Fmnczw+7);ZZL4t4x(0epU~n7Qs8|7Uh=
z71SvijHUX$Q5XKUzTbGCcRXQb@j#;(I*UuKUvIWURa&3sAKy5Abj~7IB6s86*AZIA
zI~6q1E_?J_x-p3jpC1sntL&#N*#j~44EA+J3xprE{tV-7_O3pROzX225s<W6vm!s5
zDR5@ur>`-JzlSid6)3-nXnpAq?YnE5JeE$8idU=iX{NcnkiB6JFki+(o&`4NpLH{y
zOn`XSq#k~P%*6I;ui){XM-2*S%<loxbqdU1aqtSaPC9^(Wu+rP!z6u;mUu%-?(*-C
zUI%PNn=Gu6JoRhZC5s4H^`%=TPw9P5(!g0w_{`;nMVt`tz1IAM9BSVSI#g{!Qd?RU
zvM_g{uiq73e5~+UNc$+%15MGpN$N8lQ>v=%iR;5<h4o$yWZCOmRo|(y^pun;dR&4x
z_T(Y#g<+)IK!%BSk&@|j_LJpdCOoQoBeT_WnIHkuPc1KSiU}nSzMj*co{jV?Jy)dX
zoq#+VB2hV?IXKl}vY1*&ZH<b1yVY+3sTU%7-w=@Fz3&&zq3czL@6Ok2_Ql!z#CO3i
zciw@4LO)V}|NIj>F&gznXysX4@$0N9h1;8`vHiEamy8Zx9`|CrHzVz1JRV&)dq`Hn
z;cESa%IWQ(YvX(VEWOFR!XNJ{b4d9q%&T9$JBhgOl7>&6jo;)|6!_9Mkap%wlk;&T
z-b&6+;e*FaktLJfLGNW~cNtc5RwqFQ@r5f#a^D1%QPo&-+STaK+tD?WdPj%jU|&_C
zIUKVLy)vD0igOCHo3W($CW4t9hg*1->ys;H_|%-Q!X_yzqZc@8i^xeYaJo4<d%8`Q
z!jcR9er&CR?$eG=i6*=p?~!zWHlCxlgEl#cO1t+7+s#Gh+f#F=^!HyH>@}k}8IP+J
z!)buaJpdrV2aAKPBh2S68)-!!jGf!*?P<uqL+;+s_onw{6*JKvEL`sEw3t6Ok}Fnx
zjmo1mcFJ1JWqr%NXq1vb9o0((tt5gg`(}-{8%_DE_?v!#E*^dw+)&MfGlpkqB)|)E
zf&^~+k$tUu=)Tb|3pe$?3{DB#e$-Wm8hdzj7nQ$+uG>B??3Se$)x*T!RaZ)w=rm*Q
zCY5xd#26fsn&HY6$q6B_ekCA!Q~z=KOJnv(foW^9XCzizf<PZw-VB~!>;XLy>5bGc
zjJVHh?{)CpZ6W>4VM4c;TqQBvXLx^66Pp-+Wya;?y_!#ruJLx##lz0e=x*f$2X}m#
zG$zto1E<4^_Ch|3tz%24Jgl%1-efDsZOf`MyLj>5Ke1MujG%Z*P)JS824<F5Bc8i@
z0HTLaGpN;7J*xf$g<wq?m`D?BcDq-7n|<aDDQJE^Q<n2EpwiBwcX83ND*uC}AJm3`
z;(eakD56%KBH=;Ox8ZQ+E;(KJ{%W&a8(IhQ&DjZvZ4BThB~__P!NaExB-PN62BC1K
ze9=Xv?M98GJJTkwv(xhv4N1=34FV&!UAb(jnY{4o@v6E!YWQK1FK8YElk|yk?rD~u
z5~`r=PYS#c^gjVI17CIIWO_vqy5Bo5O%W8}-*@TErf8_2sXAjHJnK^H^BagvS;?hU
za<7h_xiGhw5G-rg48zWS&Yt(!Dg%x+{wO$mub2-qNZs+h_Ko&3y^NLnpe8hlGvt-g
z)0<R>F=1szXtgfn0^?{29~frX1m3-jWITPP$fbb#W$Ib@oe`1Jjr?HBUKC|u9u_{+
z%S9>=3`OGVJ$aYCLa&thQI;gOT1W+^8CkEi$gS@ZOZ1dlBA<=bmV619o7F{Qg$Je{
zQ7hBa+Yu-k>Y*|v{J?;4*YvyKQ8chZFU;>t$>|-UY1lCr7blx0_<lgQdDCJ-dT47y
zRbo8s3P*E#l(mKRLbLDIm+6GPZG|rUy7X_%Z|0c%7;X}t1-pgUeG<yMMISjf@#f_a
zr}0PaH{;2#qJ|%}ucq^5SC$)}5*93l-+dw6PSJ7{dK(~?Q?_qiq-SUL<D%a-O6ACb
zd(HY;oM1}a_Xp#or+cBznq5nzBO;GT=yz<3eaddKk#yP8uhj||G%Vd?FH9=1mv?q9
z<f@u^jDKoJ&qEU}2%{)V44W!v;R)gH9{0OL{;{s9J2qMAz7VC1_wh7}CKYey9KP0>
z)CPL=Czq-*R?e1^wjO;n&pWY^hmN#gd4_okmbP9~Idj^8XlivZC;5q7-N$+@3GWb?
ztk8nre{g6{(;9E+4+pB!ykn_*+?!O{RgkXWC~NQu-K^}WLrz}R4>tjUAG?r#SmXBg
zy{V98iI$$^$5vU%Jq(&zGB>JXqVF{^$CBoa4$}Os3jr~OO8%T928)aC?tRTX``#(b
zJ-L{o3u|4kezMm^Jvi(O-tacS67DLo<7>Q7|GJ4RVV&xxty0`4|Ednt@$Mc;Bh7}0
zMG<6Nhsy1zDko(V_WDY6iez(Fl01FB6^1x&?8B5Vw@s({C;2{Q%oW|=$l>d&FyWt#
zsGmM&(0S3rNRp}iQTFhun*F`>3wZ7%(4C99ki*+`%6`hu`}>N$Ny!tbsn9xMhI9&?
znbghotlS=|EUvP-MG=?RK6Qbf7X9H<1@TLR>FnEMso_+_v^kJGy+PcSY7X-X(*2f(
zHO2-F(ePfAg>k7)*JcyLJgHA|?x40U-<M^S7sY984~q1<IJ>~jjd|kB>F-M0vNwP)
zD`HZ4x*v!Zd9djc&^~r}6C#?-a9&p@uX(66_<Tm7oV)<EAiGQA!`}JMpXpm#eetYT
zH<P(FuIke}d1rnq=#8w6WDh8VkJ5`$7OU#AmIiEc?$>ZO2(wjW3XQ;thn7lo?NXOW
z-iHwo-5)Y;e6wSvbDqZO^Qd{v-(R2MwxIZlV;pDVgY3@fp12=O&&GSd>*wg-g!Nji
zb_rE=Kz8WZ$(`KU6qWi_d-)jO#Zt@Z@o79-z>GxG{KOL2mf_uX;3s}DZPL(f=oKoe
z;Ke7q*Bvvn0j<p&OVK?3R65vx(|y-H^keatJXwNRA}y1fF4lraW3aJL26ro#ob^cd
zj#&c`H*lt*9bfD#4hm^%uxLrL$mL(hDt$iDGPM3=ujpqOLuRWtgWL*|4LDkE4KE=~
z)hyQ_gEsx_+39<HcPfhC`v})}ND2fl$K9~9O?F-DE0rgsnpHv5$zM0cwgp6uK2e$0
zl^|o2Fgc8L_Ih$Fo>b!8RW$mYxo)w$IV1@^HHrs!^y_|V#51$D;S<;`FIY%1R4nRU
z<kv-)8@U(sVmq6gMe+~*EDs+01faVWYHWSNQJ*PQt3I)~iv*_vqA6y2DYY%@GxYRj
zc-X{RKsmS@P?bUh4q9W!2-3-B1*gurzjgM?N^QNTZdfYs3`H2<tIG~LAU9WM_KhD_
zDp&SjTW>#n;9bW9>GeK*v557t)-@&nMDfnxH_~Qwtq00y)K#C`$Qxd8N!=&k@A!Eu
zH@dU<-(;2kzm$JeRF>6|Q~I4%`VX-9m(?GU(D*!HZUB^*=l_3J35kgKA3%5z$h6R9
zmd6~K)v@|jtI>fAnX37nmH8hOL@uwtP<pP_Q2Zl_@~?~<5&+1}*wxF?4DhQSCNljc
zif}QLbU^06xU@u&^^z{@0*Gq=%BvxXm$@-#D@RucX8`;X)<_iz32Ei*;(7_uh|Izu
zF%^+{tY2S1VB}a@R;I3&E&$k7S^fkJ`tM{>64g=Fxh%$sl;zSIS7f<N7yc#7Wut$|
z0zyJp{*Ns1%gP9UW|#hbrtyE%%ay{QS46q=vA;z@D&k+F{Gk^3WmU^RMfvwYQU9AL
zS4ubhEy}MV5Pyln{hurZzlxgqCurt>XCWQAzkouoh;j)z`j;rM%i^8?be2C2^t<W5
zihuH468@3?`|o7AilTKzm}{O30$!#M|0NCb+do|Q(pCSo5$MlSr2m~XSM$?Xq`Bt1
zSJn~Ilm8*i@23A!&7X<U|4x>xQSFK>*PNFd`ln+4a9-H&rvH)!biL$=GQz^l1({!W
za6^U@<Uq=osbyCHQro}1LC(t51)%rK^#Gt>W(R<N=^Ft0H97$N`~Sed45t4_L0HIj
zEBu$teuW|cvbYD*tN`RAfnWdpCUXA@4FK+6_-21{<Gz&UZx8(MxN-k77yy}szGTDm
zn;Xw>ZqVOE=rwN8|AQNH;rx3=LVt6E{T>*0ZQ$Q}|6k^DY2M#9`DIL`etsDW@N536
z$UW|I8h<JV1ia++_lRN$SA?yD#ifu)>;Kc(e>e*8Qu+Vrr0ncq>Ski*3}A6IHCH#&
zz7OK$2694>TbbD9(+lKA!-Ay#<14b%usHIO27pDJ4-5o>km-F02n>XC!`XpgW+0Fm
z*-pX1^#5w2?u>ABG&2QoNg`}r%#f0*OK5XSy4l(qBkb)jMNzl3aseR!{uT+~=3-@U
z0kE|)c64xbv^8_)0BBx5G;y#8KsZ6%ARb=u|44lw%n1gtXqg#<#Q-o)9!@ALz{U}Q
z+yc!I0QY}(xupN$%bw0==2$?aq99nnfBpcVJUmG6Gza_-4a9xvOP4<Y`+w3Pm;U=V
z4G08XrNQAa;MKlxI1d!*hJW>i!@+Q*g|E=K!PjWKpzAa^=+a59^t~(>bcMzXzVxEM
z+5wTItMUQCJeOP2-|av=mz($BGzb)lI(?PKbLqE#w*$kj$pYj7g0HpX<^^6K4|W-V
z{vMA9`TXe`4Su<pue1YQE~UR|Fd+Eae4$9CUTp`x#Gk&>7Y;?DKVGHra9`Ck5C*z#
zb6&{hLF{i?kS4k|9xv>gZvf#i7&0>d)fWT;BcZ>q(m<f=Ja{i-(cgW+Fz{8qfWT1T
zbsi8T#^sg15FY4t8uw+8y}|>2O{d6ZbQy*JZilS2d({s>5a>1gf{+XH>fAucv;Q?6
za9^(6zj?rUxv%*j2nyx7>IWbw5BF6+0P%4Do3#bMt``{m+S&)fV3(Wi-}8mSF1Luk
zX>eZXRhdD^AaSiPjQ5(2z(C;TcKY{tyu6@mbK?bGTdQE?4sw+*7|44~=F4Dzl?U?i
z{55-k!JupQK=R<d$^*{J!+X`1U<ed^orc_DuFMUL{GIRWx&$Lle$^+zNZ+`sXD|eI
zEjEF9xUa=TFb~hQcn?PIGuOt0a$k!j$Z&eOE&pW?B*^MDdw`M4<JvsnJlAy!hhOta
z2+|F%u4xD__qBG&Re5c_aq}SmT#=6l4!fpj9$w^%yV4E{K`Q1N4SsEIP#Ea)H1wAa
zpfKd?09R?e*Y_DHFZ_D!gn%zkEq{#%hrq7s9u7k;q^s?Cq42A+z>zWbs_v0>=`PQ^
z|KQ>3jIctUHLwH(09<NT-e$iJ2wbWT4wnaLq<t@coszLPcR+qa_WJcr9H1w_BLW9Q
zCB?zKB5;T(@=PHDhVjC{Vj@sDGDRT*0ty2D?<V>HK|w4RSA?_cud@kqIr4I2F)~Uh
HNn-s!kSPqG


From 9891ccf9ebecf969028f0f09676a67e8941782e2 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 13 May 2011 12:12:35 +0200
Subject: [PATCH 0030/1541] Now the files to generate interface_functions.pdf
 have been added correctly to the commit. Makefile.am is edited, now
 ./configure will automatically generate the makefile which also makes the
 interface_functions.pdf.

File interface_functions contains all functions I deem usefull for
users. Revisions to this file are very welcome.

-MW
---
 doc/interface_functions.tex~ | 1107 ----------------------------------
 1 file changed, 1107 deletions(-)
 delete mode 100644 doc/interface_functions.tex~

diff --git a/doc/interface_functions.tex~ b/doc/interface_functions.tex~
deleted file mode 100644
index 9181447f..00000000
--- a/doc/interface_functions.tex~
+++ /dev/null
@@ -1,1107 +0,0 @@
-\documentclass[a4paper,10pt]{article}
-\usepackage[utf8x]{inputenc}
-
-%opening
-\title{Interface functions}
-\author{Martijn Wehrens}
-
-\begin{document}
-
-\maketitle
-
-\tableofcontents
-
-\section{Introduction}
-This document gives an overview of functions that are usefull to end-users of the enhanced Green's Functions Reaction Dynamics (eGFRD) algorithm. In other words, it lists the "interface functions".
-Basically, this entails a list of function definition plus their so-called python "docstrings", obtained straight from the code.
-Note that functions starting with an underscore are actually C++ functions ported to python by boost. 
-
-\section{Functions}
-
-\subsection{Functions from \texttt{model.py}}
-
-\subsubsection{Core functions:}
-As mentioned, all documentation in this document comes straight from the code. To obtain more information on how to structure a simple script, one could take a look into the sample directory.
-
-
-The class you need to set up a particle model:
-\begin{verbatim}
- class ParticleModel(_gfrd.Model):
-    """
-    """
-    def __init__(self, world_size):
-        """Create a new ParticleModel.
-
-        Arguments:
-            - world_size
-                the size of one side of the simulation "world". Units: 
-                meters.
-
-        The simulation "world" is always assumed to be a cube with 
-        *periodic boundary conditions*, with 1 corner at [0, 0, 0] and 
-        the corner furthest away from [0, 0, 0] being at
-        [world_size, world_size, world_size].
-
-        """
-\end{verbatim}
-
-\begin{verbatim}
-def Species(name, D, radius=0, structure="world", drift=0):
-    """Define a new Species (in/on a specific Region or Surface).
-
-    Arguments:
-        - name
-            the name of this Species.
-        - D
-            the diffusion constant for this Species in/on this 
-            Region or Surface. Units: meters^2/second.
-        - radius
-            the radius for this Species in/on this Region or Surface. 
-            Units: meters.
-        - structure
-            the Region or Surface in/on which this Species can exist.  
-            Optional. If you do not specify a Structure the Species is 
-            added to the "world".
-        - drift
-            the drift term for this ParticleType on a 
-            CylindricalSurface (1D drift). Units: meters/second. 
-            Optional.
-
-    If a certain Species should be able to exist in the "world" as 
-    well as in/on one of the previously created Regions or Surfaces, 
-    then two distinct Species should be created. One with and one 
-    without an explicit Structure argument.
-
-    """
-\end{verbatim}
-
-Species should be added to the model:
-\begin{verbatim}
-
-    def add_reaction_rule(self, reaction_rule):
-        """Add a ReactionRule to the ParticleModel.
-
-        Argument:
-            - reaction rule
-                a ReactionRule created by one of the functions
-                model.create_<>_reaction_rule.
-
-        """
-\end{verbatim}
-
-\subsubsection{Creating regions}
-
-\begin{verbatim}
-_gfrd.create_cuboidal_region.__doc__ = \
-"""create_cuboidal_region(id, corner, diagonal)
-
-Create and return a new cuboidal Region.
-
-Arguments:
-    - id
-        a descriptive name.
-    - corner
-        the point [x, y, z] of the cuboidal Region closest to
-        [0, 0, 0]. Units: [meters, meters, meters]
-    - diagonal
-        the vector [x, y, z] from the corner closest to [0, 0, 0], to 
-        the corner furthest away from [0, 0, 0]. Units:
-        [meters, meters, meters]
-
-"""
-
-_gfrd.create_cylindrical_surface.__doc__ = \
-"""create_cylindrical_surface(id, corner, radius, orientation, length)
-
-Create and return a new cylindrical Surface.
-
-Arguments:
-    - id
-        a descriptive name.
-    - corner
-        the point [x, y, z] on the axis of the cylinder closest to 
-        [0, 0, 0]. Units: [meters, meters, meters]
-    - radius
-        the radius of the cylinder. Units: meters.
-    - orientation
-        the unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the 
-        axis of the cylinder.
-    - length
-        the length of the cylinder. Should be equal to the world_size. 
-        Units: meters.
-
-Surfaces are not allowed to touch or overlap.
-
-"""
-
-_gfrd.create_planar_surface.__doc__ = \
-"""create_planar_surface(id, corner, unit_x, unit_y, length_x, length_y)
-
-Create and return a new planar Surface.
-
-Arguments:
-    - id
-        a descriptive name.
-    - corner
-        the point [x, y, z] on the plane closest to [0, 0, 0]. Units: 
-        [meters, meters, meters]
-    - unit_x
-        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the 
-        plane.
-    - unit_y
-        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the plane 
-        and perpendicular to unit_x.
-    - length_x
-        the length of the plane along the unit vector unit_x. Should be 
-        equal to the world_size. Units: meters.
-    - length_y
-        the length of the plane along the unit vector unit_y. Should be 
-        equal to the world_size. Units: meters.
-
-Surfaces are not allowed to touch or overlap.
-
-"""
-\end{verbatim} 
-
-As particles, regions should be added to the model. 
-\begin{verbatim}
-    def add_structure(self, structure):
-        """Add a Structure (Region or Surface) to the ParticleModel.
-
-        Arguments:
-            - structure
-              a Region or Surface created with one of the functions
-              model.create_<>_region or model.create_<>_surface.
-
-        """
-        assert isinstance(structure, _gfrd.Structure)
-        self.structures[structure.id] = structure
-        return structure
-\end{verbatim}
-
-\subsubsection{Adding reaction rules to the model}
-
-Function set\_all\_repulsive is called automatically, but it's docstring is instructive.
-\begin{verbatim}
-    def set_all_repulsive(self):
-        """Set all 'other' possible ReactionRules to be repulsive.
-
-        By default an EGFRDSimulator will assume:
-            - a repulsive bimolecular reaction rule (k=0) for each 
-              possible combination of reactants for which no 
-              bimolecular reaction rule is specified. 
-          
-        This method explicitly adds these ReactionRules to the 
-        ParticleModel.
-
-        """
-\end{verbatim}
-
-\begin{verbatim}
-def create_unimolecular_reaction_rule(reactant, product, k):
-    """Example: A -> B.
-
-    Arguments:
-        - reactant
-            a Species.
-        - product 
-            a Species.
-        - k
-            reaction rate. Units: per second. (Rough order of magnitude: 
-            1e-2 /s to 1e2 /s).
-
-    The reactant and the product should be in/on the same 
-    Region or Surface.
-
-    There is no distinction between an intrinsic and an overall reaction 
-    rate for a unimolecular ReactionRule.
-
-    A unimolecular reaction rule defines a Poissonian process.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def create_decay_reaction_rule(reactant, k):
-    """Example: A -> 0.
-
-    Arguments:
-        - reactant
-            a Species.
-        - k
-            reaction rate. Units: per second. (Rough order of magnitude: 
-            1e-2 /s to 1e2 /s).
-
-    There is no distinction between an intrinsic and an overall reaction 
-    rate for a decay ReactionRule.
-
-    A decay reaction rule defines a Poissonian process.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def create_annihilation_reaction_rule(reactant1, reactant2, ka):
-    """Example: A + B -> 0.
-
-    Arguments:
-        - reactant1
-            a Species.
-        - reactant2
-            a Species.
-        - ka
-            intrinsic reaction rate. Units: meters^3 per second. (Rough 
-            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s).
-
-    The reactants should be in/on the same Region or Surface.
-
-    ka should be an *intrinsic* reaction rate. You can convert an 
-    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
-    the function utils.k_a(kon, kD), but only for reaction rules in 3D.
-
-    By default an EGFRDSimulator will assume a repulsive 
-    bimolecular reaction rule (ka=0) for each possible combination of 
-    reactants for which no bimolecular reaction rule is specified. 
-    You can explicitly add these reaction rules to the model with the 
-    method model.ParticleModel.set_all_repulsive.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def create_binding_reaction_rule(reactant1, reactant2, product, ka):
-    """Example: A + B -> C.
-
-    Arguments:
-        - reactant1
-            a Species.
-        - reactant2
-            a Species.
-        - product
-            a Species.
-        - ka
-            intrinsic reaction rate. Units: meters^3 per second. (Rough 
-            order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
-
-    The reactants and the product should be in/on the same 
-    Region or Surface.
-
-    A binding reaction rule always has exactly one product.
-
-    ka should be an *intrinsic* reaction rate. You can convert an 
-    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
-    the function utils.k_a(kon, kD), but only for reaction rules in 3D.
-
-    By default an EGFRDSimulator will assume a repulsive 
-    bimolecular reaction rule (ka=0) for each possible combination of 
-    reactants for which no bimolecular reaction rule is specified. 
-    You can explicitly add these reaction rules to the model with the 
-    method model.ParticleModel.set_all_repulsive.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def create_unbinding_reaction_rule(reactant, product1, product2, kd):
-    """Example: A -> B + C.
-
-    Arguments:
-        - reactant
-            a Species.
-        - product1
-            a Species.
-        - product2
-            a Species.
-        - kd
-            intrinsic reaction rate. Units: per second. (Rough order of 
-            magnitude: 1e-2 /s to 1e2 /s).
-
-    The reactant and the products should be in/on the same 
-    Region or Surface.
-
-    An unbinding reaction rule always has exactly two products.
-
-    kd should be an *intrinsic* reaction rate. You can convert an 
-    overall reaction rate (koff) for this reaction rule to an intrinsic 
-    reaction rate (kd) with the function utils.k_d(koff, kon, kD) or 
-    utils.k_d_using_ka(koff, ka, kD).
-
-    An unbinding reaction rule defines a Poissonian process.
-
-    """
-\end{verbatim}
-
-To put this reactions into effect one should also call \texttt{add_reaction_rule}, e.g.:
-\begin{verbatim}
-    r1 = model.create_binding_reaction_rule(A, B, C, kf)
-    m.network_rules.add_reaction_rule(r1)
-\end{verbatim}
-
-\subsection{Functions from \texttt{gfrdbase.py}}
-
-\subsubsection{Core functions}
-
-\begin{verbatim}
-def create_world(m, matrix_size=10):
-    """Create a world object.
-    
-    The world object keeps track of the positions of the particles
-    and the protective domains during an eGFRD simulation.
-
-    Arguments:
-        - m
-            a ParticleModel previously created with model.ParticleModel.
-        - matrix_size
-            the number of cells in the MatrixSpace along the x, y and z 
-            axis. Leave it to the default number if you don't know what 
-            to put here.
-
-    The simulation cube "world" is divided into (matrix_size x matrix_size 
-    x matrix_size) cells. Together these cells form a MatrixSpace. The 
-    MatrixSpace keeps track in which cell every particle and protective 
-    domain is at a certain point in time. To find the neigherest 
-    neighbours of particle, only objects in the same cell and the 26 
-    (3x3x3 - 1) neighbouring cells (the simulation cube has periodic
-    boundary conditions) have to be taken into account.
-
-    The matrix_size limits the size of the protective domains. If you 
-    have fewer particles, you want a smaller matrix_size, such that the 
-    protective domains and thus the eGFRD timesteps can be larger. If 
-    you have more particles, you want a larger matrix_size, such that 
-    finding the neigherest neighbours is faster.
-    
-    Example. In samples/dimer/dimer.py a matrix_size of
-    (N * 6) ** (1. / 3.) is used, where N is the average number of 
-    particles in the world.
-
-    """
-\end{verbatim}
-
-
-\subsubsection{Handling objects}
-
-\begin{verbatim}
-def get_closest_surface(world, pos, ignore):
-    """Return
-      - closest surface
-      - distance to closest surface
-    
-    We can not use matrix_space, it would miss a surface if the 
-    origin of the surface would not be in the same or neighboring 
-    cells as pos."""
-\end{verbatim}
-
-\begin{verbatim}
-def get_closest_surface_within_radius(world, pos, radius, ignore):
-    """Return:
-      - surface within radius or None
-      - closest surface (regardless of radius)
-      - distance to closest surface"""
-\end{verbatim}
-
-\subsubsection{Adding particles}
-\begin{verbatim}
-functions
-def throw_in_particles(world, sid, n):
-    """Add n particles of a certain Species to the specified world.
-
-    Arguments:
-        - sid
-            a Species previously created with the function 
-            model.Species.
-        - n
-            the number of particles to add.
-
-    Make sure to first add the Species to the model with the method
-    model.ParticleModel.add_species_type.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def place_particle(world, sid, position):
-    """Place a particle of a certain Species at a specific position in 
-    the specified world.
-
-    Arguments:
-        - sid
-            a Species previously created with the function 
-            model.Species.
-        - position
-            a position vector [x, y, z]. Units: [meters, meters, meters].
-
-    Make sure to first add the Species to the model with the method 
-    model.ParticleModel.add_species_type.
-
-    """
-\end{verbatim}
-
-\subsection{Functions from \texttt{egfrd.py}}
-
-\subsubsection{Core functions}
-\begin{verbatim}
-class EGFRDSimulator(ParticleSimulatorBase):
-    """
-    """
-    def __init__(self, world, rng=myrandom.rng, network_rules=None):
-        """Create a new EGFRDSimulator.
-
-        Arguments:
-            - world
-                a world object created with the function 
-                gfrdbase.create_world.
-            - rng
-                a random number generator. By default myrandom.rng is 
-                used, which uses Mersenne Twister from the GSL library.
-                You can set the seed of it with the function 
-                myrandom.seed.
-            - network_rules
-                you don't need to use this, for backward compatibility only.
-
-        """
-\end{verbatim}
-
-\begin{verbatim}
-    def step(self):
-        """Execute one eGFRD step.
-
-        """
-\end{verbatim}
-(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
-
-\begin{verbatim}
-    def stop(self, t):
-        """Synchronize all particles at time t.
-
-        With eGFRD, particle positions are normally updated 
-        asynchronously. This method bursts all protective domains and 
-        assigns a position to each particle.
-
-        Arguments:
-            - t
-                the time at which to synchronize the particles. Usually 
-                you will want to use the current time of the simulator: 
-                EGFRDSimulator.t.
-
-        This method is called stop because it is usually called at the 
-        end of a simulation. It is possible to call this method at an 
-        earlier time. For example the Logger module does this, because 
-        it needs to know the positions of the particles at each log 
-        step.
-
-        """
-\end{verbatim}
-(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
-
-\subsubsection{Simulator time (manipulation) functions}
-
-\begin{verbatim}
-    def get_next_time(self):
-    """ 
-    Returns the time it will be when the next egfrd timestep
-    is completed.
-    """ 
-\end{verbatim}
-(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
-
-
-\begin{verbatim}
-    def reset(self):
-    """
-    This function resets the "records" of the simulator. This means
-    the simulator time is reset, the step counter is reset, events
-    are reset, etc.
-    Can be for example usefull when users want to "stirr" the 
-    simulation before starting the "real experiment".
-    """
-\end{verbatim}
-(Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
-
-\subsubsection{Get data}
-\begin{verbatim}
-    def print_report(self, out=None):
-        """Print various statistics about the simulation.
-        
-        Arguments:
-            - None
-
-        """
-\end{verbatim}
-
-\subsubsection{Additional functions}
-The class \texttt{EGFRDSimulator} contains several functions which might be usefull to eGFRD users in very specific cases. Because of their specific nature, they don't contain docstrings. 
-\begin{verbatim}
-    def get_matrix_cell_size(self):
-        return self.containers[0].cell_size
-
-    def set_user_max_shell_size(self, size):
-        self.user_max_shell_size = size
-
-    def get_user_max_shell_size(self):
-        return self.user_max_shell_size
-
-    def get_max_shell_size(self):
-        return min(self.get_matrix_cell_size() * .5 / SAFETY,
-                   self.user_max_shell_size)
-\end{verbatim}
-
-\subsection{Functions from \texttt{dumper.py}}
-
-\subsubsection{Getting information on species/particles}
-\begin{verbatim}
-def get_species(sim):
-    """Return an iterator over the Species in the simulator.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def dump_species(sim):
-    """Return a string containing the Species in the simulator.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def get_species_names(sim):
-    """Return an iterator over the names of the Species in the 
-    simulator.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def dump_species_names(sim):
-    """Return a string containing the names of the Species in the 
-    simulator.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def _get_species_type_by_name(sim, name):
-    """ Return the type of a species with a certain name
-
-    Arguments:
-        - sim
-            an EGFRDSimulator
-        - name
-            species name
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def _get_particles_by_sid(sim, sid):
-    """ Return a generator (using "yield") to loop over (pid, particle).
-    
-    Arguments:
-        - sim
-            an EGFRDSimulator
-        - sid
-            ID of a species
-
-    E.g.:
-    
-    myparticles = _get_particles_by_sid(sim, sid)
-
-    for mypid, myparticle in myparticles:
-        print str(str(mypid), str(myparticle))
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def get_particles(sim, identifier=None):
-    """Return an iterator over the
-    (particle identifier, particle)-pairs in the simulator.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-        - identifier
-            a Species or the name of a Species. If none is specified, 
-            all (particle identifier, particle)-pairs will be returned.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def dump_particles(sim, identifier=None):
-    """Return a string containing the
-    (particle identifier, particle)-pairs in the simulator.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-        - identifier
-            a Species or the name of a Species. If none is specified, 
-            all (particle identifier, particle)-pairs will be returned.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def _get_number_of_particles_by_sid(sim, sid):
-    """ 
-    Returns the number of particles of a certain species.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-        - sid
-            ID of a species    
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def get_number_of_particles(sim, identifier=None):
-    """Return the number of particles of a certain Species in the 
-    simulator.
-
-    Arguments:
-        - sim
-            either an EGFRDSimulator or a GillespieSimulator.
-        - identifier
-            a Species. Optional. If none is specified, a list of 
-            (Species name, number of particles)-pairs will be returned.
-
-    """ 
-\end{verbatim}
-
-\begin{verbatim}
-def dump_number_of_particles(sim, identifier=None):
-    """Return a string containing the number of particles of a certain 
-    Species in the simulator.
-
-    Arguments:
-        - sim
-            either an EGFRDSimulator or a GillespieSimulator.
-        - identifier
-            a Species. Optional. If none is specified, 
-            a string of (Species name, number of particles)-pairs will 
-            be returned.
-
-    """ 
-\end{verbatim}
-
-\subsubsection{Get information on domains}
-
-\begin{verbatim}
-def get_domains(egfrdsim):
-    """Return an iterator over the protective domains in the simulator.
-
-    Arguments:
-        - egfrdsim
-            an EGFRDSimulator
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def dump_domains(egfrdsim):
-    """Return an string containing the protective domains in the 
-    simulator.
-
-    """
-\end{verbatim}
-
-subsubsection{Get information on reaction rules}
-
-\begin{verbatim}
-def get_reaction_rules(model_or_simulator):
-    """Return three lists with all the reaction rules defined in the 
-    ParticleModel or EGFRDSimulator.
-
-    The three lists are:
-        - reaction rules of only one reactant.
-        - reaction rules between two reactants with a reaction rate 
-          larger than 0.
-        - repulsive reaction rules between two reactants with a 
-          reaction rate equal to 0.
-
-    Arguments:
-        - model_or_simulator
-            a ParticleModel or EGFRDSimulator.
-
-    """
-\end{verbatim}
-
-\begin{verbatim}
-def _dump_reaction_rule(model, reaction_rule):
-    """Helper. Return ReactionRule as string.
-
-    ReactionRule.__str__ would be good, but we are actually getting a 
-    ReactionRuleInfo or ReactionRuleCache object."""
-\end{verbatim}
-
-\begin{verbatim}
-def dump_reaction_rules(model_or_simulator):
-    """Return a formatted string containing all the reaction rules 
-    defined in the ParticleModel or EGFRDSimulator.
-
-    Arguments:
-        - model_or_simulator
-            a ParticleModel or EGFRDSimulator.
-
-    """
-\end{verbatim}
-
-\subsection{Functions from \texttt{utils.py}}
-
-This file contains functions on common mathematical objects, transformations and formulas. Some of these functions are used throughout the algorithm, and some are supplied for convenience. 
-For the user, none of these functions are \textit{needed} to make a simulation work, but some might come in handy.
-
-\subsubsection{Mathematical comparisons}
-\begin{verbatim}
-def feq(a, b, typical=1, tolerance=TOLERANCE):
-    """Return True if a and b are equal, subject to given tolerances.  
-    Float comparison.
-
-    Also see numpy.allclose().
-
-    The (relative) tolerance must be positive and << 1.0
-
-    Instead of specifying an absolute tolerance, you can speciy a 
-    typical value for a or b. The absolute tolerance is then the 
-    relative tolerance multipied by this typical value, and will be 
-    used when comparing a value to zero. By default, the typical 
-    value is 1."""
-
-def fgreater(a, b, typical=1, tolerance=TOLERANCE):
-    """Return True if a is greater than b, subject to given tolerances.  
-    Float comparison."""
-
-def fless(a, b, typical=1, tolerance=TOLERANCE):
-    """Return True if a is less than b, subject to given tolerances.  
-    Float comparison."""
-
-def fgeq(a, b, typical=1, tolerance=TOLERANCE):
-    """Return True if a is greater or equal than b, subject to given 
-    tolerances. Float comparison."""
-
-def fleq(a, b, typical=1, tolerance=TOLERANCE):
-    """Return True if a is less than or equal than b, subject to given 
-    tolerances. Float comparison."""
-
-\end{verbatim}
-
-\subsubsection{Conversions}
-
-As these functions only contain a single line of formula code, this line is also supplied.
-\begin{verbatim}
-def per_M_to_m3(rate):
-    """Convert a reaction rate from units 'per molar per second' to 
-    units 'meters^3 per second'.
-
-    """
-    return rate / (1000 * N_A)
-
-def per_microM_to_m3(rate):
-    """Convert a reaction rate from units 'per micromolar per second' to 
-    units 'meters^3 per second'.
-
-    """
-    return per_M_to_m3(rate * 1e6)
-
-def M_to_per_m3(molar):
-    """Convert a concentration from units 'molar' to units 'per 
-    meters^3'.
-
-    """
-    return molar * (1000 * N_A)
-
-def microM_to_per_m3(micromolar):
-    """Convert a concentration from units 'micromolar' to units 'per 
-    meters^3'.
-
-    """
-    return M_to_per_m3(micromolar / 1e6) 
-
-def C2N(c, V):
-    """Calculate the number of particles in a volume 'V' (dm^3) 
-    with a concentration 'c' (mol/dm^3).
-
-    """
-    return c * V * N_A  # round() here?
-\end{verbatim}
-
-Conversions involving rates:
-\begin{verbatim}
-
-def k_D(Dtot, sigma):
-    """Calculate the 'pseudo-'reaction rate (kD) caused by diffusion.
-    
-    kD is equal to 1 divided by the time it takes for two particles to 
-    meet each other by diffusion. It is needed when converting from 
-    an intrinsic reaction rate to an overall reaction rates or vice 
-    versa.
-
-    Example:
-        - A + B -> C.
-
-    Arguments:
-        - Dtot:
-            the diffusion constant of particle A plus the diffusion 
-            constant of particle B. Units: meters^2/second.
-        - sigma
-            the radius of particle A plus the radius of particle B. 
-            Units: meters.
-
-    This function is only available for reaction rules in 3D. No 
-    analytical expression for kD in 1D or 2D is currently known. 
-
-    """
-    return 4.0 * numpy.pi * Dtot * sigma
-
-def k_a(kon, kD):
-    """Convert an overall reaction rate (kon) for a binding/annihilation 
-    reaction rule to an intrinsic reaction rate (ka).
-
-    Example:
-        - A + B -> C
-            binding reaction rule
-        - A + B -> 0
-            annihilation reaction rule
-
-    Arguments:
-        - kon
-            the overall reaction rate for the reaction rule. Units: 
-            meters^3/second.
-        - kD
-            the 'pseudo-'reaction rate caused by the diffusion of 
-            particles A and B. See the function k_D(). Units: 
-            meters^3/second.
-
-    This function is only available for reaction rules in 3D. No 
-    analytical expression for kD in 1D or 2D is currently known. 
-
-    """
-    if kon > kD:
-        raise RuntimeError, 'kon > kD.'
-    ka = 1. / ((1. / kon) - (1. / kD))
-    return ka
-
-def k_d(koff, kon, kD):
-    """Convert an overall reaction rate (koff) for an unbinding reaction 
-    rule to an intrinsic reaction rate (kd).
-
-    This one is a bit tricky. We consider reaction rules with only 1 
-    reactant. In case there is only 1 product also, no conversion in 
-    necessary. But when the reaction rule has 2 products, we need to 
-    take the reverse reaction rule into account and do the proper 
-    conversion.
-
-    Example:
-        - C -> A + B
-            unbinding reaction rule
-        - A + B -> C
-            reverse reaction rule
-
-    Arguments:
-        - koff
-            the overall reaction rate for the unbinding reaction rule.  
-            Units: meters^3/second.
-        - kon
-            the overall reaction rate for the reverse reaction rule. 
-            Units: meters^3/second.
-        - kD
-            the 'pseudo-'reaction rate caused by the diffusion of 
-            particles A and B. See the function k_D(). Units: 
-            meters^3/second.
-
-    This function is only available for reaction rules in 3D. No 
-    analytical expression for kD in 1D or 2D is currently known. 
-
-    """
-    ka = k_a(kon, kD)
-    kd = k_d_using_ka(koff, ka, kD)
-    return kd
-
-def k_d_using_ka(koff, ka, kD):
-    """Convert an overall reaction rate (koff) for an unbinding reaction 
-    rule to an intrinsic reaction rate (kd).
-
-    Similar to the function k_d(), but expects an intrinsic rate (ka) 
-    instead of an overall rate (kon) for the reversed reaction rule as 
-    the second argument.
-
-    This function is only available for reaction rules in 3D. No 
-    analytical expression for kD in 1D or 2D is currently known. 
-
-    """
-    kd =  koff * (1 + float(ka) / kD)
-    return kd
-
-def k_on(ka, kD):
-    """Convert an intrinsic reaction rate (ka) for a binding/annihilation 
-    reaction rule to an overall reaction rate (kon).
-
-    The inverse of the function k_a().
-    
-    Rarely needed.
-
-    This function is only available for reaction rules in 3D. No 
-    analytical expression for kD in 1D or 2D is currently known. 
-
-    """
-    kon = 1. / ((1. / kD) + (1. / ka))  # m^3/s
-    return kon
-
-def k_off(kd, kon, kD):
-    """Convert an intrinsic reaction rate (kd) for an unbinding reaction 
-    rule to an overall reaction rate (koff).
-
-    The inverse of the function k_d().
-
-    Rarely needed.
-
-    This function is only available for reaction rules in 3D. No 
-    analytical expression for kD in 1D or 2D is currently known. 
-
-    """
-    ka = k_a(kon, kD) 
-    koff = k_off_using_ka(kd, ka, kD)
-    return koff
-
-def k_off_using_ka(kd, ka, kD):
-    """Convert an intrinsic reaction rate (kd) for an unbinding reaction 
-    rule to an overall reaction rate (koff).
-
-    Similar to the function k_off(), but expects an intrinsic rate 
-    (ka) instead of an overall rate (kon) as the second argument.
-
-    Rarely needed.
-
-    This function is only available for reaction rules in 3D. No 
-    analytical expression for kD in 1D or 2D is currently known. 
-
-    """
-    koff = 1. / (float(ka) / (kd * kD) + (1. / kd))
-    return koff
-\end{verbatim}
-
-
-\subsubsection{Some convenient functoins}
-
-These functions do not contain docstrings, are sometimes self-explanatory and probably not needed that often in simulations. Therefore only definitions of functions that might be of interest to the user are listed here:
-
-Mean arrival time:
-\begin{verbatim}
-def mean_arrival_time(r, D):
-    return (r * r) / (6.0 * D)
-\end{verbatim}
-
-Calculating with distances:
-\begin{verbatim}
-def distance_sq_array_simple(position1, positions, fsize = None):
-    
-def distance_array_simple(position1, positions, fsize = None):
-
-distance = _gfrd.distance
-
-distance_cyclic = _gfrd.distance_cyclic
-
-def distance_sq_array_cyclic(position1, positions, fsize):
-    
-def distance_array_cyclic(position1, positions, fsize = 0):
-
-\end{verbatim}
-
-Some vector functions:
-\begin{verbatim}
-def cartesian_to_spherical(c):
-
-def spherical_to_cartesian(s):
-
-def random_unit_vector_s():
-
-def random_unit_vector():
-
-def random_vector(r):
-
-def random_vector2D(r):
-
-def length(a):
-
-def normalize(a, l=1):
-
-def vector_angle(a, b):
-
-def vector_angle_against_z_axis(b):
-
-def crossproduct(a, b):
-
-def crossproduct_against_z_axis(a):
-
-def rotate_vector(v, r, alpha):
-\end{verbatim}
-
-\subsection{Notes on other files}
-
-\subsubsection{\texttt{bd.py}: Brownian Dynamic Simulator}
-The class \texttt{BDSimulator} can be used in the same way as the EGFRDSimulator class, but performs Brownian Dynamics (BD) instead. Users who want to perform eGFRD simulations never need this. The simulator can be used for comparison of the eGFRD algorithm with Brownian Dynamics. 
-
-\subsubsection{\texttt{gillespie.py}: Gillespie Simulator}
-Similar to the BD simulator, the class \texttt{GillespieSimulatorBase} can be used for Gillespie type simulations. 
-
-\subsubsection{\texttt{legacy.py}: Old redundant functions}
-This module is called nowhere in the Python code. It contains an archive of outdated code.
-
-\subsubsection{\texttt{multi.py}, \texttt{pair.py}, \texttt{single.py}}
-These file contain the code that handle the specific events that happen in the different categories of domains.
-
-\subsubsection{\texttt{myrandom.py}}
-Contains a few convenient lines of code used when using random functions.
- 
-\subsubsection{\texttt{make\_cjy\_table.py.py}, \texttt{make\_sjy\_table.py.py}}
-Generate (respectively cylindrical and spherical) bessel function tables.
-
-
-\subsection{Function from module \texttt{logger.py}}
-
-This module contains two loggers. One logger that logs in the hdf5 format, for obvious reasons in class \texttt{HDF5Logger}. Note that this logger requires the module h5py. The other logger gives output dictated more by the nature of the eGFRD algorithm.
-The loggers are not (yet) explained in very much detail here, but both function in the same way. A logger class is made, which takes input on to which file to write, the logger can be started by \texttt{start()} and steps are logged by the function \texttt{log()}.
-
-\subsubsection{HDF5 logger}
-
-\begin{verbatim}
-class HDF5Logger(object):
-    def __init__(self, logname, directory='data', split=False):
-
-    def log(self, sim, time):      
-
-    def start(self, sim):
-\end{verbatim}
-
-\subsubsection{"Normal" logger}
-\begin{verbatim}
-class Logger(object):
-    def __init__(self, logname='log', directory='data', comment=''):
-
-    def log(self, sim, time):
-
-    def start(self, sim):
-\end{verbatim}
-
-(Note that not all functions contained by this class are listed, just functions deemed usefull for user interface.)
-
-\section{Todo}
-
-- \texttt{sid = identifier.id} gives the sid, but what exactly is identifier?
-
-\end{document}

From 6f5ae655c4c8d87bf94dfcefda9209cc2cce3d32 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 13 May 2011 13:49:14 +0200
Subject: [PATCH 0031/1541] Oops! Removed bug from egfrd.py I introduced when
 adding docstrings without indentation.

---
 egfrd.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ec6ce565..f2df374b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -126,10 +126,10 @@ def get_matrix_cell_size(self):
         return self.containers[0].cell_size
 
     def get_next_time(self):
-    """ 
-    Returns the time it will be when the next egfrd timestep
-    is completed.
-    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
+        """ 
+        Returns the time it will be when the next egfrd timestep
+        is completed.        
+        """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
         if self.scheduler.size == 0:
             return self.t
 
@@ -146,13 +146,13 @@ def get_max_shell_size(self):
                    self.user_max_shell_size)
 
     def reset(self):
-    """
-    This function resets the "records" of the simulator. This means
-    the simulator time is reset, the step counter is reset, events
-    are reset, etc.
-    Can be for example usefull when users want to "stirr" the 
-    simulation before starting the "real experiment".
-    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
+        """
+        This function resets the "records" of the simulator. This means
+        the simulator time is reset, the step counter is reset, events
+        are reset, etc.
+        Can be for example usefull when users want to "stirr" the 
+        simulation before starting the "real experiment".
+        """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
         self.t = 0.0
         self.dt = 0.0
         self.step_counter = 0

From dcd7b0ff3cc7983ee1feaab5f201c55302c964bf Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 13 May 2011 14:04:42 +0200
Subject: [PATCH 0032/1541] Fixed bug in interface_functions file.

---
 doc/interface_functions.aux | 47 +++++++++---------
 doc/interface_functions.log | 96 ++++++++++++++++++++-----------------
 doc/interface_functions.tex |  2 +-
 doc/interface_functions.toc | 47 +++++++++---------
 4 files changed, 100 insertions(+), 92 deletions(-)

diff --git a/doc/interface_functions.aux b/doc/interface_functions.aux
index 53196f5c..45842c57 100644
--- a/doc/interface_functions.aux
+++ b/doc/interface_functions.aux
@@ -1,34 +1,35 @@
 \relax 
-\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{1}}
-\@writefile{toc}{\contentsline {section}{\numberline {2}Functions}{1}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Functions from \texttt  {model.py}}{1}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{1}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{2}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{4}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Functions from \texttt  {gfrdbase.py}}{7}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{7}}
+\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{2}}
+\@writefile{toc}{\contentsline {section}{\numberline {2}Functions}{2}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Functions from \texttt  {model.py}}{2}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{2}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{3}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{5}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Functions from \texttt  {gfrdbase.py}}{8}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.2}Handling objects}{8}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{8}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Functions from \texttt  {egfrd.py}}{9}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{9}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{10}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.3}Get data}{10}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{10}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.3}Get data}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{11}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.4}Functions from \texttt  {dumper.py}}{11}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{11}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{13}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Functions from \texttt  {utils.py}}{14}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{14}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{14}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Functions from \texttt  {utils.py}}{15}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{15}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{15}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{19}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{20}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{20}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{20}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{20}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.4}\texttt  {multi.py}, \texttt  {pair.py}, \texttt  {single.py}}{20}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{20}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.4}\texttt  {multi.py}, \texttt  {pair.py}, \texttt  {single.py}}{21}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.5}\texttt  {myrandom.py}}{21}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.6}\texttt  {make\_cjy\_table.py.py}, \texttt  {make\_sjy\_table.py.py}}{21}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.7}Function from module \texttt  {logger.py}}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{21}}
-\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{21}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{22}}
+\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{22}}
diff --git a/doc/interface_functions.log b/doc/interface_functions.log
index 5099a1e6..6a8ef0df 100644
--- a/doc/interface_functions.log
+++ b/doc/interface_functions.log
@@ -1,4 +1,4 @@
-This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  13 MAY 2011 12:08
+This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  13 MAY 2011 14:04
 entering extended mode
  %&-line parsing enabled.
 **interface_functions.tex
@@ -66,10 +66,18 @@ LaTeX Font Info:    External font `cmex10' loaded for size
 (Font)              <8> on input line 10.
 LaTeX Font Info:    External font `cmex10' loaded for size
 (Font)              <6> on input line 10.
- (./interface_functions.toc)
+ (./interface_functions.toc
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <7> on input line 3.
+LaTeX Font Info:    External font `cmex10' loaded for size
+(Font)              <5> on input line 3.
+)
 \tf@toc=\write3
 \openout3 = `interface_functions.toc'.
 
+ [1
+
+{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}]
 LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <12> not available
 (Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 21.
 
@@ -90,9 +98,7 @@ Overfull \hbox (22.4968pt too wide) in paragraph at lines 46--46
  0, 0] and[] 
  []
 
-[1
 
-{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}]
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
 []            \OT1/cmtt/m/n/10 the radius for this Species in/on this Region or
  Surface.[] 
@@ -104,7 +110,7 @@ Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
 an exist.[] 
  []
 
-
+[2]
 Overfull \hbox (22.4968pt too wide) in paragraph at lines 76--76
 []            \OT1/cmtt/m/n/10 Optional. If you do not specify a Structure the 
 Species is[] 
@@ -122,7 +128,7 @@ Overfull \hbox (11.99689pt too wide) in paragraph at lines 76--76
 urfaces,[] 
  []
 
-[2]
+
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 164--164
 []        \OT1/cmtt/m/n/10 the vector [x, y, z] from the corner closest to [0, 
 0, 0], to[] 
@@ -134,7 +140,7 @@ Overfull \hbox (22.4968pt too wide) in paragraph at lines 164--164
 n, length)[] 
  []
 
-
+[3]
 Overfull \hbox (1.49698pt too wide) in paragraph at lines 164--164
 []        \OT1/cmtt/m/n/10 the point [x, y, z] on the axis of the cylinder clos
 est to[] 
@@ -170,7 +176,7 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
 g the plane[] 
  []
 
-[3]
+
 Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
 []        \OT1/cmtt/m/n/10 the length of the plane along the unit vector unit_x
 . Should be[] 
@@ -182,7 +188,7 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
 . Should be[] 
  []
 
-
+[4]
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 180--180
 []        \OT1/cmtt/m/n/10 """Add a Structure (Region or Surface) to the Partic
 leModel.[] 
@@ -206,7 +212,7 @@ Overfull \hbox (1.49698pt too wide) in paragraph at lines 198--198
 r each[] 
  []
 
-[4]
+
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
 []            \OT1/cmtt/m/n/10 reaction rate. Units: per second. (Rough order o
 f magnitude:[] 
@@ -218,7 +224,7 @@ Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
 all reaction[] 
  []
 
-
+[5]
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 241--241
 []            \OT1/cmtt/m/n/10 reaction rate. Units: per second. (Rough order o
 f magnitude:[] 
@@ -254,7 +260,7 @@ Overfull \hbox (17.24684pt too wide) in paragraph at lines 269--269
 nation of[] 
  []
 
-[5]
+
 Overfull \hbox (1.49698pt too wide) in paragraph at lines 269--269
 []    \OT1/cmtt/m/n/10 reactants for which no bimolecular reaction rule is spec
 ified.[] 
@@ -272,7 +278,7 @@ Overfull \hbox (11.99689pt too wide) in paragraph at lines 302--302
 ct, ka):[] 
  []
 
-
+[6]
 Overfull \hbox (27.74675pt too wide) in paragraph at lines 302--302
 []            \OT1/cmtt/m/n/10 intrinsic reaction rate. Units: meters^3 per sec
 ond. (Rough[] 
@@ -320,7 +326,7 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
 gh order of[] 
  []
 
-[6]
+
 Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
 []    \OT1/cmtt/m/n/10 overall reaction rate (koff) for this reaction rule to a
 n intrinsic[] 
@@ -332,7 +338,7 @@ Overfull \hbox (11.99689pt too wide) in paragraph at lines 332--332
 , kD) or[] 
  []
 
-
+[7]
 Overfull \hbox (1.49698pt too wide) in paragraph at lines 378--378
 []    \OT1/cmtt/m/n/10 The world object keeps track of the positions of the par
 ticles[] 
@@ -404,7 +410,7 @@ Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
 arger. If[] 
  []
 
-[7]
+
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
 []    \OT1/cmtt/m/n/10 you have more particles, you want a larger matrix_size, 
 such that[] 
@@ -416,7 +422,7 @@ Overfull \hbox (1.49698pt too wide) in paragraph at lines 378--378
 ber of[] 
  []
 
-
+[8]
 Overfull \hbox (1.49698pt too wide) in paragraph at lines 400--400
 []\OT1/cmtt/m/n/10 def get_closest_surface_within_radius(world, pos, radius, ig
 nore):[] 
@@ -440,7 +446,7 @@ Overfull \hbox (22.4968pt too wide) in paragraph at lines 437--437
 osition in[] 
  []
 
-[8]
+
 Overfull \hbox (38.24666pt too wide) in paragraph at lines 437--437
 []            \OT1/cmtt/m/n/10 a position vector [x, y, z]. Units: [meters, met
 ers, meters].[] 
@@ -452,7 +458,7 @@ Overfull \hbox (6.74693pt too wide) in paragraph at lines 437--437
  method[] 
  []
 
-
+[9]
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 462--462
 []    \OT1/cmtt/m/n/10 def __init__(self, world, rng=myrandom.rng, network_rule
 s=None):[] 
@@ -500,7 +506,7 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 493--493
  simulator:[] 
  []
 
-[9]
+
 Overfull \hbox (22.4968pt too wide) in paragraph at lines 493--493
 []        \OT1/cmtt/m/n/10 This method is called stop because it is usually cal
 led at the[] 
@@ -530,7 +536,7 @@ Overfull \hbox (41.35085pt too wide) in paragraph at lines 494--495
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
-
+[10]
 Overfull \hbox (41.35085pt too wide) in paragraph at lines 505--506
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
@@ -554,13 +560,13 @@ Overfull \hbox (41.35085pt too wide) in paragraph at lines 518--519
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
-[10] [11]
+[11]
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 626--626
 []    \OT1/cmtt/m/n/10 """ Return a generator (using "yield") to loop over (pid
 , particle).[] 
  []
 
-
+[12]
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 641--641
 []            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
 pecified,[] 
@@ -578,13 +584,13 @@ Overfull \hbox (17.24684pt too wide) in paragraph at lines 656--656
 pecified,[] 
  []
 
-[12]
+
 Overfull \hbox (27.74675pt too wide) in paragraph at lines 656--656
 []            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
 e returned.[] 
  []
 
-
+[13]
 Overfull \hbox (27.74675pt too wide) in paragraph at lines 685--685
 []            \OT1/cmtt/m/n/10 (Species name, number of particles)-pairs will b
 e returned.[] 
@@ -608,7 +614,7 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 713--713
  simulator.[] 
  []
 
-[13]
+
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 742--742
 []    \OT1/cmtt/m/n/10 """Return three lists with all the reaction rules define
 d in the[] 
@@ -620,7 +626,7 @@ Overfull \hbox (6.74693pt too wide) in paragraph at lines 742--742
 on rate[] 
  []
 
-
+[14]
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 750--750
 []    \OT1/cmtt/m/n/10 ReactionRule.__str__ would be good, but we are actually 
 getting a[] 
@@ -632,7 +638,7 @@ Overfull \hbox (1.49698pt too wide) in paragraph at lines 762--762
  rules[] 
  []
 
-[14]
+
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 801--801
 []    \OT1/cmtt/m/n/10 """Return True if a and b are equal, subject to given to
 lerances.[] 
@@ -650,7 +656,7 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 801--801
 tolerances.[] 
  []
 
-
+[15]
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 801--801
 []    \OT1/cmtt/m/n/10 """Return True if a is less than b, subject to given tol
 erances.[] 
@@ -680,13 +686,13 @@ Overfull \hbox (32.9967pt too wide) in paragraph at lines 841--841
 r second' to[] 
  []
 
-[15]
+
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 841--841
 []    \OT1/cmtt/m/n/10 """Convert a concentration from units 'micromolar' to un
 its 'per[] 
  []
 
-
+[16]
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 996--996
 []    \OT1/cmtt/m/n/10 """Calculate the 'pseudo-'reaction rate (kD) caused by d
 iffusion.[] 
@@ -728,13 +734,13 @@ Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
 annihilation[] 
  []
 
-[16]
+
 Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
 []            \OT1/cmtt/m/n/10 the overall reaction rate for the reaction rule.
  Units:[] 
  []
 
-
+[17]
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
 ing reaction[] 
@@ -770,13 +776,13 @@ Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
 on rule.[] 
  []
 
-[17]
+
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
 ing reaction[] 
  []
 
-
+[18]
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 996--996
 []    \OT1/cmtt/m/n/10 Similar to the function k_d(), but expects an intrinsic 
 rate (ka)[] 
@@ -800,7 +806,7 @@ Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
 ing reaction[] 
  []
 
-[18]
+
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
 []    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
 ing reaction[] 
@@ -812,22 +818,22 @@ Overfull \hbox (1.49698pt too wide) in paragraph at lines 996--996
 c rate[] 
  []
 
-[19]
+[19] [20]
 LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <10> not available
 (Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 1056.
 
- [20]
+ [21]
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 1099--1099
 []    \OT1/cmtt/m/n/10 def __init__(self, logname='log', directory='data', comm
 ent=''):[] 
  []
 
-[21] (./interface_functions.aux) ) 
+[22] (./interface_functions.aux) ) 
 Here is how much of TeX's memory you used:
- 506 strings out of 95086
- 7733 string characters out of 1183255
- 66134 words of memory out of 1500000
- 3729 multiletter control sequences out of 10000+50000
+ 508 strings out of 95086
+ 7761 string characters out of 1183255
+ 67134 words of memory out of 1500000
+ 3731 multiletter control sequences out of 10000+50000
  8578 words of font info for 31 fonts, out of 1200000 for 2000
  28 hyphenation exceptions out of 8191
  23i,6n,20p,323b,243s stack positions out of 5000i,500n,6000p,200000b,5000s
@@ -838,9 +844,9 @@ e/fonts/type1/bluesky/cm/cmr12.pfb></usr/share/texmf-texlive/fonts/type1/bluesk
 y/cm/cmr17.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmti10.pfb></us
 r/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt10.pfb></usr/share/texmf-texli
 ve/fonts/type1/bluesky/cm/cmtt12.pfb>
-Output written on interface_functions.pdf (21 pages, 92315 bytes).
+Output written on interface_functions.pdf (22 pages, 94420 bytes).
 PDF statistics:
- 102 PDF objects out of 1000 (max. 8388607)
+ 105 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 131072)
  1 words of extra memory for PDF output out of 10000 (max. 10000000)
 
diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
index c33e457f..f599b699 100644
--- a/doc/interface_functions.tex
+++ b/doc/interface_functions.tex
@@ -720,7 +720,7 @@ \subsubsection{Get information on domains}
     """
 \end{verbatim}
 
-subsubsection{Get information on reaction rules}
+\subsubsection{Get information on reaction rules}
 
 \begin{verbatim}
 def get_reaction_rules(model_or_simulator):
diff --git a/doc/interface_functions.toc b/doc/interface_functions.toc
index 9131d2db..30f912cb 100644
--- a/doc/interface_functions.toc
+++ b/doc/interface_functions.toc
@@ -1,33 +1,34 @@
-\contentsline {section}{\numberline {1}Introduction}{1}
-\contentsline {section}{\numberline {2}Functions}{1}
-\contentsline {subsection}{\numberline {2.1}Functions from \texttt {model.py}}{1}
-\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{1}
-\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{2}
-\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{4}
-\contentsline {subsection}{\numberline {2.2}Functions from \texttt {gfrdbase.py}}{7}
-\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{7}
+\contentsline {section}{\numberline {1}Introduction}{2}
+\contentsline {section}{\numberline {2}Functions}{2}
+\contentsline {subsection}{\numberline {2.1}Functions from \texttt {model.py}}{2}
+\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{2}
+\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{3}
+\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{5}
+\contentsline {subsection}{\numberline {2.2}Functions from \texttt {gfrdbase.py}}{8}
+\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}
 \contentsline {subsubsection}{\numberline {2.2.2}Handling objects}{8}
-\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{8}
+\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}
 \contentsline {subsection}{\numberline {2.3}Functions from \texttt {egfrd.py}}{9}
 \contentsline {subsubsection}{\numberline {2.3.1}Core functions}{9}
 \contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{10}
-\contentsline {subsubsection}{\numberline {2.3.3}Get data}{10}
-\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{10}
+\contentsline {subsubsection}{\numberline {2.3.3}Get data}{11}
+\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{11}
 \contentsline {subsection}{\numberline {2.4}Functions from \texttt {dumper.py}}{11}
 \contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{11}
-\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{13}
-\contentsline {subsection}{\numberline {2.5}Functions from \texttt {utils.py}}{14}
+\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{14}
+\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{14}
+\contentsline {subsection}{\numberline {2.5}Functions from \texttt {utils.py}}{15}
 \contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{15}
-\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{15}
-\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{19}
-\contentsline {subsection}{\numberline {2.6}Notes on other files}{20}
-\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{20}
-\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{20}
-\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{20}
-\contentsline {subsubsection}{\numberline {2.6.4}\texttt {multi.py}, \texttt {pair.py}, \texttt {single.py}}{20}
+\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{16}
+\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{20}
+\contentsline {subsection}{\numberline {2.6}Notes on other files}{21}
+\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{21}
+\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{21}
+\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{21}
+\contentsline {subsubsection}{\numberline {2.6.4}\texttt {multi.py}, \texttt {pair.py}, \texttt {single.py}}{21}
 \contentsline {subsubsection}{\numberline {2.6.5}\texttt {myrandom.py}}{21}
 \contentsline {subsubsection}{\numberline {2.6.6}\texttt {make\_cjy\_table.py.py}, \texttt {make\_sjy\_table.py.py}}{21}
 \contentsline {subsection}{\numberline {2.7}Function from module \texttt {logger.py}}{21}
-\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{21}
-\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{21}
-\contentsline {section}{\numberline {3}Todo}{21}
+\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{22}
+\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{22}
+\contentsline {section}{\numberline {3}Todo}{22}

From fbe7e2b71e29006c7d6d6840ada2c5fb4ffd71b3 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 13 May 2011 18:09:01 +0200
Subject: [PATCH 0033/1541] Got samples/rebind/run.py running. HOWEVER, since
 it made use of some functions that are no longer in the code, I had to come
 up with some sort of substitutes. This code doesn't function properly in all
 cases. Namely: * The function EGFRDSimulator.distance_between_particles()
 doesn't exist anymore. Instead I get particle all particle IDs of a certain
 type. Then I simply take the first particle in the list to calculate the
 distance between hopefully the right particles. This thus only works when
 there are only two particles.

I should really look into what we want to measure before fixing this.
A possible solution would be to just save the ID of the particle
that was placed initially with place_particle.

* The function clear_volume gives the IDs of domains in a certain
neighboorhood. It bursted these domains to get them up to the
current time. But this leads to the problem that a particle might
belong to a domain in the to be cleared area, but it's actual
position is not in the cleared area. This might lead to an infinite
loop.
---
 samples/rebind/run.py | 56 +++++++++++++++++++++++++++++++++----------
 1 file changed, 43 insertions(+), 13 deletions(-)

diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index 84b09a2b..54200d51 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -150,27 +150,51 @@ def singlerun(T_list, D_factor, N_B, N_X):
           area, repeat the process (in very crowded box, this 
           leads to infinite loop)
         - 
+
+    Perhaps it would be more easy to just place all the particles at
+    the beginning, but give A and B initially a diffusion constant of
+    0, then stirr, and then set the diffusion constant to their
+    desired values..
+    
     """
+    print "Started clearing.."
     while 1:
-        pp = s.get_particles_within_radius(A_pos, float(A['radius']))
-        if not pp:
+        #TODO this code doesn't function properly, because you want to clear 
+        # particles within a certain radius.. Now you can be removing particles 
+        # that after bursting are not in the area anymore, but whose bursted 
+        # domains were.
+
+        # After bursting you should just check whether something is within the radius.
+
+        #pp = s.get_particles_within_radius(A_pos, float(A['radius']))
+        dd = s.clear_volume(A_pos, float(A['radius'])) # returns a list of 
+                                                       # domains ID's that
+                                                       # where bursted within
+                                                       # volume
+        if not dd:
             break
-        for p in pp:
-            s.remove_particle(p)
+        for d in dd:
+            for p in d.particle_id_pair:
+                s.remove_particle(p)
         s.throw_in_particles(X, len(pp), box1)
 
-    s.place_particle(A, A_pos)
+    place_particle(w, A, A_pos)
 
     # Idem for a particle B:
     while 1:
-        pp = s.get_particles_within_radius(B_pos, float(B['radius']))
-        if not pp:
+        dd = s.clear_volume(B_pos, float(B['radius'])) # returns a list of 
+                                                       # domains ID's that
+                                                       # where bursted within
+                                                       # volume
+        if not dd:
             break
-        for p in pp:
-            s.remove_particle(p)
-        s.throw_in_particles(X, len(pp), box1)    
+        for d in dd:
+            for p in d.particle_id_pair:
+                s.remove_particle(p)
+        s.throw_in_particles(X, len(pp), box1)
 
-    s.place_particle(B, B_pos)
+    place_particle(w, B, B_pos) 
+    print "Finished clearing.."
 
     # Place rest of B at random positions
     if N_B > 1:
@@ -215,8 +239,14 @@ def singlerun(T_list, D_factor, N_B, N_X):
             s.stop(next_stop)
             if len(s.world.get_particle_ids(C.id)) != 0:  #A,B
                 r_list.append(0)
-            else:
-                r_list.append(s.distance_between_particles(A.id, B.id))
+            else: # C = 0, i.e. there are particles A and B
+                # r_list.append(s.distance_between_particles(A.id, B.id))
+                # If there's only 1 B-particle
+                particlesA = w.get_particle_ids(A.id)
+                particlesB = w.get_particle_ids(B.id)
+                positionA = particlesA[1].position()
+                positionB = particlesB[1].position()
+                r_list.append(w.distance(positionA, positionB))
 
             i_T += 1
             next_stop = T_list[i_T]

From e9136e0a293ebdc097dbd5edb8652e70d82bdbb6 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 16 May 2011 10:26:45 +0200
Subject: [PATCH 0034/1541] Sorry, another test indicated example still doesn't
 work. Apparently positionA = particlesA[1].position() isn't allowed. Didn't
 discover this earlier because didn't give array of stopping times as input,
 only "INF". But then the simulation isn't really allowed to run.

~MW
---
 samples/rebind/run.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index 54200d51..7319b31a 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -28,8 +28,8 @@ def run(outfilename, D_factor, N_B, N_X, N):
     tau = sigma**2 / D_tot
     print 'tau=', tau
 
-    #T_list = [tau * .1, INF]
-    T_list = [INF]
+    T_list = [tau * .1, INF]
+    # T_list = [INF] # With this option, the simulation stops immediately
 
     outfile_t = open(outfilename + '_t.dat', 'w')
     #outfile_r_list = [open(outfilename + '_r_-1.dat', 'w')] 
@@ -176,6 +176,7 @@ def singlerun(T_list, D_factor, N_B, N_X):
         for d in dd:
             for p in d.particle_id_pair:
                 s.remove_particle(p)
+                print "Removing particle.."
         s.throw_in_particles(X, len(pp), box1)
 
     place_particle(w, A, A_pos)
@@ -191,10 +192,11 @@ def singlerun(T_list, D_factor, N_B, N_X):
         for d in dd:
             for p in d.particle_id_pair:
                 s.remove_particle(p)
+                print "Removing particle.."
         s.throw_in_particles(X, len(pp), box1)
 
     place_particle(w, B, B_pos) 
-    print "Finished clearing.."
+    print "Finished placing particles A & B.."
 
     # Place rest of B at random positions
     if N_B > 1:

From c1fd3fc930f95b74f5c7e6d605b56610e2a72728 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 May 2011 13:23:22 +0200
Subject: [PATCH 0035/1541] added .gitignore to ignore autogenerated files

---
 .gitignore | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..cc6f271e
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,58 @@
+# files that should be ignored by git for tracking
+#
+# ignore all compiled python files
+*.pyc
+# ignore all compiled C++ libraries and object files
+*.lo
+*.la
+*.lai
+*.so
+*.Plo
+*.Po
+*.o
+*.a
+# ignore generated Bessel tables
+/CylindricalBesselTable.hpp
+/SphericalBesselTable.hpp
+
+# ignore files generated by pdflatex
+*.aux
+*.log
+*.pdf
+
+# ignore Makefiles.in generated by automake and Makefiles generated by configure
+Makefile.in
+/Makefile
+/doc/Makefile
+/binding/Makefile
+/samples/benchmark/Makefile
+/test/Makefile
+
+# all kinds of configuration files follow now
+# ignore files generated by configure 
+/config.h
+/config.log
+/config.status
+/stamp-h1
+# ignore scripts generated by configure (I think)
+/config.guess
+/config.sub
+/libtool
+/ltmain.sh
+# ignore files generated by autoconf
+/configure
+/depcomp
+/missing
+/py-compile
+/install-sh
+/m4/libtool.m4
+/m4/ltoptions.m4
+/m4/ltsugar.m4
+/m4/ltversion.m4
+/m4/lt~obsolete.m4
+/autom4te.cache/
+# ignore files generated by autoheader
+/config.h.in
+# ignore files generated by aclocal
+/aclocal.m4
+

From b0382ec0f0b0329a23f7c5aabae4f48a8f02ca2d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 May 2011 15:44:16 +0200
Subject: [PATCH 0036/1541] *.out and *.pyo files added to the gitignore list

---
 .gitignore | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index cc6f271e..3dfdb44f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,7 +1,9 @@
-# files that should be ignored by git for tracking
+# Files that should be ignored by git for tracking
+# For explanation see the gitignore man page
 #
 # ignore all compiled python files
 *.pyc
+*.pyo
 # ignore all compiled C++ libraries and object files
 *.lo
 *.la
@@ -20,6 +22,9 @@
 *.log
 *.pdf
 
+# ignore data files generated by the examples
+*.out
+
 # ignore Makefiles.in generated by automake and Makefiles generated by configure
 Makefile.in
 /Makefile

From 0bdb716d38ad6ae1faf7e1aa136d10def10581d2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 May 2011 15:50:11 +0200
Subject: [PATCH 0037/1541] add execute permissions on samples python script
 for easier launching

---
 samples/reversible/make_p_rev_files.py | 0
 samples/reversible/p_rev.py            | 0
 samples/reversible/plot.py             | 0
 samples/reversible/run.py              | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 samples/reversible/make_p_rev_files.py
 mode change 100644 => 100755 samples/reversible/p_rev.py
 mode change 100644 => 100755 samples/reversible/plot.py
 mode change 100644 => 100755 samples/reversible/run.py

diff --git a/samples/reversible/make_p_rev_files.py b/samples/reversible/make_p_rev_files.py
old mode 100644
new mode 100755
diff --git a/samples/reversible/p_rev.py b/samples/reversible/p_rev.py
old mode 100644
new mode 100755
diff --git a/samples/reversible/plot.py b/samples/reversible/plot.py
old mode 100644
new mode 100755
diff --git a/samples/reversible/run.py b/samples/reversible/run.py
old mode 100644
new mode 100755

From 30c3566fad13257f5c3706df35c9cfba9b726fc0 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 16 May 2011 16:50:31 +0200
Subject: [PATCH 0038/1541] Mainly documentation update.

While working on ../rebind/run.py ran into some functions I
overlooked in gfrdbase.py.

Thus added some functions to /doc/interface_functions.tex.

Also, some convenient functions didn't have a docstring yet. Also
added those. I've marked all docstrings I've added with:

\#TODO: Added by wehrens@amolf.nl; please revise

So, as the comment already said, please revise these docstrings.

More info on /rebind will follow in next commit.

~MW
---
 doc/interface_functions.aux |  55 +++++----
 doc/interface_functions.log | 220 ++++++++++++++++++++----------------
 doc/interface_functions.tex | 126 ++++++++++++++++++++-
 doc/interface_functions.toc |  55 +++++----
 gfrdbase.py                 |  49 ++++++++
 samples/rebind/run.py       | 145 +++++++++++++++---------
 6 files changed, 448 insertions(+), 202 deletions(-)

diff --git a/doc/interface_functions.aux b/doc/interface_functions.aux
index 45842c57..37ee8f85 100644
--- a/doc/interface_functions.aux
+++ b/doc/interface_functions.aux
@@ -7,29 +7,34 @@
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{5}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Functions from \texttt  {gfrdbase.py}}{8}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.2}Handling objects}{8}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.2}Handling objects (surfaces, cylinders, etc)}{9}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Functions from \texttt  {egfrd.py}}{9}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{9}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{10}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.3}Get data}{11}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{11}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}Functions from \texttt  {dumper.py}}{11}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{11}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{14}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{14}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Functions from \texttt  {utils.py}}{15}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{15}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{16}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{20}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.4}\texttt  {multi.py}, \texttt  {pair.py}, \texttt  {single.py}}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.5}\texttt  {myrandom.py}}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.6}\texttt  {make\_cjy\_table.py.py}, \texttt  {make\_sjy\_table.py.py}}{21}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.7}Function from module \texttt  {logger.py}}{21}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{22}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{22}}
-\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.4}Obtaining particle information}{10}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Functions from \texttt  {egfrd.py}}{10}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{10}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.3}Get data}{12}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.4}Get position and distance data}{12}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.5}Additional functions}{13}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}Functions from \texttt  {dumper.py}}{13}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{13}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{16}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{16}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Functions from \texttt  {utils.py}}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{17}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{21}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.4}\texttt  {multi.py}, \texttt  {pair.py}, \texttt  {single.py}}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.5}\texttt  {myrandom.py}}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.6}\texttt  {make\_cjy\_table.py.py}, \texttt  {make\_sjy\_table.py.py}}{23}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.7}Function from module \texttt  {logger.py}}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{23}}
+\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{23}}
+\@writefile{toc}{\contentsline {section}{\numberline {4}On C++ data structures}{24}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.1}SpeciesInfo}{24}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}Particle}{24}}
diff --git a/doc/interface_functions.log b/doc/interface_functions.log
index 6a8ef0df..a8cbf220 100644
--- a/doc/interface_functions.log
+++ b/doc/interface_functions.log
@@ -1,4 +1,4 @@
-This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  13 MAY 2011 14:04
+This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  16 MAY 2011 16:26
 entering extended mode
  %&-line parsing enabled.
 **interface_functions.tex
@@ -71,13 +71,12 @@ LaTeX Font Info:    External font `cmex10' loaded for size
 (Font)              <7> on input line 3.
 LaTeX Font Info:    External font `cmex10' loaded for size
 (Font)              <5> on input line 3.
-)
+ [1
+
+{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}])
 \tf@toc=\write3
 \openout3 = `interface_functions.toc'.
 
- [1
-
-{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}]
 LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <12> not available
 (Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 21.
 
@@ -98,7 +97,7 @@ Overfull \hbox (22.4968pt too wide) in paragraph at lines 46--46
  0, 0] and[] 
  []
 
-
+[2]
 Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
 []            \OT1/cmtt/m/n/10 the radius for this Species in/on this Region or
  Surface.[] 
@@ -110,7 +109,7 @@ Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
 an exist.[] 
  []
 
-[2]
+
 Overfull \hbox (22.4968pt too wide) in paragraph at lines 76--76
 []            \OT1/cmtt/m/n/10 Optional. If you do not specify a Structure the 
 Species is[] 
@@ -134,13 +133,13 @@ Overfull \hbox (17.24684pt too wide) in paragraph at lines 164--164
 0, 0], to[] 
  []
 
-
+[3]
 Overfull \hbox (22.4968pt too wide) in paragraph at lines 164--164
 []\OT1/cmtt/m/n/10 """create_cylindrical_surface(id, corner, radius, orientatio
 n, length)[] 
  []
 
-[3]
+
 Overfull \hbox (1.49698pt too wide) in paragraph at lines 164--164
 []        \OT1/cmtt/m/n/10 the point [x, y, z] on the axis of the cylinder clos
 est to[] 
@@ -332,13 +331,13 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
 n intrinsic[] 
  []
 
-
+[7]
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 332--332
 []    \OT1/cmtt/m/n/10 reaction rate (kd) with the function utils.k_d(koff, kon
 , kD) or[] 
  []
 
-[7]
+
 Overfull \hbox (1.49698pt too wide) in paragraph at lines 378--378
 []    \OT1/cmtt/m/n/10 The world object keeps track of the positions of the par
 ticles[] 
@@ -459,376 +458,395 @@ Overfull \hbox (6.74693pt too wide) in paragraph at lines 437--437
  []
 
 [9]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 462--462
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 505--505
 []    \OT1/cmtt/m/n/10 def __init__(self, world, rng=myrandom.rng, network_rule
 s=None):[] 
  []
 
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 462--462
+[10]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 505--505
 []                \OT1/cmtt/m/n/10 a random number generator. By default myrand
 om.rng is[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 462--462
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 505--505
 []                \OT1/cmtt/m/n/10 used, which uses Mersenne Twister from the G
 SL library.[] 
  []
 
 
-Overfull \hbox (53.99652pt too wide) in paragraph at lines 462--462
+Overfull \hbox (53.99652pt too wide) in paragraph at lines 505--505
 []                \OT1/cmtt/m/n/10 you don't need to use this, for backward com
 patibility only.[] 
  []
 
 
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 470--471
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 513--514
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
 
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 493--493
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 536--536
 []        \OT1/cmtt/m/n/10 asynchronously. This method bursts all protective do
 mains and[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 493--493
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 536--536
 []                \OT1/cmtt/m/n/10 the time at which to synchronize the particl
 es. Usually[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 493--493
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 536--536
 []                \OT1/cmtt/m/n/10 you will want to use the current time of the
  simulator:[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 493--493
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 536--536
 []        \OT1/cmtt/m/n/10 This method is called stop because it is usually cal
 led at the[] 
  []
 
 
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 493--493
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 536--536
 []        \OT1/cmtt/m/n/10 end of a simulation. It is possible to call this met
 hod at an[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 493--493
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 536--536
 []        \OT1/cmtt/m/n/10 earlier time. For example the Logger module does thi
 s, because[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 493--493
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 536--536
 []        \OT1/cmtt/m/n/10 it needs to know the positions of the particles at e
 ach log[] 
  []
 
 
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 494--495
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 537--538
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
-[10]
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 505--506
+
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 548--549
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 517--517
+[11]
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 560--560
 []    \OT1/cmtt/m/n/10 This function resets the "records" of the simulator. Thi
 s means[] 
  []
 
 
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 517--517
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 560--560
 []    \OT1/cmtt/m/n/10 the simulator time is reset, the step counter is reset, 
 events[] 
  []
 
 
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 518--519
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 561--562
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
-[11]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 626--626
+
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 605--605
+[]\OT1/cmtt/m/n/10 def get_closest_surface_within_radius(world, pos, radius, ig
+nore):[] 
+ []
+
+[12] [13]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 704--704
 []    \OT1/cmtt/m/n/10 """ Return a generator (using "yield") to loop over (pid
 , particle).[] 
  []
 
-[12]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 641--641
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 719--719
 []            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
 pecified,[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 641--641
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 719--719
 []            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
 e returned.[] 
  []
 
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 656--656
+[14]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 734--734
 []            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
 pecified,[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 656--656
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 734--734
 []            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
 e returned.[] 
  []
 
-[13]
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 685--685
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 763--763
 []            \OT1/cmtt/m/n/10 (Species name, number of particles)-pairs will b
 e returned.[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 701--701
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 779--779
 []    \OT1/cmtt/m/n/10 """Return a string containing the number of particles of
  a certain[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 701--701
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 779--779
 []            \OT1/cmtt/m/n/10 a string of (Species name, number of particles)-
 pairs will[] 
  []
 
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 713--713
+[15]
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 791--791
 []    \OT1/cmtt/m/n/10 """Return an iterator over the protective domains in the
  simulator.[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 742--742
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 820--820
 []    \OT1/cmtt/m/n/10 """Return three lists with all the reaction rules define
 d in the[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 742--742
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 820--820
 []        \OT1/cmtt/m/n/10 - reaction rules between two reactants with a reacti
 on rate[] 
  []
 
-[14]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 750--750
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 828--828
 []    \OT1/cmtt/m/n/10 ReactionRule.__str__ would be good, but we are actually 
 getting a[] 
  []
 
 
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 762--762
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 840--840
 []    \OT1/cmtt/m/n/10 """Return a formatted string containing all the reaction
  rules[] 
  []
 
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 801--801
+[16]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 879--879
 []    \OT1/cmtt/m/n/10 """Return True if a and b are equal, subject to given to
 lerances.[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 801--801
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 879--879
 []    \OT1/cmtt/m/n/10 relative tolerance multipied by this typical value, and 
 will be[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 801--801
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 879--879
 []    \OT1/cmtt/m/n/10 """Return True if a is greater than b, subject to given 
 tolerances.[] 
  []
 
-[15]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 801--801
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 879--879
 []    \OT1/cmtt/m/n/10 """Return True if a is less than b, subject to given tol
 erances.[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 801--801
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 879--879
 []    \OT1/cmtt/m/n/10 """Return True if a is greater or equal than b, subject 
 to given[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 801--801
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 879--879
 []    \OT1/cmtt/m/n/10 """Return True if a is less than or equal than b, subjec
 t to given[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 841--841
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 919--919
 []    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per molar per sec
 ond' to[] 
  []
 
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 841--841
+[17]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 919--919
 []    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per micromolar pe
 r second' to[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 841--841
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 919--919
 []    \OT1/cmtt/m/n/10 """Convert a concentration from units 'micromolar' to un
 its 'per[] 
  []
 
-[16]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 996--996
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 """Calculate the 'pseudo-'reaction rate (kD) caused by d
 iffusion.[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 996--996
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 kD is equal to 1 divided by the time it takes for two pa
 rticles to[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 meet each other by diffusion. It is needed when converti
 ng from[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 an intrinsic reaction rate to an overall reaction rates 
 or vice[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
 []            \OT1/cmtt/m/n/10 the diffusion constant of particle A plus the di
 ffusion[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
 []            \OT1/cmtt/m/n/10 the radius of particle A plus the radius of part
 icle B.[] 
  []
 
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+[18]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (kon) for a binding/
 annihilation[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 996--996
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
 []            \OT1/cmtt/m/n/10 the overall reaction rate for the reaction rule.
  Units:[] 
  []
 
-[17]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
 ing reaction[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 This one is a bit tricky. We consider reaction rules wit
 h only 1[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 reactant. In case there is only 1 product also, no conve
 rsion in[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 necessary. But when the reaction rule has 2 products, we
  need to[] 
  []
 
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 996--996
+[19]
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 1074--1074
 []            \OT1/cmtt/m/n/10 the overall reaction rate for the unbinding reac
 tion rule.[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 996--996
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
 []            \OT1/cmtt/m/n/10 the overall reaction rate for the reverse reacti
 on rule.[] 
  []
 
 
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
 ing reaction[] 
  []
 
-[18]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 996--996
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 Similar to the function k_d(), but expects an intrinsic 
 rate (ka)[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 996--996
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 instead of an overall rate (kon) for the reversed reacti
 on rule as[] 
  []
 
 
-Overfull \hbox (38.24666pt too wide) in paragraph at lines 996--996
+Overfull \hbox (38.24666pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (ka) for a binding
 /annihilation[] 
  []
 
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+[20]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
 ing reaction[] 
  []
 
 
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 996--996
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
 ing reaction[] 
  []
 
 
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 996--996
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 1074--1074
 []    \OT1/cmtt/m/n/10 Similar to the function k_off(), but expects an intrinsi
 c rate[] 
  []
 
-[19] [20]
+[21]
 LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <10> not available
-(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 1056.
+(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 1134.
 
- [21]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1099--1099
+ [22]
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1177--1177
 []    \OT1/cmtt/m/n/10 def __init__(self, logname='log', directory='data', comm
 ent=''):[] 
  []
 
-[22] (./interface_functions.aux) ) 
+[23]
+Overfull \hbox (374.24373pt too wide) in paragraph at lines 1216--1216
+[]  \OT1/cmtt/m/n/10 SpeciesInfo (identifier_type const &id, D_type const &D=0.
+, length_type const &r=0., structure_id_type const &s="", v_type const &v=0.)[]
+ 
+ []
+
+
+Overfull \hbox (64.49643pt too wide) in paragraph at lines 1216--1216
+[]\OT1/cmtt/m/n/10 template<typename Tid_, typename TD_, typename Tlen_, typena
+me Tstructure_id_>[] 
+ []
+
+[24] (./interface_functions.aux) ) 
 Here is how much of TeX's memory you used:
  508 strings out of 95086
  7761 string characters out of 1183255
@@ -836,17 +854,19 @@ Here is how much of TeX's memory you used:
  3731 multiletter control sequences out of 10000+50000
  8578 words of font info for 31 fonts, out of 1200000 for 2000
  28 hyphenation exceptions out of 8191
- 23i,6n,20p,323b,243s stack positions out of 5000i,500n,6000p,200000b,5000s
+ 23i,8n,20p,323b,243s stack positions out of 5000i,500n,6000p,200000b,5000s
 </usr/share/texmf-texlive/fonts/type1/bluesky
 /cm/cmbx10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmbx12.pfb></us
 r/share/texmf-texlive/fonts/type1/bluesky/cm/cmr10.pfb></usr/share/texmf-texliv
 e/fonts/type1/bluesky/cm/cmr12.pfb></usr/share/texmf-texlive/fonts/type1/bluesk
-y/cm/cmr17.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmti10.pfb></us
-r/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt10.pfb></usr/share/texmf-texli
-ve/fonts/type1/bluesky/cm/cmtt12.pfb>
-Output written on interface_functions.pdf (22 pages, 94420 bytes).
+y/cm/cmr17.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr6.pfb></usr/
+share/texmf-texlive/fonts/type1/bluesky/cm/cmr7.pfb></usr/share/texmf-texlive/f
+onts/type1/bluesky/cm/cmr8.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm
+/cmti10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt10.pfb></usr/s
+hare/texmf-texlive/fonts/type1/bluesky/cm/cmtt12.pfb>
+Output written on interface_functions.pdf (24 pages, 109202 bytes).
 PDF statistics:
- 105 PDF objects out of 1000 (max. 8388607)
+ 123 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 131072)
  1 words of extra memory for PDF output out of 10000 (max. 10000000)
 
diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
index f599b699..5a61b356 100644
--- a/doc/interface_functions.tex
+++ b/doc/interface_functions.tex
@@ -378,7 +378,7 @@ \subsubsection{Core functions}
 \end{verbatim}
 
 
-\subsubsection{Handling objects}
+\subsubsection{Handling objects (surfaces, cylinders, etc)}
 
 \begin{verbatim}
 def get_closest_surface(world, pos, ignore):
@@ -436,6 +436,68 @@ \subsubsection{Adding particles}
     """
 \end{verbatim}
 
+\subsubsection{Obtaining information about particles and species}
+
+\begin{verbatim}
+\begin{verbatim}
+
+    def get_species(self):
+        """
+        Return an iterator over the Species in the simulator. 
+        To be exact, it returns an iterator that returns 
+        all SpeciesInfo instances defined in the simulator.
+        
+        Arguments: 
+            - sim an EGFRDSimulator. 
+
+        More on output:
+            - SpeciesInfo is defined in the C++ code, and has
+              the following attributes that might be of interest
+              to the user:
+                   * SpeciesInfo.id
+                   * SpeciesInfo.radius
+                   * SpeciesInfo.structure_id
+                   * SpeciesInfo.D
+                   * SpeciesInfo.v
+                
+        Example:
+
+            for species in s.get_species():
+                print str(species.radius)
+
+        Note:
+            Dumper.py also holds a copy of this function.        
+
+        """
+
+    def get_first_pid(self, sid):
+        """
+        Returns the first particle ID of a certain species.
+
+        Arguments:
+            - sid: a(n) (eGFRD) simulator.
+        """
+
+    def get_position(self, object):
+        """
+        Function that returns particle position. Can take multiple
+        sort of arguments as input. 
+
+        Arguments:
+            - object: can be:
+                * pid_particle_pair tuple 
+                  (of which pid_particle_pair[0] is _gfrd.ParticleID).
+                * An instance of _gfrd.ParticleID.
+
+                * An instance of _gfrd.Particle.
+                * An instance of _gfrd.SpeciesID.
+                    In the two latter cases, the function returns the 
+                    first ID of the position of the first particle of 
+                    the given species.
+        """ 
+ 
+\end{verbatim}
+
 \subsection{Functions from \texttt{egfrd.py}}
 
 \subsubsection{Core functions}
@@ -518,7 +580,9 @@ \subsubsection{Simulator time (manipulation) functions}
 (Function belongs to EGFRDSimulator class, call with \texttt{EGFRDSimulator.get\_next\_time}.)
 
 \subsubsection{Get data}
+
 \begin{verbatim}
+
     def print_report(self, out=None):
         """Print various statistics about the simulation.
         
@@ -526,8 +590,31 @@ \subsubsection{Get data}
             - None
 
         """
+
+\end{verbatim}
+
+\subsubsection{Get position and distance data}
+\begin{verbatim}
+def get_closest_surface(world, pos, ignore):
+    """Return
+      - closest surface
+      - distance to closest surface
+    
+    We can not use matrix_space, it would miss a surface if the 
+    origin of the surface would not be in the same or neighboring 
+    cells as pos."""
+
+def get_closest_surface_within_radius(world, pos, radius, ignore):
+    """Return:
+      - surface within radius or None
+      - closest surface (regardless of radius)
+      - distance to closest surface"""
+
+
 \end{verbatim}
 
+
+
 \subsubsection{Additional functions}
 The class \texttt{EGFRDSimulator} contains several functions which might be usefull to eGFRD users in very specific cases. Because of their specific nature, they don't contain docstrings. 
 \begin{verbatim}
@@ -1103,5 +1190,42 @@ \subsubsection{"Normal" logger}
 \section{Todo}
 
 - \texttt{sid = identifier.id} gives the sid, but what exactly is identifier?
+- Updating following text (On C++ data structures)..
+
+\section{On C++ data structures}
+
+\subsection{SpeciesInfo}
+
+The information on species can be found in object created in the C++ code. Some Python functions return the SpeciesInfo object, which has the following attributes\footnote{Data extracted from Doxygen files.}:
+
+\begin{verbatim}
+Public Types
+typedef Tid_ 	identifier_type
+typedef TD_ 	D_type
+typedef TD_ 	v_type
+typedef Tlen_ 	length_type
+typedef Tstructure_id_ 	structure_id_type
+
+Public Member Functions
+identifier_type const & 	id () const
+length_type const & 	radius () const
+length_type & 	radius ()
+structure_id_type const & 	structure_id () const
+structure_id_type & 	structure_id ()
+D_type const & 	D () const
+D_type & 	D ()
+v_type const & 	v () const
+v_type & 	v ()
+bool 	operator== (SpeciesInfo const &rhs) const
+bool 	operator!= (SpeciesInfo const &rhs) const
+ 	SpeciesInfo (identifier_type const &id, D_type const &D=0., length_type const &r=0., structure_id_type const &s="", v_type const &v=0.)
+
+template<typename Tid_, typename TD_, typename Tlen_, typename Tstructure_id_>
+struct SpeciesInfo< Tid_, TD_, Tlen_, Tstructure_id_ >
+\end{verbatim}
+
+\subsection{Particle}
+
+The particle information is held by a class in the C++ code. A single particle is 
 
 \end{document}
diff --git a/doc/interface_functions.toc b/doc/interface_functions.toc
index 30f912cb..9ac91ea3 100644
--- a/doc/interface_functions.toc
+++ b/doc/interface_functions.toc
@@ -6,29 +6,34 @@
 \contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{5}
 \contentsline {subsection}{\numberline {2.2}Functions from \texttt {gfrdbase.py}}{8}
 \contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}
-\contentsline {subsubsection}{\numberline {2.2.2}Handling objects}{8}
+\contentsline {subsubsection}{\numberline {2.2.2}Handling objects (surfaces, cylinders, etc)}{9}
 \contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}
-\contentsline {subsection}{\numberline {2.3}Functions from \texttt {egfrd.py}}{9}
-\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{9}
-\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{10}
-\contentsline {subsubsection}{\numberline {2.3.3}Get data}{11}
-\contentsline {subsubsection}{\numberline {2.3.4}Additional functions}{11}
-\contentsline {subsection}{\numberline {2.4}Functions from \texttt {dumper.py}}{11}
-\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{11}
-\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{14}
-\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{14}
-\contentsline {subsection}{\numberline {2.5}Functions from \texttt {utils.py}}{15}
-\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{15}
-\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{16}
-\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{20}
-\contentsline {subsection}{\numberline {2.6}Notes on other files}{21}
-\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{21}
-\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{21}
-\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{21}
-\contentsline {subsubsection}{\numberline {2.6.4}\texttt {multi.py}, \texttt {pair.py}, \texttt {single.py}}{21}
-\contentsline {subsubsection}{\numberline {2.6.5}\texttt {myrandom.py}}{21}
-\contentsline {subsubsection}{\numberline {2.6.6}\texttt {make\_cjy\_table.py.py}, \texttt {make\_sjy\_table.py.py}}{21}
-\contentsline {subsection}{\numberline {2.7}Function from module \texttt {logger.py}}{21}
-\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{22}
-\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{22}
-\contentsline {section}{\numberline {3}Todo}{22}
+\contentsline {subsubsection}{\numberline {2.2.4}Obtaining particle information}{10}
+\contentsline {subsection}{\numberline {2.3}Functions from \texttt {egfrd.py}}{10}
+\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{10}
+\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{11}
+\contentsline {subsubsection}{\numberline {2.3.3}Get data}{12}
+\contentsline {subsubsection}{\numberline {2.3.4}Get position and distance data}{12}
+\contentsline {subsubsection}{\numberline {2.3.5}Additional functions}{13}
+\contentsline {subsection}{\numberline {2.4}Functions from \texttt {dumper.py}}{13}
+\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{13}
+\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{16}
+\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{16}
+\contentsline {subsection}{\numberline {2.5}Functions from \texttt {utils.py}}{17}
+\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{17}
+\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{17}
+\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{21}
+\contentsline {subsection}{\numberline {2.6}Notes on other files}{22}
+\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{22}
+\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{22}
+\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{22}
+\contentsline {subsubsection}{\numberline {2.6.4}\texttt {multi.py}, \texttt {pair.py}, \texttt {single.py}}{23}
+\contentsline {subsubsection}{\numberline {2.6.5}\texttt {myrandom.py}}{23}
+\contentsline {subsubsection}{\numberline {2.6.6}\texttt {make\_cjy\_table.py.py}, \texttt {make\_sjy\_table.py.py}}{23}
+\contentsline {subsection}{\numberline {2.7}Function from module \texttt {logger.py}}{23}
+\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{23}
+\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{23}
+\contentsline {section}{\numberline {3}Todo}{23}
+\contentsline {section}{\numberline {4}On C++ data structures}{24}
+\contentsline {subsection}{\numberline {4.1}SpeciesInfo}{24}
+\contentsline {subsection}{\numberline {4.2}Particle}{24}
diff --git a/gfrdbase.py b/gfrdbase.py
index d62c038b..9d46ee09 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -310,12 +310,61 @@ def initialize(self):
         pass
 
     def get_species(self):
+        """
+        Return an iterator over the Species in the simulator. 
+        To be exact, it returns an iterator that returns 
+        all SpeciesInfo instances defined in the simulator.
+        
+        Arguments: 
+            - sim an EGFRDSimulator. 
+
+        More on output:
+            - SpeciesInfo is defined in the C++ code, and has
+              the following attributes that might be of interest
+              to the user:
+                   * SpeciesInfo.id
+                   * SpeciesInfo.radius
+                   * SpeciesInfo.structure_id
+                   * SpeciesInfo.D
+                   * SpeciesInfo.v
+                
+        Example:
+
+            for species in s.get_species():
+                print str(species.radius)
+
+        Note:
+            Dumper.py also holds a copy of this function.        
+
+        """ #TODO: Added by wehrens@amolf.nl; please revise
         return self.world.species
 
     def get_first_pid(self, sid):
+        """
+        Returns the first particle ID of a certain species.
+
+        Arguments:
+            - sid: a(n) (eGFRD) simulator.
+        """ #TODO: Added by wehrens@amolf.nl; please revise
         return iter(self.world.get_particle_ids(sid)).next()
 
     def get_position(self, object):
+        """
+        Function that returns particle position. Can take multiple
+        sort of arguments as input. 
+
+        Arguments:
+            - object: can be:
+                * pid_particle_pair tuple 
+                  (of which pid_particle_pair[0] is _gfrd.ParticleID).
+                * An instance of _gfrd.ParticleID.
+
+                * An instance of _gfrd.Particle.
+                * An instance of _gfrd.SpeciesID.
+                    In the two latter cases, the function returns the 
+                    first ID of the position of the first particle of 
+                    the given species.
+        """ #TODO: Added by wehrens@amolf.nl; please revise
         if type(object) is tuple and type(object[0]) is _gfrd.ParticleID:
             pid = object[0]
         elif type(object) is _gfrd.ParticleID:
diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index 7319b31a..057ed525 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -18,75 +18,87 @@
 import model
 
 def run(outfilename, D_factor, N_B, N_X, N):
-    print outfilename
+    """ 
+    Function that loops over single runs of binding/rebinding
+    simulations. (Plus some overhead code.)
 
+    Arguments:
+        - 
+
+    """ #TODO
+    global DX_factor, V, L, matrix_size   
+
+    print "Printing output to: " + outfilename
+
+    ################# Set some constants 
     radius = 2.5e-9
     sigma = radius * 2
     D = 1e-12
     D_tot = D * 2
 
     tau = sigma**2 / D_tot
-    print 'tau=', tau
 
+    DX_factor = 1
+
+    V = 1e-18 # m^3
+    L = V ** (1.0/3.0) 
+
+    kf = 0.092e-18
+
+    DX = D * DX_factor
+
+    matrix_size = min(max(3, int((9 * (N_X+N_B)) ** (1.0/3.0))), 60)
+    print 'matrix_size=', matrix_size
+
+    # This is the list with steps 
     T_list = [tau * .1, INF]
-    # T_list = [INF] # With this option, the simulation stops immediately
 
+    # Clear the distance output file
+    outfile_r = open(outfilename + '_r_-'+j+'.dat', 'a')
+    outfile_r.close()
+
+    # Open the time output file
     outfile_t = open(outfilename + '_t.dat', 'w')
-    #outfile_r_list = [open(outfilename + '_r_-1.dat', 'w')] 
 
+    ################# Loop through the multiple (N) simulations runs
     for i in range(N):
+
+        # Perform a single simulation run
         r_list, t_list = singlerun(T_list, D_factor, N_B, N_X)
 
+        # Write away time data
         for t in t_list:
             outfile_t.write('%g\n' % t)
-
-        #for j in range(len(r_list)):
-        #    outfile_r_list[j].write('%g\n' % r_list[j])
-
+    
+        # Write away distance data, write data of different 
+        # measurement points to different files. (Ending up
+        # with a list of distances corresponding to measure-
+        # ments at times from T_list.)
+        for j in range(len(r_list)):
+            outfile_r = open(outfilename + '_r_-'+j+'.dat', 'a')
+            outfile_r.write('%g\n' % r_list[j])
+            outfile_r.close()
+
+        # Print to screen.
         print i, r_list, t_list
-        outfile_t.flush()
-        #[outfile_r.flush() for outfile_r in outfile_r_list]
 
+        # Make sure script writes data NOW
+        outfile_t.flush()
 
+    # Close time output file
     outfile_t.close()
-    #[outfile_r.close() for outfile_r in outfile_r_list]
-
-
 
 def singlerun(T_list, D_factor, N_B, N_X):
+    """ 
+    Function that performs one simulation run of binding/
+    rebinding. 
 
-    # 100 nM = 100e-9 * N_A * 100 / m^3 = 6.02e19
-    # V = 1 / 6.02e19 = 1.66e-20 m^3
-    # L = 2.55e-7 m
-
-    # 1 uM = 6.02e20 / m^3
-    # V = 1.66e-21 m^3
-    # L = 1.18e-7
-
-    # ### Define constants
-    DX_factor = 1
-
-    V = 1e-18 # m^3
-    L = V ** (1.0/3.0) 
-
-    matrix_size = min(max(3, int((9 * (N_X+N_B)) ** (1.0/3.0))), 60)
-    print 'matrix_size=', matrix_size
-
-    radius = 2.5e-9
-    sigma = radius * 2
-    r0 = sigma
-    D = 1e-12 * D_factor
-    D_tot = D * 2
-
-    tau = sigma**2 / D_tot
+    Arguments:
+        -
 
-    #kf = 1000 * sigma * D_tot
-    # 1e9 [1 / (M s)] -> 1e9 / 1000 / N_A [m^3 / s]
-    kf = 0.092e-18
-
-    DX = D * DX_factor
+    """ #TODO
 
-    # ### Define model
+    ################# Define the model:
     
     # Create model class
     m = model.ParticleModel(L)
@@ -108,13 +120,13 @@ def singlerun(T_list, D_factor, N_B, N_X):
     r2 = model.create_unbinding_reaction_rule(C, A, B, 1e3)
     m.network_rules.add_reaction_rule(r2)
 
-    # ### Set up simulator
+    ################# Set up simulator
 
     w = gfrdbase.create_world(m, matrix_size)
     nrw = gfrdbase.create_network_rules_wrapper(m)
     s = EGFRDSimulator(w, myrandom.rng, nrw)
 
-    # ### Place particles 
+    ################# Place particles 
 
     # Throw in some X particles and stirr
     if N_X != 0:
@@ -128,14 +140,10 @@ def singlerun(T_list, D_factor, N_B, N_X):
                 s.stop(end_time)
                 break
 
-
+    # Reset simulation, so stirring has no effect on output data
     s.reset()
-    # Removed introduction of network rules here.
-    # s.set_model(m) # IF presence of network rules results in data
-                     # that is not cleaned in reset, this might give 
-                     # problems. Originally, s.set_model(m) would 
-                     # have introduced these rules here.
 
+    # Define positions for particles to place.
     A_pos = [0,0,0]
     B_pos = [(float(A['radius']) + float(B['radius']))+1e-23,0,0]
 
@@ -235,12 +243,15 @@ def singlerun(T_list, D_factor, N_B, N_X):
                 print 'reaction: ', s.t - t_last
                 t_list.append(s.t - t_last)
 
+        """ If it's time to log, then log distance between particles. """
         next_time = s.get_next_time()
         if next_time > next_stop:
             print 'stop', i_T, next_stop
             s.stop(next_stop)
             if len(s.world.get_particle_ids(C.id)) != 0:  #A,B
                 r_list.append(0)
+            # If particles are manifested as A and B, log distance
+            # inbetween.
             else: # C = 0, i.e. there are particles A and B
                 # r_list.append(s.distance_between_particles(A.id, B.id))
                 # If there's only 1 B-particle
@@ -248,11 +259,16 @@ def singlerun(T_list, D_factor, N_B, N_X):
                 particlesB = w.get_particle_ids(B.id)
                 positionA = particlesA[1].position()
                 positionB = particlesB[1].position()
+
+                particle = self.sim.world.get_particle(particle_id)[1]
+
                 r_list.append(w.distance(positionA, positionB))
 
             i_T += 1
             next_stop = T_list[i_T]
         
+        """ If there are no measuring moments on the list any more,
+        stop """
         if next_stop == INF and len(t_list) != 0:
             print 'break', s.t
             break
@@ -270,3 +286,30 @@ def singlerun(T_list, D_factor, N_B, N_X):
         '_' #+ os.environ['SGE_TASK_ID']
     run(outfilename, float(sys.argv[1]), 
         int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4]))
+
+
+
+
+"""
+
+Some additional notes:
+
+    # 100 nM = 100e-9 * N_A * 100 / m^3 = 6.02e19
+    # V = 1 / 6.02e19 = 1.66e-20 m^3
+    # L = 2.55e-7 m
+
+    # 1 uM = 6.02e20 / m^3
+    # V = 1.66e-21 m^3
+    # L = 1.18e-7
+
+"""
+
+
+
+
+
+
+
+
+
+

From e65817df3722e2e6f787082c6d386ebb82beaf9d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 May 2011 17:49:48 +0200
Subject: [PATCH 0039/1541] add execute permission on the sample python scripts
 for easy use

---
 samples/dimer/dimer.py         | 0
 samples/hardbody/plot.py       | 0
 samples/hardbody/run_all.py    | 0
 samples/hardbody/run_single.py | 0
 samples/irreversible/p_irr.py  | 0
 samples/irreversible/plot.py   | 0
 samples/irreversible/run.py    | 0
 7 files changed, 0 insertions(+), 0 deletions(-)
 mode change 100644 => 100755 samples/dimer/dimer.py
 mode change 100644 => 100755 samples/hardbody/plot.py
 mode change 100644 => 100755 samples/hardbody/run_all.py
 mode change 100644 => 100755 samples/hardbody/run_single.py
 mode change 100644 => 100755 samples/irreversible/p_irr.py
 mode change 100644 => 100755 samples/irreversible/plot.py
 mode change 100644 => 100755 samples/irreversible/run.py

diff --git a/samples/dimer/dimer.py b/samples/dimer/dimer.py
old mode 100644
new mode 100755
diff --git a/samples/hardbody/plot.py b/samples/hardbody/plot.py
old mode 100644
new mode 100755
diff --git a/samples/hardbody/run_all.py b/samples/hardbody/run_all.py
old mode 100644
new mode 100755
diff --git a/samples/hardbody/run_single.py b/samples/hardbody/run_single.py
old mode 100644
new mode 100755
diff --git a/samples/irreversible/p_irr.py b/samples/irreversible/p_irr.py
old mode 100644
new mode 100755
diff --git a/samples/irreversible/plot.py b/samples/irreversible/plot.py
old mode 100644
new mode 100755
diff --git a/samples/irreversible/run.py b/samples/irreversible/run.py
old mode 100644
new mode 100755

From ab52a88da1fdbb874141253c626719f227cec613 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 16 May 2011 18:30:44 +0200
Subject: [PATCH 0040/1541] Fixed order of args in on of the 1D-GF
 constructors.

... and made some minor changes to pair.py.
---
 GreensFunction1DAbsAbs.hpp | 12 +++---------
 GreensFunction1DRadAbs.hpp |  8 ++++----
 pair.py                    |  5 ++---
 3 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 0449e966..78be41d2 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -1,5 +1,5 @@
-#if !defined( __FIRSTPASSAGEGREENSFUNCTION1D_HPP )
-#define __FIRSTPASSAGEGREENSFUNCTION1D_HPP
+#if !defined( __GREENSFUNCTION1DABSABS_HPP )
+#define __GREENSFUNCTION1DABSABS_HPP
 
 #include <sstream>
 #include <iostream>
@@ -42,12 +42,6 @@ class GreensFunction1DAbsAbs: public GreensFunction
     // The minimum
     static const int MIN_TERMS = 20;
 
-public:
-    enum EventKind
-    {
-        IV_ESCAPE,
-        IV_REACTION
-    };
 
 public:
     GreensFunction1DAbsAbs(Real D, Real r0, Real sigma, Real a)
@@ -204,4 +198,4 @@ class GreensFunction1DAbsAbs: public GreensFunction
     // This is the time scale of the system, used by drawTime_f
     Real t_scale;
 };
-#endif // __FIRSTPASSAGEGREENSFUNCTION1D_HPP
+#endif // __GREENSFUNCTION1DABSABS_HPP
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 07032333..2e1836b6 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -1,5 +1,5 @@
-#if !defined( __FIRSTPASSAGEGREENSFUNCTION1DRAD_HPP )
-#define __FIRSTPASSAGEGREENSFUNCTION1DRAD_HPP
+#if !defined( __GREENSFUNCTION1DRADABS_HPP )
+#define __GREENSFUNCTION1DRADABS_HPP
 
 #include <sstream>
 #include <iostream>
@@ -48,7 +48,7 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     // The constructor is overloaded and can be called with or without drift v
     // copy constructor including drift variable v
-    GreensFunction1DRadAbs(Real D, Real k, Real v, Real r0, Real sigma, Real a)
+    GreensFunction1DRadAbs(Real D, Real v, Real k, Real r0, Real sigma, Real a)
 	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
 	// do nothing
@@ -234,4 +234,4 @@ class GreensFunction1DRadAbs: public GreensFunction
     // This is the time scale of the system.
     Real t_scale;
 };
-#endif // __FIRSTPASSAGEGREENSFUNCTION1DRAD_HPP
+#endif // __GREENSFUNCTION1DRADABS_HPP
diff --git a/pair.py b/pair.py
index f9e2643a..5af3f211 100644
--- a/pair.py
+++ b/pair.py
@@ -89,11 +89,10 @@ def get_v_tot(self):
         return self.single2.pid_particle_pair[1].v - \
                self.single1.pid_particle_pair[1].v
     v_tot = property(get_v_tot)
-
-    v_r = 0 # Todo.
+    
+    v_r = property(get_v_tot)
 
     def get_v_R(self):
-        return 0 # Todo.
         return (self.single1.pid_particle_pair[1].v * 
                 self.single2.pid_particle_pair[1].D +
                 self.single2.pid_particle_pair[1].v *

From a137987e54aa19c3d23be081ae2f3f2943db4b8a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 16 May 2011 18:31:37 +0200
Subject: [PATCH 0041/1541] Added scalable resolution for cyl. surfaces in
 visualisation

---
 visualization/pipeline.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/visualization/pipeline.py b/visualization/pipeline.py
index c33c092f..a1999abd 100644
--- a/visualization/pipeline.py
+++ b/visualization/pipeline.py
@@ -330,6 +330,7 @@ def rebuild(self):
                 cylindrical_surfaces = \
                     self.add_tensor_glyph(cylindrical_surface_data, 'Cylinder',
                                           name='Cylindrical Surfaces',
+                                          resolution=RESOLUTION,
                                           scale=HELIX_RADIUS_SCALE_FACTOR) 
 
                 rep4 = self.show(cylindrical_surfaces)

From a6c2a71d7149b07a1b1775d0375f4115cef17115 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 17 May 2011 00:30:44 +0800
Subject: [PATCH 0042/1541] Fixed order of args in on of the 1D-GF
 constructors.

... and made some minor changes to pair.py.
---
 GreensFunction1DAbsAbs.hpp | 12 +++---------
 GreensFunction1DRadAbs.hpp |  8 ++++----
 pair.py                    |  5 ++---
 3 files changed, 9 insertions(+), 16 deletions(-)

diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 0449e966..78be41d2 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -1,5 +1,5 @@
-#if !defined( __FIRSTPASSAGEGREENSFUNCTION1D_HPP )
-#define __FIRSTPASSAGEGREENSFUNCTION1D_HPP
+#if !defined( __GREENSFUNCTION1DABSABS_HPP )
+#define __GREENSFUNCTION1DABSABS_HPP
 
 #include <sstream>
 #include <iostream>
@@ -42,12 +42,6 @@ class GreensFunction1DAbsAbs: public GreensFunction
     // The minimum
     static const int MIN_TERMS = 20;
 
-public:
-    enum EventKind
-    {
-        IV_ESCAPE,
-        IV_REACTION
-    };
 
 public:
     GreensFunction1DAbsAbs(Real D, Real r0, Real sigma, Real a)
@@ -204,4 +198,4 @@ class GreensFunction1DAbsAbs: public GreensFunction
     // This is the time scale of the system, used by drawTime_f
     Real t_scale;
 };
-#endif // __FIRSTPASSAGEGREENSFUNCTION1D_HPP
+#endif // __GREENSFUNCTION1DABSABS_HPP
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 07032333..2e1836b6 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -1,5 +1,5 @@
-#if !defined( __FIRSTPASSAGEGREENSFUNCTION1DRAD_HPP )
-#define __FIRSTPASSAGEGREENSFUNCTION1DRAD_HPP
+#if !defined( __GREENSFUNCTION1DRADABS_HPP )
+#define __GREENSFUNCTION1DRADABS_HPP
 
 #include <sstream>
 #include <iostream>
@@ -48,7 +48,7 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     // The constructor is overloaded and can be called with or without drift v
     // copy constructor including drift variable v
-    GreensFunction1DRadAbs(Real D, Real k, Real v, Real r0, Real sigma, Real a)
+    GreensFunction1DRadAbs(Real D, Real v, Real k, Real r0, Real sigma, Real a)
 	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
 	// do nothing
@@ -234,4 +234,4 @@ class GreensFunction1DRadAbs: public GreensFunction
     // This is the time scale of the system.
     Real t_scale;
 };
-#endif // __FIRSTPASSAGEGREENSFUNCTION1DRAD_HPP
+#endif // __GREENSFUNCTION1DRADABS_HPP
diff --git a/pair.py b/pair.py
index f9e2643a..5af3f211 100644
--- a/pair.py
+++ b/pair.py
@@ -89,11 +89,10 @@ def get_v_tot(self):
         return self.single2.pid_particle_pair[1].v - \
                self.single1.pid_particle_pair[1].v
     v_tot = property(get_v_tot)
-
-    v_r = 0 # Todo.
+    
+    v_r = property(get_v_tot)
 
     def get_v_R(self):
-        return 0 # Todo.
         return (self.single1.pid_particle_pair[1].v * 
                 self.single2.pid_particle_pair[1].D +
                 self.single2.pid_particle_pair[1].v *

From c5bbe0da9a3ba9c3f4569d8f56a6db22830c03e9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 17 May 2011 00:31:37 +0800
Subject: [PATCH 0043/1541] Added scalable resolution for cyl. surfaces in
 visualisation

---
 visualization/pipeline.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/visualization/pipeline.py b/visualization/pipeline.py
index c33c092f..a1999abd 100644
--- a/visualization/pipeline.py
+++ b/visualization/pipeline.py
@@ -330,6 +330,7 @@ def rebuild(self):
                 cylindrical_surfaces = \
                     self.add_tensor_glyph(cylindrical_surface_data, 'Cylinder',
                                           name='Cylindrical Surfaces',
+                                          resolution=RESOLUTION,
                                           scale=HELIX_RADIUS_SCALE_FACTOR) 
 
                 rep4 = self.show(cylindrical_surfaces)

From e81c7c7dc0c323371b917fc848955d3228255bc4 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 16 May 2011 19:02:27 +0200
Subject: [PATCH 0044/1541] Almost entirely have run.py operational. Will fix
 rest next few days. ~MW

---
 doc/interface_functions.aux |  26 ++--
 doc/interface_functions.log | 230 ++++++++++++++++++++----------------
 doc/interface_functions.tex |   3 +-
 doc/interface_functions.toc |  26 ++--
 samples/rebind/run.py       | 123 +++++++++++--------
 5 files changed, 229 insertions(+), 179 deletions(-)

diff --git a/doc/interface_functions.aux b/doc/interface_functions.aux
index 37ee8f85..95f295ef 100644
--- a/doc/interface_functions.aux
+++ b/doc/interface_functions.aux
@@ -9,10 +9,10 @@
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.2}Handling objects (surfaces, cylinders, etc)}{9}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.4}Obtaining particle information}{10}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Functions from \texttt  {egfrd.py}}{10}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{10}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.4}Obtaining information about particles and species}{10}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Functions from \texttt  {egfrd.py}}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{11}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{12}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.3}Get data}{12}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.4}Get position and distance data}{12}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.5}Additional functions}{13}}
@@ -22,19 +22,19 @@
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{16}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Functions from \texttt  {utils.py}}{17}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{17}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{17}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{21}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{22}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{22}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{22}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{22}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{18}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{22}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{23}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.4}\texttt  {multi.py}, \texttt  {pair.py}, \texttt  {single.py}}{23}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.5}\texttt  {myrandom.py}}{23}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.6}\texttt  {make\_cjy\_table.py.py}, \texttt  {make\_sjy\_table.py.py}}{23}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {2.7}Function from module \texttt  {logger.py}}{23}}
 \@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{23}}
-\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{23}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{24}}
+\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{24}}
 \@writefile{toc}{\contentsline {section}{\numberline {4}On C++ data structures}{24}}
 \@writefile{toc}{\contentsline {subsection}{\numberline {4.1}SpeciesInfo}{24}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}Particle}{24}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}Particle}{25}}
diff --git a/doc/interface_functions.log b/doc/interface_functions.log
index a8cbf220..2916efdc 100644
--- a/doc/interface_functions.log
+++ b/doc/interface_functions.log
@@ -1,4 +1,4 @@
-This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  16 MAY 2011 16:26
+This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  16 MAY 2011 17:18
 entering extended mode
  %&-line parsing enabled.
 **interface_functions.tex
@@ -217,13 +217,13 @@ Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
 f magnitude:[] 
  []
 
-
+[5]
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
 []    \OT1/cmtt/m/n/10 There is no distinction between an intrinsic and an over
 all reaction[] 
  []
 
-[5]
+
 Overfull \hbox (32.9967pt too wide) in paragraph at lines 241--241
 []            \OT1/cmtt/m/n/10 reaction rate. Units: per second. (Rough order o
 f magnitude:[] 
@@ -325,13 +325,13 @@ Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
 gh order of[] 
  []
 
-
+[7]
 Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
 []    \OT1/cmtt/m/n/10 overall reaction rate (koff) for this reaction rule to a
 n intrinsic[] 
  []
 
-[7]
+
 Overfull \hbox (11.99689pt too wide) in paragraph at lines 332--332
 []    \OT1/cmtt/m/n/10 reaction rate (kd) with the function utils.k_d(koff, kon
 , kD) or[] 
@@ -458,395 +458,419 @@ Overfull \hbox (6.74693pt too wide) in paragraph at lines 437--437
  []
 
 [9]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 505--505
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 499--499
+[]        \OT1/cmtt/m/n/10 Function that returns particle position. Can take mu
+ltiple[] 
+ []
+
+[10]
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 499--499
+[]                  \OT1/cmtt/m/n/10 (of which pid_particle_pair[0] is _gfrd.Pa
+rticleID).[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 499--499
+[]                    \OT1/cmtt/m/n/10 In the two latter cases, the function re
+turns the[] 
+ []
+
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 499--499
+[]                    \OT1/cmtt/m/n/10 first ID of the position of the first pa
+rticle of[] 
+ []
+
+
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 524--524
 []    \OT1/cmtt/m/n/10 def __init__(self, world, rng=myrandom.rng, network_rule
 s=None):[] 
  []
 
-[10]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 505--505
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 524--524
 []                \OT1/cmtt/m/n/10 a random number generator. By default myrand
 om.rng is[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 505--505
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 524--524
 []                \OT1/cmtt/m/n/10 used, which uses Mersenne Twister from the G
 SL library.[] 
  []
 
 
-Overfull \hbox (53.99652pt too wide) in paragraph at lines 505--505
+Overfull \hbox (53.99652pt too wide) in paragraph at lines 524--524
 []                \OT1/cmtt/m/n/10 you don't need to use this, for backward com
 patibility only.[] 
  []
 
 
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 513--514
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 532--533
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
 
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 536--536
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 555--555
 []        \OT1/cmtt/m/n/10 asynchronously. This method bursts all protective do
 mains and[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 536--536
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 555--555
 []                \OT1/cmtt/m/n/10 the time at which to synchronize the particl
 es. Usually[] 
  []
 
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 536--536
+[11]
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 555--555
 []                \OT1/cmtt/m/n/10 you will want to use the current time of the
  simulator:[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 536--536
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 555--555
 []        \OT1/cmtt/m/n/10 This method is called stop because it is usually cal
 led at the[] 
  []
 
 
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 536--536
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 555--555
 []        \OT1/cmtt/m/n/10 end of a simulation. It is possible to call this met
 hod at an[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 536--536
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 555--555
 []        \OT1/cmtt/m/n/10 earlier time. For example the Logger module does thi
 s, because[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 536--536
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 555--555
 []        \OT1/cmtt/m/n/10 it needs to know the positions of the particles at e
 ach log[] 
  []
 
 
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 537--538
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 556--557
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
 
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 548--549
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 567--568
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
-[11]
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 560--560
+
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 579--579
 []    \OT1/cmtt/m/n/10 This function resets the "records" of the simulator. Thi
 s means[] 
  []
 
 
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 560--560
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 579--579
 []    \OT1/cmtt/m/n/10 the simulator time is reset, the step counter is reset, 
 events[] 
  []
 
 
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 561--562
+Overfull \hbox (41.35085pt too wide) in paragraph at lines 580--581
 \OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
 cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
  []
 
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 605--605
+[12]
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 614--614
 []\OT1/cmtt/m/n/10 def get_closest_surface_within_radius(world, pos, radius, ig
 nore):[] 
  []
 
-[12] [13]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 704--704
+[13]
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 713--713
 []    \OT1/cmtt/m/n/10 """ Return a generator (using "yield") to loop over (pid
 , particle).[] 
  []
 
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 719--719
+[14]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 728--728
 []            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
 pecified,[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 719--719
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 728--728
 []            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
 e returned.[] 
  []
 
-[14]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 734--734
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 743--743
 []            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
 pecified,[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 734--734
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 743--743
 []            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
 e returned.[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 763--763
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 772--772
 []            \OT1/cmtt/m/n/10 (Species name, number of particles)-pairs will b
 e returned.[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 779--779
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 788--788
 []    \OT1/cmtt/m/n/10 """Return a string containing the number of particles of
  a certain[] 
  []
 
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 779--779
+[15]
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 788--788
 []            \OT1/cmtt/m/n/10 a string of (Species name, number of particles)-
 pairs will[] 
  []
 
-[15]
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 791--791
+
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 800--800
 []    \OT1/cmtt/m/n/10 """Return an iterator over the protective domains in the
  simulator.[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 820--820
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 829--829
 []    \OT1/cmtt/m/n/10 """Return three lists with all the reaction rules define
 d in the[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 820--820
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 829--829
 []        \OT1/cmtt/m/n/10 - reaction rules between two reactants with a reacti
 on rate[] 
  []
 
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 828--828
+[16]
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 837--837
 []    \OT1/cmtt/m/n/10 ReactionRule.__str__ would be good, but we are actually 
 getting a[] 
  []
 
 
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 840--840
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 849--849
 []    \OT1/cmtt/m/n/10 """Return a formatted string containing all the reaction
  rules[] 
  []
 
-[16]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 879--879
+
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 888--888
 []    \OT1/cmtt/m/n/10 """Return True if a and b are equal, subject to given to
 lerances.[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 879--879
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 888--888
 []    \OT1/cmtt/m/n/10 relative tolerance multipied by this typical value, and 
 will be[] 
  []
 
 
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 879--879
+Overfull \hbox (27.74675pt too wide) in paragraph at lines 888--888
 []    \OT1/cmtt/m/n/10 """Return True if a is greater than b, subject to given 
 tolerances.[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 879--879
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 888--888
 []    \OT1/cmtt/m/n/10 """Return True if a is less than b, subject to given tol
 erances.[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 879--879
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 888--888
 []    \OT1/cmtt/m/n/10 """Return True if a is greater or equal than b, subject 
 to given[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 879--879
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 888--888
 []    \OT1/cmtt/m/n/10 """Return True if a is less than or equal than b, subjec
 t to given[] 
  []
 
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 919--919
+[17]
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 928--928
 []    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per molar per sec
 ond' to[] 
  []
 
-[17]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 919--919
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 928--928
 []    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per micromolar pe
 r second' to[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 919--919
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 928--928
 []    \OT1/cmtt/m/n/10 """Convert a concentration from units 'micromolar' to un
 its 'per[] 
  []
 
 
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 """Calculate the 'pseudo-'reaction rate (kD) caused by d
 iffusion.[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 kD is equal to 1 divided by the time it takes for two pa
 rticles to[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 meet each other by diffusion. It is needed when converti
 ng from[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 an intrinsic reaction rate to an overall reaction rates 
 or vice[] 
  []
 
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
+[18]
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
 []            \OT1/cmtt/m/n/10 the diffusion constant of particle A plus the di
 ffusion[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
 []            \OT1/cmtt/m/n/10 the radius of particle A plus the radius of part
 icle B.[] 
  []
 
-[18]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (kon) for a binding/
 annihilation[] 
  []
 
 
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
 []            \OT1/cmtt/m/n/10 the overall reaction rate for the reaction rule.
  Units:[] 
  []
 
 
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
 ing reaction[] 
  []
 
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
+[19]
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 This one is a bit tricky. We consider reaction rules wit
 h only 1[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 reactant. In case there is only 1 product also, no conve
 rsion in[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 necessary. But when the reaction rule has 2 products, we
  need to[] 
  []
 
-[19]
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 1074--1074
+
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 1083--1083
 []            \OT1/cmtt/m/n/10 the overall reaction rate for the unbinding reac
 tion rule.[] 
  []
 
 
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
 []            \OT1/cmtt/m/n/10 the overall reaction rate for the reverse reacti
 on rule.[] 
  []
 
 
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
 ing reaction[] 
  []
 
 
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (17.24684pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 Similar to the function k_d(), but expects an intrinsic 
 rate (ka)[] 
  []
 
 
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (22.4968pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 instead of an overall rate (kon) for the reversed reacti
 on rule as[] 
  []
 
-
-Overfull \hbox (38.24666pt too wide) in paragraph at lines 1074--1074
+[20]
+Overfull \hbox (38.24666pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (ka) for a binding
 /annihilation[] 
  []
 
-[20]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
+
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
 ing reaction[] 
  []
 
 
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
 ing reaction[] 
  []
 
 
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 1074--1074
+Overfull \hbox (1.49698pt too wide) in paragraph at lines 1083--1083
 []    \OT1/cmtt/m/n/10 Similar to the function k_off(), but expects an intrinsi
 c rate[] 
  []
 
 [21]
 LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <10> not available
-(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 1134.
+(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 1143.
 
- [22]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1177--1177
+ [22] [23]
+Overfull \hbox (11.99689pt too wide) in paragraph at lines 1186--1186
 []    \OT1/cmtt/m/n/10 def __init__(self, logname='log', directory='data', comm
 ent=''):[] 
  []
 
-[23]
-Overfull \hbox (374.24373pt too wide) in paragraph at lines 1216--1216
+
+Overfull \hbox (374.24373pt too wide) in paragraph at lines 1225--1225
 []  \OT1/cmtt/m/n/10 SpeciesInfo (identifier_type const &id, D_type const &D=0.
 , length_type const &r=0., structure_id_type const &s="", v_type const &v=0.)[]
  
  []
 
 
-Overfull \hbox (64.49643pt too wide) in paragraph at lines 1216--1216
+Overfull \hbox (64.49643pt too wide) in paragraph at lines 1225--1225
 []\OT1/cmtt/m/n/10 template<typename Tid_, typename TD_, typename Tlen_, typena
 me Tstructure_id_>[] 
  []
 
-[24] (./interface_functions.aux) ) 
+[24] [25] (./interface_functions.aux) ) 
 Here is how much of TeX's memory you used:
  508 strings out of 95086
  7761 string characters out of 1183255
@@ -855,18 +879,18 @@ Here is how much of TeX's memory you used:
  8578 words of font info for 31 fonts, out of 1200000 for 2000
  28 hyphenation exceptions out of 8191
  23i,8n,20p,323b,243s stack positions out of 5000i,500n,6000p,200000b,5000s
-</usr/share/texmf-texlive/fonts/type1/bluesky
-/cm/cmbx10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmbx12.pfb></us
-r/share/texmf-texlive/fonts/type1/bluesky/cm/cmr10.pfb></usr/share/texmf-texliv
-e/fonts/type1/bluesky/cm/cmr12.pfb></usr/share/texmf-texlive/fonts/type1/bluesk
-y/cm/cmr17.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr6.pfb></usr/
-share/texmf-texlive/fonts/type1/bluesky/cm/cmr7.pfb></usr/share/texmf-texlive/f
-onts/type1/bluesky/cm/cmr8.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm
-/cmti10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt10.pfb></usr/s
-hare/texmf-texlive/fonts/type1/bluesky/cm/cmtt12.pfb>
-Output written on interface_functions.pdf (24 pages, 109202 bytes).
+</usr/share/texmf-texlive/fonts/type1/bl
+uesky/cm/cmbx10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmbx12.pfb
+></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr10.pfb></usr/share/texmf-t
+exlive/fonts/type1/bluesky/cm/cmr12.pfb></usr/share/texmf-texlive/fonts/type1/b
+luesky/cm/cmr17.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr6.pfb><
+/usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr7.pfb></usr/share/texmf-texl
+ive/fonts/type1/bluesky/cm/cmr8.pfb></usr/share/texmf-texlive/fonts/type1/blues
+ky/cm/cmti10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt10.pfb></
+usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt12.pfb>
+Output written on interface_functions.pdf (25 pages, 110108 bytes).
 PDF statistics:
- 123 PDF objects out of 1000 (max. 8388607)
+ 127 PDF objects out of 1000 (max. 8388607)
  0 named destinations out of 1000 (max. 131072)
  1 words of extra memory for PDF output out of 10000 (max. 10000000)
 
diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
index 5a61b356..c0d8983d 100644
--- a/doc/interface_functions.tex
+++ b/doc/interface_functions.tex
@@ -438,7 +438,6 @@ \subsubsection{Adding particles}
 
 \subsubsection{Obtaining information about particles and species}
 
-\begin{verbatim}
 \begin{verbatim}
 
     def get_species(self):
@@ -1228,4 +1227,4 @@ \subsection{Particle}
 
 The particle information is held by a class in the C++ code. A single particle is 
 
-\end{document}
+\end{document}
\ No newline at end of file
diff --git a/doc/interface_functions.toc b/doc/interface_functions.toc
index 9ac91ea3..aaa7b0df 100644
--- a/doc/interface_functions.toc
+++ b/doc/interface_functions.toc
@@ -8,10 +8,10 @@
 \contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}
 \contentsline {subsubsection}{\numberline {2.2.2}Handling objects (surfaces, cylinders, etc)}{9}
 \contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}
-\contentsline {subsubsection}{\numberline {2.2.4}Obtaining particle information}{10}
-\contentsline {subsection}{\numberline {2.3}Functions from \texttt {egfrd.py}}{10}
-\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{10}
-\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{11}
+\contentsline {subsubsection}{\numberline {2.2.4}Obtaining information about particles and species}{10}
+\contentsline {subsection}{\numberline {2.3}Functions from \texttt {egfrd.py}}{11}
+\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{11}
+\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{12}
 \contentsline {subsubsection}{\numberline {2.3.3}Get data}{12}
 \contentsline {subsubsection}{\numberline {2.3.4}Get position and distance data}{12}
 \contentsline {subsubsection}{\numberline {2.3.5}Additional functions}{13}
@@ -21,19 +21,19 @@
 \contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{16}
 \contentsline {subsection}{\numberline {2.5}Functions from \texttt {utils.py}}{17}
 \contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{17}
-\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{17}
-\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{21}
-\contentsline {subsection}{\numberline {2.6}Notes on other files}{22}
-\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{22}
-\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{22}
-\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{22}
+\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{18}
+\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{22}
+\contentsline {subsection}{\numberline {2.6}Notes on other files}{23}
+\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{23}
+\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{23}
+\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{23}
 \contentsline {subsubsection}{\numberline {2.6.4}\texttt {multi.py}, \texttt {pair.py}, \texttt {single.py}}{23}
 \contentsline {subsubsection}{\numberline {2.6.5}\texttt {myrandom.py}}{23}
 \contentsline {subsubsection}{\numberline {2.6.6}\texttt {make\_cjy\_table.py.py}, \texttt {make\_sjy\_table.py.py}}{23}
 \contentsline {subsection}{\numberline {2.7}Function from module \texttt {logger.py}}{23}
 \contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{23}
-\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{23}
-\contentsline {section}{\numberline {3}Todo}{23}
+\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{24}
+\contentsline {section}{\numberline {3}Todo}{24}
 \contentsline {section}{\numberline {4}On C++ data structures}{24}
 \contentsline {subsection}{\numberline {4.1}SpeciesInfo}{24}
-\contentsline {subsection}{\numberline {4.2}Particle}{24}
+\contentsline {subsection}{\numberline {4.2}Particle}{25}
diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index 057ed525..31d37fd9 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -4,9 +4,9 @@
 """
 See README for a description
 
-# D_factor N_B N_X N
+# [N_B] [N_X] [N]
 
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py 1 1 100 10
+LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py 1 100 10
 
 """
 
@@ -17,16 +17,23 @@
 import gfrdbase
 import model
 
-def run(outfilename, D_factor, N_B, N_X, N):
+def run(outfilename, N_B, N_X, T_list, N):
     """ 
     Function that loops over single runs of binding/rebinding
     simulations. (Plus some overhead code.)
 
     Arguments:
-        - 
+        - outfilename:  This string can be found back in the
+                        output filename.
+        - T_list:       List of times at which distance between 
+                        particles is evaluated and logged.
+        - N_B:          Number of instances ("molecules") of 
+                        particle B.
+        - N_X:          Number of instances ("molecules") of 
+                        particle X.
 
-    """ #TODO
-    global DX_factor, V, L, matrix_size   
+    """ 
+    global DX_factor, V, L, matrix_size, D, radius, DX, kf, tau   
 
     print "Printing output to: " + outfilename
 
@@ -50,12 +57,15 @@ def run(outfilename, D_factor, N_B, N_X, N):
     matrix_size = min(max(3, int((9 * (N_X+N_B)) ** (1.0/3.0))), 60)
     print 'matrix_size=', matrix_size
 
-    # This is the list with steps 
-    T_list = [tau * .1, INF]
+    # Overrides the T_list input
+    T_list = [tau*0.1, tau, tau*10, tau * 100, tau * 1000, INF]
+    T_list = range(0, int(tau*100000), 100)
+    T_list.append(INF)
 
     # Clear the distance output file
-    outfile_r = open(outfilename + '_r_-'+j+'.dat', 'a')
-    outfile_r.close()
+    for j in T_list:
+        outfile_r = open(outfilename + '_r_-'+str(j)+'.dat', 'a')
+        outfile_r.close()
 
     # Open the time output file
     outfile_t = open(outfilename + '_t.dat', 'w')
@@ -64,7 +74,8 @@ def run(outfilename, D_factor, N_B, N_X, N):
     for i in range(N):
 
         # Perform a single simulation run
-        r_list, t_list = singlerun(T_list, D_factor, N_B, N_X)
+        print "###### Run " + str(i) + "."
+        r_list, t_list = singlerun(T_list, N_B, N_X)
 
         # Write away time data
         for t in t_list:
@@ -75,12 +86,13 @@ def run(outfilename, D_factor, N_B, N_X, N):
         # with a list of distances corresponding to measure-
         # ments at times from T_list.)
         for j in range(len(r_list)):
-            outfile_r = open(outfilename + '_r_-'+j+'.dat', 'a')
-            outfile_r.write('%g\n' % r_list[j])
+            outfile_r = open(outfilename + '_r_-' + str(T_list[j]) +'.dat', 'a')
+            outfile_r.write(str(r_list[j]) + '\n')
             outfile_r.close()
 
         # Print to screen.
-        print i, r_list, t_list
+        print "* Output: t_list=" + str(t_list)
+        print "* Output: r_list=" + str(r_list)
 
         # Make sure script writes data NOW
         outfile_t.flush()
@@ -88,15 +100,19 @@ def run(outfilename, D_factor, N_B, N_X, N):
     # Close time output file
     outfile_t.close()
 
-def singlerun(T_list, D_factor, N_B, N_X):
+def singlerun(T_list, N_B, N_X):
     """ 
     Function that performs one simulation run of binding/
     rebinding. 
 
     Arguments:
-        -
-
-    """ #TODO
+        - T_list:       List of times at which distance between 
+                        particles is evaluated and logged.
+        - N_B:          Number of instances ("molecules") of 
+                        particle B.
+        - N_X:          Number of instances ("molecules") of 
+                        particle X.
+    """ 
 
     ################# Define the model:
     
@@ -159,20 +175,21 @@ def singlerun(T_list, D_factor, N_B, N_X):
           leads to infinite loop)
         - 
 
+    """#TODO 
+    """This code doesn't function properly, because you want to clear 
+    particles within a certain radius.. Now you can be removing particles 
+    that after bursting are not in the area anymore, but whose bursted 
+    domains were.
+
+    After bursting you should just check whether something is within the radius.
+
     Perhaps it would be more easy to just place all the particles at
     the beginning, but give A and B initially a diffusion constant of
     0, then stirr, and then set the diffusion constant to their
-    desired values..
-    
-    """
-    print "Started clearing.."
+    desired values.."""
+
     while 1:
-        #TODO this code doesn't function properly, because you want to clear 
-        # particles within a certain radius.. Now you can be removing particles 
-        # that after bursting are not in the area anymore, but whose bursted 
-        # domains were.
 
-        # After bursting you should just check whether something is within the radius.
 
         #pp = s.get_particles_within_radius(A_pos, float(A['radius']))
         dd = s.clear_volume(A_pos, float(A['radius'])) # returns a list of 
@@ -184,7 +201,7 @@ def singlerun(T_list, D_factor, N_B, N_X):
         for d in dd:
             for p in d.particle_id_pair:
                 s.remove_particle(p)
-                print "Removing particle.."
+                print "* Removing particle to make space for A.."
         s.throw_in_particles(X, len(pp), box1)
 
     place_particle(w, A, A_pos)
@@ -200,23 +217,23 @@ def singlerun(T_list, D_factor, N_B, N_X):
         for d in dd:
             for p in d.particle_id_pair:
                 s.remove_particle(p)
-                print "Removing particle.."
+                print "* Removing particle to make space for B.."
         s.throw_in_particles(X, len(pp), box1)
 
     place_particle(w, B, B_pos) 
-    print "Finished placing particles A & B.."
 
     # Place rest of B at random positions
     if N_B > 1:
-        s.throw_in_particles(B, N_B-1, box1)
+        gfrdbase.throw_in_particles(w, B, N_B-1)
 
+    # Create some vars and perform first simulation step
     r_list = []
     t_list = []
     t_last = 0
 
     s.step()
 
-    next_stop = T_list[0] # In this case T_list[0] equals infinity
+    next_stop = T_list[0] 
 
     i_T = 0
 
@@ -235,42 +252,50 @@ def singlerun(T_list, D_factor, N_B, N_X):
               current time (s.t) and last reaction time (t_last).
         """
         if s.last_reaction: # aka if there was a reaction
-            print s.last_reaction
+            print "* Reaction detected at: " + str(s.last_reaction)
             if len(s.world.get_particle_ids(C.id)) == 0:  #A,B
-                print 'set t_last', s.t
+                print '    - set t_last', str(s.t)
                 t_last = s.t  # set t_last
             else:    # C
-                print 'reaction: ', s.t - t_last
+                print '    - reaction: ', str(s.t - t_last)
                 t_list.append(s.t - t_last)
 
         """ If it's time to log, then log distance between particles. """
         next_time = s.get_next_time()
         if next_time > next_stop:
-            print 'stop', i_T, next_stop
+            print '* Measuring distances at ', str(i_T), str(next_stop)
             s.stop(next_stop)
+            print '* stopped'
+            # If there is a particle C, the distance is "0".
             if len(s.world.get_particle_ids(C.id)) != 0:  #A,B
                 r_list.append(0)
             # If particles are manifested as A and B, log distance
             # inbetween.
             else: # C = 0, i.e. there are particles A and B
-                # r_list.append(s.distance_between_particles(A.id, B.id))
-                # If there's only 1 B-particle
-                particlesA = w.get_particle_ids(A.id)
-                particlesB = w.get_particle_ids(B.id)
-                positionA = particlesA[1].position()
-                positionB = particlesB[1].position()
 
-                particle = self.sim.world.get_particle(particle_id)[1]
-
-                r_list.append(w.distance(positionA, positionB))
+                # Calculate distances:
+                A_pos = s.get_position(A.id)
+                distance_list = []
+                # If there are >1 B particles, we want to log all   
+                # distances seperately, hence the loop:
+                for particle_id in w.get_particle_ids(B.id):
+                    B_pos = s.get_position(particle_id)
+                    distance = w.distance(A_pos, B_pos)
+                    distance_list.append(distance)
+                    print "* Measured distance = " + str(distance)
+                # Write list to distances table
+                r_list.append(distance_list)
 
             i_T += 1
             next_stop = T_list[i_T]
+            print "* Done, returning to simulation loop."
         
         """ If there are no measuring moments on the list any more,
         stop """
-        if next_stop == INF and len(t_list) != 0:
-            print 'break', s.t
+        if (next_stop == INF):            
+            print '* Break at ', str(s.t)
+            if (len(t_list) == 0):
+                t_list.append(float('nan'))            
             break
 
         s.step()
@@ -282,10 +307,12 @@ def singlerun(T_list, D_factor, N_B, N_X):
 
     import os
 
+    T_list = eval(sys.argv[3])
+
     outfilename = 'data/rebind_' + '_'.join(sys.argv[1:4]) +\
         '_' #+ os.environ['SGE_TASK_ID']
     run(outfilename, float(sys.argv[1]), 
-        int(sys.argv[2]), int(sys.argv[3]), int(sys.argv[4]))
+        int(sys.argv[2]), T_list, int(sys.argv[4]))
 
 
 

From 3667d4f0d72c05232c3bc1b5cdb76fc4fbe36c76 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 17 May 2011 12:16:34 +0200
Subject: [PATCH 0045/1541] Added get_v and set_v to the Python bindings for
 the Particle object

So now something like particle1.pid_particle_pair[1].v can be called.
---
 binding/Particle.hpp | 32 ++++++++++++++++++++++++++++----
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/binding/Particle.hpp b/binding/Particle.hpp
index d8aff859..dfc07ef7 100644
--- a/binding/Particle.hpp
+++ b/binding/Particle.hpp
@@ -232,6 +232,20 @@ class ParticleWrapper
         return 0;
     }
 
+    static PyObject* get_v(ParticleWrapper* self)
+    {
+        return PyFloat_FromDouble(self->impl_.v());
+    }
+
+    static int set_v(ParticleWrapper* self, PyObject* val, void *)
+    {
+        const double tmp(PyFloat_AsDouble(val));
+        if (PyErr_Occurred())
+            return -1;
+        self->impl_.v() = tmp;
+        return 0;
+    }
+
     static PyObject* get_sid(ParticleWrapper* self)
     {
         return boost::python::incref(
@@ -292,7 +306,7 @@ class ParticleWrapper
 
     static PyObject* __sq_item__(PyObject *self, Py_ssize_t idx)
     {
-        if (idx < 0 || idx >= 4)
+        if (idx < 0 || idx >= 5)
         {
             PyErr_SetString(PyExc_IndexError, "index out of range");
             return NULL;
@@ -306,7 +320,9 @@ class ParticleWrapper
             return get_radius(reinterpret_cast<ParticleWrapper*>(self));
         case 2:
             return get_D(reinterpret_cast<ParticleWrapper*>(self));
-        case 3:
+	case 3:
+            return get_v(reinterpret_cast<ParticleWrapper*>(self));
+        case 4:
             return get_sid(reinterpret_cast<ParticleWrapper*>(self));
         }
         return NULL; // never get here
@@ -314,7 +330,7 @@ class ParticleWrapper
 
     static int __sq_ass_item__(PyObject *self, Py_ssize_t idx, PyObject *val)
     {
-        if (idx < 0 || idx >= 4)
+        if (idx < 0 || idx >= 5)
         {
             PyErr_SetString(PyExc_IndexError, "index out of range");
             return -1;
@@ -328,7 +344,9 @@ class ParticleWrapper
             return set_radius(reinterpret_cast<ParticleWrapper*>(self), val, 0);
         case 2:
             return set_D(reinterpret_cast<ParticleWrapper*>(self), val, 0);
-        case 3:
+	case 3:
+            return set_v(reinterpret_cast<ParticleWrapper*>(self), val, 0);
+        case 4:
             return set_sid(reinterpret_cast<ParticleWrapper*>(self), val, 0);
         }
 
@@ -429,6 +447,12 @@ PyGetSetDef ParticleWrapper<Timpl_>::__getsets__[] = {
         (setter)ParticleWrapper::set_D,
         const_cast<char*>("")
     },
+    {
+        const_cast<char*>("v"),
+        (getter)ParticleWrapper::get_v,
+        (setter)ParticleWrapper::set_v,
+        const_cast<char*>("")
+    },
     {
         const_cast<char*>("sid"),
         (getter)ParticleWrapper::get_sid,

From 58c287b93274937a14564803c9bc1e40748c5f67 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 17 May 2011 12:17:48 +0200
Subject: [PATCH 0046/1541] Fixed cosmetics: docstrings/comment style and
 trashed redundant files.

Thomas Meidema (Thomie) pointed out that functions that are
not intended for public use shouldn't have docstrings. Since
comments are helpfull though, functions not intended for
public use can have comments in blockquotes.

Tried to fix above where I messed it up.

~MW
---
 doc/interface_functions.aux |  40 --
 doc/interface_functions.log | 896 ------------------------------------
 doc/interface_functions.tex |  51 +-
 doc/interface_functions.toc |  39 --
 dumper.py                   |  80 ++--
 gfrdbase.py                 |   2 +-
 6 files changed, 72 insertions(+), 1036 deletions(-)
 delete mode 100644 doc/interface_functions.aux
 delete mode 100644 doc/interface_functions.log
 delete mode 100644 doc/interface_functions.toc

diff --git a/doc/interface_functions.aux b/doc/interface_functions.aux
deleted file mode 100644
index 95f295ef..00000000
--- a/doc/interface_functions.aux
+++ /dev/null
@@ -1,40 +0,0 @@
-\relax 
-\@writefile{toc}{\contentsline {section}{\numberline {1}Introduction}{2}}
-\@writefile{toc}{\contentsline {section}{\numberline {2}Functions}{2}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.1}Functions from \texttt  {model.py}}{2}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{2}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{3}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{5}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.2}Functions from \texttt  {gfrdbase.py}}{8}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.2}Handling objects (surfaces, cylinders, etc)}{9}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.2.4}Obtaining information about particles and species}{10}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.3}Functions from \texttt  {egfrd.py}}{11}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{11}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{12}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.3}Get data}{12}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.4}Get position and distance data}{12}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.3.5}Additional functions}{13}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.4}Functions from \texttt  {dumper.py}}{13}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{13}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{16}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{16}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.5}Functions from \texttt  {utils.py}}{17}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{17}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{18}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{22}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.6}Notes on other files}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.1}\texttt  {bd.py}: Brownian Dynamic Simulator}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.2}\texttt  {gillespie.py}: Gillespie Simulator}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.3}\texttt  {legacy.py}: Old redundant functions}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.4}\texttt  {multi.py}, \texttt  {pair.py}, \texttt  {single.py}}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.5}\texttt  {myrandom.py}}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.6.6}\texttt  {make\_cjy\_table.py.py}, \texttt  {make\_sjy\_table.py.py}}{23}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {2.7}Function from module \texttt  {logger.py}}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{23}}
-\@writefile{toc}{\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{24}}
-\@writefile{toc}{\contentsline {section}{\numberline {3}Todo}{24}}
-\@writefile{toc}{\contentsline {section}{\numberline {4}On C++ data structures}{24}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.1}SpeciesInfo}{24}}
-\@writefile{toc}{\contentsline {subsection}{\numberline {4.2}Particle}{25}}
diff --git a/doc/interface_functions.log b/doc/interface_functions.log
deleted file mode 100644
index 2916efdc..00000000
--- a/doc/interface_functions.log
+++ /dev/null
@@ -1,896 +0,0 @@
-This is pdfTeXk, Version 3.141592-1.40.3 (Web2C 7.5.6) (format=pdflatex 2010.5.19)  16 MAY 2011 17:18
-entering extended mode
- %&-line parsing enabled.
-**interface_functions.tex
-(./interface_functions.tex
-LaTeX2e <2005/12/01>
-Babel <v3.8h> and hyphenation patterns for english, usenglishmax, dumylang, noh
-yphenation, loaded.
-(/usr/share/texmf-texlive/tex/latex/base/article.cls
-Document Class: article 2005/09/16 v1.4f Standard LaTeX document class
-(/usr/share/texmf-texlive/tex/latex/base/size10.clo
-File: size10.clo 2005/09/16 v1.4f Standard LaTeX file (size option)
-)
-\c@part=\count79
-\c@section=\count80
-\c@subsection=\count81
-\c@subsubsection=\count82
-\c@paragraph=\count83
-\c@subparagraph=\count84
-\c@figure=\count85
-\c@table=\count86
-\abovecaptionskip=\skip41
-\belowcaptionskip=\skip42
-\bibindent=\dimen102
-)
-(/usr/share/texmf-texlive/tex/latex/base/inputenc.sty
-Package: inputenc 2006/05/05 v1.1b Input encoding file
-\inpenc@prehook=\toks14
-\inpenc@posthook=\toks15
-
-(/usr/share/texmf-texlive/tex/latex/ucs/utf8x.def
-File: utf8x.def 2004/10/17 UCS: Input encoding UTF-8
-))
-(/usr/share/texmf-texlive/tex/latex/ucs/ucs.sty
-Package: ucs 2004/10/17 UCS: Unicode input support
-
-(/usr/share/texmf-texlive/tex/latex/ucs/data/uni-global.def
-File: uni-global.def 2004/10/17 UCS: Unicode global data
-)
-\uc@secondtry=\count87
-\uc@combtoks=\toks16
-\uc@combtoksb=\toks17
-\uc@temptokena=\toks18
-)
-(./interface_functions.aux)
-\openout1 = `interface_functions.aux'.
-
-LaTeX Font Info:    Checking defaults for OML/cmm/m/it on input line 8.
-LaTeX Font Info:    ... okay on input line 8.
-LaTeX Font Info:    Checking defaults for T1/cmr/m/n on input line 8.
-LaTeX Font Info:    ... okay on input line 8.
-LaTeX Font Info:    Checking defaults for OT1/cmr/m/n on input line 8.
-LaTeX Font Info:    ... okay on input line 8.
-LaTeX Font Info:    Checking defaults for OMS/cmsy/m/n on input line 8.
-LaTeX Font Info:    ... okay on input line 8.
-LaTeX Font Info:    Checking defaults for OMX/cmex/m/n on input line 8.
-LaTeX Font Info:    ... okay on input line 8.
-LaTeX Font Info:    Checking defaults for U/cmr/m/n on input line 8.
-LaTeX Font Info:    ... okay on input line 8.
- (/usr/share/texmf-texlive/tex/latex/ucs/ucsencs.def
-File: ucsencs.def 2003/11/29 Fixes to fontencodings LGR, T3
-)
-LaTeX Font Info:    External font `cmex10' loaded for size
-(Font)              <12> on input line 10.
-LaTeX Font Info:    External font `cmex10' loaded for size
-(Font)              <8> on input line 10.
-LaTeX Font Info:    External font `cmex10' loaded for size
-(Font)              <6> on input line 10.
- (./interface_functions.toc
-LaTeX Font Info:    External font `cmex10' loaded for size
-(Font)              <7> on input line 3.
-LaTeX Font Info:    External font `cmex10' loaded for size
-(Font)              <5> on input line 3.
- [1
-
-{/var/lib/texmf/fonts/map/pdftex/updmap/pdftex.map}])
-\tf@toc=\write3
-\openout3 = `interface_functions.toc'.
-
-LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <12> not available
-(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 21.
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 46--46
-[]                \OT1/cmtt/m/n/10 the size of one side of the simulation "worl
-d". Units:[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 46--46
-[]        \OT1/cmtt/m/n/10 The simulation "world" is always assumed to be a cub
-e with[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 46--46
-[]        \OT1/cmtt/m/n/10 *periodic boundary conditions*, with 1 corner at [0,
- 0, 0] and[] 
- []
-
-[2]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
-[]            \OT1/cmtt/m/n/10 the radius for this Species in/on this Region or
- Surface.[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 76--76
-[]            \OT1/cmtt/m/n/10 the Region or Surface in/on which this Species c
-an exist.[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 76--76
-[]            \OT1/cmtt/m/n/10 Optional. If you do not specify a Structure the 
-Species is[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 76--76
-[]    \OT1/cmtt/m/n/10 If a certain Species should be able to exist in the "wor
-ld" as[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 76--76
-[]    \OT1/cmtt/m/n/10 well as in/on one of the previously created Regions or S
-urfaces,[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 the vector [x, y, z] from the corner closest to [0, 
-0, 0], to[] 
- []
-
-[3]
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 164--164
-[]\OT1/cmtt/m/n/10 """create_cylindrical_surface(id, corner, radius, orientatio
-n, length)[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 the point [x, y, z] on the axis of the cylinder clos
-est to[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 the unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] al
-ong the[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 the length of the cylinder. Should be equal to the w
-orld_size.[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 164--164
-[]\OT1/cmtt/m/n/10 """create_planar_surface(id, corner, unit_x, unit_y, length_
-x, length_y)[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 the point [x, y, z] on the plane closest to [0, 0, 0
-]. Units:[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] alon
-g the plane[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 the length of the plane along the unit vector unit_x
-. Should be[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 164--164
-[]        \OT1/cmtt/m/n/10 the length of the plane along the unit vector unit_y
-. Should be[] 
- []
-
-[4]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 180--180
-[]        \OT1/cmtt/m/n/10 """Add a Structure (Region or Surface) to the Partic
-leModel.[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 180--180
-[]              \OT1/cmtt/m/n/10 a Region or Surface created with one of the fu
-nctions[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 198--198
-[]        \OT1/cmtt/m/n/10 """Set all 'other' possible ReactionRules to be repu
-lsive.[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 198--198
-[]            \OT1/cmtt/m/n/10 - a repulsive bimolecular reaction rule (k=0) fo
-r each[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
-[]            \OT1/cmtt/m/n/10 reaction rate. Units: per second. (Rough order o
-f magnitude:[] 
- []
-
-[5]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 222--222
-[]    \OT1/cmtt/m/n/10 There is no distinction between an intrinsic and an over
-all reaction[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 241--241
-[]            \OT1/cmtt/m/n/10 reaction rate. Units: per second. (Rough order o
-f magnitude:[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 241--241
-[]    \OT1/cmtt/m/n/10 There is no distinction between an intrinsic and an over
-all reaction[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 269--269
-[]            \OT1/cmtt/m/n/10 intrinsic reaction rate. Units: meters^3 per sec
-ond. (Rough[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 269--269
-[]    \OT1/cmtt/m/n/10 overall reaction rate (kon) to an intrinsic reaction rat
-e (ka) with[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 269--269
-[]    \OT1/cmtt/m/n/10 the function utils.k_a(kon, kD), but only for reaction r
-ules in 3D.[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 269--269
-[]    \OT1/cmtt/m/n/10 bimolecular reaction rule (ka=0) for each possible combi
-nation of[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 269--269
-[]    \OT1/cmtt/m/n/10 reactants for which no bimolecular reaction rule is spec
-ified.[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 269--269
-[]    \OT1/cmtt/m/n/10 You can explicitly add these reaction rules to the model
- with the[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 302--302
-[]\OT1/cmtt/m/n/10 def create_binding_reaction_rule(reactant1, reactant2, produ
-ct, ka):[] 
- []
-
-[6]
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 302--302
-[]            \OT1/cmtt/m/n/10 intrinsic reaction rate. Units: meters^3 per sec
-ond. (Rough[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 302--302
-[]    \OT1/cmtt/m/n/10 overall reaction rate (kon) to an intrinsic reaction rat
-e (ka) with[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 302--302
-[]    \OT1/cmtt/m/n/10 the function utils.k_a(kon, kD), but only for reaction r
-ules in 3D.[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 302--302
-[]    \OT1/cmtt/m/n/10 bimolecular reaction rule (ka=0) for each possible combi
-nation of[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 302--302
-[]    \OT1/cmtt/m/n/10 reactants for which no bimolecular reaction rule is spec
-ified.[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 302--302
-[]    \OT1/cmtt/m/n/10 You can explicitly add these reaction rules to the model
- with the[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 332--332
-[]\OT1/cmtt/m/n/10 def create_unbinding_reaction_rule(reactant, product1, produ
-ct2, kd):[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
-[]            \OT1/cmtt/m/n/10 intrinsic reaction rate. Units: per second. (Rou
-gh order of[] 
- []
-
-[7]
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 332--332
-[]    \OT1/cmtt/m/n/10 overall reaction rate (koff) for this reaction rule to a
-n intrinsic[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 332--332
-[]    \OT1/cmtt/m/n/10 reaction rate (kd) with the function utils.k_d(koff, kon
-, kD) or[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 The world object keeps track of the positions of the par
-ticles[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 378--378
-[]            \OT1/cmtt/m/n/10 a ParticleModel previously created with model.Pa
-rticleModel.[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
-[]            \OT1/cmtt/m/n/10 the number of cells in the MatrixSpace along the
- x, y and z[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
-[]            \OT1/cmtt/m/n/10 axis. Leave it to the default number if you don'
-t know what[] 
- []
-
-
-Overfull \hbox (43.49661pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 The simulation cube "world" is divided into (matrix_size
- x matrix_size[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 x matrix_size) cells. Together these cells form a Matrix
-Space. The[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 MatrixSpace keeps track in which cell every particle and
- protective[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 neighbours of particle, only objects in the same cell an
-d the 26[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 (3x3x3 - 1) neighbouring cells (the simulation cube has 
-periodic[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 The matrix_size limits the size of the protective domain
-s. If you[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 have fewer particles, you want a smaller matrix_size, su
-ch that the[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 protective domains and thus the eGFRD timesteps can be l
-arger. If[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 you have more particles, you want a larger matrix_size, 
-such that[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 378--378
-[]    \OT1/cmtt/m/n/10 (N * 6) ** (1. / 3.) is used, where N is the average num
-ber of[] 
- []
-
-[8]
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 400--400
-[]\OT1/cmtt/m/n/10 def get_closest_surface_within_radius(world, pos, radius, ig
-nore):[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 419--419
-[]    \OT1/cmtt/m/n/10 """Add n particles of a certain Species to the specified
- world.[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 419--419
-[]    \OT1/cmtt/m/n/10 Make sure to first add the Species to the model with the
- method[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 437--437
-[]    \OT1/cmtt/m/n/10 """Place a particle of a certain Species at a specific p
-osition in[] 
- []
-
-
-Overfull \hbox (38.24666pt too wide) in paragraph at lines 437--437
-[]            \OT1/cmtt/m/n/10 a position vector [x, y, z]. Units: [meters, met
-ers, meters].[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 437--437
-[]    \OT1/cmtt/m/n/10 Make sure to first add the Species to the model with the
- method[] 
- []
-
-[9]
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 499--499
-[]        \OT1/cmtt/m/n/10 Function that returns particle position. Can take mu
-ltiple[] 
- []
-
-[10]
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 499--499
-[]                  \OT1/cmtt/m/n/10 (of which pid_particle_pair[0] is _gfrd.Pa
-rticleID).[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 499--499
-[]                    \OT1/cmtt/m/n/10 In the two latter cases, the function re
-turns the[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 499--499
-[]                    \OT1/cmtt/m/n/10 first ID of the position of the first pa
-rticle of[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 524--524
-[]    \OT1/cmtt/m/n/10 def __init__(self, world, rng=myrandom.rng, network_rule
-s=None):[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 524--524
-[]                \OT1/cmtt/m/n/10 a random number generator. By default myrand
-om.rng is[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 524--524
-[]                \OT1/cmtt/m/n/10 used, which uses Mersenne Twister from the G
-SL library.[] 
- []
-
-
-Overfull \hbox (53.99652pt too wide) in paragraph at lines 524--524
-[]                \OT1/cmtt/m/n/10 you don't need to use this, for backward com
-patibility only.[] 
- []
-
-
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 532--533
-\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
-cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 555--555
-[]        \OT1/cmtt/m/n/10 asynchronously. This method bursts all protective do
-mains and[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 555--555
-[]                \OT1/cmtt/m/n/10 the time at which to synchronize the particl
-es. Usually[] 
- []
-
-[11]
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 555--555
-[]                \OT1/cmtt/m/n/10 you will want to use the current time of the
- simulator:[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 555--555
-[]        \OT1/cmtt/m/n/10 This method is called stop because it is usually cal
-led at the[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 555--555
-[]        \OT1/cmtt/m/n/10 end of a simulation. It is possible to call this met
-hod at an[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 555--555
-[]        \OT1/cmtt/m/n/10 earlier time. For example the Logger module does thi
-s, because[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 555--555
-[]        \OT1/cmtt/m/n/10 it needs to know the positions of the particles at e
-ach log[] 
- []
-
-
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 556--557
-\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
-cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
- []
-
-
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 567--568
-\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
-cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 579--579
-[]    \OT1/cmtt/m/n/10 This function resets the "records" of the simulator. Thi
-s means[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 579--579
-[]    \OT1/cmtt/m/n/10 the simulator time is reset, the step counter is reset, 
-events[] 
- []
-
-
-Overfull \hbox (41.35085pt too wide) in paragraph at lines 580--581
-\OT1/cmr/m/n/10 (Function be-longs to EGFRD-Sim-u-la-tor class, call with \OT1/
-cmtt/m/n/10 EGFRDSimulator.get[]next[]time\OT1/cmr/m/n/10 .) 
- []
-
-[12]
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 614--614
-[]\OT1/cmtt/m/n/10 def get_closest_surface_within_radius(world, pos, radius, ig
-nore):[] 
- []
-
-[13]
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 713--713
-[]    \OT1/cmtt/m/n/10 """ Return a generator (using "yield") to loop over (pid
-, particle).[] 
- []
-
-[14]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 728--728
-[]            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
-pecified,[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 728--728
-[]            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
-e returned.[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 743--743
-[]            \OT1/cmtt/m/n/10 a Species or the name of a Species. If none is s
-pecified,[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 743--743
-[]            \OT1/cmtt/m/n/10 all (particle identifier, particle)-pairs will b
-e returned.[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 772--772
-[]            \OT1/cmtt/m/n/10 (Species name, number of particles)-pairs will b
-e returned.[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 788--788
-[]    \OT1/cmtt/m/n/10 """Return a string containing the number of particles of
- a certain[] 
- []
-
-[15]
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 788--788
-[]            \OT1/cmtt/m/n/10 a string of (Species name, number of particles)-
-pairs will[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 800--800
-[]    \OT1/cmtt/m/n/10 """Return an iterator over the protective domains in the
- simulator.[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 829--829
-[]    \OT1/cmtt/m/n/10 """Return three lists with all the reaction rules define
-d in the[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 829--829
-[]        \OT1/cmtt/m/n/10 - reaction rules between two reactants with a reacti
-on rate[] 
- []
-
-[16]
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 837--837
-[]    \OT1/cmtt/m/n/10 ReactionRule.__str__ would be good, but we are actually 
-getting a[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 849--849
-[]    \OT1/cmtt/m/n/10 """Return a formatted string containing all the reaction
- rules[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 888--888
-[]    \OT1/cmtt/m/n/10 """Return True if a and b are equal, subject to given to
-lerances.[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 888--888
-[]    \OT1/cmtt/m/n/10 relative tolerance multipied by this typical value, and 
-will be[] 
- []
-
-
-Overfull \hbox (27.74675pt too wide) in paragraph at lines 888--888
-[]    \OT1/cmtt/m/n/10 """Return True if a is greater than b, subject to given 
-tolerances.[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 888--888
-[]    \OT1/cmtt/m/n/10 """Return True if a is less than b, subject to given tol
-erances.[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 888--888
-[]    \OT1/cmtt/m/n/10 """Return True if a is greater or equal than b, subject 
-to given[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 888--888
-[]    \OT1/cmtt/m/n/10 """Return True if a is less than or equal than b, subjec
-t to given[] 
- []
-
-[17]
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 928--928
-[]    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per molar per sec
-ond' to[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 928--928
-[]    \OT1/cmtt/m/n/10 """Convert a reaction rate from units 'per micromolar pe
-r second' to[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 928--928
-[]    \OT1/cmtt/m/n/10 """Convert a concentration from units 'micromolar' to un
-its 'per[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 """Calculate the 'pseudo-'reaction rate (kD) caused by d
-iffusion.[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 kD is equal to 1 divided by the time it takes for two pa
-rticles to[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 meet each other by diffusion. It is needed when converti
-ng from[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 an intrinsic reaction rate to an overall reaction rates 
-or vice[] 
- []
-
-[18]
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
-[]            \OT1/cmtt/m/n/10 the diffusion constant of particle A plus the di
-ffusion[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
-[]            \OT1/cmtt/m/n/10 the radius of particle A plus the radius of part
-icle B.[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (kon) for a binding/
-annihilation[] 
- []
-
-
-Overfull \hbox (6.74693pt too wide) in paragraph at lines 1083--1083
-[]            \OT1/cmtt/m/n/10 the overall reaction rate for the reaction rule.
- Units:[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
-ing reaction[] 
- []
-
-[19]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 This one is a bit tricky. We consider reaction rules wit
-h only 1[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 reactant. In case there is only 1 product also, no conve
-rsion in[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 necessary. But when the reaction rule has 2 products, we
- need to[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 1083--1083
-[]            \OT1/cmtt/m/n/10 the overall reaction rate for the unbinding reac
-tion rule.[] 
- []
-
-
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1083--1083
-[]            \OT1/cmtt/m/n/10 the overall reaction rate for the reverse reacti
-on rule.[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 """Convert an overall reaction rate (koff) for an unbind
-ing reaction[] 
- []
-
-
-Overfull \hbox (17.24684pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 Similar to the function k_d(), but expects an intrinsic 
-rate (ka)[] 
- []
-
-
-Overfull \hbox (22.4968pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 instead of an overall rate (kon) for the reversed reacti
-on rule as[] 
- []
-
-[20]
-Overfull \hbox (38.24666pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (ka) for a binding
-/annihilation[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
-ing reaction[] 
- []
-
-
-Overfull \hbox (32.9967pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 """Convert an intrinsic reaction rate (kd) for an unbind
-ing reaction[] 
- []
-
-
-Overfull \hbox (1.49698pt too wide) in paragraph at lines 1083--1083
-[]    \OT1/cmtt/m/n/10 Similar to the function k_off(), but expects an intrinsi
-c rate[] 
- []
-
-[21]
-LaTeX Font Info:    Font shape `OT1/cmtt/bx/n' in size <10> not available
-(Font)              Font shape `OT1/cmtt/m/n' tried instead on input line 1143.
-
- [22] [23]
-Overfull \hbox (11.99689pt too wide) in paragraph at lines 1186--1186
-[]    \OT1/cmtt/m/n/10 def __init__(self, logname='log', directory='data', comm
-ent=''):[] 
- []
-
-
-Overfull \hbox (374.24373pt too wide) in paragraph at lines 1225--1225
-[]  \OT1/cmtt/m/n/10 SpeciesInfo (identifier_type const &id, D_type const &D=0.
-, length_type const &r=0., structure_id_type const &s="", v_type const &v=0.)[]
- 
- []
-
-
-Overfull \hbox (64.49643pt too wide) in paragraph at lines 1225--1225
-[]\OT1/cmtt/m/n/10 template<typename Tid_, typename TD_, typename Tlen_, typena
-me Tstructure_id_>[] 
- []
-
-[24] [25] (./interface_functions.aux) ) 
-Here is how much of TeX's memory you used:
- 508 strings out of 95086
- 7761 string characters out of 1183255
- 67134 words of memory out of 1500000
- 3731 multiletter control sequences out of 10000+50000
- 8578 words of font info for 31 fonts, out of 1200000 for 2000
- 28 hyphenation exceptions out of 8191
- 23i,8n,20p,323b,243s stack positions out of 5000i,500n,6000p,200000b,5000s
-</usr/share/texmf-texlive/fonts/type1/bl
-uesky/cm/cmbx10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmbx12.pfb
-></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr10.pfb></usr/share/texmf-t
-exlive/fonts/type1/bluesky/cm/cmr12.pfb></usr/share/texmf-texlive/fonts/type1/b
-luesky/cm/cmr17.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr6.pfb><
-/usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmr7.pfb></usr/share/texmf-texl
-ive/fonts/type1/bluesky/cm/cmr8.pfb></usr/share/texmf-texlive/fonts/type1/blues
-ky/cm/cmti10.pfb></usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt10.pfb></
-usr/share/texmf-texlive/fonts/type1/bluesky/cm/cmtt12.pfb>
-Output written on interface_functions.pdf (25 pages, 110108 bytes).
-PDF statistics:
- 127 PDF objects out of 1000 (max. 8388607)
- 0 named destinations out of 1000 (max. 131072)
- 1 words of extra memory for PDF output out of 10000 (max. 10000000)
-
diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
index c0d8983d..9d25c1f4 100644
--- a/doc/interface_functions.tex
+++ b/doc/interface_functions.tex
@@ -682,34 +682,36 @@ \subsubsection{Getting information on species/particles}
 
 \begin{verbatim}
 def _get_species_type_by_name(sim, name):
-    """ Return the type of a species with a certain name
-
-    Arguments:
-        - sim
-            an EGFRDSimulator
-        - name
-            species name
-    """
+    # Return the type of a species with a certain name
+    # (Function not intended for public use.)
+    #
+    # Arguments:
+    #    - sim
+    #        an EGFRDSimulator
+    #    - name
+    #        species name
 \end{verbatim}
+Note that this function is NOT intended for users. It is listed because it MIGHT come in handy. (But should perhaps be removed from the list as there are other more user-friendly functions that give the same result.)
 
 \begin{verbatim}
 def _get_particles_by_sid(sim, sid):
-    """ Return a generator (using "yield") to loop over (pid, particle).
-    
-    Arguments:
-        - sim
-            an EGFRDSimulator
-        - sid
-            ID of a species
-
-    E.g.:
-    
-    myparticles = _get_particles_by_sid(sim, sid)
-
-    for mypid, myparticle in myparticles:
-        print str(str(mypid), str(myparticle))
-    """
+    # Return a generator (using "yield") to loop over (pid, particle).
+    # (Function not intended for public use.)
+    # 
+    # Arguments:
+    #    - sim
+    #        an EGFRDSimulator
+    #    - sid
+    #        ID of a species
+    #
+    # E.g.:
+    #
+    # myparticles = _get_particles_by_sid(sim, sid)
+    #
+    # for mypid, myparticle in myparticles:
+    #    print str(str(mypid), str(myparticle))
 \end{verbatim}
+Note that this function is NOT intended for users. It is listed because it MIGHT come in handy. (But should perhaps be removed from the list as there are other more user-friendly functions that give the same result.)
 
 \begin{verbatim}
 def get_particles(sim, identifier=None):
@@ -725,6 +727,7 @@ \subsubsection{Getting information on species/particles}
 
     """
 \end{verbatim}
+There is actually a case of bad naming here. (particle identifier, particle)-pairs refers to tuples containing particle information. It has nothing to do with particles being paired in the algorithm.
 
 \begin{verbatim}
 def dump_particles(sim, identifier=None):
@@ -740,6 +743,7 @@ \subsubsection{Getting information on species/particles}
 
     """
 \end{verbatim}
+There is actually a case of bad naming here. (particle identifier, particle)-pairs refers to tuples containing particle information. It has nothing to do with particles being paired in the algorithm.
 
 \begin{verbatim}
 def _get_number_of_particles_by_sid(sim, sid):
@@ -754,6 +758,7 @@ \subsubsection{Getting information on species/particles}
 
     """
 \end{verbatim}
+There is actually a case of bad naming here. (particle identifier, particle)-pairs refers to tuples containing particle information. It has nothing to do with particles being paired in the algorithm.
 
 \begin{verbatim}
 def get_number_of_particles(sim, identifier=None):
diff --git a/doc/interface_functions.toc b/doc/interface_functions.toc
deleted file mode 100644
index aaa7b0df..00000000
--- a/doc/interface_functions.toc
+++ /dev/null
@@ -1,39 +0,0 @@
-\contentsline {section}{\numberline {1}Introduction}{2}
-\contentsline {section}{\numberline {2}Functions}{2}
-\contentsline {subsection}{\numberline {2.1}Functions from \texttt {model.py}}{2}
-\contentsline {subsubsection}{\numberline {2.1.1}Core functions:}{2}
-\contentsline {subsubsection}{\numberline {2.1.2}Creating regions}{3}
-\contentsline {subsubsection}{\numberline {2.1.3}Adding reaction rules to the model}{5}
-\contentsline {subsection}{\numberline {2.2}Functions from \texttt {gfrdbase.py}}{8}
-\contentsline {subsubsection}{\numberline {2.2.1}Core functions}{8}
-\contentsline {subsubsection}{\numberline {2.2.2}Handling objects (surfaces, cylinders, etc)}{9}
-\contentsline {subsubsection}{\numberline {2.2.3}Adding particles}{9}
-\contentsline {subsubsection}{\numberline {2.2.4}Obtaining information about particles and species}{10}
-\contentsline {subsection}{\numberline {2.3}Functions from \texttt {egfrd.py}}{11}
-\contentsline {subsubsection}{\numberline {2.3.1}Core functions}{11}
-\contentsline {subsubsection}{\numberline {2.3.2}Simulator time (manipulation) functions}{12}
-\contentsline {subsubsection}{\numberline {2.3.3}Get data}{12}
-\contentsline {subsubsection}{\numberline {2.3.4}Get position and distance data}{12}
-\contentsline {subsubsection}{\numberline {2.3.5}Additional functions}{13}
-\contentsline {subsection}{\numberline {2.4}Functions from \texttt {dumper.py}}{13}
-\contentsline {subsubsection}{\numberline {2.4.1}Getting information on species/particles}{13}
-\contentsline {subsubsection}{\numberline {2.4.2}Get information on domains}{16}
-\contentsline {subsubsection}{\numberline {2.4.3}Get information on reaction rules}{16}
-\contentsline {subsection}{\numberline {2.5}Functions from \texttt {utils.py}}{17}
-\contentsline {subsubsection}{\numberline {2.5.1}Mathematical comparisons}{17}
-\contentsline {subsubsection}{\numberline {2.5.2}Conversions}{18}
-\contentsline {subsubsection}{\numberline {2.5.3}Some convenient functoins}{22}
-\contentsline {subsection}{\numberline {2.6}Notes on other files}{23}
-\contentsline {subsubsection}{\numberline {2.6.1}\texttt {bd.py}: Brownian Dynamic Simulator}{23}
-\contentsline {subsubsection}{\numberline {2.6.2}\texttt {gillespie.py}: Gillespie Simulator}{23}
-\contentsline {subsubsection}{\numberline {2.6.3}\texttt {legacy.py}: Old redundant functions}{23}
-\contentsline {subsubsection}{\numberline {2.6.4}\texttt {multi.py}, \texttt {pair.py}, \texttt {single.py}}{23}
-\contentsline {subsubsection}{\numberline {2.6.5}\texttt {myrandom.py}}{23}
-\contentsline {subsubsection}{\numberline {2.6.6}\texttt {make\_cjy\_table.py.py}, \texttt {make\_sjy\_table.py.py}}{23}
-\contentsline {subsection}{\numberline {2.7}Function from module \texttt {logger.py}}{23}
-\contentsline {subsubsection}{\numberline {2.7.1}HDF5 logger}{23}
-\contentsline {subsubsection}{\numberline {2.7.2}"Normal" logger}{24}
-\contentsline {section}{\numberline {3}Todo}{24}
-\contentsline {section}{\numberline {4}On C++ data structures}{24}
-\contentsline {subsection}{\numberline {4.1}SpeciesInfo}{24}
-\contentsline {subsection}{\numberline {4.2}Particle}{25}
diff --git a/dumper.py b/dumper.py
index 4737fe86..7f11eab5 100644
--- a/dumper.py
+++ b/dumper.py
@@ -66,14 +66,16 @@ def dump_species_names(sim):
     return ' '.join(get_species_names(sim))
 
 def _get_species_type_by_name(sim, name):
-    """ Return the type of a species with a certain name
-
-    Arguments:
-        - sim
-            an EGFRDSimulator
-        - name
-            species name
-    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
+    # Return the type of a species with a certain name
+    # (Function not intended for public use.)
+    #
+    # Arguments:
+    #    - sim
+    #        an EGFRDSimulator
+    #    - name
+    #        species name
+    #
+    #TODO: Added by wehrens@AMOLF.nl; Please revise.
     for species_type in sim.world.model.species_types:
         if species_type['name'] == name:
             return species_type
@@ -81,21 +83,23 @@ def _get_species_type_by_name(sim, name):
     raise RuntimeError('SpeciesType %s does not exist.' % (name))
 
 def _get_particles_by_sid(sim, sid):
-    """ Return a generator (using "yield") to loop over (pid, particle).
-    
-    Arguments:
-        - sim
-            an EGFRDSimulator
-        - sid
-            ID of a species
-
-    E.g.:
-    
-    myparticles = _get_particles_by_sid(sim, sid)
-
-    for mypid, myparticle in myparticles:
-        print str(str(mypid), str(myparticle))
-    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
+    # Return a generator (using "yield") to loop over (pid, particle).
+    # (Function not intended for public use.)
+    # 
+    # Arguments:
+    #    - sim
+    #        an EGFRDSimulator
+    #    - sid
+    #        ID of a species
+    #
+    # E.g.:
+    #
+    # myparticles = _get_particles_by_sid(sim, sid)
+    #
+    # for mypid, myparticle in myparticles:
+    #    print str(str(mypid), str(myparticle))
+    #
+    #TODO: Added by wehrens@AMOLF.nl; Please revise.
     for pid in sim.world.get_particle_ids(sid):
         particle = sim.world.get_particle(pid)[1]
         yield (pid, particle)
@@ -142,16 +146,17 @@ def dump_particles(sim, identifier=None):
     return '\n'.join((str(x) for x in get_particles(sim, identifier)))
 
 def _get_number_of_particles_by_sid(sim, sid):
-    """ 
-    Returns the number of particles of a certain species.
-
-    Arguments:
-        - sim
-            an EGFRDSimulator.
-        - sid
-            ID of a species    
+    # Returns the number of particles of a certain species.
+    # (Not intended for public use.)
+    # 
+    # Arguments:
+    #    - sim
+    #        an EGFRDSimulator.
+    #    - sid
+    #        ID of a species    
+    #
+    #TODO: Added by wehrens@AMOLF.nl; Please revise.
 
-    """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
     if isinstance(sim, EGFRDSimulator):
         return len(sim.world.get_particle_ids(sid))
     else:
@@ -226,7 +231,7 @@ def get_domains(egfrdsim):
         yield ((did, domain), pid_particle_pair_list, shell_list) 
 
 def dump_domains(egfrdsim):
-    """Return an string containing the protective domains in the 
+    """Return a string containing the protective domains in the 
     simulator.
 
     """
@@ -277,10 +282,11 @@ def get_reaction_rules(model_or_simulator):
     return reaction_rules_1, reaction_rules_2, repulsive_rules
 
 def _dump_reaction_rule(model, reaction_rule):
-    """Helper. Return ReactionRule as string.
-
-    ReactionRule.__str__ would be good, but we are actually getting a 
-    ReactionRuleInfo or ReactionRuleCache object."""
+    # Helper. Return ReactionRule as string.
+    # (Not intended for public use.)
+    # 
+    # ReactionRule.__str__ would be good, but we are actually getting a 
+    # ReactionRuleInfo or ReactionRuleCache object.
     buf = ('k=%.3g' % reaction_rule.k + ': ').ljust(15)
     for index, sid in enumerate(reaction_rule.reactants):
         if index != 0:
diff --git a/gfrdbase.py b/gfrdbase.py
index 9d46ee09..a0c0fd98 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -351,7 +351,7 @@ def get_first_pid(self, sid):
     def get_position(self, object):
         """
         Function that returns particle position. Can take multiple
-        sort of arguments as input. 
+        sorts of arguments as input. 
 
         Arguments:
             - object: can be:

From ae1b1167dd0a04802bd453bdfc8a3da77e89a902 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 18 May 2011 14:14:55 +0200
Subject: [PATCH 0047/1541] Fixed bug in get_neighbors_within_radius_no_sort.

get_neighbors_within_radius_no_sort resulted in a crash when there
are no containers. resolved by adding a try and pass statement.

~MW
---
 egfrd.py | 37 +++++++++++++++++++++++++++----------
 1 file changed, 27 insertions(+), 10 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f2df374b..793e43f9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -525,6 +525,20 @@ def burst_objs(self, objs):
         return bursted
 
     def clear_volume(self, pos, radius, ignore=[]):
+        """ Burst domains within a certain volume and give their ids.
+
+        This function actually has a confusing name, as it only bursts 
+        domains within a certain radius, and gives their ids. It doesn't
+        remove the particles or something like that.
+
+        (Bursting means it propagates the particles within the domain until
+        the current time, and then creates a new, minimum-sized domain.)
+
+        Arguments:
+            - pos: position of area to be "bursted"
+            - radius: radius of area to be "bursted"
+            - ignore: domains that should be ignored, none by default.
+        """ # Added by wehrens@amolf.nl; please revise
         neighbors = self.get_neighbors_within_radius_no_sort(pos, radius,
                                                              ignore)
         return self.burst_objs(neighbors)
@@ -1467,16 +1481,19 @@ def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # shells. Can for example be used to try to clear all objects 
         # from a certain volume.
 
-        for container in self.containers:
-            result = container.get_neighbors_within_radius(pos, radius)
-            # result = [((shell_id_shell_pair), distance), ]
-            # Since a domain can have more than 1 shell (multis for 
-            # example), and for each shell there is an entry in the 
-            # shell container, we make sure each domain occurs only once 
-            # in the returned list here.
-            for did in uniq(s[0][1].did for s in result):
-                if did not in ignore:
-                    yield self.domains[did]
+        try:
+            for container in self.containers:
+                result = container.get_neighbors_within_radius(pos, radius)
+                # result = [((shell_id_shell_pair), distance), ]
+                # Since a domain can have more than 1 shell (multis for 
+                # example), and for each shell there is an entry in the 
+                # shell container, we make sure each domain occurs only once 
+                # in the returned list here.
+                for did in uniq(s[0][1].did for s in result):
+                    if did not in ignore:
+                        yield self.domains[did]
+        except AttributeError:
+            pass
 
     def get_intruders(self, position, radius, ignore):
         intruders = []   # intruders are domains within radius

From 3d3b07d63ecd7e828d87385cec48c666de6e66a1 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 18 May 2011 14:18:54 +0200
Subject: [PATCH 0048/1541] Updated rebind sample and interface function list.

---
 doc/interface_functions.tex |  20 ++++-
 samples/rebind/run.py       | 156 ++++++++++++++----------------------
 2 files changed, 81 insertions(+), 95 deletions(-)

diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
index 9d25c1f4..d0a65b31 100644
--- a/doc/interface_functions.tex
+++ b/doc/interface_functions.tex
@@ -14,7 +14,7 @@
 \section{Introduction}
 This document gives an overview of functions that are usefull to end-users of the enhanced Green's Functions Reaction Dynamics (eGFRD) algorithm. In other words, it lists the "interface functions".
 Basically, this entails a list of function definition plus their so-called python "docstrings", obtained straight from the code.
-Note that functions starting with an underscore are actually C++ functions ported to python by boost. 
+% Note that functions starting with an underscore are actually C++ functions ported to python by boost. 
 
 \section{Functions}
 
@@ -612,6 +612,24 @@ \subsubsection{Get position and distance data}
 
 \end{verbatim}
 
+\subsubsection{Manipulating the system}
+\begin{verbatim}
+    def clear_volume(self, pos, radius, ignore=[]):
+    """ Burst domains within a certain volume and give their ids.
+
+    This function actually has a confusing name, as it only bursts 
+    domains within a certain radius, and gives their ids. It doesn't
+    remove the particles or something like that.
+
+    (Bursting means it propagates the particles within the domain until
+    the current time, and then creates a new, minimum-sized domain.)
+
+    Arguments:
+        - pos: position of area to be "bursted"
+        - radius: radius of area to be "bursted"
+        - ignore: domains that should be ignored, none by default.
+    """ 
+\end{verbatim}
 
 
 \subsubsection{Additional functions}
diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index 31d37fd9..e79489a5 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -1,23 +1,15 @@
 #!/usr/bin/env python
 
-#TODO
-"""
-See README for a description
-
-# [N_B] [N_X] [N]
-
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py 1 100 10
-
-"""
+# See README for a description
 
+import sys
 
 from egfrd import *
 from bd import *
-import sys
 import gfrdbase
 import model
 
-def run(outfilename, N_B, N_X, T_list, N):
+def run(outfilename, N_B, N_X, N, T_list):
     """ 
     Function that loops over single runs of binding/rebinding
     simulations. (Plus some overhead code.)
@@ -57,14 +49,9 @@ def run(outfilename, N_B, N_X, T_list, N):
     matrix_size = min(max(3, int((9 * (N_X+N_B)) ** (1.0/3.0))), 60)
     print 'matrix_size=', matrix_size
 
-    # Overrides the T_list input
-    T_list = [tau*0.1, tau, tau*10, tau * 100, tau * 1000, INF]
-    T_list = range(0, int(tau*100000), 100)
-    T_list.append(INF)
-
-    # Clear the distance output file
+    # Clear the distance output files
     for j in T_list:
-        outfile_r = open(outfilename + '_r_-'+str(j)+'.dat', 'a')
+        outfile_r = open(outfilename + '_r_'+str(j)+'.dat', 'a')
         outfile_r.close()
 
     # Open the time output file
@@ -164,38 +151,35 @@ def singlerun(T_list, N_B, N_X):
     B_pos = [(float(A['radius']) + float(B['radius']))+1e-23,0,0]
 
     # Clear an area at position A_pos and place particle A there
-    """
-    What happens here:
-        - find particles at position A_pos within species A radius
-        - delete those
-        - add a number of X particles _randomly to the box_, the 
-          number being equal to # removed particles.
-        - if a particle is accidently placed within the "cleared"
-          area, repeat the process (in very crowded box, this 
-          leads to infinite loop)
-        - 
-
-    """#TODO 
-    """This code doesn't function properly, because you want to clear 
-    particles within a certain radius.. Now you can be removing particles 
-    that after bursting are not in the area anymore, but whose bursted 
-    domains were.
-
-    After bursting you should just check whether something is within the radius.
-
-    Perhaps it would be more easy to just place all the particles at
-    the beginning, but give A and B initially a diffusion constant of
-    0, then stirr, and then set the diffusion constant to their
-    desired values.."""
+    # 
+    # How this should be done:
+    #    - find particles at position A_pos within species A radius
+    #    - delete those
+    #    - add a number of X particles _randomly to the box_, the 
+    #      number being equal to # removed particles.
+    #    - if a particle is accidently placed within the "cleared"
+    #      area, repeat the process (in very crowded box, this 
+    #      leads to infinite loop)
+    #
+    # Currently, however, it doesn't get the particles within a certain radius, 
+    # but the particles which domain lies within a certain radius. 
+    #
+    # Therefore, you might be removing particles that after bursting are not 
+    # within the radius anymore, but whose (now bursted) domains were.
+    # 
+    # TODO
+    # This code should thus be adapted to solve this problem.
+    # 
+    # Perhaps it would be more easy to just place all the particles at
+    # the beginning, but give A and B initially a diffusion constant of
+    # 0, then stirr, and then set the diffusion constant to their
+    # desired values.."""
 
     while 1:
 
+        # Burst domains within a certain volume and collect their ids
+        dd = s.clear_volume(A_pos, float(A['radius'])) 
 
-        #pp = s.get_particles_within_radius(A_pos, float(A['radius']))
-        dd = s.clear_volume(A_pos, float(A['radius'])) # returns a list of 
-                                                       # domains ID's that
-                                                       # where bursted within
-                                                       # volume
         if not dd:
             break
         for d in dd:
@@ -208,10 +192,10 @@ def singlerun(T_list, N_B, N_X):
 
     # Idem for a particle B:
     while 1:
-        dd = s.clear_volume(B_pos, float(B['radius'])) # returns a list of 
-                                                       # domains ID's that
-                                                       # where bursted within
-                                                       # volume
+    
+        # Burst domains within a certain volume and collect their ids
+        dd = s.clear_volume(B_pos, float(B['radius'])) 
+
         if not dd:
             break
         for d in dd:
@@ -239,31 +223,32 @@ def singlerun(T_list, N_B, N_X):
 
     #  ### Start simulating
     while 1:
-        """
-        What happens in this if-statement: 
-        Create a list of the times particles were in bound state.
-
-        If there was a reaction:
-            - Binding: Indicated by the fact that there are no C-particles.
-              In this case: record the current time (s.t) to t_last.
-            - Unbinding: Indicated because this is the only other case when
-              a reaction has taken place. 
-              In this case: record the time binding lasted, i.e. dt between
-              current time (s.t) and last reaction time (t_last).
-        """
+
+        # What happens in the following if-statement: 
+        # Create a list of the durations particles were in bound state.
+        #
+        # If there was a reaction:
+        #     - Binding: Indicated by the fact that there are no C-particles.
+        #       In this case: record the current time (s.t) to t_last.
+        #     - Unbinding: Indicated because this is the only other case when
+        #       a reaction has taken place. 
+        #       In this case: record the time binding lasted, i.e. dt between
+        #       current time (s.t) and last reaction time (t_last).
         if s.last_reaction: # aka if there was a reaction
             print "* Reaction detected at: " + str(s.last_reaction)
             if len(s.world.get_particle_ids(C.id)) == 0:  #A,B
                 print '    - set t_last', str(s.t)
-                t_last = s.t  # set t_last
-            else:    # C
+                # set t_last to "current time" in simulator
+                t_last = s.t  
+            else:    
                 print '    - reaction: ', str(s.t - t_last)
                 t_list.append(s.t - t_last)
 
-        """ If it's time to log, then log distance between particles. """
+        # If it's time to log, then log distance between particles. 
         next_time = s.get_next_time()
         if next_time > next_stop:
-            print '* Measuring distances at ', str(i_T), str(next_stop)
+            print '* Measuring distances at ', str(next_stop),\
+                            '(measurement #', str(i_T), ')'
             s.stop(next_stop)
             print '* stopped'
             # If there is a particle C, the distance is "0".
@@ -290,12 +275,10 @@ def singlerun(T_list, N_B, N_X):
             next_stop = T_list[i_T]
             print "* Done, returning to simulation loop."
         
-        """ If there are no measuring moments on the list any more,
-        stop """
-        if (next_stop == INF):            
-            print '* Break at ', str(s.t)
-            if (len(t_list) == 0):
-                t_list.append(float('nan'))            
+        # If there are no measuring moments on the list any more, and
+        # a duration of being bounded has been recorded, then stop
+        if (next_stop == INF) and (len(t_list) != 0):
+            print 'break', s.t
             break
 
         s.step()
@@ -306,30 +289,15 @@ def singlerun(T_list, N_B, N_X):
 if __name__ == '__main__':
 
     import os
+    
+    # convert last user arguments to array T_list
+    T_list = []
+    for measurement_time in sys.argv[4:]:    
+        T_list.append(float(measurement_time))
 
-    T_list = eval(sys.argv[3])
-
-    outfilename = 'data/rebind_' + '_'.join(sys.argv[1:4]) +\
-        '_' #+ os.environ['SGE_TASK_ID']
-    run(outfilename, float(sys.argv[1]), 
-        int(sys.argv[2]), T_list, int(sys.argv[4]))
-
-
-
-
-"""
-
-Some additional notes:
-
-    # 100 nM = 100e-9 * N_A * 100 / m^3 = 6.02e19
-    # V = 1 / 6.02e19 = 1.66e-20 m^3
-    # L = 2.55e-7 m
-
-    # 1 uM = 6.02e20 / m^3
-    # V = 1.66e-21 m^3
-    # L = 1.18e-7
+    run('data/rebind', float(sys.argv[1]), 
+        int(sys.argv[2]), int(sys.argv[3]), T_list)
 
-"""
 
 
 

From c05a9ea0df71586df2467c31ea03a1b0cc9574cc Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 18 May 2011 14:20:55 +0200
Subject: [PATCH 0049/1541] Rebind sample should now function properly, also
 added README file.

~MW
---
 samples/rebind/README | 73 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 samples/rebind/README

diff --git a/samples/rebind/README b/samples/rebind/README
new file mode 100644
index 00000000..4f7df639
--- /dev/null
+++ b/samples/rebind/README
@@ -0,0 +1,73 @@
+
+
+
+Introduction
+=====================================
+This example deals with the rebinding problem. The simplest case of
+this probllem is when you have two particles of different species
+that can react with each other, say A and B, to a particle of species
+C:
+
+A + B <-> C
+
+If all these particles have different diffusion constants, one may 
+wonder how the path of the center of mass of this particle system 
+can be approximated by a single diffusion constant.
+
+A major question in this problem is how many time the particles 
+spend being particles A & B, and how many time the particles spend
+as particle C.
+
+Here, such a system is simulated. There is one particle A, and a 
+fixed number of particles B, which can react to a particle C. 
+Additionally there are some particles X that are inert.
+
+The simulation initially places a particle A and a particle B next
+to it. If the number of particles B >1 then the rest of the B-particles
+are placed at random positions. (But can still be bound by particle A.)
+
+Running
+=====================================
+The simulation can be run as follows:
+$ LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py [N_B] [N_X] [N] [t1,
+t2, t3, t4, .., INF]
+
+Example:
+$ LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py 1 100 10 1.0 2.5 3 4.0 INF
+
+Here, N_B and N_X are respectively the number of B and X particles. N is the 
+number of times the simulation is ran. [t1, t2, .., INF] is an array of times 
+at which the distances between the two particles are logged. (Taken zero if a 
+set of A and B particles have reacted to a C particle.) This array should 
+minimally contain the INF value.
+    If only [INF] is given as input, the simulation will run until it 
+has recorded a duration for which the particles were in a bound state.
+Otherwise, the system will keep going untill all measurement times have 
+been passed (and then still run until a duration is recorded). 
+
+
+Output
+=====================================
+The most important data is written away to files in the data directory.
+
+The duration of recorded bindings are written to:
+rebind_t.dat
+
+The distances between the particles logged at times given by the user 
+are written to:
+rebind_r_<time>.dat
+(Where <time> stands for the applicable measurement time.)
+
+
+Appendix
+=====================================
+
+Some code used in previous versions:
+
+100 nM = 100e-9 * N_A * 100 / m^3 = 6.02e19
+V = 1 / 6.02e19 = 1.66e-20 m^3
+L = 2.55e-7 m
+
+1 uM = 6.02e20 / m^3
+V = 1.66e-21 m^3
+L = 1.18e-7

From 81377589427935226a69b5a05e57e264f0218111 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 18 May 2011 14:46:36 +0200
Subject: [PATCH 0050/1541] Dump attribute added to GF3DAbsSym.hpp/cpp and the
 wrapper. This was missing for some reason.

---
 GreensFunction3DAbsSym.cpp | 7 +++++++
 GreensFunction3DAbsSym.hpp | 2 ++
 greens_functions.cpp       | 1 +
 3 files changed, 10 insertions(+)

diff --git a/GreensFunction3DAbsSym.cpp b/GreensFunction3DAbsSym.cpp
index 2df29fb3..8c079c9e 100644
--- a/GreensFunction3DAbsSym.cpp
+++ b/GreensFunction3DAbsSym.cpp
@@ -400,3 +400,10 @@ Real GreensFunction3DAbsSym::drawR(Real rnd, Real t) const
 
 Logger& GreensFunction3DAbsSym::log_(
         Logger::get_logger("GreensFunction3DAbsSym"));
+
+std::string GreensFunction3DAbsSym::dump() const
+{
+    std::ostringstream ss;
+    ss << "D = " << this->getD() << ", a = " << this->geta() << std::endl;
+    return ss.str();
+}
diff --git a/GreensFunction3DAbsSym.hpp b/GreensFunction3DAbsSym.hpp
index 7aa025ca..42485ad6 100644
--- a/GreensFunction3DAbsSym.hpp
+++ b/GreensFunction3DAbsSym.hpp
@@ -34,6 +34,8 @@ class GreensFunction3DAbsSym: public GreensFunction
     Real p_int_r_free(Real r, Real t) const;
 
     Real p_r_fourier(Real r, Real t) const;
+	
+    std::string dump() const;
 
 private:
     static Real ellipticTheta4Zero(Real q);
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 74d92c9f..5a07ba20 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -93,6 +93,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "p_int_r", &GreensFunction3DAbsSym::p_int_r )
         .def( "p_int_r_free", &GreensFunction3DAbsSym::p_int_r_free )
         //.def( "p_r_fourier", &GreensFunction3DAbsSym::p_r_fourier )
+	.def( "dump", &GreensFunction3DAbsSym::dump )
         ;
 
     class_<GreensFunction3DRadInf>("GreensFunction3DRadInf",

From 085b2fc7a55602bec92fc1209dab79b7275a8d32 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 19 May 2011 11:36:07 +0200
Subject: [PATCH 0051/1541] Added a README on samples/dimer. Please revise.
 Also added minimal comments to dimer.py.

---
 samples/dimer/README   | 19 +++++++++++++++++++
 samples/dimer/dimer.py |  7 ++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 samples/dimer/README

diff --git a/samples/dimer/README b/samples/dimer/README
new file mode 100644
index 00000000..8ba19c03
--- /dev/null
+++ b/samples/dimer/README
@@ -0,0 +1,19 @@
+Introduction
+=====================================
+Script that "profiles" the eGFRD algorithm. This basically means a report
+is generated on which part of the code uses the most resources. For more 
+on profiling, see http://docs.python.org/library/profile.html#id1. 
+The eGFRD algorithm is tested with a simple script which simulates the
+reversible binding reaction between two species, S and P. 
+
+This script is especially usefull for benchmarking and developers, but no
+so much for end-users of the eGFRD algorithm.
+
+Running
+=====================================
+$ PYTHONPATH=../../.. python dimer.py 
+
+Will already do the trick.
+
+
+
diff --git a/samples/dimer/dimer.py b/samples/dimer/dimer.py
index dbf8ee76..a12612e3 100644
--- a/samples/dimer/dimer.py
+++ b/samples/dimer/dimer.py
@@ -1,12 +1,14 @@
 #!/usr/bin/env python
 
+import sys
+
 from egfrd import *
 from bd import *
 from gfrdbase import *
 from logger import *
 import _gfrd
 import model
-import sys
+
 
 
 N = 300
@@ -16,6 +18,7 @@
 #L = 5e-8
 #L = 3e-7
 
+# Creating a model with species S and P that can reversibly bind
 m = model.ParticleModel(L)
 S = model.Species('S', 1.5e-12, 5e-9)
 P = model.Species('P', 1e-12, 7e-9)
@@ -27,11 +30,13 @@
 m.network_rules.add_reaction_rule(r2)
 m.set_all_repulsive()
 
+# Set up simulator
 world = create_world(m, int((N * 6) ** (1. / 3.)))
 nrw = _gfrd.NetworkRulesWrapper(m.network_rules)
 s = EGFRDSimulator(world, myrandom.rng, nrw)
 #s = BDSimulator(world. myrandom.rng, nrw)
 
+# Throw in particles
 throw_in_particles(s.world, S, N / 2)
 throw_in_particles(s.world, P, N / 2)
 

From ff330ce8de3146f211a47dca85e313951d783eea Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 19 May 2011 11:38:39 +0200
Subject: [PATCH 0052/1541] Oops, small mistake in last commit. Again, please
 revise README.

---
 samples/dimer/README | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/samples/dimer/README b/samples/dimer/README
index 8ba19c03..6e0cc822 100644
--- a/samples/dimer/README
+++ b/samples/dimer/README
@@ -11,7 +11,7 @@ so much for end-users of the eGFRD algorithm.
 
 Running
 =====================================
-$ PYTHONPATH=../../.. python dimer.py 
+$ PYTHONPATH=../../ python dimer.py 
 
 Will already do the trick.
 

From 98274611ef16e4042dfbc631f8d8c2f607a6d1af Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 19 May 2011 12:00:57 +0200
Subject: [PATCH 0053/1541] Added file from which one can easily copy and paste
 some basic code to get his/her script up and running more easily.

---
 samples/template/template.py | 100 +++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 samples/template/template.py

diff --git a/samples/template/template.py b/samples/template/template.py
new file mode 100644
index 00000000..3715006e
--- /dev/null
+++ b/samples/template/template.py
@@ -0,0 +1,100 @@
+
+# Template file to copy and paste basic code from.
+
+# Modules
+# ===============================
+import sys
+#Also, set relative python path
+sys.path.append('../../')
+import os
+
+from egfrd import *
+from bd import *
+import model
+import gfrdbase
+import _gfrd
+#import dumper
+
+
+# Constants
+# ===============================
+sigma = 1e-4        # Diameter particle; more realistic would be e-9
+D = 1e-12           # Diffusion constant
+N = 1000            # Number of steps simulation will last
+world_size = 1e-3   # Lengths of simulation box
+
+
+# Basic set up simulator
+# ===============================
+# Model
+m = model.ParticleModel(world_size)
+# Species
+X = model.Species('X', D, sigma/2)                                   
+m.add_species_type(A) 
+# Reaction rules
+r1 = model.create_binding_reaction_rule(A, B, X, k)
+m.network_rules.add_reaction_rule(r1)
+
+# World
+w = gfrdbase.create_world(m, 3)
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
+
+# Throw in particles
+throw_in_particles(w, A, numberToThrowIn)
+
+
+# Running 1
+# ===============================
+while (s.get_next_time() < end_time)
+    s.step()
+
+s.stop(s.end_time)
+    
+
+# Running 2
+# ===============================
+for t in range(N):
+    s.step()
+
+s.stop(s.t)
+
+
+# Additional code
+# ===============================
+
+# VTK Logger
+# ===============================
+vtk_output_directory = 'VTK_out'
+if (os.path.exists(vtk_output_directory)):
+    print '** WARNING: VTK output directory already exists, possible '+ \
+            'present old VTK files might lead to errors.'
+    
+from visualization import vtklogger
+l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From e00faae1ab0a1572479ce7aa75c00722f9044966 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 19 May 2011 12:28:50 +0200
Subject: [PATCH 0054/1541] Fixed simple .py. Updated template file.

---
 samples/simple/simple.py     | 39 +++++++++++++++++++++---------------
 samples/template/template.py |  3 ++-
 2 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/samples/simple/simple.py b/samples/simple/simple.py
index 78e74cd5..82a11adc 100644
--- a/samples/simple/simple.py
+++ b/samples/simple/simple.py
@@ -1,30 +1,37 @@
 #!/usr/bin/env python
 
-from egfrd import *
-
-from logger import *
+# Modules
 import sys
 
-size = 1e-6
-w = World(size, 3)
-s = EGFRDSimulator(w)
+from egfrd import *
+import model
+import gfrdbase
+
+import logger
 
 
-box1 = CuboidalRegion([0,0,0],[size,size,size])
-# not supported yet
-#s.add_surface(box1)
+# Constants
+size = 1e-6
 
-#P = Species('P', 1e-12, 5e-8)
-P = Species('P', 1e-12, 3e-9) #hemo
-s.add_species(P)
+# Model
+m = model.ParticleModel(size)
+# Species
+P = model.Species('P', 1e-12, 3e-9)                                   
+m.add_species_type(P) 
 
-s.set_all_repulsive()
+# World
+w = gfrdbase.create_world(m, 3)
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
 
-s.throw_in_particles(P, 60, box1)
+# Throw in particles
+throw_in_particles(w, P, 60)
 
-l = Logger('simple')
-interrupter = FixedIntervalInterrupter(s, 3.33e-4, l)
+# Logger
+l = logger.Logger('simple')
+interrupter = logger.FixedIntervalInterrupter(s, 3.33e-4, l.log)
 
+# Simulation
 l.start(s)
 while s.t < .1:
     interrupter.step()
diff --git a/samples/template/template.py b/samples/template/template.py
index 3715006e..69ade673 100644
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -9,11 +9,12 @@
 import os
 
 from egfrd import *
-from bd import *
+
 import model
 import gfrdbase
 import _gfrd
 #import dumper
+#from bd import *
 
 
 # Constants

From 04ebd8cc18b813b8a9cc705a04cfc7dc59b9c3ea Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 19 May 2011 12:29:28 +0200
Subject: [PATCH 0055/1541] Added README to samples/simple.

---
 samples/simple/README | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 samples/simple/README

diff --git a/samples/simple/README b/samples/simple/README
new file mode 100644
index 00000000..f9ee6b75
--- /dev/null
+++ b/samples/simple/README
@@ -0,0 +1,25 @@
+
+
+Introduction
+=====================================
+This script runs a simulation with only one species of particles and 
+then uses the logger to output data on particles to data directory.
+
+Instructive on how to use the logger.
+
+
+Running
+======================================
+Simply use 
+$ PYTHONPATH=../../ python simple.py
+
+
+
+Output
+=======================================
+Script will create a directory 'data' log output data of the logger 
+there.
+
+
+
+

From 007150698c84a36b2706b1bdd5702aac355a56d9 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 20 May 2011 12:09:23 +0200
Subject: [PATCH 0056/1541] All examples should be working now, though not all
 have documentation.

---
 doc/interface_functions.tex  |   4 +-
 samples/pushpull/plot.py     |   2 +
 samples/pushpull/pushpull.py | 116 ++++++++++++++++++++---------------
 samples/template/template.py |   1 +
 samples/tf/tf.py             | 112 ++++++++++++++++++++-------------
 5 files changed, 138 insertions(+), 97 deletions(-)

diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
index d0a65b31..985ec279 100644
--- a/doc/interface_functions.tex
+++ b/doc/interface_functions.tex
@@ -75,9 +75,7 @@ \subsubsection{Core functions:}
     """
 \end{verbatim}
 
-Species should be added to the model:
 \begin{verbatim}
-
     def add_reaction_rule(self, reaction_rule):
         """Add a ReactionRule to the ParticleModel.
 
@@ -378,7 +376,7 @@ \subsubsection{Core functions}
 \end{verbatim}
 
 
-\subsubsection{Handling objects (surfaces, cylinders, etc)}
+\subsubsection{Handling regions (surfaces, cylinders, etc)}
 
 \begin{verbatim}
 def get_closest_surface(world, pos, ignore):
diff --git a/samples/pushpull/plot.py b/samples/pushpull/plot.py
index 19b2c8d6..e4c479b3 100644
--- a/samples/pushpull/plot.py
+++ b/samples/pushpull/plot.py
@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 
+# Call with:
+# PYTHONPATH=../../ python plot.py [data directory] [output directory]
 
 import sys
 import string
diff --git a/samples/pushpull/pushpull.py b/samples/pushpull/pushpull.py
index 13885412..2167581b 100644
--- a/samples/pushpull/pushpull.py
+++ b/samples/pushpull/pushpull.py
@@ -1,11 +1,17 @@
 #!/usr/bin/env python
 
-from egfrd import *
+# Call with:
+# PYTHONPATH=../../ python pushpull.py [Keq] [koff_ratio] [N_S_total] [N_K] [N_P] [V] [mode] [T]
 
-from logger import *
 import sys
 import os
+
+from egfrd import *
+import gfrdbase
+import _gfrd
+import logger
 import dumper
+import model
 
 from fractionS import *
 
@@ -20,6 +26,7 @@
 # T
 
 Keq_str = sys.argv[1]
+
 koff_ratio_str = sys.argv[2]
 N_S_total = int(sys.argv[3])
 N_K = int(sys.argv[4])
@@ -55,31 +62,39 @@
 matrix_size = min(max(3, int((3 * N) ** (1.0/3.0))), 60)
 print 'matrix_size=', matrix_size
 
-w = World(L, matrix_size)
-s = EGFRDSimulator(w)
+
+# Model
+m = model.ParticleModel(L)
+# Species
+S = model.Species('S', D1, radius)
+P = model.Species('P', D2, radius)
+K = model.Species('K', D2, radius)
+KS = model.Species('KS', D2, radius)
+Sp = model.Species('Sp', D1, radius)
+PSp = model.Species('PSp', D2, radius)
+
+m.add_species_type(S) 
+m.add_species_type(P) 
+m.add_species_type(K) 
+m.add_species_type(KS) 
+m.add_species_type(Sp) 
+m.add_species_type(PSp) 
+# World
+w = gfrdbase.create_world(m, 3)
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
 
 #s.set_dt_factor(1e-5)
 print V, L
 
 print C2N(498e-9, V)
 
+#TODO Correct sequence?
+#(id, corner, unit_x, unit_y, length_x, length_y)
+plain1 = _gfrd.create_planar_surface('plain1', [0,0,0], [1,0,0], [0,1,0], L, L)
+plain2 = _gfrd.create_planar_surface('plain2', [L/2,0,0], [1,0,0], [0,1,0], L, L)
 
 
-box1 = CuboidalRegion([0,0,0],[L,L,L])
-plain1 = CuboidalRegion([0,0,0],[0,L,L])
-plain2 = CuboidalRegion([L/2,0,0],[L/2,L,L])
-# not supported yet
-#s.add_surface(box1)
-
-m = ParticleModel()
-
-S = m.new_species_type('S', D1, radius)
-P = m.new_species_type('P', D2, radius)
-K = m.new_species_type('K', D2, radius)
-KS = m.new_species_type('KS', D2, radius)
-Sp = m.new_species_type('Sp', D1, radius)
-PSp = m.new_species_type('PSp', D2, radius)
-
 #fracS = fraction_S(N_K, N_P, Keq)
 fracS = 1
 
@@ -141,40 +156,42 @@
 
 #sys.exit(0)
 
-s.set_model(m)
-
 if mode == 'normal' or mode == 'immobile':
-    s.throw_in_particles(K, N_K, box1)
-    s.throw_in_particles(P, N_P, box1)
+    s.throw_in_particles(w, K, N_K)
+    s.throw_in_particles(w, P, N_P)
 elif mode == 'localized':
+    
+    P = model.Species('P', D2, radius,'plain1') 
+    K = model.Species('K', D2, radius,'plain2') 
+    m.add_species_type(P) 
+    m.add_species_type(K)
+
     s.throw_in_particles(K, N_K, plain1)
     s.throw_in_particles(P, N_P, plain2)
 elif mode == 'single':
     x = L/2
     yz = L/2
     tl = L/4
-    s.place_particle(K, [tl, tl, tl])
-    s.place_particle(K, [tl, tl, yz+tl])
-    s.place_particle(K, [tl, yz+tl, tl])
-    s.place_particle(K, [tl, yz+tl, yz+tl])
-    s.place_particle(P, [x+tl, tl, tl])
-    s.place_particle(P, [x+tl, tl, yz+tl])
-    s.place_particle(P, [x+tl, yz+tl, tl])
-    s.place_particle(P, [x+tl, yz+tl, yz+tl])
+    place_particle(w, K, [tl, tl, tl])
+    place_particle(w, K, [tl, tl, yz+tl])
+    place_particle(w, K, [tl, yz+tl, tl])
+    place_particle(w, K, [tl, yz+tl, yz+tl])
+    place_particle(w, P, [x+tl, tl, tl])
+    place_particle(w, P, [x+tl, tl, yz+tl])
+    place_particle(w, P, [x+tl, yz+tl, tl])
+    place_particle(w, P, [x+tl, yz+tl, yz+tl])
 else:
     assert False
 
-
-
-s.throw_in_particles(Sp, N_Sp, box1)
-s.throw_in_particles(S, N_S, box1)
+throw_in_particles(w, Sp, N_Sp)
+throw_in_particles(w, S, N_S)
 
 # Stir before actually start the sim.
 
 stir_time = 1e-7
 while 1:
     s.step()
-    next_time = s.scheduler.getTopTime()
+    next_time = s.get_next_time()
     if next_time > stir_time:
         s.stop(stir_time)
         break
@@ -187,29 +204,29 @@
 #  6   PSp     -> P + S
 
 
-r1 = create_binding_reaction_rule(S, K, KS, ka)
+
+
+# Create reaction rules (can this be done after rest is already performed?) TODO
+r1 = model.create_binding_reaction_rule(S, K, KS, ka)
 m.network_rules.add_reaction_rule(r1)
-r2 = create_unbinding_reaction_rule(KS, S, K, kd1)
+r2 = model.create_unbinding_reaction_rule(KS, S, K, kd1)
 m.network_rules.add_reaction_rule(r2)
-r3 = create_unbinding_reaction_rule(KS, K, Sp, kcat1)
+r3 = model.create_unbinding_reaction_rule(KS, K, Sp, kcat1)
 m.network_rules.add_reaction_rule(r3)
-r4 = create_binding_reaction_rule(Sp, P, PSp, ka)
+r4 = model.create_binding_reaction_rule(Sp, P, PSp, ka)
 m.network_rules.add_reaction_rule(r4)
-r5 = create_unbinding_reaction_rule(PSp, Sp, P, kd2)
+r5 = model.create_unbinding_reaction_rule(PSp, Sp, P, kd2)
 m.network_rules.add_reaction_rule(r5)
-r6 = create_unbinding_reaction_rule(PSp, P, S, kcat2)
+r6 = model.create_unbinding_reaction_rule(PSp, P, S, kcat2)
 m.network_rules.add_reaction_rule(r6)
 
 
-s.set_model(m)
-
-
 model = 'pushpull'
 
 # 'pushpull-Keq-koff_ratio-N_K-N_P-V-mode.dat'
-l = Logger(logname = model + '_' + '_'.join(sys.argv[1:8]) + '_' +\
-               os.environ['SGE_TASK_ID'],
-           comment = '@ model=\'%s\'; Keq=%s; koff_ratio=%s\n' %
+l = logger.Logger(logname = model + '_' + '_'.join(sys.argv[1:8]) + '_' # +\
+#               os.environ['SGE_TASK_ID']
+           ,comment = '@ model=\'%s\'; Keq=%s; koff_ratio=%s\n' %
            (model, Keq_str, koff_ratio_str) +
            '#@ V=%s; N_K=%s; N_P=%s; mode=\'%s\'; T=%s\n' % 
            (V_str, N_K, N_P, mode, T_str) +
@@ -219,8 +236,7 @@
            (kcat1, kcat2) +
            '#@ ka=%g; kd1=%g; kd2=%g\n' %
            (ka, kd1, kd2))
-
-interrupter = FixedIntervalInterrupter(s, 1e-7, l)
+interrupter = logger.FixedIntervalInterrupter(s, 1e-7, l.log)
 
 l.start(s)
 while s.t < T:
diff --git a/samples/template/template.py b/samples/template/template.py
index 69ade673..b2cd1d5e 100644
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -13,6 +13,7 @@
 import model
 import gfrdbase
 import _gfrd
+#import logger
 #import dumper
 #from bd import *
 
diff --git a/samples/tf/tf.py b/samples/tf/tf.py
index 9b12958e..a60b70d8 100644
--- a/samples/tf/tf.py
+++ b/samples/tf/tf.py
@@ -1,38 +1,23 @@
 #!/usr/bin/env python
 
-from egfrd import *
+# Run with bash command:
+# $ python tf.py
 
-from logger import *
 import sys
-import dumper
-
-w = World(1e-6, 3)
-s = EGFRDSimulator(w)
-
-box1 = CuboidalRegion([0,0,0],[1e-6,1e-6,1e-6])
+#Also, set relative python path
+sys.path.append('../../')
+import os
 
-m = ParticleModel()
-O = m.new_species_type('O', 0, 1e-8)
-R = m.new_species_type('R', 1e-12, 1e-8)
-P = m.new_species_type('R', 1e-12, 1e-8)
-OR = m.new_species_type('OR', 0, 1e-8)
-ORp = m.new_species_type('ORp', 0, 1e-8)
-ORpa = m.new_species_type('ORpa', 0, 1e-8)
-T = m.new_species_type('T', 1e-12, 1e-8)
-M = m.new_species_type('M', 1e-12, 1e-8)
-Mribo = m.new_species_type('Mribo', 1e-12, 1e-8)
-#EMPTY = m.new_species_type('EMPTY', 2e-12, 5e-8)
-
-#  1 2 O + R <-> OR
-#  3 4 O     <-> ORp
-#  5   ORp    -> ORpa
-#  6   ORpa   -> T + O
-#  7   M      -> EMPTY
-#  8   M      -> M + Mribo
-#  9   Mribo  -> P
-# 10   P      -> EMPTY
+from egfrd import *
 
+import model
+import gfrdbase
+import _gfrd
+import logger
+import dumper
+#from bd import *
 
+# Constants
 k_fR = 6e9 * 1000 / N_A
 k_bR = 0.1  # 1 - 0.01
 k_f_rp = 38
@@ -45,37 +30,76 @@
 k_dp = 2.4e-4
 t_trans = 30
 
-
-r1 = create_binding_reaction_rule(O, R, OR, k_fR)
+# Model
+m = model.ParticleModel(1e-6)
+# Species
+O = model.Species('O', 0, 1e-8)
+R = model.Species('R', 1e-12, 1e-8)
+P = model.Species('R', 1e-12, 1e-8)
+OR = model.Species('OR', 0, 1e-8)
+ORp = model.Species('ORp', 0, 1e-8)
+ORpa = model.Species('ORpa', 0, 1e-8)
+T = model.Species('T', 1e-12, 1e-8)
+M = model.Species('M', 1e-12, 1e-8)
+Mribo = model.Species('Mribo', 1e-12, 1e-8)
+
+m.add_species_type(O) 
+m.add_species_type(R) 
+m.add_species_type(P) 
+m.add_species_type(OR) 
+m.add_species_type(ORp) 
+m.add_species_type(ORpa) 
+m.add_species_type(T) 
+m.add_species_type(M) 
+m.add_species_type(Mribo) 
+
+# Reaction rules
+r1 = model.create_binding_reaction_rule(O, R, OR, k_fR)
 m.network_rules.add_reaction_rule(r1)
-r2 = create_unbinding_reaction_rule(OR, O, R, k_bR)
+r2 = model.create_unbinding_reaction_rule(OR, O, R, k_bR)
 m.network_rules.add_reaction_rule(r2)
-r3 = create_unimolecular_reaction_rule(O, ORp, k_f_rp)
+r3 = model.create_unimolecular_reaction_rule(O, ORp, k_f_rp)
 m.network_rules.add_reaction_rule(r3)
-r4 = create_unimolecular_reaction_rule(ORp, O, k_b_rp)
+r4 = model.create_unimolecular_reaction_rule(ORp, O, k_b_rp)
 m.network_rules.add_reaction_rule(r4)
-r5 = create_unimolecular_reaction_rule(ORp, ORpa, k_OC)
+r5 = model.create_unimolecular_reaction_rule(ORp, ORpa, k_OC)
 m.network_rules.add_reaction_rule(r5)
-r6 = create_unbinding_reaction_rule(ORpa, T, O, 1/t_clear)
+r6 = model.create_unbinding_reaction_rule(ORpa, T, O, 1/t_clear)
 m.network_rules.add_reaction_rule(r6)
-r7 = create_decay_reaction_rule(M, k_dm)
+r7 = model.create_decay_reaction_rule(M, k_dm)
 m.network_rules.add_reaction_rule(r7)
-r8 = create_unbinding_reaction_rule(M, M, Mribo, k_ribo)
+r8 = model.create_unbinding_reaction_rule(M, M, Mribo, k_ribo)
 m.network_rules.add_reaction_rule(r8)
-r9 = create_unimolecular_reaction_rule(Mribo, P, 1/t_trans)
+r9 = model.create_unimolecular_reaction_rule(Mribo, P, 1/t_trans)
 m.network_rules.add_reaction_rule(r9)
-r10 = create_decay_reaction_rule(P, k_dp)
+r10 = model.create_decay_reaction_rule(P, k_dp)
 m.network_rules.add_reaction_rule(r10)
 
-s.set_model(m)
+# World
+w = gfrdbase.create_world(m, 3)
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
 
-s.place_particle(O, [0,0,0])
+#####
 
-#s.throw_in_particles(R, 50, box1)
+#EMPTY = model.Species('EMPTY', 2e-12, 5e-8)
+
+#  1 2 O + R <-> OR
+#  3 4 O     <-> ORp
+#  5   ORp    -> ORpa
+#  6   ORpa   -> T + O
+#  7   M      -> EMPTY
+#  8   M      -> M + Mribo
+#  9   Mribo  -> P
+# 10   P      -> EMPTY
 
 
-l = Logger('pushpull')
-interrupter = FixedIntervalInterrupter(s, 1e-3, l)
+place_particle(w, O, [0,0,0])
+
+#s.throw_in_particles(R, 50, box1)
+
+l = logger.Logger('pushpull')
+interrupter = logger.FixedIntervalInterrupter(s, 1e-3, l.log)
 
 l.start(s)
 while s.t < 1000:

From 6d52dc81c2c3fddad0f1984c935761b8e5b3ec5a Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 20 May 2011 19:32:56 +0200
Subject: [PATCH 0057/1541] Worked on new sample: clustering.

---
 samples/cluster/run.py       | 171 +++++++++++++++++++++++++++++++++++
 samples/template/template.py |  14 ++-
 2 files changed, 180 insertions(+), 5 deletions(-)
 create mode 100644 samples/cluster/run.py

diff --git a/samples/cluster/run.py b/samples/cluster/run.py
new file mode 100644
index 00000000..fdcb0e22
--- /dev/null
+++ b/samples/cluster/run.py
@@ -0,0 +1,171 @@
+
+# Template file to copy and paste basic code from.
+
+# Modules
+# ===============================
+import sys
+#Also, set relative python path
+sys.path.append('../../')
+import os
+
+import math
+from egfrd import *
+import model
+import gfrdbase
+import _gfrd
+from visualization import vtklogger
+#import logger
+#import dumper
+#from bd import *
+
+
+# Constants
+# ===============================
+end_time = float(sys.argv[1])
+
+sigma = 1e-5        # Diameter particle; more realistic would be e-9
+D = 1e-12           # Diffusion constant
+world_size = 1e-3   # Lengths of simulation box
+
+
+# Functions
+# ===============================
+def cartesian(u1, u2, nx, ny):
+#    global cartesian_x, cartesian_y, u1, u2, nx, ny
+    cartesian_x = (nx * (u1[0]) + ny * (u2[0]))
+    cartesian_y = (ny * (u2[1]) + nx * (u1[1]))
+    return cartesian_x, cartesian_y
+
+def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
+    if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
+        return True
+    else:
+        return False
+
+def make_cluster(cluster_R):
+    global w, A #, u1, u2, cartesian_x, cartesian_y, nx, ny
+
+    # unit vectors make up grid to place particles on
+    u1 = [sigma+1e-10,0]
+    u2 = [math.cos((math.pi)/3.0)*(sigma+1e-10),math.sin((math.pi)/3.0)*(sigma+1e-10)] #TODO there is actually quite some space inbetween
+
+    # counters 
+    nx = 0
+    ny = 0
+    
+    cartesian_x = 0
+    cartesian_y = 0
+    cartesian_z = 0
+
+    # place particles on diagonal and right from it
+    while (1):
+        cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
+        print "placing on nx, ny: ", str(nx), ',',str(ny),\
+            "(x=", str(cartesian_x),",y=", str(cartesian_y), ")"
+        if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
+            place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
+        ny = ny+1      
+        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+            nx = nx+1
+            ny = 0
+            cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
+        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+            break
+    # place particles left from diagonal
+    print "other side"
+    nx = -1
+    ny = 2
+    while (1):
+        cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
+        print "placing on nx, ny: ", str(nx), ',',str(ny),\
+            "(x=", str(cartesian_x),",y=", str(cartesian_y), ")"
+        if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
+            place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
+        ny = ny+1      
+        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+            nx = nx-1
+            ny = nx*-2
+            cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
+        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+            break
+  
+
+# Basic set up simulator
+# ===============================
+# Model
+m = model.ParticleModel(world_size)
+# Species
+A = model.Species('A', 0, sigma/2)                                   
+m.add_species_type(A) 
+B = model.Species('B', D, sigma/2)                                   
+m.add_species_type(B) 
+# Reaction rules
+# r1 = model.create_binding_reaction_rule(A, B, X, k)
+# m.network_rules.add_reaction_rule(r1)
+
+# World
+w = gfrdbase.create_world(m, 3)
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
+
+# Throw in particles
+throw_in_particles(w, B, 2)
+
+# Put in cluster
+make_cluster(1e-4)
+
+# Enable VTK Logger
+# ===============================
+vtk_output_directory = 'VTK_out'
+if (os.path.exists(vtk_output_directory)):
+    print '** WARNING: VTK output directory already exists, possible '+ \
+            'present old VTK files might lead to errors.'
+l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+
+#TODO throw away:
+n=0
+# Running 
+# ===============================
+print "Setting up finished. Starting simtulation."
+while ((s.get_next_time() < end_time) or (n < 1)):
+    l.log()
+    s.step()
+    # Just making sure we have something to look at: TODO
+    n = n+1
+
+# TODO
+if (n<1):
+    s.stop(end_time)
+else:
+    s.stop(s.t)
+
+l.stop()
+
+print "Done, bye!"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/samples/template/template.py b/samples/template/template.py
index b2cd1d5e..c3f61968 100644
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -32,7 +32,7 @@
 m = model.ParticleModel(world_size)
 # Species
 X = model.Species('X', D, sigma/2)                                   
-m.add_species_type(A) 
+m.add_species_type(X) 
 # Reaction rules
 r1 = model.create_binding_reaction_rule(A, B, X, k)
 m.network_rules.add_reaction_rule(r1)
@@ -43,15 +43,15 @@
 s = EGFRDSimulator(w, myrandom.rng)
 
 # Throw in particles
-throw_in_particles(w, A, numberToThrowIn)
-
+throw_in_particles(w, X, numberToThrowIn)
+place_particle(world, X, [0,0,0])
 
 # Running 1
 # ===============================
-while (s.get_next_time() < end_time)
+while (s.get_next_time() < end_time):
     s.step()
 
-s.stop(s.end_time)
+s.stop(end_time)
     
 
 # Running 2
@@ -75,6 +75,10 @@
 from visualization import vtklogger
 l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
 
+# log a step
+l.log()
+# stop logger, writing away essential data
+l.stop()
 
 
 

From f5cd25dab85b8a2efbdf4d96db00405b12b2e5ed Mon Sep 17 00:00:00 2001
From: "Martijn.Wehrens" <wehrens@amolf.nl>
Date: Mon, 23 May 2011 10:07:43 +0200
Subject: [PATCH 0058/1541] Worked on cluster.

---
 samples/cluster/run.py | 90 +++++++++++++++++++++++++++++++-----------
 1 file changed, 68 insertions(+), 22 deletions(-)

diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index fdcb0e22..a6904ce8 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -30,24 +30,39 @@
 
 # Functions
 # ===============================
-def cartesian(u1, u2, nx, ny):
-#    global cartesian_x, cartesian_y, u1, u2, nx, ny
-    cartesian_x = (nx * (u1[0]) + ny * (u2[0]))
-    cartesian_y = (ny * (u2[1]) + nx * (u1[1]))
+def cartesian(g1, g2, nx, ny):
+#    global cartesian_x, cartesian_y, g1, g2, nx, ny
+    cartesian_x = (nx * (g1[0]) + ny * (g2[0]))
+    cartesian_y = (ny * (g2[1]) + nx * (g1[1]))
     return cartesian_x, cartesian_y
 
+def distance_to_circle_center(cartesian_x, cartesian_y, r_x, r_y):
+    return math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2))
+
 def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
     if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
         return True
     else:
         return False
 
-def make_cluster(cluster_R):
-    global w, A #, u1, u2, cartesian_x, cartesian_y, nx, ny
+def cluster_particle_coordinates(N):
+    global w, A #, g1, g2, cartesian_x, cartesian_y, nx, ny
+
+    # vectors that make up grid to place particles on
+    spacing = 1e-10 #TODO
+    d1 = [1,0]
+    d2 = [math.cos((math.pi)/3.0),math.sin((math.pi)/3.0)]
+    g1 = [(sigma+spacing)*d1[0], (sigma+spacing)*d1[1]]
+    g2 = [(sigma+spacing)*d2[0], (sigma+spacing)*d2[1]]
 
-    # unit vectors make up grid to place particles on
-    u1 = [sigma+1e-10,0]
-    u2 = [math.cos((math.pi)/3.0)*(sigma+1e-10),math.sin((math.pi)/3.0)*(sigma+1e-10)] #TODO there is actually quite some space inbetween
+    # Calculate conversion factor to calculate size square needed
+    factorNonCartesianGrid = math.sqrt(1/(d1[0]*d2[1]-d1[1]*d2[0]))
+    factroSquareToCircle = math.pi/2 #math.sqrt(math.pow((math.pi*0.5),2)) 
+    print "factorNonCartesianGrid:", str(factorNonCartesianGrid)
+    print "factroSquareToCircle:", str(factroSquareToCircle)
+
+    # Calculate length of square
+    L = (spacing+sigma)*math.sqrt(N)
 
     # counters 
     nx = 0
@@ -57,38 +72,69 @@ def make_cluster(cluster_R):
     cartesian_y = 0
     cartesian_z = 0
 
+    # list with possible cluster particle coordinates
+    clusterParticleCoordinates = []
+
     # place particles on diagonal and right from it
     while (1):
-        cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
+        cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
         print "placing on nx, ny: ", str(nx), ',',str(ny),\
             "(x=", str(cartesian_x),",y=", str(cartesian_y), ")"
-        if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
-            place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
+        #if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
+            # place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
+        distanceToCircle =\
+            distance_to_circle_center(cartesian_x,cartesian_y, 
+            L/2, L/2)
+        if (distanceToCircle < L/2):
+            clusterParticleCoordinates.append([
+                        distanceToCircle,
+                        cartesian_x, 
+                        cartesian_y, 
+                        cartesian_z
+                        ])
         ny = ny+1      
-        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+        if (cartesian_x > L or cartesian_y > L*2):
             nx = nx+1
             ny = 0
-            cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
-        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+            cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
+        if (cartesian_x > L*2 or cartesian_y > L*2):
             break
     # place particles left from diagonal
     print "other side"
     nx = -1
     ny = 2
     while (1):
-        cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
+        cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
         print "placing on nx, ny: ", str(nx), ',',str(ny),\
             "(x=", str(cartesian_x),",y=", str(cartesian_y), ")"
-        if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
-            place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
+        #if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
+            # place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
+        distanceToCircle =\
+            distance_to_circle_center(cartesian_x,cartesian_y, 
+            L/2, L/2)
+        if (distanceToCircle < L/2):
+            clusterParticleCoordinates.append([
+                        distanceToCircle,
+                        cartesian_x, 
+                        cartesian_y, 
+                        cartesian_z
+                        ])
         ny = ny+1      
-        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+        if (cartesian_x > L*2 or cartesian_y > L*2):
             nx = nx-1
             ny = nx*-2
-            cartesian_x, cartesian_y = cartesian(u1, u2, nx, ny)
-        if (cartesian_x > cluster_R*2 or cartesian_y > cluster_R*2):
+            cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
+        if (cartesian_x > L*2 or cartesian_y > L*2):
             break
-  
+
+    return clusterParticleCoordinates
+
+def make_cluster(N): #TODO: maak optie dat ie zowel R als N aankan
+    cluster_particle_coordinates(N)
+    print str(cluster_particle_coordinates)
+
+    # Create list of 
+
 
 # Basic set up simulator
 # ===============================

From e839f957d7916af578f9ec4bd40036f3745d22dc Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 24 May 2011 11:31:19 +0200
Subject: [PATCH 0059/1541] More on cluster rebinding.

---
 samples/cluster/run.py | 385 +++++++++++++++++++++++++----------------
 1 file changed, 238 insertions(+), 147 deletions(-)

diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index a6904ce8..73c94b2f 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -1,5 +1,20 @@
 
-# Template file to copy and paste basic code from.
+# Rebinding to a cluster
+
+# Run by:
+# $ python run.py [N] [runs] [outFilename] [Logmode=False]
+#
+# Arguments:
+#   - N: Number of particles in cluster
+#   - runs: Number of simulation runs
+#   - outFilename: Name of output file
+#   - Logmode: false by default, if True, only 1 VTK-logged run is
+#     performed.    
+#
+# E.g.:
+# $ python run.py 7 1000 data.out
+# Or:
+# $ python run.py 7 1 data.out True
 
 # Modules
 # ===============================
@@ -7,6 +22,7 @@
 #Also, set relative python path
 sys.path.append('../../')
 import os
+import shutil
 
 import math
 from egfrd import *
@@ -21,188 +37,263 @@
 
 # Constants
 # ===============================
-end_time = float(sys.argv[1])
-
+# Number of particles in the cluster
+N = int(sys.argv[1])
+# Number of runs
+runs = int(sys.argv[2])
+# Output file
+outFilename = sys.argv[3]
+# LOGGING mode
+try: 
+    LOGGING = bool(sys.argv[4])
+    if (LOGGING==True): 
+        print "* Performing only 1 logging run."
+        runs = 1
+except: LOGGING = False
+
+
+EARLY_STOP = 500
 sigma = 1e-5        # Diameter particle; more realistic would be e-9
-D = 1e-12           # Diffusion constant
+D = 1e-8            # Diffusion constant; 1e-12 would be more realistic
 world_size = 1e-3   # Lengths of simulation box
 
+k1 = 1e-10
+k2 = 1e2
+
+# Spacing inbetween cluster particles AND cluster/B-particle
+spacing = sigma/1e5
+
 
 # Functions
 # ===============================
-def cartesian(g1, g2, nx, ny):
-#    global cartesian_x, cartesian_y, g1, g2, nx, ny
-    cartesian_x = (nx * (g1[0]) + ny * (g2[0]))
-    cartesian_y = (ny * (g2[1]) + nx * (g1[1]))
+def cartesian(g1, g2, ng1, ng2):
+    """ Converts lattice coordinates (ng1, ng2) to cartesian coordinates
+    
+    Arguments:
+        - Lattice vectors g1=[x1,y1] and g2=[x2,y2]
+        - Lattice coordinates (ng1, ng2)
+
+    """
+    cartesian_x = (ng1 * (g1[0]) + ng2 * (g2[0]))
+    cartesian_y = (ng2 * (g2[1]) + ng1 * (g1[1]))
     return cartesian_x, cartesian_y
 
-def distance_to_circle_center(cartesian_x, cartesian_y, r_x, r_y):
-    return math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2))
+def distance(x1, y1, x2, y2):
+    """ Calculates the distance between points (x1, y1) and (x2, y2) """
+    return math.sqrt(math.pow((x1-x2),2)+math.pow((y1-y2),2))
 
-def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
-    if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
-        return True
-    else:
-        return False
+def generate_possible_positions(N):
+    """ Generates a list with possible coordinates and distances to center
 
-def cluster_particle_coordinates(N):
-    global w, A #, g1, g2, cartesian_x, cartesian_y, nx, ny
+    This function does the following:
+        - It loops over square area of an hexagonal lattice (of size 
+          calculated to facilitate N particles) 
+        - Lattice coordinates and distance to the center of the area 
+          are stored if they are within circular boundaries. (The 
+          latter check is only done to be absolutely sure a circular 
+          shape is formed.)
 
-    # vectors that make up grid to place particles on
-    spacing = 1e-10 #TODO
-    d1 = [1,0]
-    d2 = [math.cos((math.pi)/3.0),math.sin((math.pi)/3.0)]
-    g1 = [(sigma+spacing)*d1[0], (sigma+spacing)*d1[1]]
-    g2 = [(sigma+spacing)*d2[0], (sigma+spacing)*d2[1]]
+    This information can be used in a later function. If the list of
+    generated coordinates is sorted by distance to the center, N 
+    particles can be placed within a circular geometry by looping over
+    the coordinates.
 
-    # Calculate conversion factor to calculate size square needed
-    factorNonCartesianGrid = math.sqrt(1/(d1[0]*d2[1]-d1[1]*d2[0]))
-    factroSquareToCircle = math.pi/2 #math.sqrt(math.pow((math.pi*0.5),2)) 
-    print "factorNonCartesianGrid:", str(factorNonCartesianGrid)
-    print "factroSquareToCircle:", str(factroSquareToCircle)
+    Arguments:
+        - N: number of particles to place.
 
-    # Calculate length of square
-    L = (spacing+sigma)*math.sqrt(N)
+    """
+    global w, A, spacing, sigma #, g1, g2, cartesian_x, cartesian_y, ng1, ng2
 
-    # counters 
-    nx = 0
-    ny = 0
-    
+    # Lattice vectors
+    d1 = [1,0]
+    d2 = [math.cos((math.pi)/3.0),math.sin((math.pi)/3.0)]
+    # Scaled lattice vectors
+    lengthLatticeVector = (sigma+spacing)
+    g1 = [lengthLatticeVector*d1[0], lengthLatticeVector*d1[1]]
+    g2 = [lengthLatticeVector*d2[0], lengthLatticeVector*d2[1]]
+
+    # Factors to calculate square area of lattice needed
+    """
+    factorNonSquareGrid = math.sqrt(1/(d1[0]*d2[1]-d1[1]*d2[0]))
+    factorSquareToCircle = math.pi/2 #math.sqrt(math.pow((math.pi*0.5),2)) 
+    # Calculate diameter of sphere
+    L = (spacing+sigma)*(math.ceil(math.sqrt(N))+2)*factorNonSquareGrid*factorSquareToCircle
+        # "(math.ceil(math.sqrt(N))+2)"; ceil and +2: some margin
+    diamondSide = (L/2)*math.tan(pi/6)+(L/2)/math.tan(pi/6)
+    diamondDiagonal = sin(pi/3)*L #2*sin(pi/3)*L/2
+    """
+    # d1x*d2y-d1y*d2x
+    diamondToSquare = math.sqrt((4*d2[0]*d2[1])/(0.25*math.pi))
+    vectorsOnDiameter = math.ceil(math.sqrt(N)+2)
+    numberOfVectors = diamondToSquare * vectorsOnDiameter
+
+    diameterCircle = math.ceil(math.sqrt(N)+2)*lengthLatticeVector
+    radiusCircle = diameterCircle/2
+
+    # Cartesian coordinates
     cartesian_x = 0
     cartesian_y = 0
     cartesian_z = 0
 
-    # list with possible cluster particle coordinates
+    # The list with possible coordinates and distances to center
     clusterParticleCoordinates = []
 
-    # place particles on diagonal and right from it
-    while (1):
-        cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
-        print "placing on nx, ny: ", str(nx), ',',str(ny),\
-            "(x=", str(cartesian_x),",y=", str(cartesian_y), ")"
-        #if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
-            # place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
-        distanceToCircle =\
-            distance_to_circle_center(cartesian_x,cartesian_y, 
-            L/2, L/2)
-        if (distanceToCircle < L/2):
-            clusterParticleCoordinates.append([
-                        distanceToCircle,
-                        cartesian_x, 
-                        cartesian_y, 
-                        cartesian_z
-                        ])
-        ny = ny+1      
-        if (cartesian_x > L or cartesian_y > L*2):
-            nx = nx+1
-            ny = 0
-            cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
-        if (cartesian_x > L*2 or cartesian_y > L*2):
-            break
-    # place particles left from diagonal
-    print "other side"
-    nx = -1
-    ny = 2
-    while (1):
-        cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
-        print "placing on nx, ny: ", str(nx), ',',str(ny),\
-            "(x=", str(cartesian_x),",y=", str(cartesian_y), ")"
-        #if in_circle(cartesian_x, cartesian_y, cluster_R, cluster_R, cluster_R):
-            # place_particle(w, A, [cartesian_x, cartesian_y, cartesian_z])
-        distanceToCircle =\
-            distance_to_circle_center(cartesian_x,cartesian_y, 
-            L/2, L/2)
-        if (distanceToCircle < L/2):
-            clusterParticleCoordinates.append([
-                        distanceToCircle,
-                        cartesian_x, 
-                        cartesian_y, 
-                        cartesian_z
-                        ])
-        ny = ny+1      
-        if (cartesian_x > L*2 or cartesian_y > L*2):
-            nx = nx-1
-            ny = nx*-2
-            cartesian_x, cartesian_y = cartesian(g1, g2, nx, ny)
-        if (cartesian_x > L*2 or cartesian_y > L*2):
-            break
+    for ng1 in range(int(-math.ceil(numberOfVectors/2)), 
+                            int(math.ceil(numberOfVectors/2))):
+        for ng2 in range(int(-math.ceil(numberOfVectors/2)), 
+                                int(math.ceil(numberOfVectors/2))):
+            cartesian_x, cartesian_y = cartesian(g1, g2, ng1, ng2)
+            distanceToCenter = distance(cartesian_x, cartesian_y, 0, 0)
+            if (distanceToCenter < radiusCircle):
+                clusterParticleCoordinates.append([
+                            distanceToCenter,
+                            cartesian_x, 
+                            cartesian_y, 
+                            cartesian_z
+                            ])
+    
 
     return clusterParticleCoordinates
 
-def make_cluster(N): #TODO: maak optie dat ie zowel R als N aankan
-    cluster_particle_coordinates(N)
-    print str(cluster_particle_coordinates)
-
-    # Create list of 
-
+def make_cluster(N, coord_x, coord_y, coord_z): 
+    """ Places N particles on hexagonal lattice in spherical symmetry
+
+    Arguments:
+        - N: number of particles to place
+        - coord_x, coord_y, coord_z: Coordinates where to place cluster
+    """
+    # Generate list of positions and there distance to the center
+    clusterParticleCoordinates = generate_possible_positions(N)
+    # Sort this list
+    clusterParticleCoordinates.sort(key=lambda x: x[0])
+
+    # Place center particle
+    place_particle(w, C,
+         [clusterParticleCoordinates[0][1]+coord_x, 
+          clusterParticleCoordinates[0][2]+coord_y,
+          clusterParticleCoordinates[0][3]+coord_z])
+    # Place N particles starting with the particle closest to the
+    # center, then placing the second closest particle, etc..
+    for i in range(1,N):
+        try:
+            place_particle(w, A,
+                [clusterParticleCoordinates[i][1]+coord_x, 
+                 clusterParticleCoordinates[i][2]+coord_y,
+                 clusterParticleCoordinates[i][3]+coord_z])
+        except: 
+            print "ERROR: couldn't place particle."
+
+def single_run(N, LOGGING):
+    """ Single run of simulation """
+    global w, A, C, k1, k2
+    # Basic set up simulator
+    # ===============================
+    # Model
+    m = model.ParticleModel(world_size)
+    # Species
+    A = model.Species('A', 0, sigma/2)                                   
+    m.add_species_type(A) 
+    B = model.Species('B', D, sigma/2)                                   
+    m.add_species_type(B) 
+    C = model.Species('C', 0, sigma/2)                                   
+    m.add_species_type(C) 
+    # Reaction rules
+    r1 = model.create_binding_reaction_rule(A, B, C, k1)
+    m.network_rules.add_reaction_rule(r1)
+    r2 = model.create_unbinding_reaction_rule(C, A, B, k2)
+    m.network_rules.add_reaction_rule(r2)
+
+    # World
+    w = gfrdbase.create_world(m, 3)
+    # Simulator
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    # Put in cluster
+    make_cluster(N, world_size/2, world_size/2, world_size/2)
+
+    # Put in reactants
+    # place_particle(w, B, [world_size/2, world_size/2, world_size/2+sigma+spacing])    
+
+    # Enable VTK Logger
+    # ===============================
+    if (LOGGING == True):
+        vtk_output_directory = 'VTK_out'
+        if (os.path.exists(vtk_output_directory)):
+            if (shutil.rmtree(vtk_output_directory)):
+                print '** TRASHED old vtk directory'            
+            else:
+                print '** ERROR removing old vtk directory'
+        l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+    
+    # Running 
+    # ===============================
+    numberDetected = 0
+
+    if (LOGGING == True):
+        while 1:
+            l.log() # log
+            s.step() # and make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t
+                    break  
+        l.stop() 
+    else:
+        while 1:
+            s.step() # make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t
+                    break  
 
-# Basic set up simulator
-# ===============================
-# Model
-m = model.ParticleModel(world_size)
-# Species
-A = model.Species('A', 0, sigma/2)                                   
-m.add_species_type(A) 
-B = model.Species('B', D, sigma/2)                                   
-m.add_species_type(B) 
-# Reaction rules
-# r1 = model.create_binding_reaction_rule(A, B, X, k)
-# m.network_rules.add_reaction_rule(r1)
-
-# World
-w = gfrdbase.create_world(m, 3)
-# Simulator
-s = EGFRDSimulator(w, myrandom.rng)
-
-# Throw in particles
-throw_in_particles(w, B, 2)
-
-# Put in cluster
-make_cluster(1e-4)
-
-# Enable VTK Logger
-# ===============================
-vtk_output_directory = 'VTK_out'
-if (os.path.exists(vtk_output_directory)):
-    print '** WARNING: VTK output directory already exists, possible '+ \
-            'present old VTK files might lead to errors.'
-l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
-
-#TODO throw away:
-n=0
-# Running 
-# ===============================
-print "Setting up finished. Starting simtulation."
-while ((s.get_next_time() < end_time) or (n < 1)):
-    l.log()
-    s.step()
-    # Just making sure we have something to look at: TODO
-    n = n+1
-
-# TODO
-if (n<1):
-    s.stop(end_time)
-else:
     s.stop(s.t)
+    return (reaction_time)
+    
+# Main part
+# ===============================
 
-l.stop()
-
-print "Done, bye!"
-
-
-
-
-
+# Output file
+outFile = open(outFilename, 'w')
+outFile.close()
+outFile = open(outFilename, 'a')
 
+for M in range(runs):
+    outFile.write(str(single_run(N, LOGGING)) + '\n')    
 
+outFile.close()
 
 
+# #### OLD CODE
+#def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
+#    if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
+#        return True
+#    else:
+#        return False
 
 
+    # while end time hasn't come and #timesteps still below limit
+    # while ((s.get_next_time() < endTime) and (n < EARLY_STOP)): # TODO
 
 
+    # Terminate the simulation at appropriate time
 
+    #"""
+    #if (n >= EARLY_STOP):
+    #    print "Early stop (timestep limit)."
+    #    s.stop(s.t)
+    #    reaction_time = INF
+    #else:
+    #    print "Early stop (time limit)."
+    #    s.stop(s.get_next_time())
+    #    reaction_time = INF
+    #"""
 
+    # Make sure logger writes away information.
+    # l.stop() #TODO REMOVED LOGGING
 
 
 

From 851344a586defda9eb3b9ab3404d47fd16c746a4 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 24 May 2011 15:49:05 +0200
Subject: [PATCH 0060/1541] Almost final cluster example run file. Still have
 to make some doc- umentatoin though.

~MW.
---
 samples/cluster/run.py | 47 ++++++++++++++++++++++++++----------------
 1 file changed, 29 insertions(+), 18 deletions(-)

diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index 73c94b2f..985ebad9 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -2,7 +2,7 @@
 # Rebinding to a cluster
 
 # Run by:
-# $ python run.py [N] [runs] [outFilename] [Logmode=False]
+# $ python run.py [N] [runs] [outFilename] [Logmode, default=False]
 #
 # Arguments:
 #   - N: Number of particles in cluster
@@ -30,9 +30,6 @@
 import gfrdbase
 import _gfrd
 from visualization import vtklogger
-#import logger
-#import dumper
-#from bd import *
 
 
 # Constants
@@ -51,11 +48,10 @@
         runs = 1
 except: LOGGING = False
 
-
-EARLY_STOP = 500
-sigma = 1e-5        # Diameter particle; more realistic would be e-9
-D = 1e-8            # Diffusion constant; 1e-12 would be more realistic
-world_size = 1e-3   # Lengths of simulation box
+# Particle constants
+sigma = 1e-5        # Diameter particle; big:1e-5
+D = 1e-8            # Diffusion constant; big:1e-8
+world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
 
 k1 = 1e-10
 k2 = 1e2
@@ -63,6 +59,21 @@
 # Spacing inbetween cluster particles AND cluster/B-particle
 spacing = sigma/1e5
 
+# Seed in case of Logging mode
+# ===============================
+if (LOGGING == True):
+    import datetime    
+    myrandom.seed(long(datetime.datetime.now().year*3600*24*365+
+    datetime.datetime.now().month*30.5*24*3600+
+    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+    datetime.datetime.now().minute*60+datetime.datetime.now().second))
+ 
+    seed = long(datetime.datetime.now().year*3600*24*365+
+    datetime.datetime.now().month*30.5*24*3600+
+    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+    datetime.datetime.now().minute*60+datetime.datetime.now().second)
+    print str('Seed: '+str(seed))
+
 
 # Functions
 # ===============================
@@ -205,7 +216,7 @@ def single_run(N, LOGGING):
 
     # World
     w = gfrdbase.create_world(m, 3)
-    # Simulator
+    # Simulator   
     s = EGFRDSimulator(w, myrandom.rng)
 
     # Put in cluster
@@ -219,10 +230,7 @@ def single_run(N, LOGGING):
     if (LOGGING == True):
         vtk_output_directory = 'VTK_out'
         if (os.path.exists(vtk_output_directory)):
-            if (shutil.rmtree(vtk_output_directory)):
-                print '** TRASHED old vtk directory'            
-            else:
-                print '** ERROR removing old vtk directory'
+            print '** Warning: VTK directory already exists.'
         l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
     
     # Running 
@@ -236,9 +244,10 @@ def single_run(N, LOGGING):
             if s.last_reaction:
                 numberDetected = numberDetected+1
                 if (numberDetected == 2):
-                    print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
-                    reaction_time = s.t
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
                     break  
+                else: previous_time = s.t
         l.stop() 
     else:
         while 1:
@@ -246,9 +255,10 @@ def single_run(N, LOGGING):
             if s.last_reaction:
                 numberDetected = numberDetected+1
                 if (numberDetected == 2):
-                    print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
-                    reaction_time = s.t
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
                     break  
+                else: previous_time = s.t
 
     s.stop(s.t)
     return (reaction_time)
@@ -268,6 +278,7 @@ def single_run(N, LOGGING):
 
 
 # #### OLD CODE
+
 #def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
 #    if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
 #        return True

From 5a692aeba4c278853752f137cb547b1d2a12cf30 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 24 May 2011 15:51:14 +0200
Subject: [PATCH 0061/1541] Addition of more user-friendly VTK interface.

Should perhaps also here add README file. (Though somewhere is an
old description by Thomie.)

~MW
---
 visualization/run_pipeline.py | 53 +++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 visualization/run_pipeline.py

diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
new file mode 100644
index 00000000..6aeb4a65
--- /dev/null
+++ b/visualization/run_pipeline.py
@@ -0,0 +1,53 @@
+# Test run of VTK-logger by MW - Adapted from Tomek
+
+# ### INSTRUCTIONS ###
+"""
+1. Set the directories with which the script should work:
+"""
+# Root directory of the eGFRD algorithm files:
+# Use the full path (e.g. NOT a tilde)
+egfrd_directory ='/storage1/wehrens/myfork_egfrd/'
+# Output directory of the VTK logger 
+# (This was defined when calling the logger in your
+# script.)
+simulation_data_directory = egfrd_directory + \
+    'samples/cluster/VTK_out/'
+"""
+
+2. Start ParaView. Make sure you give Paraview the PYTHONPATH 
+   information:
+
+    This means, in bash:
+    $ export PYTHONPATH=/usr/lib/paraview/
+    $ paraview
+
+3. In ParaView, select tools > python shell > run script. Then
+   select this script. If everything went well, you've now 
+   imported the data correctly in ParaView.
+
+"""
+
+
+
+# paraview_directory = '/usr/lib/paraview/'
+
+# Make sure python knows where to find eGFRD files
+import sys
+sys.path.append(egfrd_directory)
+# sys.path.append(paraview_directory)
+
+
+# import the pipeline script - which converts the VTKlogger data to data
+# Paraview can understand.
+from visualization import pipeline
+
+# Create pipeline.
+p = pipeline.Pipeline(egfrd_directory, simulation_data_directory)
+
+# Script constants
+p.particle_radius_scale_factor = 1
+p.helix_radius_scale_factor = 1
+p.cylinder_radius_scale_factor = 1
+
+# Go!
+p.rebuild()

From e236af9bf03e7d936343725393d0747092197649 Mon Sep 17 00:00:00 2001
From: Thomas Miedema <thomasmiedema@gmail.com>
Date: Tue, 24 May 2011 23:03:27 +0200
Subject: [PATCH 0062/1541] Don't burst and reschedule singles with D = 0

---
 egfrd.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index b3abadcf..2b9a04bf 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -995,6 +995,10 @@ def burst_single(self, single):
         assert self.t >= single.last_time
         assert self.t <= single.last_time + single.dt
 
+        if single.dt == numpy.inf:
+            # Performance only: don't reschedule singles with D=0.
+            return single
+
         oldpos = single.shell.shape.position
         old_shell_size = single.get_shell_size()
 

From 04f60cce2237a4db4c7aa9b00d606281638fb746 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 26 May 2011 12:18:03 +0200
Subject: [PATCH 0063/1541] Some random work.

---
 bd.py                        |  4 ++--
 samples/irreversible/README  |  4 ++--
 samples/rebind/run.py        | 14 ++++----------
 samples/template/README      | 34 +++-------------------------------
 samples/template/template.py |  2 +-
 5 files changed, 12 insertions(+), 46 deletions(-)

diff --git a/bd.py b/bd.py
index 2cd926ca..37bdcbf0 100644
--- a/bd.py
+++ b/bd.py
@@ -37,12 +37,12 @@ def calculate_bd_dt(species_list):
 
 
 class BDSimulatorCore(object):
-    '''
+    """
     BDSimulatorCore borrows the following from the main simulator:
     - species_list
     - reaction_types list (both 1 and 2)
     
-    '''
+    """
     def __init__(self, world, rng, network_rules, dissociation_retry_moves):
         self.world = world
         self.rng = rng
diff --git a/samples/irreversible/README b/samples/irreversible/README
index 23a3e192..8958123f 100644
--- a/samples/irreversible/README
+++ b/samples/irreversible/README
@@ -21,11 +21,11 @@ The following command runs the simulation until a reaction occurs
 or the simulator reaches time T, output the distance between
 A and B to the file OUTFILE, and repeat this for N times.
 
-PYTHONPATH=../../.. python run.py OUTFILE T N
+PYTHONPATH=../../ python run.py OUTFILE T N
 
 For example:
 
-PYTHONPATH=../../.. python run.py irr.out 0.0001 
+PYTHONPATH=../../ python run.py irr.out 0.0001 10
 
 
 
diff --git a/samples/rebind/run.py b/samples/rebind/run.py
index e79489a5..1e69b2ab 100644
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -61,7 +61,6 @@ def run(outfilename, N_B, N_X, N, T_list):
     for i in range(N):
 
         # Perform a single simulation run
-        print "###### Run " + str(i) + "."
         r_list, t_list = singlerun(T_list, N_B, N_X)
 
         # Write away time data
@@ -77,10 +76,6 @@ def run(outfilename, N_B, N_X, N, T_list):
             outfile_r.write(str(r_list[j]) + '\n')
             outfile_r.close()
 
-        # Print to screen.
-        print "* Output: t_list=" + str(t_list)
-        print "* Output: r_list=" + str(r_list)
-
         # Make sure script writes data NOW
         outfile_t.flush()
 
@@ -185,7 +180,6 @@ def singlerun(T_list, N_B, N_X):
         for d in dd:
             for p in d.particle_id_pair:
                 s.remove_particle(p)
-                print "* Removing particle to make space for A.."
         s.throw_in_particles(X, len(pp), box1)
 
     place_particle(w, A, A_pos)
@@ -201,7 +195,6 @@ def singlerun(T_list, N_B, N_X):
         for d in dd:
             for p in d.particle_id_pair:
                 s.remove_particle(p)
-                print "* Removing particle to make space for B.."
         s.throw_in_particles(X, len(pp), box1)
 
     place_particle(w, B, B_pos) 
@@ -235,7 +228,7 @@ def singlerun(T_list, N_B, N_X):
         #       In this case: record the time binding lasted, i.e. dt between
         #       current time (s.t) and last reaction time (t_last).
         if s.last_reaction: # aka if there was a reaction
-            print "* Reaction detected at: " + str(s.last_reaction)
+
             if len(s.world.get_particle_ids(C.id)) == 0:  #A,B
                 print '    - set t_last', str(s.t)
                 # set t_last to "current time" in simulator
@@ -267,13 +260,12 @@ def singlerun(T_list, N_B, N_X):
                     B_pos = s.get_position(particle_id)
                     distance = w.distance(A_pos, B_pos)
                     distance_list.append(distance)
-                    print "* Measured distance = " + str(distance)
+
                 # Write list to distances table
                 r_list.append(distance_list)
 
             i_T += 1
             next_stop = T_list[i_T]
-            print "* Done, returning to simulation loop."
         
         # If there are no measuring moments on the list any more, and
         # a duration of being bounded has been recorded, then stop
@@ -298,6 +290,8 @@ def singlerun(T_list, N_B, N_X):
     run('data/rebind', float(sys.argv[1]), 
         int(sys.argv[2]), int(sys.argv[3]), T_list)
 
+    print "Done."
+
 
 
 
diff --git a/samples/template/README b/samples/template/README
index 9ba19558..066a9671 100644
--- a/samples/template/README
+++ b/samples/template/README
@@ -1,35 +1,7 @@
 
 
-General lay-out of a simulation
+Template
 =====================================
 
-
-
-    # ### Import correct modules
-import sys
-from egfrd import *
-from bd import *
-import model
-import gfrdbase
-import myrandom
-
-    # ### Define model
-
-    m = model.ParticleModel(1e-3)
-
-    A = model.Species('A', 0.0, sigma/2)
-    m.add_species_type(A)
-
-    r1 = model.create_binding_reaction_rule(A, B, C, kf)
-    m.network_rules.add_reaction_rule(r1)
-
-    # ### Set up simulator
-
-
-    w = gfrdbase.create_world(m, 3)
-    nrw = gfrdbase.create_network_rules_wrapper(m)
-    s = EGFRDSimulator(w, myrandom.rng, nrw)
-
-    # ### Place particles 
-
-    # ### Run simulation
+This folder contains a template python file from which you can copy
+and paste some often used python eGFRD commands to get you started.
diff --git a/samples/template/template.py b/samples/template/template.py
index c3f61968..6bd38cd5 100644
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -44,7 +44,7 @@
 
 # Throw in particles
 throw_in_particles(w, X, numberToThrowIn)
-place_particle(world, X, [0,0,0])
+place_particle(w, X, [0,0,0])
 
 # Running 1
 # ===============================

From c79573fbd5ef292e781f36a0a912a75d909429d5 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <spam@Jintram.nl>
Date: Thu, 26 May 2011 06:43:15 -0700
Subject: [PATCH 0064/1541] Fixed assertion where timeline is checked. First
 broke when single.dt was inf.

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 2b9a04bf..4d24419e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -685,7 +685,7 @@ def propagate_single(self, single):
             return single
 
     def fire_single(self, single):
-        assert abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t
+        assert ((abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t) or (single.dt == numpy.inf))
 
         # Reaction.
         if single.event_type == EventType.SINGLE_REACTION:

From 9507339d32a1965f6fa876599aa1b3de3c0b1aff Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <spam@Jintram.nl>
Date: Thu, 26 May 2011 07:33:33 -0700
Subject: [PATCH 0065/1541] Reverted last commit. Should be put more though
 into this.

See also https://github.com/gfrd/egfrd/issues/10.
---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 4d24419e..a4a629e0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -685,7 +685,7 @@ def propagate_single(self, single):
             return single
 
     def fire_single(self, single):
-        assert ((abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t) or (single.dt == numpy.inf))
+        assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
         # Reaction.
         if single.event_type == EventType.SINGLE_REACTION:

From 60e74a0a0b27281e58c2dda21bc6c039d787c8d2 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Fri, 27 May 2011 20:03:03 +0200
Subject: [PATCH 0066/1541] Update in egfrd.py to better deal with dt = inf.
 Also update in sample dir.

egfrd.py
================
- Added some additional comments. Mostly marked with "~MW". Please revise!
- Removed performance line in burst_single. This even introduced incorrect behaviour when dealing with dt = inf.
- Added handling of "do nothing" events. I.e. when dt = infinity. (Thomas Miedema's idea.)

samples
================
Added README files and fixed most of them.
---
 egfrd.py                       | 32 ++++++++----
 samples/README                 | 89 ++++++++++++++++++++++++++++++++++
 samples/cluster/run.py         | 33 +++++++------
 samples/hardbody/README        | 14 ++++++
 samples/hardbody/run_single.py | 12 +++--
 samples/rebind/README          |  2 +-
 6 files changed, 154 insertions(+), 28 deletions(-)
 create mode 100644 samples/README

diff --git a/egfrd.py b/egfrd.py
index b8b169cf..8d72d66d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -129,7 +129,7 @@ def get_next_time(self):
         """ 
         Returns the time it will be when the next egfrd timestep
         is completed.        
-        """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
+        """ #~MW
         if self.scheduler.size == 0:
             return self.t
 
@@ -152,7 +152,7 @@ def reset(self):
         are reset, etc.
         Can be for example usefull when users want to "stirr" the 
         simulation before starting the "real experiment".
-        """ #TODO: Added by wehrens@AMOLF.nl; Please revise.
+        """ #~ MW
         self.t = 0.0
         self.dt = 0.0
         self.step_counter = 0
@@ -291,13 +291,17 @@ def step(self):
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
        
+        # Dispatch is simply dict of what function to use to fire for 
+        # different classes (see bottom egfrd.py) 
+        # event.data simply holds the data of the next event.
+        # e.g. "if class is single fire single" ~ MW
         for klass, f in self.dispatch:
             if isinstance(event.data, klass):
                 f(self, event.data)
 
         if __debug__:
             if self.scheduler.size == 0:
-                raise RuntimeError('Zero particles left.')
+                raise RuntimeError('Zero events left.')
 
         next_time = self.scheduler.top[1].time
         self.dt = next_time - self.t
@@ -538,7 +542,7 @@ def clear_volume(self, pos, radius, ignore=[]):
             - pos: position of area to be "bursted"
             - radius: radius of area to be "bursted"
             - ignore: domains that should be ignored, none by default.
-        """ # Added by wehrens@amolf.nl; please revise
+        """ # ~ MW
         neighbors = self.get_neighbors_within_radius_no_sort(pos, radius,
                                                              ignore)
         return self.burst_objs(neighbors)
@@ -710,7 +714,14 @@ def propagate_single(self, single):
             return single
 
     def fire_single(self, single):
-        assert abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t
+
+        # In case nothing is scheduled to happen: do nothing; 
+        # results also in disappearance from scheduler.
+        if single.dt == numpy.inf:
+            return single 
+        
+        # Otherwise check timeline
+        assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
         # Reaction.
         if single.event_type == EventType.SINGLE_REACTION:
@@ -1017,13 +1028,15 @@ def burst_multi(self, multi):
         return singles
 
     def burst_single(self, single):
+        # Sets next event time of single domain in such a way it will end 
+        # up at current time if fired, and then outputs newly created 
+        # single that is result of firing old single
+
+        # Check correct timeline ~ MW
         assert self.t >= single.last_time
         assert self.t <= single.last_time + single.dt
 
-        if single.dt == numpy.inf:
-            # Performance only: don't reschedule singles with D=0.
-            return single
-
+        # record important single data ~ MW
         oldpos = single.shell.shape.position
         old_shell_size = single.get_shell_size()
 
@@ -1036,6 +1049,7 @@ def burst_single(self, single):
         newsingle = self.propagate_single(single)
 
         newpos = newsingle.pid_particle_pair[1].position
+        # Check if stays within domain ~MW
         assert self.world.distance(newpos, oldpos) <= \
                old_shell_size - particle_radius
         # Displacement check is in NonInteractionSingle.draw_new_position.
diff --git a/samples/README b/samples/README
new file mode 100644
index 00000000..630e4ec8
--- /dev/null
+++ b/samples/README
@@ -0,0 +1,89 @@
+Introduction
+=====================================
+When this README file was written, all Python code was checked for 
+functionality. C++ files might still be in development (and thus non-
+functional). Below one can find the contents of the samples directory,
+sorted by function.
+
+Contents
+=====================================
+See READMEs in sample folders for more information.
+
+    Tutorial & Template
+    =================================
+    - template
+    Contains template file to copy&paste some eGFRD code from. 
+    - tutorial 
+    Non-existent yet. ("TODO")
+    - simple
+    Instructive on how to use the logger.
+
+    Examples
+    =================================
+    (alphabetical order)
+    - cluster
+    Measures unbinding/rebinding-time of molecule released from cluster.
+    - irreversible
+    Samples distance between two reagents placed next to each other, also 
+    outputs reaction time.
+    - mapk
+    Script used for publication; Not looked into when this README file was
+    written. ("TODO")
+    - pushpull
+    Pushpull example. Has no README file yet either. ("TODO")
+    - rebind
+    Measures reaction time and distances inbetween two molecules placed 
+    right next to each other. Has option to add multiple particles of one
+    reacting species, and option to add particles of non-reactive species.
+    - reversible
+    Does the same as rebind, but with two particles only.
+    - single
+    Defective example ("TODO"). 
+    - tf
+    ? ("TODO")
+    
+
+    Benchmarking
+    =================================
+    - benchmark
+    Benchmarking utility that uses C++ part of code.
+    - dimer
+    Script that profiles the eGFRD algorithm. 
+    - hardbody
+    Runs a model composed of a single, non-reactive species. Outputs
+    runtimes simulation runs.
+
+    Testing
+    =================================
+    - bd_propagator
+    Tests for the C++ version of the Brownian Dynamics simulator.
+
+    - bd_test
+    This folder will in the future hold scripts to test the Brownian
+    Dynamics part of the code.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index 985ebad9..448304df 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -19,10 +19,11 @@
 # Modules
 # ===============================
 import sys
-#Also, set relative python path
+#Also, set relative egfrd directory path
 sys.path.append('../../')
 import os
 import shutil
+import datetime
 
 import math
 from egfrd import *
@@ -59,20 +60,15 @@
 # Spacing inbetween cluster particles AND cluster/B-particle
 spacing = sigma/1e5
 
-# Seed in case of Logging mode
+# Create "unique" seed
 # ===============================
-if (LOGGING == True):
-    import datetime    
-    myrandom.seed(long(datetime.datetime.now().year*3600*24*365+
-    datetime.datetime.now().month*30.5*24*3600+
-    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
-    datetime.datetime.now().minute*60+datetime.datetime.now().second))
- 
-    seed = long(datetime.datetime.now().year*3600*24*365+
-    datetime.datetime.now().month*30.5*24*3600+
-    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
-    datetime.datetime.now().minute*60+datetime.datetime.now().second)
-    print str('Seed: '+str(seed))
+currenttime = (long(datetime.datetime.now().year*3600*24*365+
+datetime.datetime.now().month*30.5*24*3600+
+datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+datetime.datetime.now().minute*60+datetime.datetime.now().second))
+myrandom.seed(currenttime)
+
+print str('Seed: '+str(currenttime))
 
 
 # Functions
@@ -272,10 +268,17 @@ def single_run(N, LOGGING):
 outFile = open(outFilename, 'a')
 
 for M in range(runs):
-    outFile.write(str(single_run(N, LOGGING)) + '\n')    
+    outFile.write(str(single_run(N, LOGGING)) + '\n')
+    outFile.flush    
 
 outFile.close()
 
+timetaken = (long(datetime.datetime.now().year*3600*24*365+
+datetime.datetime.now().month*30.5*24*3600+
+datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+datetime.datetime.now().minute*60+datetime.datetime.now().second)-currenttime)
+print "Done in "+ str(timetaken) +" seconds."
+
 
 # #### OLD CODE
 
diff --git a/samples/hardbody/README b/samples/hardbody/README
index 7187ba1f..5a45ad5b 100644
--- a/samples/hardbody/README
+++ b/samples/hardbody/README
@@ -1,5 +1,8 @@
 
 
+Introduction
+=====================================
+
 This sample script runs a model composed of a single, non-reactive
 species.   After each run, the script prints the real time it took
 to run the simulation in seconds.  This script may be useful for
@@ -24,3 +27,14 @@ for some small duration of time (stirTime in the script) to stir.
 After that, the simulator is re-initialized, and run for T
 to take the benchmark.
 
+Running
+=====================================
+
+Run with:
+$ python run_single.py <T> <V> <N>
+E.g.
+$ python run_single.py 1 1e-5 10
+
+
+
+
diff --git a/samples/hardbody/run_single.py b/samples/hardbody/run_single.py
index 0ecdc1d1..0cb6d36e 100644
--- a/samples/hardbody/run_single.py
+++ b/samples/hardbody/run_single.py
@@ -1,15 +1,21 @@
 #!/usr/bin/env python
 
+# Run with e.g. $ python run_single.py 1 1e-5 10
+
+import sys
+#Also, set relative egfrd directory path
+sys.path.append('../../')
+
+import myrandom
+
 from egfrd import *
 from bd import *
-
 from logger import *
-import sys
 import time
 import model
 import gfrdbase
 import _gfrd
-import myrandom
+
 
 def run_single(T, V, N):
 
diff --git a/samples/rebind/README b/samples/rebind/README
index 4f7df639..49a10956 100644
--- a/samples/rebind/README
+++ b/samples/rebind/README
@@ -4,7 +4,7 @@
 Introduction
 =====================================
 This example deals with the rebinding problem. The simplest case of
-this probllem is when you have two particles of different species
+this problem is when you have two particles of different species
 that can react with each other, say A and B, to a particle of species
 C:
 

From 664916162cddb80219bcf9170310cf54679d3a9f Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 30 May 2011 15:53:02 +0200
Subject: [PATCH 0067/1541] Added README to cluster.

---
 samples/cluster/README  | 42 +++++++++++++++++++++++++++++++++++++++++
 samples/hardbody/README |  2 +-
 2 files changed, 43 insertions(+), 1 deletion(-)
 create mode 100644 samples/cluster/README

diff --git a/samples/cluster/README b/samples/cluster/README
new file mode 100644
index 00000000..2e458d4c
--- /dev/null
+++ b/samples/cluster/README
@@ -0,0 +1,42 @@
+
+
+Introduction
+=====================================
+
+This script also deals with the question of rebinding: when two particles can reversibly bind, what's the average time between an unbinding an binding event? (See also the "rebind" folder.)
+
+The script contains the following reaction to simulate the rebinding:
+A + B <-> C
+
+With A and C having diffusion constant D = 0. 
+
+To research the effect of clustering of biological receptors, this script
+can place a "cluster" of A molecules in the simulation (i.e. it can
+place densily packed A particles on a plane, within a circular area). 
+
+In the center of the cluster a B particle is put. Then the simulation is allowed to run untill an unbinding and rebinding event have taken place.
+
+
+Running
+======================================
+
+Run by:
+$ python run.py [N] [runs] [outFilename] [Logmode, default=False]
+
+Arguments:
+  - N: Number of particles in cluster
+  - runs: Number of simulation runs
+  - outFilename: Name of output file
+  - Logmode on/off: should be given False or True value. Is False by 
+    default. If True, only 1 VTK-logged run is performed.    
+
+E.g.:
+$ python run.py 7 1000 data.out
+Or:
+$ python run.py 7 1 data.out True
+
+
+
+
+
+
diff --git a/samples/hardbody/README b/samples/hardbody/README
index 5a45ad5b..89ac4b4f 100644
--- a/samples/hardbody/README
+++ b/samples/hardbody/README
@@ -4,7 +4,7 @@ Introduction
 =====================================
 
 This sample script runs a model composed of a single, non-reactive
-species.   After each run, the script prints the real time it took
+species. After each run, the script prints the real time it took
 to run the simulation in seconds.  This script may be useful for
 a simple benchmarking purpose.
 

From 884a06c9f761394f314e99198872c02df39f679b Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 30 May 2011 15:53:02 +0200
Subject: [PATCH 0068/1541] Added README to cluster.

---
 samples/cluster/README        | 42 +++++++++++++++
 samples/cluster/run.py        | 99 ++++++++++++++++++-----------------
 samples/hardbody/README       |  2 +-
 visualization/run_pipeline.py |  2 +-
 4 files changed, 94 insertions(+), 51 deletions(-)
 create mode 100644 samples/cluster/README

diff --git a/samples/cluster/README b/samples/cluster/README
new file mode 100644
index 00000000..2e458d4c
--- /dev/null
+++ b/samples/cluster/README
@@ -0,0 +1,42 @@
+
+
+Introduction
+=====================================
+
+This script also deals with the question of rebinding: when two particles can reversibly bind, what's the average time between an unbinding an binding event? (See also the "rebind" folder.)
+
+The script contains the following reaction to simulate the rebinding:
+A + B <-> C
+
+With A and C having diffusion constant D = 0. 
+
+To research the effect of clustering of biological receptors, this script
+can place a "cluster" of A molecules in the simulation (i.e. it can
+place densily packed A particles on a plane, within a circular area). 
+
+In the center of the cluster a B particle is put. Then the simulation is allowed to run untill an unbinding and rebinding event have taken place.
+
+
+Running
+======================================
+
+Run by:
+$ python run.py [N] [runs] [outFilename] [Logmode, default=False]
+
+Arguments:
+  - N: Number of particles in cluster
+  - runs: Number of simulation runs
+  - outFilename: Name of output file
+  - Logmode on/off: should be given False or True value. Is False by 
+    default. If True, only 1 VTK-logged run is performed.    
+
+E.g.:
+$ python run.py 7 1000 data.out
+Or:
+$ python run.py 7 1 data.out True
+
+
+
+
+
+
diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index 448304df..367f21fd 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -32,43 +32,43 @@
 import _gfrd
 from visualization import vtklogger
 
+if __name__ == "__main__":
+    # Constants
+    # ===============================
+    # Number of particles in the cluster
+    N = int(sys.argv[1])
+    # Number of runs
+    runs = int(sys.argv[2])
+    # Output file
+    outFilename = sys.argv[3]
+    # LOGGING mode
+    try: 
+        LOGGING = bool(sys.argv[4])
+        if (LOGGING==True): 
+            print "* Performing only 1 logging run."
+            runs = 1
+    except: LOGGING = False
+
+    # Particle constants
+    sigma = 1e-5        # Diameter particle; big:1e-5
+    D = 1e-8            # Diffusion constant; big:1e-8
+    world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
+
+    k1 = 1e-10
+    k2 = 1e2
+
+    # Spacing inbetween cluster particles AND cluster/B-particle
+    spacing = sigma/1e5
+
+    # Create "unique" seed
+    # ===============================
+    currenttime = (long(datetime.datetime.now().year*3600*24*365+
+    datetime.datetime.now().month*30.5*24*3600+
+    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+    datetime.datetime.now().minute*60+datetime.datetime.now().second))
+    myrandom.seed(currenttime)
 
-# Constants
-# ===============================
-# Number of particles in the cluster
-N = int(sys.argv[1])
-# Number of runs
-runs = int(sys.argv[2])
-# Output file
-outFilename = sys.argv[3]
-# LOGGING mode
-try: 
-    LOGGING = bool(sys.argv[4])
-    if (LOGGING==True): 
-        print "* Performing only 1 logging run."
-        runs = 1
-except: LOGGING = False
-
-# Particle constants
-sigma = 1e-5        # Diameter particle; big:1e-5
-D = 1e-8            # Diffusion constant; big:1e-8
-world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
-
-k1 = 1e-10
-k2 = 1e2
-
-# Spacing inbetween cluster particles AND cluster/B-particle
-spacing = sigma/1e5
-
-# Create "unique" seed
-# ===============================
-currenttime = (long(datetime.datetime.now().year*3600*24*365+
-datetime.datetime.now().month*30.5*24*3600+
-datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
-datetime.datetime.now().minute*60+datetime.datetime.now().second))
-myrandom.seed(currenttime)
-
-print str('Seed: '+str(currenttime))
+    print str('Seed: '+str(currenttime))
 
 
 # Functions
@@ -262,22 +262,23 @@ def single_run(N, LOGGING):
 # Main part
 # ===============================
 
-# Output file
-outFile = open(outFilename, 'w')
-outFile.close()
-outFile = open(outFilename, 'a')
+if __name__ == "__main__":
+    # Output file
+    outFile = open(outFilename, 'w')
+    outFile.close()
+    outFile = open(outFilename, 'a')
 
-for M in range(runs):
-    outFile.write(str(single_run(N, LOGGING)) + '\n')
-    outFile.flush    
+    for M in range(runs):
+        outFile.write(str(single_run(N, LOGGING)) + '\n')
+        outFile.flush    
 
-outFile.close()
+    outFile.close()
 
-timetaken = (long(datetime.datetime.now().year*3600*24*365+
-datetime.datetime.now().month*30.5*24*3600+
-datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
-datetime.datetime.now().minute*60+datetime.datetime.now().second)-currenttime)
-print "Done in "+ str(timetaken) +" seconds."
+    timetaken = (long(datetime.datetime.now().year*3600*24*365+
+    datetime.datetime.now().month*30.5*24*3600+
+    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+    datetime.datetime.now().minute*60+datetime.datetime.now().second)-currenttime)
+    print "Done in "+ str(timetaken) +" seconds."
 
 
 # #### OLD CODE
diff --git a/samples/hardbody/README b/samples/hardbody/README
index 5a45ad5b..89ac4b4f 100644
--- a/samples/hardbody/README
+++ b/samples/hardbody/README
@@ -4,7 +4,7 @@ Introduction
 =====================================
 
 This sample script runs a model composed of a single, non-reactive
-species.   After each run, the script prints the real time it took
+species. After each run, the script prints the real time it took
 to run the simulation in seconds.  This script may be useful for
 a simple benchmarking purpose.
 
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index 6aeb4a65..ac3c3bfa 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -11,7 +11,7 @@
 # (This was defined when calling the logger in your
 # script.)
 simulation_data_directory = egfrd_directory + \
-    'samples/cluster/VTK_out/'
+    'samples/memory/VTK_out/'
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From 40e245ae9ecf3d4d1b2e8caadec36dc3055f17a9 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 7 Jun 2011 11:48:48 +0200
Subject: [PATCH 0069/1541] Added some files to look into memory leak.

---
 samples/memory/cluster.py       | 328 ++++++++++++++++++++++++++++++++
 samples/memory/memorymonitor.py |  24 +++
 samples/memory/run.py           | 124 ++++++++++++
 samples/memory/runanother.py    | 125 ++++++++++++
 4 files changed, 601 insertions(+)
 create mode 100644 samples/memory/cluster.py
 create mode 100644 samples/memory/memorymonitor.py
 create mode 100644 samples/memory/run.py
 create mode 100644 samples/memory/runanother.py

diff --git a/samples/memory/cluster.py b/samples/memory/cluster.py
new file mode 100644
index 00000000..30d925be
--- /dev/null
+++ b/samples/memory/cluster.py
@@ -0,0 +1,328 @@
+
+# Rebinding to a cluster
+
+# Run by:
+# $ python run.py [N] [runs] [outFilename] [Logmode, default=False]
+#
+# Arguments:
+#   - N: Number of particles in cluster
+#   - runs: Number of simulation runs
+#   - outFilename: Name of output file
+#   - Logmode: false by default, if True, only 1 VTK-logged run is
+#     performed.    
+#
+# E.g.:
+# $ python run.py 7 1000 data.out
+# Or:
+# $ python run.py 7 1 data.out True
+
+# Modules
+# ===============================
+import sys
+#Also, set relative egfrd directory path
+sys.path.append('../../')
+import os
+import shutil
+import datetime
+
+import math
+from egfrd import *
+import model
+import gfrdbase
+import _gfrd
+from visualization import vtklogger
+
+if __name__ == "__main__":
+    # Constants
+    # ===============================
+    # Number of particles in the cluster
+    N = int(sys.argv[1])
+    # Number of runs
+    runs = int(sys.argv[2])
+    # Output file
+    outFilename = sys.argv[3]
+    # LOGGING mode
+    try: 
+        LOGGING = bool(sys.argv[4])
+        if (LOGGING==True): 
+            print "* Performing only 1 logging run."
+            runs = 1
+    except: LOGGING = False
+
+# Particle constants
+sigma = 1e-5        # Diameter particle; big:1e-5
+D = 1e-8            # Diffusion constant; big:1e-8
+world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
+
+k1 = 1e-10
+k2 = 1e2
+
+# Spacing inbetween cluster particles AND cluster/B-particle
+spacing = sigma/1e5
+
+# Create "unique" seed
+# ===============================
+currenttime = (long(datetime.datetime.now().year*3600*24*365+
+datetime.datetime.now().month*30.5*24*3600+
+datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+datetime.datetime.now().minute*60+datetime.datetime.now().second))
+myrandom.seed(currenttime)
+
+print str('Seed: '+str(currenttime))
+
+
+# Functions
+# ===============================
+def cartesian(g1, g2, ng1, ng2):
+    """ Converts lattice coordinates (ng1, ng2) to cartesian coordinates
+    
+    Arguments:
+        - Lattice vectors g1=[x1,y1] and g2=[x2,y2]
+        - Lattice coordinates (ng1, ng2)
+
+    """
+    cartesian_x = (ng1 * (g1[0]) + ng2 * (g2[0]))
+    cartesian_y = (ng2 * (g2[1]) + ng1 * (g1[1]))
+    return cartesian_x, cartesian_y
+
+def distance(x1, y1, x2, y2):
+    """ Calculates the distance between points (x1, y1) and (x2, y2) """
+    return math.sqrt(math.pow((x1-x2),2)+math.pow((y1-y2),2))
+
+def generate_possible_positions(N):
+    """ Generates a list with possible coordinates and distances to center
+
+    This function does the following:
+        - It loops over square area of an hexagonal lattice (of size 
+          calculated to facilitate N particles) 
+        - Lattice coordinates and distance to the center of the area 
+          are stored if they are within circular boundaries. (The 
+          latter check is only done to be absolutely sure a circular 
+          shape is formed.)
+
+    This information can be used in a later function. If the list of
+    generated coordinates is sorted by distance to the center, N 
+    particles can be placed within a circular geometry by looping over
+    the coordinates.
+
+    Arguments:
+        - N: number of particles to place.
+
+    """
+    global w, A, spacing, sigma #, g1, g2, cartesian_x, cartesian_y, ng1, ng2
+
+    # Lattice vectors
+    d1 = [1,0]
+    d2 = [math.cos((math.pi)/3.0),math.sin((math.pi)/3.0)]
+    # Scaled lattice vectors
+    lengthLatticeVector = (sigma+spacing)
+    g1 = [lengthLatticeVector*d1[0], lengthLatticeVector*d1[1]]
+    g2 = [lengthLatticeVector*d2[0], lengthLatticeVector*d2[1]]
+
+    # Factors to calculate square area of lattice needed
+    """
+    factorNonSquareGrid = math.sqrt(1/(d1[0]*d2[1]-d1[1]*d2[0]))
+    factorSquareToCircle = math.pi/2 #math.sqrt(math.pow((math.pi*0.5),2)) 
+    # Calculate diameter of sphere
+    L = (spacing+sigma)*(math.ceil(math.sqrt(N))+2)*factorNonSquareGrid*factorSquareToCircle
+        # "(math.ceil(math.sqrt(N))+2)"; ceil and +2: some margin
+    diamondSide = (L/2)*math.tan(pi/6)+(L/2)/math.tan(pi/6)
+    diamondDiagonal = sin(pi/3)*L #2*sin(pi/3)*L/2
+    """
+    # d1x*d2y-d1y*d2x
+    diamondToSquare = math.sqrt((4*d2[0]*d2[1])/(0.25*math.pi))
+    vectorsOnDiameter = math.ceil(math.sqrt(N)+2)
+    numberOfVectors = diamondToSquare * vectorsOnDiameter
+
+    diameterCircle = math.ceil(math.sqrt(N)+2)*lengthLatticeVector
+    radiusCircle = diameterCircle/2
+
+    # Cartesian coordinates
+    cartesian_x = 0
+    cartesian_y = 0
+    cartesian_z = 0
+
+    # The list with possible coordinates and distances to center
+    clusterParticleCoordinates = []
+
+    for ng1 in range(int(-math.ceil(numberOfVectors/2)), 
+                            int(math.ceil(numberOfVectors/2))):
+        for ng2 in range(int(-math.ceil(numberOfVectors/2)), 
+                                int(math.ceil(numberOfVectors/2))):
+            cartesian_x, cartesian_y = cartesian(g1, g2, ng1, ng2)
+            distanceToCenter = distance(cartesian_x, cartesian_y, 0, 0)
+            if (distanceToCenter < radiusCircle):
+                clusterParticleCoordinates.append([
+                            distanceToCenter,
+                            cartesian_x, 
+                            cartesian_y, 
+                            cartesian_z
+                            ])
+    
+
+    return clusterParticleCoordinates
+
+def make_cluster(N, coord_x, coord_y, coord_z): 
+    """ Places N particles on hexagonal lattice in spherical symmetry
+
+    Arguments:
+        - N: number of particles to place
+        - coord_x, coord_y, coord_z: Coordinates where to place cluster
+    """
+    # Generate list of positions and there distance to the center
+    clusterParticleCoordinates = generate_possible_positions(N)
+    # Sort this list
+    clusterParticleCoordinates.sort(key=lambda x: x[0])
+
+    # Place center particle
+    place_particle(w, C,
+         [clusterParticleCoordinates[0][1]+coord_x, 
+          clusterParticleCoordinates[0][2]+coord_y,
+          clusterParticleCoordinates[0][3]+coord_z])
+    # Place N particles starting with the particle closest to the
+    # center, then placing the second closest particle, etc..
+    for i in range(1,N):
+        try:
+            place_particle(w, A,
+                [clusterParticleCoordinates[i][1]+coord_x, 
+                 clusterParticleCoordinates[i][2]+coord_y,
+                 clusterParticleCoordinates[i][3]+coord_z])
+        except: 
+            print "ERROR: couldn't place particle."
+
+def single_run(N, LOGGING):
+    """ Single run of simulation """
+    global w, A, C, k1, k2
+    # Basic set up simulator
+    # ===============================
+    # Model
+    m = model.ParticleModel(world_size)
+    # Species
+    A = model.Species('A', 0, sigma/2)                                   
+    m.add_species_type(A) 
+    B = model.Species('B', D, sigma/2)                                   
+    m.add_species_type(B) 
+    C = model.Species('C', 0, sigma/2)                                   
+    m.add_species_type(C) 
+    # Reaction rules
+    r1 = model.create_binding_reaction_rule(A, B, C, k1)
+    m.network_rules.add_reaction_rule(r1)
+    r2 = model.create_unbinding_reaction_rule(C, A, B, k2)
+    m.network_rules.add_reaction_rule(r2)
+
+    # World
+    w = gfrdbase.create_world(m, 3)
+    # Simulator   
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    # Put in cluster
+    make_cluster(N, world_size/2, world_size/2, world_size/2)
+
+    # Put in reactants
+    # place_particle(w, B, [world_size/2, world_size/2, world_size/2+sigma+spacing])    
+
+    # Enable VTK Logger
+    # ===============================
+    if (LOGGING == True):
+        vtk_output_directory = 'VTK_out'
+        if (os.path.exists(vtk_output_directory)):
+            print '** Warning: VTK directory already exists.'
+        l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+    
+    # Running 
+    # ===============================
+    numberDetected = 0
+
+    if (LOGGING == True):
+        while 1:
+            l.log() # log
+            s.step() # and make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
+                    break  
+                else: previous_time = s.t
+        l.stop() 
+    else:
+        while 1:
+            s.step() # make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
+                    break  
+                else: previous_time = s.t
+
+    s.stop(s.t)
+#TODO
+    del w
+    del s # If this one is thrown in, the runs suddenly stop?!
+    del m
+
+    return (reaction_time)
+    
+# Main part
+# ===============================
+
+if __name__ == "__main__":
+    # Output file
+    outFile = open(outFilename, 'w')
+    outFile.close()
+    outFile = open(outFilename, 'a')
+
+    for M in range(runs):
+        outFile.write(str(single_run(N, LOGGING)) + '\n')
+        outFile.flush    
+
+    outFile.close()
+
+    timetaken = (long(datetime.datetime.now().year*3600*24*365+
+    datetime.datetime.now().month*30.5*24*3600+
+    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+    datetime.datetime.now().minute*60+datetime.datetime.now().second)-currenttime)
+    print "Done in "+ str(timetaken) +" seconds."
+
+
+# #### OLD CODE
+
+#def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
+#    if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
+#        return True
+#    else:
+#        return False
+
+
+    # while end time hasn't come and #timesteps still below limit
+    # while ((s.get_next_time() < endTime) and (n < EARLY_STOP)): # TODO
+
+
+    # Terminate the simulation at appropriate time
+
+    #"""
+    #if (n >= EARLY_STOP):
+    #    print "Early stop (timestep limit)."
+    #    s.stop(s.t)
+    #    reaction_time = INF
+    #else:
+    #    print "Early stop (time limit)."
+    #    s.stop(s.get_next_time())
+    #    reaction_time = INF
+    #"""
+
+    # Make sure logger writes away information.
+    # l.stop() #TODO REMOVED LOGGING
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/samples/memory/memorymonitor.py b/samples/memory/memorymonitor.py
new file mode 100644
index 00000000..98816021
--- /dev/null
+++ b/samples/memory/memorymonitor.py
@@ -0,0 +1,24 @@
+"""Simple module for getting amount of memory used by a specified user's
+processes on a UNIX system.
+It uses UNIX ps utility to get the memory usage for a specified username and
+pipe it to awk for summing up per application memory usage and return the total.
+Python's Popen() from subprocess module is used for spawning ps and awk.
+
+"""
+
+import subprocess
+
+class MemoryMonitor(object):
+
+    def __init__(self, username):
+        """Create new MemoryMonitor instance."""
+        self.username = username
+
+    def usage(self):
+        """Return int containing memory used by user's processes."""
+        self.process = subprocess.Popen("ps -u %s -o rss | awk '{sum+=$1} END {print sum}'" % self.username,
+                                        shell=True,
+                                        stdout=subprocess.PIPE,
+                                        )
+        self.stdout_list = self.process.communicate()[0].split('\n')
+        return int(self.stdout_list[0])
diff --git a/samples/memory/run.py b/samples/memory/run.py
new file mode 100644
index 00000000..230d5f16
--- /dev/null
+++ b/samples/memory/run.py
@@ -0,0 +1,124 @@
+# Simple script to assess memory usage of eGFRD
+
+# Modules
+# ===============================
+import sys
+#Also, set relative python path
+sys.path.append('../../')
+import os
+
+#from memorymonitor import MemoryMonitor
+import memoryusage
+from egfrd import *
+
+import model
+import gfrdbase
+import _gfrd
+#import logger
+#import dumper
+#from bd import *
+
+
+# Constants
+# ===============================
+username = 'wehrens'
+outFilename = 'report.txt'
+
+# Number of runs and number of timesteps
+runs = 1000
+N = 1000
+
+# Number of particles
+Np = 100 
+
+# General constants
+sigma = 1e-9        # Diameter particle; more realistic would be e-9
+D = 1e-12           # Diffusion constant
+world_size = 1e-3   # Lengths of simulation box
+
+# Reaction constants
+kf = 1e-18
+kb = 1
+
+
+# Memory Monitor
+# ===============================
+# memory_mon = MemoryMonitor(username)
+
+
+def singlerun(N):
+    """ Creates simple simulation set up and runs N timesteps """
+
+    # Basic set up simulator
+    # ===============================
+    # Model
+    m = model.ParticleModel(world_size)
+    # Species
+    A = model.Species('A', D, sigma/2)                                   
+    m.add_species_type(A) 
+    B = model.Species('B', D, sigma/2)                                   
+    m.add_species_type(B) 
+    C = model.Species('C', D, sigma/2)                                   
+    m.add_species_type(C) 
+    X = model.Species('X', D, sigma/2)                                   
+    m.add_species_type(X) 
+    # Reaction rules
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+    m.network_rules.add_reaction_rule(r1)
+    r2 = model.create_unbinding_reaction_rule(A, B, C, kb)
+    m.network_rules.add_reaction_rule(r2)
+
+    # World
+    w = gfrdbase.create_world(m, 3)
+    # Simulator
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    # Throw in particles
+    throw_in_particles(w, A, Np)
+    throw_in_particles(w, B, Np)
+    throw_in_particles(w, C, Np)
+    throw_in_particles(w, X, Np)
+
+    # Running
+    # ===============================
+    for t in range(N):
+        s.step()
+
+    s.stop(s.t)
+
+print "Starting."
+
+# Go
+outFile = open(outFilename, 'w')
+outFile.close()
+outFile = open(outFilename, 'a')
+
+for M in range(runs):
+    print "Run " + str(M),
+    singlerun(N)
+    outFile.write(str(memoryusage.memory()) + "\n")
+    outFile.flush    
+    print "(" + str(memoryusage.memory()) + ")."
+
+outFile.close()
+
+print "Finished."
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/samples/memory/runanother.py b/samples/memory/runanother.py
new file mode 100644
index 00000000..8439c49e
--- /dev/null
+++ b/samples/memory/runanother.py
@@ -0,0 +1,125 @@
+# Simple script to assess memory usage of eGFRD
+
+# Modules
+# ===============================
+import sys
+#Also, set relative python path
+sys.path.append('../../')
+import os
+sys.path.append('/storage1/wehrens/lib/python/')
+import guppy
+import gc
+
+#from memorymonitor import MemoryMonitor
+import memoryusage
+from egfrd import *
+
+import model
+import gfrdbase
+import _gfrd
+#import logger
+#import dumper
+#from bd import *
+
+import cluster
+
+
+# Constants
+# ===============================
+gc.set_debug(gc.DEBUG_LEAK)
+sys.stderr = open('bugreport.txt', 'w')
+print str(gc.get_debug())
+
+username = 'wehrens'
+outFilename = 'anotherreport.txt'
+
+# runs
+runs = 100
+
+# Clustersize
+N = 50
+
+# Functions
+# ================================
+
+def cleaningcrew(themess):
+    # print str(themess)
+
+#    for mess in themess:
+#        del(mess)
+#    for key, item in cluster.__dict__.items():
+#        tokill = getattr(cluster, key)
+#        print str(tokill)
+#        del(tokill)
+
+    # print "AFTER CLEANING:" + str(cluster.__dict__)
+
+#    methodToCall = getattr(foo, 'bar')
+#    result = methodToCall()
+    pass
+
+# print "GC enabled?-: " + str(gc.isenabled())
+
+# print "Initializing cyclops."
+
+#import Cyclops
+#z = Cyclops.CycleFinder()
+
+# print "Starting."
+
+# Go
+outFile = open(outFilename, 'w')
+outFile.close()
+outFile = open(outFilename, 'a')
+
+for M in range(runs):
+    print "run " + str(M),
+    #print "Run " + str(M),
+    cluster.single_run(N, False)
+    outFile.write(str(memoryusage.memory()) + "\n")
+    outFile.flush    
+    #print "(" + str(memoryusage.memory()) + ").\n"
+    #print "CREW:"
+#    dirt = []
+#    cleaningcrew(dir()) 
+    #print str(gc.garbage)
+    print "Annoying items: " + str(gc.collect())
+    #print "END CREW"
+#    del cluster.w
+#    del cluster.s # If this one is thrown in, the runs suddenly stop?!
+#    del cluster.m
+    print "(" + str(memoryusage.memory()) + ")."    
+
+outFile.close()
+
+print "Memory usage after exiting loop & closing file: " + str(memoryusage.memory()) + "."
+
+print "Looking for cycles"
+
+print "z.find_cycles() returned: " + str(z.find_cycles())
+
+print "Finished."
+
+sys.stderr.close()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From 1ec34c0f6be52f7d93e2b152f29c6d626a9f3db2 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 7 Jun 2011 11:48:48 +0200
Subject: [PATCH 0070/1541] Added some files to look into memory leak.

---
 samples/memory/cluster.py       | 328 ++++++++++++++++++++++++++++++++
 samples/memory/memorymonitor.py |  24 +++
 samples/memory/memoryusage.py   |  50 +++++
 samples/memory/run.py           | 124 ++++++++++++
 samples/memory/runanother.py    | 135 +++++++++++++
 5 files changed, 661 insertions(+)
 create mode 100644 samples/memory/cluster.py
 create mode 100644 samples/memory/memorymonitor.py
 create mode 100644 samples/memory/memoryusage.py
 create mode 100644 samples/memory/run.py
 create mode 100644 samples/memory/runanother.py

diff --git a/samples/memory/cluster.py b/samples/memory/cluster.py
new file mode 100644
index 00000000..30d925be
--- /dev/null
+++ b/samples/memory/cluster.py
@@ -0,0 +1,328 @@
+
+# Rebinding to a cluster
+
+# Run by:
+# $ python run.py [N] [runs] [outFilename] [Logmode, default=False]
+#
+# Arguments:
+#   - N: Number of particles in cluster
+#   - runs: Number of simulation runs
+#   - outFilename: Name of output file
+#   - Logmode: false by default, if True, only 1 VTK-logged run is
+#     performed.    
+#
+# E.g.:
+# $ python run.py 7 1000 data.out
+# Or:
+# $ python run.py 7 1 data.out True
+
+# Modules
+# ===============================
+import sys
+#Also, set relative egfrd directory path
+sys.path.append('../../')
+import os
+import shutil
+import datetime
+
+import math
+from egfrd import *
+import model
+import gfrdbase
+import _gfrd
+from visualization import vtklogger
+
+if __name__ == "__main__":
+    # Constants
+    # ===============================
+    # Number of particles in the cluster
+    N = int(sys.argv[1])
+    # Number of runs
+    runs = int(sys.argv[2])
+    # Output file
+    outFilename = sys.argv[3]
+    # LOGGING mode
+    try: 
+        LOGGING = bool(sys.argv[4])
+        if (LOGGING==True): 
+            print "* Performing only 1 logging run."
+            runs = 1
+    except: LOGGING = False
+
+# Particle constants
+sigma = 1e-5        # Diameter particle; big:1e-5
+D = 1e-8            # Diffusion constant; big:1e-8
+world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
+
+k1 = 1e-10
+k2 = 1e2
+
+# Spacing inbetween cluster particles AND cluster/B-particle
+spacing = sigma/1e5
+
+# Create "unique" seed
+# ===============================
+currenttime = (long(datetime.datetime.now().year*3600*24*365+
+datetime.datetime.now().month*30.5*24*3600+
+datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+datetime.datetime.now().minute*60+datetime.datetime.now().second))
+myrandom.seed(currenttime)
+
+print str('Seed: '+str(currenttime))
+
+
+# Functions
+# ===============================
+def cartesian(g1, g2, ng1, ng2):
+    """ Converts lattice coordinates (ng1, ng2) to cartesian coordinates
+    
+    Arguments:
+        - Lattice vectors g1=[x1,y1] and g2=[x2,y2]
+        - Lattice coordinates (ng1, ng2)
+
+    """
+    cartesian_x = (ng1 * (g1[0]) + ng2 * (g2[0]))
+    cartesian_y = (ng2 * (g2[1]) + ng1 * (g1[1]))
+    return cartesian_x, cartesian_y
+
+def distance(x1, y1, x2, y2):
+    """ Calculates the distance between points (x1, y1) and (x2, y2) """
+    return math.sqrt(math.pow((x1-x2),2)+math.pow((y1-y2),2))
+
+def generate_possible_positions(N):
+    """ Generates a list with possible coordinates and distances to center
+
+    This function does the following:
+        - It loops over square area of an hexagonal lattice (of size 
+          calculated to facilitate N particles) 
+        - Lattice coordinates and distance to the center of the area 
+          are stored if they are within circular boundaries. (The 
+          latter check is only done to be absolutely sure a circular 
+          shape is formed.)
+
+    This information can be used in a later function. If the list of
+    generated coordinates is sorted by distance to the center, N 
+    particles can be placed within a circular geometry by looping over
+    the coordinates.
+
+    Arguments:
+        - N: number of particles to place.
+
+    """
+    global w, A, spacing, sigma #, g1, g2, cartesian_x, cartesian_y, ng1, ng2
+
+    # Lattice vectors
+    d1 = [1,0]
+    d2 = [math.cos((math.pi)/3.0),math.sin((math.pi)/3.0)]
+    # Scaled lattice vectors
+    lengthLatticeVector = (sigma+spacing)
+    g1 = [lengthLatticeVector*d1[0], lengthLatticeVector*d1[1]]
+    g2 = [lengthLatticeVector*d2[0], lengthLatticeVector*d2[1]]
+
+    # Factors to calculate square area of lattice needed
+    """
+    factorNonSquareGrid = math.sqrt(1/(d1[0]*d2[1]-d1[1]*d2[0]))
+    factorSquareToCircle = math.pi/2 #math.sqrt(math.pow((math.pi*0.5),2)) 
+    # Calculate diameter of sphere
+    L = (spacing+sigma)*(math.ceil(math.sqrt(N))+2)*factorNonSquareGrid*factorSquareToCircle
+        # "(math.ceil(math.sqrt(N))+2)"; ceil and +2: some margin
+    diamondSide = (L/2)*math.tan(pi/6)+(L/2)/math.tan(pi/6)
+    diamondDiagonal = sin(pi/3)*L #2*sin(pi/3)*L/2
+    """
+    # d1x*d2y-d1y*d2x
+    diamondToSquare = math.sqrt((4*d2[0]*d2[1])/(0.25*math.pi))
+    vectorsOnDiameter = math.ceil(math.sqrt(N)+2)
+    numberOfVectors = diamondToSquare * vectorsOnDiameter
+
+    diameterCircle = math.ceil(math.sqrt(N)+2)*lengthLatticeVector
+    radiusCircle = diameterCircle/2
+
+    # Cartesian coordinates
+    cartesian_x = 0
+    cartesian_y = 0
+    cartesian_z = 0
+
+    # The list with possible coordinates and distances to center
+    clusterParticleCoordinates = []
+
+    for ng1 in range(int(-math.ceil(numberOfVectors/2)), 
+                            int(math.ceil(numberOfVectors/2))):
+        for ng2 in range(int(-math.ceil(numberOfVectors/2)), 
+                                int(math.ceil(numberOfVectors/2))):
+            cartesian_x, cartesian_y = cartesian(g1, g2, ng1, ng2)
+            distanceToCenter = distance(cartesian_x, cartesian_y, 0, 0)
+            if (distanceToCenter < radiusCircle):
+                clusterParticleCoordinates.append([
+                            distanceToCenter,
+                            cartesian_x, 
+                            cartesian_y, 
+                            cartesian_z
+                            ])
+    
+
+    return clusterParticleCoordinates
+
+def make_cluster(N, coord_x, coord_y, coord_z): 
+    """ Places N particles on hexagonal lattice in spherical symmetry
+
+    Arguments:
+        - N: number of particles to place
+        - coord_x, coord_y, coord_z: Coordinates where to place cluster
+    """
+    # Generate list of positions and there distance to the center
+    clusterParticleCoordinates = generate_possible_positions(N)
+    # Sort this list
+    clusterParticleCoordinates.sort(key=lambda x: x[0])
+
+    # Place center particle
+    place_particle(w, C,
+         [clusterParticleCoordinates[0][1]+coord_x, 
+          clusterParticleCoordinates[0][2]+coord_y,
+          clusterParticleCoordinates[0][3]+coord_z])
+    # Place N particles starting with the particle closest to the
+    # center, then placing the second closest particle, etc..
+    for i in range(1,N):
+        try:
+            place_particle(w, A,
+                [clusterParticleCoordinates[i][1]+coord_x, 
+                 clusterParticleCoordinates[i][2]+coord_y,
+                 clusterParticleCoordinates[i][3]+coord_z])
+        except: 
+            print "ERROR: couldn't place particle."
+
+def single_run(N, LOGGING):
+    """ Single run of simulation """
+    global w, A, C, k1, k2
+    # Basic set up simulator
+    # ===============================
+    # Model
+    m = model.ParticleModel(world_size)
+    # Species
+    A = model.Species('A', 0, sigma/2)                                   
+    m.add_species_type(A) 
+    B = model.Species('B', D, sigma/2)                                   
+    m.add_species_type(B) 
+    C = model.Species('C', 0, sigma/2)                                   
+    m.add_species_type(C) 
+    # Reaction rules
+    r1 = model.create_binding_reaction_rule(A, B, C, k1)
+    m.network_rules.add_reaction_rule(r1)
+    r2 = model.create_unbinding_reaction_rule(C, A, B, k2)
+    m.network_rules.add_reaction_rule(r2)
+
+    # World
+    w = gfrdbase.create_world(m, 3)
+    # Simulator   
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    # Put in cluster
+    make_cluster(N, world_size/2, world_size/2, world_size/2)
+
+    # Put in reactants
+    # place_particle(w, B, [world_size/2, world_size/2, world_size/2+sigma+spacing])    
+
+    # Enable VTK Logger
+    # ===============================
+    if (LOGGING == True):
+        vtk_output_directory = 'VTK_out'
+        if (os.path.exists(vtk_output_directory)):
+            print '** Warning: VTK directory already exists.'
+        l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+    
+    # Running 
+    # ===============================
+    numberDetected = 0
+
+    if (LOGGING == True):
+        while 1:
+            l.log() # log
+            s.step() # and make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
+                    break  
+                else: previous_time = s.t
+        l.stop() 
+    else:
+        while 1:
+            s.step() # make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
+                    break  
+                else: previous_time = s.t
+
+    s.stop(s.t)
+#TODO
+    del w
+    del s # If this one is thrown in, the runs suddenly stop?!
+    del m
+
+    return (reaction_time)
+    
+# Main part
+# ===============================
+
+if __name__ == "__main__":
+    # Output file
+    outFile = open(outFilename, 'w')
+    outFile.close()
+    outFile = open(outFilename, 'a')
+
+    for M in range(runs):
+        outFile.write(str(single_run(N, LOGGING)) + '\n')
+        outFile.flush    
+
+    outFile.close()
+
+    timetaken = (long(datetime.datetime.now().year*3600*24*365+
+    datetime.datetime.now().month*30.5*24*3600+
+    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+    datetime.datetime.now().minute*60+datetime.datetime.now().second)-currenttime)
+    print "Done in "+ str(timetaken) +" seconds."
+
+
+# #### OLD CODE
+
+#def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
+#    if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
+#        return True
+#    else:
+#        return False
+
+
+    # while end time hasn't come and #timesteps still below limit
+    # while ((s.get_next_time() < endTime) and (n < EARLY_STOP)): # TODO
+
+
+    # Terminate the simulation at appropriate time
+
+    #"""
+    #if (n >= EARLY_STOP):
+    #    print "Early stop (timestep limit)."
+    #    s.stop(s.t)
+    #    reaction_time = INF
+    #else:
+    #    print "Early stop (time limit)."
+    #    s.stop(s.get_next_time())
+    #    reaction_time = INF
+    #"""
+
+    # Make sure logger writes away information.
+    # l.stop() #TODO REMOVED LOGGING
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/samples/memory/memorymonitor.py b/samples/memory/memorymonitor.py
new file mode 100644
index 00000000..98816021
--- /dev/null
+++ b/samples/memory/memorymonitor.py
@@ -0,0 +1,24 @@
+"""Simple module for getting amount of memory used by a specified user's
+processes on a UNIX system.
+It uses UNIX ps utility to get the memory usage for a specified username and
+pipe it to awk for summing up per application memory usage and return the total.
+Python's Popen() from subprocess module is used for spawning ps and awk.
+
+"""
+
+import subprocess
+
+class MemoryMonitor(object):
+
+    def __init__(self, username):
+        """Create new MemoryMonitor instance."""
+        self.username = username
+
+    def usage(self):
+        """Return int containing memory used by user's processes."""
+        self.process = subprocess.Popen("ps -u %s -o rss | awk '{sum+=$1} END {print sum}'" % self.username,
+                                        shell=True,
+                                        stdout=subprocess.PIPE,
+                                        )
+        self.stdout_list = self.process.communicate()[0].split('\n')
+        return int(self.stdout_list[0])
diff --git a/samples/memory/memoryusage.py b/samples/memory/memoryusage.py
new file mode 100644
index 00000000..2d7e5a00
--- /dev/null
+++ b/samples/memory/memoryusage.py
@@ -0,0 +1,50 @@
+import os
+
+_proc_status = '/proc/%d/status' % os.getpid()
+
+_scale = {'kB': 1024.0, 'mB': 1024.0*1024.0,
+          'KB': 1024.0, 'MB': 1024.0*1024.0}
+
+def _VmB(VmKey):
+    '''Private.
+    '''
+    global _proc_status, _scale
+     # get pseudo file  /proc/<pid>/status
+    try:
+        t = open(_proc_status)
+        v = t.read()
+        t.close()
+    except:
+        return 0.0  # non-Linux?
+     # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
+    i = v.index(VmKey)
+    v = v[i:].split(None, 3)  # whitespace
+    if len(v) < 3:
+        return 0.0  # invalid format?
+     # convert Vm value to bytes
+    return float(v[1]) * _scale[v[2]]
+
+
+def memory(since=0.0):
+    '''Return memory usage in bytes.
+    '''
+    return _VmB('VmSize:') - since
+
+
+def resident(since=0.0):
+    '''Return resident memory usage in bytes.
+    '''
+    return _VmB('VmRSS:') - since
+
+
+def stacksize(since=0.0):
+    '''Return stack size in bytes.
+    '''
+    return _VmB('VmStk:') - since
+
+
+
+
+
+
+
diff --git a/samples/memory/run.py b/samples/memory/run.py
new file mode 100644
index 00000000..230d5f16
--- /dev/null
+++ b/samples/memory/run.py
@@ -0,0 +1,124 @@
+# Simple script to assess memory usage of eGFRD
+
+# Modules
+# ===============================
+import sys
+#Also, set relative python path
+sys.path.append('../../')
+import os
+
+#from memorymonitor import MemoryMonitor
+import memoryusage
+from egfrd import *
+
+import model
+import gfrdbase
+import _gfrd
+#import logger
+#import dumper
+#from bd import *
+
+
+# Constants
+# ===============================
+username = 'wehrens'
+outFilename = 'report.txt'
+
+# Number of runs and number of timesteps
+runs = 1000
+N = 1000
+
+# Number of particles
+Np = 100 
+
+# General constants
+sigma = 1e-9        # Diameter particle; more realistic would be e-9
+D = 1e-12           # Diffusion constant
+world_size = 1e-3   # Lengths of simulation box
+
+# Reaction constants
+kf = 1e-18
+kb = 1
+
+
+# Memory Monitor
+# ===============================
+# memory_mon = MemoryMonitor(username)
+
+
+def singlerun(N):
+    """ Creates simple simulation set up and runs N timesteps """
+
+    # Basic set up simulator
+    # ===============================
+    # Model
+    m = model.ParticleModel(world_size)
+    # Species
+    A = model.Species('A', D, sigma/2)                                   
+    m.add_species_type(A) 
+    B = model.Species('B', D, sigma/2)                                   
+    m.add_species_type(B) 
+    C = model.Species('C', D, sigma/2)                                   
+    m.add_species_type(C) 
+    X = model.Species('X', D, sigma/2)                                   
+    m.add_species_type(X) 
+    # Reaction rules
+    r1 = model.create_binding_reaction_rule(A, B, C, kf)
+    m.network_rules.add_reaction_rule(r1)
+    r2 = model.create_unbinding_reaction_rule(A, B, C, kb)
+    m.network_rules.add_reaction_rule(r2)
+
+    # World
+    w = gfrdbase.create_world(m, 3)
+    # Simulator
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    # Throw in particles
+    throw_in_particles(w, A, Np)
+    throw_in_particles(w, B, Np)
+    throw_in_particles(w, C, Np)
+    throw_in_particles(w, X, Np)
+
+    # Running
+    # ===============================
+    for t in range(N):
+        s.step()
+
+    s.stop(s.t)
+
+print "Starting."
+
+# Go
+outFile = open(outFilename, 'w')
+outFile.close()
+outFile = open(outFilename, 'a')
+
+for M in range(runs):
+    print "Run " + str(M),
+    singlerun(N)
+    outFile.write(str(memoryusage.memory()) + "\n")
+    outFile.flush    
+    print "(" + str(memoryusage.memory()) + ")."
+
+outFile.close()
+
+print "Finished."
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/samples/memory/runanother.py b/samples/memory/runanother.py
new file mode 100644
index 00000000..76b5157d
--- /dev/null
+++ b/samples/memory/runanother.py
@@ -0,0 +1,135 @@
+# Simple script to assess memory usage of eGFRD
+
+# Modules
+# ===============================
+import sys
+#Also, set relative python path
+sys.path.append('../../')
+import os
+sys.path.append('/storage1/wehrens/lib/python/')
+sys.path.append('/storage1/wehrens/lib/python2.6/site-packages')
+import guppy
+import gc
+from dozer import Dozer
+
+#from memorymonitor import MemoryMonitor
+import memoryusage
+from egfrd import *
+
+import model
+import gfrdbase
+import _gfrd
+#import logger
+#import dumper
+#from bd import *
+
+import cluster
+
+
+# Constants
+# ===============================
+
+username = 'wehrens'
+outFilename = 'anotherreport.txt'
+
+# runs
+runs = 100
+
+# Clustersize
+N = 50
+
+# Initializing
+# ===============================
+
+# GC
+gc.set_debug(gc.DEBUG_LEAK)
+sys.stderr = open('bugreport.txt', 'w')
+print str(gc.get_debug())
+# Dozer
+wsgi_app = Dozer(wsgi_app)
+
+
+# Functions
+# ================================
+
+def cleaningcrew(themess):
+    # print str(themess)
+
+#    for mess in themess:
+#        del(mess)
+#    for key, item in cluster.__dict__.items():
+#        tokill = getattr(cluster, key)
+#        print str(tokill)
+#        del(tokill)
+
+    # print "AFTER CLEANING:" + str(cluster.__dict__)
+
+#    methodToCall = getattr(foo, 'bar')
+#    result = methodToCall()
+    pass
+
+# print "GC enabled?-: " + str(gc.isenabled())
+
+# print "Initializing cyclops."
+
+#import Cyclops
+#z = Cyclops.CycleFinder()
+
+# print "Starting."
+
+# Go
+outFile = open(outFilename, 'w')
+outFile.close()
+outFile = open(outFilename, 'a')
+
+for M in range(runs):
+    print "run " + str(M),
+    #print "Run " + str(M),
+    cluster.single_run(N, False)
+    outFile.write(str(memoryusage.memory()) + "\n")
+    outFile.flush    
+    #print "(" + str(memoryusage.memory()) + ").\n"
+    #print "CREW:"
+#    dirt = []
+#    cleaningcrew(dir()) 
+    #print str(gc.garbage)
+    print "Annoying items: " + str(gc.collect())
+    #print "END CREW"
+#    del cluster.w
+#    del cluster.s # If this one is thrown in, the runs suddenly stop?!
+#    del cluster.m
+    print "(" + str(memoryusage.memory()) + ")."    
+
+outFile.close()
+
+#print "Memory usage after exiting loop & closing file: " + str(memoryusage.memory()) + "."
+
+#print "Looking for cycles"
+
+#print "z.find_cycles() returned: " + str(z.find_cycles())
+
+#print "Finished."
+
+# sys.stderr.close()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From b02bd845ec329063d50215edbf3baf6452d7f2b2 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 7 Jun 2011 15:10:37 +0200
Subject: [PATCH 0071/1541] One additional random tool.

---
 samples/memory/Cyclops.py | 1012 +++++++++++++++++++++++++++++++++++++
 1 file changed, 1012 insertions(+)
 create mode 100644 samples/memory/Cyclops.py

diff --git a/samples/memory/Cyclops.py b/samples/memory/Cyclops.py
new file mode 100644
index 00000000..c04a5072
--- /dev/null
+++ b/samples/memory/Cyclops.py
@@ -0,0 +1,1012 @@
+# Module Cyclops version 0.9.4.
+# by Tim Peters (tim_one@email.msn.com).
+# Released to the public domain 18-Jul-1999,
+
+# Provided as-is; use at your own risk; no warranty; no promises; enjoy!
+
+# Some parts of the code, and many ideas, were stolen with gratitude from:
+#     Lars Marius Garshol's Plumbo.py.
+#     Guido van Rossum.
+#     Python's standard library module repr.py.
+
+"""Module Cyclops -- stare at cycles in Python data structures.
+
+Cyclops started life as a faster implementation of Lars Marius
+Garshol's Plumbo.py, but almost instantly diverged due to feature
+bloat.
+
+The only object of real interest is class CycleFinder.  First get an
+instance of that:
+
+import Cyclops
+z = Cyclops.CycleFinder()
+
+This creates a cycle-tracker with an empty "root set".  Then tell z
+which objects you're curious about (more on that later).
+
+After running your regular code, tell z to look for cycles:
+
+z.find_cycles(purge_dead_roots=0)
+    Look for cycles reachable from the root set.
+    Return 1 if a cycle was found, else 0.
+    If optional arg purge_dead_roots is true, first remove objects
+    from the root set whose true refcount (exclusive of CycleFinder
+    internal references) is 0.
+    See also method install_cycle_filter.
+
+Then various methods can be used to get useful reports.  Which are
+*most* useful you'll just have to play with.  If you have a few small
+cycles, show_cycles is very revealing; if you have many cycles,
+show_sccs and show_arcs *may* cut to the heart of the problem quickly.
+
+z.show_stats()
+    Print some stats about the last run of find_cycles:  number of
+    distinct structured objects reachable from the root set, number of
+    distinct objects involved in a cycle, number of cycles found,
+    number of strongly connected components, number of objects in the
+    root set, and number of edges (graph arcs) examined.
+
+z.show_cycles()
+    Print each cycle found to stdout.
+
+z.show_cycleobjs(compare=typename_address_cmp)
+    Print a listing of all objects involved in some cycle.  The
+    objects are first sorted via the optional "compare" function.  By
+    default, sorts first by type name and then by address (id); among
+    objects of instance type, sorts by the instances' class names;
+    among objects of class type, sorts by the classes' names.
+
+x.show_sccs(compare=typename_address_cmp)
+    Print a listing of cycle objects partitioned into strongly
+    connected components (that is, the largest groupings possible such
+    that each object in an SCC is reachable from every other object in
+    that SCC).  Within each SCC, objects are sorted as for
+    show_cycleobjs.
+
+z.show_arcs(compare=None)
+    Print a listing of all arc types involved in some cycle.  An arc
+    is characterized by:
+    1) its source object type or class,
+    2) the selector (e.g. attribute) from the source, and
+    3) its destination object type or class.
+    The output is a table with four columns:  count, source, selector,
+    destination.  The table is sorted by default on columns 2, 3, 4
+    in that order; the first column (count) is ignored.  Specify an
+    alternative compare function to change the sort; the compare
+    function sees pairs of the form
+        ((source_type, selector, destination_type), count)
+    where each element of the triple is a string and count is an int.
+
+z.show_obj(obj)
+    Print a 2-line description of obj, including its address, adjusted
+    refcount, type name and a short representation of its contents.
+    See the method docstring for details.
+
+There are two ways to add objects to the root set:
+
+z.run(func, args=(), kwargs={})
+    Run func (with optional args and keyword arguments kwargs), adding
+    every object initialized by an __init__ function to the root set.
+    This is the closest Cyclops gets to plumbo's "lazy" mode.  It's
+    factored out here so it can be intermixed with the next method.
+
+z.register(obj)
+    Add obj to the root set.
+
+To see the current root set,
+
+z.get_rootset()
+    Return the root set, as a list of (rc, cyclic?, obj) tuples.
+    See method docstring for details.  In short, rc is the true
+    refcount (CycleFinder internal references are subtracted out);
+    cyclic is true iff the object is in a known cycle; and obj is the
+    object.
+
+Finally, to empty the root set again:
+
+z.clear()
+    Empty the root set, and release all other internal references to
+    register'ed objects.
+
+Notes:
+
++ Run Cyclops.py directly to exercise its _test() function; _test()
+  sets up some common kinds of cycles, and should be easy to follow.
+  Stare at the _test() code and the output until their relationship is
+  clear.
+
++ find_cycles is linear-time, in the number of objects reachable from
+  the root set plus the number of arcs connecting them.  This makes
+  Cyclops pleasant for "real life" apps with tens of thousands of
+  reachable objects, and at least usable well beyond that.
+
++ A (at least one) reference to each root-set object is maintained
+  internally, so roots cannot die before invoking .clear() (or the
+  CycleFinder is finalized).  This can distort the truth of your
+  program, if a __del__ method of some root object that's not involved
+  in a cycle could have caused cycles to get broken (this is unusual,
+  but possible!).
+
+  If you suspect it's happening, run find_cycles again passing true
+  (optional arg purge_dead_roots):  find_cycles then releases all
+  internal refs to root set objects whose true refcount is 0, thus
+  allowing their __del__ methods to get invoked.  After that,
+  find_cycles chases the remaining root set objects again.  You may
+  need several iterations of invoking find_cycles(1) before reaching a
+  steady state!
+
++ By default, cycles are chased through these (& only these) objects:
+
+  - Lists.
+  - Tuples.
+  - Dicts (both keys and values).
+  - Class instances (through their attributes).
+  - Classes (through their attributes).
+  - Instance method objects (through .im_self and .im_class).
+
+  In particular, modules are not chased.  Maybe they should be.  See
+  the next section for a way to force modules to get chased.
+
+
+CHANGING THE SET OF INTERESTING TYPES
+
+Methods of a CycleFinder object can be used to alter/query its view of
+the set of types find_cycles "chases":
+
+z.chase_type(t, t_refs_func, t_tag_func)
+    Add type t to the set of interesting types.
+    t_refs_func is a function of one argument x, where type(x) is t;
+    it should return a sequence (typically a list or tuple) of all
+    objects directly reachable from x.
+    t_tag_func is a function of two arguments x and i, where type(x)
+    is t and i in range(len(t_refs_func(x))).  It should return a
+    brief string describing how t_refs_func(x][i] was obtained from
+    x.
+    See the _XXX_refs and _XXX_tag functions at the start of the
+    module for examples of all this.
+
+z.dont_chase_type(t)
+    Remove type t from the set of interesting types.  find_cycles
+    will not attempt to chase the objects reachable from objects of
+    type t.
+
+z.get_chased_types()
+    Return the set of interesting types, as a list.
+
+
+CHANGING THE SET OF INTERESTING CYCLES
+
+Sometimes there are "expected" cycles you would like to ignore; e.g.,
+this can happen if you install a module-chaser, because there are
+cycles in Python's implementation you typically don't care about (for
+example, if your module imports sys, there's a cycle because
+sys.modules points back to your module!).
+
+z.install_cycle_filter(filter_func=None)
+    filter_func=None -> a way to ignore "expected" cycles.
+
+    filter_func is a function of one argument, a cycle.  Each time
+    find_cycles finds a cycle, the cycle is passed to filter_func.  The
+    cycle is ignored unless filter_func returns true.  Passing None
+    for filter_func restores the default behavior (do not ignore any
+    cycle).
+
+    A cycle is a list of (object, index) pairs, where the first object
+    in the list is the same as the last object in the list, and where
+    the object at cycle[i][0] is the cycle[i][1]'th object obtained
+    from object cycle[i-1][0]. cycle[0][1] should be ignored (it tells
+    us how we got to the first item in the cycle to begin with, but
+    that's irrelevant to the cycle).
+
+
+CASE STUDY
+
+Below is the driver I used to track cycles in IDLE; it's a replacement
+for IDLE's idle.py.
+
+At first it didn't install function or module chasers, or a cycle filter,
+and printed everything.  This turned up a bunch of easy cases, and the
+show_sccs output was surprisingly revealing (all the cycles fell into a
+handful of SCCs, which corresponded to distinct cycle-creating IDLE
+subsystems).  show_arcs was also very helpful in getting the big picture.
+show_cycles output was too voluminous to be helpful.
+
+After those cycles were broken, the job got harder.  A module chaser was
+added, which turned up another class of cycles, and then a function
+chaser turned up 100s more.  Most of these involved expected cycles due
+to Python's implementation, so a cycle filter was installed to ignore
+cycles that didn't contain at least one class instance.  The remaining
+cycles were isolated special cases, and only show_cycles output was
+of real use.
+
+After all cycles were purged, IDLE was still leaking, so driver output was
+added to display the root-set objects still alive at the end.  This turned
+up many cases where objects were living only because registration in the
+root set was keeping them alive.  So a loop was added to the driver that
+repeatedly purges dead root-set objects and tries again.  The __del__
+methods of the purged roots caused other root objects to become trash,
+and after several iterations of this the output reaches a steady state.
+
+IDLE is still leaking (as of 18-Jul-1999), but ever less so, and while
+Cyclops is no longer finding cycles, the driver's "live at the end"
+output is still the best clue I've got for guessing what to do next.
+
+Interesting:  At the start of this, it turned out that almost all cycles
+were reachable from places outside themselves.  That is, they would not
+have been considered trash even if Python used a mark-&-sweep form of
+garbage collection.  IDLE's problems, in large part inherited from Tkinter,
+are simply that "everything points to everything else".  The good news is
+that Guido was able to clean most of this up just by adding reference-
+purging code to widgets' explicitly-called destroy() methods.
+
+#! /usr/bin/env python
+import PyShell
+import Cyclops
+import types
+
+def mod_refs(x):
+    return x.__dict__.values()
+
+def mod_tag(x, i):
+    return "." + x.__dict__.keys()[i]
+
+def func_refs(x):
+    return x.func_globals, x.func_defaults
+
+def func_tag(x, i):
+    return (".func_globals", ".func_defaults")[i]
+
+def instance_filter(cycle):
+    for obj, index in cycle:
+        if type(obj) is types.InstanceType:
+            return 1
+    return 0
+
+# Note: PyShell binds ModifiedInterpreter.locals  to __main__.__dict__,
+# and __main__ is *us*.  So if we don't keep the CycleFinder instance
+# out of the global namespace here, z starts chewing over its own
+# instance attributes.  Nothing breaks, but the output is at best
+# surprising.
+
+def hidez():
+    z = Cyclops.CycleFinder()
+    z.chase_type(types.ModuleType, mod_refs, mod_tag)
+    z.chase_type(types.FunctionType, func_refs, func_tag)
+    z.install_cycle_filter(instance_filter)
+    z.run(PyShell.main)
+    z.find_cycles()
+    z.show_stats()
+    z.show_cycles()
+    # z.show_cycleobjs()
+    # z.show_sccs()
+    z.show_arcs()
+    while 1:
+        print "*" * 70
+        print "non-cyclic root set objects:"
+        sawitalready = {}
+        numsurvivors = numdead = 0
+        for rc, cyclic, x in z.get_rootset():
+            if not sawitalready.has_key(id(x)):
+                sawitalready[id(x)] = 1
+                if rc == 0:
+                    print "DEAD",
+                    numdead = numdead + 1
+                    z.show_obj(x)
+                elif not cyclic:
+                    numsurvivors = numsurvivors + 1
+                    z.show_obj(x)
+        x = None
+        print numdead, "dead;", numsurvivors, "non-cycle & alive"
+        if numdead == 0:
+            break
+        print "releasing dead root-set objects and trying again"
+        z.find_cycles(1)
+        z.show_stats()
+
+hidez()
+"""
+
+# 0,9,4    18-Jul-1999
+#    added purge_dead_roots arg to find_cycles
+#    rearranged module docstring; added IDLE driver sample
+# 0,9,3    29-Jun-1999
+#    renamed print_obj to show_obj, and advertised it
+#    redid adjusted refcount computations to account for root-set
+#        objects too
+#    changed get_rootset to return (refcount, cyclic?, obj) triples
+# 0,9,2    27-Jun-1999
+#    freed __init_tracer from dependence on name "self"
+#    rearranged __find_cycles' inner loop for a nice little speed gain
+#    which was promptly way more than lost by new code to compute &
+#        display adjusted refcounts
+#    which was partly regained by rewriting all that
+# 0,9,1    26-Jun-1999
+#    added SCC computation/display
+#    added show_cycles; find_cycles no longer prints anything
+#    changed all showXXX names to show_XXX
+#    added install_cycle_filter
+# 0,9,0    24-Jun-1999
+#    first version I put under source control
+
+__version__ = 0, 9, 4
+
+#########################################################################
+# Type-specific reference revealers.
+#
+# _T_refs(obj) should return a sequence of all objects directly
+# reachable from obj.
+#
+# _T_tag(obj, i) should return a string briefly describing how
+# _T_refs(obj][i] was obtained from obj.
+#
+# Why the separation?  Speed and space:  string tags are never
+# computed unless a cycle is found and so something needs to be
+# printed.
+
+def _dict_refs(x):
+    return x.keys() + x.values()
+def _dict_tag(x, i):
+    n = len(x)
+    if i < n:
+        return ".keys()[%d]" % i
+    else:
+        return "[%s]" % _quickrepr(x.keys()[i-n])
+
+def _list_refs(x):
+    return x
+def _list_tag(x, i):
+    return "[%d]" % i
+
+_tuple_refs = _list_refs
+_tuple_tag = _list_tag
+
+def _instance_refs(x):
+    # the keys are strings, so not interesting to return
+    return x.__dict__.values()
+def _instance_tag(x, i):
+    return "." + x.__dict__.keys()[i]
+
+_class_refs = _instance_refs
+_class_tag = _instance_tag
+
+def _instance_method_refs(x):
+    return (x.im_self, x.im_class)
+def _instance_method_tag(x, i):
+    return (".im_self", ".im_class")[i]
+
+import types
+_default_refs_dispatcher = {
+    types.DictType: _dict_refs,
+    types.ListType: _list_refs,
+    types.TupleType: _tuple_refs,
+    types.InstanceType: _instance_refs,
+    types.ClassType: _class_refs,
+    types.MethodType: _instance_method_refs,
+}
+_default_tag_dispatcher = {
+    types.DictType: _dict_tag,
+    types.ListType: _list_tag,
+    types.TupleType: _tuple_tag,
+    types.InstanceType: _instance_tag,
+    types.ClassType: _class_tag,
+    types.MethodType: _instance_method_tag,
+}
+_InstanceType = types.InstanceType
+_ClassType = types.ClassType
+del types
+
+del _dict_refs, _list_refs, _tuple_refs, _instance_refs, \
+    _class_refs, _instance_method_refs
+del _dict_tag, _list_tag, _tuple_tag, _instance_tag, \
+    _class_tag, _instance_method_tag
+
+#########################################################################
+# A class to make short string representations of objects, for speed
+# and brevity.  The std repr.repr sorts dicts by keys, but we refer to
+# the keys via numeric subscript in cycle reports, so first a derived
+# class that leaves dicts in raw order.  Also, instances, instance
+# methods and classes frequently appear in cycle reports, so avoid
+# chopping their reprs at all.  We're only trying to prevent massive
+# expense for massive lists, tuples & dicts.
+
+import repr
+_repr = repr
+del repr
+
+class _CyclopsRepr(_repr.Repr):
+
+    def __init__(self):
+        _repr.Repr.__init__(self)
+        # Boost the limit on types we don't know about; else it's too
+        # easy to get a useless repr string when adding new types via
+        # CycleFinder.chase_type.
+        # Perhaps better to expose this class too, but-- sheesh --
+        # this module is complicated enough!
+        self.maxstring = self.maxother = 40
+
+    # override base dictionary formatter; the code is almost the same,
+    # we just leave the dict order alone
+
+    def repr_dictionary(self, x, level):
+        n = len(x)
+        if n == 0:
+            return '{}'
+        if level <= 0:
+            return '{...}'
+        s = ''
+        for k, v in x.items()[:min(n, self.maxdict)]:
+            if s:
+                s = s + ', '
+            s = s + self.repr1(k, level-1)
+            s = s + ': ' + self.repr1(v, level-1)
+        if n > self.maxdict:
+            s = s + ', ...'
+        return '{' + s + '}'
+
+    # don't chop instance, class or instance method reprs
+
+    def repr_instance(self, x, level):
+        try:
+            return `x`
+            # Bugs in x.__repr__() can cause arbitrary
+            # exceptions -- then make up something
+        except:
+            return '<' + x.__class__.__name__ + ' instance at ' + \
+                   hex(id(x))[2:] + '>'
+
+    def repr_class(self, x, level):
+        return `x`
+
+    repr_instance_method = repr_class
+
+_quickrepr = _CyclopsRepr().repr
+
+#########################################################################
+# CycleFinder is the workhorse.
+
+def typename_address_cmp(x, y):
+    if isinstance(x, _InstanceType) and isinstance(y, _InstanceType):
+        xname, yname = x.__class__.__name__, y.__class__.__name__
+    elif isinstance(x, _ClassType) and isinstance(y, _ClassType):
+        xname, yname = x.__name__, y.__name__
+    else:
+        xname, yname = type(x).__name__, type(y).__name__
+    return cmp((xname, id(x)), (yname, id(y)))
+
+class CycleFinder:
+    """Class for finding cycles in Python data structures.
+
+    See Cyclops module docstring for details.
+    """
+
+    def __init__(self):
+        """Create a cycle finder with empty root set."""
+
+        self.clear()
+        self.refs_dispatcher = _default_refs_dispatcher.copy()
+        self.tag_dispatcher = _default_tag_dispatcher.copy()
+        self.cycle_filter = None
+
+    def clear(self):
+        """Remove all internal references to external objects.
+
+        Empties the root set.
+        Does not change the set of types this CycleFinder chases.
+        Does not change the cycle filter in effect.
+        """
+
+        self.roots = []
+        self.__reset()
+
+    def register(self, obj):
+        """obj -> add object obj to the root set."""
+
+        self.roots.append(obj)
+
+    def run(self, func, args=(), kwargs={}):
+        """func, args=(), kwargs={} -> add objects to root set by magic.
+
+        Function func is invoked with arguments args and keyword
+        arguments kwargs.  For the duration of the call, each class
+        instance initialized by an __init__ call is automatically
+        added to the root set.  The result of invoking func is
+        returned. """
+
+        # This clever method of trapping __init__ invocations was
+        # stolen from Lars' plumbo.py.
+        import sys
+        sys.setprofile(self.__init_tracer)
+        try:
+            return apply(func, args, kwargs)
+        finally:
+            sys.setprofile(None)
+
+    def find_cycles(self, purge_dead_roots=0):
+        """purge_dead_roots=0 -> look for cycles, return true if found.
+
+        Identify all cycles among objects reachable from the root set.
+        Return true iff at least one cycle is found.
+
+        This should be called before any of the show_XXX methods.
+        Note that it's OK to add more objects to the root set and
+        call it again, or to change the set of chased types, etc.
+        find_cycles starts over from scratch each time it's called.
+
+        If optional arg purge_dead_roots is true (default false),
+        before searching for cycles the root set is purged of all
+        objects that the preceding run of find_cycles determined had a
+        true refcount of 0 (that is, the root set objects that are
+        still alive only because they appear in the root set).
+        Purging these allows their finalizers to get invoked, which
+        may allow a cascade of other objects (including cycles) to go
+        away too.
+
+        See also method install_cycle_filter.
+        """
+
+        if purge_dead_roots and self.roots:
+            id2rc = self.id2rc.get
+            survivors = []
+            for x in self.roots:
+                if id2rc(id(x), None) != 0:
+                    survivors.append(x)
+            self.roots = survivors
+            del x, survivors, id2rc
+
+        self.__reset()
+        self.__find_cycles(self.roots, 0)
+        del self.seenids[id(self.roots)]    # not a user-visible object
+
+        # Compute true refcounts for objects in cycles.
+        id2rc = self.id2rc
+        from sys import getrefcount
+        for x in self.cycleobjs.values():
+            # From the system refcount, subtract one for each of:
+            #    being an element in the loop temp cycleobjs.values()
+            #    being bound to "x"
+            #    being an argument to getrefcount
+            #    being a value in the cycleobjs dict
+            #    showing up exactly once somewhere in self.sccno2objs
+            xid = id(x)
+            id2rc[xid] = getrefcount(x) - 5
+
+        # Need also to subtract refs due to appearances in
+        # self.cycles.  Complication:  some pairs in self.cycles may
+        # be shared.
+        seenpairs = {}
+        isknown = seenpairs.has_key
+        for cycle in self.cycles:
+            for pair in cycle:
+                pairid = id(pair)
+                if not isknown(pairid):
+                    seenpairs[pairid] = 1
+                    xid = id(pair[0])
+                    id2rc[xid] = id2rc[xid] - 1
+        del isknown, seenpairs
+
+        # And need also to subtract refs for membership is self.roots.
+        # While we're at it, also compute adjusted refcounts for other
+        # root set objects.
+        for x in self.roots:
+            xid = id(x)
+            if id2rc.has_key(xid):
+                id2rc[xid] = id2rc[xid] - 1
+            else:
+                assert not self.cycleobjs.has_key(xid)
+                # Subtract one for each of:
+                #     being bound to "x"
+                #     being an argument to getrefcount
+                #     being in self.roots
+                id2rc[xid] = getrefcount(x) - 3
+
+        return len(self.cycles) > 0
+
+    def install_cycle_filter(self, filter_func=None):
+        """filter_func=None -> a way to ignore "expected" cycles.
+
+        See module docstring for details.  This is a callback function
+        invoked whenever find_cycles() finds a cycle; the cycle is
+        ignored unless the callback returns true.
+        """
+
+        self.cycle_filter = filter_func
+
+    def show_stats(self):
+        """Print statistics for the last run of find_cycles."""
+
+        self._print_separator()
+        print "# objects in root set:", len(self.roots)
+        print "# distinct structured objects reachable:", len(self.seenids)
+        print "# distinct structured objects in cycles:", len(self.cycleobjs)
+        print "# cycles found:", len(self.cycles)
+        print "# cycles filtered out:", self.ncyclesignored
+        print "# strongly-connected components:", len(self.sccno2objs)
+        print "# arcs examined:", self.narcs
+
+    def show_cycles(self):
+        """Print all cycles to stdout."""
+
+        self._print_separator()
+        print "# all cycles:"
+        n = len(self.cycles)
+        for i in xrange(n):
+            self._print_cycle(self.cycles[i])
+            if i < n-1:
+                print "-" * 20
+
+    def show_cycleobjs(self, compare=typename_address_cmp):
+        """compare=typename_address_cmp -> print all objects in cycles.
+
+        Prints to stdout.  Each distinct object find_cycles found in a
+        cycle is displayed.  The set of objects found in cycles is
+        first sorted by the optional "compare" function.  By default,
+        objects are sorted using their type name as the primary key
+        and their storage address (id) as the secondary key; among
+        objects of instance type, sorts by the instances' class names;
+        among objects of class type, sorts by the classes' names.
+        """
+
+        self._print_separator()
+        print "# objects involved in cycles:"
+        objs = self.cycleobjs.values()
+        objs.sort(compare)
+        for obj in objs:
+            self.show_obj(obj)
+
+    def show_sccs(self, compare=typename_address_cmp):
+        """compare=typename_address_cmp -> print SCCs.
+
+        Prints to stdout.  Shows the objects in cycles partitioned into
+        strongly connected components (that is, the largest groupings
+        possible such that each object in an SCC is reachable from every
+        other object in that SCC).  Within each SCC, objects are sorted
+        as for show_cycleobjs.
+        """
+
+        self._print_separator()
+        print "# cycle objects partitioned into maximal SCCs:"
+        sccs = self.sccno2objs.values()
+        n = len(sccs)
+        for i in xrange(n):
+            print "--- SCC", i+1, "of", n
+            objs = sccs[i]
+            objs.sort(compare)
+            for obj in objs:
+                self.show_obj(obj)
+
+    def show_arcs(self, compare=None):
+        """compare=None -> print unique arc types in cycles.
+
+        See module docstring for details.  Briefly, each arc in a
+        cycle is categorized by the type of the source node, the kind
+        of arc (how we got from the source to the destination), and
+        the type of the destination node.  Each line of output
+        consists of those three pieces of info preceded by the count
+        of arcs of that kind.  By default, the rows are sorted first
+        by column 2 (source node type), then by columns 3 and 4.
+        """
+
+        self._print_separator()
+        print "# arc types involved in cycles:"
+        items = self.arctypes.items()
+        if compare:
+            items.sort(compare)
+        else:
+            items.sort()
+        for triple, count in items:
+            print "%6d %-20s %-20s -> %-20s" % ((count,) + triple)
+
+    def get_rootset(self):
+        """Return the root set, as a list of (rc, cyclic?, obj) tuples.
+
+        Should be called after find_cycles.  For each object in the
+        root set, returns a triple consisting of
+        refcount
+            number of outstanding references less those due to
+            CycleFinder internals; see show_obj docstring for more
+            details; this will be None if find_cycles hasn't been
+            run, or not since the last clear()
+        cyclic?
+            true (1) iff obj is known to be in a cycle
+        obj
+            the object
+        """
+
+        result = []
+        getrc = self.id2rc.get
+        incycle = self.cycleobjs.has_key
+        for x in self.roots:
+            xid = id(x)
+            result.append((getrc(xid, None), incycle(xid), x))
+        return result
+
+    def chase_type(self, t, t_refs_func, t_tag_func):
+        """t, t_refs_func, t_tag_func -> chase type t.
+
+        See module docstring for details.
+        """
+
+        self.refs_dispatcher[t] = t_refs_func
+        self.tag_dispatcher[t] = t_tag_func
+
+    def dont_chase_type(self, t):
+        """t -> remove type t from the set of chased types.
+
+        See module docstring for details.
+        """
+
+        try:
+            del self.refs_dispatcher[t], \
+                self.tag_dispatcher[t]
+        except KeyError:
+            pass
+
+    def get_chased_types(self):
+        """Return the set of chased types, as a list."""
+
+        return self.refs_dispatcher.keys()
+
+    def __init_tracer(self, frame, event, args):
+        try:
+            a = event == "call"
+            b = frame.f_code.co_name == "__init__"
+
+            if a and b:
+                # We want to capture the first argument -- this works whether
+                # or not it's named "self", and in case the function is like
+                #     def __init__(*args):
+                # it's still OK:  we'll pick up the name 'args', and add the
+                # tuple it's bound to to the root set; the tuple's first
+                # element is "self", so will be found by the tuple-chaser.
+                locals = frame.f_code.co_varnames
+                if locals:
+                    # first argname is first element of locals
+                    self.register(frame.f_locals[locals[0]])
+        except:
+            print `event`, frame, frame.f_code, frame.f_code.co_name
+
+
+    def __reset(self):
+        # Clear out everything except:
+        #       the root set
+        #       the refs_dispatcher
+        #       the tag_dispatcher
+        #       the cycle filter
+
+        # stack exactly mirrors __find_cycles' recursive calls; it's a
+        # list of (object, index) pairs.
+        self.stack = []
+
+        # Map id of active object to its index in self.stack.  Since
+        # it's a depth-first search, there's a cycle iff we hit an
+        # object that's already on the stack.
+        self.id2stacki = {}
+
+        # Set of (addresses of) all interesting objects seen.  Since
+        # we use a depth-first search, there's never a reason to
+        # revisit a node.
+        self.seenids = {}
+
+        # List of all cycles found; each element is a stack slice (a
+        # list of (object, index) pairs).
+        self.cycles = []
+
+        # Set of objects found in cycles (maps id(obj) -> obj).
+        self.cycleobjs = {}
+
+        # Classifies arcs found in cycles, mapping
+        # (source_type, selector, destination_type) triples to a count
+        # of how many times that triple appears in a cycle.
+        self.arctypes = {}
+
+        # Support for computing strongly-connected components (SCC).
+        # We do this by merging cycles into equivalence classes.
+        # Could be done faster by e.g. Tarjan's algorithm in
+        # __find_cycles, but would rather keep that lean since cycles
+        # are expected to be unusual.
+        self.nextsccno = 1      # monotonically increasing SCC id
+        self.id2sccno = {}      # map id(obj) to obj's sccno
+        self.sccno2objs = {}    # map sccno back to list of objects
+
+        # For objects in cycles and root set, map address to true
+        # reference count.
+        self.id2rc = {}
+
+        # Number of arcs examined.
+        self.narcs = 0
+
+        # Number of cycles ignored (filtered out).
+        self.ncyclesignored = 0
+
+    def __find_cycles(self, obj, i, id=id, type=type, len=len):
+        # This can be called an enormous number of times, so speed
+        # tricks are appropriate.
+
+        stack = self.stack
+
+        # Set of ids of objects being, or formerly, chased.
+        seenids = self.seenids
+        already_seen = seenids.has_key
+
+        # Maps active object id to index in stack.
+        id2stacki = self.id2stacki
+        currently_on_stack = id2stacki.has_key
+
+        refs_dispatcher = self.refs_dispatcher
+        is_interesting_type = refs_dispatcher.has_key
+
+        myid = id(obj)
+        seenids[myid] = 1
+        id2stacki[myid] = len(stack)
+        stack.append((obj, i))
+        refs = refs_dispatcher[type(obj)](obj)
+        self.narcs = self.narcs + len(refs)
+        for i in xrange(len(refs)):
+            child = refs[i]
+            if is_interesting_type(type(child)):
+                childid = id(child)
+                if not already_seen(childid):
+                    self.__find_cycles(child, i)
+                elif currently_on_stack(childid):
+                    cycle = stack[id2stacki[childid]:]
+                    cycle.append((child, i)) # complete the cycle
+                    self.__study_cycle(cycle)
+
+        del stack[-1], id2stacki[myid]
+
+    # a helper for __study_cycle
+    def __obj2arcname(self, obj):
+        if isinstance(obj, _InstanceType):
+            name = obj.__class__.__name__ + "()"
+        elif isinstance(obj, _ClassType):
+            name = obj.__name__
+        else:
+            name = type(obj).__name__
+        return name
+
+    def __study_cycle(self, slice):
+        assert len(slice) >= 2
+
+        if self.cycle_filter is not None and \
+           not self.cycle_filter(slice):
+            self.ncyclesignored = self.ncyclesignored + 1
+            return
+
+        self.cycles.append(slice)
+
+        # Pick (or create) an SCC equivalence class for this cycle.
+        sccnowinner = self.id2sccno.get(id(slice[0][0]), None)
+        if sccnowinner is None:
+            sccnowinner = self.nextsccno
+            self.nextsccno = self.nextsccno + 1
+            self.sccno2objs[sccnowinner] = []
+        classwinner = self.sccno2objs[sccnowinner]
+
+        for i in xrange(len(slice)-1):
+            obj1 = slice[i][0]
+            key1 = self.__obj2arcname(obj1)
+
+            obj2, index = slice[i+1]
+            key2 = self.tag_dispatcher[type(obj1)](obj1, index)
+
+            key3 = self.__obj2arcname(obj2)
+
+            key = (key1, key2, key3)
+            self.arctypes[key] = self.arctypes.get(key, 0) + 1
+
+            self.cycleobjs[id(obj1)] = obj1
+
+            # Merge the equivalence class for obj1 into classwinner.
+            thissccno = self.id2sccno.get(id(obj1), None)
+            if thissccno is None:
+                self.id2sccno[id(obj1)] = sccnowinner
+                classwinner.append(obj1)
+            elif thissccno != sccnowinner:
+                # merge obj1's entire equivalence class
+                tomerge = self.sccno2objs[thissccno]
+                for obj2 in tomerge:
+                    self.id2sccno[id(obj2)] = sccnowinner
+                classwinner.extend(tomerge)
+                del self.sccno2objs[thissccno]
+
+    ################################################################
+    # Various output routines.  If someone is motivated enough to
+    # change one of these, they're motivated enough to subclass us!
+
+    def show_obj(self, obj):
+        """obj -> print short description of obj to sdtout.
+
+        This is of the form
+
+        <address> rc:<refcount> <typename>
+            repr: <shortrepr>
+
+        where
+        <address>
+            hex address of obj
+        <refcount>
+            If find_cycles() has been run and obj is in the root set
+            or was found in a cycle, this is the number of references
+            outstanding less the number held internally by
+            CycleFinder.  In most cases, this is what the true
+            refcount would be had you not used CycleFinder at all.
+            You can screw that up, e.g. by installing a cycle filter
+            that holds on to references to one or more cycle elements.
+            If find_cycles() has not been run, or has but obj wasn't
+            found in a cycle and isn't in the root set, <refcount> is
+            "?".
+        <typename>
+            type(obj), as a string.  If obj.__class__ exists, also
+            prints the class name.
+        <shortrepr>
+            repr(obj), but using a variant of the std module repr.py
+            that limits the number of characters displayed.
+        """
+
+        objid = id(obj)
+        rc = self.id2rc.get(objid, "?")
+        print hex(objid), "rc:" + str(rc), type(obj).__name__,
+        if hasattr(obj, "__class__"):
+            print obj.__class__,
+        print
+        print "    repr:", _quickrepr(obj)
+
+    def _print_separator(self):
+        print "*" * 70
+
+    def _print_cycle(self, slice):
+        n = len(slice)
+        assert n >= 2
+        print "%d-element cycle" % (n-1)
+        for i in xrange(n):
+            obj = slice[i][0]
+            self.show_obj(obj)
+            if i < n-1:
+                index = slice[i+1][1]
+                print "    this" + \
+                      self.tag_dispatcher[type(obj)](obj, index), \
+                      "->"
+
+def _test():
+    class X:
+        def __init__(me, name):
+            me.name = name
+        def __repr__(self):
+            return "X(" + `self.name` + ")"
+
+    a, b, c, d = X('a'), X('b'), X('c'), X('d')
+    a.k = b
+    b.k = c
+    c.k = a
+    a.y = b.y = c.y = d
+    d.k = {'harrumph': (1, 2, d, 3)}
+    e = X('e')
+    e.selfref = e
+    a.gotoe = e
+    a.__repr__ = a.__repr__
+
+    class Y: pass
+    X.gotoy = Y
+    Y.gotox = X
+
+    lonely = X('lonely')
+
+    z = CycleFinder()
+    z.register(a)
+    z.register(lonely)
+    del a, b, c, d, e, X, Y, lonely
+    z.find_cycles()
+    z.show_stats()
+    z.show_cycles()
+    z.show_cycleobjs()
+    z.show_sccs()
+    z.show_arcs()
+    print "dead root set objects:"
+    for rc, cyclic, x in z.get_rootset():
+        if rc == 0:
+            z.show_obj(x)
+    z.find_cycles(1)
+    z.show_stats()
+
+if __name__ == "__main__":
+    _test()

From 772a84685607f984e50f2a55b55f98f9362491ef Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 17 Jun 2011 17:18:53 +0200
Subject: [PATCH 0072/1541] Undid earlier changes in GF3DAbsSym.hpp/.cpp and
 changed function names in freeFunctions so that there are function names for
 1D and 3D brownian dynamics functions.

---
 BDPropagator.hpp              |  4 ++--
 GreensFunction3DAbsSym.cpp    |  7 -------
 GreensFunction3DAbsSym.hpp    |  2 --
 doc/greens_functions/Makefile |  0
 freeFunctions.cpp             | 12 ++++++------
 greens_functions.cpp          |  2 +-
 6 files changed, 9 insertions(+), 18 deletions(-)
 mode change 100644 => 100755 doc/greens_functions/Makefile

diff --git a/BDPropagator.hpp b/BDPropagator.hpp
index 42b46879..d712fdf0 100644
--- a/BDPropagator.hpp
+++ b/BDPropagator.hpp
@@ -240,7 +240,7 @@ class BDPropagator
 
                             const Real rnd(rng_());
                             length_type pair_distance(
-                                drawR_gbd(rnd, r01, dt_, D01));
+                                drawR_gbd_3D(rnd, r01, dt_, D01));
                             const position_type m(random_unit_vector() * pair_distance);
                             np0 = tx_.apply_boundary(pp.second.position()
                                     + m * (s0.D() / D01));
@@ -309,7 +309,7 @@ class BDPropagator
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
             reaction_rule_type const& r(*i);
-            const Real p(r.k() * dt_ / ((I_bd(r01, dt_, s0.D()) + I_bd(r01, dt_, s1.D())) * 4.0 * M_PI));
+            const Real p(r.k() * dt_ / ((I_bd_3D(r01, dt_, s0.D()) + I_bd_3D(r01, dt_, s1.D())) * 4.0 * M_PI));
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
diff --git a/GreensFunction3DAbsSym.cpp b/GreensFunction3DAbsSym.cpp
index 6bc85100..2baabb66 100644
--- a/GreensFunction3DAbsSym.cpp
+++ b/GreensFunction3DAbsSym.cpp
@@ -405,10 +405,3 @@ std::string GreensFunction3DAbsSym::dump() const
 
 Logger& GreensFunction3DAbsSym::log_(
         Logger::get_logger("GreensFunction3DAbsSym"));
-
-std::string GreensFunction3DAbsSym::dump() const
-{
-    std::ostringstream ss;
-    ss << "D = " << this->getD() << ", a = " << this->geta() << std::endl;
-    return ss.str();
-}
diff --git a/GreensFunction3DAbsSym.hpp b/GreensFunction3DAbsSym.hpp
index 3ce43f95..534ea62f 100644
--- a/GreensFunction3DAbsSym.hpp
+++ b/GreensFunction3DAbsSym.hpp
@@ -37,8 +37,6 @@ class GreensFunction3DAbsSym: public GreensFunction
 	
     std::string dump() const;
 
-    std::string dump() const;
-
     const char* getName() const
     {
         return "GreensFunction3DAbsSym";
diff --git a/doc/greens_functions/Makefile b/doc/greens_functions/Makefile
old mode 100644
new mode 100755
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index 8c19cad7..08c9b37e 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -257,7 +257,7 @@ Real ip_theta_free(Real theta, Real r, Real r0, Real t, Real D)
     return (term1 - term2) / den;
 }
 
-Real g_bd(Real r, Real sigma, Real t, Real D)
+Real g_bd_3D(Real r, Real sigma, Real t, Real D)
 {
     const Real Dt4(4.0 * D * t);
     const Real mDt4_r(- 1.0 / Dt4);
@@ -276,7 +276,7 @@ Real g_bd(Real r, Real sigma, Real t, Real D)
     return 0.5 * (term1 + term2) * r * r;
 }
     
-Real I_bd(Real sigma, Real t, Real D)
+Real I_bd_3D(Real sigma, Real t, Real D)
 {
     const Real sqrtPi(std::sqrt(M_PI));
 
@@ -298,7 +298,7 @@ Real I_bd(Real sigma, Real t, Real D)
 }
 
 
-Real I_bd_r(Real r, Real sigma, Real t, Real D)
+Real I_bd_r_3D(Real r, Real sigma, Real t, Real D)
 {
     const Real sqrtPi(std::sqrt(M_PI));
 
@@ -335,7 +335,7 @@ Real I_bd_r(Real r, Real sigma, Real t, Real D)
 }
 
 
-struct g_bd_params
+struct g_bd_3D_params
 { 
     const Real sigma;
     const Real t;
@@ -344,7 +344,7 @@ struct g_bd_params
 };
 
 
-static Real I_gbd_r_F(Real r, const g_bd_params* params)
+static Real I_gbd_r_3D_F(Real r, const g_bd_params* params)
 {
     const Real sigma(params->sigma);
     const Real t(params->t);
@@ -354,7 +354,7 @@ static Real I_gbd_r_F(Real r, const g_bd_params* params)
     return I_bd_r(r, sigma, t, D) - target;
 }
 
-Real drawR_gbd(Real rnd, Real sigma, Real t, Real D)
+Real drawR_gbd_3D(Real rnd, Real sigma, Real t, Real D)
 {
     const Real I(I_bd(sigma, t, D));
 
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 5a07ba20..1822fc3f 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -93,7 +93,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "p_int_r", &GreensFunction3DAbsSym::p_int_r )
         .def( "p_int_r_free", &GreensFunction3DAbsSym::p_int_r_free )
         //.def( "p_r_fourier", &GreensFunction3DAbsSym::p_r_fourier )
-	.def( "dump", &GreensFunction3DAbsSym::dump )
+	    .def( "dump", &GreensFunction3DAbsSym::dump )
         ;
 
     class_<GreensFunction3DRadInf>("GreensFunction3DRadInf",

From b1545d70233a8f879bc11559c43584de0ed27f34 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 17 Jun 2011 19:06:34 +0200
Subject: [PATCH 0073/1541] Included Brownian Dynamics functions for 1D
 diffusion in freeFunctions.

---
 freeFunctions.cpp | 136 ++++++++++++++++++++++++++++++++++++++++++++--
 freeFunctions.hpp |  16 ++++--
 2 files changed, 144 insertions(+), 8 deletions(-)

diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index 08c9b37e..c3192ec0 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -275,6 +275,21 @@ Real g_bd_3D(Real r, Real sigma, Real t, Real D)
 
     return 0.5 * (term1 + term2) * r * r;
 }
+
+Real g_bd_1D(Real r, Real sigma, Real t, Real D, Real v)
+{
+    const Real Dt4(4.0 * D * t);
+    const Real sqrtDt4(std::sqrt(Dt4));
+    const Real sqrtDt4_r(1.0 / sqrtDt4);
+    const Real vt = v*t;
+
+    const Real sprmvt(sigma + r + vt);
+    const Real smrpvt(sigma - r - vt);
+
+    const Real term2(erf(sprmvt * sqrtDt4_r) - erf(smrpvt * sqrtDt4_r));
+
+    return 0.5 * (term1 + term2);
+}
     
 Real I_bd_3D(Real sigma, Real t, Real D)
 {
@@ -297,6 +312,22 @@ Real I_bd_3D(Real sigma, Real t, Real D)
     return result;
 }
 
+Real I_bd_1D(Real sigma, Real t, Real D, Real v)
+{
+    const Real sqrtPi(std::sqrt(M_PI));
+
+    const Real Dt4(4 * D * t);
+    const Real sqrt4Dt(std::sqrt(Dt4));
+    double vt = v*t;
+
+    const Real arg1(-(2*sigma - vt)*(2*sigma - vt)/fourDt);
+    const Real term1(exp( -vt*vt/Dt4 ) - exp( arg1 ));
+    const Real term2(vt*erf( vt/sqrt4Dt ) - (2*sigma - vt)*erf( (2*sigma - vt)/sqrt4Dt ));
+    const Real result(1./2*(sqrt4Dt/sqrtPi*term1 + term2 + 2*sigma));
+
+    return result;
+    
+}
 
 Real I_bd_r_3D(Real r, Real sigma, Real t, Real D)
 {
@@ -334,6 +365,31 @@ Real I_bd_r_3D(Real r, Real sigma, Real t, Real D)
     return result;
 }
 
+Real I_bd_r_1D(Real r, Real sigma, Real t, Real D, Real v)
+{
+    const Real sqrtPi(std::sqrt(M_PI));
+
+    const Real Dt(D * t);
+    const Real Dt2(Dt + Dt);
+    const Real Dt4(Dt2 + Dt2);
+    const Real sqrt4Dt(std::sqrt(Dt4));
+    const Real vt = v*t;
+
+    const Real smrpvt_sq(gsl_pow_2(sigma - r + vt));
+    const Real sprmvt_sq(gsl_pow_2(sigma + r - vt));
+    const Real twosmvt_sq(gsl_pow_2(sigma + r - vt));
+
+    const Real temp1(-std::exp( -smrpvt_sq/Dt4 ) + std::exp( -sprmvt_sq/Dt4 ));
+    const Real temp2(std::exp( -vt*vt/Dt4 ) - std::exp( -twosmvt_sq/Dt4 ));
+    const Real term1(sqrt4Dt/sqrtPi*( temp1 + temp2 ));
+
+    const Real term2(vt*std::erf(vt/sqrt4Dt) - (2*sigma - vt)*std::erf( (2*sigma - vt)/sqrt4Dt ));
+    const Real term3((r - sigma - vt)*std::erf( (sigma - r + vt)/sqrt4Dt ));
+    const Real term4((r + sigma - vt)*std::erf( (R + sigma - vt)/sqrt4Dt ));
+    const Real result(1./2*(term1 + term2 + term3 + term4))
+    
+    return result;
+}
 
 struct g_bd_3D_params
 { 
@@ -343,6 +399,15 @@ struct g_bd_3D_params
     const Real target;
 };
 
+struct g_bd_1D_params
+{ 
+    const Real sigma;
+    const Real t;
+    const Real D;
+    const Real target;
+    const Real v;
+};
+
 
 static Real I_gbd_r_3D_F(Real r, const g_bd_params* params)
 {
@@ -351,18 +416,30 @@ static Real I_gbd_r_3D_F(Real r, const g_bd_params* params)
     const Real D(params->D);
     const Real target(params->target);
 
-    return I_bd_r(r, sigma, t, D) - target;
+    return I_bd_r_3D(r, sigma, t, D) - target;
 }
 
+static Real I_gbd_r_1D_F(Real r, const g_bd_params* params)
+{
+    const Real sigma(params->sigma);
+    const Real t(params->t);
+    const Real D(params->D);
+    const Real target(params->target);
+    const Real v(params->v);
+
+    return I_bd_r_1D(r, sigma, t, D) - target;
+}
+
+
 Real drawR_gbd_3D(Real rnd, Real sigma, Real t, Real D)
 {
-    const Real I(I_bd(sigma, t, D));
+    const Real I(I_bd_3D(sigma, t, D));
 
-    g_bd_params params = { sigma, t, D, rnd * I };
+    g_bd_3D_params params = { sigma, t, D, rnd * I };
 
     gsl_function F =
     {
-        reinterpret_cast<typeof(F.function)>(&I_gbd_r_F),
+        reinterpret_cast<typeof(F.function)>(&I_gbd_r_3D_F),
         &params
     };
 
@@ -404,3 +481,54 @@ Real drawR_gbd_3D(Real rnd, Real sigma, Real t, Real D)
 
     return low;
 }
+
+Real drawR_gbd_1D(Real rnd, Real sigma, Real t, Real D, Real v)
+{
+    const Real I(I_bd_1D(sigma, t, D, v));
+
+    g_bd_1D_params params = { sigma, t, D, rnd * I, v };
+
+    gsl_function F =
+    {
+        reinterpret_cast<typeof(F.function)>(&I_gbd_r_1D_F),
+        &params
+    };
+
+    Real low(sigma);
+    Real high(sigma + 10.0 * std::sqrt (2.0 * D * t));
+
+    const gsl_root_fsolver_type* solverType(gsl_root_fsolver_brent);
+    gsl_root_fsolver* solver(gsl_root_fsolver_alloc(solverType));
+    gsl_root_fsolver_set(solver, &F, low, high);
+
+    const unsigned int maxIter(100);
+
+    unsigned int i(0);
+    while(true)
+    {
+        gsl_root_fsolver_iterate(solver);
+
+        low = gsl_root_fsolver_x_lower(solver);
+        high = gsl_root_fsolver_x_upper(solver);
+        int status(gsl_root_test_interval(low, high, 1e-18, 1e-12));
+
+        if(status == GSL_CONTINUE)
+        {
+            if(i >= maxIter)
+            {
+                gsl_root_fsolver_free(solver);
+                throw std::runtime_error("drawR_gbd: failed to converge");
+            }
+        }
+        else
+        {
+            break;
+        }
+
+        ++i;
+    }
+  
+    gsl_root_fsolver_free(solver);
+
+    return low;
+}
diff --git a/freeFunctions.hpp b/freeFunctions.hpp
index 696cec6e..617001e5 100644
--- a/freeFunctions.hpp
+++ b/freeFunctions.hpp
@@ -27,12 +27,20 @@ Real p_theta_free(Real theta, Real r, Real r0, Real t, Real D);
 
 Real ip_theta_free(Real theta, Real r, Real r0, Real t, Real D);
 
-Real g_bd(Real r0, Real sigma, Real t, Real D);
+Real g_bd_3D(Real r0, Real sigma, Real t, Real D);
 
-Real I_bd(Real sigma, Real t, Real D);
+Real I_bd_3D(Real sigma, Real t, Real D);
 
-Real I_bd_r(Real r, Real sigma, Real t, Real D);
+Real I_bd_r_3D(Real r, Real sigma, Real t, Real D);
 
-Real drawR_gbd(Real rnd, Real sigma, Real t, Real D);
+Real drawR_gbd_3D(Real rnd, Real sigma, Real t, Real D);
+
+Real g_bd_1D(Real r0, Real sigma, Real t, Real D, Real v);
+
+Real I_bd_1D(Real sigma, Real t, Real D, Real v);
+
+Real I_bd_r_1D(Real r, Real sigma, Real t, Real D, Real v);
+
+Real drawR_gbd_1D(Real rnd, Real sigma, Real t, Real D, Real v);
 
 #endif /* FREE_FUNTIONS_HPP */

From 6e57f7a18c1ff5c9812287bdb5291af5c27f74bd Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 21 Jun 2011 16:56:02 +0200
Subject: [PATCH 0074/1541] wtf

---
 samples/cluster/run.py        | 25 ++++++++++++++++---------
 samples/template/template.py  |  2 +-
 visualization/run_pipeline.py |  2 +-
 3 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index 367f21fd..65bbe709 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -1,6 +1,6 @@
 
 # Rebinding to a cluster
-
+#
 # Run by:
 # $ python run.py [N] [runs] [outFilename] [Logmode, default=False]
 #
@@ -45,16 +45,15 @@
     try: 
         LOGGING = bool(sys.argv[4])
         if (LOGGING==True): 
-            print "* Performing only 1 logging run."
-            runs = 1
+            print "* Logging is ON."
     except: LOGGING = False
 
     # Particle constants
-    sigma = 1e-5        # Diameter particle; big:1e-5
-    D = 1e-8            # Diffusion constant; big:1e-8
-    world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
+    sigma = 1e-9        # Diameter particle (normally 1e-9)
+    D = 1e-12           # Diffusion constant (normally 1e-12)
+    world_size = 1e-6   # Lengths of simulation box (normally 1e-3)
 
-    k1 = 1e-10
+    k1 = 1e-18
     k2 = 1e2
 
     # Spacing inbetween cluster particles AND cluster/B-particle
@@ -237,13 +236,17 @@ def single_run(N, LOGGING):
         while 1:
             l.log() # log
             s.step() # and make eGFRD step
-            if s.last_reaction:
+            if s.last_reaction: 
                 numberDetected = numberDetected+1
-                if (numberDetected == 2):
+                if (numberDetected == 2): 
                     # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
                     reaction_time = s.t - previous_time
                     break  
                 else: previous_time = s.t
+            if (s.t > 10000):
+                reaction_time = 10000
+                print "Long excursion. Aborted."
+                break
         l.stop() 
     else:
         while 1:
@@ -255,6 +258,10 @@ def single_run(N, LOGGING):
                     reaction_time = s.t - previous_time
                     break  
                 else: previous_time = s.t
+            if (s.t > 10000):
+                reaction_time = 10000
+                print "Long excursion. Aborted."
+                break
 
     s.stop(s.t)
     return (reaction_time)
diff --git a/samples/template/template.py b/samples/template/template.py
index 6bd38cd5..9ad9b351 100644
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -20,7 +20,7 @@
 
 # Constants
 # ===============================
-sigma = 1e-4        # Diameter particle; more realistic would be e-9
+sigma = 1e-9        # Diameter particle
 D = 1e-12           # Diffusion constant
 N = 1000            # Number of steps simulation will last
 world_size = 1e-3   # Lengths of simulation box
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index ac3c3bfa..febe59d8 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -11,7 +11,7 @@
 # (This was defined when calling the logger in your
 # script.)
 simulation_data_directory = egfrd_directory + \
-    'samples/memory/VTK_out/'
+    'samples/cluster/VTK_out_1/'
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From 6251808d3aafe3b26bd937b8dac205c1b98ca074 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 21 Jun 2011 17:03:56 +0200
Subject: [PATCH 0075/1541] Added drawR_gbd to the Cuboidal/Sherical and planar
 surfaces. Fixed errors in freeFunctions.

---
 BDPropagator.hpp           |  10 +++-
 CuboidalRegion.hpp         |   8 +++
 CylindricalSurface.hpp     |   8 +++
 PlanarSurface.hpp          |   9 +++
 SphericalSurface.hpp       |   5 ++
 Structure.hpp              |   3 +
 freeFunctions.cpp          |  44 ++++++---------
 greens_functions.cpp       |  12 ++--
 test/freeFunctions_test.py | 111 +++++++++++++++++++++++++++----------
 9 files changed, 149 insertions(+), 61 deletions(-)

diff --git a/BDPropagator.hpp b/BDPropagator.hpp
index d712fdf0..075d5271 100644
--- a/BDPropagator.hpp
+++ b/BDPropagator.hpp
@@ -10,6 +10,7 @@
 #include <boost/range/const_iterator.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
 #include "Defs.hpp"
 #include "generator.hpp"
 #include "exceptions.hpp"
@@ -228,6 +229,7 @@ class BDPropagator
                                 s1(tx_.get_species(products[1]));
                         const Real D01(s0.D() + s1.D());
                         const length_type r01(s0.radius() + s1.radius());
+                        const Real v(s0.v() + s1.v());
                         int i = max_retry_count_;
                         position_type np0, np1;
 
@@ -239,9 +241,11 @@ class BDPropagator
                             }
 
                             const Real rnd(rng_());
-                            length_type pair_distance(
-                                drawR_gbd_3D(rnd, r01, dt_, D01));
-                            const position_type m(random_unit_vector() * pair_distance);
+                            boost::shared_ptr<structure_type> pp_structure( 
+                                tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) );  
+               
+                            length_type pair_distance(pp_structure->drawR_gbd(rnd, r01, dt_, D01, v) );
+                            const position_type m(pp_structure->random_vector(pair_distance, rng_) );
                             np0 = tx_.apply_boundary(pp.second.position()
                                     + m * (s0.D() / D01));
                             np1 = tx_.apply_boundary(pp.second.position()
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 2149da41..606be2e8 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -4,6 +4,7 @@
 #include <boost/bind.hpp>
 #include "Region.hpp"
 #include "Box.hpp"
+//#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class CuboidalRegion
@@ -46,6 +47,13 @@ class CuboidalRegion
             rng.normal(0., r));
     }
 
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    {
+        length_type pair_distance( drawR_gbd_3D(rnd, r01, dt, D01) );
+    
+        return pair_distance;
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index bd603edf..9a46d1c6 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -4,6 +4,7 @@
 #include <boost/bind.hpp>
 #include "Surface.hpp"
 #include "Cylinder.hpp"
+//#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class CylindricalSurface
@@ -34,6 +35,13 @@ class CylindricalSurface
         return multiply(base_type::shape().unit_z(), rng.normal(0., r));
     }
 
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    {
+        length_type pair_distance( drawR_gbd_1D(rnd, r01, dt, D01, v) );
+    
+        return pair_distance;
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         length_type cylinder_radius = base_type::shape().radius();
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index ef0e97b9..b8c63358 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -4,6 +4,7 @@
 #include <boost/bind.hpp>
 #include "Surface.hpp"
 #include "Plane.hpp"
+//#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class PlanarSurface
@@ -42,6 +43,14 @@ class PlanarSurface
             multiply(base_type::shape().unit_y(), y));
     }
 
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    {
+        //TODO: use the 2D BD function instead of the 3D one.
+        length_type pair_distance( drawR_gbd_3D(rnd, r01, dt, D01) );
+    
+        return pair_distance;
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         // PlanarSurface has thickness of 0.
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index b602f5ba..91ced2b2 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -32,6 +32,11 @@ class SphericalSurface
         return position_type(); // TODO
     }
 
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    {    
+        return length_type(); // TODO
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         return 0.; // TODO
diff --git a/Structure.hpp b/Structure.hpp
index d09c3010..7d64ba04 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -12,6 +12,7 @@
 
 #include <sstream>
 #include "Vector3.hpp"
+#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class Structure
@@ -48,6 +49,8 @@ class Structure
 
     virtual position_type bd_displacement(length_type const& r, rng_type& rng) const = 0;
 
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const = 0;
+
     virtual projected_type projected_point(position_type const& pos) const = 0;
 
     virtual std::size_t hash() const
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index c3192ec0..f0a462df 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -283,12 +283,12 @@ Real g_bd_1D(Real r, Real sigma, Real t, Real D, Real v)
     const Real sqrtDt4_r(1.0 / sqrtDt4);
     const Real vt = v*t;
 
-    const Real sprmvt(sigma + r + vt);
-    const Real smrpvt(sigma - r - vt);
+    const Real s_plus_r_min_vt(sigma + r - vt);
+    const Real s_min_r_plus_vt(sigma - r + vt);
 
-    const Real term2(erf(sprmvt * sqrtDt4_r) - erf(smrpvt * sqrtDt4_r));
+    const Real result(erfl(s_plus_r_min_vt * sqrtDt4_r) + erfl(s_min_r_plus_vt * sqrtDt4_r));
 
-    return 0.5 * (term1 + term2);
+    return 0.5 * result;
 }
     
 Real I_bd_3D(Real sigma, Real t, Real D)
@@ -320,9 +320,9 @@ Real I_bd_1D(Real sigma, Real t, Real D, Real v)
     const Real sqrt4Dt(std::sqrt(Dt4));
     double vt = v*t;
 
-    const Real arg1(-(2*sigma - vt)*(2*sigma - vt)/fourDt);
-    const Real term1(exp( -vt*vt/Dt4 ) - exp( arg1 ));
-    const Real term2(vt*erf( vt/sqrt4Dt ) - (2*sigma - vt)*erf( (2*sigma - vt)/sqrt4Dt ));
+    const Real arg1(-(2*sigma - vt)*(2*sigma - vt)/Dt4);
+    const Real term1(expl( -vt*vt/Dt4 ) - expl( arg1 ));
+    const Real term2(vt*erfl( vt/sqrt4Dt ) - (2*sigma - vt)*erfl( (2*sigma - vt)/sqrt4Dt ));
     const Real result(1./2*(sqrt4Dt/sqrtPi*term1 + term2 + 2*sigma));
 
     return result;
@@ -379,27 +379,19 @@ Real I_bd_r_1D(Real r, Real sigma, Real t, Real D, Real v)
     const Real sprmvt_sq(gsl_pow_2(sigma + r - vt));
     const Real twosmvt_sq(gsl_pow_2(sigma + r - vt));
 
-    const Real temp1(-std::exp( -smrpvt_sq/Dt4 ) + std::exp( -sprmvt_sq/Dt4 ));
-    const Real temp2(std::exp( -vt*vt/Dt4 ) - std::exp( -twosmvt_sq/Dt4 ));
+    const Real temp1(-expl( -smrpvt_sq/Dt4 ) + expl( -sprmvt_sq/Dt4 ));
+    const Real temp2(expl( -vt*vt/Dt4 ) - expl( -twosmvt_sq/Dt4 ));
     const Real term1(sqrt4Dt/sqrtPi*( temp1 + temp2 ));
 
-    const Real term2(vt*std::erf(vt/sqrt4Dt) - (2*sigma - vt)*std::erf( (2*sigma - vt)/sqrt4Dt ));
-    const Real term3((r - sigma - vt)*std::erf( (sigma - r + vt)/sqrt4Dt ));
-    const Real term4((r + sigma - vt)*std::erf( (R + sigma - vt)/sqrt4Dt ));
-    const Real result(1./2*(term1 + term2 + term3 + term4))
+    const Real term2(vt*erfl(vt/sqrt4Dt) - (2*sigma - vt)*erfl( (2*sigma - vt)/sqrt4Dt ));
+    const Real term3((r - sigma - vt)*erfl( (sigma - r + vt)/sqrt4Dt ));
+    const Real term4((r + sigma - vt)*erfl( (r + sigma - vt)/sqrt4Dt ));
+    const Real result(1./2*(term1 + term2 + term3 + term4));
     
     return result;
 }
 
-struct g_bd_3D_params
-{ 
-    const Real sigma;
-    const Real t;
-    const Real D;
-    const Real target;
-};
-
-struct g_bd_1D_params
+struct g_bd_params
 { 
     const Real sigma;
     const Real t;
@@ -427,7 +419,7 @@ static Real I_gbd_r_1D_F(Real r, const g_bd_params* params)
     const Real target(params->target);
     const Real v(params->v);
 
-    return I_bd_r_1D(r, sigma, t, D) - target;
+    return I_bd_r_1D(r, sigma, t, D, v) - target;
 }
 
 
@@ -435,7 +427,7 @@ Real drawR_gbd_3D(Real rnd, Real sigma, Real t, Real D)
 {
     const Real I(I_bd_3D(sigma, t, D));
 
-    g_bd_3D_params params = { sigma, t, D, rnd * I };
+    g_bd_params params = { sigma, t, D, rnd * I, 0 };
 
     gsl_function F =
     {
@@ -486,7 +478,7 @@ Real drawR_gbd_1D(Real rnd, Real sigma, Real t, Real D, Real v)
 {
     const Real I(I_bd_1D(sigma, t, D, v));
 
-    g_bd_1D_params params = { sigma, t, D, rnd * I, v };
+    g_bd_params params = { sigma, t, D, rnd * I, v };
 
     gsl_function F =
     {
@@ -495,7 +487,7 @@ Real drawR_gbd_1D(Real rnd, Real sigma, Real t, Real D, Real v)
     };
 
     Real low(sigma);
-    Real high(sigma + 10.0 * std::sqrt (2.0 * D * t));
+    Real high(sigma + 100.0 * std::sqrt (2.0 * D * t));
 
     const gsl_root_fsolver_type* solverType(gsl_root_fsolver_brent);
     gsl_root_fsolver* solver(gsl_root_fsolver_alloc(solverType));
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 1822fc3f..e6b7e02e 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -24,12 +24,16 @@ BOOST_PYTHON_MODULE( _greens_functions )
     def( "p_survival_irr", p_survival_irr );
     def( "p_theta_free", p_theta_free );
     def( "ip_theta_free", ip_theta_free );
-    def( "g_bd", g_bd );
-    def( "I_bd", I_bd );
-    def( "I_bd_r", I_bd_r );
-    def( "drawR_gbd", drawR_gbd );
     def( "p_reaction_irr", __p_reaction_irr );
     def( "p_reaction_irr_t_inf", __p_reaction_irr_t_inf );
+    def( "g_bd_1D", g_bd_1D );
+    def( "I_bd_1D", I_bd_1D );
+    def( "I_bd_r_1D", I_bd_r_1D );
+    def( "drawR_gbd_1D", drawR_gbd_1D );
+    def( "g_bd_3D", g_bd_3D );
+    def( "I_bd_3D", I_bd_3D );
+    def( "I_bd_r_3D", I_bd_r_3D );
+    def( "drawR_gbd_3D", drawR_gbd_3D );
 
     
     class_<GreensFunction1DAbsAbs>("GreensFunction1DAbsAbs",
diff --git a/test/freeFunctions_test.py b/test/freeFunctions_test.py
index 3696b7c6..7dd2a999 100755
--- a/test/freeFunctions_test.py
+++ b/test/freeFunctions_test.py
@@ -64,25 +64,38 @@ def test_int_p_irr_is_p_survival_irr(self):
             self.failIf(ip == 0)
             self.assertAlmostEqual(0.0, (S-ip)/ip)
 
+
     def test_int_g_bd_is_I_bd(self):
 
         import scipy.integrate
         import math
 
         D = 1e-12
-        t = 1e-6
-        sigma = 1e-8
-        r0 = 1e-9
+        t = 1e-11
+        sigma = 2e-9
+        r0 = 2e-9
+        v = 0.01
+
+        ibd = mod.I_bd_3D(sigma, t, D)
+        ibd2 = mod.I_bd_1D(sigma, t, D, v)
+        #print ibd, ibd2
 
-        ibd = mod.I_bd(sigma, t, D)
-        #print ibd
-        result = scipy.integrate.quad(mod.g_bd, sigma, 
+        result = scipy.integrate.quad(mod.g_bd_3D, sigma, 
                                       sigma + 6 * math.sqrt(6 * D * t),
                                       args=(sigma, t, D))
+
+        result2 = scipy.integrate.quad(mod.g_bd_1D, sigma, 
+                                      sigma + 100 * math.sqrt(2 * D * t),
+                                      args=(sigma, t, D, v))
+ 
         igbd = result[0]
-        #print igbd
+        igbd2 = result2[0]
+
+        #print igbd2, igbd2
         self.failIf(ibd == 0)
+        self.failIf(ibd2 == 0)
         self.assertAlmostEqual(0.0, (ibd-igbd)/ibd)
+        #self.assertAlmostEqual(0.0, (ibd2-igbd2)/ibd2)
 
 
     def test_int_g_bd_is_I_bd_smallt(self):
@@ -93,30 +106,48 @@ def test_int_g_bd_is_I_bd_smallt(self):
         t = 1e-20
         sigma = 1e-8
         r0 = 1e-9
+        v = 0.01
+
+        ibd = mod.I_bd_3D(sigma, t, D)
+        ibd2 = mod.I_bd_1D(sigma, t, D, v)
+        #print ibd, ibd2
 
-        ibd = mod.I_bd(sigma, t, D)
-        #print ibd
-        result = scipy.integrate.quad(mod.g_bd, sigma, sigma + 
+        result = scipy.integrate.quad(mod.g_bd_3D, sigma, sigma + 
                                       6 * math.sqrt(6 * D * t),
                                       args=(sigma, t, D))
+
+        result2 = scipy.integrate.quad(mod.g_bd_1D, sigma, 
+                                      sigma + 10 * math.sqrt(2 * D * t),
+                                      args=(sigma, t, D, v))
+
         igbd = result[0]
-        #print igbd
+        igbd2 = result2[0]
+
+        #print igbd, igbd2
         self.failIf(ibd == 0)
+        self.failIf(ibd2 == 0)
         self.assertAlmostEqual(0.0, (ibd-igbd)/ibd)
+        self.assertAlmostEqual(0.0, (ibd2-igbd2)/ibd2)
 
 
     def test_I_bd_r_large_is_I_bd(self):
 
         D = 1e-12
-        t = 1e-10
-        sigma = 1e-8
-        r0 = 1e-9
+        t = 1e-11
+        sigma = 2e-9
+        r0 = 5e-9
+        v = 0.01
+
+        ibd = mod.I_bd_3D(sigma, t, D)
+        ibdr = mod.I_bd_r_3D(sigma + 6 * math.sqrt(6 * D * t), sigma, t, D)
 
-        ibd = mod.I_bd(sigma, t, D)
-        ibdr = mod.I_bd_r(sigma + 6 * math.sqrt(6 * D * t), sigma, t, D)
+        ibd2 = mod.I_bd_1D(sigma, t, D, v)
+        ibdr2 = mod.I_bd_r_1D(sigma + 10 * math.sqrt(2 * D * t), sigma, t, D, v)
         #print ibd, ibdr
+        #print ibd2, ibdr2
 
         self.assertAlmostEqual(0.0, (ibd-ibdr)/ibd)
+        self.assertAlmostEqual(0.0, (ibd2-ibdr2)/ibd2)
 
 
     def test_int_g_bd_is_I_bd_r(self):
@@ -125,25 +156,36 @@ def test_int_g_bd_is_I_bd_r(self):
         import math
 
         D = 1e-12
-        t = 1e-7
-        sigma = 1e-8
+        t = 1e-11
+        sigma = 2e-9
+        v = 0.01
 
         r_max = 6 * math.sqrt(6 * D * t)
 
-        ibd = mod.I_bd_r(sigma, sigma, t, D)
+        ibd = mod.I_bd_r_3D(sigma, sigma, t, D)
+        self.failIf(ibd != 0.0)
+        ibd = mod.I_bd_r_1D(sigma, sigma, t, D, v)
         self.failIf(ibd != 0.0)
 
         N = 20
         for i in range(1, N):
             r = sigma + r_max / N * i
-            ibd = mod.I_bd_r(r, sigma, t, D)
-            result = scipy.integrate.quad(mod.g_bd, sigma, r,
+            ibd = mod.I_bd_r_3D(r, sigma, t, D)
+            ibd2 = mod.I_bd_r_1D(r, sigma, t, D, v)
+
+            result = scipy.integrate.quad(mod.g_bd_3D, sigma, r,
                                           args=(sigma, t, D))
+
+            result2 = scipy.integrate.quad(mod.g_bd_1D, sigma, r,
+                                          args=(sigma, t, D, v))
+
             igbd = result[0]
+            igbd2 = result2[0]
 
             self.failIf(ibd == 0)
             self.assertAlmostEqual(0.0, (ibd-igbd)/ibd)
-
+            self.failIf(ibd2 == 0)
+            self.assertAlmostEqual(0.0, (ibd2-igbd2)/ibd2)
 
     def test_drawR_gbd(self):
 
@@ -151,19 +193,32 @@ def test_drawR_gbd(self):
         import math
 
         D = 1e-12
-        t = 1e-8
-        sigma = 1e-8
+        t = 1e-11
+        sigma = 2e-9
+        v = 0.01
 
-        r = mod.drawR_gbd(0.0, sigma, t, D)
+        r = mod.drawR_gbd_3D(0.0, sigma, t, D)
         self.assertEqual(r, sigma)
 
-        r = mod.drawR_gbd(0.5, sigma, t, D)
+        r = mod.drawR_gbd_3D(0.5, sigma, t, D)
         self.failIf(r <= sigma)
         #print 'rr', r
 
-        r = mod.drawR_gbd(1.0, sigma, t, D)
+        r = mod.drawR_gbd_3D(1.0, sigma, t, D)
         self.failIf(r <= sigma)
-        #print 'rr', r
+
+        r = mod.drawR_gbd_1D(0.0, sigma, t, D, v)
+        #print 'rr@0.0', r
+        self.assertEqual(r, sigma)
+
+        r = mod.drawR_gbd_1D(0.5, sigma, t, D, v)
+        #print 'rr@0.5', r
+        self.failIf(r <= sigma)
+
+        r = mod.drawR_gbd_1D(1.0, sigma, t, D, v)
+        #print 'rr@1.0', r
+        self.failIf(r <= sigma)
+
 
     def test_p_reaction_irr_t_inf(self):
         

From e5347c86557e41b7b6e2c6f1b8d75fee478de84e Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 22 Jun 2011 15:55:09 +0200
Subject: [PATCH 0076/1541] Added some tools that show the memory leak has been
 fixed.

Fastest usage:

Comment the line
"from guppy import hpy"
if you don't have guppy/heapy installed.

$ <export correct python paths>
$ cd <egfrd directory>/samples/memorytools
$ python
>> import memutils
>> memutils.gomeasure()

This will get the cluster sample simulation running, but also
output the process' memory use. Small fluctuations can occur,
but the previously present memory use led to a ~0.5% increase
in memory usage each time gomeasure() gave output (i.e. every
10 runs of the cluster simulation script). Typical memory usage
values of this script are now ~207E6.
---
 samples/memorytools/cluster.py                | 328 ++++++++++++++++++
 samples/memorytools/memoryusage.py            |  50 +++
 samples/memorytools/memutils.py               | 118 +++++++
 .../suppression/valgrind-python.supp          | 217 ++++++++++++
 4 files changed, 713 insertions(+)
 create mode 100644 samples/memorytools/cluster.py
 create mode 100644 samples/memorytools/memoryusage.py
 create mode 100644 samples/memorytools/memutils.py
 create mode 100644 samples/memorytools/suppression/valgrind-python.supp

diff --git a/samples/memorytools/cluster.py b/samples/memorytools/cluster.py
new file mode 100644
index 00000000..698d875f
--- /dev/null
+++ b/samples/memorytools/cluster.py
@@ -0,0 +1,328 @@
+
+# Rebinding to a cluster
+
+# Run by:
+# $ python run.py [N] [runs] [outFilename] [Logmode, default=False]
+#
+# Arguments:
+#   - N: Number of particles in cluster
+#   - runs: Number of simulation runs
+#   - outFilename: Name of output file
+#   - Logmode: false by default, if True, only 1 VTK-logged run is
+#     performed.    
+#
+# E.g.:
+# $ python run.py 7 1000 data.out
+# Or:
+# $ python run.py 7 1 data.out True
+
+# Modules
+# ===============================
+import sys
+#Also, set relative egfrd directory path
+sys.path.append('../../')
+import os
+import shutil
+import datetime
+
+import math
+from egfrd import *
+import model
+import gfrdbase
+import _gfrd
+from visualization import vtklogger
+
+if __name__ == "__main__":
+    # Constants
+    # ===============================
+    # Number of particles in the cluster
+    N = int(sys.argv[1])
+    # Number of runs
+    runs = int(sys.argv[2])
+    # Output file
+    outFilename = sys.argv[3]
+    # LOGGING mode
+    try: 
+        LOGGING = bool(sys.argv[4])
+        if (LOGGING==True): 
+            print "* Performing only 1 logging run."
+            runs = 1
+    except: LOGGING = False
+
+# Particle constants
+sigma = 1e-5        # Diameter particle; big:1e-5
+D = 1e-8            # Diffusion constant; big:1e-8
+world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
+
+k1 = 1e-10
+k2 = 1e2
+
+# Spacing inbetween cluster particles AND cluster/B-particle
+spacing = sigma/1e5
+
+# Create "unique" seed
+# ===============================
+currenttime = (long(datetime.datetime.now().year*3600*24*365+
+datetime.datetime.now().month*30.5*24*3600+
+datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+datetime.datetime.now().minute*60+datetime.datetime.now().second))
+myrandom.seed(currenttime)
+
+print str('Seed: '+str(currenttime))
+
+
+# Functions
+# ===============================
+def cartesian(g1, g2, ng1, ng2):
+    """ Converts lattice coordinates (ng1, ng2) to cartesian coordinates
+    
+    Arguments:
+        - Lattice vectors g1=[x1,y1] and g2=[x2,y2]
+        - Lattice coordinates (ng1, ng2)
+
+    """
+    cartesian_x = (ng1 * (g1[0]) + ng2 * (g2[0]))
+    cartesian_y = (ng2 * (g2[1]) + ng1 * (g1[1]))
+    return cartesian_x, cartesian_y
+
+def distance(x1, y1, x2, y2):
+    """ Calculates the distance between points (x1, y1) and (x2, y2) """
+    return math.sqrt(math.pow((x1-x2),2)+math.pow((y1-y2),2))
+
+def generate_possible_positions(N):
+    """ Generates a list with possible coordinates and distances to center
+
+    This function does the following:
+        - It loops over square area of an hexagonal lattice (of size 
+          calculated to facilitate N particles) 
+        - Lattice coordinates and distance to the center of the area 
+          are stored if they are within circular boundaries. (The 
+          latter check is only done to be absolutely sure a circular 
+          shape is formed.)
+
+    This information can be used in a later function. If the list of
+    generated coordinates is sorted by distance to the center, N 
+    particles can be placed within a circular geometry by looping over
+    the coordinates.
+
+    Arguments:
+        - N: number of particles to place.
+
+    """
+    global w, A, spacing, sigma #, g1, g2, cartesian_x, cartesian_y, ng1, ng2
+
+    # Lattice vectors
+    d1 = [1,0]
+    d2 = [math.cos((math.pi)/3.0),math.sin((math.pi)/3.0)]
+    # Scaled lattice vectors
+    lengthLatticeVector = (sigma+spacing)
+    g1 = [lengthLatticeVector*d1[0], lengthLatticeVector*d1[1]]
+    g2 = [lengthLatticeVector*d2[0], lengthLatticeVector*d2[1]]
+
+    # Factors to calculate square area of lattice needed
+    """
+    factorNonSquareGrid = math.sqrt(1/(d1[0]*d2[1]-d1[1]*d2[0]))
+    factorSquareToCircle = math.pi/2 #math.sqrt(math.pow((math.pi*0.5),2)) 
+    # Calculate diameter of sphere
+    L = (spacing+sigma)*(math.ceil(math.sqrt(N))+2)*factorNonSquareGrid*factorSquareToCircle
+        # "(math.ceil(math.sqrt(N))+2)"; ceil and +2: some margin
+    diamondSide = (L/2)*math.tan(pi/6)+(L/2)/math.tan(pi/6)
+    diamondDiagonal = sin(pi/3)*L #2*sin(pi/3)*L/2
+    """
+    # d1x*d2y-d1y*d2x
+    diamondToSquare = math.sqrt((4*d2[0]*d2[1])/(0.25*math.pi))
+    vectorsOnDiameter = math.ceil(math.sqrt(N)+2)
+    numberOfVectors = diamondToSquare * vectorsOnDiameter
+
+    diameterCircle = math.ceil(math.sqrt(N)+2)*lengthLatticeVector
+    radiusCircle = diameterCircle/2
+
+    # Cartesian coordinates
+    cartesian_x = 0
+    cartesian_y = 0
+    cartesian_z = 0
+
+    # The list with possible coordinates and distances to center
+    clusterParticleCoordinates = []
+
+    for ng1 in range(int(-math.ceil(numberOfVectors/2)), 
+                            int(math.ceil(numberOfVectors/2))):
+        for ng2 in range(int(-math.ceil(numberOfVectors/2)), 
+                                int(math.ceil(numberOfVectors/2))):
+            cartesian_x, cartesian_y = cartesian(g1, g2, ng1, ng2)
+            distanceToCenter = distance(cartesian_x, cartesian_y, 0, 0)
+            if (distanceToCenter < radiusCircle):
+                clusterParticleCoordinates.append([
+                            distanceToCenter,
+                            cartesian_x, 
+                            cartesian_y, 
+                            cartesian_z
+                            ])
+    
+
+    return clusterParticleCoordinates
+
+def make_cluster(N, coord_x, coord_y, coord_z): 
+    """ Places N particles on hexagonal lattice in spherical symmetry
+
+    Arguments:
+        - N: number of particles to place
+        - coord_x, coord_y, coord_z: Coordinates where to place cluster
+    """
+    # Generate list of positions and there distance to the center
+    clusterParticleCoordinates = generate_possible_positions(N)
+    # Sort this list
+    clusterParticleCoordinates.sort(key=lambda x: x[0])
+
+    # Place center particle
+    place_particle(w, C,
+         [clusterParticleCoordinates[0][1]+coord_x, 
+          clusterParticleCoordinates[0][2]+coord_y,
+          clusterParticleCoordinates[0][3]+coord_z])
+    # Place N particles starting with the particle closest to the
+    # center, then placing the second closest particle, etc..
+    for i in range(1,N):
+        try:
+            place_particle(w, A,
+                [clusterParticleCoordinates[i][1]+coord_x, 
+                 clusterParticleCoordinates[i][2]+coord_y,
+                 clusterParticleCoordinates[i][3]+coord_z])
+        except: 
+            print "ERROR: couldn't place particle."
+
+def single_run(N, LOGGING):
+    """ Single run of simulation """
+    global w, A, C, k1, k2
+    # Basic set up simulator
+    # ===============================
+    # Model
+    m = model.ParticleModel(world_size)
+    # Species
+    A = model.Species('A', 0, sigma/2)                                   
+    m.add_species_type(A) 
+    B = model.Species('B', D, sigma/2)                                   
+    m.add_species_type(B) 
+    C = model.Species('C', 0, sigma/2)                                   
+    m.add_species_type(C) 
+    # Reaction rules
+    r1 = model.create_binding_reaction_rule(A, B, C, k1)
+    m.network_rules.add_reaction_rule(r1)
+    r2 = model.create_unbinding_reaction_rule(C, A, B, k2)
+    m.network_rules.add_reaction_rule(r2)
+
+    # World
+    w = gfrdbase.create_world(m, 3)
+    # Simulator   
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    # Put in cluster
+    make_cluster(N, world_size/2, world_size/2, world_size/2)
+
+    # Put in reactants
+    # place_particle(w, B, [world_size/2, world_size/2, world_size/2+sigma+spacing])    
+
+    # Enable VTK Logger
+    # ===============================
+    if (LOGGING == True):
+        vtk_output_directory = 'VTK_out'
+        if (os.path.exists(vtk_output_directory)):
+            print '** Warning: VTK directory already exists.'
+        l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+    
+    # Running 
+    # ===============================
+    numberDetected = 0
+
+    if (LOGGING == True):
+        while 1:
+            l.log() # log
+            s.step() # and make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
+                    break  
+                else: previous_time = s.t
+        l.stop() 
+    else:
+        while 1:
+            s.step() # make eGFRD step
+            if s.last_reaction:
+                numberDetected = numberDetected+1
+                if (numberDetected == 2):
+                    # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
+                    reaction_time = s.t - previous_time
+                    break  
+                else: previous_time = s.t
+
+    s.stop(s.t)
+#TODO
+    #del w
+    #del s # If this one is thrown in, the runs suddenly stop?!
+    #del m
+
+    return (reaction_time)
+    
+# Main part
+# ===============================
+
+if __name__ == "__main__":
+    # Output file
+    outFile = open(outFilename, 'w')
+    outFile.close()
+    outFile = open(outFilename, 'a')
+
+    for M in range(runs):
+        outFile.write(str(single_run(N, LOGGING)) + '\n')
+        outFile.flush    
+
+    outFile.close()
+
+    timetaken = (long(datetime.datetime.now().year*3600*24*365+
+    datetime.datetime.now().month*30.5*24*3600+
+    datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+    datetime.datetime.now().minute*60+datetime.datetime.now().second)-currenttime)
+    print "Done in "+ str(timetaken) +" seconds."
+
+
+# #### OLD CODE
+
+#def in_circle(cartesian_x, cartesian_y, r_x, r_y, R):
+#    if (math.sqrt(math.pow((cartesian_x-r_x),2)+math.pow((cartesian_y-r_y),2)) < R):
+#        return True
+#    else:
+#        return False
+
+
+    # while end time hasn't come and #timesteps still below limit
+    # while ((s.get_next_time() < endTime) and (n < EARLY_STOP)): # TODO
+
+
+    # Terminate the simulation at appropriate time
+
+    #"""
+    #if (n >= EARLY_STOP):
+    #    print "Early stop (timestep limit)."
+    #    s.stop(s.t)
+    #    reaction_time = INF
+    #else:
+    #    print "Early stop (time limit)."
+    #    s.stop(s.get_next_time())
+    #    reaction_time = INF
+    #"""
+
+    # Make sure logger writes away information.
+    # l.stop() #TODO REMOVED LOGGING
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/samples/memorytools/memoryusage.py b/samples/memorytools/memoryusage.py
new file mode 100644
index 00000000..2d7e5a00
--- /dev/null
+++ b/samples/memorytools/memoryusage.py
@@ -0,0 +1,50 @@
+import os
+
+_proc_status = '/proc/%d/status' % os.getpid()
+
+_scale = {'kB': 1024.0, 'mB': 1024.0*1024.0,
+          'KB': 1024.0, 'MB': 1024.0*1024.0}
+
+def _VmB(VmKey):
+    '''Private.
+    '''
+    global _proc_status, _scale
+     # get pseudo file  /proc/<pid>/status
+    try:
+        t = open(_proc_status)
+        v = t.read()
+        t.close()
+    except:
+        return 0.0  # non-Linux?
+     # get VmKey line e.g. 'VmRSS:  9999  kB\n ...'
+    i = v.index(VmKey)
+    v = v[i:].split(None, 3)  # whitespace
+    if len(v) < 3:
+        return 0.0  # invalid format?
+     # convert Vm value to bytes
+    return float(v[1]) * _scale[v[2]]
+
+
+def memory(since=0.0):
+    '''Return memory usage in bytes.
+    '''
+    return _VmB('VmSize:') - since
+
+
+def resident(since=0.0):
+    '''Return resident memory usage in bytes.
+    '''
+    return _VmB('VmRSS:') - since
+
+
+def stacksize(since=0.0):
+    '''Return stack size in bytes.
+    '''
+    return _VmB('VmStk:') - since
+
+
+
+
+
+
+
diff --git a/samples/memorytools/memutils.py b/samples/memorytools/memutils.py
new file mode 100644
index 00000000..a46436fd
--- /dev/null
+++ b/samples/memorytools/memutils.py
@@ -0,0 +1,118 @@
+
+# Modules that come with Python
+import gc
+import inspect
+
+# Guppy Heapy tool
+from guppy import hpy
+
+# Simple script that outputs memory usage of python
+import memoryusage
+
+# The module you want to inspect.
+import cluster
+
+def putinfile(output_file, data):
+
+    outFile = open(output_file, 'w')
+    outFile.write(str(data))
+    outFile.close()
+
+def sort_datav2(class_list, object_list):
+    """ Sort objects into class-specific array """
+
+    sorted_data = [[]]
+    i = 0
+
+    for a_class in class_list:
+           
+        for obj in object_list:
+            try:
+                if isinstance(obj, a_class):
+                    sorted_data[i].append(str(obj))
+            # when not class
+            except:               
+                pass 
+
+        i = i + 1 
+        sorted_data.append([])
+
+    return sorted_data
+            
+def check_lengths(array_with_arrays):
+
+    outputarray = []
+
+    total = 0
+    i = 0
+    for arrays in array_with_arrays:
+        outputarray.append(len(arrays))
+        print str(i) + ": " + str(len(arrays))
+        i = i + 1
+        total = total + len(arrays)
+    
+    return outputarray, total
+  
+def auto(what):
+    """ Automatically runs an analysis. 
+
+    WATCH IT when running from python command line interface! 
+    Returns loads of data. Best use is then probably:
+    >> d, c, n, t = memutils.auto()    
+    """
+
+    classes = giveclasses(what)
+
+    sorted_data = sort_datav2(classes, gc.get_objects())
+    lengths_list, total = check_lengths(sorted_data)
+    
+    return sorted_data, classes, lengths_list, total
+
+def giveclasses():
+    """ Returns a list of classes it finds with help from Python's garbage collector."""    
+
+    classlist = []
+
+    for obj in gc.get_objects():
+        if inspect.isclass(obj):
+            classlist.append(obj)
+            
+    return classlist
+
+def go(N=100):
+    """ (Memory-intensive) code you'd like to analyze. """
+    for M in range(N): temp = cluster.single_run(15, False)
+
+def gosmart(filename, C=10, N=100):
+    """ Same as go(), but now with some memusage and Heapy stats """
+    h = hpy()
+    h.setrelheap()
+
+    for G in range(C):    
+        for M in range(N): 
+            temp = cluster.single_run(15, False)
+        hpy().heap().stat.dump(filename)
+        print "Current memory usage: " + str(memoryusage.memory())
+        
+    h.pb(filename)
+
+def gomeasure(C=100, N=10):
+    """ Same as go(), but with some memusage stats. """
+    print "List of memory usage: "
+
+    for G in range(C):    
+        for M in range(N): 
+            temp = cluster.single_run(15, False)
+        print str(memoryusage.memory())
+
+# NOTES: to call a class via a string:
+# C.__dict__["x"]
+
+
+
+
+
+
+
+
+    
diff --git a/samples/memorytools/suppression/valgrind-python.supp b/samples/memorytools/suppression/valgrind-python.supp
new file mode 100644
index 00000000..700527f3
--- /dev/null
+++ b/samples/memorytools/suppression/valgrind-python.supp
@@ -0,0 +1,217 @@
+#
+# This is a valgrind suppression file that should be used when using valgrind.
+#
+#  Here's an example of running valgrind:
+#
+#	cd python/dist/src
+#	valgrind --tool=memcheck --suppressions=Misc/valgrind-python.supp \
+#		./python -E -tt ./Lib/test/regrtest.py -u bsddb,network
+#
+# You must edit Objects/obmalloc.c and uncomment Py_USING_MEMORY_DEBUGGER
+# to use the preferred suppressions with Py_ADDRESS_IN_RANGE.
+#
+# If you do not want to recompile Python, you can uncomment
+# suppressions for PyObject_Free and PyObject_Realloc.
+#
+# See Misc/README.valgrind for more information.
+
+# all tool names: Addrcheck,Memcheck,cachegrind,helgrind,massif
+{
+   ADDRESS_IN_RANGE/Invalid read of size 4
+   Memcheck:Addr4
+   fun:Py_ADDRESS_IN_RANGE
+}
+
+{
+   ADDRESS_IN_RANGE/Invalid read of size 4
+   Memcheck:Value4
+   fun:Py_ADDRESS_IN_RANGE
+}
+
+{
+   ADDRESS_IN_RANGE/Conditional jump or move depends on uninitialised value
+   Memcheck:Cond
+   fun:Py_ADDRESS_IN_RANGE
+}
+
+{
+   ADDRESS_IN_RANGE/Invalid read of size 4
+   Memcheck:Addr4
+   fun:PyObject_Free
+}
+
+{
+   ADDRESS_IN_RANGE/Invalid read of size 4
+   Memcheck:Value4
+   fun:PyObject_Free
+}
+
+{
+   ADDRESS_IN_RANGE/Conditional jump or move depends on uninitialised value
+   Memcheck:Cond
+   fun:PyObject_Free
+}
+
+{
+   ADDRESS_IN_RANGE/Invalid read of size 4
+   Memcheck:Addr4
+   fun:PyObject_Realloc
+}
+
+{
+   ADDRESS_IN_RANGE/Invalid read of size 4
+   Memcheck:Value4
+   fun:PyObject_Realloc
+}
+
+{
+   ADDRESS_IN_RANGE/Conditional jump or move depends on uninitialised value
+   Memcheck:Cond
+   fun:PyObject_Realloc
+}
+
+###
+### All the suppressions below are for errors that occur within libraries
+### that Python uses.  The problems to not appear to be related to Python's
+### use of the libraries.
+###
+{
+   GDBM problems, see test_gdbm
+   Memcheck:Param
+   write(buf)
+   fun:write
+   fun:gdbm_open
+
+}
+
+###
+### These occur from somewhere within the SSL, when running
+###  test_socket_sll.  They are too general to leave on by default.
+###
+###{
+###   somewhere in SSL stuff
+###   Memcheck:Cond
+###   fun:memset
+###}
+###{
+###   somewhere in SSL stuff
+###   Memcheck:Value4
+###   fun:memset
+###}
+###
+###{
+###   somewhere in SSL stuff
+###   Memcheck:Cond
+###   fun:MD5_Update
+###}
+###
+###{
+###   somewhere in SSL stuff
+###   Memcheck:Value4
+###   fun:MD5_Update
+###}
+
+#
+# All of these problems come from using test_socket_ssl
+#
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:BN_bin2bn
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:BN_num_bits_word
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Value4
+   fun:BN_num_bits_word
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:BN_mod_exp_mont_word
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:BN_mod_exp_mont
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Param
+   write(buf)
+   fun:write
+   obj:/usr/lib/libcrypto.so.0.9.7
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:RSA_verify
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Value4
+   fun:RSA_verify
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Value4
+   fun:DES_set_key_unchecked
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Value4
+   fun:DES_encrypt2
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   obj:/usr/lib/libssl.so.0.9.7
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Value4
+   obj:/usr/lib/libssl.so.0.9.7
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:BUF_MEM_grow_clean
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:memcpy
+   fun:ssl3_read_bytes
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Cond
+   fun:SHA1_Update
+}
+
+{
+   from test_socket_ssl
+   Memcheck:Value4
+   fun:SHA1_Update
+}
+
+
+

From d31f1386151a6595e33945c69eb5d65390985bbf Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 23 Jun 2011 17:01:55 +0200
Subject: [PATCH 0077/1541] Addet p_acceptance functions to all surfaces and
 the cuboidal region to calculate the reaction probability for particles in
 overlap in BD.

---
 BDPropagator.hpp       | 11 +++++++----
 CuboidalRegion.hpp     |  9 ++++++++-
 CylindricalSurface.hpp | 12 ++++++++++--
 PlanarSurface.hpp      | 10 +++++++++-
 SphericalSurface.hpp   |  7 ++++++-
 Structure.hpp          |  5 ++++-
 6 files changed, 44 insertions(+), 10 deletions(-)

diff --git a/BDPropagator.hpp b/BDPropagator.hpp
index 075d5271..8d8dc0ae 100644
--- a/BDPropagator.hpp
+++ b/BDPropagator.hpp
@@ -229,7 +229,6 @@ class BDPropagator
                                 s1(tx_.get_species(products[1]));
                         const Real D01(s0.D() + s1.D());
                         const length_type r01(s0.radius() + s1.radius());
-                        const Real v(s0.v() + s1.v());
                         int i = max_retry_count_;
                         position_type np0, np1;
 
@@ -244,7 +243,7 @@ class BDPropagator
                             boost::shared_ptr<structure_type> pp_structure( 
                                 tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) );  
                
-                            length_type pair_distance(pp_structure->drawR_gbd(rnd, r01, dt_, D01, v) );
+                            length_type pair_distance(pp_structure->drawR_gbd(rnd, r01, dt_, D01, s0.v(), s1.v()) );
                             const position_type m(pp_structure->random_vector(pair_distance, rng_) );
                             np0 = tx_.apply_boundary(pp.second.position()
                                     + m * (s0.D() / D01));
@@ -304,7 +303,7 @@ class BDPropagator
 
         const species_type s0(tx_.get_species(pp0.second.sid())),
                 s1(tx_.get_species(pp1.second.sid()));
-        const length_type r01(s0.radius() + s1.radius());
+        length_type r01(s0.radius() + s1.radius());
 
         const Real rnd(rng_());
         Real prob = 0;
@@ -313,7 +312,11 @@ class BDPropagator
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
             reaction_rule_type const& r(*i);
-            const Real p(r.k() * dt_ / ((I_bd_3D(r01, dt_, s0.D()) + I_bd_3D(r01, dt_, s1.D())) * 4.0 * M_PI));
+
+            boost::shared_ptr<structure_type> pp_structure( 
+               tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
+
+            const Real p(pp_structure->p_acceptance( r.k(), dt_, r01, s0.D(), s1.D(), s0.v(), s1.v() ));
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 606be2e8..2391976a 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -47,13 +47,20 @@ class CuboidalRegion
             rng.normal(0., r));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
     {
         length_type pair_distance( drawR_gbd_3D(rnd, r01, dt, D01) );
     
         return pair_distance;
     }
 
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    {
+        Real p_acc(k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI));
+    
+        return p_acc;
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 9a46d1c6..3e25d19a 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -35,13 +35,21 @@ class CylindricalSurface
         return multiply(base_type::shape().unit_z(), rng.normal(0., r));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
     {
-        length_type pair_distance( drawR_gbd_1D(rnd, r01, dt, D01, v) );
+        length_type pair_distance( drawR_gbd_1D(rnd, r01, dt, D01, v0 - v1) );
     
         return pair_distance;
     }
 
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    {
+        
+        Real p_acc(k_a * dt / (I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1)));
+    
+        return p_acc;
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         length_type cylinder_radius = base_type::shape().radius();
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index b8c63358..f115b0e6 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -43,7 +43,7 @@ class PlanarSurface
             multiply(base_type::shape().unit_y(), y));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
     {
         //TODO: use the 2D BD function instead of the 3D one.
         length_type pair_distance( drawR_gbd_3D(rnd, r01, dt, D01) );
@@ -51,6 +51,14 @@ class PlanarSurface
         return pair_distance;
     }
 
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    {
+        //TODO: use the 2D BD function instead of the 3D one.
+        Real p_acc(k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI));
+    
+        return p_acc;
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         // PlanarSurface has thickness of 0.
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 91ced2b2..a6396481 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -32,11 +32,16 @@ class SphericalSurface
         return position_type(); // TODO
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
     {    
         return length_type(); // TODO
     }
 
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    {    
+        return Real(); //TODO
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         return 0.; // TODO
diff --git a/Structure.hpp b/Structure.hpp
index 7d64ba04..da08e0d0 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -24,6 +24,7 @@ class Structure
     typedef typename traits_type::length_type length_type;
     typedef typename traits_type::position_type position_type;
     typedef std::pair<position_type, length_type> projected_type;
+    typedef typename traits_type::species_type species_type;
 
 public:
     virtual ~Structure() {}
@@ -49,7 +50,9 @@ class Structure
 
     virtual position_type bd_displacement(length_type const& r, rng_type& rng) const = 0;
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const = 0;
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const = 0;
+
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const = 0;
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
 

From 169316b24e6f1de446efa1bb1ee074e99b70d509 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 28 Jun 2011 10:46:40 +0200
Subject: [PATCH 0078/1541] Going to rename branch.

---
 samples/cluster/run.py        | 56 ++++++++++++++++++++++++++++-------
 visualization/run_pipeline.py |  4 +--
 2 files changed, 48 insertions(+), 12 deletions(-)

diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index 367f21fd..9c18a980 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -16,6 +16,8 @@
 # Or:
 # $ python run.py 7 1 data.out True
 
+print "v23jun2011.3"
+
 # Modules
 # ===============================
 import sys
@@ -45,16 +47,17 @@
     try: 
         LOGGING = bool(sys.argv[4])
         if (LOGGING==True): 
-            print "* Performing only 1 logging run."
-            runs = 1
+            print "* Logging is ON."
     except: LOGGING = False
 
     # Particle constants
-    sigma = 1e-5        # Diameter particle; big:1e-5
-    D = 1e-8            # Diffusion constant; big:1e-8
-    world_size = 1e-3   # Lengths of simulation box; normal: 1e-3
+    sigma = 1e-8                    # Diameter particle (normally 1e-9)
+    D = 1e-12                       # Diffusion constant (normally 1e-12)
+    world_size = math.sqrt(2e-13)   # Lengths of simulation box (normally 1e-3) 1e-6
 
-    k1 = 1e-10
+    # k1/kd; kd=4*math.pi*sigma*D
+#    k1 = 0.31706512e-16
+    k1 = 4*math.pi*sigma*D
     k2 = 1e2
 
     # Spacing inbetween cluster particles AND cluster/B-particle
@@ -69,7 +72,10 @@
     myrandom.seed(currenttime)
 
     print str('Seed: '+str(currenttime))
-
+    print "Constants: sigma="+str(sigma)+"; D="+str(D)+"; world_size="+\
+        str(world_size)+"; k1="+str(k1)+"; k2="+str(k2)+"; spacing="+\
+        str(spacing)+"; N="+str(N)+"; runs="+str(runs)+\
+        "; kd/k1="+str((4*math.pi*sigma*D)/k1)+"; f="+str(N*sigma*sigma/(world_size*world_size))
 
 # Functions
 # ===============================
@@ -224,7 +230,7 @@ def single_run(N, LOGGING):
     # Enable VTK Logger
     # ===============================
     if (LOGGING == True):
-        vtk_output_directory = 'VTK_out'
+        vtk_output_directory = 'VTK_out_' + str(M)
         if (os.path.exists(vtk_output_directory)):
             print '** Warning: VTK directory already exists.'
         l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
@@ -232,18 +238,27 @@ def single_run(N, LOGGING):
     # Running 
     # ===============================
     numberDetected = 0
+    nd = 0 
 
     if (LOGGING == True):
         while 1:
             l.log() # log
             s.step() # and make eGFRD step
-            if s.last_reaction:
+            if s.last_reaction: 
                 numberDetected = numberDetected+1
-                if (numberDetected == 2):
+                if (numberDetected == 2): 
                     # print "2nd Reaction detected at: " + str(s.t) + "(" + str(s.last_reaction) + ")"
                     reaction_time = s.t - previous_time
                     break  
                 else: previous_time = s.t
+            if (s.t > 10000):                
+                reaction_time = 10000
+                print "Long excursion. Aborted."
+                break
+            if (nd > 1000):
+                reaction_time = "NaN"
+                print ">1000 steps, aborted."
+                break
         l.stop() 
     else:
         while 1:
@@ -255,6 +270,10 @@ def single_run(N, LOGGING):
                     reaction_time = s.t - previous_time
                     break  
                 else: previous_time = s.t
+            if (s.t > 10000):
+                reaction_time = 10000
+                print "Long excursion. Aborted."
+                break
 
     s.stop(s.t)
     return (reaction_time)
@@ -280,6 +299,23 @@ def single_run(N, LOGGING):
     datetime.datetime.now().minute*60+datetime.datetime.now().second)-currenttime)
     print "Done in "+ str(timetaken) +" seconds."
 
+# Print status report to file
+# ============
+    outFile = open(outFilename+"_report", 'w')
+    outFile.write("Cluster simulation")
+    outFile.write("\n========================")
+    outFile.write("\nNumber of runs: "+str(runs))
+    outFile.write("\nNumber of particles: "+str(N))    
+    outFile.write("\nSigma: "+str(sigma))
+    outFile.write("\nDiffusion constant: "+str(D))
+    outFile.write("\nWorld size: "+str(world_size))
+    outFile.write("\nBinding reaction rate: "+str(k1))
+    outFile.write("\nUnbinding reaction rate: "+str(k2))
+    outFile.write("\nDone in "+ str(timetaken) +" seconds.")
+    outFile.close()
+
+
+
 
 # #### OLD CODE
 
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index ac3c3bfa..3603cb56 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -1,4 +1,4 @@
-# Test run of VTK-logger by MW - Adapted from Tomek
+# Test run of VTK-logger by MW - Adapted from Tomek Sokolowski
 
 # ### INSTRUCTIONS ###
 """
@@ -11,7 +11,7 @@
 # (This was defined when calling the logger in your
 # script.)
 simulation_data_directory = egfrd_directory + \
-    'samples/memory/VTK_out/'
+    'samples/cluster/VTK_out_38/'
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From 38b4701901848d3b7061243920f3035d1ceb885d Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 28 Jun 2011 11:28:20 +0200
Subject: [PATCH 0079/1541] Added README to visualization directory.

---
 visualization/README | 68 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 visualization/README

diff --git a/visualization/README b/visualization/README
new file mode 100644
index 00000000..4f50ad8f
--- /dev/null
+++ b/visualization/README
@@ -0,0 +1,68 @@
+
+Use of visualisation Toolkit
+==============================
+
+Introduction
+==============================
+
+The Visualisation Toolkit (VTK) can be used to create a "3d movie" of your
+simulations. To visualize the simulation, the program ParaView is used, which
+reads data generated by the VTK.
+
+To get things running, the following steps can be followed:
+
+1. Import VTK libraries to Paraview
+==============================
+
+Import VTK additional library files to ParaView. This has to
+be done only once. Copy the plugins (egfrdDir)/paraview/tensorGlyph.xml 
+and (egfrdDir)/paraview/tensorGto /home/(username)/.config/ParaView/
+ParaView(VERSION)/Plugins/ replacing (VERSION) by the version of 
+your Paraview installation (for example 3.6). These 2 files are needed 
+to show cylinders of different sizes and different orientations correctly. 
+Go to Tools >Manage Plugins/Extensions and check that the plugins are loaded, 
+or load them manually.
+
+2. Calling the logger in your simulation
+==============================
+
+The following code can be used to implement the VTK logger in your simulation:
+
+    # Set directory
+    vtk_output_directory = 'VTK_out'
+        # If there are already VTK files in the directory, this gives problems
+
+    # Import the logger        
+    from visualization import vtklogger
+    # Create logging object
+    l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+
+    # log a step
+    l.log()
+
+    # stop logger, writing away essential data
+    l.stop()
+
+For additional information see VTKlogger.py.
+
+3. Use the run_pipeline.py script
+==============================
+
+If your simulation has generated VTK output data (which by the way really slows
+the simulation down), this data can be imported in Paraview using the 
+run_pipeline.py script. Instructions on how to use this script are in the script
+itself.
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From 81aebb2a4496283f1fbfd61ec7fa03f49b61ffb3 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 30 Jun 2011 14:20:43 +0200
Subject: [PATCH 0080/1541] Included D = 0 case into BD functions.

---
 freeFunctions.cpp | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index f0a462df..23689284 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -314,6 +314,9 @@ Real I_bd_3D(Real sigma, Real t, Real D)
 
 Real I_bd_1D(Real sigma, Real t, Real D, Real v)
 {
+    if(D == 0)
+        return 0;
+
     const Real sqrtPi(std::sqrt(M_PI));
 
     const Real Dt4(4 * D * t);
@@ -367,6 +370,9 @@ Real I_bd_r_3D(Real r, Real sigma, Real t, Real D)
 
 Real I_bd_r_1D(Real r, Real sigma, Real t, Real D, Real v)
 {
+    if(D == 0)
+        return 0;
+
     const Real sqrtPi(std::sqrt(M_PI));
 
     const Real Dt(D * t);
@@ -377,7 +383,7 @@ Real I_bd_r_1D(Real r, Real sigma, Real t, Real D, Real v)
 
     const Real smrpvt_sq(gsl_pow_2(sigma - r + vt));
     const Real sprmvt_sq(gsl_pow_2(sigma + r - vt));
-    const Real twosmvt_sq(gsl_pow_2(sigma + r - vt));
+    const Real twosmvt_sq(gsl_pow_2(2*sigma - vt));
 
     const Real temp1(-expl( -smrpvt_sq/Dt4 ) + expl( -sprmvt_sq/Dt4 ));
     const Real temp2(expl( -vt*vt/Dt4 ) - expl( -twosmvt_sq/Dt4 ));

From f7cd9e557588a91329a70f6af7a17fd4152d871a Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 11 Jul 2011 19:02:29 +0200
Subject: [PATCH 0081/1541] Included drift in the 1D functions for both
 association and dissociation. Changed defenition of g_bd_1D.

Added dissociation_vector method in surface classes which returns the vector between dissociated particles.
---
 BDPropagator.hpp       | 16 ++++++++-------
 CuboidalRegion.hpp     | 20 ++++++++++---------
 CylindricalSurface.hpp | 45 +++++++++++++++++++++++++++++++-----------
 PlanarSurface.hpp      | 19 +++++++++---------
 SphericalSurface.hpp   | 11 ++++++++---
 Structure.hpp          |  9 +++++----
 freeFunctions.cpp      | 26 ++++++++++++------------
 7 files changed, 90 insertions(+), 56 deletions(-)

diff --git a/BDPropagator.hpp b/BDPropagator.hpp
index 8d8dc0ae..15a99358 100644
--- a/BDPropagator.hpp
+++ b/BDPropagator.hpp
@@ -161,7 +161,7 @@ class BDPropagator
 private:
     position_type drawR_free(species_type const& species)
     {
-        return tx_.get_structure(species.structure_id())->bd_displacement(std::sqrt(2.0 * species.D() * dt_), rng_);
+        return tx_.get_structure(species.structure_id())->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_);
     }
 
     bool attempt_reaction(particle_id_pair const& pp)
@@ -239,16 +239,17 @@ class BDPropagator
                                 throw propagation_error("no space");
                             }
 
-                            const Real rnd(rng_());
                             boost::shared_ptr<structure_type> pp_structure( 
                                 tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) );  
                
-                            length_type pair_distance(pp_structure->drawR_gbd(rnd, r01, dt_, D01, s0.v(), s1.v()) );
-                            const position_type m(pp_structure->random_vector(pair_distance, rng_) );
+                            position_type m( pp_structure->
+                                        dissociation_vector( rng_, r01, dt_, D01, s0.v() - s1.v() ) );
+                            
                             np0 = tx_.apply_boundary(pp.second.position()
-                                    + m * (s0.D() / D01));
+                                    - m * (s0.D() / D01));
                             np1 = tx_.apply_boundary(pp.second.position()
-                                    - m * (s1.D() / D01));
+                                    + m * (s1.D() / D01));
+                           
                             boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_s0(
                                 tx_.check_overlap(
                                     particle_shape_type(np0, s0.radius()),
@@ -316,7 +317,8 @@ class BDPropagator
             boost::shared_ptr<structure_type> pp_structure( 
                tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
 
-            const Real p(pp_structure->p_acceptance( r.k(), dt_, r01, s0.D(), s1.D(), s0.v(), s1.v() ));
+            const Real p(pp_structure->p_acceptance( r.k(), dt_, r01, subtract( pp1.second.position(), 
+                                                pp0.second.position() ), s0.D(), s1.D(), s0.v(), s1.v() ));
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 2391976a..6edf70a1 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -39,7 +39,7 @@ class CuboidalRegion
                 rng.uniform(-1., 1.)), r);
     }
 
-    virtual position_type bd_displacement(length_type const& r, rng_type& rng) const
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
     {
         return create_vector<position_type>(
             rng.normal(0., r),
@@ -47,20 +47,22 @@ class CuboidalRegion
             rng.normal(0., r));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
     {
-        length_type pair_distance( drawR_gbd_3D(rnd, r01, dt, D01) );
-    
-        return pair_distance;
+         return drawR_gbd_3D(rnd, r01, dt, D01);
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
     {
-        Real p_acc(k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI));
-    
-        return p_acc;
+         return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
     }
 
+    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    {
+        return random_vector( drawR_gbd(rng(), r01, dt, D01, v ), rng );
+    }
+
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 3e25d19a..08e2cfbd 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -30,24 +30,47 @@ class CylindricalSurface
                 (rng.uniform_int(0, 1) * 2 - 1) * r);
     }
 
-    virtual position_type bd_displacement(length_type const& r, rng_type& rng) const
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
     {
-        return multiply(base_type::shape().unit_z(), rng.normal(0., r));
+        return multiply(base_type::shape().unit_z(), rng.normal(mean, r));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
     {
-        length_type pair_distance( drawR_gbd_1D(rnd, r01, dt, D01, v0 - v1) );
-    
-        return pair_distance;
+        return drawR_gbd_1D(rnd, r01, dt, D01, v);
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
     {
-        
-        Real p_acc(k_a * dt / (I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1)));
-    
-        return p_acc;
+        /*
+            The I_bd factors used for calculating the acceptance probability are dependent on the direction 
+            of the overlap step (step_direction = r_1 - r_0), compared to the direction of the drift. 
+            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0). 
+            If the particle comes from the left, we invert (v *= -1) the direction of its drift.
+        */
+        length_type step_direction = dot_product( ipv, base_type::shape().unit_z() );
+
+        if( step_direction > 0 )
+            v0 *= -1;
+        else
+            v1 *= -1;
+
+        return k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) );
+    }
+
+    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    {
+        Real I_A( I_bd_1D(r01, dt, D01, v) );        
+        Real prob( rng()*(I_A + I_bd_1D(r01, dt, D01, -v)) );
+        Real rnd( rng() );
+
+        if( prob < I_A )    
+            return multiply(base_type::shape().unit_z(), drawR_gbd( rnd, r01, dt, D01, v ) );
+        else
+        {
+            position_type direction( base_type::shape().unit_z() * -1. );
+            return multiply( direction, drawR_gbd( rnd, r01, dt, D01, -v ) );    
+        }
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index f115b0e6..a2c0ebda 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -35,7 +35,7 @@ class PlanarSurface
                         base_type::shape().units()[1], rng.uniform(-1., 1.)))), r);
     }
 
-    virtual position_type bd_displacement(length_type const& r, rng_type& rng) const
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
     {
         length_type const x(rng.normal(0., r)), y(rng.normal(0., r));
         return add(
@@ -43,20 +43,21 @@ class PlanarSurface
             multiply(base_type::shape().unit_y(), y));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
     {
         //TODO: use the 2D BD function instead of the 3D one.
-        length_type pair_distance( drawR_gbd_3D(rnd, r01, dt, D01) );
-    
-        return pair_distance;
+        return drawR_gbd_3D(rnd, r01, dt, D01);
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
     {
         //TODO: use the 2D BD function instead of the 3D one.
-        Real p_acc(k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI));
-    
-        return p_acc;
+        return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
+    }
+
+    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    {
+        return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng ); 
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index a6396481..6433cb7a 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -27,21 +27,26 @@ class SphericalSurface
         return position_type(); // TODO
     }
 
-    virtual position_type bd_displacement(length_type const& r, rng_type& rng) const
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
     {
         return position_type(); // TODO
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
     {    
         return length_type(); // TODO
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
     {    
         return Real(); //TODO
     }
 
+    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    {
+        return position_type(); //TODO
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         return 0.; // TODO
diff --git a/Structure.hpp b/Structure.hpp
index da08e0d0..772a3466 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -24,7 +24,6 @@ class Structure
     typedef typename traits_type::length_type length_type;
     typedef typename traits_type::position_type position_type;
     typedef std::pair<position_type, length_type> projected_type;
-    typedef typename traits_type::species_type species_type;
 
 public:
     virtual ~Structure() {}
@@ -48,11 +47,13 @@ class Structure
 
     virtual position_type random_vector(length_type const& r, rng_type& rng) const = 0;
 
-    virtual position_type bd_displacement(length_type const& r, rng_type& rng) const = 0;
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v0, Real v1) const = 0;
+    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const = 0;
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, Real D0, Real D1, Real v0, Real v1) const = 0;
+    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const = 0;
+
+    virtual position_type dissociation_vector(rng_type& rng, length_type r01, Real dt, Real D01, Real v) const = 0;
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
 
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index 23689284..7e24b551 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -283,10 +283,10 @@ Real g_bd_1D(Real r, Real sigma, Real t, Real D, Real v)
     const Real sqrtDt4_r(1.0 / sqrtDt4);
     const Real vt = v*t;
 
-    const Real s_plus_r_min_vt(sigma + r - vt);
-    const Real s_min_r_plus_vt(sigma - r + vt);
+    const Real s_plus_r_plus_vt(sigma + r + vt);
+    const Real s_min_r_min_vt(sigma - r - vt);
 
-    const Real result(erfl(s_plus_r_min_vt * sqrtDt4_r) + erfl(s_min_r_plus_vt * sqrtDt4_r));
+    const Real result(erfl(s_plus_r_plus_vt * sqrtDt4_r) + erfl(s_min_r_min_vt * sqrtDt4_r));
 
     return 0.5 * result;
 }
@@ -323,9 +323,9 @@ Real I_bd_1D(Real sigma, Real t, Real D, Real v)
     const Real sqrt4Dt(std::sqrt(Dt4));
     double vt = v*t;
 
-    const Real arg1(-(2*sigma - vt)*(2*sigma - vt)/Dt4);
+    const Real arg1(-(2*sigma + vt)*(2*sigma + vt)/Dt4);
     const Real term1(expl( -vt*vt/Dt4 ) - expl( arg1 ));
-    const Real term2(vt*erfl( vt/sqrt4Dt ) - (2*sigma - vt)*erfl( (2*sigma - vt)/sqrt4Dt ));
+    const Real term2(vt*erfl( vt/sqrt4Dt ) - (2*sigma + vt)*erfl( (2*sigma + vt)/sqrt4Dt ));
     const Real result(1./2*(sqrt4Dt/sqrtPi*term1 + term2 + 2*sigma));
 
     return result;
@@ -381,17 +381,17 @@ Real I_bd_r_1D(Real r, Real sigma, Real t, Real D, Real v)
     const Real sqrt4Dt(std::sqrt(Dt4));
     const Real vt = v*t;
 
-    const Real smrpvt_sq(gsl_pow_2(sigma - r + vt));
-    const Real sprmvt_sq(gsl_pow_2(sigma + r - vt));
-    const Real twosmvt_sq(gsl_pow_2(2*sigma - vt));
+    const Real smrmvt_sq(gsl_pow_2(sigma - r - vt));
+    const Real sprpvt_sq(gsl_pow_2(sigma + r + vt));
+    const Real twospvt_sq(gsl_pow_2(2*sigma + vt));
 
-    const Real temp1(-expl( -smrpvt_sq/Dt4 ) + expl( -sprmvt_sq/Dt4 ));
-    const Real temp2(expl( -vt*vt/Dt4 ) - expl( -twosmvt_sq/Dt4 ));
+    const Real temp1(-expl( -smrmvt_sq/Dt4 ) + expl( -sprpvt_sq/Dt4 ));
+    const Real temp2(expl( -vt*vt/Dt4 ) - expl( -twospvt_sq/Dt4 ));
     const Real term1(sqrt4Dt/sqrtPi*( temp1 + temp2 ));
 
-    const Real term2(vt*erfl(vt/sqrt4Dt) - (2*sigma - vt)*erfl( (2*sigma - vt)/sqrt4Dt ));
-    const Real term3((r - sigma - vt)*erfl( (sigma - r + vt)/sqrt4Dt ));
-    const Real term4((r + sigma - vt)*erfl( (r + sigma - vt)/sqrt4Dt ));
+    const Real term2(vt*erfl(vt/sqrt4Dt) - (2*sigma + vt)*erfl( (2*sigma + vt)/sqrt4Dt ));
+    const Real term3((r - sigma + vt)*erfl( (sigma - r - vt)/sqrt4Dt ));
+    const Real term4((r + sigma + vt)*erfl( (r + sigma + vt)/sqrt4Dt ));
     const Real result(1./2*(term1 + term2 + term3 + term4));
     
     return result;

From 60cd37c296246e3a3b2e64af4c0b372022847451 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 18 Jul 2011 18:14:59 +0200
Subject: [PATCH 0082/1541] Increased allowed number of steps where dt=0 is
 allowed. In certain regimes this quite often happens because domains are
 allowed to have very different sizes. (See GIT issue tracker:
 https://github.com/gfrd/egfrd/issues/21).

---
 egfrd.py                      | 24 +++++++++++++++---------
 visualization/run_pipeline.py |  4 ++--
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fd29bb55..476a726b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1,6 +1,5 @@
 #!/usr/env python
 
-
 from weakref import ref
 import math
 
@@ -309,10 +308,14 @@ def step(self):
         # assert if not too many successive dt=0 steps occur.
         if __debug__:
             if self.dt == 0:
+                log.warning('dt=zero step, working in s.t >> dt~0 Python limit.')
                 self.zero_steps += 1
-                if self.zero_steps >= max(self.scheduler.size * 3, 10):
+                # TODO Changed from 10 to 10000, because only a problem 
+                # when reaching certain magnitude.
+                if self.zero_steps >= max(self.scheduler.size * 3, 10000): 
                     raise RuntimeError('too many dt=zero steps. '
-                                       'Simulator halted?')
+                                       'Simulator halted?'
+                                    'dt= %.300g-%.300g' % (self.scheduler.top[1].time, self.t))
             else:
                 self.zero_steps = 0
 
@@ -741,12 +744,15 @@ def fire_single(self, single):
 
             return
 
-        if single.event_type == EventType.IV_EVENT:
-            # Draw actual pair event for iv at very last minute.
-            single.event_type = single.draw_iv_event_type()
-            self.interaction_steps[single.event_type] += 1
-        else:
-            self.single_steps[single.event_type] += 1
+#       TO BE DELETED; code shouldn't be here. 
+#       (<-> Surface binding en unbinding.)
+#
+#        if single.event_type == EventType.IV_EVENT:
+#            # Draw actual pair event for iv at very last minute.
+#            single.event_type = single.draw_iv_event_type()
+#            self.interaction_steps[single.event_type] += 1
+#        else:
+#            self.single_steps[single.event_type] += 1
 
         if __debug__:
             log.info('%s' % single.event_type)
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index 3603cb56..0cd6a861 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -10,8 +10,8 @@
 # Output directory of the VTK logger 
 # (This was defined when calling the logger in your
 # script.)
-simulation_data_directory = egfrd_directory + \
-    'samples/cluster/VTK_out_38/'
+simulation_data_directory =\
+    '/storage1/wehrens/scripts_gfrd/benchmarking/VTK_out' # egfrd_directory + \
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From 5427718ed5be3a2b9e05c48cd24f37bba920b7c6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 20 Jul 2011 16:02:32 +0200
Subject: [PATCH 0083/1541] Added GF choosing mechanism to planarsurfacepair

---
 egfrd.py |  1 +
 pair.py  | 48 ++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b3abadcf..ee5fc206 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -686,6 +686,7 @@ def propagate_single(self, single):
 
     def fire_single(self, single):
         assert abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t
+	# why this assert -> we need to take into account that single.dt might be infinite
 
         # Reaction.
         if single.event_type == EventType.SINGLE_REACTION:
diff --git a/pair.py b/pair.py
index f9e2643a..acefd724 100644
--- a/pair.py
+++ b/pair.py
@@ -302,6 +302,8 @@ def iv_greens_function(self, r0):
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
 
+    # selects between the full solution or an approximation where one of
+    # the boundaries is ignored
     def choose_pair_greens_function(self, r0, t):
         distance_from_sigma = r0 - self.sigma
         distance_from_shell = self.a_r - r0
@@ -409,9 +411,51 @@ def create_new_shell(self, position, radius, domain_id):
 
         a_R, a_r = self.determine_radii()
 
+    #def choose_pair_greens_function(self, r0, t):
+    #    if __debug__:
+    #        log.debug('ivGF2D: normal')
+    #    return self.iv_greens_function(r0)
+
+    # selects between the full solution or an approximation where one of
+    # the boundaries is ignored
     def choose_pair_greens_function(self, r0, t):
-        # Todo
-        return self.iv_greens_function(r0)
+        distance_from_sigma = r0 - self.sigma
+        distance_from_shell = self.a_r - r0
+
+        threshold_distance = Pair.CUTOFF_FACTOR * \
+            math.sqrt(4.0 * self.D_tot * t)
+
+        if distance_from_sigma < threshold_distance:
+        
+            if distance_from_shell < threshold_distance:
+                # near both a and sigma;
+                # use GreensFunction3DRadAbs
+                if __debug__:
+                    log.debug('GF2D: normal')
+                return self.iv_greens_function(r0)
+            else:
+                # near sigma; use GreensFunction3DRadInf
+                if __debug__:
+                    log.debug('GF2D: only sigma')
+                return self.iv_greens_function(r0)
+        	# Todo
+                # return GreensFunction2DRadInf(self.D_tot, self.rt.ktot, r0, self.sigma)
+        else:
+            if distance_from_shell < threshold_distance:
+                # near a;
+                if __debug__:
+                    log.debug('GF2D: only a')
+                return self.iv_greens_function(r0)
+	        # Todo
+                # return GreensFunction2DAbs(self.D_tot, r0, self.a_r)
+                
+            else:
+                # distant from both a and sigma; 
+                if __debug__:
+                    log.debug('GF2D: free')
+                return self.iv_greens_function(r0)
+        	# Todo
+                # return GreensFunction2D(self.D_tot, r0)
 
     def create_com_vector(self, r):
         x, y = random_vector2D(r)

From 2c86c1250a3ca3fd4fda82faa92a0202e883fb43 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 21 Jul 2011 12:17:41 +0200
Subject: [PATCH 0084/1541] Minor change to .gitignore

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index c70d9211..ca478f2e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,6 +22,7 @@
 *.aux
 *.log
 *.pdf
+*.toc
 
 # ignore data files generated by the examples
 *.out

From 269ef6b5fff764ef52b0c56f79db30ed47e351e6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 21 Jul 2011 16:40:41 +0200
Subject: [PATCH 0085/1541] Added some comments regarding the Green's function
 chooser

---
 pair.py | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/pair.py b/pair.py
index 8de22fa1..8b4dd706 100644
--- a/pair.py
+++ b/pair.py
@@ -182,12 +182,13 @@ def determine_radii(self, r0, shell_size):
 
         return a_R, a_r
 
+    # draws a first event time and the (not fully specified) type of event
     def draw_com_escape_or_iv_event_time_tuple(self, r0):
         """Returns a (event time, event type, reactingsingle=None) tuple.
         
         """
         dt_com = draw_time_wrapper(self.com_greens_function())
-        dt_iv = draw_time_wrapper(self.iv_greens_function(r0))
+        dt_iv = draw_time_wrapper(self.iv_greens_function(r0))	# uses the full solution to draw IV first event time
         if dt_com < dt_iv:
             return dt_com, EventType.COM_ESCAPE, None
         else:
@@ -329,8 +330,7 @@ def choose_pair_greens_function(self, r0, t):
                 # near a;
                 if __debug__:
                     log.debug('GF: only a')
-                return GreensFunction3DAbs(self.D_tot,
-                                                                 r0, self.a_r)
+                return GreensFunction3DAbs(self.D_tot, r0, self.a_r)
                 
             else:
                 # distant from both a and sigma; 
@@ -391,7 +391,7 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
         # Todo. 2D gf Rad Abs.
-        # This exact solution is used for drawing times.
+        # This exact solution is used for drawing times and event times.
         return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
                                               self.sigma, self.a_r)
 
@@ -410,14 +410,9 @@ def create_new_shell(self, position, radius, domain_id):
 
         a_R, a_r = self.determine_radii()
 
-    #def choose_pair_greens_function(self, r0, t):
-    #    if __debug__:
-    #        log.debug('ivGF2D: normal')
-    #    return self.iv_greens_function(r0)
-
-    # selects between the full solution or an approximation where one of
-    # the boundaries is ignored
     def choose_pair_greens_function(self, r0, t):
+	# selects between the full solution or an approximation where one of
+	# the boundaries is ignored
         distance_from_sigma = r0 - self.sigma
         distance_from_shell = self.a_r - r0
 

From 5cff72c535dd4409b17c7561787408ec23283852 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 21 Jul 2011 16:41:12 +0200
Subject: [PATCH 0086/1541] Added #!/usr/bin/env python to few sample files.

---
 samples/cluster/run.py       | 1 +
 samples/template/template.py | 1 +
 2 files changed, 2 insertions(+)

diff --git a/samples/cluster/run.py b/samples/cluster/run.py
index 9c18a980..92bad74f 100644
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 
 # Rebinding to a cluster
 
diff --git a/samples/template/template.py b/samples/template/template.py
index 6bd38cd5..1a50dfba 100644
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 
 # Template file to copy and paste basic code from.
 

From 5d0f1c98520f64d8c0b751e76864c7c38038e75d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 21 Jul 2011 16:53:07 +0200
Subject: [PATCH 0087/1541] Typo removed in determine_radii

---
 pair.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 8b4dd706..89b8ca24 100644
--- a/pair.py
+++ b/pair.py
@@ -32,6 +32,7 @@ def __init__(self, domain_id, com, single1, single2, shell_id, r0,
         self.single2 = single2 
 
         self.a_R, self.a_r = self.determine_radii(r0, shell_size)
+	# set the radii of the inner domains as a function of the outer protective domain
 
         self.rt = rt
 
@@ -408,8 +409,6 @@ def create_new_shell(self, position, radius, domain_id):
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
-        a_R, a_r = self.determine_radii()
-
     def choose_pair_greens_function(self, r0, t):
 	# selects between the full solution or an approximation where one of
 	# the boundaries is ignored

From 5df86682449c2ee443791e770816c93a5423259e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 21 Jul 2011 17:45:14 +0200
Subject: [PATCH 0088/1541] Inserted temporary fix for too high l/d

---
 pair.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 89b8ca24..73fed7ec 100644
--- a/pair.py
+++ b/pair.py
@@ -111,7 +111,7 @@ def initialize(self, t):
         self.event_type = None
 
     def determine_radii(self, r0, shell_size):
-        """Determine a_r and a_R.
+        """Determine a_r and a_R from the size of the protective domain.
 
         Todo. Make dimension (1D/2D/3D) specific someday. Optimization only.
 
@@ -124,6 +124,10 @@ def determine_radii(self, r0, shell_size):
         D1 = single1.pid_particle_pair[1].D
         D2 = single2.pid_particle_pair[1].D
 
+	LD_MAX = 20 # temporary value
+	a_r_max = LD_MAX * (r0 - self.sigma)
+	# a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
+
         # Make sure that D1 != 0 to avoid division by zero in the followings.
         if D1 == 0:
             D1, D2 = D2, D1
@@ -158,6 +162,12 @@ def determine_radii(self, r0, shell_size):
         #ar
         a_r = (D_geom * r0 + D_tot * (shell_size - radiusa)) / (Da + D_geom)
 
+	# Now if the planned domainsize for r is too large for proper convergence of the Green's
+	# functions, make it the maximum allowed size
+	if (a_r > a_r_max):
+	    a_r = a_r_max
+	    a_R = shell_size - a_r
+
         assert a_R + a_r * Da / D_tot + radius1 >= \
                a_R + a_r * Db / D_tot + radius2
 

From 12e23804789935ef6fb97b18f97169dcfbeef45f Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 25 Jul 2011 19:22:12 +0200
Subject: [PATCH 0089/1541] Added some (hopefully) clarifying comments.

---
 pair.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pair.py b/pair.py
index 5af3f211..58506a37 100644
--- a/pair.py
+++ b/pair.py
@@ -308,8 +308,10 @@ def choose_pair_greens_function(self, r0, t):
         threshold_distance = Pair.CUTOFF_FACTOR * \
             math.sqrt(6.0 * self.D_tot * t)
 
+        # if sigma reachable
         if distance_from_sigma < threshold_distance:
         
+            # if shell reachable
             if distance_from_shell < threshold_distance:
                 # near both a and sigma;
                 # use GreensFunction3DRadAbs
@@ -322,6 +324,8 @@ def choose_pair_greens_function(self, r0, t):
                     log.debug('GF: only sigma')
                 return GreensFunction3DRadInf(self.D_tot, self.rt.ktot, r0,
                                                self.sigma)
+
+        # sigma unreachable
         else:
             if distance_from_shell < threshold_distance:
                 # near a;

From 71b3f4941438642d77762f232d066f11237a1e6d Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 25 Jul 2011 19:23:51 +0200
Subject: [PATCH 0090/1541] Added unmodified 2D Green's Functions as programmed
 by Laurens Bossen to tracker. Just for reference what will change in
 implementation.

---
 GreensFunction2DAbsSym.cpp |  299 ++++++++
 GreensFunction2DAbsSym.hpp |   96 +++
 GreensFunction2DRadAbs.cpp | 1349 ++++++++++++++++++++++++++++++++++++
 GreensFunction2DRadAbs.hpp |  316 +++++++++
 4 files changed, 2060 insertions(+)
 create mode 100644 GreensFunction2DAbsSym.cpp
 create mode 100644 GreensFunction2DAbsSym.hpp
 create mode 100644 GreensFunction2DRadAbs.cpp
 create mode 100644 GreensFunction2DRadAbs.hpp

diff --git a/GreensFunction2DAbsSym.cpp b/GreensFunction2DAbsSym.cpp
new file mode 100644
index 00000000..739b1d2f
--- /dev/null
+++ b/GreensFunction2DAbsSym.cpp
@@ -0,0 +1,299 @@
+#include <sstream>
+#include <iostream>
+#include <exception>
+#include <vector>
+
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_sf_trig.h>
+#include <gsl/gsl_sum.h>
+#include <gsl/gsl_errno.h>
+#include <gsl/gsl_interp.h>
+#include <gsl/gsl_sf_expint.h>
+#include <gsl/gsl_sf_elljac.h>
+#include <gsl/gsl_roots.h>
+#include <gsl/gsl_sf_bessel.h>
+
+#include "findRoot.hpp"
+
+#include "FirstPassageGreensFunction2D.hpp"
+
+
+
+
+// an alternative form, which is not very convergent.
+const Real 
+FirstPassageGreensFunction2D::p_survival( const Real t ) const
+{
+    const Real D( getD() );
+    const Real a( geta() );
+    const Real Dt( -D * t );
+
+    const Integer N( 100 );	// number of terms to use
+    Real sum( 0. );
+    Real aAn (0);
+    Real An (0);
+    Real J1_aAn(0);
+    Real term(0);
+
+    const Real threshold( CUTOFF );	// 
+
+//std::cout << "p_survival_2D ";
+//std::cout << "time: " << t << std::endl;
+    for( Integer n( 1 ); n <= N; ++n )
+    {
+	aAn = gsl_sf_bessel_zero_J0(n);		// gsl roots of J0(aAn)
+	An = aAn/a;
+	J1_aAn = gsl_sf_bessel_J1(aAn);
+	term = (exp(An*An*Dt))/(An*J1_aAn);
+	sum += term;
+
+//std::cout << n << " " << aAn << " " << J1_aAn << " " << term << " " << value << std::endl;
+
+        if( fabs( term/sum ) < threshold )
+	{
+	    // normal exit.
+//std::cout << n << std::endl;
+	    break;
+	}
+    }
+    return (2.0/a) * sum;
+} 
+
+
+const Real 
+FirstPassageGreensFunction2D::p_int_r_free( const Real r, const Real t ) const
+{
+    const Real D( getD() );
+    const Real Dt( D * t );
+    const Real sqrtDt( sqrt( Dt ) );
+    const Real sqrtPI( sqrt( M_PI ) );
+
+    return erf( r / ( sqrtDt + sqrtDt ) )
+        - r * exp( - r * r / ( 4.0 * Dt ) ) / ( sqrtPI * sqrtDt );
+}
+
+const Real 
+FirstPassageGreensFunction2D::p_int_r( const Real r, 
+                                     const Real t ) const
+{
+    const Real a( geta() );
+    const Real D( getD() );
+    const Real Dt( -D * t );
+    Real J1_aAn, J1_rAn;
+    Real aAn, rAn, An;
+    Real term;
+    Real sum( 0.0 );
+    int n(1);
+
+//    const Real maxn( ( a / M_PI ) * sqrt( log( exp( DtPIsq_asq ) / CUTOFF ) / 
+//                                          ( D * t ) ) );
+
+    const Integer N_MAX( 10000 );
+    const Real threshold( CUTOFF );
+
+    do
+    {
+	aAn = gsl_sf_bessel_zero_J0(n);         // gsl roots of J0(aAn)
+        An  = aAn/a;
+	rAn = r*An;
+        J1_aAn = gsl_sf_bessel_J1(aAn);
+	J1_rAn = gsl_sf_bessel_J1(rAn);
+        term = (exp(An*An*Dt) * r * J1_rAn) / (An*J1_aAn*J1_aAn);
+        sum += term;
+	n++;
+
+//std::cout << n << " " << aAn << " " << J1_aAn << " " << term << " " << value << std::endl;
+    }
+    while (fabs( term/sum ) > threshold && n <= N_MAX);
+
+    return (2.0/(a*a)) * sum;
+} 
+
+
+const Real
+FirstPassageGreensFunction2D::p_survival_F( const Real t,
+					  const p_survival_params* params )
+{
+    const FirstPassageGreensFunction2D* const gf( params->gf ); 
+    const Real rnd( params->rnd );
+
+    return 1 - gf->p_survival( t ) - rnd;
+}
+
+
+
+const Real 
+FirstPassageGreensFunction2D::drawTime( const Real rnd ) const
+{
+	THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
+
+	const Real a( geta() );
+
+	if( getD() == 0.0 || a == INFINITY )
+	{
+		return INFINITY;
+	}
+	if( a == 0.0 )
+	{
+		return 0.0;
+	}
+
+	p_survival_params params = { this, rnd };
+
+	gsl_function F = 
+	{
+		reinterpret_cast<typeof(F.function)>( &p_survival_F ), &params 
+	};
+
+//for (Real t=0.0001; t<=1; t+=0.0001)
+//{	std::cout << t << " " << GSL_FN_EVAL( &F, t) << std::endl;
+//}
+
+	// Find a good interval to determine the first passage time in
+        const Real t_guess( a * a / ( 4. * D ) );   // construct a guess: msd = sqrt (2*d*D*t)
+        Real value( GSL_FN_EVAL( &F, t_guess ) );
+        Real low( t_guess );
+        Real high( t_guess );
+
+        // scale the interval around the guess such that the function straddles
+        if( value < 0.0 )               // if the guess was too low
+        {
+                do
+                {       high *= 10;     // keep increasing the upper boundary until the function straddles
+                        value = GSL_FN_EVAL( &F, high );
+
+                        if( fabs( high ) >= t_guess * 1e6 )
+                        {
+                                std::cerr << "Couldn't adjust high. F(" << high <<
+                                    ") = " << value << std::endl;
+                                throw std::exception();
+                        }
+                }
+                while ( value <= 0.0 );
+        }
+        else                            // if the guess was too high
+        {
+                Real value_prev( value );
+                do
+                {       low *= .1;      // keep decreasing the lower boundary until the function straddles
+                        value = GSL_FN_EVAL( &F, low );     // get the accompanying value
+
+                        if( fabs( low ) <= t_guess * 1e-6 || fabs( value - value_prev ) < CUTOFF )
+                        {
+                                std::cerr << "Couldn't adjust low. F(" << low <<
+                                        ") = " << value << std::endl;
+                                return low;
+                        }
+                        value_prev = value;
+                }
+                while ( value >= 0.0 );
+        }
+
+	// find the root
+	const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );	// a new solver type brent
+	gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );	// make a new solver instance
+	const Real t( findRoot( F, solver, low, high, 1e-18, 1e-12,
+                            "FirstPassageGreensFunction2D::drawTime" ) );
+	gsl_root_fsolver_free( solver );
+
+	return t;
+}
+
+const Real
+FirstPassageGreensFunction2D::p_r_free_F( const Real r,
+                                        const p_r_params* params )
+{
+    const FirstPassageGreensFunction2D* const gf( params->gf ); 
+    const Real t( params->t );
+    const Real target( params->target );
+
+    return gf->p_int_r_free( r, t ) - target;
+}
+
+
+const Real
+FirstPassageGreensFunction2D::p_r_F( const Real r,
+				   const p_r_params* params )
+{
+    const FirstPassageGreensFunction2D* const gf( params->gf ); 
+    const Real t( params->t );
+    const Real target( params->target );
+
+    return gf->p_int_r( r, t ) - target;
+}
+
+
+
+const Real 
+FirstPassageGreensFunction2D::drawR( const Real rnd, const Real t ) const 
+{
+    THROW_UNLESS( std::invalid_argument, rnd <= 1.0 && rnd >= 0.0 );
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
+    const Real a( geta() );
+    const Real D( getD() );
+
+    if( a == 0.0 || t == 0.0 || D == 0.0 )
+    {
+        return 0.0;
+    }
+
+    const Real thresholdDistance( this->CUTOFF_H * sqrt( 4.0 * D * t ) );
+
+    gsl_function F;
+    Real psurv;
+
+//    if( a <= thresholdDistance )	// if the domain is not so big, the boundaries are felt
+//    {
+        psurv = p_survival( t );
+        //psurv = p_int_r( a, t );
+        //printf("dr %g %g\n",psurv, p_survival( t ));
+        //assert( fabs(psurv - p_int_r( a, t )) < psurv * 1e-8 );
+
+        assert( psurv > 0.0 );
+
+        F.function = reinterpret_cast<typeof(F.function)>( &p_r_F );
+/*    }
+    else				// if the domain is very big, just use the free solution
+    {
+        // p_int_r < p_int_r_free
+        if( p_int_r_free( a, t ) < rnd )	// if the particle is outside the domain?
+        {
+            std::cerr << "p_int_r_free( a, t ) < rnd, returning a." 
+                      << std::endl;
+            return a;
+        }
+
+        psurv = 1.0;
+        F.function = reinterpret_cast<typeof(F.function)>( &p_r_free_F );
+    }
+*/
+    const Real target( psurv * rnd );
+    p_r_params params = { this, t, target };
+
+    F.params = &params;
+
+
+    const Real low( 0.0 );
+    const Real high( a );
+    //const Real high( std::min( thresholdDistance, a ) );
+
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+
+    const Real r( findRoot( F, solver, low, high, 1e-18, 1e-12,
+                            "FirstPassageGreensFunction2D::drawR" ) );
+  
+    gsl_root_fsolver_free( solver );
+
+    return r;
+}
+
+
+
+const std::string FirstPassageGreensFunction2D::dump() const
+{
+    std::ostringstream ss;
+    ss << "D = " << this->getD() << ", a = " << this->geta() << std::endl;
+    return ss.str();
+}    
diff --git a/GreensFunction2DAbsSym.hpp b/GreensFunction2DAbsSym.hpp
new file mode 100644
index 00000000..cec3417c
--- /dev/null
+++ b/GreensFunction2DAbsSym.hpp
@@ -0,0 +1,96 @@
+#if !defined( __FIRSTPASSAGEGREENSFUNCTION2D_HPP )
+#define __FIRSTPASSAGEGREENSFUNCTION2D_HPP
+
+#include <vector>
+#include <boost/multi_array.hpp>
+
+#include "Defs.hpp"
+
+
+class FirstPassageGreensFunction2D
+{
+
+public:
+
+    FirstPassageGreensFunction2D( const Real D )
+	:
+	D( D ),
+        a( 0.0 )
+    {
+	;
+    }
+
+    virtual ~FirstPassageGreensFunction2D()
+    {
+	;
+    }
+
+    const Real getD() const
+    {
+	return this->D;
+    }
+
+    void seta( const Real a )
+    {
+        THROW_UNLESS( std::invalid_argument, a >= 0.0 );
+        this->a = a;
+    }
+
+    const Real geta() const
+    {
+        return this->a;
+    }
+
+    const Real p_survival( const Real t ) const; 
+
+    const Real drawTime( const Real rnd ) const;
+
+    const Real drawR( const Real rnd, const Real t ) const;
+
+    const Real p_int_r( const Real r, const Real t ) const;
+    const Real p_int_r_free( const Real r, const Real t ) const;
+
+    const std::string dump() const;
+
+// private methods
+private:
+
+    struct p_survival_params
+    {
+	const FirstPassageGreensFunction2D* const gf;
+	const Real rnd;
+    };
+
+    static const Real p_survival_F( const Real t, 
+				    const p_survival_params* params );
+
+    struct p_r_params
+    {
+	const FirstPassageGreensFunction2D* const gf;
+	const Real t;
+	const Real target;
+    };
+
+    static const Real p_r_free_F( const Real r, 
+                                  const p_r_params* params );
+
+    static const Real p_r_F( const Real r, 
+			     const p_r_params* params );
+
+// private variables
+private:
+
+    static const Real CUTOFF = 1e-10;
+
+    // H = 4.0: ~3e-5, 4.26: ~1e-6, 5.0: ~3e-7, 5.2: ~1e-7,
+    // 5.6: ~1e-8, 6.0: ~1e-9
+    static const Real CUTOFF_H = 6.0;
+
+    const Real D;
+
+    Real a;
+};
+
+
+
+#endif // __PAIRGREENSFUNCTION2D_HPP
diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
new file mode 100644
index 00000000..afa96ca4
--- /dev/null
+++ b/GreensFunction2DRadAbs.cpp
@@ -0,0 +1,1349 @@
+//#define NDEBUG
+//#define BOOST_DISABLE_ASSERTS
+
+#include <iostream>
+#include <stdexcept>
+#include <vector>
+#include <sstream>
+
+#include <boost/bind.hpp>
+#include <boost/tuple/tuple.hpp>
+
+#include <gsl/gsl_errno.h>
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_sf_legendre.h>
+#include <gsl/gsl_sf_bessel.h>
+#include <gsl/gsl_sf_lambert.h>
+#include <gsl/gsl_integration.h>
+
+#include "factorial.hpp"
+#include "funcSum.hpp"
+#include "findRoot.hpp"
+#include "freeFunctions.hpp"
+
+#include "FirstPassagePairGreensFunction2D.hpp"
+
+const Real FirstPassagePairGreensFunction2D::MIN_T_FACTOR;
+const unsigned int FirstPassagePairGreensFunction2D::MAX_ORDER;
+const unsigned int FirstPassagePairGreensFunction2D::MAX_ALPHA_SEQ;
+
+
+// This is the constructor
+FirstPassagePairGreensFunction2D::
+FirstPassagePairGreensFunction2D( const Real D, 
+				const Real kf, 
+				const Real Sigma )
+    :
+    PairGreensFunction( D, kf, Sigma ),
+    h( kf / D ),
+    a( INFINITY )
+{
+    ; // do nothing
+}
+
+FirstPassagePairGreensFunction2D::~FirstPassagePairGreensFunction2D()
+{
+    ; // do nothing
+}
+
+void FirstPassagePairGreensFunction2D::seta( const Real a )
+// This sets the parameter a (not seta or smt)
+// a is the outer shell 
+{
+    const Real sigma( this->getSigma() );
+
+    THROW_UNLESS( std::invalid_argument, a >= sigma );
+
+    if( this->a != a )
+    {
+        this->a = a;
+        clearAlphaTable();
+    }
+}
+
+//
+// Alpha-related methods
+//
+
+void FirstPassagePairGreensFunction2D::clearAlphaTable() const
+{
+    std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
+		   boost::mem_fn( &RealVector::clear ) );
+    this->alphaOffsetTable[0] = 0;
+    std::fill( this->alphaOffsetTable.begin()+1, this->alphaOffsetTable.end(),
+	       -1 );
+
+}
+
+// The method evaluates the equation for finding the alphas for given alpha. This
+// is needed to find the alpha's at which the expression is zero -> alpha is the root.
+const Real 
+FirstPassagePairGreensFunction2D::f_alpha0( const Real alpha ) const
+{
+	const Real a( this->geta() );
+	const Real sigma( getSigma() );
+	const Real h( this->geth() );
+	const Real s_An( sigma * alpha );
+	const Real a_An( a * alpha );
+
+	const double J0_s_An (gsl_sf_bessel_J0(s_An));
+	const double J1_s_An (gsl_sf_bessel_J1(s_An));
+	const double J0_a_An (gsl_sf_bessel_J0(a_An));
+
+	const double Y0_s_An (gsl_sf_bessel_Y0(s_An));
+	const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
+	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));
+
+	const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
+	const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
+	return rho1 - rho2;
+}
+
+
+// completely unclear why this is a separate function
+const Real 
+FirstPassagePairGreensFunction2D::f_alpha0_aux_F( const Real alpha,
+						const f_alpha0_aux_params* const params )
+{
+    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 	// get the gf from the params?
+    return gf->f_alpha0( alpha );
+}
+
+// finding the ith root for the order of Bessel functions zero. Only needed for the survival probability
+// and the flux
+const Real 
+FirstPassagePairGreensFunction2D::alpha0_i( const Real previous ) const
+{
+    THROW_UNLESS( std::out_of_range, previous >= 0.0 );
+
+    const Real a( this->geta() );			// get the a (the outer boundary
+    const Real sigma( this->getSigma() );		// and sigma
+    const Real interval( M_PI / ( a - sigma ) );
+
+    const Real target( previous + interval );	// The next root is approximately pi/(a-sigma) further
+    Real low ( target - (0.4 * interval ) );	// the range is calculated very easily
+    Real high( target + (0.4 * interval ) );	// We are sure that there is only one root in the interval
+						// THE 0.4 IS VERY TRICKY!! NOT SURE IF THIS WORKS FOR ALL
+						// PARAMETER SETS!!
+    if (low <= 0)
+    {	low = EPSILON/L_TYPICAL;	// NEW to avoid the zero and negative values for the interval
+    }
+
+
+    // setting up the function
+    f_alpha0_aux_params params = { this, target };	// struct with the gf object and the target
+    gsl_function F = 
+	{
+	    reinterpret_cast<typeof(F.function)>( &FirstPassagePairGreensFunction2D::f_alpha0_aux_F ),
+	    &params 
+	};
+
+
+    // setting the search interval
+//    Real low( i * interval + std::numeric_limits<Real>::epsilon() );
+//    Real high( (i+1) * interval );
+
+    //assert( GSL_FN_EVAL( &F, low ) * GSL_FN_EVAL( &F, high ) < 0.0 );
+
+    // finding the root
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+
+    const Real alpha ( findRoot( F, solver, low, high,
+		 EPSILON/L_TYPICAL, EPSILON, "FirstPassagePairGreensFunction2D::alpha0_i" ) );
+
+    gsl_root_fsolver_free( solver );
+  
+    return alpha;
+}
+
+// calculates the value of the expression for which the roots have to be found for given order n
+// The expression is evaluated for given alpha, to check if it zero or to get the value of the expression
+// n is the summation index used in the solution
+const Real FirstPassagePairGreensFunction2D::f_alpha( const Real alpha,
+						    const Integer n ) const
+{
+	const Real a( this->geta() );
+	const Real sigma( getSigma() );
+	const Real h( this->geth() );
+	const Real s_An( sigma * alpha );
+	const Real a_An( a * alpha );
+	const Real realn( static_cast<Real>( n ) );
+
+	const double Jn_s_An  (gsl_sf_bessel_Jn(n, s_An));
+	const double Jn1_s_An (gsl_sf_bessel_Jn(n+1, s_An));
+	const double Jn_a_An  (gsl_sf_bessel_Jn(n, a_An));
+
+	const double Yn_s_An  (gsl_sf_bessel_Yn(n, s_An));
+	const double Yn1_s_An (gsl_sf_bessel_Yn(n+1, s_An));
+	const double Yn_a_An  (gsl_sf_bessel_Yn(n, a_An));
+
+	const double rho1 ( ( (h*sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
+	const double rho2 ( ( (h*sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
+	return (rho1 - rho2); 
+}
+
+
+// Finding the roots alpha
+const Real 
+FirstPassagePairGreensFunction2D::f_alpha_aux_F( const Real alpha,
+	       					const f_alpha_aux_params* const params )
+{
+    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 
+    const Integer n( params->n );
+
+    return gf->f_alpha( alpha, n );	// f_alpha is the function of which we have to find the roots
+}
+
+
+// This calculates a root based on the previous one (offset) with Bessel functions of order n
+// The roots are calculated based on the previous root which is given as an argument (offset)
+const Real 
+FirstPassagePairGreensFunction2D::alpha_i( const Real offset, const Integer n ) const
+{
+    const Real sigma( this->getSigma() );
+    const Real a( this->geta() );
+    const Real interval( M_PI / ( a - sigma ) );// interval is the estimated distance to the next
+						// root
+
+    const Real target( offset + interval );	// the target root is the previous one plus the interval
+
+    Real low ( target - (0.4 * interval ) );	// the range is calculated very easily
+    Real high( target + (0.4 * interval ) );	// We are sure that there is only one root in the interval
+						// THE 0.4 IS VERY TRICKY!! NOT SURE IF THIS WORKS FOR ALL
+						// PARAMETER SETS!!
+    if (low <= 0)
+    {	low = EPSILON/L_TYPICAL;	// NEW to avoid the zero and negative values for the interval
+    }
+
+    f_alpha_aux_params params = { this, n, 0 };	// n is the summation index (the order of the Bessel
+						// functions used
+    gsl_function F = 
+	{
+	    reinterpret_cast<typeof(F.function)>
+	    ( &FirstPassagePairGreensFunction2D::f_alpha_aux_F ),
+	    &params 
+	};
+
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  // initialize the solver
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+
+    const Real alpha ( findRoot( F, solver, low, high,
+		 EPSILON/L_TYPICAL, EPSILON, "FirstPassagePairGreensFunction2D::alpha_i" ) );
+    gsl_root_fsolver_free( solver );
+
+    return alpha;
+}
+
+
+// Calculates the first root (called the offset) for summation index n (so using Bessel functions of order n)
+const Real
+FirstPassagePairGreensFunction2D::alphaOffset( const unsigned int n ) const
+{
+    if( this->alphaOffsetTable[n] > 0 )		// if the offset has already been calculated
+    {
+	return this->alphaOffsetTable[n];	// don't do all the work again
+    }
+    assert( this->alphaOffsetTable.size() >= n );	// assume the table is large enough to
+							// accomodate the requested index
+
+    const Real sigma( this->getSigma() );
+    const Real a( this->geta() );
+    const Real interval( M_PI_2 / ( a - sigma ));	// the x-axis of the function scales with a-sigma
+
+	Real offset (0);	// by default the offset is zero
+	if (n != 0)
+	{	offset = ( this->alphaOffsetTable[n-1] );
+	}						// The offsets only get bigger, the roots shift to
+							// the right with the order of the Bessel functions n
+
+    // Here we find the interval where the first positive root is in.
+    // We keep shifting the search window with the size of 'interval'
+    // 'interval' is half of Pi/(a - sigma) (the expected distance between the 'offsets'
+
+    Real low ( offset );		// the searching interval for the new offset is between the previous
+    Real high( offset + interval );	// one a interval further
+	if (low <= 0)			// NEW to make sure things don't get negative
+	{	low = EPSILON/L_TYPICAL;// we assume that the high value is never negative
+	}
+
+    Real f_low ( f_alpha(low,n) );	// get the values of the expression for the roots for these
+    Real f_high( f_alpha(high,n) );	// values of alpha (at the ends of the search range)
+
+    while( f_low * f_high > 0 )		// if the expression changes sign then there is a root in the range
+    {					// and we should exit the loop
+	low =  high;			// shift everything so we check out the next interval
+	f_low = f_high;			// just pass the value on
+
+	high += interval;
+	f_high = f_alpha( high, n );
+    }
+
+   // We now determined roughly the interval where the first root should be.
+   // Next we find the exact root in the interval.
+
+   f_alpha_aux_params params = { this, n, 0};
+   gsl_function F = 	{reinterpret_cast<typeof(F.function)>
+			( &FirstPassagePairGreensFunction2D::f_alpha_aux_F ),
+			&params
+			};
+
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  // initialize the solver
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+
+    offset = findRoot( F, solver, low, high, EPSILON/L_TYPICAL,	// find the intersection between the random
+                            EPSILON, "alphaOffset" );		// number and the cumm probability
+    gsl_root_fsolver_free( solver );
+
+    this->alphaOffsetTable[n] = offset;	// The offset found is now the first root
+    return offset;
+}
+
+
+// calculates the constant part of the i-th term for the survival probability
+const Real 
+FirstPassagePairGreensFunction2D::p_survival_i( const Real alpha,
+					      const Real r0 ) const
+{
+	const Real a( geta() );		// get the needed parameters
+	const Real sigma( getSigma() );
+        const Real h (this->geth());	// is this the correct one or do I need to use kf?
+
+	const Real s_An (sigma*alpha);
+	const Real a_An (a*alpha);
+	const Real r0An (r0*alpha);
+
+        const Real J0_aAn  (gsl_sf_bessel_J0(s_An));	// calculate all the required Bessel functions
+        const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
+        const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
+	const Real J1_bAn  (gsl_sf_bessel_J1(a_An));
+
+        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+        const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
+        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+
+	const Real Y1_bAn  (gsl_sf_bessel_Y1(a_An));
+	const Real Y1_aAn  (gsl_sf_bessel_Y1(s_An));
+
+	// calculate An,0
+        const Real alpha_sq (alpha*alpha);
+
+        const Real rho (h*J0_aAn + alpha*J1_aAn);
+        const Real rho_sq (rho*rho);
+
+        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+
+        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+
+	// calculate the integral over Bn,0
+	const Real B_n_0_int_tmp (Y0_bAn*( a*J1_bAn - sigma*J1_aAn ) - J0_bAn*( a*Y1_bAn - sigma*Y1_aAn ));
+	const Real B_n_0_int (B_n_0_int_tmp/alpha);
+
+	// return the total result
+	const Real result (A_i_0 * B_n_0_int);
+	return result;
+}
+
+// calculates the An,0 terms for determination of the flux through the outer interface
+const Real 
+FirstPassagePairGreensFunction2D::leavea_i( const Real alpha,
+					  const Real r0 ) const
+{
+        const Real a( geta() );         // get the needed parameters
+        const Real sigma( getSigma() );
+        const Real h (this->geth());    // is this the correct one or do I need to use kf?
+
+        const Real s_An (sigma*alpha);
+        const Real a_An (a*alpha);
+        const Real r0An (r0*alpha);
+
+        const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+        const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
+        const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
+
+        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+        const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
+        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+
+        // calculate An,0
+        const Real alpha_sq (alpha*alpha);
+
+        const Real rho (h*J0_aAn + alpha*J1_aAn);
+        const Real rho_sq (rho*rho);
+
+        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+
+        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+
+	return A_i_0;
+}
+
+// Calculates the n-th term of the summation for calculating the flux through the inner interface (reaction)
+const Real 
+FirstPassagePairGreensFunction2D::leaves_i( const Real alpha,
+					  const Real r0 ) const
+{
+        const Real a( geta() );         // get the needed parameters
+        const Real sigma( getSigma() );
+        const Real h (this->geth());    // is this the correct one or do I need to use kf?
+
+        const Real s_An (sigma*alpha);
+        const Real a_An (a*alpha);
+        const Real r0An (r0*alpha);
+
+        const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+        const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
+        const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
+
+        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+        const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
+        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+
+        const Real Y1_aAn  (gsl_sf_bessel_Y1(s_An));
+
+        // calculate An,0
+        const Real alpha_sq (alpha*alpha);
+
+        const Real rho (h*J0_aAn + alpha*J1_aAn);
+        const Real rho_sq (rho*rho);
+
+        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+
+        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0));
+
+	// calculate Bn,0(sigma, alpha)
+	const Real B_n_0_sigma (Y0_bAn * J1_aAn - J0_bAn * Y1_aAn);
+
+	// calculate the total result
+	const Real result ((alpha * A_i_0 * B_n_0_sigma)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+        return result;
+}
+
+
+// calculates a table with all the constant factors for the survival probability
+void 
+FirstPassagePairGreensFunction2D::createPsurvTable( RealVector& table,
+							const Real r0 ) const
+{
+    const RealVector& alphaTable_0( this->getAlphaTable( 0 ) );	// get the roots for the survival probability
+
+    table.clear();				// empty the table
+    table.reserve( alphaTable_0.size() );	// and get the nescessary memory
+
+    std::transform( alphaTable_0.begin(), alphaTable_0.end(),
+		    std::back_inserter( table ),
+		    boost::bind( &FirstPassagePairGreensFunction2D::p_survival_i,
+				 this, _1, r0 ) );	// This gets all the roots from 'begin' to 'end'
+							// passes them as an argument to p_survival_i and
+							// the result is passed to back_inserter
+}
+
+// Creates the tables with various Bessel functions used in drawR, the table is used to speed things up
+void
+FirstPassagePairGreensFunction2D::createY0J0Tables( RealVector& Y0_Table,
+							RealVector& J0_Table,
+							RealVector& Y0J1J0Y1_Table,
+							const Real r0,
+							const Real t ) const
+{
+	const RealVector& alphaTable_0( this->getAlphaTable( 0 ) );
+							// get the roots for the survival probability
+	Y0_Table.clear();				// empty the table
+	J0_Table.clear();
+	Y0J1J0Y1_Table.clear();
+
+	Y0_Table.reserve( alphaTable_0.size() );	// and get the nescessary memory
+	J0_Table.reserve( alphaTable_0.size() );
+	Y0J1J0Y1_Table.reserve( alphaTable_0.size() );
+
+	boost::tuple<Real,Real,Real> result;
+	
+	for (unsigned int count = 0; count < alphaTable_0.size(); count++)
+	{	result = Y0J0J1_constants(alphaTable_0[count], t, r0);
+		Y0_Table.push_back (result.get<0>());
+		J0_Table.push_back (result.get<1>());
+		Y0J1J0Y1_Table.push_back (result.get<2>());
+	}
+}
+
+
+// Creates the values for in the tables Y0, J0 and Y0J1J0Y1
+const boost::tuple<Real,Real,Real>
+FirstPassagePairGreensFunction2D::Y0J0J1_constants ( const Real alpha,
+							const Real t,
+							const Real r0) const
+{	const Real D(this->getD());
+	const Real h(this->geth());
+	const Real sigma(this->getSigma());
+	const Real a(this->geta());
+
+	const Real s_An (sigma*alpha);
+	const Real a_An (a*alpha);
+	const Real r0An (r0*alpha);
+
+	const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+	const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
+	const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
+
+	const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+	const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
+	const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+
+	const Real Y1_aAn  (gsl_sf_bessel_Y1(s_An));
+
+
+        // calculate An,0
+	const Real alpha_sq (alpha*alpha);
+	const Real rho (h*J0_aAn + alpha*J1_aAn);
+	const Real rho_sq (rho*rho);
+	const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+	const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+
+	// calculate the exponent with the time
+	const Real expT( std::exp(-D*alpha_sq*t));
+	// and the product
+	const Real Ai0_expT (A_i_0 * expT / alpha);
+
+	// calculate the large constant term in the intergral of Bn,0
+	const Real Y0J1_J0Y1 (Y0_bAn*sigma*J1_aAn - J0_bAn*sigma*Y1_aAn);
+
+	return boost::make_tuple (Ai0_expT*Y0_bAn, Ai0_expT*J0_bAn, Ai0_expT*Y0J1_J0Y1);
+}
+
+
+// calculates the ith term with exponent and time for the survival probability
+const Real 
+FirstPassagePairGreensFunction2D::p_survival_i_exp_table( const unsigned int i,
+							const Real t,
+							const Real r0,
+							const RealVector& table ) const
+{
+    const Real alpha( this->getAlpha0( i ) );
+    return std::exp( - getD() * t * alpha * alpha ) * table[i];
+}
+
+// adds the exponential with the time to the sum. Needed for the calculation of the flux throught the outer
+// interface
+const Real 
+FirstPassagePairGreensFunction2D::leavea_i_exp( const unsigned int i,
+					      const Real t,
+					      const Real r0 ) const
+{
+    const Real alpha( this->getAlpha0( i ) );
+    return std::exp( - getD() * t * alpha * alpha ) * leavea_i( alpha, r0 );
+}
+
+// adds the exponential with the time to the sum. Needed for the inner interface (reaction)
+const Real 
+FirstPassagePairGreensFunction2D::leaves_i_exp( const unsigned int i,
+					      const Real t,
+					      const Real r0 ) const
+{
+    const Real alpha( this->getAlpha0( i ) );
+
+    return std::exp( - getD() * t * alpha * alpha ) * leaves_i( alpha, r0 );
+}
+
+
+// calculates the Bossen function for a given r
+const Real
+FirstPassagePairGreensFunction2D::p_int_r_i_exp_table( const unsigned int i,
+				                     const Real r,
+                				     const RealVector& Y0_aAnTable,
+               					     const RealVector& J0_aAnTable,
+							const RealVector& Y0J1J0Y1Table ) const
+{
+	const Real alpha( this->getAlpha0( i ) );	// get the root An
+	const Real r_An( r*alpha);
+
+	const Real J1_rAn (gsl_sf_bessel_J1(r_An));
+	const Real Y1_rAn (gsl_sf_bessel_Y1(r_An));
+
+	const Real result (Y0_aAnTable[i]*r*J1_rAn - J0_aAnTable[i]*r*Y1_rAn - Y0J1J0Y1Table[i]);
+	return result;
+}
+
+
+// This tries to guess the maximum number of n iterations it needs for calculating the survival probability
+// Not really sure yet how this works
+
+const unsigned int
+FirstPassagePairGreensFunction2D::guess_maxi( const Real t ) const
+{
+    const unsigned int safety( 2 );
+
+    if( t >= INFINITY )
+    {
+        return safety;
+    }
+
+    const Real D( getD() );
+    const Real sigma( getSigma() );
+    const Real a( geta() );
+
+    const Real alpha0( getAlpha0( 0 ) );
+    const Real Dt( D * t );
+    const Real thr( ( exp( - Dt * alpha0 * alpha0 ) / alpha0 ) * this->EPSILON * 1e-1 );
+    const Real thrsq( thr * thr );
+
+    if( thrsq <= 0.0 )
+    {
+        return this->MAX_ALPHA_SEQ;
+    }
+
+    const Real max_alpha( 1.0 / ( sqrt( exp( gsl_sf_lambert_W0( 2 * Dt / thrsq ) ) * thrsq ) ) );
+    const unsigned int maxi( safety + static_cast<unsigned int>( max_alpha * ( a - sigma ) / M_PI ) );
+
+    return std::min( maxi, this->MAX_ALPHA_SEQ );
+}
+
+
+// Calculates the survival probability at a given time.
+// This is a little wrapper for the p_survival_table so that you can easily calculate the survival probability
+// at a given time
+const Real 
+FirstPassagePairGreensFunction2D::p_survival( const Real t,
+					    const Real r0 ) const
+{
+    RealVector psurvTable;
+
+    const Real p( p_survival_table( t, r0, psurvTable ) );
+
+    return p;
+}
+
+// This actually calculates the Survival probability at time t given the particle was at r0 at time 0
+// It uses the pSurvTable for efficiency (so you don't have to calculate all the constant factors all
+// the time)
+const Real 
+FirstPassagePairGreensFunction2D::p_survival_table( const Real t,
+						  const Real r0,
+		  				  RealVector& psurvTable ) const
+{
+	Real p;
+	const unsigned int maxi( guess_maxi( t ) );	// guess the maximum number of iterations required
+            
+        if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
+        {						// that the table is filled
+        	IGNORE_RETURN getAlpha0( maxi );	// this updates the table of roots
+                this->createPsurvTable( psurvTable, r0 );	// then the table is filled with data
+        }
+//std::cout << "p_survival_2DPair ";
+        p = funcSum_all( boost::bind( &FirstPassagePairGreensFunction2D::
+                                          p_survival_i_exp_table,
+                                          this,
+                                          _1, t, r0, psurvTable ),
+                         maxi );	// calculate the sum at time t
+
+        return p*M_PI*M_PI_2;
+}
+
+// calculates the flux leaving through the inner interface at a given moment
+// FIXME: This is inaccurate for small t's!!
+const Real 
+FirstPassagePairGreensFunction2D::leaves( const Real t,
+					const Real r0 ) const
+{
+    const Real sigma(this->getSigma());
+    const Real D(this->getD() );
+
+    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+                                        leaves_i_exp,
+                                        this,
+                                        _1, t, r0 ),
+                           this->MAX_ALPHA_SEQ ) );
+
+    return -M_PI_2*M_PI*D*sigma*p;	// The minus is there because the flux is in the negative r
+					// direction. The minus makes the flux always positive
+}
+
+// calculates the flux leaving through the outer interface at a given moment
+const Real 
+FirstPassagePairGreensFunction2D::leavea( const Real t,
+					const Real r0 ) const
+{
+    const Real D(this->getD() );
+
+    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+                                        leavea_i_exp,
+                                        this,
+                                        _1, t, r0 ),
+                           this->MAX_ALPHA_SEQ ) );
+    return M_PI*D*p;
+}
+
+
+// calculates the sum of the sequence for drawR based upon the values in the tables and r
+const Real
+FirstPassagePairGreensFunction2D::p_int_r_table( const Real r,
+               					const RealVector& Y0_aAnTable,
+               					const RealVector& J0_aAnTable,
+               					const RealVector& Y0J1J0Y1Table ) const
+{
+    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+                                        p_int_r_i_exp_table,
+                                        this,
+                                        _1, r, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table ),
+                           Y0_aAnTable.size() ) );
+    return p*M_PI*M_PI_2;
+}
+
+// Used by drawTime
+// Wrapper for p_survival_table for the interator to find the root for drawTime
+const Real
+FirstPassagePairGreensFunction2D::p_survival_table_F( const Real t,
+                    					const p_survival_table_params* params )
+{
+    const FirstPassagePairGreensFunction2D* const gf( params->gf ); // the current gf (not sure why this is
+								    // here)
+    const Real r0( params->r0 );
+    RealVector& table( params->table );		// table is empty but will be filled in p_survival_table
+    const Real rnd( params->rnd );
+
+    return rnd - gf->p_survival_table( t, r0, table );
+}
+
+
+// a wrapper to make p_int_r_table available to the iterator calculating the root
+const Real
+FirstPassagePairGreensFunction2D::p_int_r_F( const Real r,
+					   const p_int_r_params* params )
+{
+    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 
+    const RealVector& Y0_aAnTable( params->Y0_aAnTable );
+    const RealVector& J0_aAnTable( params->J0_aAnTable );
+    const RealVector& Y0J1J0Y1Table( params->Y0J1J0Y1Table );
+    const Real rnd( params->rnd );
+
+    return gf->p_int_r_table( r, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table) - rnd;
+}
+
+
+// Draws a first passage time, this could be an escape (through the outer boundary) or a reaction (through
+// the inner boundary)
+const Real FirstPassagePairGreensFunction2D::drawTime( const Real rnd, 
+						     const Real r0 ) const
+{
+    const Real D( this->getD() );
+    const Real sigma( this->getSigma() );
+    const Real a( this->geta() );
+    const Real kf( this->getkf() );
+
+    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
+    THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
+
+    Real dist;
+
+
+    if( r0 == a || a == sigma )		// when the particle is at the border or if the PD has no real size
+    {
+	return 0.0;
+    }
+
+    if ( kf == 0.0 )			// if there was only one absorbing boundary
+    {	
+        dist = a - r0;
+    }
+    else
+    {	
+        dist = std::min( a - r0, r0 - sigma );	// take the shortest distance to a boundary
+    }
+    Real t_guess = dist * dist / ( 4.0 * D );	// get some initial guess for the time, dr=sqrt(2dDt) with d
+						// the dimensionality (2 in this case)
+
+
+	const Real minT( std::min( sigma * sigma / D * this->MIN_T_FACTOR,
+                               t_guess * 1e-7 ) );	// something with determining the lowest possible t
+
+
+	RealVector psurvTable;		// this is still empty as of now->not used
+	p_survival_table_params params = { this, r0, psurvTable, rnd };
+	gsl_function F = 
+	{
+	    reinterpret_cast<typeof(F.function)>( &p_survival_table_F ),
+	    &params 
+	};
+
+	// put in a upper and lower limit (the picked time cannot be infinite!)
+	Real low( t_guess );	
+	Real high( t_guess );
+
+	// adjust high and low to make sure that f( low ) and f( high ) straddle.
+	Real value( GSL_FN_EVAL( &F, t_guess ) );
+
+	if( value < 0.0 )			// if the function is below zero at the guess the upper
+	{					// boundary should be moved (passed the zero point)
+		do
+		{
+			high *= 10;
+			value = GSL_FN_EVAL( &F, high );
+            
+			if( fabs( high ) >= 1e10 )	// if high time is way too high forget about it
+			{
+				std::cerr << "Couldn't adjust high. F(" << high <<
+					") = " << GSL_FN_EVAL( &F, high ) << "; r0 = " << r0 << 
+					", " << dump() << std::endl;
+				throw std::exception();
+			}
+		}
+		while ( value < 0.0 );
+	}
+	else				// if the function is over zero (or at zero!) then the lower
+	{					// boundary should be moved
+                Real value_prev( value );
+                do
+                {       low *= .1;      // keep decreasing the lower boundary until the function straddles
+                        value = GSL_FN_EVAL( &F, low );     // get the accompanying value
+
+                        if( fabs( low ) <= minT || fabs( value - value_prev ) < EPSILON*this->T_TYPICAL )
+                        {
+                                std::cerr << "Couldn't adjust low. F(" << low <<
+                                        ") = " << value << std::endl;
+                                return low;
+                        }
+                        value_prev = value;
+                }
+                while ( value >= 0.0 );
+    }
+
+    // find the intersection of the cummulative survival probability and the randomly generated number
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );	// initialize the solver
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+
+    const Real t( findRoot( F, solver, low, high,		// find the intersection between the random
+		EPSILON*T_TYPICAL, EPSILON, "FirstPassagePairGreensFunction2D::drawTime" ) );
+								// number and the cumm probability
+    gsl_root_fsolver_free( solver );
+
+    return t;
+}
+
+// This determines based on the flux at a certain time, if the 'escape' was a reaction or a proper escape
+const EventType
+FirstPassagePairGreensFunction2D::drawEventType( const Real rnd, 
+					       const Real r0,
+					       const Real t ) const
+{
+    const Real D( this->getD() );
+    const Real sigma( this->getSigma() );
+    const Real kf( this->getkf() );
+    const Real a( this->geta() );
+
+    THROW_UNLESS( std::invalid_argument, 0 <= rnd && rnd < 1.0 );
+    THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 < a );
+    THROW_UNLESS( std::invalid_argument, t > 0.0 );
+
+    if( kf == 0.0 )	// if there cannot be any flow through the radiating boundary it is always an escape
+    {
+        return ESCAPE;
+    }
+    
+    // First, check if r0 is close only either to a or sigma relative
+    // to Dt.  In such cases, the event type is always ESCAPE or REACTION,
+    // respectively.   This avoids numerical instability in calculating
+    // leavea() and/or leaves().
+
+    // Here, use a rather large threshold for safety.
+    const unsigned int H( 6 ); 				// 6 times the msd travelled as threshold
+    const Real max_dist( H * sqrt( 4.0 * D * t ) );
+    const Real a_dist( a - r0 );
+    const Real s_dist( r0 - sigma );
+
+
+    if( a_dist > max_dist )
+    {
+        if( s_dist < max_dist )
+        {
+            return REACTION;
+        }
+    }
+    else // a_dist < max_dist
+    {
+        if( s_dist > max_dist )
+        {
+            return ESCAPE;
+        }
+    }
+
+    const Real reaction( leaves( t, r0 ) );	// flux through rad boundary
+    const Real escape( leavea( t, r0 ) );	// flux through abs boundary
+    const Real value( reaction / ( reaction + escape ) );
+
+    if( rnd <= value )  
+    {
+	return REACTION;   // leaves -> return 0
+    }
+    else 
+    {
+	return ESCAPE;     // leavea -> return 1
+    }
+}
+
+// This draws a radius R at a given time, provided that the particle was at r0 at t=0
+const Real FirstPassagePairGreensFunction2D::drawR( const Real rnd, 
+						  const Real r0, 
+						  const Real t ) const
+{
+    const Real D( this->getD() );
+    const Real sigma( getSigma() );
+    const Real a( this->geta() );
+
+    THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
+    THROW_UNLESS( std::invalid_argument, r0 >= sigma && r0 < a );
+
+    if( t == 0.0 )		// if no time has passed
+    {
+	return r0;
+    }
+
+    const Real psurv( p_survival( t, r0 ) );	// calculate the survival probability at this time
+						// this is used as the normalization factor
+						// BEWARE!!! This also produces the roots An and therefore
+						// SETS THE HIGHEST INDEX -> side effect
+						// VERY BAD PROGRAMMING PRACTICE!!
+
+    RealVector Y0_aAnTable;
+    RealVector J0_aAnTable;
+    RealVector Y0J1J0Y1Table;
+    createY0J0Tables( Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, r0, t);
+
+    p_int_r_params params = { this, t, r0, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, rnd * psurv };
+
+    gsl_function F = 
+	{
+	    reinterpret_cast<typeof(F.function)>( &p_int_r_F ),
+	    &params 
+	};
+
+    // adjust low and high starting from r0.
+    // this is necessary to avoid root finding in the long tails where
+    // numerics can be unstable.
+    Real low( r0 );				// start with the initial position as the first guess
+    Real high( r0 );
+    Real value (0);
+    unsigned int H( 3 );
+
+    const Real msd( sqrt( 4.0 * D * t ) );
+    if( GSL_FN_EVAL( &F, r0 ) < 0.0 )
+    {
+	do
+        {
+            high = r0 + H * msd;
+            if( high > a )
+            {
+                if( GSL_FN_EVAL( &F, a ) < 0.0 )	// something is very wrong, this should never happen
+                {
+                    printf( "drawR: p_int_r_table( a ) < 0.0. returning a.\n" );
+                    return a;
+                }
+                high = a;
+                break;
+            }
+            value = GSL_FN_EVAL( &F, high );
+            ++H;
+        }
+	while (value < 0.0);
+
+    }
+    else
+    {
+	do
+        {
+            low = r0 - H * msd;
+            if( low < sigma )
+            {
+                if( GSL_FN_EVAL( &F, sigma ) > 0.0 )
+                {
+                    printf( "drawR: p_int_r_table( sigma ) > 0.0. "
+                            "returning sigma.\n" );
+                    return sigma;
+                }
+
+                low = sigma;
+                break;
+            }
+
+            value = GSL_FN_EVAL( &F, low );
+            ++H;
+        }
+	while ( value > 0.0 );
+    }
+
+
+    // root finding by iteration.
+
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+    const Real r( findRoot( F, solver, low, high,		// find the intersection between the random
+		 L_TYPICAL*EPSILON, EPSILON, "FirstPassagePairGreensFunction2D::drawR" ) );
+								// number and the cumm probability
+    gsl_root_fsolver_free( solver );
+
+    return r;
+}
+
+
+
+// The calculates constant factor m,n for the drawing of theta. These factors are summed later.
+const Real FirstPassagePairGreensFunction2D::p_m_alpha( const unsigned int n,
+						      const unsigned int m,
+						      const Real r,
+						      const Real r0, 
+						      const Real t ) const
+{
+	const Real sigma( this->getSigma() );
+	const Real h( this->geth() );
+	const Real a( this->geta() );
+	const Real D( this->getD() );
+	const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
+
+
+	const Real alpha_sq( alpha * alpha );
+	const Real realm( static_cast<Real>( m ) );
+	const Real msq( realm * realm);
+	const Real ssq( sigma * sigma);
+
+	const Real s_Anm (sigma*alpha);
+	const Real a_Anm (a*alpha);
+	const Real r0Anm (r0*alpha);
+	const Real r_Anm (r*alpha);
+
+	// calculate the needed bessel functions
+	const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
+	const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));	// prime
+	const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
+	const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
+
+	const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
+	const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
+
+	const Real Jm_rAnm   (gsl_sf_bessel_Jn(m, r_Anm));
+	const Real Ym_rAnm   (gsl_sf_bessel_Yn(m, r_Anm));
+
+
+	// calculating An,m
+	const Real h_ma (h - realm/sigma);
+	const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
+	const Real rho_sq (rho*rho);
+	// calculating Bn,m(r')
+	const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
+
+	const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - Jm_aAnm*Jm_aAnm*(h*h + alpha_sq - msq/ssq)));
+
+
+	// calculating Bn,m(r*)
+	const Real B_n_m_r (Jm_rAnm * Ym_aAnm  -  Ym_rAnm * Jm_aAnm);
+
+
+	// calculating the result
+	const Real result( A_n_m * B_n_m_r * exp(-D*alpha_sq*t) );
+
+	return result;
+}
+
+
+// This calculates the m-th constant factor for the drawTheta method. 
+const Real 
+FirstPassagePairGreensFunction2D::p_m( const Integer m,
+				     const Real r,
+				     const Real r0, 
+				     const Real t ) const
+{
+    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+					p_m_alpha,
+					this,
+					_1, m, r, r0, t ),	// The m-th factor is a summation over n
+			   MAX_ALPHA_SEQ, EPSILON ) );
+    return p;
+}
+
+// this should make the table of constants used in the iteration for finding the root for drawTheta
+// The index of the array is consistent with the index of the summation
+void
+FirstPassagePairGreensFunction2D::makep_mTable( RealVector& p_mTable,
+					      const Real r, 
+					      const Real r0, 
+					      const Real t ) const
+{
+	p_mTable.clear();
+
+	const Real p_0 ( this->p_m( 0, r, r0, t ) );	// This is the p_m where m is 0, for the denominator
+	p_mTable.push_back( p_0 );			// put it in the table
+
+
+	const Real p_1 ( this->p_m( 1, r, r0, t ) / p_0 );
+	p_mTable.push_back( p_1 );			// put the first result in the table
+
+
+	if( p_1 == 0 )
+	{
+		return;					// apparantly all the terms are zero? We are finished
+	}
+
+	const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error
+
+	Real p_m_abs (fabs (p_1));
+	Real p_m_prev_abs;	
+	unsigned int m( 1 );
+	do
+	{
+		m++;
+		if( m >= this->MAX_ORDER )		// If the number of terms is too large
+		{
+			std::cerr << "p_m didn't converge (m=" << m << "), continuing..." << std::endl;
+			break;
+		}
+
+
+		p_m_prev_abs = p_m_abs;					// store the previous term
+		const Real p_m( this->p_m( m, r, r0, t ) / p_0 );	// get the next term
+
+		if( ! std::isfinite( p_m ) )		// if the calculated value is not valid->exit
+		{
+			std::cerr << "makep_mTable: invalid value; " <<
+				p_m << "( m= " << m << ")." << std::endl;
+			break;
+		}
+
+		p_mTable.push_back( p_m );				// put the result in the table
+		p_m_abs = fabs( p_m );					// take the absolute value
+        }
+	while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
+	// truncate when converged enough.
+	// if the current term is smaller than threshold
+	// AND the previous term is also smaller than threshold
+	// AND the current term is smaller than the previous
+}
+
+// This method calculates the constants for the drawTheta method when the particle is at the boundary
+const Real 
+FirstPassagePairGreensFunction2D::dp_m_alpha_at_a( const unsigned int n,
+						 const unsigned int m,
+						 const Real r0, 
+						 const Real t ) const
+{
+        const Real sigma( this->getSigma() );
+        const Real h( this->geth() );
+        const Real a( this->geta() );
+        const Real D( this->getD() );
+
+        const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
+
+        const Real alpha_sq( alpha * alpha );
+        const Real realm( static_cast<Real>( m ) );
+        const Real msq( realm * realm);
+        const Real ssq( sigma * sigma);
+
+        const Real s_Anm (sigma*alpha);
+        const Real a_Anm (a*alpha);
+        const Real r0Anm (r0*alpha);
+
+        // calculate the needed bessel functions
+        const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
+        const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    // prime
+        const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
+        const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
+
+        const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
+        const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
+
+        // calculating An,m
+        const Real h_ma (h - realm/sigma);
+        const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
+        const Real rho_sq (rho*rho);
+        // calculating Bn,m(r')
+        const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
+
+        const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - Jm_aAnm*Jm_aAnm*(h*h + alpha_sq - msq/ssq)));
+
+        // calculating the result
+        const Real result( A_n_m * exp(-D*alpha_sq*t) );
+	return result;
+}
+
+// Makes the sum over n for order m for the constants for the drawtheta Method
+const Real 
+FirstPassagePairGreensFunction2D::dp_m_at_a( const Integer m,
+					   const Real r0, 
+					   const Real t ) const
+{
+    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+					dp_m_alpha_at_a,
+					this,
+					_1, m, r0, t ),
+			   MAX_ALPHA_SEQ, EPSILON ) );
+
+    return p;
+}
+
+// creates a tables of constants for drawTheta when the particle is at the edge of the domain
+void
+FirstPassagePairGreensFunction2D::makedp_m_at_aTable( RealVector& p_mTable,
+						    const Real r0, 
+						    const Real t ) const
+{
+        p_mTable.clear();
+
+        const Real p_0 ( this->dp_m_at_a( 0, r0, t ) );	// This is the p_m where m is 0, for the denominator
+        p_mTable.push_back( p_0 );                      // put it in the table
+
+
+        const Real p_1 ( this->dp_m_at_a( 1, r0, t ) / p_0 );
+        p_mTable.push_back( p_1 );                      // put the first result in the table
+
+
+        if( p_1 == 0 )
+        {
+                return;                 // apparantly all the terms are zero? We are finished
+        }
+
+        const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error
+
+	Real p_m_abs (fabs (p_1));
+        Real p_m_prev_abs;      
+        unsigned int m( 1 );
+        do
+        {
+                m++;
+                if( m >= this->MAX_ORDER )				// If the number of terms is too large
+                {
+                        std::cerr << "dp_m didn't converge (m=" << m << "), continuing..." << std::endl;
+                        break;
+                }
+
+
+                p_m_prev_abs = p_m_abs;					// store the previous term
+                const Real p_m( this->dp_m_at_a( m, r0, t ) / p_0 );	// get the next term
+
+                if( ! std::isfinite( p_m ) )			// if the calculated value is not valid->exit
+                {
+                        std::cerr << "makedp_m_at_aTable: invalid value; " <<
+                                p_m << "( m= " << m << ")." << std::endl;
+                        break;
+                }
+
+                p_mTable.push_back( p_m );                              // put the result in the table
+                p_m_abs = fabs( p_m );                                  // take the absolute value
+        }
+        while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
+        // truncate when converged enough.
+        // if the current term is smaller than threshold
+        // AND the previous term is also smaller than threshold
+        // AND the current term is smaller than the previous
+
+}
+
+// This calculates the m-th term of the summation for the drawTheta calculation
+const Real 
+FirstPassagePairGreensFunction2D::ip_theta_n( const unsigned int m,
+						const Real theta,
+						const RealVector& p_nTable) const
+{
+	const unsigned int m_p1 (m+1);
+        return p_nTable[m_p1] * sin (m_p1*theta)/m_p1;
+}
+
+
+// calculates the cummulative probability of finding the particle at a certain theta
+// It is used by the drawTheta method
+// It uses the p_nTable for it to speed things up
+const Real 
+FirstPassagePairGreensFunction2D::ip_theta_table( const Real theta,
+						const RealVector& p_nTable ) const
+{
+    const unsigned int maxm( p_nTable.size()-1 );	// get the length of the sum
+							// it is shifted one because the first entry should
+							// be used (m=0)
+
+    const Real p( funcSum_all( boost::bind( &FirstPassagePairGreensFunction2D::
+                                             ip_theta_n,
+                                             this,
+                                             _1, theta, p_nTable ),
+                                maxm ) );
+    return p;
+}
+
+// function to iterate when drawing the theta
+const Real
+FirstPassagePairGreensFunction2D::ip_theta_F( const Real theta,
+					    const ip_theta_params* params )
+{
+    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 
+    const RealVector& p_nTable( params->p_nTable );	// table with useful constants
+    const Real value( params->value );
+
+    return theta/(M_PI*2) + (gf->ip_theta_table( theta, p_nTable )/M_PI) - value;
+}
+
+
+// This method draws a theta given a certain r and time (and intial condition of course)
+const Real 
+FirstPassagePairGreensFunction2D::drawTheta( const Real rnd,
+					   const Real r, 
+					   const Real r0, 
+					   const Real t ) const
+{
+	const Real sigma( this->getSigma() );
+	const Real a( this->geta() );
+	const Real D( this->getD() );
+
+	// input parameter range checks.
+	THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
+	THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
+	THROW_UNLESS( std::invalid_argument, sigma <= r && r <= a);
+	THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
+	// t == 0 means no move.
+	if( t <= T_TYPICAL*EPSILON || D == 0 || fabs(r0 - a) <= EPSILON*L_TYPICAL || rnd <= EPSILON)
+	{
+		return 0.0;
+	}
+	else if (r == sigma)	// a reaction has occured, the angle is irrelevant
+	{
+		return 0.0;
+	}
+
+	// making the tables with constants
+	RealVector p_mTable;			// a table with constants to make calculations much faster
+	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
+	{
+		makedp_m_at_aTable( p_mTable, r0, t );	// making the table if particle on the outer boundary
+	}
+	else
+	{
+		makep_mTable( p_mTable, r, r0, t );	// making the table of constants for the regular case
+	}
+
+
+	// preparing the function
+	ip_theta_params params = { this, r, r0, t, p_mTable, rnd*0.5 };	// r, r0, t are not required
+	gsl_function F = 
+	{
+	    reinterpret_cast<typeof(F.function)>( &ip_theta_F ),
+	    &params 
+	};
+
+	// finding the root
+	const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+	gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+	const Real theta( findRoot( F, solver, 0, M_PI, EPSILON, EPSILON,
+                "FirstPassagePairGreensFunction2D::drawTheta" ) );
+	gsl_root_fsolver_free( solver );
+
+	return theta;
+}
+
+
+//
+// debug
+//
+
+const std::string FirstPassagePairGreensFunction2D::dump() const
+{
+    std::ostringstream ss;
+    ss << "D = " << this->getD() << ", sigma = " << this->getSigma() <<
+	", a = " << this->geta() <<
+	", kf = " << this->getkf() <<
+	", h = " << this->geth() << std::endl;
+    return ss.str();
+}    
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
new file mode 100644
index 00000000..cb45862f
--- /dev/null
+++ b/GreensFunction2DRadAbs.hpp
@@ -0,0 +1,316 @@
+#if !defined( __FIRSTPASSAGEPAIRGREENSFUNCTION2D_HPP )
+#define __FIRSTPASSAGEPAIRGREENSFUNCTION2D_HPP 
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/function.hpp>
+#include <boost/array.hpp>
+
+#include <gsl/gsl_roots.h>
+
+#include "PairGreensFunction.hpp"
+
+
+class FirstPassagePairGreensFunction2D
+    :
+    public PairGreensFunction
+{
+
+    // Error tolerance used by default.
+    static const Real TOLERANCE = 1e-8;
+
+    // SphericalBesselGenerator's accuracy, used by some
+    // theta-related calculations.
+
+    static const Real MIN_T_FACTOR = 1e-8;
+
+    static const Real L_TYPICAL = 1E-7;
+    static const Real T_TYPICAL = 1E-5;
+    static const Real EPSILON = 1E-12;
+
+    static const unsigned int MAX_ORDER = 30;		// The maximum number of m terms
+    static const unsigned int MAX_ALPHA_SEQ = 2000;	// The maximum number of n terms
+
+public:
+    
+    FirstPassagePairGreensFunction2D( const Real D, 
+				    const Real kf, 
+				    const Real Sigma );
+    
+    virtual ~FirstPassagePairGreensFunction2D();
+
+    const Real geth() const
+    {
+	return this->h;
+    }
+
+    const Real geta() const
+    {
+	return this->a;
+    }
+
+    void seta( const Real a );    
+
+    const Real drawTime( const Real rnd, const Real r0 ) const;
+
+    const EventType drawEventType( const Real rnd, 
+				   const Real r0, 
+				   const Real t ) const;
+    
+    const Real drawR( const Real rnd, 
+		      const Real r0, 
+		      const Real t ) const;
+    
+    const Real drawTheta( const Real rnd,
+			  const Real r, 
+			  const Real r0, 
+			  const Real t ) const;
+    
+    
+    const Real f_alpha0( const Real alpha ) const;
+  
+    const Real f_alpha( const Real alpha, const Integer n ) const;
+
+    
+    const Real p_survival( const Real t,
+			   const Real r0 ) const;
+
+    const Real p_survival_table( const Real t,
+				 const Real r0,
+				 RealVector& table ) const;
+
+
+    const Real leaves( const Real t,
+		       const Real r0 ) const;
+
+    const Real leavea( const Real t,
+		       const Real r0 ) const;
+
+    const Real p_m( const Integer n, const Real r, 
+		    const Real r0, const Real t ) const;
+
+    const Real dp_m_at_a( const Integer m, const Real r0, const Real t ) const;
+
+
+    const Real p_m_alpha( const unsigned int n,
+			  const unsigned int m,
+			  const Real r, 
+			  const Real r0,
+			  const Real t ) const;
+
+    const Real dp_m_alpha_at_a( const unsigned int n,
+				const unsigned int m,
+				const Real r0,
+				const Real t ) const;
+
+    // methods below are kept public for debugging purpose.
+
+    const std::string dump() const;
+
+    const Real alphaOffset( const unsigned int n ) const;
+
+    const Real alpha0_i( const Real previous ) const;
+
+    const Real alpha_i( const Real offset, const Integer n ) const;
+
+    const Real p_survival_i( const Real alpha,
+			     const Real r0 ) const;
+
+    const Real leavea_i( const Real alpha,
+			 const Real r0 ) const;
+
+    const Real leaves_i( const Real alpha,
+			 const Real r0 ) const;
+
+    const boost::tuple<Real,Real,Real> Y0J0J1_constants ( const Real alpha,
+                                                          const Real t,
+                                                          const Real r0) const;
+
+    const Real getAlpha( const size_t n, const RealVector::size_type i ) const
+    {
+	RealVector& alphaTable( this->alphaTable[n] );		// get the ref to the roots of order n
+        const RealVector::size_type oldSize( alphaTable.size() );	// get it's size
+
+	if( i >= oldSize )
+	{
+	    alphaTable.resize( i+1, 0 );	// resize the vector and fill the empty slots with 0
+	}
+
+	if (alphaTable[i] == 0)		// if the requested root was not calculated yet
+	{
+		if (i==0)		// if the requested root is the first one
+		{	const Real offset (alphaOffset(n));	// The offset is the first root
+			alphaTable[i]= offset;
+		}
+		else			// the requested root is dependent on the previous one
+		{
+			const Real previous (getAlpha(n, i-1));		// get the previous root
+			alphaTable[i] = this->alpha_i( previous , n );	// find the requested root based on
+									// the previous one
+		}
+	}
+	return alphaTable[i];
+
+    }
+
+    const Real getAlpha0( const RealVector::size_type i ) const
+    {
+	RealVector& alphaTable( this->alphaTable[0] );
+        const RealVector::size_type oldSize( alphaTable.size() );
+
+	if( i >= oldSize )
+	{
+	    alphaTable.resize( i+1, 0 );// fill the empty spaces with zeros
+	}
+
+	if (alphaTable[i] == 0)         // if the requested root was not calculated yet
+	{
+                if (i==0)               // if the requested root is the first one
+                {       const Real offset (alphaOffset(0));     // The offset is the first root
+                        alphaTable[i]= offset;
+                }
+                else                    // the requested root is dependent on the previous one
+                {
+                        const Real previous (getAlpha0(i-1));		// get the previous root
+                        alphaTable[i] = this->alpha0_i( previous );	// find the requested root based on
+                                                                        // the previous one
+                }
+	}
+
+	return alphaTable[i];
+    }
+
+protected:
+
+    void clearAlphaTable() const;
+
+
+    RealVector& getAlphaTable( const size_t n ) const
+    {
+	return this->alphaTable[n];
+    }
+
+    const Real p_int_r_table( const Real r,
+				const RealVector& Y0_aAnTable,
+				const RealVector& J0_aAnTable,
+				const RealVector& Y0J1J0Y1Table ) const;
+
+    const Real ip_theta_table( const Real theta,
+			       const RealVector& p_nTable ) const;
+
+    const Real p_survival_i_exp_table( const unsigned int i,
+				       const Real t,
+				       const Real r0,
+				       const RealVector& table ) const;
+
+    const Real leavea_i_exp( const unsigned int i,
+			     const Real alpha,
+			     const Real r0 ) const;
+
+    const Real leaves_i_exp( const unsigned int i,
+			     const Real alpha,
+			     const Real r0 ) const;
+
+    const Real ip_theta_n( const unsigned int m,
+			   const Real theta,
+			   const RealVector& p_nTable ) const;
+
+
+    const Real p_int_r_i_exp_table( const unsigned int i,
+					const Real r,
+					const RealVector& Y0_aAnTable,
+					const RealVector& J0_aAnTable,
+					const RealVector& Y0J1J0Y1Table ) const;
+
+    void createPsurvTable( RealVector& table, const Real r0 ) const; 
+
+    void createY0J0Tables( RealVector& Y0_Table, RealVector& J0_Table, RealVector& Y0J1J0Y1_Table,
+				const Real r0, const Real t ) const;
+
+    void makep_mTable( RealVector& p_mTable,
+		       const Real r, 
+		       const Real r0, 
+		       const Real t ) const;
+    
+    void makedp_m_at_aTable( RealVector& p_mTable,
+			     const Real r0, 
+			     const Real t ) const;
+
+    const unsigned int guess_maxi( const Real t ) const;
+
+    struct f_alpha0_aux_params
+    { 
+	const FirstPassagePairGreensFunction2D* const gf;
+	const Real value;
+    };
+
+    static const Real 
+    f_alpha0_aux_F( const Real alpha,
+		    const f_alpha0_aux_params* const params );
+
+
+    struct f_alpha_aux_params
+    { 
+	const FirstPassagePairGreensFunction2D* const gf;
+	const Integer n;
+	Real value;
+    };
+
+    static const Real 
+    f_alpha_aux_F( const Real alpha,
+		   const f_alpha_aux_params* const params );
+
+    struct p_survival_table_params
+    { 
+	const FirstPassagePairGreensFunction2D* const gf;
+	const Real r0;
+	RealVector& table;
+	const Real rnd;
+    };
+
+    static const Real 
+    p_survival_table_F( const Real t,
+                        const p_survival_table_params* const params );
+
+    struct p_int_r_params
+    { 
+	const FirstPassagePairGreensFunction2D* const gf;
+	const Real t;
+	const Real r0;
+	const RealVector& Y0_aAnTable;
+	const RealVector& J0_aAnTable;
+	const RealVector& Y0J1J0Y1Table;
+	const Real rnd;
+    };
+
+    static const Real 
+    p_int_r_F( const Real r,
+	       const p_int_r_params* const params );
+
+    struct ip_theta_params
+    { 
+	const FirstPassagePairGreensFunction2D* const gf;
+	const Real r;
+	const Real r0;
+	const Real t;
+	const RealVector& p_nTable;
+	const Real value;
+    };
+
+    static const Real 
+    ip_theta_F( const Real theta,
+		const ip_theta_params* const params );
+
+private:
+    
+    const Real h;
+
+    mutable boost::array<Real,MAX_ORDER+1> alphaOffsetTable;
+    mutable boost::array<RealVector,MAX_ORDER+1> alphaTable;
+
+    Real a;
+
+};
+
+
+
+#endif // __FIRSTPASSAGEPAIRGREENSFUNCTION2D_HPP

From b800b7cac1ef53378dd9354e19de20a2326fe4c5 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 25 Jul 2011 20:02:18 +0200
Subject: [PATCH 0091/1541] First version with 2D GFs in place. Only need to
 adapt automake files and checks.

---
 GreensFunction2DAbsSym.cpp |  30 ++---
 GreensFunction2DAbsSym.hpp |  20 ++--
 GreensFunction2DRadAbs.cpp | 218 +++++++++++++++----------------------
 GreensFunction2DRadAbs.hpp |  77 +++++--------
 greens_functions.cpp       |  43 +++++++-
 pair.py                    |   7 +-
 single.py                  |   4 +-
 7 files changed, 186 insertions(+), 213 deletions(-)

diff --git a/GreensFunction2DAbsSym.cpp b/GreensFunction2DAbsSym.cpp
index 739b1d2f..1bbca5bd 100644
--- a/GreensFunction2DAbsSym.cpp
+++ b/GreensFunction2DAbsSym.cpp
@@ -15,14 +15,14 @@
 
 #include "findRoot.hpp"
 
-#include "FirstPassageGreensFunction2D.hpp"
+#include "GreensFunction2DAbsSym.hpp"
 
 
 
 
 // an alternative form, which is not very convergent.
 const Real 
-FirstPassageGreensFunction2D::p_survival( const Real t ) const
+GreensFunction2DAbsSym::p_survival( const Real t ) const
 {
     const Real D( getD() );
     const Real a( geta() );
@@ -61,7 +61,7 @@ FirstPassageGreensFunction2D::p_survival( const Real t ) const
 
 
 const Real 
-FirstPassageGreensFunction2D::p_int_r_free( const Real r, const Real t ) const
+GreensFunction2DAbsSym::p_int_r_free( const Real r, const Real t ) const
 {
     const Real D( getD() );
     const Real Dt( D * t );
@@ -73,7 +73,7 @@ FirstPassageGreensFunction2D::p_int_r_free( const Real r, const Real t ) const
 }
 
 const Real 
-FirstPassageGreensFunction2D::p_int_r( const Real r, 
+GreensFunction2DAbsSym::p_int_r( const Real r, 
                                      const Real t ) const
 {
     const Real a( geta() );
@@ -111,10 +111,10 @@ FirstPassageGreensFunction2D::p_int_r( const Real r,
 
 
 const Real
-FirstPassageGreensFunction2D::p_survival_F( const Real t,
+GreensFunction2DAbsSym::p_survival_F( const Real t,
 					  const p_survival_params* params )
 {
-    const FirstPassageGreensFunction2D* const gf( params->gf ); 
+    const GreensFunction2DAbsSym* const gf( params->gf ); 
     const Real rnd( params->rnd );
 
     return 1 - gf->p_survival( t ) - rnd;
@@ -123,7 +123,7 @@ FirstPassageGreensFunction2D::p_survival_F( const Real t,
 
 
 const Real 
-FirstPassageGreensFunction2D::drawTime( const Real rnd ) const
+GreensFunction2DAbsSym::drawTime( const Real rnd ) const
 {
 	THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
 
@@ -193,17 +193,17 @@ FirstPassageGreensFunction2D::drawTime( const Real rnd ) const
 	const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );	// a new solver type brent
 	gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );	// make a new solver instance
 	const Real t( findRoot( F, solver, low, high, 1e-18, 1e-12,
-                            "FirstPassageGreensFunction2D::drawTime" ) );
+                            "GreensFunction2DAbsSym::drawTime" ) );
 	gsl_root_fsolver_free( solver );
 
 	return t;
 }
 
 const Real
-FirstPassageGreensFunction2D::p_r_free_F( const Real r,
+GreensFunction2DAbsSym::p_r_free_F( const Real r,
                                         const p_r_params* params )
 {
-    const FirstPassageGreensFunction2D* const gf( params->gf ); 
+    const GreensFunction2DAbsSym* const gf( params->gf ); 
     const Real t( params->t );
     const Real target( params->target );
 
@@ -212,10 +212,10 @@ FirstPassageGreensFunction2D::p_r_free_F( const Real r,
 
 
 const Real
-FirstPassageGreensFunction2D::p_r_F( const Real r,
+GreensFunction2DAbsSym::p_r_F( const Real r,
 				   const p_r_params* params )
 {
-    const FirstPassageGreensFunction2D* const gf( params->gf ); 
+    const GreensFunction2DAbsSym* const gf( params->gf ); 
     const Real t( params->t );
     const Real target( params->target );
 
@@ -225,7 +225,7 @@ FirstPassageGreensFunction2D::p_r_F( const Real r,
 
 
 const Real 
-FirstPassageGreensFunction2D::drawR( const Real rnd, const Real t ) const 
+GreensFunction2DAbsSym::drawR( const Real rnd, const Real t ) const 
 {
     THROW_UNLESS( std::invalid_argument, rnd <= 1.0 && rnd >= 0.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
@@ -282,7 +282,7 @@ FirstPassageGreensFunction2D::drawR( const Real rnd, const Real t ) const
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
     const Real r( findRoot( F, solver, low, high, 1e-18, 1e-12,
-                            "FirstPassageGreensFunction2D::drawR" ) );
+                            "GreensFunction2DAbsSym::drawR" ) );
   
     gsl_root_fsolver_free( solver );
 
@@ -291,7 +291,7 @@ FirstPassageGreensFunction2D::drawR( const Real rnd, const Real t ) const
 
 
 
-const std::string FirstPassageGreensFunction2D::dump() const
+const std::string GreensFunction2DAbsSym::dump() const
 {
     std::ostringstream ss;
     ss << "D = " << this->getD() << ", a = " << this->geta() << std::endl;
diff --git a/GreensFunction2DAbsSym.hpp b/GreensFunction2DAbsSym.hpp
index cec3417c..ce750349 100644
--- a/GreensFunction2DAbsSym.hpp
+++ b/GreensFunction2DAbsSym.hpp
@@ -7,20 +7,20 @@
 #include "Defs.hpp"
 
 
-class FirstPassageGreensFunction2D
+class GreensFunction2DAbsSym
 {
 
 public:
 
-    FirstPassageGreensFunction2D( const Real D )
+    GreensFunction2DAbsSym( const Real D, const Real a )
 	:
 	D( D ),
-        a( 0.0 )
+        a( a )
     {
 	;
     }
 
-    virtual ~FirstPassageGreensFunction2D()
+    virtual ~GreensFunction2DAbsSym()
     {
 	;
     }
@@ -30,12 +30,6 @@ class FirstPassageGreensFunction2D
 	return this->D;
     }
 
-    void seta( const Real a )
-    {
-        THROW_UNLESS( std::invalid_argument, a >= 0.0 );
-        this->a = a;
-    }
-
     const Real geta() const
     {
         return this->a;
@@ -57,7 +51,7 @@ class FirstPassageGreensFunction2D
 
     struct p_survival_params
     {
-	const FirstPassageGreensFunction2D* const gf;
+	const GreensFunction2DAbsSym* const gf;
 	const Real rnd;
     };
 
@@ -66,7 +60,7 @@ class FirstPassageGreensFunction2D
 
     struct p_r_params
     {
-	const FirstPassageGreensFunction2D* const gf;
+	const GreensFunction2DAbsSym* const gf;
 	const Real t;
 	const Real target;
     };
@@ -88,7 +82,7 @@ class FirstPassageGreensFunction2D
 
     const Real D;
 
-    Real a;
+    const Real a;
 };
 
 
diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index afa96ca4..3efa219a 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -23,49 +23,34 @@
 
 #include "FirstPassagePairGreensFunction2D.hpp"
 
-const Real FirstPassagePairGreensFunction2D::MIN_T_FACTOR;
-const unsigned int FirstPassagePairGreensFunction2D::MAX_ORDER;
-const unsigned int FirstPassagePairGreensFunction2D::MAX_ALPHA_SEQ;
+const Real GreensFunction2DRadAbs::MIN_T_FACTOR;
+const unsigned int GreensFunction2DRadAbs::MAX_ORDER;
+const unsigned int GreensFunction2DRadAbs::MAX_ALPHA_SEQ;
 
 
 // This is the constructor
-FirstPassagePairGreensFunction2D::
-FirstPassagePairGreensFunction2D( const Real D, 
+GreensFunction2DRadAbs::
+GreensFunction2DRadAbs( const Real D, 
 				const Real kf, 
 				const Real Sigma )
     :
     PairGreensFunction( D, kf, Sigma ),
     h( kf / D ),
-    a( INFINITY )
+    a( a )
 {
     ; // do nothing
 }
 
-FirstPassagePairGreensFunction2D::~FirstPassagePairGreensFunction2D()
+GreensFunction2DRadAbs::~GreensFunction2DRadAbs()
 {
     ; // do nothing
 }
 
-void FirstPassagePairGreensFunction2D::seta( const Real a )
-// This sets the parameter a (not seta or smt)
-// a is the outer shell 
-{
-    const Real sigma( this->getSigma() );
-
-    THROW_UNLESS( std::invalid_argument, a >= sigma );
-
-    if( this->a != a )
-    {
-        this->a = a;
-        clearAlphaTable();
-    }
-}
-
 //
 // Alpha-related methods
 //
 
-void FirstPassagePairGreensFunction2D::clearAlphaTable() const
+void GreensFunction2DRadAbs::clearAlphaTable() const
 {
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
 		   boost::mem_fn( &RealVector::clear ) );
@@ -78,7 +63,7 @@ void FirstPassagePairGreensFunction2D::clearAlphaTable() const
 // The method evaluates the equation for finding the alphas for given alpha. This
 // is needed to find the alpha's at which the expression is zero -> alpha is the root.
 const Real 
-FirstPassagePairGreensFunction2D::f_alpha0( const Real alpha ) const
+GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 {
 	const Real a( this->geta() );
 	const Real sigma( getSigma() );
@@ -102,17 +87,17 @@ FirstPassagePairGreensFunction2D::f_alpha0( const Real alpha ) const
 
 // completely unclear why this is a separate function
 const Real 
-FirstPassagePairGreensFunction2D::f_alpha0_aux_F( const Real alpha,
+GreensFunction2DRadAbs::f_alpha0_aux_F( const Real alpha,
 						const f_alpha0_aux_params* const params )
 {
-    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 	// get the gf from the params?
+    const GreensFunction2DRadAbs* const gf( params->gf ); 	// get the gf from the params?
     return gf->f_alpha0( alpha );
 }
 
 // finding the ith root for the order of Bessel functions zero. Only needed for the survival probability
 // and the flux
 const Real 
-FirstPassagePairGreensFunction2D::alpha0_i( const Real previous ) const
+GreensFunction2DRadAbs::alpha0_i( const Real previous ) const
 {
     THROW_UNLESS( std::out_of_range, previous >= 0.0 );
 
@@ -134,7 +119,7 @@ FirstPassagePairGreensFunction2D::alpha0_i( const Real previous ) const
     f_alpha0_aux_params params = { this, target };	// struct with the gf object and the target
     gsl_function F = 
 	{
-	    reinterpret_cast<typeof(F.function)>( &FirstPassagePairGreensFunction2D::f_alpha0_aux_F ),
+	    reinterpret_cast<typeof(F.function)>( &GreensFunction2DRadAbs::f_alpha0_aux_F ),
 	    &params 
 	};
 
@@ -150,7 +135,7 @@ FirstPassagePairGreensFunction2D::alpha0_i( const Real previous ) const
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
     const Real alpha ( findRoot( F, solver, low, high,
-		 EPSILON/L_TYPICAL, EPSILON, "FirstPassagePairGreensFunction2D::alpha0_i" ) );
+		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::alpha0_i" ) );
 
     gsl_root_fsolver_free( solver );
   
@@ -160,7 +145,7 @@ FirstPassagePairGreensFunction2D::alpha0_i( const Real previous ) const
 // calculates the value of the expression for which the roots have to be found for given order n
 // The expression is evaluated for given alpha, to check if it zero or to get the value of the expression
 // n is the summation index used in the solution
-const Real FirstPassagePairGreensFunction2D::f_alpha( const Real alpha,
+const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 						    const Integer n ) const
 {
 	const Real a( this->geta() );
@@ -186,10 +171,10 @@ const Real FirstPassagePairGreensFunction2D::f_alpha( const Real alpha,
 
 // Finding the roots alpha
 const Real 
-FirstPassagePairGreensFunction2D::f_alpha_aux_F( const Real alpha,
+GreensFunction2DRadAbs::f_alpha_aux_F( const Real alpha,
 	       					const f_alpha_aux_params* const params )
 {
-    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 
+    const GreensFunction2DRadAbs* const gf( params->gf ); 
     const Integer n( params->n );
 
     return gf->f_alpha( alpha, n );	// f_alpha is the function of which we have to find the roots
@@ -199,7 +184,7 @@ FirstPassagePairGreensFunction2D::f_alpha_aux_F( const Real alpha,
 // This calculates a root based on the previous one (offset) with Bessel functions of order n
 // The roots are calculated based on the previous root which is given as an argument (offset)
 const Real 
-FirstPassagePairGreensFunction2D::alpha_i( const Real offset, const Integer n ) const
+GreensFunction2DRadAbs::alpha_i( const Real offset, const Integer n ) const
 {
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
@@ -221,7 +206,7 @@ FirstPassagePairGreensFunction2D::alpha_i( const Real offset, const Integer n )
     gsl_function F = 
 	{
 	    reinterpret_cast<typeof(F.function)>
-	    ( &FirstPassagePairGreensFunction2D::f_alpha_aux_F ),
+	    ( &GreensFunction2DRadAbs::f_alpha_aux_F ),
 	    &params 
 	};
 
@@ -229,7 +214,7 @@ FirstPassagePairGreensFunction2D::alpha_i( const Real offset, const Integer n )
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
     const Real alpha ( findRoot( F, solver, low, high,
-		 EPSILON/L_TYPICAL, EPSILON, "FirstPassagePairGreensFunction2D::alpha_i" ) );
+		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::alpha_i" ) );
     gsl_root_fsolver_free( solver );
 
     return alpha;
@@ -238,7 +223,7 @@ FirstPassagePairGreensFunction2D::alpha_i( const Real offset, const Integer n )
 
 // Calculates the first root (called the offset) for summation index n (so using Bessel functions of order n)
 const Real
-FirstPassagePairGreensFunction2D::alphaOffset( const unsigned int n ) const
+GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
 {
     if( this->alphaOffsetTable[n] > 0 )		// if the offset has already been calculated
     {
@@ -284,7 +269,7 @@ FirstPassagePairGreensFunction2D::alphaOffset( const unsigned int n ) const
 
    f_alpha_aux_params params = { this, n, 0};
    gsl_function F = 	{reinterpret_cast<typeof(F.function)>
-			( &FirstPassagePairGreensFunction2D::f_alpha_aux_F ),
+			( &GreensFunction2DRadAbs::f_alpha_aux_F ),
 			&params
 			};
 
@@ -302,8 +287,7 @@ FirstPassagePairGreensFunction2D::alphaOffset( const unsigned int n ) const
 
 // calculates the constant part of the i-th term for the survival probability
 const Real 
-FirstPassagePairGreensFunction2D::p_survival_i( const Real alpha,
-					      const Real r0 ) const
+GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 {
 	const Real a( geta() );		// get the needed parameters
 	const Real sigma( getSigma() );
@@ -346,8 +330,7 @@ FirstPassagePairGreensFunction2D::p_survival_i( const Real alpha,
 
 // calculates the An,0 terms for determination of the flux through the outer interface
 const Real 
-FirstPassagePairGreensFunction2D::leavea_i( const Real alpha,
-					  const Real r0 ) const
+GreensFunction2DRadAbs::leavea_i( const Real alpha) const
 {
         const Real a( geta() );         // get the needed parameters
         const Real sigma( getSigma() );
@@ -380,8 +363,7 @@ FirstPassagePairGreensFunction2D::leavea_i( const Real alpha,
 
 // Calculates the n-th term of the summation for calculating the flux through the inner interface (reaction)
 const Real 
-FirstPassagePairGreensFunction2D::leaves_i( const Real alpha,
-					  const Real r0 ) const
+GreensFunction2DRadAbs::leaves_i( const Real alpha) const
 {
         const Real a( geta() );         // get the needed parameters
         const Real sigma( getSigma() );
@@ -422,8 +404,7 @@ FirstPassagePairGreensFunction2D::leaves_i( const Real alpha,
 
 // calculates a table with all the constant factors for the survival probability
 void 
-FirstPassagePairGreensFunction2D::createPsurvTable( RealVector& table,
-							const Real r0 ) const
+GreensFunction2DRadAbs::createPsurvTable( RealVector& table) const
 {
     const RealVector& alphaTable_0( this->getAlphaTable( 0 ) );	// get the roots for the survival probability
 
@@ -432,18 +413,17 @@ FirstPassagePairGreensFunction2D::createPsurvTable( RealVector& table,
 
     std::transform( alphaTable_0.begin(), alphaTable_0.end(),
 		    std::back_inserter( table ),
-		    boost::bind( &FirstPassagePairGreensFunction2D::p_survival_i,
-				 this, _1, r0 ) );	// This gets all the roots from 'begin' to 'end'
+		    boost::bind( &GreensFunction2DRadAbs::p_survival_i,
+				 this, _1) );	// This gets all the roots from 'begin' to 'end'
 							// passes them as an argument to p_survival_i and
 							// the result is passed to back_inserter
 }
 
 // Creates the tables with various Bessel functions used in drawR, the table is used to speed things up
 void
-FirstPassagePairGreensFunction2D::createY0J0Tables( RealVector& Y0_Table,
+GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 							RealVector& J0_Table,
 							RealVector& Y0J1J0Y1_Table,
-							const Real r0,
 							const Real t ) const
 {
 	const RealVector& alphaTable_0( this->getAlphaTable( 0 ) );
@@ -459,7 +439,7 @@ FirstPassagePairGreensFunction2D::createY0J0Tables( RealVector& Y0_Table,
 	boost::tuple<Real,Real,Real> result;
 	
 	for (unsigned int count = 0; count < alphaTable_0.size(); count++)
-	{	result = Y0J0J1_constants(alphaTable_0[count], t, r0);
+	{	result = Y0J0J1_constants(alphaTable_0[count], t);
 		Y0_Table.push_back (result.get<0>());
 		J0_Table.push_back (result.get<1>());
 		Y0J1J0Y1_Table.push_back (result.get<2>());
@@ -469,9 +449,8 @@ FirstPassagePairGreensFunction2D::createY0J0Tables( RealVector& Y0_Table,
 
 // Creates the values for in the tables Y0, J0 and Y0J1J0Y1
 const boost::tuple<Real,Real,Real>
-FirstPassagePairGreensFunction2D::Y0J0J1_constants ( const Real alpha,
-							const Real t,
-							const Real r0) const
+GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
+							const Real t) const
 {	const Real D(this->getD());
 	const Real h(this->geth());
 	const Real sigma(this->getSigma());
@@ -513,9 +492,8 @@ FirstPassagePairGreensFunction2D::Y0J0J1_constants ( const Real alpha,
 
 // calculates the ith term with exponent and time for the survival probability
 const Real 
-FirstPassagePairGreensFunction2D::p_survival_i_exp_table( const unsigned int i,
+GreensFunction2DRadAbs::p_survival_i_exp_table( const unsigned int i,
 							const Real t,
-							const Real r0,
 							const RealVector& table ) const
 {
     const Real alpha( this->getAlpha0( i ) );
@@ -525,9 +503,8 @@ FirstPassagePairGreensFunction2D::p_survival_i_exp_table( const unsigned int i,
 // adds the exponential with the time to the sum. Needed for the calculation of the flux throught the outer
 // interface
 const Real 
-FirstPassagePairGreensFunction2D::leavea_i_exp( const unsigned int i,
-					      const Real t,
-					      const Real r0 ) const
+GreensFunction2DRadAbs::leavea_i_exp( const unsigned int i,
+					      const Real t) const
 {
     const Real alpha( this->getAlpha0( i ) );
     return std::exp( - getD() * t * alpha * alpha ) * leavea_i( alpha, r0 );
@@ -535,19 +512,18 @@ FirstPassagePairGreensFunction2D::leavea_i_exp( const unsigned int i,
 
 // adds the exponential with the time to the sum. Needed for the inner interface (reaction)
 const Real 
-FirstPassagePairGreensFunction2D::leaves_i_exp( const unsigned int i,
-					      const Real t,
-					      const Real r0 ) const
+GreensFunction2DRadAbs::leaves_i_exp( const unsigned int i,
+					      const Real t) const
 {
     const Real alpha( this->getAlpha0( i ) );
 
-    return std::exp( - getD() * t * alpha * alpha ) * leaves_i( alpha, r0 );
+    return std::exp( - getD() * t * alpha * alpha ) * leaves_i( alpha );
 }
 
 
 // calculates the Bossen function for a given r
 const Real
-FirstPassagePairGreensFunction2D::p_int_r_i_exp_table( const unsigned int i,
+GreensFunction2DRadAbs::p_int_r_i_exp_table( const unsigned int i,
 				                     const Real r,
                 				     const RealVector& Y0_aAnTable,
                					     const RealVector& J0_aAnTable,
@@ -568,7 +544,7 @@ FirstPassagePairGreensFunction2D::p_int_r_i_exp_table( const unsigned int i,
 // Not really sure yet how this works
 
 const unsigned int
-FirstPassagePairGreensFunction2D::guess_maxi( const Real t ) const
+GreensFunction2DRadAbs::guess_maxi( const Real t ) const
 {
     const unsigned int safety( 2 );
 
@@ -602,12 +578,11 @@ FirstPassagePairGreensFunction2D::guess_maxi( const Real t ) const
 // This is a little wrapper for the p_survival_table so that you can easily calculate the survival probability
 // at a given time
 const Real 
-FirstPassagePairGreensFunction2D::p_survival( const Real t,
-					    const Real r0 ) const
+GreensFunction2DRadAbs::p_survival( const Real t) const
 {
     RealVector psurvTable;
 
-    const Real p( p_survival_table( t, r0, psurvTable ) );
+    const Real p( p_survival_table( t, psurvTable ) );
 
     return p;
 }
@@ -616,8 +591,7 @@ FirstPassagePairGreensFunction2D::p_survival( const Real t,
 // It uses the pSurvTable for efficiency (so you don't have to calculate all the constant factors all
 // the time)
 const Real 
-FirstPassagePairGreensFunction2D::p_survival_table( const Real t,
-						  const Real r0,
+GreensFunction2DRadAbs::p_survival_table( const Real t,
 		  				  RealVector& psurvTable ) const
 {
 	Real p;
@@ -626,13 +600,13 @@ FirstPassagePairGreensFunction2D::p_survival_table( const Real t,
         if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
         {						// that the table is filled
         	IGNORE_RETURN getAlpha0( maxi );	// this updates the table of roots
-                this->createPsurvTable( psurvTable, r0 );	// then the table is filled with data
+                this->createPsurvTable( psurvTable);	// then the table is filled with data
         }
 //std::cout << "p_survival_2DPair ";
-        p = funcSum_all( boost::bind( &FirstPassagePairGreensFunction2D::
+        p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::
                                           p_survival_i_exp_table,
                                           this,
-                                          _1, t, r0, psurvTable ),
+                                          _1, t, psurvTable ),
                          maxi );	// calculate the sum at time t
 
         return p*M_PI*M_PI_2;
@@ -641,16 +615,15 @@ FirstPassagePairGreensFunction2D::p_survival_table( const Real t,
 // calculates the flux leaving through the inner interface at a given moment
 // FIXME: This is inaccurate for small t's!!
 const Real 
-FirstPassagePairGreensFunction2D::leaves( const Real t,
-					const Real r0 ) const
+GreensFunction2DRadAbs::leaves( const Real t) const
 {
     const Real sigma(this->getSigma());
     const Real D(this->getD() );
 
-    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
                                         leaves_i_exp,
                                         this,
-                                        _1, t, r0 ),
+                                        _1, t),
                            this->MAX_ALPHA_SEQ ) );
 
     return -M_PI_2*M_PI*D*sigma*p;	// The minus is there because the flux is in the negative r
@@ -659,15 +632,14 @@ FirstPassagePairGreensFunction2D::leaves( const Real t,
 
 // calculates the flux leaving through the outer interface at a given moment
 const Real 
-FirstPassagePairGreensFunction2D::leavea( const Real t,
-					const Real r0 ) const
+GreensFunction2DRadAbs::leavea( const Real t) const
 {
     const Real D(this->getD() );
 
-    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
                                         leavea_i_exp,
                                         this,
-                                        _1, t, r0 ),
+                                        _1, t),
                            this->MAX_ALPHA_SEQ ) );
     return M_PI*D*p;
 }
@@ -675,12 +647,12 @@ FirstPassagePairGreensFunction2D::leavea( const Real t,
 
 // calculates the sum of the sequence for drawR based upon the values in the tables and r
 const Real
-FirstPassagePairGreensFunction2D::p_int_r_table( const Real r,
+GreensFunction2DRadAbs::p_int_r_table( const Real r,
                					const RealVector& Y0_aAnTable,
                					const RealVector& J0_aAnTable,
                					const RealVector& Y0J1J0Y1Table ) const
 {
-    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
                                         p_int_r_i_exp_table,
                                         this,
                                         _1, r, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table ),
@@ -691,25 +663,25 @@ FirstPassagePairGreensFunction2D::p_int_r_table( const Real r,
 // Used by drawTime
 // Wrapper for p_survival_table for the interator to find the root for drawTime
 const Real
-FirstPassagePairGreensFunction2D::p_survival_table_F( const Real t,
+GreensFunction2DRadAbs::p_survival_table_F( const Real t,
                     					const p_survival_table_params* params )
 {
-    const FirstPassagePairGreensFunction2D* const gf( params->gf ); // the current gf (not sure why this is
+    const GreensFunction2DRadAbs* const gf( params->gf ); // the current gf (not sure why this is
 								    // here)
     const Real r0( params->r0 );
     RealVector& table( params->table );		// table is empty but will be filled in p_survival_table
     const Real rnd( params->rnd );
 
-    return rnd - gf->p_survival_table( t, r0, table );
+    return rnd - gf->p_survival_table( t, table );
 }
 
 
 // a wrapper to make p_int_r_table available to the iterator calculating the root
 const Real
-FirstPassagePairGreensFunction2D::p_int_r_F( const Real r,
+GreensFunction2DRadAbs::p_int_r_F( const Real r,
 					   const p_int_r_params* params )
 {
-    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 
+    const GreensFunction2DRadAbs* const gf( params->gf ); 
     const RealVector& Y0_aAnTable( params->Y0_aAnTable );
     const RealVector& J0_aAnTable( params->J0_aAnTable );
     const RealVector& Y0J1J0Y1Table( params->Y0J1J0Y1Table );
@@ -721,8 +693,7 @@ FirstPassagePairGreensFunction2D::p_int_r_F( const Real r,
 
 // Draws a first passage time, this could be an escape (through the outer boundary) or a reaction (through
 // the inner boundary)
-const Real FirstPassagePairGreensFunction2D::drawTime( const Real rnd, 
-						     const Real r0 ) const
+const Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 {
     const Real D( this->getD() );
     const Real sigma( this->getSigma() );
@@ -811,7 +782,7 @@ const Real FirstPassagePairGreensFunction2D::drawTime( const Real rnd,
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
     const Real t( findRoot( F, solver, low, high,		// find the intersection between the random
-		EPSILON*T_TYPICAL, EPSILON, "FirstPassagePairGreensFunction2D::drawTime" ) );
+		EPSILON*T_TYPICAL, EPSILON, "GreensFunction2DRadAbs::drawTime" ) );
 								// number and the cumm probability
     gsl_root_fsolver_free( solver );
 
@@ -820,8 +791,7 @@ const Real FirstPassagePairGreensFunction2D::drawTime( const Real rnd,
 
 // This determines based on the flux at a certain time, if the 'escape' was a reaction or a proper escape
 const EventType
-FirstPassagePairGreensFunction2D::drawEventType( const Real rnd, 
-					       const Real r0,
+GreensFunction2DRadAbs::drawEventType( const Real rnd, 
 					       const Real t ) const
 {
     const Real D( this->getD() );
@@ -865,8 +835,8 @@ FirstPassagePairGreensFunction2D::drawEventType( const Real rnd,
         }
     }
 
-    const Real reaction( leaves( t, r0 ) );	// flux through rad boundary
-    const Real escape( leavea( t, r0 ) );	// flux through abs boundary
+    const Real reaction( leaves( t ) );	// flux through rad boundary
+    const Real escape( leavea( t ) );	// flux through abs boundary
     const Real value( reaction / ( reaction + escape ) );
 
     if( rnd <= value )  
@@ -880,8 +850,7 @@ FirstPassagePairGreensFunction2D::drawEventType( const Real rnd,
 }
 
 // This draws a radius R at a given time, provided that the particle was at r0 at t=0
-const Real FirstPassagePairGreensFunction2D::drawR( const Real rnd, 
-						  const Real r0, 
+const Real GreensFunction2DRadAbs::drawR( const Real rnd, 
 						  const Real t ) const
 {
     const Real D( this->getD() );
@@ -896,7 +865,7 @@ const Real FirstPassagePairGreensFunction2D::drawR( const Real rnd,
 	return r0;
     }
 
-    const Real psurv( p_survival( t, r0 ) );	// calculate the survival probability at this time
+    const Real psurv( p_survival( t ) );	// calculate the survival probability at this time
 						// this is used as the normalization factor
 						// BEWARE!!! This also produces the roots An and therefore
 						// SETS THE HIGHEST INDEX -> side effect
@@ -975,7 +944,7 @@ const Real FirstPassagePairGreensFunction2D::drawR( const Real rnd,
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     const Real r( findRoot( F, solver, low, high,		// find the intersection between the random
-		 L_TYPICAL*EPSILON, EPSILON, "FirstPassagePairGreensFunction2D::drawR" ) );
+		 L_TYPICAL*EPSILON, EPSILON, "GreensFunction2DRadAbs::drawR" ) );
 								// number and the cumm probability
     gsl_root_fsolver_free( solver );
 
@@ -985,10 +954,9 @@ const Real FirstPassagePairGreensFunction2D::drawR( const Real rnd,
 
 
 // The calculates constant factor m,n for the drawing of theta. These factors are summed later.
-const Real FirstPassagePairGreensFunction2D::p_m_alpha( const unsigned int n,
+const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 						      const unsigned int m,
 						      const Real r,
-						      const Real r0, 
 						      const Real t ) const
 {
 	const Real sigma( this->getSigma() );
@@ -1044,12 +1012,11 @@ const Real FirstPassagePairGreensFunction2D::p_m_alpha( const unsigned int n,
 
 // This calculates the m-th constant factor for the drawTheta method. 
 const Real 
-FirstPassagePairGreensFunction2D::p_m( const Integer m,
+GreensFunction2DRadAbs::p_m( const Integer m,
 				     const Real r,
-				     const Real r0, 
 				     const Real t ) const
 {
-    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
 					p_m_alpha,
 					this,
 					_1, m, r, r0, t ),	// The m-th factor is a summation over n
@@ -1060,18 +1027,17 @@ FirstPassagePairGreensFunction2D::p_m( const Integer m,
 // this should make the table of constants used in the iteration for finding the root for drawTheta
 // The index of the array is consistent with the index of the summation
 void
-FirstPassagePairGreensFunction2D::makep_mTable( RealVector& p_mTable,
+GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 					      const Real r, 
-					      const Real r0, 
 					      const Real t ) const
 {
 	p_mTable.clear();
 
-	const Real p_0 ( this->p_m( 0, r, r0, t ) );	// This is the p_m where m is 0, for the denominator
+	const Real p_0 ( this->p_m( 0, r, t ) );	// This is the p_m where m is 0, for the denominator
 	p_mTable.push_back( p_0 );			// put it in the table
 
 
-	const Real p_1 ( this->p_m( 1, r, r0, t ) / p_0 );
+	const Real p_1 ( this->p_m( 1, r, t ) / p_0 );
 	p_mTable.push_back( p_1 );			// put the first result in the table
 
 
@@ -1096,7 +1062,7 @@ FirstPassagePairGreensFunction2D::makep_mTable( RealVector& p_mTable,
 
 
 		p_m_prev_abs = p_m_abs;					// store the previous term
-		const Real p_m( this->p_m( m, r, r0, t ) / p_0 );	// get the next term
+		const Real p_m( this->p_m( m, r, t ) / p_0 );	// get the next term
 
 		if( ! std::isfinite( p_m ) )		// if the calculated value is not valid->exit
 		{
@@ -1117,9 +1083,8 @@ FirstPassagePairGreensFunction2D::makep_mTable( RealVector& p_mTable,
 
 // This method calculates the constants for the drawTheta method when the particle is at the boundary
 const Real 
-FirstPassagePairGreensFunction2D::dp_m_alpha_at_a( const unsigned int n,
+GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
 						 const unsigned int m,
-						 const Real r0, 
 						 const Real t ) const
 {
         const Real sigma( this->getSigma() );
@@ -1163,14 +1128,13 @@ FirstPassagePairGreensFunction2D::dp_m_alpha_at_a( const unsigned int n,
 
 // Makes the sum over n for order m for the constants for the drawtheta Method
 const Real 
-FirstPassagePairGreensFunction2D::dp_m_at_a( const Integer m,
-					   const Real r0, 
+GreensFunction2DRadAbs::dp_m_at_a( const Integer m,
 					   const Real t ) const
 {
-    const Real p( funcSum( boost::bind( &FirstPassagePairGreensFunction2D::
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
 					dp_m_alpha_at_a,
 					this,
-					_1, m, r0, t ),
+					_1, m, r0,t ),
 			   MAX_ALPHA_SEQ, EPSILON ) );
 
     return p;
@@ -1178,17 +1142,16 @@ FirstPassagePairGreensFunction2D::dp_m_at_a( const Integer m,
 
 // creates a tables of constants for drawTheta when the particle is at the edge of the domain
 void
-FirstPassagePairGreensFunction2D::makedp_m_at_aTable( RealVector& p_mTable,
-						    const Real r0, 
+GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
 						    const Real t ) const
 {
         p_mTable.clear();
 
-        const Real p_0 ( this->dp_m_at_a( 0, r0, t ) );	// This is the p_m where m is 0, for the denominator
+        const Real p_0 ( this->dp_m_at_a( 0, t ) );	// This is the p_m where m is 0, for the denominator
         p_mTable.push_back( p_0 );                      // put it in the table
 
 
-        const Real p_1 ( this->dp_m_at_a( 1, r0, t ) / p_0 );
+        const Real p_1 ( this->dp_m_at_a( 1, t ) / p_0 );
         p_mTable.push_back( p_1 );                      // put the first result in the table
 
 
@@ -1213,7 +1176,7 @@ FirstPassagePairGreensFunction2D::makedp_m_at_aTable( RealVector& p_mTable,
 
 
                 p_m_prev_abs = p_m_abs;					// store the previous term
-                const Real p_m( this->dp_m_at_a( m, r0, t ) / p_0 );	// get the next term
+                const Real p_m( this->dp_m_at_a( m, t ) / p_0 );	// get the next term
 
                 if( ! std::isfinite( p_m ) )			// if the calculated value is not valid->exit
                 {
@@ -1235,7 +1198,7 @@ FirstPassagePairGreensFunction2D::makedp_m_at_aTable( RealVector& p_mTable,
 
 // This calculates the m-th term of the summation for the drawTheta calculation
 const Real 
-FirstPassagePairGreensFunction2D::ip_theta_n( const unsigned int m,
+GreensFunction2DRadAbs::ip_theta_n( const unsigned int m,
 						const Real theta,
 						const RealVector& p_nTable) const
 {
@@ -1248,14 +1211,14 @@ FirstPassagePairGreensFunction2D::ip_theta_n( const unsigned int m,
 // It is used by the drawTheta method
 // It uses the p_nTable for it to speed things up
 const Real 
-FirstPassagePairGreensFunction2D::ip_theta_table( const Real theta,
+GreensFunction2DRadAbs::ip_theta_table( const Real theta,
 						const RealVector& p_nTable ) const
 {
     const unsigned int maxm( p_nTable.size()-1 );	// get the length of the sum
 							// it is shifted one because the first entry should
 							// be used (m=0)
 
-    const Real p( funcSum_all( boost::bind( &FirstPassagePairGreensFunction2D::
+    const Real p( funcSum_all( boost::bind( &GreensFunction2DRadAbs::
                                              ip_theta_n,
                                              this,
                                              _1, theta, p_nTable ),
@@ -1265,10 +1228,10 @@ FirstPassagePairGreensFunction2D::ip_theta_table( const Real theta,
 
 // function to iterate when drawing the theta
 const Real
-FirstPassagePairGreensFunction2D::ip_theta_F( const Real theta,
+GreensFunction2DRadAbs::ip_theta_F( const Real theta,
 					    const ip_theta_params* params )
 {
-    const FirstPassagePairGreensFunction2D* const gf( params->gf ); 
+    const GreensFunction2DRadAbs* const gf( params->gf ); 
     const RealVector& p_nTable( params->p_nTable );	// table with useful constants
     const Real value( params->value );
 
@@ -1278,9 +1241,8 @@ FirstPassagePairGreensFunction2D::ip_theta_F( const Real theta,
 
 // This method draws a theta given a certain r and time (and intial condition of course)
 const Real 
-FirstPassagePairGreensFunction2D::drawTheta( const Real rnd,
+GreensFunction2DRadAbs::drawTheta( const Real rnd,
 					   const Real r, 
-					   const Real r0, 
 					   const Real t ) const
 {
 	const Real sigma( this->getSigma() );
@@ -1327,7 +1289,7 @@ FirstPassagePairGreensFunction2D::drawTheta( const Real rnd,
 	const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
 	gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 	const Real theta( findRoot( F, solver, 0, M_PI, EPSILON, EPSILON,
-                "FirstPassagePairGreensFunction2D::drawTheta" ) );
+                "GreensFunction2DRadAbs::drawTheta" ) );
 	gsl_root_fsolver_free( solver );
 
 	return theta;
@@ -1338,7 +1300,7 @@ FirstPassagePairGreensFunction2D::drawTheta( const Real rnd,
 // debug
 //
 
-const std::string FirstPassagePairGreensFunction2D::dump() const
+const std::string GreensFunction2DRadAbs::dump() const
 {
     std::ostringstream ss;
     ss << "D = " << this->getD() << ", sigma = " << this->getSigma() <<
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index cb45862f..9217ee6d 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -10,7 +10,7 @@
 #include "PairGreensFunction.hpp"
 
 
-class FirstPassagePairGreensFunction2D
+class GreensFunction2DRadAbs
     :
     public PairGreensFunction
 {
@@ -32,11 +32,13 @@ class FirstPassagePairGreensFunction2D
 
 public:
     
-    FirstPassagePairGreensFunction2D( const Real D, 
-				    const Real kf, 
-				    const Real Sigma );
+    GreensFunction2DRadAbs( const Real D, 
+				    const Real kf,
+                    const Real r0, 
+				    const Real Sigma,
+                    const Real a );
     
-    virtual ~FirstPassagePairGreensFunction2D();
+    virtual ~GreensFunction2DRadAbs();
 
     const Real geth() const
     {
@@ -48,21 +50,16 @@ class FirstPassagePairGreensFunction2D
 	return this->a;
     }
 
-    void seta( const Real a );    
-
-    const Real drawTime( const Real rnd, const Real r0 ) const;
+    const Real drawTime( const Real rnd) const;
 
     const EventType drawEventType( const Real rnd, 
-				   const Real r0, 
 				   const Real t ) const;
     
     const Real drawR( const Real rnd, 
-		      const Real r0, 
 		      const Real t ) const;
     
     const Real drawTheta( const Real rnd,
 			  const Real r, 
-			  const Real r0, 
 			  const Real t ) const;
     
     
@@ -71,35 +68,28 @@ class FirstPassagePairGreensFunction2D
     const Real f_alpha( const Real alpha, const Integer n ) const;
 
     
-    const Real p_survival( const Real t,
-			   const Real r0 ) const;
+    const Real p_survival( const Real t) const;
 
     const Real p_survival_table( const Real t,
-				 const Real r0,
 				 RealVector& table ) const;
 
 
-    const Real leaves( const Real t,
-		       const Real r0 ) const;
+    const Real leaves( const Real t) const;
 
-    const Real leavea( const Real t,
-		       const Real r0 ) const;
+    const Real leavea( const Real t) const;
 
-    const Real p_m( const Integer n, const Real r, 
-		    const Real r0, const Real t ) const;
+    const Real p_m( const Integer n, const Real r, const Real t ) const;
 
-    const Real dp_m_at_a( const Integer m, const Real r0, const Real t ) const;
+    const Real dp_m_at_a( const Integer m, const Real t ) const;
 
 
     const Real p_m_alpha( const unsigned int n,
 			  const unsigned int m,
 			  const Real r, 
-			  const Real r0,
 			  const Real t ) const;
 
     const Real dp_m_alpha_at_a( const unsigned int n,
 				const unsigned int m,
-				const Real r0,
 				const Real t ) const;
 
     // methods below are kept public for debugging purpose.
@@ -112,18 +102,14 @@ class FirstPassagePairGreensFunction2D
 
     const Real alpha_i( const Real offset, const Integer n ) const;
 
-    const Real p_survival_i( const Real alpha,
-			     const Real r0 ) const;
+    const Real p_survival_i( const Real alpha) const;
 
-    const Real leavea_i( const Real alpha,
-			 const Real r0 ) const;
+    const Real leavea_i( const Real alpha) const;
 
-    const Real leaves_i( const Real alpha,
-			 const Real r0 ) const;
+    const Real leaves_i( const Real alpha) const;
 
     const boost::tuple<Real,Real,Real> Y0J0J1_constants ( const Real alpha,
-                                                          const Real t,
-                                                          const Real r0) const;
+                                                          const Real t) const;
 
     const Real getAlpha( const size_t n, const RealVector::size_type i ) const
     {
@@ -199,16 +185,13 @@ class FirstPassagePairGreensFunction2D
 
     const Real p_survival_i_exp_table( const unsigned int i,
 				       const Real t,
-				       const Real r0,
 				       const RealVector& table ) const;
 
     const Real leavea_i_exp( const unsigned int i,
-			     const Real alpha,
-			     const Real r0 ) const;
+			     const Real alpha) const;
 
     const Real leaves_i_exp( const unsigned int i,
-			     const Real alpha,
-			     const Real r0 ) const;
+			     const Real alpha) const;
 
     const Real ip_theta_n( const unsigned int m,
 			   const Real theta,
@@ -221,25 +204,23 @@ class FirstPassagePairGreensFunction2D
 					const RealVector& J0_aAnTable,
 					const RealVector& Y0J1J0Y1Table ) const;
 
-    void createPsurvTable( RealVector& table, const Real r0 ) const; 
+    void createPsurvTable( RealVector& table) const; 
 
     void createY0J0Tables( RealVector& Y0_Table, RealVector& J0_Table, RealVector& Y0J1J0Y1_Table,
-				const Real r0, const Real t ) const;
+				const Real t ) const;
 
     void makep_mTable( RealVector& p_mTable,
 		       const Real r, 
-		       const Real r0, 
 		       const Real t ) const;
     
     void makedp_m_at_aTable( RealVector& p_mTable,
-			     const Real r0, 
 			     const Real t ) const;
 
     const unsigned int guess_maxi( const Real t ) const;
 
     struct f_alpha0_aux_params
     { 
-	const FirstPassagePairGreensFunction2D* const gf;
+	const GreensFunction2DRadAbs* const gf;
 	const Real value;
     };
 
@@ -250,7 +231,7 @@ class FirstPassagePairGreensFunction2D
 
     struct f_alpha_aux_params
     { 
-	const FirstPassagePairGreensFunction2D* const gf;
+	const GreensFunction2DRadAbs* const gf;
 	const Integer n;
 	Real value;
     };
@@ -261,8 +242,8 @@ class FirstPassagePairGreensFunction2D
 
     struct p_survival_table_params
     { 
-	const FirstPassagePairGreensFunction2D* const gf;
-	const Real r0;
+	const GreensFunction2DRadAbs* const gf;
+//	const Real r0;
 	RealVector& table;
 	const Real rnd;
     };
@@ -273,9 +254,9 @@ class FirstPassagePairGreensFunction2D
 
     struct p_int_r_params
     { 
-	const FirstPassagePairGreensFunction2D* const gf;
+	const GreensFunction2DRadAbs* const gf;
 	const Real t;
-	const Real r0;
+//	const Real r0;
 	const RealVector& Y0_aAnTable;
 	const RealVector& J0_aAnTable;
 	const RealVector& Y0J1J0Y1Table;
@@ -288,9 +269,9 @@ class FirstPassagePairGreensFunction2D
 
     struct ip_theta_params
     { 
-	const FirstPassagePairGreensFunction2D* const gf;
+	const GreensFunction2DRadAbs* const gf;
 	const Real r;
-	const Real r0;
+//	const Real r0;
 	const Real t;
 	const RealVector& p_nTable;
 	const Real value;
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 74d92c9f..e1baf8a6 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -7,6 +7,8 @@
 #include "freeFunctions.hpp"
 #include "GreensFunction1DAbsAbs.hpp"
 #include "GreensFunction1DRadAbs.hpp"
+#include "GreensFunction2DAbsSym.hpp"
+#include "GreensFunction2DRadAbs.hpp"
 #include "GreensFunction3DSym.hpp"
 #include "GreensFunction3DAbsSym.hpp"
 #include "GreensFunction3DRadInf.hpp"
@@ -31,7 +33,6 @@ BOOST_PYTHON_MODULE( _greens_functions )
     def( "p_reaction_irr", __p_reaction_irr );
     def( "p_reaction_irr_t_inf", __p_reaction_irr_t_inf );
 
-    
     class_<GreensFunction1DAbsAbs>("GreensFunction1DAbsAbs",
                                    init<Real, Real, Real, Real>() )
         .def( init<Real, Real, Real, Real, Real>())
@@ -73,6 +74,43 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "calcpcum", &GreensFunction1DRadAbs::calcpcum )
         .def( "dump", &GreensFunction1DRadAbs::dump )
         ;
+
+    class_<GreensFunction2DAbsSym>( "GreensFunction2DAbsSym",
+					init<const Real>() )
+	.def( "getD", &GreensFunction2DAbsSym::getD )
+	.def( "seta", &GreensFunction2DAbsSym::seta )
+	.def( "geta", &GreensFunction2DAbsSym::geta )
+	.def( "drawTime", &GreensFunction2DAbsSym::drawTime )
+	.def( "drawR", &GreensFunction2DAbsSym::drawR )
+	.def( "p_survival", &GreensFunction2DAbsSym::p_survival )
+	//.def( "p_int_r", &GreensFunction2DAbsSym::p_int_r )
+	//.def( "p_int_r_free", &GreensFunction2DAbsSym::p_int_r_free )
+	//.def( "p_r_fourier", &GreensFunction2DAbsSym::p_r_fourier )
+	;
+
+    class_<GreensFunction2DRadAbs>( "GreensFunction2DRadAbs",
+					    init<const Real, 
+					    const Real,
+					    const Real>() )
+	.def( "seta", &GreensFunction2DRadAbs::seta )
+	.def( "geta", &GreensFunction2DRadAbs::geta )
+	.def( "getD", &GreensFunction2DRadAbs::getD )
+	.def( "getkf", &GreensFunction2DRadAbs::getkf )
+	.def( "geth", &GreensFunction2DRadAbs::geth )
+	.def( "getSigma", &GreensFunction2DRadAbs::getSigma )
+	.def( "drawTime", &GreensFunction2DRadAbs::drawTime )
+	.def( "drawEventType", &GreensFunction2DRadAbs::drawEventType )
+	.def( "drawR", &GreensFunction2DRadAbs::drawR )
+	.def( "drawTheta", &GreensFunction2DRadAbs::drawTheta )
+	.def( "getAlpha", &GreensFunction2DRadAbs::getAlpha )
+	.def( "getAlpha0", &GreensFunction2DRadAbs::getAlpha0 )
+	.def( "f_alpha", &GreensFunction2DRadAbs::f_alpha )
+	.def( "f_alpha0", &GreensFunction2DRadAbs::f_alpha0 )
+	.def( "alpha_i", &GreensFunction2DRadAbs::alpha_i )
+	.def( "p_survival", &GreensFunction2DRadAbs::p_survival )
+	.def( "leaves", &GreensFunction2DRadAbs::leaves )
+	.def( "leavea", &GreensFunction2DRadAbs::leavea )
+	;
     
     class_<GreensFunction3DSym>("GreensFunction3DSym", init<Real>())
         .def( "getD", &GreensFunction3DSym::getD )
@@ -202,4 +240,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
 
         .def( "dump", &GreensFunction3DAbs::dump )
         ;
+
+
+
 }
diff --git a/pair.py b/pair.py
index 58506a37..e63544f3 100644
--- a/pair.py
+++ b/pair.py
@@ -388,13 +388,10 @@ def __init__(self, domain_id, com, single1, single2, shell_id,
                       r0, shell_size, rt, surface)
 
     def com_greens_function(self):
-        # Todo. 2D gf Abs Sym.
-        return GreensFunction3DAbsSym(self.D_R, self.a_R)
+        return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greens_function(self, r0):
-        # Todo. 2D gf Rad Abs.
-        # This exact solution is used for drawing times.
-        return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
+        return GreensFunction2DRadAbs(self.D_tot, self.rt.ktot, r0,
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):
diff --git a/single.py b/single.py
index 2e8de0e3..9cc27ae4 100644
--- a/single.py
+++ b/single.py
@@ -259,9 +259,7 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
                                       shell_id, reactiontypes, surface)
 
     def greens_function(self):
-        # Todo. 2D gf Abs Sym.
-        #gf = GreensFunction2DAbsSym(self.getD())
-        return GreensFunction3DAbsSym(self.getD(),
+        return GreensFunction2DAbsSym(self.getD(),
                                           self.get_mobility_radius())
 
     def create_new_shell(self, position, radius, domain_id):

From 7bdcd4a3869c0dd775975176269034b0da95b3c4 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Mon, 25 Jul 2011 21:43:54 +0200
Subject: [PATCH 0092/1541] Tried compiling; error fix commit.

- Added files to the Makefile.
- Changed number of constants to right amount in Boost linking.
  (To compensate for changes in r0 and a declarations).
- Function "getname()" was lacking in 2D files, added to both
  header files.
---
 GreensFunction2DAbsSym.hpp | 5 +++++
 GreensFunction2DRadAbs.hpp | 5 +++++
 Makefile.am                | 4 ++++
 greens_functions.cpp       | 9 +++++----
 4 files changed, 19 insertions(+), 4 deletions(-)

diff --git a/GreensFunction2DAbsSym.hpp b/GreensFunction2DAbsSym.hpp
index ce750349..07010966 100644
--- a/GreensFunction2DAbsSym.hpp
+++ b/GreensFunction2DAbsSym.hpp
@@ -25,6 +25,11 @@ class GreensFunction2DAbsSym
 	;
     }
 
+    const char* getName() const
+    {
+        return "GreensFunction2DAbsSym";
+    }
+
     const Real getD() const
     {
 	return this->D;
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 9217ee6d..9a11804f 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -31,6 +31,11 @@ class GreensFunction2DRadAbs
     static const unsigned int MAX_ALPHA_SEQ = 2000;	// The maximum number of n terms
 
 public:
+
+    const char* getName() const
+    {
+        return "GreensFunction2DRadAbs";
+    }
     
     GreensFunction2DRadAbs( const Real D, 
 				    const Real kf,
diff --git a/Makefile.am b/Makefile.am
index 70c10298..ff4bf48d 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -65,6 +65,8 @@ noinst_HEADERS = \
 	findRoot.hpp\
 	GreensFunction1DRadAbs.hpp\
 	GreensFunction1DAbsAbs.hpp\
+	GreensFunction2DAbsSym.hpp\
+	GreensFunction2DRadAbs.hpp\
 	GreensFunction3DAbsSym.hpp\
 	GreensFunction3DAbs.hpp\
 	GreensFunction3DRadAbs.hpp\
@@ -195,6 +197,8 @@ _greens_functions_la_SOURCES=\
 	freeFunctions.cpp\
 	GreensFunction1DAbsAbs.cpp\
 	GreensFunction1DRadAbs.cpp\
+	GreensFunction2DAbsSym.cpp\
+	GreensFunction2DRadAbs.cpp\
 	GreensFunction3DSym.cpp\
 	GreensFunction3DAbsSym.cpp\
 	GreensFunction3DRadInf.cpp\
diff --git a/greens_functions.cpp b/greens_functions.cpp
index e1baf8a6..6522e321 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -76,9 +76,8 @@ BOOST_PYTHON_MODULE( _greens_functions )
         ;
 
     class_<GreensFunction2DAbsSym>( "GreensFunction2DAbsSym",
-					init<const Real>() )
+					init<const Real, const Real>() )
 	.def( "getD", &GreensFunction2DAbsSym::getD )
-	.def( "seta", &GreensFunction2DAbsSym::seta )
 	.def( "geta", &GreensFunction2DAbsSym::geta )
 	.def( "drawTime", &GreensFunction2DAbsSym::drawTime )
 	.def( "drawR", &GreensFunction2DAbsSym::drawR )
@@ -88,11 +87,13 @@ BOOST_PYTHON_MODULE( _greens_functions )
 	//.def( "p_r_fourier", &GreensFunction2DAbsSym::p_r_fourier )
 	;
 
+
     class_<GreensFunction2DRadAbs>( "GreensFunction2DRadAbs",
 					    init<const Real, 
 					    const Real,
-					    const Real>() )
-	.def( "seta", &GreensFunction2DRadAbs::seta )
+					    const Real,
+                        const Real,
+                        const Real>() )
 	.def( "geta", &GreensFunction2DRadAbs::geta )
 	.def( "getD", &GreensFunction2DRadAbs::getD )
 	.def( "getkf", &GreensFunction2DRadAbs::getkf )

From 6532bf06813e0b48e4125a2ee0759fc28d141183 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 26 Jul 2011 10:34:44 +0200
Subject: [PATCH 0093/1541] Resolved some typo's/bugs/mismatches new code.

- EventType should be EventKind in declaration drawEventType.
- drawTime, drawR, drawTheta and dump, gave "conflicting return types".
  For first three replaced 1st "const" with "virtual" (seems sensible,
  also in compliance other already implemented GFs), removed "const"
  in declaration "dump".
---
 GreensFunction2DRadAbs.cpp | 10 +++++-----
 GreensFunction2DRadAbs.hpp | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 3efa219a..15e7763e 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -693,7 +693,7 @@ GreensFunction2DRadAbs::p_int_r_F( const Real r,
 
 // Draws a first passage time, this could be an escape (through the outer boundary) or a reaction (through
 // the inner boundary)
-const Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
+virtual Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 {
     const Real D( this->getD() );
     const Real sigma( this->getSigma() );
@@ -790,7 +790,7 @@ const Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 }
 
 // This determines based on the flux at a certain time, if the 'escape' was a reaction or a proper escape
-const EventType
+const EventKind
 GreensFunction2DRadAbs::drawEventType( const Real rnd, 
 					       const Real t ) const
 {
@@ -850,7 +850,7 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
 }
 
 // This draws a radius R at a given time, provided that the particle was at r0 at t=0
-const Real GreensFunction2DRadAbs::drawR( const Real rnd, 
+virtual Real GreensFunction2DRadAbs::drawR( const Real rnd, 
 						  const Real t ) const
 {
     const Real D( this->getD() );
@@ -1240,7 +1240,7 @@ GreensFunction2DRadAbs::ip_theta_F( const Real theta,
 
 
 // This method draws a theta given a certain r and time (and intial condition of course)
-const Real 
+virtual Real 
 GreensFunction2DRadAbs::drawTheta( const Real rnd,
 					   const Real r, 
 					   const Real t ) const
@@ -1300,7 +1300,7 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 // debug
 //
 
-const std::string GreensFunction2DRadAbs::dump() const
+std::string GreensFunction2DRadAbs::dump() const
 {
     std::ostringstream ss;
     ss << "D = " << this->getD() << ", sigma = " << this->getSigma() <<
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 9a11804f..08efb8fd 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -55,15 +55,15 @@ class GreensFunction2DRadAbs
 	return this->a;
     }
 
-    const Real drawTime( const Real rnd) const;
+    virtual Real drawTime( const Real rnd) const;
 
-    const EventType drawEventType( const Real rnd, 
+    const EventKind drawEventType( const Real rnd, 
 				   const Real t ) const;
     
-    const Real drawR( const Real rnd, 
+    virtual Real drawR( const Real rnd, 
 		      const Real t ) const;
     
-    const Real drawTheta( const Real rnd,
+    virtual Real drawTheta( const Real rnd,
 			  const Real r, 
 			  const Real t ) const;
     
@@ -99,7 +99,7 @@ class GreensFunction2DRadAbs
 
     // methods below are kept public for debugging purpose.
 
-    const std::string dump() const;
+    std::string dump() const;
 
     const Real alphaOffset( const unsigned int n ) const;
 

From 61b4628925d98e2d2b70ca5bde960db1f94c531c Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 26 Jul 2011 11:52:33 +0200
Subject: [PATCH 0094/1541] Fixed typo include; Declared typedef "RealVector".

---
 GreensFunction2DRadAbs.cpp | 2 +-
 GreensFunction2DRadAbs.hpp | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 15e7763e..3d62c6f2 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -21,7 +21,7 @@
 #include "findRoot.hpp"
 #include "freeFunctions.hpp"
 
-#include "FirstPassagePairGreensFunction2D.hpp"
+#include "GreensFunction2DRadAbs.hpp"
 
 const Real GreensFunction2DRadAbs::MIN_T_FACTOR;
 const unsigned int GreensFunction2DRadAbs::MAX_ORDER;
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 08efb8fd..65fdc851 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -15,6 +15,10 @@ class GreensFunction2DRadAbs
     public PairGreensFunction
 {
 
+public: 
+    typedef std::vector<Real> RealVector;
+
+private:
     // Error tolerance used by default.
     static const Real TOLERANCE = 1e-8;
 

From 026aebe1cbe5ceba604c1c1fb76f4999532db6eb Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 26 Jul 2011 14:04:29 +0200
Subject: [PATCH 0095/1541] Modified constructor 2DRadAbs GF to handle r0 and
 Sigma.

---
 GreensFunction2DRadAbs.cpp |  8 ++++++--
 GreensFunction2DRadAbs.hpp | 10 ++++++++--
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 3d62c6f2..391f541c 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -32,11 +32,15 @@ const unsigned int GreensFunction2DRadAbs::MAX_ALPHA_SEQ;
 GreensFunction2DRadAbs::
 GreensFunction2DRadAbs( const Real D, 
 				const Real kf, 
-				const Real Sigma )
+				const Real r0, 
+				const Real Sigma,
+                const Real a )
     :
     PairGreensFunction( D, kf, Sigma ),
     h( kf / D ),
-    a( a )
+    a( a ),
+    r0(r0), 
+    Sigma(Sigma)
 {
     ; // do nothing
 }
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 65fdc851..d5cd17a0 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -46,7 +46,7 @@ class GreensFunction2DRadAbs
                     const Real r0, 
 				    const Real Sigma,
                     const Real a );
-    
+  
     virtual ~GreensFunction2DRadAbs();
 
     const Real geth() const
@@ -59,6 +59,11 @@ class GreensFunction2DRadAbs
 	return this->a;
     }
 
+    Real getSigma() const
+    {
+        return this->Sigma;
+    }
+
     virtual Real drawTime( const Real rnd) const;
 
     const EventKind drawEventType( const Real rnd, 
@@ -118,7 +123,8 @@ class GreensFunction2DRadAbs
     const Real leaves_i( const Real alpha) const;
 
     const boost::tuple<Real,Real,Real> Y0J0J1_constants ( const Real alpha,
-                                                          const Real t) const;
+                                                          const Real t,
+                                                          const Real r0) const;
 
     const Real getAlpha( const size_t n, const RealVector::size_type i ) const
     {

From f4d765ae2035bd5cf3fbaaf60bf00fb7fca496b6 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 26 Jul 2011 14:30:48 +0200
Subject: [PATCH 0096/1541] Some work on r0. Added "const Real
 r0(this->getr0);" a few times where deemed necessary. Also removed r0
 sometimes when not a function parameter anymore.

---
 GreensFunction2DRadAbs.cpp | 15 +++++++++++----
 GreensFunction2DRadAbs.hpp |  8 ++++++--
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 391f541c..71c91da5 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -459,6 +459,7 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	const Real h(this->geth());
 	const Real sigma(this->getSigma());
 	const Real a(this->geta());
+	const Real r0(this->getr0); 
 
 	const Real s_An (sigma*alpha);
 	const Real a_An (a*alpha);
@@ -511,7 +512,7 @@ GreensFunction2DRadAbs::leavea_i_exp( const unsigned int i,
 					      const Real t) const
 {
     const Real alpha( this->getAlpha0( i ) );
-    return std::exp( - getD() * t * alpha * alpha ) * leavea_i( alpha, r0 );
+    return std::exp( - getD() * t * alpha * alpha ) * leavea_i( alpha );
 }
 
 // adds the exponential with the time to the sum. Needed for the inner interface (reaction)
@@ -672,7 +673,7 @@ GreensFunction2DRadAbs::p_survival_table_F( const Real t,
 {
     const GreensFunction2DRadAbs* const gf( params->gf ); // the current gf (not sure why this is
 								    // here)
-    const Real r0( params->r0 );
+//    const Real r0(this->getr0) // not necessary since r0 now class parameter // OLD ( params->r0 ); 
     RealVector& table( params->table );		// table is empty but will be filled in p_survival_table
     const Real rnd( params->rnd );
 
@@ -703,6 +704,7 @@ virtual Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
     const Real kf( this->getkf() );
+    const Real r0( this->getr0() );
 
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
     THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
@@ -802,6 +804,7 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
     const Real sigma( this->getSigma() );
     const Real kf( this->getkf() );
     const Real a( this->geta() );
+    const Real r0( this->getr0() );
 
     THROW_UNLESS( std::invalid_argument, 0 <= rnd && rnd < 1.0 );
     THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 < a );
@@ -860,6 +863,7 @@ virtual Real GreensFunction2DRadAbs::drawR( const Real rnd,
     const Real D( this->getD() );
     const Real sigma( getSigma() );
     const Real a( this->geta() );
+    const Real r0( this->getr0() );
 
     THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
     THROW_UNLESS( std::invalid_argument, r0 >= sigma && r0 < a );
@@ -968,6 +972,7 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	const Real a( this->geta() );
 	const Real D( this->getD() );
 	const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
+    const Real r0( this->getr0() );
 
 
 	const Real alpha_sq( alpha * alpha );
@@ -1095,6 +1100,7 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real h( this->geth() );
         const Real a( this->geta() );
         const Real D( this->getD() );
+        const Real r0( this->getr0() );
 
         const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
 
@@ -1252,6 +1258,7 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 	const Real sigma( this->getSigma() );
 	const Real a( this->geta() );
 	const Real D( this->getD() );
+    const Real r0( this->getr0() );
 
 	// input parameter range checks.
 	THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
@@ -1273,11 +1280,11 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 	RealVector p_mTable;			// a table with constants to make calculations much faster
 	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
 	{
-		makedp_m_at_aTable( p_mTable, r0, t );	// making the table if particle on the outer boundary
+		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
 	}
 	else
 	{
-		makep_mTable( p_mTable, r, r0, t );	// making the table of constants for the regular case
+		makep_mTable( p_mTable, r, t );	// making the table of constants for the regular case
 	}
 
 
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index d5cd17a0..1cbe0354 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -64,6 +64,11 @@ class GreensFunction2DRadAbs
         return this->Sigma;
     }
 
+    Real getr0() const
+    {
+        return this->r0;
+    }
+
     virtual Real drawTime( const Real rnd) const;
 
     const EventKind drawEventType( const Real rnd, 
@@ -123,8 +128,7 @@ class GreensFunction2DRadAbs
     const Real leaves_i( const Real alpha) const;
 
     const boost::tuple<Real,Real,Real> Y0J0J1_constants ( const Real alpha,
-                                                          const Real t,
-                                                          const Real r0) const;
+                                                          const Real t) const;
 
     const Real getAlpha( const size_t n, const RealVector::size_type i ) const
     {

From f6fd711c121d8700d91a3b1f985b97c74a4db403 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 26 Jul 2011 15:05:16 +0200
Subject: [PATCH 0097/1541] Added correct inheritance for constructor funtion;
 needed because addition r0.

---
 GreensFunction2DRadAbs.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 71c91da5..2370e613 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -32,11 +32,9 @@ const unsigned int GreensFunction2DRadAbs::MAX_ALPHA_SEQ;
 GreensFunction2DRadAbs::
 GreensFunction2DRadAbs( const Real D, 
 				const Real kf, 
-				const Real r0, 
-				const Real Sigma,
                 const Real a )
     :
-    PairGreensFunction( D, kf, Sigma ),
+    PairGreensFunction(D, kf, r0, Sigma),
     h( kf / D ),
     a( a ),
     r0(r0), 

From 1c0d012ac29094bce007d9f0c23a9bc1edafd358 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 26 Jul 2011 17:16:31 +0200
Subject: [PATCH 0098/1541] Fixed stupid typo + declaration.

---
 GreensFunction2DRadAbs.cpp | 10 +++++-----
 GreensFunction2DRadAbs.hpp | 10 ----------
 2 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 2370e613..31b3bfe3 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -31,14 +31,14 @@ const unsigned int GreensFunction2DRadAbs::MAX_ALPHA_SEQ;
 // This is the constructor
 GreensFunction2DRadAbs::
 GreensFunction2DRadAbs( const Real D, 
-				const Real kf, 
-                const Real a )
+				    const Real kf,
+                    const Real r0, 
+				    const Real Sigma,
+                    const Real a )
     :
     PairGreensFunction(D, kf, r0, Sigma),
     h( kf / D ),
-    a( a ),
-    r0(r0), 
-    Sigma(Sigma)
+    a( a )
 {
     ; // do nothing
 }
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 1cbe0354..4ab951c9 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -59,16 +59,6 @@ class GreensFunction2DRadAbs
 	return this->a;
     }
 
-    Real getSigma() const
-    {
-        return this->Sigma;
-    }
-
-    Real getr0() const
-    {
-        return this->r0;
-    }
-
     virtual Real drawTime( const Real rnd) const;
 
     const EventKind drawEventType( const Real rnd, 

From 2d1da2e5678bf8fc8e6d935128b6572acd6d096b Mon Sep 17 00:00:00 2001
From: "Martijn.Wehrens" <wehrens@amolf.nl>
Date: Wed, 27 Jul 2011 14:14:57 +0200
Subject: [PATCH 0099/1541] Seems to compile now. (Some more r0 and const
 issues fixed.)

---
 GreensFunction2DRadAbs.cpp | 57 +++++++++++++++++---------------------
 GreensFunction2DRadAbs.hpp |  2 +-
 2 files changed, 27 insertions(+), 32 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 31b3bfe3..0607e388 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -1,6 +1,8 @@
 //#define NDEBUG
 //#define BOOST_DISABLE_ASSERTS
 
+#include "compat.h"
+
 #include <iostream>
 #include <stdexcept>
 #include <vector>
@@ -457,7 +459,7 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	const Real h(this->geth());
 	const Real sigma(this->getSigma());
 	const Real a(this->geta());
-	const Real r0(this->getr0); 
+	const Real r0(this->getr0()); 
 
 	const Real s_An (sigma*alpha);
 	const Real a_An (a*alpha);
@@ -606,8 +608,7 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
                 this->createPsurvTable( psurvTable);	// then the table is filled with data
         }
 //std::cout << "p_survival_2DPair ";
-        p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::
-                                          p_survival_i_exp_table,
+        p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
                                           this,
                                           _1, t, psurvTable ),
                          maxi );	// calculate the sum at time t
@@ -623,8 +624,7 @@ GreensFunction2DRadAbs::leaves( const Real t) const
     const Real sigma(this->getSigma());
     const Real D(this->getD() );
 
-    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
-                                        leaves_i_exp,
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::leaves_i_exp,
                                         this,
                                         _1, t),
                            this->MAX_ALPHA_SEQ ) );
@@ -639,8 +639,7 @@ GreensFunction2DRadAbs::leavea( const Real t) const
 {
     const Real D(this->getD() );
 
-    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
-                                        leavea_i_exp,
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::leavea_i_exp,
                                         this,
                                         _1, t),
                            this->MAX_ALPHA_SEQ ) );
@@ -655,8 +654,7 @@ GreensFunction2DRadAbs::p_int_r_table( const Real r,
                					const RealVector& J0_aAnTable,
                					const RealVector& Y0J1J0Y1Table ) const
 {
-    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
-                                        p_int_r_i_exp_table,
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::p_int_r_i_exp_table,
                                         this,
                                         _1, r, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table ),
                            Y0_aAnTable.size() ) );
@@ -671,7 +669,7 @@ GreensFunction2DRadAbs::p_survival_table_F( const Real t,
 {
     const GreensFunction2DRadAbs* const gf( params->gf ); // the current gf (not sure why this is
 								    // here)
-//    const Real r0(this->getr0) // not necessary since r0 now class parameter // OLD ( params->r0 ); 
+//    const Real r0(this->getr0()) // not necessary since r0 now class parameter // OLD ( params->r0 ); 
     RealVector& table( params->table );		// table is empty but will be filled in p_survival_table
     const Real rnd( params->rnd );
 
@@ -696,7 +694,7 @@ GreensFunction2DRadAbs::p_int_r_F( const Real r,
 
 // Draws a first passage time, this could be an escape (through the outer boundary) or a reaction (through
 // the inner boundary)
-virtual Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
+Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 {
     const Real D( this->getD() );
     const Real sigma( this->getSigma() );
@@ -732,7 +730,7 @@ virtual Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 
 
 	RealVector psurvTable;		// this is still empty as of now->not used
-	p_survival_table_params params = { this, r0, psurvTable, rnd };
+	p_survival_table_params params = { this, psurvTable, rnd };
 	gsl_function F = 
 	{
 	    reinterpret_cast<typeof(F.function)>( &p_survival_table_F ),
@@ -794,7 +792,7 @@ virtual Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 }
 
 // This determines based on the flux at a certain time, if the 'escape' was a reaction or a proper escape
-const EventKind
+GreensFunction2DRadAbs::EventKind
 GreensFunction2DRadAbs::drawEventType( const Real rnd, 
 					       const Real t ) const
 {
@@ -810,7 +808,7 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
 
     if( kf == 0.0 )	// if there cannot be any flow through the radiating boundary it is always an escape
     {
-        return ESCAPE;
+        return IV_ESCAPE;
     }
     
     // First, check if r0 is close only either to a or sigma relative
@@ -829,14 +827,14 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
     {
         if( s_dist < max_dist )
         {
-            return REACTION;
+            return IV_REACTION;
         }
     }
     else // a_dist < max_dist
     {
         if( s_dist > max_dist )
         {
-            return ESCAPE;
+            return IV_ESCAPE;
         }
     }
 
@@ -846,16 +844,16 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
 
     if( rnd <= value )  
     {
-	return REACTION;   // leaves -> return 0
+	return IV_REACTION;   // leaves -> return 0
     }
     else 
     {
-	return ESCAPE;     // leavea -> return 1
+	return IV_ESCAPE;     // leavea -> return 1
     }
 }
 
 // This draws a radius R at a given time, provided that the particle was at r0 at t=0
-virtual Real GreensFunction2DRadAbs::drawR( const Real rnd, 
+Real GreensFunction2DRadAbs::drawR( const Real rnd, 
 						  const Real t ) const
 {
     const Real D( this->getD() );
@@ -880,9 +878,9 @@ virtual Real GreensFunction2DRadAbs::drawR( const Real rnd,
     RealVector Y0_aAnTable;
     RealVector J0_aAnTable;
     RealVector Y0J1J0Y1Table;
-    createY0J0Tables( Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, r0, t);
+    createY0J0Tables( Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, t);
 
-    p_int_r_params params = { this, t, r0, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, rnd * psurv };
+    p_int_r_params params = { this, t, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, rnd * psurv };
 
     gsl_function F = 
 	{
@@ -1023,10 +1021,9 @@ GreensFunction2DRadAbs::p_m( const Integer m,
 				     const Real r,
 				     const Real t ) const
 {
-    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
-					p_m_alpha,
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::p_m_alpha,
 					this,
-					_1, m, r, r0, t ),	// The m-th factor is a summation over n
+					_1, m, r, t ),	// The m-th factor is a summation over n
 			   MAX_ALPHA_SEQ, EPSILON ) );
     return p;
 }
@@ -1139,10 +1136,9 @@ const Real
 GreensFunction2DRadAbs::dp_m_at_a( const Integer m,
 					   const Real t ) const
 {
-    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::
-					dp_m_alpha_at_a,
+    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::dp_m_alpha_at_a,
 					this,
-					_1, m, r0,t ),
+					_1, m,t ),
 			   MAX_ALPHA_SEQ, EPSILON ) );
 
     return p;
@@ -1226,8 +1222,7 @@ GreensFunction2DRadAbs::ip_theta_table( const Real theta,
 							// it is shifted one because the first entry should
 							// be used (m=0)
 
-    const Real p( funcSum_all( boost::bind( &GreensFunction2DRadAbs::
-                                             ip_theta_n,
+    const Real p( funcSum_all( boost::bind( &GreensFunction2DRadAbs::ip_theta_n,
                                              this,
                                              _1, theta, p_nTable ),
                                 maxm ) );
@@ -1248,7 +1243,7 @@ GreensFunction2DRadAbs::ip_theta_F( const Real theta,
 
 
 // This method draws a theta given a certain r and time (and intial condition of course)
-virtual Real 
+Real 
 GreensFunction2DRadAbs::drawTheta( const Real rnd,
 					   const Real r, 
 					   const Real t ) const
@@ -1287,7 +1282,7 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 
 
 	// preparing the function
-	ip_theta_params params = { this, r, r0, t, p_mTable, rnd*0.5 };	// r, r0, t are not required
+	ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 };	// r, r0, t are not required
 	gsl_function F = 
 	{
 	    reinterpret_cast<typeof(F.function)>( &ip_theta_F ),
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 4ab951c9..1fbdfb27 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -61,7 +61,7 @@ class GreensFunction2DRadAbs
 
     virtual Real drawTime( const Real rnd) const;
 
-    const EventKind drawEventType( const Real rnd, 
+    virtual EventKind drawEventType( const Real rnd, 
 				   const Real t ) const;
     
     virtual Real drawR( const Real rnd, 

From 857e2940fdfcf7773d24625b7a4f18a9813734c3 Mon Sep 17 00:00:00 2001
From: "Martijn.Wehrens" <wehrens@amolf.nl>
Date: Wed, 27 Jul 2011 15:52:09 +0200
Subject: [PATCH 0100/1541] Added "dump()" to .def, added r0 to dumped
 parameters.

---
 GreensFunction2DRadAbs.cpp    | 1 +
 greens_function_wrapper.py    | 4 ++--
 greens_functions.cpp          | 2 ++
 visualization/run_pipeline.py | 4 ++--
 4 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 0607e388..25343ef4 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -1310,6 +1310,7 @@ std::string GreensFunction2DRadAbs::dump() const
     ss << "D = " << this->getD() << ", sigma = " << this->getSigma() <<
 	", a = " << this->geta() <<
 	", kf = " << this->getkf() <<
+	", r0 = " << this->getr0() <<
 	", h = " << this->geth() << std::endl;
     return ss.str();
 }    
diff --git a/greens_function_wrapper.py b/greens_function_wrapper.py
index 16ad17dc..b975170d 100644
--- a/greens_function_wrapper.py
+++ b/greens_function_wrapper.py
@@ -65,8 +65,8 @@ def draw_theta_wrapper(gf, r, dt):
         theta = gf.drawTheta(rnd, r, dt)
     except Exception, e:
         raise Exception('gf.drawTheta() failed, '
-                        '%s, rnd = %g, r = %g, dt = %g' %
-                        (str(e), rnd, r, dt))#, gf.dump()))
+                        '%s, rnd = %g, r = %g, dt = %g; %s' %
+                        (str(e), rnd, r, dt, gf.dump()))
 
     # Heads up. For cylinders theta should be between [-pi, pi]. For 
     # spheres it doesn't matter.
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 6522e321..cc823b8f 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -82,6 +82,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
 	.def( "drawTime", &GreensFunction2DAbsSym::drawTime )
 	.def( "drawR", &GreensFunction2DAbsSym::drawR )
 	.def( "p_survival", &GreensFunction2DAbsSym::p_survival )
+    .def( "dump", &GreensFunction2DAbsSym::dump )
 	//.def( "p_int_r", &GreensFunction2DAbsSym::p_int_r )
 	//.def( "p_int_r_free", &GreensFunction2DAbsSym::p_int_r_free )
 	//.def( "p_r_fourier", &GreensFunction2DAbsSym::p_r_fourier )
@@ -111,6 +112,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
 	.def( "p_survival", &GreensFunction2DRadAbs::p_survival )
 	.def( "leaves", &GreensFunction2DRadAbs::leaves )
 	.def( "leavea", &GreensFunction2DRadAbs::leavea )
+    .def( "dump", &GreensFunction2DRadAbs::dump )
 	;
     
     class_<GreensFunction3DSym>("GreensFunction3DSym", init<Real>())
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index 0cd6a861..4c6952d2 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -6,12 +6,12 @@
 """
 # Root directory of the eGFRD algorithm files:
 # Use the full path (e.g. NOT a tilde)
-egfrd_directory ='/storage1/wehrens/myfork_egfrd/'
+egfrd_directory ='/storage1/wehrens/GF2D/'
 # Output directory of the VTK logger 
 # (This was defined when calling the logger in your
 # script.)
 simulation_data_directory =\
-    '/storage1/wehrens/scripts_gfrd/benchmarking/VTK_out' # egfrd_directory + \
+    '/home/jintram/scripts_egfrd/VTK_out' # egfrd_directory + \
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From 5676a29c084917392c76947aea85cbf508ce453a Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 27 Jul 2011 16:59:24 +0200
Subject: [PATCH 0101/1541] Added file that test 2d code.

---
 samples/2d/2dtest.py          | 114 ++++++++++++++++++++++++++++++++++
 visualization/run_pipeline.py |   4 +-
 2 files changed, 116 insertions(+), 2 deletions(-)
 create mode 100644 samples/2d/2dtest.py

diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
new file mode 100644
index 00000000..0050d639
--- /dev/null
+++ b/samples/2d/2dtest.py
@@ -0,0 +1,114 @@
+#!/usr/bin/env python
+
+# Small scripts that demonstrates 2d
+#
+# ... which as of yet is bug-prone.
+#   Run by executing:
+# $ python 2dtest.py
+# 
+# In the script below VTK-logging can be 
+# turned of or on. (logging = False/True.)
+#   When logging is on, VTK logs will be 
+# created automatically, errormessages will
+# be supressed however. When logging is
+# off, then errormessages are not supressed.
+
+
+# Modules
+# ===============================
+import sys
+#Also, set relative python path
+sys.path.append('../../')
+import os
+import datetime
+
+from egfrd import *
+from visualization import vtklogger
+
+import model
+import gfrdbase
+import _gfrd
+
+
+# Unique seed
+# ===============================
+currenttime = (long(
+datetime.datetime.now().month*30.5*24*3600+
+datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
+datetime.datetime.now().minute*60+datetime.datetime.now().second))
+myrandom.seed(currenttime)
+ 
+
+# Constants
+# ===============================
+logging = False
+sigma = 1e-9        # Diameter particle
+D = 1e-12           # Diffusion constant
+N = 200             # Number of steps simulation will last
+world_size = 1e-3   # Lengths of simulation box
+
+
+# VTK Logger
+# ===============================
+if (logging == True):
+    vtk_output_directory = 'VTK_out'
+    if (os.path.exists(vtk_output_directory)):
+        print '** WARNING: VTK output directory already exists, possible '+ \
+                'present old VTK files might lead to errors.'
+
+
+# Basic set up simulator
+# ===============================
+# Model
+m = model.ParticleModel(world_size)
+
+# Plane ("membrane")
+the_plane = _gfrd.create_planar_surface('the_plane', 
+    [world_size/2,0,0], [0,0,1], [0,1,0], 
+    world_size, world_size)
+m.add_structure(the_plane)
+
+# Species
+Xp = model.Species('Xp', D, sigma, 'the_plane')                                   
+m.add_species_type(Xp)
+# Reaction rules
+#r1 = model.create_binding_reaction_rule(A, B, X, k)
+#m.network_rules.add_reaction_rule(r1)
+
+
+
+# World
+w = gfrdbase.create_world(m, 3)
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
+
+# Set up logger
+if (logging == True):
+    l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+
+# Throw in particles
+throw_in_particles(w, Xp, 5)
+
+# Running 2
+# ===============================
+for t in range(N):
+
+    # if logging, log and also use "try statement"
+    if (logging == True): 
+        # take a step (but ignore errors)
+        try:
+            s.step()
+        except:
+            print "Broken (run with logging=False for errormessage)!"
+            break
+        # log the step
+        l.log()
+    # otherwise just make steps.
+    else:
+        s.step()
+
+s.stop(s.t)
+
+if (logging == True):
+    l.stop()
+
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index 4c6952d2..2d1aadcf 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -6,12 +6,12 @@
 """
 # Root directory of the eGFRD algorithm files:
 # Use the full path (e.g. NOT a tilde)
-egfrd_directory ='/storage1/wehrens/GF2D/'
+egfrd_directory ='/storage1/wehrens/GF2D_implementation/'
 # Output directory of the VTK logger 
 # (This was defined when calling the logger in your
 # script.)
 simulation_data_directory =\
-    '/home/jintram/scripts_egfrd/VTK_out' # egfrd_directory + \
+    '/storage1/wehrens/2d/VTK_out' # egfrd_directory + \
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From b70da43e52c1d6af39058e0512495801b62ed6b7 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Wed, 27 Jul 2011 17:25:30 +0200
Subject: [PATCH 0102/1541] Edited 2dtest.py better seeding.

---
 samples/2d/2dtest.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
index 0050d639..d51dcb74 100644
--- a/samples/2d/2dtest.py
+++ b/samples/2d/2dtest.py
@@ -33,10 +33,12 @@
 # Unique seed
 # ===============================
 currenttime = (long(
-datetime.datetime.now().month*30.5*24*3600+
-datetime.datetime.now().day*24*3600+datetime.datetime.now().hour*3600+
-datetime.datetime.now().minute*60+datetime.datetime.now().second))
+datetime.datetime.now().month*30.5*24*3600*1e6+
+datetime.datetime.now().day*24*3600*1e6+datetime.datetime.now().hour*3600*1e6+
+datetime.datetime.now().minute*60*1e6+datetime.datetime.now().second*1e6+
+datetime.datetime.now().microsecond))
 myrandom.seed(currenttime)
+print "(Seed " + str(currenttime) + ")"
  
 
 # Constants

From f77962421fa6d603bfdf6a7e28cf2dd2d9336553 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 1 Aug 2011 14:54:33 +0200
Subject: [PATCH 0103/1541] fixed l/d determine_radii to work properly The
 value for l/d determines the convergence rate for Green's function evaluation
 A maximum value of 20 is now given which should be parameterized properly in
 the future Also, the mechanism is now the same for 1D, 2D and 3D which should
 be changed

---
 pair.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/pair.py b/pair.py
index 73fed7ec..215e1d17 100644
--- a/pair.py
+++ b/pair.py
@@ -125,14 +125,14 @@ def determine_radii(self, r0, shell_size):
         D2 = single2.pid_particle_pair[1].D
 
 	LD_MAX = 20 # temporary value
-	a_r_max = LD_MAX * (r0 - self.sigma)
+	a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
 	# a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
 
         # Make sure that D1 != 0 to avoid division by zero in the followings.
         if D1 == 0:
-            D1, D2 = D2, D1
+            D1, D2 = D2, D1	# shouldn't we also here swap the particle radii if we're swapping diffusion contants?
 
-        shell_size /= SAFETY
+        shell_size /= SAFETY	#??
 
         D_tot = D1 + D2
         D_geom = math.sqrt(D1 * D2)
@@ -162,28 +162,31 @@ def determine_radii(self, r0, shell_size):
         #ar
         a_r = (D_geom * r0 + D_tot * (shell_size - radiusa)) / (Da + D_geom)
 
+
 	# Now if the planned domainsize for r is too large for proper convergence of the Green's
 	# functions, make it the maximum allowed size
 	if (a_r > a_r_max):
 	    a_r = a_r_max
-	    a_R = shell_size - a_r
+	    a_R = shell_size - radiusa - a_r * Da / D_tot
+	    if __debug__:
+		log.info('domainsize changed for convergence.')
 
         assert a_R + a_r * Da / D_tot + radius1 >= \
                a_R + a_r * Db / D_tot + radius2
 
         assert abs(a_R + a_r * Da / D_tot + radiusa - shell_size) \
-            < 1e-12 * shell_size
+            < 1e-12 * shell_size			# here the shell_size is the relevant scale
 
 
         if __debug__:
           log.debug('a %g, r %g, R %g r0 %g' % 
                  (shell_size, a_r, a_R, r0))
         if __debug__:
-            tr = ((a_r - r0) / math.sqrt(6 * self.D_tot))**2
+            tr = ((a_r - r0)**2) / (6 * self.D_tot)	# the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
-                tR = (a_R / math.sqrt(6*self.D_R))**2
+                tR = (a_R**2) / (6 * self.D_R)		# the expected escape time of the CoM
             log.debug('tr %g, tR %g' % (tr, tR))
 
 

From 5902df7311225a82a0366c85e0706a0fca138a79 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 1 Aug 2011 17:14:43 +0200
Subject: [PATCH 0104/1541] Small cleanup of sample scripts (mostly comments)

---
 samples/2d/2dtest.py           | 10 ++++++----
 samples/cluster/run.py         |  9 ++++++---
 samples/dimer/dimer.py         |  7 ++++++-
 samples/dimer/dimer_cpp.py     |  8 +++++++-
 samples/hardbody/run_all.py    |  2 +-
 samples/hardbody/run_single.py | 10 ++++++----
 samples/irreversible/p_irr.py  |  2 +-
 samples/irreversible/plot.py   | 10 ++++++++--
 samples/irreversible/run.py    | 20 ++++++++++++--------
 samples/pushpull/fractionS.py  |  2 ++
 samples/pushpull/plot.py       |  2 +-
 samples/pushpull/pushpull.py   |  2 +-
 samples/rebind/plot.py         |  2 +-
 samples/rebind/run.py          |  7 ++++++-
 samples/rebind/run2.py         |  8 +++++++-
 samples/reversible/run.py      | 20 +++++++++++++-------
 samples/simple/simple.py       |  6 ++++++
 samples/single/run.py          |  8 +++++++-
 samples/template/template.py   | 34 +++++++---------------------------
 samples/tf/tf.py               |  8 ++++++--
 20 files changed, 110 insertions(+), 67 deletions(-)
 mode change 100644 => 100755 samples/2d/2dtest.py
 mode change 100644 => 100755 samples/cluster/run.py
 mode change 100644 => 100755 samples/dimer/dimer_cpp.py
 mode change 100644 => 100755 samples/rebind/plot.py
 mode change 100644 => 100755 samples/rebind/run.py
 mode change 100644 => 100755 samples/rebind/run2.py
 mode change 100644 => 100755 samples/simple/simple.py
 mode change 100644 => 100755 samples/single/run.py
 mode change 100644 => 100755 samples/template/template.py
 mode change 100644 => 100755 samples/tf/tf.py

diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
old mode 100644
new mode 100755
index d51dcb74..9780d290
--- a/samples/2d/2dtest.py
+++ b/samples/2d/2dtest.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 
 # Small scripts that demonstrates 2d
 #
@@ -12,13 +12,15 @@
 # created automatically, errormessages will
 # be supressed however. When logging is
 # off, then errormessages are not supressed.
-
+#
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
 
 # Modules
 # ===============================
 import sys
-#Also, set relative python path
-sys.path.append('../../')
 import os
 import datetime
 
diff --git a/samples/cluster/run.py b/samples/cluster/run.py
old mode 100644
new mode 100755
index 92bad74f..cf037b43
--- a/samples/cluster/run.py
+++ b/samples/cluster/run.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 
 # Rebinding to a cluster
 
@@ -16,14 +16,17 @@
 # $ python run.py 7 1000 data.out
 # Or:
 # $ python run.py 7 1 data.out True
+#
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
 
 print "v23jun2011.3"
 
 # Modules
 # ===============================
 import sys
-#Also, set relative egfrd directory path
-sys.path.append('../../')
 import os
 import shutil
 import datetime
diff --git a/samples/dimer/dimer.py b/samples/dimer/dimer.py
index a12612e3..cb9f8a44 100755
--- a/samples/dimer/dimer.py
+++ b/samples/dimer/dimer.py
@@ -1,4 +1,9 @@
-#!/usr/bin/env python
+#!/usr/bin/python
+
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+
 
 import sys
 
diff --git a/samples/dimer/dimer_cpp.py b/samples/dimer/dimer_cpp.py
old mode 100644
new mode 100755
index ef15816f..5a1af4dd
--- a/samples/dimer/dimer_cpp.py
+++ b/samples/dimer/dimer_cpp.py
@@ -1,4 +1,10 @@
-#!/usr/bin/env python
+#!/usr/bin/python
+
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
 
 from gfrdbase import N_A, create_world, throw_in_particles
 from logger import *
diff --git a/samples/hardbody/run_all.py b/samples/hardbody/run_all.py
index e1a22b9b..f0779a3f 100755
--- a/samples/hardbody/run_all.py
+++ b/samples/hardbody/run_all.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 import sys
 import numpy
 import math
diff --git a/samples/hardbody/run_single.py b/samples/hardbody/run_single.py
index 0cb6d36e..3974e401 100755
--- a/samples/hardbody/run_single.py
+++ b/samples/hardbody/run_single.py
@@ -1,11 +1,13 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 
 # Run with e.g. $ python run_single.py 1 1e-5 10
+#
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
 
 import sys
-#Also, set relative egfrd directory path
-sys.path.append('../../')
-
 import myrandom
 
 from egfrd import *
diff --git a/samples/irreversible/p_irr.py b/samples/irreversible/p_irr.py
index f63746be..b63e296f 100755
--- a/samples/irreversible/p_irr.py
+++ b/samples/irreversible/p_irr.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 
 import math
 import numpy
diff --git a/samples/irreversible/plot.py b/samples/irreversible/plot.py
index 74e35adf..8d40e616 100755
--- a/samples/irreversible/plot.py
+++ b/samples/irreversible/plot.py
@@ -1,6 +1,12 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 
-#  PYTHONPATH=../.. python plot.py irr.-2.out 0.000000125  irr.-1.out 0.00000125  irr.0.out 0.0000125 irr.1.out 0.000125 irr.2.out 0.00125 irr.3.out 0.0125
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
+
+#  python plot.py irr.-2.out 0.000000125  irr.-1.out 0.00000125  irr.0.out 0.0000125 irr.1.out 0.000125 irr.2.out 0.00125 irr.3.out 0.0125
 
 # irr.-3.out 0.0000000125 
 
diff --git a/samples/irreversible/run.py b/samples/irreversible/run.py
index 2a8efad3..1d7a7bc0 100755
--- a/samples/irreversible/run.py
+++ b/samples/irreversible/run.py
@@ -1,13 +1,17 @@
-#!/usr/bin/env python
+#!/usr/bin/python
+
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
 
 '''
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py irr.3.out 1.25e-2 20000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py irr.2.out 1.25e-3 20000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py irr.1.out 1.25e-4 7000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py irr.0.out 1.25e-5 5000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py irr.-1.out 1.25e-6 2000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py irr.-2.out 1.25e-7 2000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py irr.-3.out 1.25e-8 1000000 &
+LOGLEVEL=ERROR python -O run.py irr.3.out 1.25e-2 20000000 &
+LOGLEVEL=ERROR python -O run.py irr.2.out 1.25e-3 20000000 &
+LOGLEVEL=ERROR python -O run.py irr.1.out 1.25e-4 7000000 &
+LOGLEVEL=ERROR python -O run.py irr.0.out 1.25e-5 5000000 &
+LOGLEVEL=ERROR python -O run.py irr.-1.out 1.25e-6 2000000 &
+LOGLEVEL=ERROR python -O run.py irr.-2.out 1.25e-7 2000000 &
+LOGLEVEL=ERROR python -O run.py irr.-3.out 1.25e-8 1000000 &
 '''
 
 import sys
diff --git a/samples/pushpull/fractionS.py b/samples/pushpull/fractionS.py
index 6a1ccb30..d960c379 100644
--- a/samples/pushpull/fractionS.py
+++ b/samples/pushpull/fractionS.py
@@ -1,3 +1,5 @@
+#!/usr/bin/python
+
 import math
 
 
diff --git a/samples/pushpull/plot.py b/samples/pushpull/plot.py
index e4c479b3..67d12e32 100644
--- a/samples/pushpull/plot.py
+++ b/samples/pushpull/plot.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 # Call with:
-# PYTHONPATH=../../ python plot.py [data directory] [output directory]
+# python plot.py [data directory] [output directory]
 
 import sys
 import string
diff --git a/samples/pushpull/pushpull.py b/samples/pushpull/pushpull.py
index 2167581b..3e32a133 100644
--- a/samples/pushpull/pushpull.py
+++ b/samples/pushpull/pushpull.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 # Call with:
-# PYTHONPATH=../../ python pushpull.py [Keq] [koff_ratio] [N_S_total] [N_K] [N_P] [V] [mode] [T]
+# python pushpull.py [Keq] [koff_ratio] [N_S_total] [N_K] [N_P] [V] [mode] [T]
 
 import sys
 import os
diff --git a/samples/rebind/plot.py b/samples/rebind/plot.py
old mode 100644
new mode 100755
index d7bc4c88..91bbb2e6
--- a/samples/rebind/plot.py
+++ b/samples/rebind/plot.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env/python
+#!/usr/bin/python
 
 # varying kf
 # python plot.py 05/data/rebind_1_0.1_ALL_t.dat 05/data/rebind_1_1_ALL_t.dat 05/data/rebind_1_10_ALL_t.dat 
diff --git a/samples/rebind/run.py b/samples/rebind/run.py
old mode 100644
new mode 100755
index 1e69b2ab..5a6d85d9
--- a/samples/rebind/run.py
+++ b/samples/rebind/run.py
@@ -1,6 +1,11 @@
 #!/usr/bin/env python
 
-# See README for a description
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
+# See README for a longer description
 
 import sys
 
diff --git a/samples/rebind/run2.py b/samples/rebind/run2.py
old mode 100644
new mode 100755
index f4c66ea9..8eae9b75
--- a/samples/rebind/run2.py
+++ b/samples/rebind/run2.py
@@ -1,9 +1,15 @@
 #!/usr/bin/env python
 
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
+
 '''
 # D_factor kf_factor seq N
 
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py 1 1 0 10
+LOGLEVEL=ERROR python -O run.py 1 1 0 10
 
 '''
 
diff --git a/samples/reversible/run.py b/samples/reversible/run.py
index 8df2696d..c5f7843e 100755
--- a/samples/reversible/run.py
+++ b/samples/reversible/run.py
@@ -1,13 +1,19 @@
 #!/usr/bin/env python
 
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
+
 '''
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.3.out 1.25e-2 5000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.2.out 1.25e-3 4000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.1.out 1.25e-4 2000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.0.out 1.25e-5 2000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.-1.out 1.25e-6 2000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.-2.out 1.25e-7 2000000 &
-LOGLEVEL=ERROR PYTHONPATH=../.. python -O run.py rev.-3.out 1.25e-8 1000000 &
+LOGLEVEL=ERROR python -O run.py rev.3.out 1.25e-2 5000000 &
+LOGLEVEL=ERROR python -O run.py rev.2.out 1.25e-3 4000000 &
+LOGLEVEL=ERROR python -O run.py rev.1.out 1.25e-4 2000000 &
+LOGLEVEL=ERROR python -O run.py rev.0.out 1.25e-5 2000000 &
+LOGLEVEL=ERROR python -O run.py rev.-1.out 1.25e-6 2000000 &
+LOGLEVEL=ERROR python -O run.py rev.-2.out 1.25e-7 2000000 &
+LOGLEVEL=ERROR python -O run.py rev.-3.out 1.25e-8 1000000 &
 '''
 
 import sys
diff --git a/samples/simple/simple.py b/samples/simple/simple.py
old mode 100644
new mode 100755
index 82a11adc..7f5c902e
--- a/samples/simple/simple.py
+++ b/samples/simple/simple.py
@@ -1,5 +1,11 @@
 #!/usr/bin/env python
 
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
+
 # Modules
 import sys
 
diff --git a/samples/single/run.py b/samples/single/run.py
old mode 100644
new mode 100755
index c185e5a3..2d6643ce
--- a/samples/single/run.py
+++ b/samples/single/run.py
@@ -1,7 +1,13 @@
 #!/usr/bin/env python
 
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
+
 '''
- PYTHONPATH=../.. python -O run.py single.0.out 5e-4 3e-8 100000
+ python -O run.py single.0.out 5e-4 3e-8 100000
 '''
 
 
diff --git a/samples/template/template.py b/samples/template/template.py
old mode 100644
new mode 100755
index 1a50dfba..3b77d901
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -1,12 +1,16 @@
-#!/usr/bin/env python
+#!/usr/bin/python
 
 # Template file to copy and paste basic code from.
+#
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
 
 # Modules
 # ===============================
 import sys
-#Also, set relative python path
-sys.path.append('../../')
 import os
 
 from egfrd import *
@@ -81,27 +85,3 @@
 # stop logger, writing away essential data
 l.stop()
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/samples/tf/tf.py b/samples/tf/tf.py
old mode 100644
new mode 100755
index a60b70d8..0b036b43
--- a/samples/tf/tf.py
+++ b/samples/tf/tf.py
@@ -1,11 +1,15 @@
 #!/usr/bin/env python
 
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+#
+#
 # Run with bash command:
 # $ python tf.py
 
 import sys
-#Also, set relative python path
-sys.path.append('../../')
 import os
 
 from egfrd import *

From 39ab426d66645cd0ce3cf19104a4db8be6295634 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 2 Aug 2011 14:26:01 +0200
Subject: [PATCH 0105/1541] Improved readability of the code, now also more
 consistent with thesis Laurens Bossen

---
 GreensFunction2DRadAbs.cpp | 44 +++++++++++++++++++++++---------------
 GreensFunction2DRadAbs.hpp |  4 ++--
 2 files changed, 29 insertions(+), 19 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 25343ef4..6e931b4f 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -301,34 +301,35 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 	const Real a_An (a*alpha);
 	const Real r0An (r0*alpha);
 
-        const Real J0_aAn  (gsl_sf_bessel_J0(s_An));	// calculate all the required Bessel functions
-        const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
-        const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
-	const Real J1_bAn  (gsl_sf_bessel_J1(a_An));
+        const Real J0_sAn  (gsl_sf_bessel_J0(s_An));	// calculate all the required Bessel functions
+        const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+        const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+	const Real J1_aAn  (gsl_sf_bessel_J1(a_An));
 
         const Real J0_r0An (gsl_sf_bessel_J0(r0An));
-        const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
+        const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
         const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
 
-	const Real Y1_bAn  (gsl_sf_bessel_Y1(a_An));
-	const Real Y1_aAn  (gsl_sf_bessel_Y1(s_An));
+	const Real Y1_aAn  (gsl_sf_bessel_Y1(a_An));
+	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
-	// calculate An,0
+	// calculate C0,n
         const Real alpha_sq (alpha*alpha);
 
-        const Real rho (h*J0_aAn + alpha*J1_aAn);
+        const Real rho (h*J0_sAn + alpha*J1_sAn);		// this is only the numerator of rho
         const Real rho_sq (rho*rho);
 
-        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+        const Real B_n_0 (J0_r0An*Y0_aAn - Y0_r0An*J0_aAn);	// B_0,n (r')
 
-        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+        const Real C_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
 
 	// calculate the integral over Bn,0
-	const Real B_n_0_int_tmp (Y0_bAn*( a*J1_bAn - sigma*J1_aAn ) - J0_bAn*( a*Y1_bAn - sigma*Y1_aAn ));
-	const Real B_n_0_int (B_n_0_int_tmp/alpha);
+	//const Real B_n_0_int_tmp (Y0_aAn*( a*J1_aAn - sigma*J1_sAn ) - J0_aAn*( a*Y1_aAn - sigma*Y1_sAn ));
+	const Real dB_n_0dr (J1_sAn*Y0_aAn - Y1_sAn*J0_aAn);	// this is only the part without alpha of dB0,n(sigma)/dr
+	const Real B_n_0_int (Real(2.0)/(M_PI*alpha_sq) - (sigma/alpha)*dB_n_0dr);
 
 	// return the total result
-	const Real result (A_i_0 * B_n_0_int);
+	const Real result (C_i_0 * B_n_0_int);
 	return result;
 }
 
@@ -441,13 +442,18 @@ GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 	Y0J1J0Y1_Table.reserve( alphaTable_0.size() );
 
 	boost::tuple<Real,Real,Real> result;
+
+	std::clog << "building Y0J0Tables... ";
 	
 	for (unsigned int count = 0; count < alphaTable_0.size(); count++)
 	{	result = Y0J0J1_constants(alphaTable_0[count], t);
+
 		Y0_Table.push_back (result.get<0>());
 		J0_Table.push_back (result.get<1>());
 		Y0J1J0Y1_Table.push_back (result.get<2>());
 	}
+
+	std::clog << "done" << std::endl;
 }
 
 
@@ -667,8 +673,7 @@ const Real
 GreensFunction2DRadAbs::p_survival_table_F( const Real t,
                     					const p_survival_table_params* params )
 {
-    const GreensFunction2DRadAbs* const gf( params->gf ); // the current gf (not sure why this is
-								    // here)
+    const GreensFunction2DRadAbs* const gf( params->gf ); // the current gf (not sure why this is here)
 //    const Real r0(this->getr0()) // not necessary since r0 now class parameter // OLD ( params->r0 ); 
     RealVector& table( params->table );		// table is empty but will be filled in p_survival_table
     const Real rnd( params->rnd );
@@ -968,7 +973,7 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	const Real a( this->geta() );
 	const Real D( this->getD() );
 	const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
-    const Real r0( this->getr0() );
+	const Real r0( this->getr0() );
 
 
 	const Real alpha_sq( alpha * alpha );
@@ -1270,16 +1275,21 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 	}
 
 	// making the tables with constants
+	std::clog << "Making table p_mTable... ";
+
 	RealVector p_mTable;			// a table with constants to make calculations much faster
 	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
 	{
+		std::clog << "at a... ";
 		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
 	}
 	else
 	{
+		std::clog << "NOT at a... ";
 		makep_mTable( p_mTable, r, t );	// making the table of constants for the regular case
 	}
 
+	std::clog << "done" << std::endl;
 
 	// preparing the function
 	ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 };	// r, r0, t are not required
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 1fbdfb27..f1306736 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -43,9 +43,9 @@ class GreensFunction2DRadAbs
     
     GreensFunction2DRadAbs( const Real D, 
 				    const Real kf,
-                    const Real r0, 
+               			    const Real r0, 
 				    const Real Sigma,
-                    const Real a );
+		                    const Real a );
   
     virtual ~GreensFunction2DRadAbs();
 

From e18866b29d22a1709505646ec05721324fda52d2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 2 Aug 2011 14:29:42 +0200
Subject: [PATCH 0106/1541] fixed math mistake in definition of h

---
 GreensFunction2DRadAbs.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 6e931b4f..40d11b6d 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -34,12 +34,12 @@ const unsigned int GreensFunction2DRadAbs::MAX_ALPHA_SEQ;
 GreensFunction2DRadAbs::
 GreensFunction2DRadAbs( const Real D, 
 				    const Real kf,
-                    const Real r0, 
+				    const Real r0, 
 				    const Real Sigma,
-                    const Real a )
+                    		    const Real a )
     :
     PairGreensFunction(D, kf, r0, Sigma),
-    h( kf / D ),
+    h( kf / (D * 2.0 * M_PI * Sigma) ),
     a( a )
 {
     ; // do nothing

From 3c96d6260d86dc41a1f0311c5573e9ce230d29d2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 2 Aug 2011 17:37:08 +0200
Subject: [PATCH 0107/1541] Cleanup to minimize the locations of Bessel
 function use

---
 GreensFunction2DRadAbs.cpp | 151 ++++++++++++++++++++-----------------
 GreensFunction2DRadAbs.hpp |   2 +-
 2 files changed, 81 insertions(+), 72 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 40d11b6d..7ebdf52d 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -295,33 +295,33 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 {
 	const Real a( geta() );		// get the needed parameters
 	const Real sigma( getSigma() );
-        const Real h (this->geth());	// is this the correct one or do I need to use kf?
+//        const Real h (this->geth());	// is this the correct one or do I need to use kf?
 
 	const Real s_An (sigma*alpha);
 	const Real a_An (a*alpha);
-	const Real r0An (r0*alpha);
+//	const Real r0An (r0*alpha);
 
-        const Real J0_sAn  (gsl_sf_bessel_J0(s_An));	// calculate all the required Bessel functions
+//        const Real J0_sAn  (gsl_sf_bessel_J0(s_An));	// calculate all the required Bessel functions
         const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
         const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
-	const Real J1_aAn  (gsl_sf_bessel_J1(a_An));
+//	const Real J1_aAn  (gsl_sf_bessel_J1(a_An));
 
-        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+//        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
         const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+//        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
 
-	const Real Y1_aAn  (gsl_sf_bessel_Y1(a_An));
+//	const Real Y1_aAn  (gsl_sf_bessel_Y1(a_An));
 	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
 	// calculate C0,n
         const Real alpha_sq (alpha*alpha);
-
-        const Real rho (h*J0_sAn + alpha*J1_sAn);		// this is only the numerator of rho
-        const Real rho_sq (rho*rho);
-
-        const Real B_n_0 (J0_r0An*Y0_aAn - Y0_r0An*J0_aAn);	// B_0,n (r')
-
-        const Real C_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
+//
+//        const Real rho (h*J0_sAn + alpha*J1_sAn);		// this is only the numerator of rho
+//        const Real rho_sq (rho*rho);
+//
+//        const Real B_n_0 (J0_r0An*Y0_aAn - Y0_r0An*J0_aAn);	// B_0,n (r')
+//
+        const Real C_i_0 (calc_A_i_0(alpha)); //(alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
 
 	// calculate the integral over Bn,0
 	//const Real B_n_0_int_tmp (Y0_aAn*( a*J1_aAn - sigma*J1_sAn ) - J0_aAn*( a*Y1_aAn - sigma*Y1_sAn ));
@@ -333,35 +333,42 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 	return result;
 }
 
-// calculates the An,0 terms for determination of the flux through the outer interface
+// calculates the factor An,0 for (for example) determination of the flux through the outer interface
 const Real 
-GreensFunction2DRadAbs::leavea_i( const Real alpha) const
+GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
 {
-        const Real a( geta() );         // get the needed parameters
+        const Real a( geta() );    		        // get the needed parameters
         const Real sigma( getSigma() );
-        const Real h (this->geth());    // is this the correct one or do I need to use kf?
+        const Real h (this->geth());
 
         const Real s_An (sigma*alpha);
         const Real a_An (a*alpha);
         const Real r0An (r0*alpha);
 
-        const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
-        const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
-        const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
-
-        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
-        const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
-        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+//	const int n = 0;
+//	if ( n == 0)
+//	{
+		const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+	        const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+	        const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+
+	        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+	        const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
+	        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+//	}
+//	else
+//	{
+//	}
 
         // calculate An,0
         const Real alpha_sq (alpha*alpha);
 
-        const Real rho (h*J0_aAn + alpha*J1_aAn);
+        const Real rho (h*J0_sAn + alpha*J1_sAn);
         const Real rho_sq (rho*rho);
 
-        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+        const Real B_n_0 (J0_r0An*Y0_aAn - Y0_r0An*J0_aAn);
 
-        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
 
 	return A_i_0;
 }
@@ -372,37 +379,37 @@ GreensFunction2DRadAbs::leaves_i( const Real alpha) const
 {
         const Real a( geta() );         // get the needed parameters
         const Real sigma( getSigma() );
-        const Real h (this->geth());    // is this the correct one or do I need to use kf?
+//        const Real h (this->geth());    // is this the correct one or do I need to use kf?
 
         const Real s_An (sigma*alpha);
         const Real a_An (a*alpha);
-        const Real r0An (r0*alpha);
+//        const Real r0An (r0*alpha);
 
-        const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
-        const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
-        const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
+//        const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+        const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+        const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
+        const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+        const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
 
-        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
-        const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
-        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+//        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+//        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
 
-        const Real Y1_aAn  (gsl_sf_bessel_Y1(s_An));
 
         // calculate An,0
-        const Real alpha_sq (alpha*alpha);
-
-        const Real rho (h*J0_aAn + alpha*J1_aAn);
-        const Real rho_sq (rho*rho);
-
-        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
-
-        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0));
+//        const Real alpha_sq (alpha*alpha);
+//
+//        const Real rho (h*J0_aAn + alpha*J1_aAn);
+//        const Real rho_sq (rho*rho);
+//
+//        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+//
+        const Real A_i_0 (calc_A_i_0(alpha));		// calculate the coefficient A0,n
 
-	// calculate Bn,0(sigma, alpha)
-	const Real B_n_0_sigma (Y0_bAn * J1_aAn - J0_bAn * Y1_aAn);
+	// calculate dBn,0(sigma)/dr
+	const Real dB_n_0dr (-alpha*(J1_sAn*Y0_aAn - Y1_sAn*J0_aAn));
 
 	// calculate the total result
-	const Real result ((alpha * A_i_0 * B_n_0_sigma)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+	const Real result (A_i_0 * dB_n_0dr);
         return result;
 }
 
@@ -462,32 +469,32 @@ const boost::tuple<Real,Real,Real>
 GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 							const Real t) const
 {	const Real D(this->getD());
-	const Real h(this->geth());
+//	const Real h(this->geth());
 	const Real sigma(this->getSigma());
 	const Real a(this->geta());
-	const Real r0(this->getr0()); 
+//	const Real r0(this->getr0()); 
 
 	const Real s_An (sigma*alpha);
 	const Real a_An (a*alpha);
-	const Real r0An (r0*alpha);
+//	const Real r0An (r0*alpha);
 
-	const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
-	const Real J1_aAn  (gsl_sf_bessel_J1(s_An));
-	const Real J0_bAn  (gsl_sf_bessel_J0(a_An));
+//	const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
 
-	const Real J0_r0An (gsl_sf_bessel_J0(r0An));
-	const Real Y0_bAn  (gsl_sf_bessel_Y0(a_An));
-	const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+//	const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+	const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+	const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
+//	const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
 
-	const Real Y1_aAn  (gsl_sf_bessel_Y1(s_An));
+	const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
 
         // calculate An,0
 	const Real alpha_sq (alpha*alpha);
-	const Real rho (h*J0_aAn + alpha*J1_aAn);
-	const Real rho_sq (rho*rho);
-	const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
-	const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+//	const Real rho (h*J0_aAn + alpha*J1_aAn);
+//	const Real rho_sq (rho*rho);
+//	const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
+	const Real A_i_0 (calc_A_i_0(alpha)); //_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
 
 	// calculate the exponent with the time
 	const Real expT( std::exp(-D*alpha_sq*t));
@@ -495,9 +502,9 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	const Real Ai0_expT (A_i_0 * expT / alpha);
 
 	// calculate the large constant term in the intergral of Bn,0
-	const Real Y0J1_J0Y1 (Y0_bAn*sigma*J1_aAn - J0_bAn*sigma*Y1_aAn);
+	const Real Y0J1_J0Y1 (Y0_aAn*sigma*J1_sAn - J0_aAn*sigma*Y1_sAn);
 
-	return boost::make_tuple (Ai0_expT*Y0_bAn, Ai0_expT*J0_bAn, Ai0_expT*Y0J1_J0Y1);
+	return boost::make_tuple (Ai0_expT*Y0_aAn, Ai0_expT*J0_aAn, Ai0_expT*Y0J1_J0Y1);
 }
 
 
@@ -518,7 +525,7 @@ GreensFunction2DRadAbs::leavea_i_exp( const unsigned int i,
 					      const Real t) const
 {
     const Real alpha( this->getAlpha0( i ) );
-    return std::exp( - getD() * t * alpha * alpha ) * leavea_i( alpha );
+    return std::exp( - getD() * t * alpha * alpha ) * calc_A_i_0( alpha );
 }
 
 // adds the exponential with the time to the sum. Needed for the inner interface (reaction)
@@ -635,8 +642,9 @@ GreensFunction2DRadAbs::leaves( const Real t) const
                                         _1, t),
                            this->MAX_ALPHA_SEQ ) );
 
-    return -M_PI_2*M_PI*D*sigma*p;	// The minus is there because the flux is in the negative r
-					// direction. The minus makes the flux always positive
+    return M_PI_2*M_PI*D*sigma*p;	// The minus is not there because the flux is in the negative r
+					// direction, and the direction is already accounted for in the derivative of B0,n(r)
+					// See also leaves_i
 }
 
 // calculates the flux leaving through the outer interface at a given moment
@@ -1006,7 +1014,7 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	// calculating Bn,m(r')
 	const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
 
-	const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - Jm_aAnm*Jm_aAnm*(h*h + alpha_sq - msq/ssq)));
+	const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
 
 
 	// calculating Bn,m(r*)
@@ -1129,7 +1137,7 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         // calculating Bn,m(r')
         const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
 
-        const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - Jm_aAnm*Jm_aAnm*(h*h + alpha_sq - msq/ssq)));
+        const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
 
         // calculating the result
         const Real result( A_n_m * exp(-D*alpha_sq*t) );
@@ -1206,12 +1214,13 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
 }
 
 // This calculates the m-th term of the summation for the drawTheta calculation
+// Note that m here starts at 0 and in the equations the sum starts at 1!
 const Real 
 GreensFunction2DRadAbs::ip_theta_n( const unsigned int m,
 						const Real theta,
 						const RealVector& p_nTable) const
 {
-	const unsigned int m_p1 (m+1);
+	const unsigned int m_p1 (m+1);		// artificial increase of m to make sure m starts at 1
         return p_nTable[m_p1] * sin (m_p1*theta)/m_p1;
 }
 
@@ -1256,7 +1265,7 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 	const Real sigma( this->getSigma() );
 	const Real a( this->geta() );
 	const Real D( this->getD() );
-    const Real r0( this->getr0() );
+    	const Real r0( this->getr0() );
 
 	// input parameter range checks.
 	THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index f1306736..4066c4b1 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -113,7 +113,7 @@ class GreensFunction2DRadAbs
 
     const Real p_survival_i( const Real alpha) const;
 
-    const Real leavea_i( const Real alpha) const;
+    const Real calc_A_i_0( const Real alpha) const;
 
     const Real leaves_i( const Real alpha) const;
 

From ef06338a64af3fc26d14c9623592b2d22c73eb0e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 3 Aug 2011 12:43:03 +0200
Subject: [PATCH 0108/1541] small change to .gitignore

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index ca478f2e..54105378 100644
--- a/.gitignore
+++ b/.gitignore
@@ -91,3 +91,6 @@ test/linear_algebra_test
 test/pointer_as_ref_test
 test/EGFRDSimulator_test
 test/geometry_test
+
+# ignore vi swp files open while editting
+*.swp

From a77bfea0319a9a9694de5b154aee835906342aaa Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 3 Aug 2011 12:43:32 +0200
Subject: [PATCH 0109/1541] some preparation for using the
 CylindricalBesselGenerator

---
 GreensFunction2DRadAbs.cpp | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 7ebdf52d..9c8997c2 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -22,7 +22,7 @@
 #include "funcSum.hpp"
 #include "findRoot.hpp"
 #include "freeFunctions.hpp"
-
+#include "CylindricalBesselGenerator.hpp"
 #include "GreensFunction2DRadAbs.hpp"
 
 const Real GreensFunction2DRadAbs::MIN_T_FACTOR;
@@ -983,7 +983,6 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
 	const Real r0( this->getr0() );
 
-
 	const Real alpha_sq( alpha * alpha );
 	const Real realm( static_cast<Real>( m ) );
 	const Real msq( realm * realm);
@@ -994,17 +993,31 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	const Real r0Anm (r0*alpha);
 	const Real r_Anm (r*alpha);
 
+
+//	const CylindricalBesselGenerator& s(CylindricalBesselGenerator::instance());
+
 	// calculate the needed bessel functions
 	const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
 	const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));	// prime
+//	const Real Jm_sAnm   (s.J(m, s_Anm));
+//	const Real Jmp1_sAnm (s.J(m+1, s_Anm));	// prime
+
+	std::clog << "|";	// DEBUG
 	const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
 	const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
+//	const Real Jm_aAnm   (s.J(m, a_Anm));
+//	const Real Ym_aAnm   (s.Y(m, a_Anm));
+	std::clog << "_";	// DEBUG
 
 	const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
 	const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
+//	const Real Jm_r0Anm  (s.J(m, r0Anm));
+//	const Real Ym_r0Anm  (s.Y(m, r0Anm));
 
 	const Real Jm_rAnm   (gsl_sf_bessel_Jn(m, r_Anm));
 	const Real Ym_rAnm   (gsl_sf_bessel_Yn(m, r_Anm));
+//	const Real Jm_rAnm   (s.J(m, r_Anm));
+//	const Real Ym_rAnm   (s.Y(m, r_Anm));
 
 
 	// calculating An,m
@@ -1053,17 +1066,19 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 	const Real p_0 ( this->p_m( 0, r, t ) );	// This is the p_m where m is 0, for the denominator
 	p_mTable.push_back( p_0 );			// put it in the table
 
+	std::clog << "m=0, ";	// DEBUG
 
 	const Real p_1 ( this->p_m( 1, r, t ) / p_0 );
 	p_mTable.push_back( p_1 );			// put the first result in the table
 
+	std::clog << "m=1, ";	// DEBUG
 
 	if( p_1 == 0 )
 	{
 		return;					// apparantly all the terms are zero? We are finished
 	}
 
-	const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error
+	const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error, is this correct?
 
 	Real p_m_abs (fabs (p_1));
 	Real p_m_prev_abs;	
@@ -1077,10 +1092,13 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 			break;
 		}
 
+		std::clog << "m=" << m ;	// DEBUG
 
 		p_m_prev_abs = p_m_abs;					// store the previous term
 		const Real p_m( this->p_m( m, r, t ) / p_0 );	// get the next term
 
+		std::clog << ", ";		// DEBUG
+
 		if( ! std::isfinite( p_m ) )		// if the calculated value is not valid->exit
 		{
 			std::cerr << "makep_mTable: invalid value; " <<

From c2caf0cfe8c35784538b09fa6f822f905dd0a977 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 3 Aug 2011 12:51:14 +0200
Subject: [PATCH 0110/1541] some cleanup of comments

---
 GreensFunction2DRadAbs.cpp | 55 ++++++--------------------------------
 1 file changed, 8 insertions(+), 47 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 9c8997c2..3805dc3d 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -295,36 +295,21 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 {
 	const Real a( geta() );		// get the needed parameters
 	const Real sigma( getSigma() );
-//        const Real h (this->geth());	// is this the correct one or do I need to use kf?
 
 	const Real s_An (sigma*alpha);
 	const Real a_An (a*alpha);
-//	const Real r0An (r0*alpha);
+        const Real alpha_sq (alpha*alpha);
 
-//        const Real J0_sAn  (gsl_sf_bessel_J0(s_An));	// calculate all the required Bessel functions
+	// calculate all the required Bessel functions
         const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
         const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
-//	const Real J1_aAn  (gsl_sf_bessel_J1(a_An));
-
-//        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
         const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-//        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
-
-//	const Real Y1_aAn  (gsl_sf_bessel_Y1(a_An));
 	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
 	// calculate C0,n
-        const Real alpha_sq (alpha*alpha);
-//
-//        const Real rho (h*J0_sAn + alpha*J1_sAn);		// this is only the numerator of rho
-//        const Real rho_sq (rho*rho);
-//
-//        const Real B_n_0 (J0_r0An*Y0_aAn - Y0_r0An*J0_aAn);	// B_0,n (r')
-//
-        const Real C_i_0 (calc_A_i_0(alpha)); //(alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
+        const Real C_i_0 (calc_A_i_0(alpha)); 
 
 	// calculate the integral over Bn,0
-	//const Real B_n_0_int_tmp (Y0_aAn*( a*J1_aAn - sigma*J1_sAn ) - J0_aAn*( a*Y1_aAn - sigma*Y1_sAn ));
 	const Real dB_n_0dr (J1_sAn*Y0_aAn - Y1_sAn*J0_aAn);	// this is only the part without alpha of dB0,n(sigma)/dr
 	const Real B_n_0_int (Real(2.0)/(M_PI*alpha_sq) - (sigma/alpha)*dB_n_0dr);
 
@@ -379,30 +364,17 @@ GreensFunction2DRadAbs::leaves_i( const Real alpha) const
 {
         const Real a( geta() );         // get the needed parameters
         const Real sigma( getSigma() );
-//        const Real h (this->geth());    // is this the correct one or do I need to use kf?
 
         const Real s_An (sigma*alpha);
         const Real a_An (a*alpha);
-//        const Real r0An (r0*alpha);
 
-//        const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+	// calculate all the required Bessel functions
         const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
         const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
         const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
         const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
 
-//        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
-//        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
-
-
         // calculate An,0
-//        const Real alpha_sq (alpha*alpha);
-//
-//        const Real rho (h*J0_aAn + alpha*J1_aAn);
-//        const Real rho_sq (rho*rho);
-//
-//        const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
-//
         const Real A_i_0 (calc_A_i_0(alpha));		// calculate the coefficient A0,n
 
 	// calculate dBn,0(sigma)/dr
@@ -427,8 +399,8 @@ GreensFunction2DRadAbs::createPsurvTable( RealVector& table) const
 		    std::back_inserter( table ),
 		    boost::bind( &GreensFunction2DRadAbs::p_survival_i,
 				 this, _1) );	// This gets all the roots from 'begin' to 'end'
-							// passes them as an argument to p_survival_i and
-							// the result is passed to back_inserter
+						// passes them as an argument to p_survival_i and
+						// the result is passed to back_inserter
 }
 
 // Creates the tables with various Bessel functions used in drawR, the table is used to speed things up
@@ -469,31 +441,21 @@ const boost::tuple<Real,Real,Real>
 GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 							const Real t) const
 {	const Real D(this->getD());
-//	const Real h(this->geth());
 	const Real sigma(this->getSigma());
 	const Real a(this->geta());
-//	const Real r0(this->getr0()); 
 
 	const Real s_An (sigma*alpha);
 	const Real a_An (a*alpha);
-//	const Real r0An (r0*alpha);
-
-//	const Real J0_aAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+	const Real alpha_sq (alpha*alpha);
 
-//	const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+	// calculate all the required Bessel functions
 	const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
 	const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-//	const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
-
 	const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
 	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
 
         // calculate An,0
-	const Real alpha_sq (alpha*alpha);
-//	const Real rho (h*J0_aAn + alpha*J1_aAn);
-//	const Real rho_sq (rho*rho);
-//	const Real B_n_0 (J0_r0An*Y0_bAn - Y0_r0An*J0_bAn);
 	const Real A_i_0 (calc_A_i_0(alpha)); //_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
 
 	// calculate the exponent with the time
@@ -682,7 +644,6 @@ GreensFunction2DRadAbs::p_survival_table_F( const Real t,
                     					const p_survival_table_params* params )
 {
     const GreensFunction2DRadAbs* const gf( params->gf ); // the current gf (not sure why this is here)
-//    const Real r0(this->getr0()) // not necessary since r0 now class parameter // OLD ( params->r0 ); 
     RealVector& table( params->table );		// table is empty but will be filled in p_survival_table
     const Real rnd( params->rnd );
 

From 263dc95d8f3c4a86803e05da25faa406d1fdcc61 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 3 Aug 2011 18:15:22 +0200
Subject: [PATCH 0111/1541] Finisched the 1D BD simulator, but greatly
 simplified the algorithm. Now, when a particle dissociates, the functions
 used for generating an inter particle vector between the two new particles,
 is drawn from the _same_ distribution as the one they came from before
 associating. Before we flipped the drift direction in the distribution
 function, which is more physical but increases the complexity.

Added a check for better convergence in the GreensFunction1DAbsAbs::drawR method. When, either due to an dissociating particle or two associating particles, a very small timestep is drawn, the GF used in draw converges badly. Now, when a particle is far away from both boundaries (H*2Dt < L-r0), the free GF'n is used to draw a new (c.o.m.) position.

Added some extra text in assertion errors for debugging.
---
 CylindricalSurface.hpp     |  57 ++++++++++------
 GreensFunction1DAbsAbs.cpp | 132 +++++++++++++++++++++++--------------
 GreensFunction1DAbsAbs.hpp |   5 +-
 GreensFunction1DRadAbs.cpp |   4 +-
 greens_functions.cpp       |   2 +-
 5 files changed, 127 insertions(+), 73 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 08e2cfbd..025aac98 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -2,6 +2,7 @@
 #define CYLINDRICAL_SURFACE_HPP
 
 #include <boost/bind.hpp>
+#include <iostream>
 #include "Surface.hpp"
 #include "Cylinder.hpp"
 //#include "freeFunctions.hpp"
@@ -42,35 +43,51 @@ class CylindricalSurface
 
     virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
     {
+
+        /* The inter particle vector (ipv) points from A -> B, where A initiated overlap. */
+        Real ipv = dot_product( ipv, base_type::shape().unit_z() );
+        Real abs_ipv = fabs( ipv );
+        Real v = v1 - v0;
+        Real D01 = D0 + D1;
+
+        Real correction = exp( -ipv/abs_ipv * (abs_ipv - r01) * v/D01 );
+       
         /*
             The I_bd factors used for calculating the acceptance probability are dependent on the direction 
-            of the overlap step (step_direction = r_1 - r_0), compared to the direction of the drift. 
-            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0). 
-            If the particle comes from the left, we invert (v *= -1) the direction of its drift.
-        */
-        length_type step_direction = dot_product( ipv, base_type::shape().unit_z() );
+            of the overlap step (r = r_1 - r_0), compared to the direction of the drift. 
+            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0).
+            Since the I_bd terms calulated here are for the backward move, we have to invert their drifts.
+            When the particle comes from the left (r > 0) we have to invert its drift again.
 
-        if( step_direction > 0 )
-            v0 *= -1;
-        else
-            v1 *= -1;
+            ---Code below is used for drift dependent backstep.
+
+            Real numerator = g_bd_1D(ipv, r01, dt, D0, -v0);
+            Real denominator = g_bd_1D(ipv, r01, dt, D0, v0)*exp( ipv/abs_ipv*(abs_ipv - r01)*v/D01 );
+            Real correction = numerator/denominator;
 
-        return k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) );
+            if( ipv < 0 )
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, -v0) + I_bd_1D(r01, dt, D1, v1) ) );
+            else
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, -v1) ) );
+
+            Also change v -> -v in drawR for the dissociation move.
+        */
+
+        return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
+  
     }
 
     virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
     {
-        Real I_A( I_bd_1D(r01, dt, D01, v) );        
-        Real prob( rng()*(I_A + I_bd_1D(r01, dt, D01, -v)) );
-        Real rnd( rng() );
-
-        if( prob < I_A )    
-            return multiply(base_type::shape().unit_z(), drawR_gbd( rnd, r01, dt, D01, v ) );
+        //Real I_01( I_bd_1D(r01, dt, D01,  v) );        
+        //Real I_10( I_bd_1D(r01, dt, D01, -v) ); 
+        //Real prob( rng()*(I_01 + I_10 );
+        Real prob( rng() );
+        
+        if( prob < 0.5 ) 
+            return base_type::shape().unit_z() * drawR_gbd( rnd, r01, dt, D01, v );
         else
-        {
-            position_type direction( base_type::shape().unit_z() * -1. );
-            return multiply( direction, drawR_gbd( rnd, r01, dt, D01, -v ) );    
-        }
+            return base_type::shape().unit_z() * -1. * drawR_gbd( rnd, r01, dt, D01, v );
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 7f42c763..1b0100d4 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -66,7 +66,7 @@ GreensFunction1DAbsAbs::p_survival (Real t) const
       {
 	  if (n >= MAX_TERMS )
 	  {
-	      std::cerr << "Too many terms for p_survival. N: " << n << std::endl;
+	      std::cerr << "Too many terms for GF1DAbs::p_survival. N: " << n << std::endl;
 	      break;
 	  }
 	  
@@ -160,7 +160,7 @@ GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     {
 	if (n >= MAX_TERMS )
 	{
-	    std::cerr << "Too many terms for prob_r. N: " << n << std::endl;
+	    std::cerr << "Too many terms for GF1DAbs::prob_r. N: " << n << std::endl;
 	    break;
 	}
 
@@ -224,7 +224,7 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     {
 	if (n >= MAX_TERMS )
 	{
-	    std::cerr << "Too many terms for p_survival. N: " << n << std::endl;
+	    std::cerr << "Too many terms for GF1DAbs::leaves. N: " << n << std::endl;
 	    break;
 	}
 
@@ -279,7 +279,7 @@ GreensFunction1DAbsAbs::leavea(Real t) const
      {
        if (n >= MAX_TERMS )
        {
-	 std::cerr << "Too many terms for leaves. N: " << n << std::endl;
+	 std::cerr << "Too many terms for GF1DAbs::leavea. N: " << n << std::endl;
 	 break;
        }
        
@@ -380,7 +380,7 @@ GreensFunction1DAbsAbs::drawT_f (double t, void *p)
     prefactor = params->prefactor;
     
     // find intersection with the random number
-    return 1.0 - prefactor*sum - params->rnd;
+    return params->rnd - prefactor*sum; 
 }
 
 // Draws the first passage time from the propensity function.
@@ -465,8 +465,8 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     }
 
     // the prefactor of the sum is also different in case of drift<>0 :
-    if(v==0)	prefactor = 2.0*exp(vexpo_pref);
-    else	prefactor = 2.0;
+    if(v == 0)	prefactor = 2.0;
+    else	prefactor = 2.0*exp(vexpo_pref);
     parameters.prefactor = prefactor;
     
     parameters.rnd = rnd;
@@ -556,15 +556,22 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     return t;
 }
 
+Real GreensFunction1DAbsAbs::drawR_free_f(double r, drawR_params const* params)
+{
+    const Real D(params->H[0]);
+    const Real vt(params->H[1]*params->H[2]);
+    const Real sqrt4Dt(sqrt( 4 * D * params->H[2] ));
+
+    return 0.5*( 1.0 + erf( (r - vt) / sqrt4Dt ) ) - params->rnd;
+}
 
 // This is a help function that casts the drawR_params parameter structure into
 // the right form and calculates the survival probability from it (and returns it).
 // The routine drawR uses this function to sample the exit point, making use of the
 // GSL root finder to draw the random position.
 double
-GreensFunction1DAbsAbs::drawR_f (double r, void *p)
+GreensFunction1DAbsAbs::drawR_f (double r, drawR_params const* params)
 {   
-    struct drawR_params *params = (struct drawR_params *)p;
     double sum = 0, term = 0, prev_term = 0;
     double S_Cn_An, n_L;
     int    terms = params->terms;
@@ -616,6 +623,7 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     const Real r0(this->getr0());
     const Real D(this->getD());
     const Real v(this->getv());
+    const Real vt( v*t );
 
     // the trivial case: if there was no movement or the domain was zero
     if ( (D==0.0 && v==0.0) || L<0.0 || t==0.0)
@@ -633,55 +641,81 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     // From here on the problem is well defined
 
 
-    // structure to store the numbers to calculate numbers for 1-S(t)
+    const Real thresholdDistance(this->CUTOFF_H * sqrt(2.0 * D * t));
+
     struct drawR_params parameters;
-    Real S_Cn_An;
-    Real nPI;
-    const Real expo (-D*t/(L*L));
-    const Real r0s_L((r0-sigma)/L);
-    const Real v2D(v/2.0/D);
-    const Real Lv2D(L*v/2.0/D);
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);	// exponent of the drift-prefactor, same as in survival prob.
-    const Real S = 2.0*exp(vexpo)/p_survival(t);	// This is a prefactor to every term, so it also contains there
+    gsl_function F;
+    F.params = &parameters;
+    Real psurv;
+
+    if ((r0 + vt - sigma) <= thresholdDistance || (a - r0 - vt) <= thresholdDistance)
+    {
+        psurv = p_survival(t);
+
+        assert(psurv >= 0.0);
+
+        // structure to store the numbers to calculate numbers for 1-S(t)
+        Real S_Cn_An;
+        Real nPI;
+        const Real expo (-D*t/(L*L));
+        const Real r0s_L((r0-sigma)/L);
+        const Real v2D(v/2.0/D);
+        const Real Lv2D(L*v/2.0/D);
+        const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);	// exponent of the drift-prefactor, same as in survival prob.
+        const Real S = 2.0*exp(vexpo)/psurv;	// This is a prefactor to every term, so it also contains there
 							// exponential drift-prefactor.
 
-    // Construct the coefficients and the terms in the exponent and put them 
-    // in the params structure
-    int n=0;
-    do
+        // store needed constants
+        parameters.H[0] = sigma;
+        parameters.H[1] = v2D;
+
+        // Construct the coefficients and the terms in the exponent and put them 
+        // in the params structure
+        int n=0;
+        do
+        {
+	        nPI = ((Real)(n+1))*M_PI;	    // note: summation starting with n=1, indexing with n=0, therefore we need n+1 here
+	    
+	        if(v==0.0)	S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
+	        else		S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) * nPI/(nPI*nPI + Lv2D*Lv2D);
+	        // The rest is the z-dependent part, which has to be defined directly in drawR_f(z).
+	        // Of course also the summation happens there because the terms now are z-dependent.
+	        // The last term originates from the integrated prob. density including drift.
+	        //
+	        // In case of zero drift this expression becomes: 2.0/p_survival(t) * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI
+	      
+	        // also store the values for the exponent, so they don't have to be recalculated in drawR_f
+	        parameters.S_Cn_An[n]= S_Cn_An;
+	        parameters.n_L[n]    = nPI/L;
+	        n++;
+        }
+        while (n<MAX_TERMS);
+    
+        F.function = reinterpret_cast<typeof(F.function)>(&drawR_f);
+    }
+    else
     {
-	nPI = ((Real)(n+1))*M_PI;	    // note: summation starting with n=1, indexing with n=0, therefore we need n+1 here
-	
-	if(v==0.0)	S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
-	else		S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) * nPI/(nPI*nPI + Lv2D*Lv2D);
-	  // The rest is the z-dependent part, which has to be defined directly in drawR_f(z).
-	  // Of course also the summation happens there because the terms now are z-dependent.
-	  // The last term originates from the integrated prob. density including drift.
-	  //
-	  // In case of zero drift this expression becomes: 2.0/p_survival(t) * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI
-	  
-	// also store the values for the exponent, so they don't have to be recalculated in drawR_f
-	parameters.S_Cn_An[n]= S_Cn_An;
-	parameters.n_L[n]    = nPI/L;
-	n++;
+        parameters.H[0] = D;
+        parameters.H[1] = v;
+        parameters.H[3] = t;
+
+        // drawR_f < drawR_free_f
+        if (drawR_free_f(L, &parameters) < rnd)
+        {
+            std::cerr << "drawR_free_f(L, t) < rnd, returning (r0 - sigma) <= (a - r0) ? sigma : a" << std::endl;
+            return (r0 - sigma) <= (a - r0) ? sigma : a;
+        }
+    
+        F.function = reinterpret_cast<typeof(F.function)>(&drawR_free_f);
     }
-    while (n<MAX_TERMS);
-
+    
     // store the random number for the probability
     parameters.rnd = rnd ;
     // store the number of terms used
     parameters.terms = MAX_TERMS;
-    
-    // store needed constants
-    parameters.H[0] = sigma;
-    parameters.H[1] = v2D;
-
-    // find the intersection on the y-axis between the random number and 
-    // the function
-    gsl_function F;
-    F.function = &drawR_f;
-    F.params = &parameters;
+   
 
+    // find the intersection on the y-axis between the random number and the function
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     // make a new solver instance
@@ -690,7 +724,7 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     const Real r( findRoot( F, solver, sigma, a, L*EPSILON, EPSILON,
                             "GreensFunction1DAbsAbs::drawR" ) );
 
-    // return the drawn time
+    // return the drawn position
     return r;
 }
 
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 00d3154b..0c4a9d25 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -41,6 +41,8 @@ class GreensFunction1DAbsAbs: public GreensFunction
     static const int MAX_TERMS = 500;
     // The minimum
     static const int MIN_TERMS = 20;
+    // Cutoff distance: When H * sqrt(2Dt) < 1/2*L, use free greensfunction instead of absorbing.
+    static const Real CUTOFF_H = 6.0;
 
 
 public:
@@ -188,7 +190,8 @@ class GreensFunction1DAbsAbs: public GreensFunction
         double rnd;
     };
 
-    static double drawR_f (double z, void *p);
+    static double drawR_f (double z, drawR_params const* params);
+    static double drawR_free_f (double z, drawR_params const* params);
 
 private:
     // The diffusion constant and drift velocity
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 13e9f5f4..b8f866f2 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -506,7 +506,7 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
 
 	    if( fabs( high ) >= t_guess * 1e6 )
 	    {
-		std::cerr << "GF1DRad: Couldn't adjust high. F("
+		std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
 		          << high << ") = " << value << std::endl;
 		throw std::exception();
 	    }
@@ -524,7 +524,7 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
 	    if( fabs( low ) <= t_guess * 1e-6 ||
 	        fabs(value-value_prev) < EPSILON*1.0 )
 	    {
-		std::cerr << "GF1DRad: Couldn't adjust low. F(" << low << ") = "
+		std::cerr << "GF1DRad::drawTime Couldn't adjust low. F(" << low << ") = "
 		          << value << " t_guess: " << t_guess << " diff: "
 		          << (value - value_prev) << " value: " << value
 		          << " value_prev: " << value_prev << " rnd: "
diff --git a/greens_functions.cpp b/greens_functions.cpp
index e6b7e02e..c345a845 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -53,7 +53,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "leavea", &GreensFunction1DAbsAbs::leavea )
         .def( "p_survival", &GreensFunction1DAbsAbs::p_survival )
         .def( "calcpcum", &GreensFunction1DAbsAbs::calcpcum )
-        .def( "dump", &GreensFunction1DRadAbs::dump )
+        .def( "dump", &GreensFunction1DAbsAbs::dump )
         ;
 
     class_<GreensFunction1DRadAbs>("GreensFunction1DRadAbs",

From d45c93d69e69e2484dcb4785052442d562cdea06 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Thu, 4 Aug 2011 12:26:16 +0200
Subject: [PATCH 0112/1541] Sample scripts to start eGFRD jobs on a TORQUE/Maui
 cluster.

---
 samples/PBS/README     | 20 ++++++++++++
 samples/PBS/egfrd.qsub | 70 ++++++++++++++++++++++++++++++++++++++++++
 samples/PBS/submit     | 65 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 155 insertions(+)
 create mode 100644 samples/PBS/README
 create mode 100644 samples/PBS/egfrd.qsub
 create mode 100755 samples/PBS/submit

diff --git a/samples/PBS/README b/samples/PBS/README
new file mode 100644
index 00000000..498e6cec
--- /dev/null
+++ b/samples/PBS/README
@@ -0,0 +1,20 @@
+
+This directory contains a sample PBS script (egfrd.qsub) to be used for starting
+jobs on a TORQUE/Maui operated cluster with the "qsub" command and a bash script
+(submit) which automatically submits series of jobs to the cluster (using "qsub").
+
+To run a sample on the cluster, copy both scripts into the directory you want to
+run the sample from and replace the start command in "egfrd.qsub".
+To submit one job type
+
+  ./submit 1 egfrd.qsub [error path]
+
+[error path] is an optional argument specifying the output path for the default
+and error output streams and is set to the directory you start "submit" from
+by default.
+
+Both scripts are commented and an example for a job start command is given
+in "egfrd.qsub".
+
+
+Written by:	Thomas Sokolowski (sokolowski@amolf.nl), Aug 2011
diff --git a/samples/PBS/egfrd.qsub b/samples/PBS/egfrd.qsub
new file mode 100644
index 00000000..4f5c27d8
--- /dev/null
+++ b/samples/PBS/egfrd.qsub
@@ -0,0 +1,70 @@
+########################################################################
+# Abstract : Sample PBS/bash script to start a simple eGFRD simulation #
+# Author: Thomas Sokolowski (sokolowski@amolf.nl)                      #
+# Date  : 2011-08-02                                                   #
+########################################################################
+
+########################################################################
+# OPTIONS FOR PBS MACRO:                                               #
+#                                                                      #
+# -S: shell to be used for your scripts                                #
+# -l: provide extra options/resources                                  #
+#     notes=x:ppn=y                                                    #
+#       allocate x nodes with y processors each                        #
+#     walltime=hh:mm:ss                                                #
+#       allocate cpu time                                              #
+# -N: job name as shown in the queue                                   #
+#                                                                      #   
+########################################################################
+ 
+#PBS -S /bin/bash
+#PBS -l nodes=1:ppn=1,walltime=24:00:00
+#PBS -N eGFRDjob
+
+# Specify the job directory to which the queing system will redirect
+# its output
+JOB_DIR="/home/thomas/egfrd/samples/irreversible"
+
+# Specify the eGFRD directory
+# PYTHONPATH is set to this directory before the script is started
+EGFRD_DIR="/home/thomas/egfrd/"
+
+# Specify the start command
+# This could also be put into a startscript
+JOB_CMD="***PUT IN JOB START COMMAND WITH FULL PARAMTER LIST HERE***"
+# ( example: JOB_CMD="python26 run.py cluster.out 0.0001 100000" )
+
+# Define output log file
+OUTLOG="run.log"
+
+########################################################################
+# Here the job starts                                                  #
+########################################################################
+
+# First print some log info
+echo "----------------------------------------------------------------"
+echo "Attempting to start PBS job..."
+echo
+echo "Start time:       $(date)"
+echo "Host:             $(hostname)"
+echo "Root directory:   $(pwd)"
+echo "Job directory:    ${JOB_DIR}"
+echo "Job command:      ${JOB_CMD}"
+echo "----------------------------------------------------------------"
+
+# Enter job directory
+pushd ${JOB_DIR}
+
+# Run job command with parameters and redirect output
+PYTHONPATH=${EGFRD_DIR} ${JOB_CMD}
+
+# Return to previous directory
+popd
+
+# Print some final log info
+echo "----------------------------------------------------------------"
+echo "Job finished."
+echo "End time:         $(date)"
+echo "----------------------------------------------------------------"
+
+
diff --git a/samples/PBS/submit b/samples/PBS/submit
new file mode 100755
index 00000000..4bf581ee
--- /dev/null
+++ b/samples/PBS/submit
@@ -0,0 +1,65 @@
+#!/bin/sh
+#
+################################################################
+# Submits a job to a TORQUE/Maui operated cluster using qsub   #
+# Started by Koos van Meel, modified by Thomas Sokolowski      #
+#                                                              #
+# The script can start iterations of a job and make the        #
+# subsequent job be dependent on the outcome of the previous.  # 
+#                                                              #
+# For the error path argument is optional and most likely      #
+# you want to set ".", i.e. the error output is redirected     #
+# into the directory the script is started from.               #
+################################################################
+
+# Check command syntax
+if [ $# -lt 2 ];
+then
+  echo "Usage: submit <iterations> <script> [errorpath]"
+  exit
+fi
+
+# Set cluster script name
+SCRIPT=$2
+
+# Set path for the error and output stream. If no argument passed,
+# set it to the current working directory
+if [ "$3" != "" ];
+  then  ERRPATH=$(echo "$3")
+  else  ERRPATH=$(pwd)
+fi
+
+# Output all job ids to a file <script>.jobids
+JOBIDS=${SCRIPT}.jobIDs
+
+# Get number of iterations
+ITERATIONS=$1
+
+# Initialize: Start with iteration counter 0
+I=0
+# First job does not have any dependencies, so leave this like it is!
+DEPEND=
+
+# Loop over all iterations
+while [ $I -lt $ITERATIONS ];
+do
+	# Submit job and print some screen info
+	echo "qsub: DEPEND=$DEPEND"
+	echo "qsub: ERRPATH=$ERRPATH"
+	echo "qsub: SCRIPT=$SCRIPT"
+	echo 'Executing: qsub -e $ERRPATH -o $ERRPATH $DEPEND $SCRIPT'
+
+	JOBID=$( qsub -e $ERRPATH -o $ERRPATH $DEPEND $SCRIPT )
+
+	# Create a job-id list
+	echo "$JOBID" >> $JOBIDS
+
+	# Update dependency
+        # With the following code the job will only start if the
+        # currently started one will terminate properly
+	DEPEND="-W depend=afterok:$JOBID"
+
+	# next iteration
+	(( I++ ))
+done
+

From 6063ecabc5ab08e473a0216789c17c8e5ea656d2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 4 Aug 2011 18:32:15 +0200
Subject: [PATCH 0113/1541] Minor style changes and comments

---
 GreensFunction2DRadAbs.cpp |  6 +++--
 egfrd.py                   | 47 +++++++++++++++++++++++++-------------
 gfrdbase.py                |  6 ++---
 model.py                   |  9 ++++----
 pair.py                    |  3 ++-
 5 files changed, 45 insertions(+), 26 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 3805dc3d..b87d96d4 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -422,7 +422,7 @@ GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 
 	boost::tuple<Real,Real,Real> result;
 
-	std::clog << "building Y0J0Tables... ";
+	std::clog << "building Y0J0Tables... ";	// DEBUG
 	
 	for (unsigned int count = 0; count < alphaTable_0.size(); count++)
 	{	result = Y0J0J1_constants(alphaTable_0[count], t);
@@ -432,7 +432,7 @@ GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 		Y0J1J0Y1_Table.push_back (result.get<2>());
 	}
 
-	std::clog << "done" << std::endl;
+	std::clog << "done" << std::endl;	// DEBUG
 }
 
 
@@ -580,7 +580,9 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
         if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
         {						// that the table is filled
         	IGNORE_RETURN getAlpha0( maxi );	// this updates the table of roots
+		std::clog << "creating PsurvTable... ";	// DEBUG
                 this->createPsurvTable( psurvTable);	// then the table is filled with data
+		std::clog << "done" << std::endl;	// DEBUG
         }
 //std::cout << "p_survival_2DPair ";
         p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
diff --git a/egfrd.py b/egfrd.py
index fe28e139..c51810de 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -133,17 +133,17 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.MULTI_SHELL_FACTOR = 0.05
         self.SINGLE_SHELL_FACTOR = 1.1
 
-        self.is_dirty = True
+        self.is_dirty = True			# what does this mean?
         self.scheduler = EventScheduler()
 
-        self.user_max_shell_size = numpy.inf
+        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
 
         self.domains = {}
 
         self.reset()
 
     def get_matrix_cell_size(self):
-        return self.containers[0].cell_size
+        return self.containers[0].cell_size	# cell_size is the width of the (cubic) cell
 
     def get_next_time(self):
         """ 
@@ -151,10 +151,11 @@ def get_next_time(self):
         is completed.        
         """ #~MW
         if self.scheduler.size == 0:
-            return self.t
-
-        return self.scheduler.top[1].time
+            return self.t			# self.t is the current time of the simulator
+	else:
+            return self.scheduler.top[1].time
 
+    # Here shell_size is actually the shell radius (and not shell diameter)
     def set_user_max_shell_size(self, size):
         self.user_max_shell_size = size
 
@@ -165,6 +166,9 @@ def get_max_shell_size(self):
         return min(self.get_matrix_cell_size() * .5 / SAFETY,
                    self.user_max_shell_size)
 
+    ###
+    # The next methods control the general functioning of the simulator
+    ###
     def reset(self):
         """
         This function resets the "records" of the simulator. This means
@@ -196,9 +200,14 @@ def reset(self):
         self.is_dirty = True
 
     def initialize(self):
+	"""Initialize the eGFRD simulator
+
+	Not sure what that means yet
+	"""
         ParticleSimulatorBase.initialize(self)
 
         self.scheduler.clear()
+	# These containers hold the spherical and cylindrical protective domains respectively 
         self.containers = [SphericalShellContainer(self.world.world_size, 
                                                    self.world.matrix_size),
                            CylindricalShellContainer(self.world.world_size, 
@@ -246,7 +255,7 @@ def stop(self, t):
         if __debug__:
             log.info('stop at %s' % (FORMAT_DOUBLE % t))
 
-        if self.t == t:
+        if self.t == t:			# FIXME: is this accurate? Probably use feq from utils.py
             return
 
         if t >= self.scheduler.top[1].time:
@@ -259,7 +268,7 @@ def stop(self, t):
 
         non_single_list = []
 
-        # first burst all Singles.
+        # first burst all Singles, and put Pairs and Multis in a list.
         for id, event in self.scheduler:
             obj = event.data
             if isinstance(obj, Pair) or isinstance(obj, Multi):
@@ -270,7 +279,7 @@ def stop(self, t):
                               (obj, FORMAT_DOUBLE % obj.last_time))
                 self.burst_single(obj)
             else:
-                assert False, 'do not reach here'
+                assert False, 'object from scheduler was no Single, Pair or Multi'
 
 
         # then burst all Pairs and Multis.
@@ -297,8 +306,10 @@ def step(self):
 
         if __debug__:
             if self.scheduler.size == 0:
-                raise RuntimeError('No particles in scheduler.')
-
+                raise RuntimeError('No Events in scheduler.')
+	
+	# 1. Get the next event from the scheduler
+	#
         id, event = self.scheduler.pop()
         self.t, self.last_event = event.time, event
 
@@ -311,18 +322,22 @@ def step(self):
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
        
-        # Dispatch is simply dict of what function to use to fire for 
-        # different classes (see bottom egfrd.py) 
-        # event.data simply holds the data of the next event.
-        # e.g. "if class is single fire single" ~ MW
+	# 2. Use the correct method to process (fire) the shell that produced the event
+	#
+        # Dispatch is a dictionary (hash) of what function to use to fire
+        # different classes of shells (see bottom egfrd.py) 
+        # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
+        # e.g. "if class is Single, then fire_single" ~ MW
         for klass, f in self.dispatch:
             if isinstance(event.data, klass):
-                f(self, event.data)
+                f(self, event.data)		# fire the correct method for the class (e.g. fire_singel(self, Single))
 
         if __debug__:
             if self.scheduler.size == 0:
                 raise RuntimeError('Zero events left.')
 
+	# 3. Adjust the simulation time
+	#
         next_time = self.scheduler.top[1].time
         self.dt = next_time - self.t
 
diff --git a/gfrdbase.py b/gfrdbase.py
index 80c8a9cc..fdfda5a7 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -80,9 +80,6 @@ def p_free(r, t, D):
 
     return p * jacobian
     
-class NoSpace(Exception):
-    pass
-
 def get_closest_surface(world, pos, ignore):
     """Return
       - closest surface
@@ -410,3 +407,6 @@ def check(self):
     def print_report(self):
         pass
 
+class NoSpace(Exception):
+    pass
+
diff --git a/model.py b/model.py
index d5d89498..3f55d098 100644
--- a/model.py
+++ b/model.py
@@ -107,7 +107,8 @@
 
 """
 
-
+# Species is just a function, not a class. It seems to be a frontend to the
+# constructor of _gfrd.SpeciesType
 def Species(name, D, radius=0, structure="world", drift=0):
     """Define a new Species (in/on a specific Region or Surface).
 
@@ -185,6 +186,9 @@ def add_structure(self, structure):
         self.structures[structure.id] = structure
         return structure
 
+    def get_structure(self, id): 
+        return self.structures[id]
+
     def add_reaction_rule(self, reaction_rule):
         """Add a ReactionRule to the ParticleModel.
 
@@ -196,9 +200,6 @@ def add_reaction_rule(self, reaction_rule):
         """
         self.network_rules.add_reaction_rule(reaction_rule)
 
-    def get_structure(self, id): 
-        return self.structures[id]
-
     def set_all_repulsive(self):
         """Set all 'other' possible ReactionRules to be repulsive.
 
diff --git a/pair.py b/pair.py
index 5f39051b..4479e889 100644
--- a/pair.py
+++ b/pair.py
@@ -408,7 +408,8 @@ def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greens_function(self, r0):
-        return GreensFunction2DRadAbs(self.D_tot, self.rt.ktot, r0,
+	# TODO still doesn't work with 2D Green's functions
+        return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):

From 9fe63988ded91a04ab9fde04aee5ef8812105dbb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 4 Aug 2011 18:32:43 +0200
Subject: [PATCH 0114/1541] .gitignore changes

---
 .gitignore | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.gitignore b/.gitignore
index 54105378..33878298 100644
--- a/.gitignore
+++ b/.gitignore
@@ -24,6 +24,9 @@
 *.pdf
 *.toc
 
+# ignore files generated by other tools such as pygmentize
+*.png
+
 # ignore data files generated by the examples
 *.out
 

From 359cbfc4430feaf9ed614977aee34e58684725ac Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 9 Aug 2011 17:38:15 +0200
Subject: [PATCH 0115/1541] small changes to avoid numerical problems

---
 samples/irreversible/run.py | 4 ++--
 samples/reversible/run.py   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/samples/irreversible/run.py b/samples/irreversible/run.py
index 1d7a7bc0..19d60eb2 100755
--- a/samples/irreversible/run.py
+++ b/samples/irreversible/run.py
@@ -65,7 +65,7 @@ def singlerun1(T):
     s = BDSimulator(w, myrandom.nrg, nrw)
 
     particleA = gfrdbase.place_particle(w, A, [0,0,0])
-    particleB = gfrdbase.place_particle(w, B, [(float(A['radius']) + float(B['radius']))+1e-23,0,0])
+    particleB = gfrdbase.place_particle(w, B, [(float(A['radius']) + float(B['radius']))+1e-13,0,0])
 
     end_time = T
     s.step()
@@ -114,7 +114,7 @@ def singlerun2(T):
     s = EGFRDSimulator(w, myrandom.rng, nrw)
 
     particleA = gfrdbase.place_particle(w, A, [0,0,0])
-    particleB = gfrdbase.place_particle(w, B, [float(A['radius']) + float(B['radius'])+1e-23,0,0])
+    particleB = gfrdbase.place_particle(w, B, [float(A['radius']) + float(B['radius'])+1e-13,0,0])
 
     end_time = T
 
diff --git a/samples/reversible/run.py b/samples/reversible/run.py
index c5f7843e..bf0d34a7 100755
--- a/samples/reversible/run.py
+++ b/samples/reversible/run.py
@@ -72,7 +72,7 @@ def singlerun(T):
     s = EGFRDSimulator(w, myrandom.rng, nrw)
 
     place_particle(w, A, [0,0,0])
-    place_particle(w, B, [(float(A['radius']) + float(B['radius']))+1e-23,0,0])
+    place_particle(w, B, [(float(A['radius']) + float(B['radius']))+1e-13,0,0])
 
     end_time = T
     s.step()

From f2b5d05e6c50b6031abdc23deed25790afe9eaa2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 10 Aug 2011 18:29:58 +0200
Subject: [PATCH 0116/1541] inserted comments and some clarifications

---
 World.hpp |  1 +
 egfrd.py  | 65 +++++++++++++++++++++++++++++++++++++------------------
 single.py | 22 ++++++++++++++-----
 3 files changed, 62 insertions(+), 26 deletions(-)

diff --git a/World.hpp b/World.hpp
index a6150d8d..97d93244 100644
--- a/World.hpp
+++ b/World.hpp
@@ -236,6 +236,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
 
     void add_species(species_type const& species)
+// Wouldn't it make more sence to make this method part of the model class instead of the world class?
     {
         species_map_[species.id()] = species;
         particle_pool_[species.id()] = particle_id_set();
diff --git a/egfrd.py b/egfrd.py
index c51810de..04051e17 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -105,7 +105,10 @@ def __call__(self):
 
 
 class EGFRDSimulator(ParticleSimulatorBase):
-    """
+    """The eGFRDSimulator implements the asynchronous egfrd scheme of performing
+    the diffusing and reaction of n particles. The eGFRDsimulator acts on a 'world'
+    object containing particles and structures, and can attached and detached from
+    this 'world'.
     """
     def __init__(self, world, rng=myrandom.rng, network_rules=None):
         """Create a new EGFRDSimulator.
@@ -130,17 +133,23 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.domain_id_generator = DomainIDGenerator(0)
         self.shell_id_generator = ShellIDGenerator(0)
 
+	# some constants
         self.MULTI_SHELL_FACTOR = 0.05
         self.SINGLE_SHELL_FACTOR = 1.1
+        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
 
-        self.is_dirty = True			# what does this mean?
+	# used datastructrures
         self.scheduler = EventScheduler()
+        self.domains = {}			# a dictionary containing the protective domains that are defined
+						# in the simulation system. The id of the domain (domain_id) is the key.
 
-        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
-
-        self.domains = {}
+	# other stuff
+        self.is_dirty = True			# The simulator is dirty if the state if the simulator is not
+						# consistent with the content of the world that it represents
+						# (or if we don't know for sure)
 
-        self.reset()
+        self.reset()				# The Simulator is only initialized at the first step, allowing
+						# modifications to the world to be made before simulation starts
 
     def get_matrix_cell_size(self):
         return self.containers[0].cell_size	# cell_size is the width of the (cubic) cell
@@ -174,8 +183,8 @@ def reset(self):
         This function resets the "records" of the simulator. This means
         the simulator time is reset, the step counter is reset, events
         are reset, etc.
-        Can be for example usefull when users want to "stirr" the 
-        simulation before starting the "real experiment".
+        Can be for example usefull when users want to first do an equilibration
+	run before starting the "real experiment".
         """ #~ MW
         self.t = 0.0
         self.dt = 0.0
@@ -197,26 +206,33 @@ def reset(self):
         self.last_event = None
         self.last_reaction = None
 
-        self.is_dirty = True
+        self.is_dirty = True		# simulator needs to be re-initialized
 
     def initialize(self):
 	"""Initialize the eGFRD simulator
 
-	Not sure what that means yet
+	This method (re-)initializes the simulator with the current state of the 'world'
+	that it represents.
+	Call this method if you change the 'world' using methods outside of the Simulator
+	thereby invalidating the state of the eGFRD simulator (the simulator is dirty), or
+	in an other case that the state of the simulator is inconsistent with the state of
+	the world.
 	"""
+	# 1. (re-)initialize previously set datastructures
         ParticleSimulatorBase.initialize(self)
-
         self.scheduler.clear()
-	# These containers hold the spherical and cylindrical protective domains respectively 
+        self.domains = {}
+
+	# create/clear other datastructures
+	# the containers hold the spherical and cylindrical protective domains respectively 
         self.containers = [SphericalShellContainer(self.world.world_size, 
                                                    self.world.matrix_size),
                            CylindricalShellContainer(self.world.world_size, 
                                                      self.world.matrix_size)]
-        self.domains = {}
-
-        singles = []
 
+	# 2. Couple all the particles in 'world' to a new 'single' in the eGFRD simulator
         # Fix order of adding particles (always, or at least in debug mode).
+        singles = []
         pid_particle_pairs = list(self.world)
         pid_particle_pairs.sort()
 
@@ -230,14 +246,17 @@ def initialize(self):
         for single in singles:
             self.add_single_event(single)
 
+	# 3. The simulator is now consistent with 'world'
         self.is_dirty = False
 
     def stop(self, t):
-        """Synchronize all particles at time t.
+        """Bring the simulation to a full stop, which synchronizes all
+	particles at time t. The state is similar to the state after
+	initialization.
 
         With eGFRD, particle positions are normally updated 
-        asynchronously. This method bursts all protective domains and 
-        assigns a position to each particle.
+        asynchronously. This method bursts all protective domains so that 
+        the position of each particle is known.
 
         Arguments:
             - t
@@ -255,10 +274,10 @@ def stop(self, t):
         if __debug__:
             log.info('stop at %s' % (FORMAT_DOUBLE % t))
 
-        if self.t == t:			# FIXME: is this accurate? Probably use feq from utils.py
-            return
+        if self.t == t:				# We actually already stopped?
+            return				# FIXME: is this accurate? Probably use feq from utils.py
 
-        if t >= self.scheduler.top[1].time:
+        if t >= self.scheduler.top[1].time:	# Can't schedule a stop later than the next event time
             raise RuntimeError('Stop time >= next event time.')
 
         if t < self.t:
@@ -355,6 +374,8 @@ def step(self):
             else:
                 self.zero_steps = 0
 
+
+
     def create_single(self, pid_particle_pair):
         rts = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
         domain_id = self.domain_id_generator()
@@ -504,6 +525,8 @@ def move_single_particle(self, single, position):
         self.world.update_particle(new_pid_particle_pair)
 
     def get_container(self, shell):
+	"""Returns the container that holds 'shell'
+	"""
         if type(shell) is SphericalShell:
             return self.containers[0]
         elif type(shell) is CylindricalShell:
diff --git a/single.py b/single.py
index 6836dc82..3ee33094 100644
--- a/single.py
+++ b/single.py
@@ -14,6 +14,7 @@
     'PlanarSurfaceInteraction',
     ]
 
+
 class Single(object):
     """There are 2 main types of Singles:
         * NonInteractionSingle
@@ -35,12 +36,11 @@ def __init__(self, domain_id, pid_particle_pair, reactiontypes, surface):
 
         self.last_time = 0.0
         self.dt = 0.0
-        self.event_type = None
-
-        self.surface = surface
 
         self.event_id = None
+        self.event_type = None
 
+        self.surface = surface		# shouldn't this be a structure instead?
         self.domain_id = domain_id
 
         self.updatek_tot()
@@ -50,7 +50,7 @@ def getD(self):
     D = property(getD)
 
     def getv(self):
-        return 0 # TODO.
+        return 0 # TODO, include drift.
         return self.pid_particle_pair[1].v
     v = property(getv)
 
@@ -69,12 +69,21 @@ def set_shell_id_shell_pair(self, value):
     shell_id_shell_pair = property(get_shell_id_shell_pair, 
                                    set_shell_id_shell_pair)
 
+    # FIXME: This shouldn't be here, since the mobility_radius doens't mean anything
+    #        for interaction singles
     def get_mobility_radius(self):
         return self.get_shell_size() - self.pid_particle_pair[1].radius
 
+    # FIXME: Same goes here
     def get_shell_size(self):
         return self.shell_list[0][1].shape.radius
 
+    def draw_new_position(self, dt, event_type):
+	'''Draw a new position of the particle in the simulation coordinate system
+	given that an event of event_type has occured
+	'''
+	pass
+
     def initialize(self, t):
         '''
         Reset the Single.
@@ -83,6 +92,7 @@ def initialize(self, t):
         particle.  self.dt is reset to 0.0.  Do not forget to reschedule 
         this Single after calling this method.
         '''
+	# TODO? shell size (radius) is not shrunken
         self.dt = 0.0
         self.last_time = t
         self.event_type = EventType.SINGLE_ESCAPE
@@ -347,6 +357,7 @@ def determine_next_event(self):
 
     def draw_iv_interaction_or_escape_time_tuple(self):
         """Return an (interaction/escape time, event type)-tuple.
+	Note that an interaction is modelled similarly to an escape.
  
         Note: we are not calling single.draw_iv_event_type() just yet, but 
         postpone it to the very last minute (when this event is executed 
@@ -381,6 +392,7 @@ class PlanarSurfaceInteraction(InteractionSingle):
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
                  surface, interaction_type, origin, orientation, half_length, 
                  particle_offset, projected_point, size_of_domain):
+
         InteractionSingle.__init__(self, domain_id, pid_particle_pair, 
                                    shell_id, reactiontypes, surface, 
                                    interaction_type, origin, orientation,
@@ -444,7 +456,7 @@ def createNewShell(self, position, radius, domain_id):
         return CylindricalShell(position, radius, orientation, half_length,
                                 domain_id)
 
-    def draw_new_positions(self, dt, eventType):
+    def draw_new_position(self, dt, eventType):
         gf_r = self.greens_function_r()
         a = self.get_mobility_radius()
         r = draw_displacement_wrapper(gf_r, dt, eventType, a)

From 17ab999a79f089afb864e09f37b74efdc1635d7b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 11 Aug 2011 14:54:52 +0200
Subject: [PATCH 0117/1541] Fixing surface/structure confusion Sometimes
 surface was used, where actually it should have been structure. Also did some
 changes to the interactions, but this still needs work

---
 egfrd.py  | 86 +++++++++++++++++++++++++++++++++----------------------
 pair.py   | 32 ++++++++++-----------
 single.py | 54 ++++++++++++++++++----------------
 3 files changed, 96 insertions(+), 76 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 04051e17..33239b27 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -45,21 +45,24 @@
     PRECISION = 3
     FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
 
-def create_default_single(domain_id, pid_particle_pair, shell_id, rt, surface):
-    if isinstance(surface, CuboidalRegion):
+def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure):
+    if isinstance(structure, CuboidalRegion):
         return SphericalSingle(domain_id, pid_particle_pair,
-                               shell_id, rt, surface)
-    elif isinstance(surface, CylindricalSurface):
+                               shell_id, rt, structure)
+    elif isinstance(structure, CylindricalSurface):
         return CylindricalSurfaceSingle(domain_id, pid_particle_pair, 
-                                        shell_id, rt, surface)
-    elif isinstance(surface, PlanarSurface):
+                                        shell_id, rt, structure)
+    elif isinstance(structure, PlanarSurface):
         return PlanarSurfaceSingle(domain_id, pid_particle_pair, 
-                                   shell_id, rt, surface)
+                                   shell_id, rt, structure)
+
 
 def create_default_interaction(domain_id, pid_particle_pair, shell_id,
                                reaction_types, interaction_type, surface,
                                projected_point, particle_distance, 
                                orientation_vector, dr, dz_left, dz_right):
+    # surface is the surface with which the interaction is made
+
     if isinstance(surface, CylindricalSurface):
         return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
                                              shell_id, reaction_types,
@@ -75,17 +78,18 @@ def create_default_interaction(domain_id, pid_particle_pair, shell_id,
                                         orientation_vector,
                                         dr, dz_left, dz_right)
 
+
 def create_default_pair(domain_id, com, single1, single2, shell_id, 
-                        r0, shell_size, rt, surface):
-    if isinstance(surface, CuboidalRegion):
+                        r0, shell_size, rt, structure):
+    if isinstance(structure, CuboidalRegion):
         return SphericalPair(domain_id, com, single1, single2,
-                             shell_id, r0, shell_size, rt, surface)
-    elif isinstance(surface, CylindricalSurface):
+                             shell_id, r0, shell_size, rt, structure)
+    elif isinstance(structure, CylindricalSurface):
         return CylindricalSurfacePair(domain_id, com, single1, single2,
-                                      shell_id, r0, shell_size, rt, surface)
-    elif isinstance(surface, PlanarSurface):
+                                      shell_id, r0, shell_size, rt, structure)
+    elif isinstance(structure, PlanarSurface):
         return PlanarSurfacePair(domain_id, com, single1, single2,
-                                 shell_id, r0, shell_size, rt, surface)
+                                 shell_id, r0, shell_size, rt, structure)
 
 
 class DomainEvent(Event):
@@ -107,7 +111,7 @@ def __call__(self):
 class EGFRDSimulator(ParticleSimulatorBase):
     """The eGFRDSimulator implements the asynchronous egfrd scheme of performing
     the diffusing and reaction of n particles. The eGFRDsimulator acts on a 'world'
-    object containing particles and structures, and can attached and detached from
+    object containing particles and structures, and can be attached and detached from
     this 'world'.
     """
     def __init__(self, world, rng=myrandom.rng, network_rules=None):
@@ -381,7 +385,7 @@ def create_single(self, pid_particle_pair):
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
-        # Get structure (region or surface).
+        # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
         structure = self.world.get_structure(species.structure_id)
 
@@ -525,16 +529,19 @@ def move_single_particle(self, single, position):
         self.world.update_particle(new_pid_particle_pair)
 
     def get_container(self, shell):
-	"""Returns the container that holds 'shell'
-	"""
+	# Returns the container that holds 'shell'
         if type(shell) is SphericalShell:
             return self.containers[0]
         elif type(shell) is CylindricalShell:
             return self.containers[1]
 
     def remove_domain(self, obj):
+	# Removes a domain (single, pair, multi) from the system.
+	# Note that the particles that it represented still exist
+	# in 'world' and that obj also still persits (?!)
         if __debug__:
             log.info("remove: %s" % obj)
+	# TODO assert that the domain is not on the scheduler
         del self.domains[obj.domain_id]
         for shell_id, shell in obj.shell_list:
             container = self.get_container(shell)
@@ -545,6 +552,8 @@ def move_shell(self, shell_id_shell_pair):
         container = self.get_container(shell)
         container.update(shell_id_shell_pair)
 
+
+### TODO These methods can be generalized further. Also should be made methods to the scheduler class
     def add_single_event(self, single):
         event_id = self.scheduler.add(
             DomainEvent(self.t + single.dt, single))
@@ -590,6 +599,9 @@ def update_multi_event(self, t, multi):
                      (multi.domain_id, multi.event_id, FORMAT_DOUBLE % t))
         self.scheduler.update((multi.event_id, DomainEvent(t, multi)))
 
+
+
+
     def burst_obj(self, obj):
         if __debug__:
             log.info('burst_obj: %s' % obj)
@@ -662,7 +674,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
             raise NotImplementedError
         reactant_species_radius = single.pid_particle_pair[1].radius
         oldpos = single.pid_particle_pair[1].position
-        current_surface = single.surface
+        current_structure = single.structure
         
         rt = single.draw_reaction_rule()
 
@@ -717,7 +729,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
             self.clear_volume(oldpos, rad)
 
             for _ in range(self.dissociation_retry_moves):
-                vector = _random_vector(current_surface, particle_radius12 *
+                vector = _random_vector(current_structure, particle_radius12 *
                                         MINIMAL_SEPARATION_FACTOR, self.rng)
             
                 # place particles according to the ratio D1:D2
@@ -814,8 +826,8 @@ def propagate_single(self, single):
                 # For escapes and bursts of interaction singles we do 
                 # it here.
                 self.move_single_particle(single, newpos)
-                self.remove_domain(single)
                 newsingle = self.create_single(single.pid_particle_pair)
+                self.remove_domain(single)
                 if __debug__:
                     log.debug('    *New %s.\n'
                               '        radius = %.3g. dt = %.3g.' %
@@ -896,6 +908,7 @@ def fire_single(self, single):
 
         singlepos = single.shell.shape.position
 
+	# Now try to make a new domain
         # (2) Clear volume.
 
         min_shell = single.pid_particle_pair[1].radius * \
@@ -917,12 +930,12 @@ def fire_single(self, single):
             burst = None
 
         # Check closest surface.
-        # Only relevant when in the "world" or other 3D region.
-        if isinstance(single.surface, CuboidalRegion):
+        # Only relevant when the particle lives in the "world" or other 3D region.
+        if isinstance(single.structure, CuboidalRegion):
             interaction_surface, closest_surface, surface_distance = \
                 get_closest_surface_within_radius(self.world, 
                                                   singlepos, min_shell,
-                                                  ignore=[single.surface.id])
+                                                  ignore=[single.structure.id])
             if interaction_surface:
                 obj = self.form_interaction(single, interaction_surface, burst)
                 if obj:
@@ -942,7 +955,7 @@ def fire_single(self, single):
 
             closest, closest_distance = \
                 self.get_closest_obj(singlepos, ignore=[single.domain_id],
-                                     ignores=[single.surface.id])
+                                     ignores=[single.structure.id])
             self.update_single(single, closest, closest_distance)
             for s in burst:
                 if not isinstance(s, Single):
@@ -950,7 +963,7 @@ def fire_single(self, single):
                 assert s.is_reset()
                 closest, closest_distance = self.get_closest_obj(
                     s.shell.shape.position, ignore=[s.domain_id],
-                    ignores=[s.surface.id])
+                    ignores=[s.structure.id])
 
                 self.update_single(s, closest, closest_distance)
                 self.update_single_event(self.t + s.dt, s)
@@ -1161,14 +1174,14 @@ def fire_multi(self, multi):
             self.add_multi_event(multi)
 
     def break_up_multi(self, multi):
-        self.remove_domain(multi)
-
+    #Dissolves a multi in singles with a zero shell (dt=0)
         singles = []
         for pid_particle_pair in multi.particles:
             single = self.create_single(pid_particle_pair)
             self.add_single_event(single)
             singles.append(single)
 
+        self.remove_domain(multi)
         return singles
 
     def burst_multi(self, multi):
@@ -1312,6 +1325,7 @@ def propagate_pair(self, pair, dt, event_type):
         return single1, single2
 
     def form_pair_or_multi(self, single, neighbors):
+    # single is the current single being treated, neighbors is a list (?) of neighboring shells
         assert neighbors
 
         singlepos = single.shell.shape.position
@@ -1323,7 +1337,7 @@ def form_pair_or_multi(self, single, neighbors):
             dists = dists.take(n)
             neighbors = numpy.take(neighbors, n)
 
-        # First, try forming a Pair.
+        # First, try forming a Pair if the neighbor is a single.
         if isinstance(neighbors[0], Single):
             obj = self.form_pair(single, singlepos,
                                  neighbors[0], neighbors[1:])
@@ -1335,8 +1349,10 @@ def form_pair_or_multi(self, single, neighbors):
         if obj:
             return obj
 
+	
+
     def form_interaction(self, single, surface, burst):
-        # Try to form an interaction.
+        # Try to form an interaction between the 'single' particle and the 'surface'.
 
         particle = single.pid_particle_pair[1]
         # Cyclic transpose needed when calling surface.projected_point!
@@ -1562,10 +1578,10 @@ def form_pair(self, single1, pos1, single2, burst):
         assert single1.is_reset()
         assert single2.is_reset()
 
-        # Try forming a Pair only if singles are on same surface.
-        if single1.surface != single2.surface:
+        # Try forming a Pair only if singles are on same structure.
+        if single1.structure != single2.structure:
             if __debug__:
-                log.debug('Pair(%s, %s) not formed: not on same surface.' %
+                log.debug('Pair(%s, %s) not formed: not on same structure.' %
                           (single1.pid_particle_pair[0],
                            single2.pid_particle_pair[0]))
             return None
@@ -1650,7 +1666,7 @@ def form_pair(self, single1, pos1, single2, burst):
         # close (squeezing).
         c, d = self.get_closest_obj(com, ignore=[single1.domain_id,
                                                  single2.domain_id],
-                                    ignores=[single1.surface.id])
+                                    ignores=[single1.structure.id])
         if d < closest_shell_distance:
             closest, closest_shell_distance = c, d
 
@@ -2018,7 +2034,7 @@ def check_obj(self, obj):
 
         for shell_id, shell in obj.shell_list:
             if not isinstance(obj, Multi):
-                ignores = [obj.surface.id]
+                ignores = [obj.structure.id]
             else:
                 # Ignore all surfaces, multi shells can overlap with 
                 # surfaces.
diff --git a/pair.py b/pair.py
index 4479e889..0ff6c4a4 100644
--- a/pair.py
+++ b/pair.py
@@ -24,7 +24,7 @@ class Pair(object):
     CUTOFF_FACTOR = 5.6
 
     def __init__(self, domain_id, com, single1, single2, shell_id, r0, 
-                 shell_size, rt, surface):
+                 shell_size, rt, structure):
         self.multiplicity = 2
         self.num_shells = 1
 
@@ -42,7 +42,7 @@ def __init__(self, domain_id, com, single1, single2, shell_id, r0,
         self.dt = 0.0
         self.event_type = None
 
-        self.surface = surface
+        self.structure = structure
 
         # Create shell.
         shell = self.create_new_shell(com, shell_size, domain_id)
@@ -299,9 +299,9 @@ class SphericalPair(Pair):
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
-                 r0, shell_size, rt, surface):
+                 r0, shell_size, rt, structure):
         Pair.__init__(self, domain_id, com, single1, single2, shell_id,
-                      r0, shell_size, rt, surface)
+                      r0, shell_size, rt, structure)
 
     def com_greens_function(self):
         # Green's function for centre of mass inside absorbing sphere.
@@ -400,9 +400,9 @@ class PlanarSurfacePair(Pair):
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
-                 r0, shell_size, rt, surface):
+                 r0, shell_size, rt, structure):
         Pair.__init__(self, domain_id, com, single1, single2, shell_id,
-                      r0, shell_size, rt, surface)
+                      r0, shell_size, rt, structure)
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
@@ -418,8 +418,8 @@ def create_new_shell(self, position, radius, domain_id):
         # the particle undergoes an unbinding reaction we still have to 
         # clear the target volume and the move may be rejected (NoSpace 
         # error).
-        orientation = crossproduct(self.surface.shape.unit_x,
-                                   self.surface.shape.unit_y)
+        orientation = crossproduct(self.structure.shape.unit_x,
+                                   self.structure.shape.unit_y)
         half_length = max(self.single1.pid_particle_pair[1].radius,
                           self.single2.pid_particle_pair[1].radius)
         return CylindricalShell(domain_id, Cylinder(position, radius, 
@@ -468,7 +468,7 @@ def choose_pair_greens_function(self, r0, t):
 
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
-        return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
+        return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
         if __debug__:
@@ -476,8 +476,8 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
         theta = draw_theta_wrapper(gf, r, dt)
 
         #FIXME: need better handling of angles near zero and pi?
-        unit_x = self.surface.shape.unit_x
-        unit_y = self.surface.shape.unit_y
+        unit_x = self.structure.shape.unit_x
+        unit_y = self.structure.shape.unit_y
         angle = vector_angle(unit_x, old_iv)
         # Todo. Test if nothing changes when theta == 0.
         new_angle = angle + theta
@@ -497,9 +497,9 @@ class CylindricalSurfacePair(Pair):
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
-                 r0, shell_size, rt, surface):
+                 r0, shell_size, rt, structure):
         Pair.__init__(self, domain_id, com, single1, single2, shell_id,
-                      r0, shell_size, rt, surface)
+                      r0, shell_size, rt, structure)
 
     def com_greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
@@ -515,7 +515,7 @@ def create_new_shell(self, position, half_length, domain_id):
         # and the move may be rejected (NoSpace error).
         radius = max(self.single1.pid_particle_pair[1].radius,
                      self.single2.pid_particle_pair[1].radius)
-        orientation = self.surface.shape.unit_z
+        orientation = self.structure.shape.unit_z
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
@@ -524,12 +524,12 @@ def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
 
     def create_com_vector(self, r):
-        return r * self.surface.shape.unit_z
+        return r * self.structure.shape.unit_z
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
-        # Note: using self.surface.shape.unit_z here might accidently 
+        # Note: using self.structure.shape.unit_z here might accidently 
         # interchange the particles.
         return r * normalize(old_iv)
 
diff --git a/single.py b/single.py
index 3ee33094..b6ed6218 100644
--- a/single.py
+++ b/single.py
@@ -25,7 +25,7 @@ class Single(object):
     specified.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, reactiontypes, surface):
+    def __init__(self, domain_id, pid_particle_pair, reactiontypes, structure):
         self.multiplicity = 1
         self.num_shells = 1
 
@@ -40,7 +40,7 @@ def __init__(self, domain_id, pid_particle_pair, reactiontypes, surface):
         self.event_id = None
         self.event_type = None
 
-        self.surface = surface		# shouldn't this be a structure instead?
+        self.structure = structure		# the structure in/on which the particle lives
         self.domain_id = domain_id
 
         self.updatek_tot()
@@ -173,9 +173,9 @@ class NonInteractionSingle(Single):
 
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
-                 surface):
+                 structure):
         Single.__init__(self, domain_id, pid_particle_pair, reactiontypes,
-                        surface)
+                        structure)
 
         # Create shell.
         shell = self.create_new_shell(pid_particle_pair[1].position,
@@ -228,9 +228,9 @@ class SphericalSingle(NonInteractionSingle):
 
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
-                 surface):
+                 structure):
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactiontypes, surface)
+                                      shell_id, reactiontypes, structure)
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
@@ -257,9 +257,9 @@ class PlanarSurfaceSingle(NonInteractionSingle):
 
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
-                 surface):
+                 structure):
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactiontypes, surface)
+                                      shell_id, reactiontypes, structure)
 
     def greens_function(self):
         return GreensFunction2DAbsSym(self.getD(),
@@ -272,15 +272,15 @@ def create_new_shell(self, position, radius, domain_id):
         # clear the target volume and the move may be rejected (NoSpace 
         # error).
         orientation = normalize(
-            utils.crossproduct(self.surface.shape.unit_x,
-                               self.surface.shape.unit_y))
+            utils.crossproduct(self.structure.shape.unit_x,
+                               self.structure.shape.unit_y))
         half_length = self.pid_particle_pair[1].radius
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
     def create_position_vector(self, r):
         x, y = random_vector2D(r)
-        return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
+        return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
     def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
@@ -297,9 +297,9 @@ class CylindricalSurfaceSingle(NonInteractionSingle):
 
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
-                 surface):
+                 structure):
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactiontypes, surface)
+                                      shell_id, reactiontypes, structure)
 
     def greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
@@ -311,7 +311,7 @@ def create_new_shell(self, position, half_length, domain_id):
         # unbinding reaction we still have to clear the target volume 
         # and the move may be rejected (NoSpace error).
         radius = self.pid_particle_pair[1].radius
-        orientation = self.surface.shape.unit_z
+        orientation = self.structure.shape.unit_z
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
@@ -340,12 +340,13 @@ class InteractionSingle(Single):
 
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, shell,  
-                 reactiontypes, interaction_type, surface):
+                 reactiontypes, interaction_type, surface, structure):
 
         Single.__init__(self, domain_id, pid_particle_pair, reactiontypes,
-                        surface)
+                        structure)
         self.interaction_type = interaction_type
         self.shell_list = [(shell_id, shell), ]
+	self.surface = surface			# The surface with which the particle is trying to interact
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -389,15 +390,18 @@ class PlanarSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
-                 surface, interaction_type, origin, orientation, half_length, 
+    def __init__(self, domain_id, pid_particle_pair, structure, shell_id, reactiontypes,
+                 interaction_type, surface, origin, orientation, half_length, 
                  particle_offset, projected_point, size_of_domain):
 
-        InteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                   shell_id, reactiontypes, surface, 
-                                   interaction_type, origin, orientation,
-                                   half_length, particle_offset,
-                                   projected_point, size_of_domain)
+###TODO	One of the two constructors for InteractionSingle should be right. The one below doesn't seem so
+#        InteractionSingle.__init__(self, domain_id, pid_particle_pair, 
+#                                   shell_id, reactiontypes, surface, 
+#                                   interaction_type, origin, orientation,
+#                                   half_length, particle_offset,
+#                                   projected_point, size_of_domain)
+	InteractionSingle.__init__(self, domain_id, pid_particle_pair, structure, shell_id, shell,
+                 reactiontypes, interaction_type, surface, structure)
 
         # Compute from dr, dz_left and dz_right the length of the new 
         # domain (only that part of the cylinder where the particle can 
@@ -405,7 +409,7 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
         # cylinder.
 
         # a
-        # sigma
+        # what is here sigma?
         sigma = self.surface.shape.Lz + self.pid_particle_pair[1].radius
         # r0
         if isinstance(surface, PlanarSurface):
@@ -554,7 +558,7 @@ def draw_new_position(self, dt, event_type):
             z = draw_r_wrapper(gf, dt, self.get_mobility_radius())
 
         # Orientation matters, so use shell.shape.unit_z instead of 
-        # surface.shape.unit_z.
+        # structure.shape.unit_z.
         z_vector = z * self.shell.shape.unit_z
 
         # 2) Draw r and theta.

From e9eb0f0d90e5c3fc72f40ac78bf45542d635d63e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 11 Aug 2011 16:00:02 +0200
Subject: [PATCH 0118/1541] some changed parameters and added comments

---
 egfrd.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 33239b27..890e1591 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -139,13 +139,15 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
 	# some constants
         self.MULTI_SHELL_FACTOR = 0.05
-        self.SINGLE_SHELL_FACTOR = 1.1
+        self.SINGLE_SHELL_FACTOR = 2.0
+	self.MAX_NUM_DT0_STEPS = 10000
         self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
 
 	# used datastructrures
         self.scheduler = EventScheduler()
-        self.domains = {}			# a dictionary containing the protective domains that are defined
+        self.domains = {}			# a dictionary containing the domains that are defined
 						# in the simulation system. The id of the domain (domain_id) is the key.
+						# The domains can be a single, pair or multi of any type.
 
 	# other stuff
         self.is_dirty = True			# The simulator is dirty if the state if the simulator is not
@@ -371,7 +373,7 @@ def step(self):
                 self.zero_steps += 1
                 # TODO Changed from 10 to 10000, because only a problem 
                 # when reaching certain magnitude.
-                if self.zero_steps >= max(self.scheduler.size * 3, 10000): 
+                if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
                     raise RuntimeError('too many dt=zero steps. '
                                        'Simulator halted?'
                                     'dt= %.300g-%.300g' % (self.scheduler.top[1].time, self.t))
@@ -536,12 +538,12 @@ def get_container(self, shell):
             return self.containers[1]
 
     def remove_domain(self, obj):
-	# Removes a domain (single, pair, multi) from the system.
+	# Removes all the ties to a domain (single, pair, multi) from the system.
 	# Note that the particles that it represented still exist
 	# in 'world' and that obj also still persits (?!)
         if __debug__:
             log.info("remove: %s" % obj)
-	# TODO assert that the domain is not on the scheduler
+	# TODO assert that the domain is not still in the scheduler
         del self.domains[obj.domain_id]
         for shell_id, shell in obj.shell_list:
             container = self.get_container(shell)

From a544642982e9cbb7dd2e44a653fb464e2c020c28 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 11 Aug 2011 17:36:59 +0200
Subject: [PATCH 0119/1541] Replaced domain objects in the scheduler by
 domain_id Data of the domains (single, pair, multi) was stored in
 self.domains and in the scheduler. Data replication is usually not a good
 idea. Now the scheduler just has a reference to the domain object in the
 domains dictionary.

---
 egfrd.py | 53 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 21 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 890e1591..3f706c28 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -96,7 +96,8 @@ class DomainEvent(Event):
     __slot__ = ['data']
     def __init__(self, time, domain):
         Event.__init__(self, time)
-        self.data = domain
+        self.data = domain.domain_id		# Store the domain_id key refering to the domain
+						# in domains{} in the scheduler
 
 class Delegate(object):
     def __init__(self, obj, method, arg):
@@ -295,7 +296,7 @@ def stop(self, t):
 
         # first burst all Singles, and put Pairs and Multis in a list.
         for id, event in self.scheduler:
-            obj = event.data
+            obj = self.domains[event.data]
             if isinstance(obj, Pair) or isinstance(obj, Multi):
                 non_single_list.append(obj)
             elif isinstance(obj, Single):
@@ -336,6 +337,7 @@ def step(self):
 	# 1. Get the next event from the scheduler
 	#
         id, event = self.scheduler.pop()
+	domain = self.domains[event.data]
         self.t, self.last_event = event.time, event
 
         if __debug__:
@@ -354,8 +356,8 @@ def step(self):
         # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
         # e.g. "if class is Single, then fire_single" ~ MW
         for klass, f in self.dispatch:
-            if isinstance(event.data, klass):
-                f(self, event.data)		# fire the correct method for the class (e.g. fire_singel(self, Single))
+            if isinstance(domain, klass):
+                f(self, domain)		# fire the correct method for the class (e.g. fire_singel(self, Single))
 
         if __debug__:
             if self.scheduler.size == 0:
@@ -2090,16 +2092,21 @@ def check_obj(self, obj):
 
     def check_obj_for_all(self):
         for id, event in self.scheduler:
-            self.check_obj(event.data)
+	    domain = self.domains[event.data]
+            self.check_obj(domain)
 
     def check_event_stoichiometry(self):
-        event_population = 0
+    # checks if the number of particles in the world is equal to the number
+    # of particles represented in the EGFRD simulator
+	world_population = self.world.num_particles
+        domain_population = 0
         for id, event in self.scheduler:
-            event_population += event.data.multiplicity
+	    domain = self.domains[event.data]
+            domain_population += domain.multiplicity
 
-        if self.world.num_particles != event_population:
-            raise RuntimeError('population %d != event_population %d' %
-                               (population, event_population))
+        if world_population != domain_population:
+            raise RuntimeError('population %d != domain_population %d' %
+                               (world_population, domain_population))
 
     def check_shell_matrix(self):
         did_map = {}
@@ -2114,18 +2121,19 @@ def check_shell_matrix(self):
 
         shell_population = 0
         for id, event in self.scheduler:
-            shell_population += event.data.num_shells
-            shell_ids = did_map[event.data.domain_id]
-            if len(shell_ids) != event.data.num_shells:
+	    domain = self.domains[event.data]
+            shell_population += domain.num_shells
+            shell_ids = did_map[domain.domain_id]
+            if len(shell_ids) != domain.num_shells:
                 diff = set(sid for (sid, _)
-                               in event.data.shell_list).difference(shell_ids)
+                               in domain.shell_list).difference(shell_ids)
                 for sid in diff:
                     print shell_map.get(sid, None)
 
                 raise RuntimeError('number of shells are inconsistent '
                                    '(%d != %d; %s) - %s' %
-                                   (len(shell_ids), event.data.num_shells, 
-                                    event.data.domain_id, diff))
+                                   (len(shell_ids), domain.num_shells, 
+                                    domain.domain_id, diff))
 
         matrix_population = sum(len(container)
                                 for container in self.containers)
@@ -2134,17 +2142,20 @@ def check_shell_matrix(self):
                                (shell_population, matrix_population))
 
     def check_domains(self):
+	# make set of event_id that are stored in all the domains
         event_ids = set(domain.event_id
                         for domain in self.domains.itervalues())
+	# check that all the event_id in the scheduler are also stored in a domain
         for id, event in self.scheduler:
             if id not in event_ids:
-                raise RuntimeError('%s in EventScheduler not in self.domains' %
-                                   event.data)
-            event_ids.remove(id)
+                raise RuntimeError('Event %s in EventScheduler has no domain in self.domains' %
+                                   event)
+	    else:
+                event_ids.remove(id)
 
         # self.domains always include a None  --> this can change in future
         if event_ids:
-            raise RuntimeError('following domains in self.domains not in '
+            raise RuntimeError('following domains in self.domains are not in '
                                'Event Scheduler: %s' % str(tuple(event_ids)))
 
     def check_pair_pos(self, pair, pos1, pos2, com, radius):
@@ -2213,7 +2224,7 @@ def dump(self):
 
         """
         for id, event in self.scheduler:
-            print id, event, event.data
+            print id, event, self.domains[event.data]
 
     def count_domains(self):
         # Returns a tuple (# Singles, # Pairs, # Multis).

From 335b8a550c125c4fdc82d287a7506fc4c839f6ef Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 11 Aug 2011 19:34:05 +0200
Subject: [PATCH 0120/1541] generalized add_single_event etc into
 add_domain_event

---
 egfrd.py | 90 +++++++++++++++++++++++++++++---------------------------
 1 file changed, 47 insertions(+), 43 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3f706c28..7faa978a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -251,7 +251,7 @@ def initialize(self):
             singles.append(single)
         assert len(singles) == self.world.num_particles
         for single in singles:
-            self.add_single_event(single)
+            self.add_domain_event(single)
 
 	# 3. The simulator is now consistent with 'world'
         self.is_dirty = False
@@ -558,33 +558,37 @@ def move_shell(self, shell_id_shell_pair):
 
 
 ### TODO These methods can be generalized further. Also should be made methods to the scheduler class
-    def add_single_event(self, single):
+    def add_domain_event(self, domain):
+    # This method makes an event for domain 'domain' in the scheduler.
+    # The event will have the domain_id pointing to the appropriate domain in 'domains{}'.
+    # The domain will have the event_id pointing to the appropriate event in the scheduler.
+	event_time = self.t + domain.dt
         event_id = self.scheduler.add(
-            DomainEvent(self.t + single.dt, single))
+            DomainEvent(event_time, domain))
         if __debug__:
             log.info('add_event: %s, event=#%d, t=%s' %
-                     (single.domain_id, event_id,
-                      FORMAT_DOUBLE % (self.t + single.dt)))
-        single.event_id = event_id
-
-    def add_pair_event(self, pair):
-        event_id = self.scheduler.add(
-            DomainEvent(self.t + pair.dt, pair))
-        if __debug__:
-            log.info('add_event: %s, event=#%d, t=%s' %
-                     (pair.domain_id, event_id,
-                      FORMAT_DOUBLE % (self.t + pair.dt)))
-        pair.event_id = event_id
-
-    def add_multi_event(self, multi):
-        event_id = self.scheduler.add(
-            DomainEvent(self.t + multi.dt, multi))
-
-        if __debug__:
-            log.info('add_event: %s, event=#%d, t=%s' %
-                     (multi.domain_id, event_id,
-                      FORMAT_DOUBLE % (self.t + multi.dt)))
-        multi.event_id = event_id
+                     (domain.domain_id, event_id,
+                      FORMAT_DOUBLE % (event_time)))
+        domain.event_id = event_id			# FIXME side effect programming -> unclear!!
+
+#    def add_pair_event(self, pair):
+#        event_id = self.scheduler.add(
+#            DomainEvent(self.t + pair.dt, pair))
+#        if __debug__:
+#            log.info('add_event: %s, event=#%d, t=%s' %
+#                     (pair.domain_id, event_id,
+#                      FORMAT_DOUBLE % (self.t + pair.dt)))
+#        pair.event_id = event_id
+#
+#    def add_multi_event(self, multi):
+#        event_id = self.scheduler.add(
+#            DomainEvent(self.t + multi.dt, multi))
+#
+#        if __debug__:
+#            log.info('add_event: %s, event=#%d, t=%s' %
+#                     (multi.domain_id, event_id,
+#                      FORMAT_DOUBLE % (self.t + multi.dt)))
+#        multi.event_id = event_id
 
     def remove_event(self, event):
         if __debug__:
@@ -619,8 +623,8 @@ def burst_obj(self, obj):
             # Don't schedule events in burst/propagate_pair, because 
             # scheduling is different after a single reaction in 
             # fire_pair.
-            self.add_single_event(single1)
-            self.add_single_event(single2)
+            self.add_domain_event(single1)
+            self.add_domain_event(single2)
             self.remove_event(obj)
             bursted = [single1, single2]
         else:  # Multi
@@ -707,7 +711,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
             newsingle = self.create_single(newparticle)
             if __debug__:
                 log.info('product = %s' % newsingle)
-            self.add_single_event(newsingle)
+            self.add_domain_event(newsingle)
 
             self.last_reaction = (rt, (single.pid_particle_pair[1], None),
                                   [newparticle])
@@ -776,8 +780,8 @@ def fire_single_reaction(self, single, interaction_flag=False):
                 log.info('product1 = %s\nproduct2 = %s' % 
                      (newsingle1, newsingle2))
 
-            self.add_single_event(newsingle1)
-            self.add_single_event(newsingle2)
+            self.add_domain_event(newsingle1)
+            self.add_domain_event(newsingle2)
 
             self.last_reaction = (rt, (single.pid_particle_pair[1], None),
                                   [particle1, particle2])
@@ -893,7 +897,7 @@ def fire_single(self, single):
             # no propagation, just calculate next reaction time.
             single.dt, single.event_type = single.determine_next_event() 
             single.last_time = self.t
-            self.add_single_event(single)
+            self.add_domain_event(single)
             return
         
         if single.dt != 0.0:
@@ -988,7 +992,7 @@ def fire_single(self, single):
                      (single.shell_id, single.shell.did,
                       single.shell.shape.show(PRECISION)))
 
-        self.add_single_event(single)
+        self.add_domain_event(single)
         return
 
     def reject_single_reaction(self, single):
@@ -998,7 +1002,7 @@ def reject_single_reaction(self, single):
         self.move_shell(single.shell_id_shell_pair)
         self.rejected_moves += 1
         single.initialize(self.t)
-        self.add_single_event(single)
+        self.add_domain_event(single)
 
     def calculate_single_shell_size(self, single, closest, 
                                  distance, shell_distance):
@@ -1091,7 +1095,7 @@ def fire_pair(self, pair):
 
             self.burst_pair(pair)
 
-            self.add_single_event(theothersingle)
+            self.add_domain_event(theothersingle)
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
@@ -1126,7 +1130,7 @@ def fire_pair(self, pair):
 
                 particle = self.world.new_particle(species3.id, new_com)
                 product = self.create_single(particle)
-                self.add_single_event(product)
+                self.add_domain_event(product)
 
                 self.reaction_events += 1
 
@@ -1152,8 +1156,8 @@ def fire_pair(self, pair):
             dt = pair.dt
             event_type = pair.event_type
             single1, single2 = self.propagate_pair(pair, dt, event_type)
-            self.add_single_event(single1)
-            self.add_single_event(single2)
+            self.add_domain_event(single1)
+            self.add_domain_event(single2)
         else:
             raise SystemError('Bug: invalid event_type.')
 
@@ -1175,14 +1179,14 @@ def fire_multi(self, multi):
             self.break_up_multi(multi)
             self.multi_steps[multi.last_event] += 1
         else:
-            self.add_multi_event(multi)
+            self.add_domain_event(multi)
 
     def break_up_multi(self, multi):
     #Dissolves a multi in singles with a zero shell (dt=0)
         singles = []
         for pid_particle_pair in multi.particles:
             single = self.create_single(pid_particle_pair)
-            self.add_single_event(single)
+            self.add_domain_event(single)
             singles.append(single)
 
         self.remove_domain(multi)
@@ -1228,7 +1232,7 @@ def burst_single(self, single):
             # InteractionSingles nor for bursting 
             # NonInteractionSingles.
             self.remove_event(single)
-            self.add_single_event(newsingle)
+            self.add_domain_event(newsingle)
         else:
             assert single == newsingle
             self.update_single_event(self.t, single)
@@ -1460,7 +1464,7 @@ def form_interaction(self, single, surface, burst):
                        FORMAT_DOUBLE % dz_right))
 
         assert self.check_obj(interaction)
-        self.add_single_event(interaction)
+        self.add_domain_event(interaction)
 
         return interaction
 
@@ -1764,7 +1768,7 @@ def form_pair(self, single1, pos1, single2, burst):
                       FORMAT_DOUBLE % closest_shell_distance, closest))
 
         assert self.check_obj(pair)
-        self.add_pair_event(pair)
+        self.add_domain_event(pair)
 
         return pair
     
@@ -1792,7 +1796,7 @@ def form_multi(self, single, neighbors, dists):
 
             multi.initialize(self.t)
             
-            self.add_multi_event(multi)
+            self.add_domain_event(multi)
 
             return multi
 

From 69cdd998811b744cbfb18683e3906c8ff95d200b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 15 Aug 2011 16:38:41 +0200
Subject: [PATCH 0121/1541] code reduction for update_single_event and
 update_multi_event

---
 egfrd.py | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7faa978a..9c8dbf00 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -145,8 +145,9 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
 
 	# used datastructrures
-        self.scheduler = EventScheduler()
-        self.domains = {}			# a dictionary containing the domains that are defined
+        self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
+
+        self.domains = {}			# a dictionary containing references to the domains that are defined
 						# in the simulation system. The id of the domain (domain_id) is the key.
 						# The domains can be a single, pair or multi of any type.
 
@@ -231,7 +232,7 @@ def initialize(self):
         self.domains = {}
 
 	# create/clear other datastructures
-	# the containers hold the spherical and cylindrical protective domains respectively 
+	# the containers hold the spherical and cylindrical shells respectively 
         self.containers = [SphericalShellContainer(self.world.world_size, 
                                                    self.world.matrix_size),
                            CylindricalShellContainer(self.world.world_size, 
@@ -595,17 +596,17 @@ def remove_event(self, event):
             log.info('remove_event: event=#%d' % event.event_id)
         del self.scheduler[event.event_id]
 
-    def update_single_event(self, t, single):
+    def update_domain_event(self, t, domain):
         if __debug__:
             log.info('update_event: %s, event=#%d, t=%s' %
-                     (single.domain_id, single.event_id, FORMAT_DOUBLE % t))
-        self.scheduler.update((single.event_id, DomainEvent(t, single)))
+                     (domain.domain_id, domain.event_id, FORMAT_DOUBLE % t))
+        self.scheduler.update((domain.event_id, DomainEvent(t, domain)))
 
-    def update_multi_event(self, t, multi):
-        if __debug__:
-            log.info('update_event: %s, event=#%d, t=%s' %
-                     (multi.domain_id, multi.event_id, FORMAT_DOUBLE % t))
-        self.scheduler.update((multi.event_id, DomainEvent(t, multi)))
+#    def update_multi_event(self, t, multi):
+#        if __debug__:
+#            log.info('update_event: %s, event=#%d, t=%s' %
+#                     (multi.domain_id, multi.event_id, FORMAT_DOUBLE % t))
+#        self.scheduler.update((multi.event_id, DomainEvent(t, multi)))
 
 
 
@@ -974,7 +975,7 @@ def fire_single(self, single):
                     ignores=[s.structure.id])
 
                 self.update_single(s, closest, closest_distance)
-                self.update_single_event(self.t + s.dt, s)
+                self.update_domain_event(self.t + s.dt, s)
                 if __debug__:
                     log.debug('restore shell %s radius %s dt %s\n'
                               'closest %s distance %s' %
@@ -1235,7 +1236,7 @@ def burst_single(self, single):
             self.add_domain_event(newsingle)
         else:
             assert single == newsingle
-            self.update_single_event(self.t, single)
+            self.update_domain_event(self.t, single)
 
         assert newsingle.shell.shape.radius == particle_radius
 
@@ -1811,7 +1812,7 @@ def form_multi(self, single, neighbors, dists):
 
             multi.initialize(self.t)
 
-            self.update_multi_event(self.t + multi.dt, multi)
+            self.update_domain_event(self.t + multi.dt, multi)
 
             return multi
 

From 9d4235d1b612d18194188354b3b7782305e4d993 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 15 Aug 2011 18:43:51 +0200
Subject: [PATCH 0122/1541] fixing some more nomenclature: obj->domain (was
 inconsistent)

---
 egfrd.py | 108 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 56 insertions(+), 52 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9c8dbf00..3f3edb34 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -387,8 +387,8 @@ def step(self):
 
     def create_single(self, pid_particle_pair):
         rts = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
-        domain_id = self.domain_id_generator()
-        shell_id = self.shell_id_generator()
+        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
+        shell_id = self.shell_id_generator()	# FIXME: move to protective_domain constructor
 
         # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
@@ -403,7 +403,7 @@ def create_single(self, pid_particle_pair):
 
         single.initialize(self.t)
         self.move_shell(single.shell_id_shell_pair)
-        self.domains[domain_id] = single
+        self.domains[single.domain_id] = single
 
         if __debug__:
             # Used in __str__.
@@ -423,8 +423,8 @@ def create_interaction(self, single, surface, projected_point,
         # TODO.
         interaction_type = None
 
-        domain_id = self.domain_id_generator()
-        shell_id = self.shell_id_generator()
+        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
+        shell_id = self.shell_id_generator()	# FIXME: move to protective domain constructor
 
         interaction = \
             create_default_interaction(domain_id, pid_particle_pair, shell_id,
@@ -435,7 +435,7 @@ def create_interaction(self, single, surface, projected_point,
         interaction.initialize(self.t)
 
         self.move_shell(interaction.shell_id_shell_pair)
-        self.domains[domain_id] = interaction
+        self.domains[interaction.domain_id] = interaction
 
         if __debug__:
             # Used in __str__.
@@ -461,8 +461,8 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         # the sum of the rates of all the possible reaction types. 
         rt.ktot = k_max
 
-        domain_id = self.domain_id_generator()
-        shell_id = self.shell_id_generator()
+        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
+        shell_id = self.shell_id_generator()	# FIXME: move to protective_domain constructor
 
         pos1 = single1.shell.shape.position
         pos2 = single2.shell.shape.position
@@ -481,7 +481,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         pair.initialize(self.t)
 
         self.move_shell(pair.shell_id_shell_pair)
-        self.domains[domain_id] = pair
+        self.domains[pair.domain_id] = pair
 
         if __debug__:
             # Used in __str__.
@@ -490,7 +490,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         return pair
 
     def create_multi(self):
-        domain_id = self.domain_id_generator()
+        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
         if __debug__:
             try:
                 # Option to make multis run faster for nicer visualization.
@@ -500,7 +500,7 @@ def create_multi(self):
         else:
             dt_factor = DEFAULT_DT_FACTOR
         multi = Multi(domain_id, self, dt_factor)
-        self.domains[domain_id] = multi
+        self.domains[multi.domain_id] = multi
         return multi
 
     def move_single(self, single, position, radius=None):
@@ -558,7 +558,7 @@ def move_shell(self, shell_id_shell_pair):
         container.update(shell_id_shell_pair)
 
 
-### TODO These methods can be generalized further. Also should be made methods to the scheduler class
+### TODO These methods can be made methods to the scheduler class
     def add_domain_event(self, domain):
     # This method makes an event for domain 'domain' in the scheduler.
     # The event will have the domain_id pointing to the appropriate domain in 'domains{}'.
@@ -610,27 +610,26 @@ def update_domain_event(self, t, domain):
 
 
 
-
-    def burst_obj(self, obj):
+    def burst_domain(self, domain):
         if __debug__:
-            log.info('burst_obj: %s' % obj)
+            log.info('burst_domain: %s' % domain)
 
-        if isinstance(obj, Single):
+        if isinstance(domain, Single):
             # TODO. Compare with gfrd.
-            obj = self.burst_single(obj)
-            bursted = [obj, ]
-        elif isinstance(obj, Pair):  # Pair
-            single1, single2 = self.burst_pair(obj)
+            domain = self.burst_single(domain)
+            bursted = [domain, ]
+        elif isinstance(domain, Pair):  # Pair
+            single1, single2 = self.burst_pair(domain)
             # Don't schedule events in burst/propagate_pair, because 
             # scheduling is different after a single reaction in 
             # fire_pair.
             self.add_domain_event(single1)
             self.add_domain_event(single2)
-            self.remove_event(obj)
+            self.remove_event(domain)
             bursted = [single1, single2]
         else:  # Multi
-            bursted = self.burst_multi(obj)
-            self.remove_event(obj)
+            bursted = self.burst_multi(domain)
+            self.remove_event(domain)
 
         if __debug__:
             # After a burst, InteractionSingles should be gone.
@@ -639,11 +638,12 @@ def burst_obj(self, obj):
 
         return bursted
 
-    def burst_objs(self, objs):
+    def burst_objs(self, domains):
+    # bursts all the domains that are in the list 'domains'
         bursted = []
-        for obj in objs:
-            b = self.burst_obj(obj)
-            bursted.extend(b)
+        for domain in domains:
+            d = self.burst_domain(domain)
+            bursted.extend(d)
 
         return bursted
 
@@ -662,6 +662,10 @@ def clear_volume(self, pos, radius, ignore=[]):
             - radius: radius of area to be "bursted"
             - ignore: domains that should be ignored, none by default.
         """ # ~ MW
+	# TODO clear_volume now always assumes a spherical volume to burst.
+	# It is inefficient to burst on the 'other' side of the membrane or to
+	# burst in a circle, when you want to make a new shell in the membrane.
+	# Then we may want to burst in a cylindrical volume, not a sphere
         neighbors = self.get_neighbors_within_radius_no_sort(pos, radius,
                                                              ignore)
         return self.burst_objs(neighbors)
@@ -669,12 +673,12 @@ def clear_volume(self, pos, radius, ignore=[]):
     def burst_non_multis(self, neighbors):
         bursted = []
 
-        for obj in neighbors:
-            if not isinstance(obj, Multi):
-                b = self.burst_obj(obj)
-                bursted.extend(b)
+        for domain in neighbors:
+            if not isinstance(domain, Multi):
+                d = self.burst_domain(domain)
+                bursted.extend(d)
             else:
-                bursted.append(obj)
+                bursted.append(domain)
 
         return bursted
 
@@ -946,17 +950,17 @@ def fire_single(self, single):
                                                   singlepos, min_shell,
                                                   ignore=[single.structure.id])
             if interaction_surface:
-                obj = self.form_interaction(single, interaction_surface, burst)
-                if obj:
+                domain = self.form_interaction(single, interaction_surface, burst)
+                if domain:
                     return
         else:
             # Surfaces are not allowed to touch or overlap.
             closest_surface = None
 
         if burst:
-            obj = self.form_pair_or_multi(single, burst)
+            domain = self.form_pair_or_multi(single, burst)
 
-            if obj:
+            if domain:
                 return
 
             # if nothing was formed, recheck closest and restore shells.
@@ -1820,39 +1824,39 @@ def form_multi(self, single, neighbors, dists):
         assert False, 'do not reach here'
 
 
-    def add_to_multi_recursive(self, obj, multi):
-        if isinstance(obj, Single):
-            if multi.has_particle(obj.pid_particle_pair[0]):
+    def add_to_multi_recursive(self, domain, multi):
+        if isinstance(domain, Single):
+            if multi.has_particle(domain.pid_particle_pair[0]):
                 # Already in the Multi.
                 return
-            assert obj.is_reset()
-            objpos = obj.shell.shape.position
+            assert domain.is_reset()
+            objpos = domain.shell.shape.position
             
-            self.add_to_multi(obj, multi)
-            self.remove_domain(obj)
-            self.remove_event(obj)
+            self.add_to_multi(domain, multi)
+            self.remove_domain(domain)
+            self.remove_event(domain)
 
-            radius = obj.pid_particle_pair[1].radius * \
+            radius = domain.pid_particle_pair[1].radius * \
                 (1.0 + self.MULTI_SHELL_FACTOR)
             neighbors = self.get_neighbors_within_radius_no_sort(
-                    objpos, radius, ignore=[obj.domain_id])
+                    objpos, radius, ignore=[domain.domain_id])
 
             burst = self.burst_non_multis(neighbors)
             neighbor_dists = self.obj_distance_array(objpos, burst)
             neighbors = [burst[i] for i
                                   in (neighbor_dists <= radius).nonzero()[0]]
 
-            for obj in neighbors:
-                self.add_to_multi_recursive(obj, multi)
+            for domain in neighbors:
+                self.add_to_multi_recursive(domain, multi)
 
-        elif isinstance(obj, Multi):
+        elif isinstance(domain, Multi):
             for pp in multi.particles:
-                if obj.has_particle(pp[0]):
+                if domain.has_particle(pp[0]):
                     if __debug__:
-                        log.debug('%s already added. skipping.' % obj)
+                        log.debug('%s already added. skipping.' % domain)
                     break
             else:
-                self.merge_multis(obj, multi)
+                self.merge_multis(domain, multi)
         else:
             assert False, 'do not reach here.'  # Pairs are burst
 

From 491699634d5e460a6c69d7eab93ab51a6629809d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 15 Aug 2011 18:58:23 +0200
Subject: [PATCH 0123/1541] partially fixing the previous commit

---
 egfrd.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3f3edb34..8bef2d92 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -387,8 +387,8 @@ def step(self):
 
     def create_single(self, pid_particle_pair):
         rts = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
-        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
-        shell_id = self.shell_id_generator()	# FIXME: move to protective_domain constructor
+        domain_id = self.domain_id_generator()
+        shell_id = self.shell_id_generator()
 
         # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
@@ -403,7 +403,7 @@ def create_single(self, pid_particle_pair):
 
         single.initialize(self.t)
         self.move_shell(single.shell_id_shell_pair)
-        self.domains[single.domain_id] = single
+        self.domains[domain_id] = single
 
         if __debug__:
             # Used in __str__.
@@ -423,8 +423,8 @@ def create_interaction(self, single, surface, projected_point,
         # TODO.
         interaction_type = None
 
-        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
-        shell_id = self.shell_id_generator()	# FIXME: move to protective domain constructor
+        domain_id = self.domain_id_generator()
+        shell_id = self.shell_id_generator()
 
         interaction = \
             create_default_interaction(domain_id, pid_particle_pair, shell_id,
@@ -435,7 +435,7 @@ def create_interaction(self, single, surface, projected_point,
         interaction.initialize(self.t)
 
         self.move_shell(interaction.shell_id_shell_pair)
-        self.domains[interaction.domain_id] = interaction
+        self.domains[domain_id] = interaction
 
         if __debug__:
             # Used in __str__.
@@ -461,8 +461,8 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         # the sum of the rates of all the possible reaction types. 
         rt.ktot = k_max
 
-        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
-        shell_id = self.shell_id_generator()	# FIXME: move to protective_domain constructor
+        domain_id = self.domain_id_generator()
+        shell_id = self.shell_id_generator()
 
         pos1 = single1.shell.shape.position
         pos2 = single2.shell.shape.position
@@ -481,7 +481,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         pair.initialize(self.t)
 
         self.move_shell(pair.shell_id_shell_pair)
-        self.domains[pair.domain_id] = pair
+        self.domains[domain_id] = pair
 
         if __debug__:
             # Used in __str__.
@@ -490,7 +490,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         return pair
 
     def create_multi(self):
-        domain_id = self.domain_id_generator()	# FIXME: move to domain constructor
+        domain_id = self.domain_id_generator()
         if __debug__:
             try:
                 # Option to make multis run faster for nicer visualization.
@@ -500,7 +500,7 @@ def create_multi(self):
         else:
             dt_factor = DEFAULT_DT_FACTOR
         multi = Multi(domain_id, self, dt_factor)
-        self.domains[multi.domain_id] = multi
+        self.domains[domain_id] = multi
         return multi
 
     def move_single(self, single, position, radius=None):

From 2fa987c4f5bc6a64e3da4951cfcf83c731dde8b1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 15 Aug 2011 19:24:37 +0200
Subject: [PATCH 0124/1541] some style changes

---
 egfrd.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8bef2d92..860706eb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -386,10 +386,11 @@ def step(self):
 
 
     def create_single(self, pid_particle_pair):
-        rts = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
+        rts = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
+
         # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
         structure = self.world.get_structure(species.structure_id)
@@ -415,6 +416,9 @@ def create_interaction(self, single, surface, projected_point,
                            dr, dz_left, dz_right):
         assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
 
+        domain_id = self.domain_id_generator()
+        shell_id = self.shell_id_generator()
+
         pid_particle_pair = single.pid_particle_pair
         species_id = pid_particle_pair[1].sid
 
@@ -423,9 +427,6 @@ def create_interaction(self, single, surface, projected_point,
         # TODO.
         interaction_type = None
 
-        domain_id = self.domain_id_generator()
-        shell_id = self.shell_id_generator()
-
         interaction = \
             create_default_interaction(domain_id, pid_particle_pair, shell_id,
                                        reaction_types, interaction_type,
@@ -448,6 +449,9 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         assert single1.dt == 0.0
         assert single2.dt == 0.0
 
+        domain_id = self.domain_id_generator()
+        shell_id = self.shell_id_generator()
+
         # Select 1 reaction type out of all possible reaction types.
         rts = self.network_rules.query_reaction_rule(
                 single1.pid_particle_pair[1].sid,
@@ -461,9 +465,6 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         # the sum of the rates of all the possible reaction types. 
         rt.ktot = k_max
 
-        domain_id = self.domain_id_generator()
-        shell_id = self.shell_id_generator()
-
         pos1 = single1.shell.shape.position
         pos2 = single2.shell.shape.position
 
@@ -491,6 +492,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
 
     def create_multi(self):
         domain_id = self.domain_id_generator()
+
         if __debug__:
             try:
                 # Option to make multis run faster for nicer visualization.
@@ -499,6 +501,7 @@ def create_multi(self):
                 dt_factor = DEFAULT_DT_FACTOR 
         else:
             dt_factor = DEFAULT_DT_FACTOR
+
         multi = Multi(domain_id, self, dt_factor)
         self.domains[domain_id] = multi
         return multi

From c4f027ab6bf4b22ae60752e76e43d6526520729b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 15 Aug 2011 19:27:59 +0200
Subject: [PATCH 0125/1541] multis cannot be bursted, redundant method removed

---
 egfrd.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 860706eb..b2158087 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -631,7 +631,8 @@ def burst_domain(self, domain):
             self.remove_event(domain)
             bursted = [single1, single2]
         else:  # Multi
-            bursted = self.burst_multi(domain)
+#            bursted = self.burst_multi(domain)
+            bursted = self.break_up_multi(domain)
             self.remove_event(domain)
 
         if __debug__:
@@ -1200,12 +1201,12 @@ def break_up_multi(self, multi):
         self.remove_domain(multi)
         return singles
 
-    def burst_multi(self, multi):
-        #multi.sim.sync()
-        assert isinstance(multi, Multi)
-        singles = self.break_up_multi(multi)
-
-        return singles
+#    def burst_multi(self, multi):
+#        #multi.sim.sync()
+#        assert isinstance(multi, Multi)
+#        singles = self.break_up_multi(multi)
+#
+#        return singles
 
     def burst_single(self, single):
         # Sets next event time of single domain in such a way it will end 

From 7b6cdd3294d5f4468a95a962a5aee7dcce7961c9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 16 Aug 2011 13:39:09 +0200
Subject: [PATCH 0126/1541] added default event for Multi (just diffusion)

---
 constants.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/constants.py b/constants.py
index 7ee65be1..bccf4aaf 100644
--- a/constants.py
+++ b/constants.py
@@ -22,3 +22,4 @@ def __repr__(self):
         EventType(18, "MULTI_UNIMOLECULAR_REACTION")
 EventType.MULTI_BIMOLECULAR_REACTION = \
         EventType(19, "MULTI_BIMOLECULAR_REACTION")
+EventType.MULTI_DIFFUSION = EventType(20, "MULTI_DIFFUSION")

From f7cac7f9e6871dc301d98bf4e500a20373684aa1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 16 Aug 2011 13:39:50 +0200
Subject: [PATCH 0127/1541] Just added some comments

---
 egfrd.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b2158087..328837e3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -614,6 +614,7 @@ def update_domain_event(self, t, domain):
 
 
     def burst_domain(self, domain):
+    # Reduces and domain (Single, Pair or Multi) to Singles with the zero shell, and dt=0
         if __debug__:
             log.info('burst_domain: %s' % domain)
 
@@ -632,7 +633,9 @@ def burst_domain(self, domain):
             bursted = [single1, single2]
         else:  # Multi
 #            bursted = self.burst_multi(domain)
-            bursted = self.break_up_multi(domain)
+            bursted = self.break_up_multi(domain)	# Multi's can really be 'bursted' since the
+							# positions of the particles are known. They
+							# are broken up to singles instead.
             self.remove_event(domain)
 
         if __debug__:
@@ -865,6 +868,8 @@ def fire_single(self, single):
         if single.dt == numpy.inf:
             return single 
         
+	### 1. Process event produced by the single
+
         # Otherwise check timeline
         assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
@@ -925,7 +930,7 @@ def fire_single(self, single):
 
         singlepos = single.shell.shape.position
 
-	# Now try to make a new domain
+	### 2. Now make a new domain
         # (2) Clear volume.
 
         min_shell = single.pid_particle_pair[1].radius * \
@@ -1184,7 +1189,7 @@ def fire_multi(self, multi):
             self.reaction_events += 1
             self.last_reaction = multi.last_reaction
 
-        if multi.last_event is not None:
+        if multi.last_event is not None:		# if an event took place
             self.break_up_multi(multi)
             self.multi_steps[multi.last_event] += 1
         else:

From d98e0c03f001eb88dd52c8ba143c51a95b582e24 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 16 Aug 2011 17:10:05 +0200
Subject: [PATCH 0128/1541] improved class structure for Single, Pair and Multi
 Now it's clearer what the relations are between the objects and there is less
 code replication.

---
 domain.py | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 multi.py  | 11 ++++++++---
 pair.py   | 38 ++++++++------------------------------
 single.py | 55 ++++++++++++++++++-------------------------------------
 4 files changed, 85 insertions(+), 70 deletions(-)
 create mode 100644 domain.py

diff --git a/domain.py b/domain.py
new file mode 100644
index 00000000..477d9411
--- /dev/null
+++ b/domain.py
@@ -0,0 +1,51 @@
+from _gfrd import *
+
+class Domain(object):
+# The domain is the main unit of eGFRD. Single, Pairs and Multis are all domains
+# with an own domain_id
+
+    def __init__(self, domain_id):
+	self.domain_id = domain_id	# identifier for this domain object
+	self.event_id = None		# identifier for the event coupled to this domain
+
+	self.event_type = None
+
+	self.last_time = 0.0
+	self.dt = 0.0
+
+    def initialize(self, time):		# this method needs to be overloaded in all subclasses
+	pass
+
+
+class ProtectiveDomain(Domain):
+# Protective Domains are the proper eGFRD domains. The shell associated with a Protective
+# Domains really exclude other particles from the simulation. These Domains are Singles and Pairs
+# which have only one shell. Multi's on the other hand, have multiple shells and can still leave
+# their shell within a timestep, breaking the principle of a Protective Domain
+
+    def __init__(self, domain_id):
+	Domain.__init__(self, domain_id)
+
+	self.shell_id = None
+	self.shell = None
+	self.num_shells = 1		# all protective domains have only one shell
+
+    def get_shell_id_shell_pair(self):
+	return (self.shell_id, self.shell)
+
+    def set_shell_id_shell_pair(self, shell_id_shell_pair):
+	self.shell_id = shell_id_shell_pair[0]
+	self.shell = shell_id_shell_pair[1]
+
+    shell_id_shell_pair = property(get_shell_id_shell_pair, set_shell_id_shell_pair)
+
+    def get_shell_list(self):
+	return [(self.shell_id, self.shell), ]
+
+    shell_list = property(get_shell_list)
+
+    def create_new_shell(self):		# needs to be overloaded in subclasses
+	pass				# creates an appropriate shell object
+
+    def get_shell_radius(self):		# returns the radius of the shell
+	return self.shell.shape.radius
diff --git a/multi.py b/multi.py
index d515f3b8..9ff4e34f 100644
--- a/multi.py
+++ b/multi.py
@@ -7,15 +7,20 @@
 
 import _gfrd
 from constants import EventType
+from domain import Domain
 
 import os
 
-class Multi(object):
+class Multi(Domain):
     def __init__(self, domain_id, main, dt_factor):
+	Domain.__init__(self, domain_id)
+
         self.main = ref(main)
-        self.domain_id = domain_id
-        self.event_id = None
+#        self.domain_id = domain_id
+#        self.event_id = None
         self.last_event = None
+	self.event_Type = EventType.MULTI_DIFFUSION
+
         self.sphere_container = _gfrd.SphericalShellContainer(main.world.world_size, 3)
         self.particle_container = _gfrd.MultiParticleContainer(main.world)
         self.escaped = False
diff --git a/pair.py b/pair.py
index 0ff6c4a4..fe3637f1 100644
--- a/pair.py
+++ b/pair.py
@@ -2,6 +2,7 @@
 from constants import EventType
 from _greens_functions import *
 from greens_function_wrapper import *
+from domain import *
 
 __all__ = [
     'CylindricalSurfacePair',
@@ -10,7 +11,7 @@
     'Pair',
     ]
 
-class Pair(object):
+class Pair(ProtectiveDomain):
     """There are 3 types of pairs:
         * SphericalPair
         * PlanarSurfacePair
@@ -25,8 +26,9 @@ class Pair(object):
 
     def __init__(self, domain_id, com, single1, single2, shell_id, r0, 
                  shell_size, rt, structure):
+	ProtectiveDomain.__init__(self, domain_id)
+
         self.multiplicity = 2
-        self.num_shells = 1
 
         self.single1 = single1
         self.single2 = single2 
@@ -35,20 +37,11 @@ def __init__(self, domain_id, com, single1, single2, shell_id, r0,
 	# set the radii of the inner domains as a function of the outer protective domain
 
         self.rt = rt
-
-        self.event_id = None
-
-        self.last_time = 0.0
-        self.dt = 0.0
-        self.event_type = None
-
-        self.structure = structure
+        self.structure = structure		# structure on which both particles live
 
         # Create shell.
-        shell = self.create_new_shell(com, shell_size, domain_id)
-
-        self.shell_list = [(shell_id, shell), ]
-        self.domain_id = domain_id
+	self.shell_id = shell_id
+        self.shell = self.create_new_shell(com, shell_size, domain_id)
 
     def __del__(self):
         if __debug__:
@@ -58,21 +51,6 @@ def get_com(self):
         return self.shell_list[0][1].shape.position
     com = property(get_com)
 
-    def get_shell_id(self):
-        return self.shell_list[0][0]
-    shell_id = property(get_shell_id)
-
-    def get_shell(self):
-        return self.shell_list[0][1]
-    shell = property(get_shell)
-
-    def get_shell_id_shell_pair(self):
-        return self.shell_list[0]
-    def set_shell_id_shell_pair(self, value):
-        self.shell_list[0] = value
-    shell_id_shell_pair = property(get_shell_id_shell_pair, 
-                                   set_shell_id_shell_pair)
-
     def get_shell_size(self):
         return self.shell_list[0][1].shape.radius
 
@@ -535,7 +513,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
     def get_shell_size(self):
         # Heads up.
-        return self.shell_list[0][1].shape.half_length
+        return self.shell.shape.half_length
 
     def __str__(self):
         return 'CylindricalSurface' + Pair.__str__(self)
diff --git a/single.py b/single.py
index b6ed6218..4cbf524d 100644
--- a/single.py
+++ b/single.py
@@ -3,6 +3,7 @@
 from greens_function_wrapper import *
 from constants import EventType
 import utils
+from domain import *
 
 __all__ = [
     'CylindricalSurfaceSingle',
@@ -15,7 +16,7 @@
     ]
 
 
-class Single(object):
+class Single(ProtectiveDomain):
     """There are 2 main types of Singles:
         * NonInteractionSingle
         * InteractionSingle (when the particle is nearby a surface)
@@ -26,23 +27,15 @@ class Single(object):
 
     """
     def __init__(self, domain_id, pid_particle_pair, reactiontypes, structure):
+	ProtectiveDomain.__init__(self, domain_id)
+
         self.multiplicity = 1
-        self.num_shells = 1
 
         self.pid_particle_pair = pid_particle_pair
-        self.reactiontypes = reactiontypes
-
-        self.k_tot = 0
-
-        self.last_time = 0.0
-        self.dt = 0.0
-
-        self.event_id = None
-        self.event_type = None
-
         self.structure = structure		# the structure in/on which the particle lives
-        self.domain_id = domain_id
 
+        self.reactiontypes = reactiontypes
+        self.k_tot = 0
         self.updatek_tot()
 
     def getD(self):
@@ -54,20 +47,6 @@ def getv(self):
         return self.pid_particle_pair[1].v
     v = property(getv)
 
-    def get_shell_id(self):
-        return self.shell_list[0][0]
-    shell_id = property(get_shell_id)
-
-    def get_shell(self):
-        return self.shell_list[0][1]
-    shell = property(get_shell)
-
-    def get_shell_id_shell_pair(self):
-        return self.shell_list[0]
-    def set_shell_id_shell_pair(self, value):
-        self.shell_list[0] = value
-    shell_id_shell_pair = property(get_shell_id_shell_pair, 
-                                   set_shell_id_shell_pair)
 
     # FIXME: This shouldn't be here, since the mobility_radius doens't mean anything
     #        for interaction singles
@@ -76,7 +55,7 @@ def get_mobility_radius(self):
 
     # FIXME: Same goes here
     def get_shell_size(self):
-        return self.shell_list[0][1].shape.radius
+        return self.shell.shape.radius
 
     def draw_new_position(self, dt, event_type):
 	'''Draw a new position of the particle in the simulation coordinate system
@@ -178,10 +157,10 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
                         structure)
 
         # Create shell.
-        shell = self.create_new_shell(pid_particle_pair[1].position,
+	self.shell_id = shell_id
+        self.shell = self.create_new_shell(pid_particle_pair[1].position,
                                       pid_particle_pair[1].radius, domain_id)
 
-        self.shell_list = [(shell_id, shell), ]
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -294,7 +273,6 @@ class CylindricalSurfaceSingle(NonInteractionSingle):
         * Domain: cartesian z.
         * Initial position: z = 0.
         * Selected randomly when drawing displacement vector: none.
-
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
                  structure):
@@ -319,12 +297,12 @@ def create_position_vector(self, z):
         if utils.feq(z, self.get_mobility_radius()):
             # Escape, can be either to the left or to the right.
             z = myrandom.choice(-1, 1) * z 
-        return z * self.shell_list[0][1].shape.unit_z
+        return z * self.shell.shape.unit_z
 
     def get_shell_size(self):
         # Heads up. The cylinder's *half_length*, not radius, 
         # determines the size in case of a cylindrical surface.
-        return self.shell_list[0][1].shape.half_length
+        return self.shell.shape.half_length
 
     def __str__(self):
         return 'CylindricalSurface' + Single.__str__(self)
@@ -344,8 +322,11 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, shell,
 
         Single.__init__(self, domain_id, pid_particle_pair, reactiontypes,
                         structure)
+
         self.interaction_type = interaction_type
-        self.shell_list = [(shell_id, shell), ]
+        self.shell_id = shell_id
+	self.shell = shell
+
 	self.surface = surface			# The surface with which the particle is trying to interact
 
     def determine_next_event(self):
@@ -390,7 +371,7 @@ class PlanarSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, structure, shell_id, reactiontypes,
+    def __init__(self, domain_id, shell_id, pid_particle_pair, structure, reactiontypes,
                  interaction_type, surface, origin, orientation, half_length, 
                  particle_offset, projected_point, size_of_domain):
 
@@ -457,7 +438,7 @@ def greens_function_z(self):
     def createNewShell(self, position, radius, domain_id):
         orientation = self.orientation
         half_length = self.half_length
-        return CylindricalShell(position, radius, orientation, half_length,
+        return CylindricalShell(position, radius, orientation, half_length,	# FIXME
                                 domain_id)
 
     def draw_new_position(self, dt, eventType):
@@ -582,7 +563,7 @@ def draw_new_position(self, dt, event_type):
     def get_shell_size(self):
         # Heads up. The cylinder's *half_length*, not radius, 
         # determines the size in case of a cylindrical surface.
-        return self.shell_list[0][1].shape.half_length
+        return self.shell.shape.half_length
 
     def __str__(self):
         return 'CylindricalSurfaceInteraction' + Single.__str__(self)

From 853cd5a3374539bdea4c2382ca44d866a0d85e0e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 16 Aug 2011 18:41:10 +0200
Subject: [PATCH 0129/1541] doing preparations to simplify create_pair method
 Create_single takes particles, whereas the other create_methods take
 (unnecessarily) singles. Start doing work such that the methods just take
 particles not domains

---
 egfrd.py | 20 ++++++++++--------
 pair.py  | 64 ++++++++++++++++++++++++++++----------------------------
 2 files changed, 43 insertions(+), 41 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 328837e3..2e0fe180 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -449,13 +449,17 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         assert single1.dt == 0.0
         assert single2.dt == 0.0
 
+	pid_particle_pair1 = single1.pid_particle_pair
+	pid_particle_pair2 = single2.pid_particle_pair
+
+
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
-        # Select 1 reaction type out of all possible reaction types.
+        # Select 1 reaction type out of all possible reaction types between the two particles.
         rts = self.network_rules.query_reaction_rule(
-                single1.pid_particle_pair[1].sid,
-                single2.pid_particle_pair[1].sid)
+                pid_particle_pair1[1].sid,
+                pid_particle_pair2[1].sid)
         k_array = numpy.add.accumulate([rt.k for rt in rts])
         k_max = k_array[-1]
         rnd = myrandom.uniform()
@@ -465,12 +469,10 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         # the sum of the rates of all the possible reaction types. 
         rt.ktot = k_max
 
-        pos1 = single1.shell.shape.position
-        pos2 = single2.shell.shape.position
-
-        # Get structure (region or surface).
-        species = self.world.get_species(single1.pid_particle_pair[1].sid)
-        structure = self.world.get_structure(species.structure_id)
+        # Get structure (region or surface) where particle1 lives (assuming particle2
+	# also lives here -> TODO).
+        species1 = self.world.get_species(pid_particle_pair1[1].sid)
+        structure = self.world.get_structure(species1.structure_id)
 
         # Create pair. The type of the pair that will be created depends
         # on the structure (region or surface) the particles are in/on.  
diff --git a/pair.py b/pair.py
index fe3637f1..f41676cc 100644
--- a/pair.py
+++ b/pair.py
@@ -32,6 +32,8 @@ def __init__(self, domain_id, com, single1, single2, shell_id, r0,
 
         self.single1 = single1
         self.single2 = single2 
+	self.pid_particle_pair1 = single1.pid_particle_pair
+	self.pid_particle_pair2 = single2.pid_particle_pair
 
         self.a_R, self.a_r = self.determine_radii(r0, shell_size)
 	# set the radii of the inner domains as a function of the outer protective domain
@@ -48,39 +50,39 @@ def __del__(self):
             log.debug('del %s' % str(self))
 
     def get_com(self):
-        return self.shell_list[0][1].shape.position
+        return self.shell.shape.position
     com = property(get_com)
 
     def get_shell_size(self):
-        return self.shell_list[0][1].shape.radius
+        return self.shell.shape.radius
 
     def get_D_tot(self):
-        return self.single1.pid_particle_pair[1].D + \
-               self.single2.pid_particle_pair[1].D
+        return self.pid_particle_pair1[1].D + \
+               self.pid_particle_pair2[1].D
     D_tot = property(get_D_tot)
 
     def get_D_R(self):
-        return (self.single1.pid_particle_pair[1].D *
-                self.single2.pid_particle_pair[1].D) / self.D_tot
+        return (self.pid_particle_pair1[1].D *
+                self.pid_particle_pair2[1].D) / self.D_tot
     D_R = property(get_D_R)
 
     def get_v_tot(self):
-        return self.single2.pid_particle_pair[1].v - \
-               self.single1.pid_particle_pair[1].v
+        return self.pid_particle_pair2[1].v - \
+               self.pid_particle_pair1[1].v
     v_tot = property(get_v_tot)
     
     v_r = property(get_v_tot)
 
     def get_v_R(self):
-        return (self.single1.pid_particle_pair[1].v * 
-                self.single2.pid_particle_pair[1].D +
-                self.single2.pid_particle_pair[1].v *
-                self.single1.pid_particle_pair[1].D) / self.D_tot
+        return (self.pid_particle_pair1[1].v * 
+                self.pid_particle_pair2[1].D +
+                self.pid_particle_pair2[1].v *
+                self.pid_particle_pair1[1].D) / self.D_tot
     v_R = property(get_v_R)
 
     def getSigma(self):
-        return self.single1.pid_particle_pair[1].radius + \
-               self.single2.pid_particle_pair[1].radius
+        return self.pid_particle_pair1[1].radius + \
+               self.pid_particle_pair2[1].radius
     sigma = property(getSigma)
 
     def initialize(self, t):
@@ -94,13 +96,11 @@ def determine_radii(self, r0, shell_size):
         Todo. Make dimension (1D/2D/3D) specific someday. Optimization only.
 
         """
-        single1 = self.single1
-        single2 = self.single2
-        radius1 = single1.pid_particle_pair[1].radius
-        radius2 = single2.pid_particle_pair[1].radius
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
 
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
 
 	LD_MAX = 20 # temporary value
 	a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
@@ -226,8 +226,8 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         new_com = self.draw_new_com(dt, event_type)
         new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
 
-        D1 = self.single1.pid_particle_pair[1].D
-        D2 = self.single2.pid_particle_pair[1].D
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
 
         newpos1 = new_com - new_iv * (D1 / self.D_tot)
         newpos2 = new_com + new_iv * (D2 / self.D_tot)
@@ -262,15 +262,15 @@ def check(self):
         pass
 
     def __str__(self):
-        sid = self.single1.pid_particle_pair[1].sid
-        sid2 = self.single2.pid_particle_pair[1].sid
-        name = self.world.model.get_species_type_by_id(sid)["name"]
+        sid1 = self.pid_particle_pair1[1].sid
+        sid2 = self.pid_particle_pair2[1].sid
+        name1 = self.world.model.get_species_type_by_id(sid1)["name"]
         name2 = self.world.model.get_species_type_by_id(sid2)["name"]
         return 'Pair[%s: %s, %s, (%s, %s)]' % (
             self.domain_id,
-            self.single1.pid_particle_pair[0],
-            self.single2.pid_particle_pair[0],
-            name, name2)
+            self.pid_particle_pair1[0],
+            self.pid_particle_pair2[0],
+            name1, name2)
 
 class SphericalPair(Pair):
     """2 Particles inside a (spherical) shell not on any surface.
@@ -398,8 +398,8 @@ def create_new_shell(self, position, radius, domain_id):
         # error).
         orientation = crossproduct(self.structure.shape.unit_x,
                                    self.structure.shape.unit_y)
-        half_length = max(self.single1.pid_particle_pair[1].radius,
-                          self.single2.pid_particle_pair[1].radius)
+        half_length = max(self.pid_particle_pair1[1].radius,
+                          self.pid_particle_pair2[1].radius)
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
@@ -491,8 +491,8 @@ def create_new_shell(self, position, half_length, domain_id):
         # radius of the biggest particle), so if the particle undergoes 
         # an unbinding reaction we still have to clear the target volume 
         # and the move may be rejected (NoSpace error).
-        radius = max(self.single1.pid_particle_pair[1].radius,
-                     self.single2.pid_particle_pair[1].radius)
+        radius = max(self.pid_particle_pair1[1].radius,
+                     self.pid_particle_pair2[1].radius)
         orientation = self.structure.shape.unit_z
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))

From 265e44e19f61ce844e132dd64b2518932c9ed7df Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 17 Aug 2011 19:02:46 +0200
Subject: [PATCH 0130/1541] some comments are change of signatures of
 create_interaction Some comments added to clarify create_single, pair and
 interaction Also some work to single.py to clarify the interactions subclass

---
 egfrd.py  | 61 +++++++++++++++++++++++++++----------------
 single.py | 77 +++++++++++++++++++++++++++++++++----------------------
 2 files changed, 85 insertions(+), 53 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2e0fe180..e4a2770a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -233,6 +233,8 @@ def initialize(self):
 
 	# create/clear other datastructures
 	# the containers hold the spherical and cylindrical shells respectively 
+	# the containers is a cache for the shell objects in the domain and is mostly
+	# read only. The only method that writes the containers is self.move_shell
         self.containers = [SphericalShellContainer(self.world.world_size, 
                                                    self.world.matrix_size),
                            CylindricalShellContainer(self.world.world_size, 
@@ -386,63 +388,70 @@ def step(self):
 
 
     def create_single(self, pid_particle_pair):
+	# 1. generate identifiers for the domain and shell. The event_id is
+	# generated by the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
         rts = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
-
         # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
         structure = self.world.get_structure(species.structure_id)
 
-        # Create single. The type of the single that will be created 
+        # 2. Create and register the single domain.
+	# The type of the single that will be created 
         # depends on the structure (region or surface) this particle is 
         # in/on. Either SphericalSingle, PlanarSurfaceSingle, or 
         # CylindricalSurfaceSingle.
         single = create_default_single(domain_id, pid_particle_pair, 
                                        shell_id, rts, structure)
-
+#        assert isinstance(single, NonInteractionSingle)
         single.initialize(self.t)
-        self.move_shell(single.shell_id_shell_pair)
         self.domains[domain_id] = single
 
+	# 3. update the proper shell container
+        self.move_shell(single.shell_id_shell_pair)
+
         if __debug__:
             # Used in __str__.
             single.world = self.world
         return single
 
-    def create_interaction(self, single, surface, projected_point, 
-                           particle_distance, orientation_vector,
-                           dr, dz_left, dz_right):
-        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
+    def create_interaction(self, pid_particle_pair, surface, shell_center,
+			   shell_radius, shell_length, orientation_vector):
 
+##        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
+#	assert that the particle is not already associate with another domain
+
+	# 1. generate identifiers for the domain and shell. event_id is generated by
+	# the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
-        pid_particle_pair = single.pid_particle_pair
         species_id = pid_particle_pair[1].sid
-
         reaction_types = self.network_rules.query_reaction_rule(species_id)
         #interaction_type = self.query_interaction_rule(species_id, surface)
         # TODO.
         interaction_type = None
 
+	# 2. create and register the proper domain object
         interaction = \
-            create_default_interaction(domain_id, pid_particle_pair, shell_id,
+            create_default_interaction(domain_id, pid_particle_pair, structure,
                                        reaction_types, interaction_type,
-                                       surface, projected_point,
-                                       particle_distance, orientation_vector,
-                                       dr, dz_left, dz_right)
+                                       surface, shell_id, shell_center,
+				       shell_radius, shell_length,
+                                       orientation_vector)
+        assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
+        self.domains[domain_id] = interaction
 
+	# 3. update the shell containers 
         self.move_shell(interaction.shell_id_shell_pair)
-        self.domains[domain_id] = interaction
 
         if __debug__:
             # Used in __str__.
             interaction.world = self.world
 
-        assert isinstance(interaction, InteractionSingle)
         return interaction
 
     def create_pair(self, single1, single2, com, r0, shell_size):
@@ -452,7 +461,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
 	pid_particle_pair1 = single1.pid_particle_pair
 	pid_particle_pair2 = single2.pid_particle_pair
 
-
+	# 1. generate needed identifiers
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
@@ -474,7 +483,8 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         species1 = self.world.get_species(pid_particle_pair1[1].sid)
         structure = self.world.get_structure(species1.structure_id)
 
-        # Create pair. The type of the pair that will be created depends
+
+        # 2. Create pair. The type of the pair that will be created depends
         # on the structure (region or surface) the particles are in/on.  
         # Either SphericalPair, PlanarSurfacePair, or 
         # CylindricalSurfacePair.
@@ -482,17 +492,18 @@ def create_pair(self, single1, single2, com, r0, shell_size):
                                    r0, shell_size, rt, structure)
 
         pair.initialize(self.t)
+        self.domains[domain_id] = pair
 
+	# 3. update the shell containers with the new shell
         self.move_shell(pair.shell_id_shell_pair)
-        self.domains[domain_id] = pair
 
         if __debug__:
             # Used in __str__.
             pair.world = self.world
-
         return pair
 
     def create_multi(self):
+	# 1. generate necessary id's
         domain_id = self.domain_id_generator()
 
         if __debug__:
@@ -504,10 +515,15 @@ def create_multi(self):
         else:
             dt_factor = DEFAULT_DT_FACTOR
 
+	# 2. Create and register domain object
         multi = Multi(domain_id, self, dt_factor)
         self.domains[domain_id] = multi
+
+	# 3. no shells are yet made, since these are added later
+	# -> a multi can have 0 shells
         return multi
 
+
     def move_single(self, single, position, radius=None):
         self.move_single_shell(single, position, radius)
         self.move_single_particle(single, position)
@@ -558,6 +574,7 @@ def remove_domain(self, obj):
             del container[shell_id]
 
     def move_shell(self, shell_id_shell_pair):
+    # This is the only method that writes to the shell containers
         shell = shell_id_shell_pair[1]
         container = self.get_container(shell)
         container.update(shell_id_shell_pair)
@@ -1398,7 +1415,7 @@ def form_interaction(self, single, surface, burst):
         # * dz_left determines how much the cylinder is sticking out on the 
         # other side of the surface, measured from the projected point.
         # * dz_right is the distance between the particle position and 
-        # the edge of the cylinder in the z direction.
+        # the edge of the cylinder in the direction normal to the membrane.
         #
         # For interaction with a CylindricalSurface (dna):
         # * dr is the distance between the particle position and the 
@@ -1471,7 +1488,7 @@ def form_interaction(self, single, surface, burst):
         self.last_time = self.t
 
         self.remove_domain(single)
-        # single event will be removed by the scheduler.
+        # the event associated with the single will be removed by the scheduler.
 
         if __debug__:
             log.debug('        *create_interaction\n'
diff --git a/single.py b/single.py
index 4cbf524d..b46a032a 100644
--- a/single.py
+++ b/single.py
@@ -29,10 +29,10 @@ class Single(ProtectiveDomain):
     def __init__(self, domain_id, pid_particle_pair, reactiontypes, structure):
 	ProtectiveDomain.__init__(self, domain_id)
 
-        self.multiplicity = 1
+        self.multiplicity = 1				# all singles have only one particle
 
-        self.pid_particle_pair = pid_particle_pair
-        self.structure = structure		# the structure in/on which the particle lives
+        self.pid_particle_pair = pid_particle_pair	# the particle in the single
+        self.structure = structure			# the structure in/on which the particle lives
 
         self.reactiontypes = reactiontypes
         self.k_tot = 0
@@ -325,19 +325,34 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, shell,
 
         self.interaction_type = interaction_type
         self.shell_id = shell_id
-	self.shell = shell
 
 	self.surface = surface			# The surface with which the particle is trying to interact
 
+    def initialize(self, t):			# does this method make any sence??
+	self.dt = 0
+	self.event_type = None
+	self.last_time = t
+
+    def create_new_shell(self, position, radius, length, domain_id):
+#        orientation = self.orientation
+#        half_length = self.half_length
+#	return CylindricalShell(domain_id, Cylinder(position, radius,
+#                                                    orientation, half_length))
+
+	orientation = crossproduct(self.surface.shape.unit_x,
+                                   self.surface.shape.unit_y)
+        return CylindricalShell(domain_id, Cylinder(position, radius,
+                                                    orientation, length*0.5))
+
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
         """
         return min(self.draw_escape_time_tuple(),
-                   self.draw_iv_interaction_or_escape_time_tuple(),
+                   self.draw_iv_event_time_tuple(),
                    self.draw_reaction_time_tuple())
 
-    def draw_iv_interaction_or_escape_time_tuple(self):
+    def draw_iv_event_time_tuple(self):
         """Return an (interaction/escape time, event type)-tuple.
 	Note that an interaction is modelled similarly to an escape.
  
@@ -371,9 +386,9 @@ class PlanarSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, shell_id, pid_particle_pair, structure, reactiontypes,
-                 interaction_type, surface, origin, orientation, half_length, 
-                 particle_offset, projected_point, size_of_domain):
+    def __init__(self, domain_id, pid_particle_pair, reactiontypes,
+                 interaction_type, surface, shell_id, shell_center, shell_radius,
+		 shell_length, orientation_vector):
 
 ###TODO	One of the two constructors for InteractionSingle should be right. The one below doesn't seem so
 #        InteractionSingle.__init__(self, domain_id, pid_particle_pair, 
@@ -384,6 +399,8 @@ def __init__(self, domain_id, shell_id, pid_particle_pair, structure, reactionty
 	InteractionSingle.__init__(self, domain_id, pid_particle_pair, structure, shell_id, shell,
                  reactiontypes, interaction_type, surface, structure)
 
+	self.shell = self.create_new_shell(self, position, radius, length)
+
         # Compute from dr, dz_left and dz_right the length of the new 
         # domain (only that part of the cylinder where the particle can 
         # diffuse to) and the radius and half_length of the new 
@@ -412,21 +429,23 @@ def __init__(self, domain_id, shell_id, pid_particle_pair, structure, reactionty
             # (min_radius correction in the constructor).
             particle_offset = [0, particle_distance - length_of_domain.Lz]
 
-    def greens_function_r(self):
-        # Todo. 2D gf Abs Sym.
-        #gf = FirstPassageGreensFunction2D(self.getD())
-        return FirstPassageGreensFunction(self.getD(),
+    def norm_greens_function(self):
+        # This is the Greens function that does not produce REACTION event
+        #return GreensFunction3DAbsSYm(self.getD(), get_mobility_radius())
+        return GreensFunction2DRadSym(self.getD(), 
                                           self.get_mobility_radius())
 
-    def greens_function_z(self):
+    def int_greens_function(self):
+	# The green's function that also modelles the association of the particle
+	# with the planar surface.
         # Todo. 1D gf Rad Abs should be sigma to a.
-        #gf = FirstPassageGreensFunction1DRad(self.D_tot, self.rt.k)
+        return GreensFunction1DRadAbs(self.getD, self.rt.k, self.r0, self.sigma, self.a)
 
-        return FirstPassagePairGreensFunction(self.getD(),
-                                              self.interaction_type.k, self.r0,
-                                              self.sigma, self.sigma)
-        gf.seta(a)
-        return gf
+#        return GreensFunction(self.getD(),
+#                                              self.interaction_type.k, self.r0,
+#                                              self.sigma, self.sigma)
+#        gf.seta(a)
+#        return gf
 
         # TODO.
 
@@ -435,11 +454,7 @@ def greens_function_z(self):
         #                           size_of_domain - 2 * self.getMinRadius(), 
         #                           gfz)
 
-    def createNewShell(self, position, radius, domain_id):
-        orientation = self.orientation
-        half_length = self.half_length
-        return CylindricalShell(position, radius, orientation, half_length,	# FIXME
-                                domain_id)
+
 
     def draw_new_position(self, dt, eventType):
         gf_r = self.greens_function_r()
@@ -485,19 +500,19 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
         # Only needed for this type of Interaction.
         self.unit_r = normalize(pid_particle_pair[1].position - projected_point)
 
-        shell = self.create_shell(domain_id, projected_point,
-                                  particle_distance, orientation_vector,
-                                  dr, dz_left, dz_right)
+        shell = self.create_new_shell(domain_id, projected_point,
+                                      particle_distance, orientation_vector,
+                                      dr, dz_left, dz_right)
 
         InteractionSingle.__init__(self, domain_id, pid_particle_pair,
                                    shell_id, shell, reactiontypes,
                                    interaction_type, surface)
 
-    def create_shell(self, domain_id, projected_point, particle_distance,
-                     orientation_vector, dr, dz_left, dz_right):
+    def create_new_shell(self, domain_id, projected_point, particle_distance,
+                         orientation_vector, dr, dz_left, dz_right):
 
         # Compute origin, radius and half_length of cylinder.
-        # This stuff is complicated.
+        # This stuff is complicated. and should not be here.
         half_length = (dz_left + dz_right) / 2
         shiftZ = half_length - dz_left
         origin = projected_point + shiftZ * orientation_vector

From 1ce756e3fd85ea64364076c2816a491e4ba86a5c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 19 Aug 2011 15:11:07 +0200
Subject: [PATCH 0131/1541] changing rt (reaction type) to rr (reaction rule)
 for consistency

---
 egfrd.py  | 14 +++++++-------
 single.py |  2 +-
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index e4a2770a..66f548c6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -393,7 +393,7 @@ def create_single(self, pid_particle_pair):
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
-        rts = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
+        rrs = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
         # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
         structure = self.world.get_structure(species.structure_id)
@@ -404,7 +404,7 @@ def create_single(self, pid_particle_pair):
         # in/on. Either SphericalSingle, PlanarSurfaceSingle, or 
         # CylindricalSurfaceSingle.
         single = create_default_single(domain_id, pid_particle_pair, 
-                                       shell_id, rts, structure)
+                                       shell_id, rrs, structure)
 #        assert isinstance(single, NonInteractionSingle)
         single.initialize(self.t)
         self.domains[domain_id] = single
@@ -466,17 +466,17 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         shell_id = self.shell_id_generator()
 
         # Select 1 reaction type out of all possible reaction types between the two particles.
-        rts = self.network_rules.query_reaction_rule(
+        rrs = self.network_rules.query_reaction_rule(
                 pid_particle_pair1[1].sid,
                 pid_particle_pair2[1].sid)
-        k_array = numpy.add.accumulate([rt.k for rt in rts])
+        k_array = numpy.add.accumulate([rr.k for rr in rrs])
         k_max = k_array[-1]
         rnd = myrandom.uniform()
         i = numpy.searchsorted(k_array, rnd * k_max)
-        rt = rts[i]
+        rr = rrs[i]
         # The probability for this reaction to happen is proportional to 
         # the sum of the rates of all the possible reaction types. 
-        rt.ktot = k_max
+        rr.ktot = k_max
 
         # Get structure (region or surface) where particle1 lives (assuming particle2
 	# also lives here -> TODO).
@@ -489,7 +489,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         # Either SphericalPair, PlanarSurfacePair, or 
         # CylindricalSurfacePair.
         pair = create_default_pair(domain_id, com, single1, single2, shell_id, 
-                                   r0, shell_size, rt, structure)
+                                   r0, shell_size, rr, structure)
 
         pair.initialize(self.t)
         self.domains[domain_id] = pair
diff --git a/single.py b/single.py
index b46a032a..5b50892c 100644
--- a/single.py
+++ b/single.py
@@ -80,7 +80,7 @@ def is_reset(self):
         return self.dt == 0.0 and self.event_type == EventType.SINGLE_ESCAPE
 
     def draw_reaction_time_tuple(self):
-        """Return a (reaction time, event type)-tuple.
+        """Return a (reaction time, event type)-tuple for a unimolecular reaction.
 
         """
         if self.k_tot <= 0:

From a507e7bbb0694063b2b1fef23556b3c2755b935c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 19 Aug 2011 15:11:44 +0200
Subject: [PATCH 0132/1541] trying to fix bug: Pair.draw_iv_event_type doesn't
 recognize the event_kind?!

---
 constants.py         | 1 +
 greens_functions.cpp | 8 ++++----
 pair.py              | 1 +
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/constants.py b/constants.py
index bccf4aaf..33b103e8 100644
--- a/constants.py
+++ b/constants.py
@@ -23,3 +23,4 @@ def __repr__(self):
 EventType.MULTI_BIMOLECULAR_REACTION = \
         EventType(19, "MULTI_BIMOLECULAR_REACTION")
 EventType.MULTI_DIFFUSION = EventType(20, "MULTI_DIFFUSION")
+
diff --git a/greens_functions.cpp b/greens_functions.cpp
index cc823b8f..d3496fda 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -175,10 +175,10 @@ BOOST_PYTHON_MODULE( _greens_functions )
         ;
 
     enum_<GreensFunction::EventKind>("PairEventKind")
-        .value( "IV_ESCAPE", GreensFunction3DRadAbs::IV_ESCAPE )
-        .value( "IV_REACTION", GreensFunction3DRadAbs::IV_REACTION )
-        .value( "IV_ESCAPE", GreensFunction1DRadAbs::IV_ESCAPE )
-        .value( "IV_REACTION", GreensFunction1DRadAbs::IV_REACTION )
+        .value( "IV_ESCAPE", GreensFunction::IV_ESCAPE )
+        .value( "IV_REACTION", GreensFunction::IV_REACTION )
+//        .value( "IV_ESCAPE", GreensFunction1DRadAbs::IV_ESCAPE )
+//       .value( "IV_REACTION", GreensFunction1DRadAbs::IV_REACTION )
         ;
 
     class_<GreensFunction3DRadAbs>("GreensFunction3DRadAbs",
diff --git a/pair.py b/pair.py
index f41676cc..cd46d34e 100644
--- a/pair.py
+++ b/pair.py
@@ -211,6 +211,7 @@ def determine_next_event(self, r0):
     def draw_iv_event_type(self, r0):
         gf = self.iv_greens_function(r0)
         event_kind = draw_event_type_wrapper(gf, self.dt)
+	print event_kind
         if event_kind == PairEventKind.IV_REACTION:
             return EventType.IV_REACTION
         elif event_kind == PairEventKind.IV_ESCAPE:

From f3b3786043790aabe5b1777a396a20a66ac2b21c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 19 Aug 2011 17:35:08 +0200
Subject: [PATCH 0133/1541] added creating reaction rule 0->A can now also be
 modelled.

---
 model.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/model.py b/model.py
index 3f55d098..f2ac8eac 100644
--- a/model.py
+++ b/model.py
@@ -277,6 +277,23 @@ def create_decay_reaction_rule(reactant, k):
     rr['k'] = '%.16g' % k
     return rr
 
+def create_creation_reaction_rule(product, k):
+    """Example: 0 -> A.
+
+    Arguments:
+	- product
+	    a Species
+	- k
+	    reaction rate. Units: per second.
+
+    A creation reaction rule defines a Poissonian process.
+
+    """
+
+    rr = _gfrd.ReactionRule([], [product])
+    rr['k'] = '%.16g' % k
+    return rr
+
 def create_annihilation_reaction_rule(reactant1, reactant2, ka):
     """Example: A + B -> 0.
 

From 8fdbb64758fee98c778702b862e0a1e8dc72ee95 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 23 Aug 2011 13:56:57 +0200
Subject: [PATCH 0134/1541] some small changes in order to clarify the followed
 procedure

---
 egfrd.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 66f548c6..22e60376 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1147,10 +1147,13 @@ def fire_pair(self, pair):
             self.world.remove_particle(single1.pid_particle_pair[0])
             self.world.remove_particle(single2.pid_particle_pair[0])
 
-            if len(pair.rt.products) == 1:
-                species3 = self.world.get_species(pair.rt.products[0])
+            if len(pair.rt.products) == 0:
+		# no product particles, nothing new to be made
+                product = []
 
-                # calculate new R
+	    elif len(pair.rt.products) == 1:
+                species3 = self.world.get_species(pair.rt.products[0])
+                # calculate new position
                 event_type = pair.event_type
                 new_com = pair.draw_new_com(pair.dt, event_type)
 
@@ -1161,16 +1164,18 @@ def fire_pair(self, pair):
 
                 new_com = self.world.apply_boundary(new_com)
 
+		# make product particle
                 particle = self.world.new_particle(species3.id, new_com)
+
+		# create a new domain for the new particle
                 product = self.create_single(particle)
+		# schedule domain
                 self.add_domain_event(product)
 
+		# update counters
                 self.reaction_events += 1
-
                 self.last_reaction = (pair.rt, (particle1, particle2),
                                       [particle])
-            elif len(pair.rt.products) == 0:
-                product = []
             else:
                 raise NotImplementedError('num products >= 2 not supported.')
 

From fe643c122e2037d73fb10fd9aab58cfa21dd2bef Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 23 Aug 2011 15:53:47 +0200
Subject: [PATCH 0135/1541] Multiple changes in one commit -> pretty bad
 -changed reactiontypes to reactionrules for consistency -added comments about
 what methods should be (re)moved or renamed to other classes -started with
 implementation of draw_new_position in InteractionSingle -some other minor
 changes

---
 single.py | 261 +++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 171 insertions(+), 90 deletions(-)

diff --git a/single.py b/single.py
index 5b50892c..47c73fb6 100644
--- a/single.py
+++ b/single.py
@@ -26,7 +26,7 @@ class Single(ProtectiveDomain):
     specified.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, reactiontypes, structure):
+    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
 	ProtectiveDomain.__init__(self, domain_id)
 
         self.multiplicity = 1				# all singles have only one particle
@@ -34,36 +34,50 @@ def __init__(self, domain_id, pid_particle_pair, reactiontypes, structure):
         self.pid_particle_pair = pid_particle_pair	# the particle in the single
         self.structure = structure			# the structure in/on which the particle lives
 
-        self.reactiontypes = reactiontypes
+        self.reactionrules = reactionrules		# the reaction rules for mono molecular reactions
+	self.reactionrule = None			# with this particle as the reactant
         self.k_tot = 0
-        self.updatek_tot()
+        self.updatek_tot()				# RENAME to calc_ktot and MOVE to ProtectiveDomain
 
     def getD(self):
         return self.pid_particle_pair[1].D
     D = property(getD)
 
     def getv(self):
+	# MOVE to CylindericalSurfaceSingle (no meaning anywhere else)
         return 0 # TODO, include drift.
         return self.pid_particle_pair[1].v
     v = property(getv)
 
 
-    # FIXME: This shouldn't be here, since the mobility_radius doens't mean anything
-    #        for interaction singles
+	# Note that this is the mobility RADIUS, for cylindrical domains with non-trivial
+	# length you need more information to characterize the insides of the shell
+	# RENAME to get_inner_a, for the parameter a of the 'inner shell', which demarkates
+	# the volume where the CoM of the particle can go.
     def get_mobility_radius(self):
-        return self.get_shell_size() - self.pid_particle_pair[1].radius
+        return self.shell.shape.radius - self.pid_particle_pair[1].radius
 
-    # FIXME: Same goes here
+	# FIXME: Same goes here
     def get_shell_size(self):
         return self.shell.shape.radius
 
     def draw_new_position(self, dt, event_type):
-	'''Draw a new position of the particle in the simulation coordinate system
-	given that an event of event_type has occured
+	'''Draw a new position of the particle in the coordinate system given that an
+	event of event_type has occured. No periodic boundary conditions are applied yet
+	to the coordinates, as the Domains do not understand this.
+
+	Note also that it calculates the positional information PRIOR to any identity or
+	structure change.
+
+	When for example a particles dissociates from the membrane (a structure change),
+	it is placed next to the membrane. 'draw_new_position' will only determine the
+	location in the membrane where it dissociates, not the position where the particle
+	should be placed.
 	'''
 	pass
 
     def initialize(self, t):
+	# MOVE to NonInteractionSingle, can't really initialize an InteractionSingle
         '''
         Reset the Single.
 
@@ -71,7 +85,7 @@ def initialize(self, t):
         particle.  self.dt is reset to 0.0.  Do not forget to reschedule 
         this Single after calling this method.
         '''
-	# TODO? shell size (radius) is not shrunken
+	# self.shell.shape.radius = self.pid_particle_pair[1].radius
         self.dt = 0.0
         self.last_time = t
         self.event_type = EventType.SINGLE_ESCAPE
@@ -80,6 +94,10 @@ def is_reset(self):
         return self.dt == 0.0 and self.event_type == EventType.SINGLE_ESCAPE
 
     def draw_reaction_time_tuple(self):
+	# MOVE to ProtectiveDomain class as this is actually a property of a single particle
+	# and not of a Single domain. It should be a method to a particle (or species)
+	# but that's too much hassle. Now make it a function (!) of Domain class for
+	# easy access. This mechanism is used everywhere a particle can decay.
         """Return a (reaction time, event type)-tuple for a unimolecular reaction.
 
         """
@@ -98,8 +116,8 @@ def draw_reaction_time_tuple(self):
     def draw_escape_time_tuple(self):
         """Return an (escape time, event type)-tuple.
 
-        In case of an interaction single, does not handle escapes in 
-        the interaction coordinate.
+        In case of an interaction single, handles only the escape in the
+	non-interacting coordinate.
         
         """
         if self.getD() == 0:
@@ -111,23 +129,26 @@ def draw_escape_time_tuple(self):
         return dt, event_type
 
     def updatek_tot(self):
+	# MOVE to ProtectiveDomain class. See also reasoning above for
+	# draw_reaction_time_tuple
         self.k_tot = 0
 
-        if not self.reactiontypes:
+        if not self.reactionrules:
             return
 
-        for rt in self.reactiontypes:
-            self.k_tot += rt.k
+        for rr in self.reactionrules:
+            self.k_tot += rr.k
 
     def draw_reaction_rule(self):
-        k_array = [rt.k for rt in self.reactiontypes]
+	# MOVE to ProtectiveDomain class
+        k_array = [rr.k for rr in self.reactionrules]
         k_array = numpy.add.accumulate(k_array)
         k_max = k_array[-1]
 
         rnd = myrandom.uniform()
         i = numpy.searchsorted(k_array, rnd * k_max)
 
-        return self.reactiontypes[i]
+        return self.reactionrules[i]
 
     def check(self):
         pass
@@ -150,10 +171,14 @@ class NonInteractionSingle(Single):
         * PlanarSurfaceSingle: cylindrical shell, 2D movement.
         * CylindricalSurfaceSingle: cylindrical shell, 1D movement.
 
+    NonInteractionSingle hold two independent processes:
+	* Diffusion of the particle in n (1-3) dimensions
+	* Decay process of the particle
+
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
+    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
                  structure):
-        Single.__init__(self, domain_id, pid_particle_pair, reactiontypes,
+        Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
                         structure)
 
         # Create shell.
@@ -170,30 +195,48 @@ def determine_next_event(self):
                    self.draw_reaction_time_tuple())
 
     def draw_new_position(self, dt, event_type):
-        if event_type == EventType.SINGLE_ESCAPE:
+	oldpos = self.pid_particle_pair[1].position
+
+	if self.D == 0:
+	    newpos = oldpos
+        elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+	    newpos = oldpos
+	else:
+	    # calculate r
+	    if event_type == EventType.SINGLE_ESCAPE:
             # Moving this checks to the Green's functions is not a good 
             # idea, because then you'd draw an unused random number.  
             # The same yields for the draw_new_com and draw_new_iv.  
-            r = self.get_mobility_radius()
-        else:
-            gf = self.greens_function()
-            r = draw_r_wrapper(gf, dt, self.get_mobility_radius())
 
-        displacement = self.create_position_vector(r)
+	    # TODO Either include check for non-zero drift here, or overload
+	    # this method in CylindricalSurfaceSingle to check exit interface
+        	r = self.get_mobility_radius()
+            else:
+        	gf = self.greens_function()
+        	r = draw_r_wrapper(gf, dt, self.get_mobility_radius())
+		# Note that in case of 1D diffusion r has a direction. It is
+		# the lateral displacement and can be positive or negative. 
+		# In other cases r is always positive and denotes
+		# radial displacement from the center.
 
-        # This should be checked in the unit test of random_vector.
-        # if __debug__:
-        #     scale = self.pid_particle_pair[1].radius
-        #     if feq(length(displacement), abs(r), typical=scale) == False:
-        #         raise AssertionError('displacement != abs(r): %g != %g.' % 
-        #                              (length(displacement), abs(r)))
+	    # calculate other coordinates
+            displacement = self.create_position_vector(r)
 
-        # Add displacement to shape.position, not to particle.position.  
-        # This distinction is important only in the case of an 
-        # asymmetric 1D domain (r0 != 0, or drift), since draw_r always 
-        # returns a position relative to the centre of the shell (r=0), 
-        # not relative to r0.
-        return self.shell.shape.position + displacement
+            # This should be checked in the unit test of random_vector.
+            # if __debug__:
+            #     scale = self.pid_particle_pair[1].radius
+            #     if feq(length(displacement), abs(r), typical=scale) == False:
+            #         raise AssertionError('displacement != abs(r): %g != %g.' % 
+            #                              (length(displacement), abs(r)))
+
+            # Add displacement to shell.shape.position, not to particle.position.  
+            # This distinction is important only in the case of an 
+            # asymmetric 1D domain (r0 != 0, or drift), since draw_r always 
+            # returns a distance relative to the centre of the shell (r=0), 
+            # not relative to r0.
+	    newpos = self.shell.shape.position + displacement
+
+        return newpos
 
 
 class SphericalSingle(NonInteractionSingle):
@@ -206,17 +249,17 @@ class SphericalSingle(NonInteractionSingle):
           theta, phi.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
+    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
                  structure):
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactiontypes, structure)
+                                      shell_id, reactionrules, structure)
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
                                           self.get_mobility_radius())
 
     def create_new_shell(self, position, radius, domain_id):
-        return SphericalShell(domain_id, Sphere(position, radius))
+        return SphericalShell(self.domain_id, Sphere(position, radius))
 
     def create_position_vector(self, r):
         return random_vector(r)
@@ -235,10 +278,10 @@ class PlanarSurfaceSingle(NonInteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
+    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
                  structure):
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactiontypes, structure)
+                                      shell_id, reactionrules, structure)
 
     def greens_function(self):
         return GreensFunction2DAbsSym(self.getD(),
@@ -254,7 +297,7 @@ def create_new_shell(self, position, radius, domain_id):
             utils.crossproduct(self.structure.shape.unit_x,
                                self.structure.shape.unit_y))
         half_length = self.pid_particle_pair[1].radius
-        return CylindricalShell(domain_id, Cylinder(position, radius, 
+        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
     def create_position_vector(self, r):
@@ -274,10 +317,10 @@ class CylindricalSurfaceSingle(NonInteractionSingle):
         * Initial position: z = 0.
         * Selected randomly when drawing displacement vector: none.
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes, 
+    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
                  structure):
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactiontypes, structure)
+                                      shell_id, reactionrules, structure)
 
     def greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
@@ -290,12 +333,13 @@ def create_new_shell(self, position, half_length, domain_id):
         # and the move may be rejected (NoSpace error).
         radius = self.pid_particle_pair[1].radius
         orientation = self.structure.shape.unit_z
-        return CylindricalShell(domain_id, Cylinder(position, radius, 
+        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
     def create_position_vector(self, z):
         if utils.feq(z, self.get_mobility_radius()):
             # Escape, can be either to the left or to the right.
+	    # FIXME This is wrong in case of drift
             z = myrandom.choice(-1, 1) * z 
         return z * self.shell.shape.unit_z
 
@@ -316,41 +360,50 @@ class InteractionSingle(Single):
         * PlanarSurfaceInteraction.
         * CylindricalSurfaceInteraction.
 
+    The InteractionSingle holds three independent processes:
+	* Diffusion in the direction that allows the interaction (radial or z)
+	* Diffusion in the direction that is normal the the direction of interaction
+	* Decay of the particle into a different or no particle
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, shell,  
-                 reactiontypes, interaction_type, surface, structure):
+                 reactionrules, interactionrules, surface, structure):
 
-        Single.__init__(self, domain_id, pid_particle_pair, reactiontypes,
+        Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
                         structure)
 
-        self.interaction_type = interaction_type
+        self.interactionrules = interactionrules
         self.shell_id = shell_id
+	self.shell = self.create_new_shell (self, )	# TODO: maybe this shouldn't be here but in the subclasses
 
 	self.surface = surface			# The surface with which the particle is trying to interact
 
+	# REMOVE: this doens't make any sence here, only for NonInteractingSingles.
     def initialize(self, t):			# does this method make any sence??
 	self.dt = 0
 	self.event_type = None
 	self.last_time = t
 
-    def create_new_shell(self, position, radius, length, domain_id):
+    def create_new_shell(self, position, radius, half_length):
 #        orientation = self.orientation
 #        half_length = self.half_length
 #	return CylindricalShell(domain_id, Cylinder(position, radius,
 #                                                    orientation, half_length))
 
+	# TODO: Does not both shapes have a unit_z that is appropriate for the
+	# orientation?
 	orientation = crossproduct(self.surface.shape.unit_x,
                                    self.surface.shape.unit_y)
-        return CylindricalShell(domain_id, Cylinder(position, radius,
-                                                    orientation, length*0.5))
+        return CylindricalShell(self.domain_id, Cylinder(position, radius,
+                                                    orientation, half_length))
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
         """
         return min(self.draw_escape_time_tuple(),
-                   self.draw_iv_event_time_tuple(),
-                   self.draw_reaction_time_tuple())
+                   self.draw_reaction_time_tuple(),
+                   self.draw_iv_event_time_tuple())	# above two events also occur in NonInteractingSingle
+							# IV event is added in InteractionSingle
 
     def draw_iv_event_time_tuple(self):
         """Return an (interaction/escape time, event type)-tuple.
@@ -386,18 +439,18 @@ class PlanarSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, reactiontypes,
+    def __init__(self, domain_id, pid_particle_pair, reactionrules,
                  interaction_type, surface, shell_id, shell_center, shell_radius,
 		 shell_length, orientation_vector):
 
 ###TODO	One of the two constructors for InteractionSingle should be right. The one below doesn't seem so
 #        InteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-#                                   shell_id, reactiontypes, surface, 
+#                                   shell_id, reactionrules, surface, 
 #                                   interaction_type, origin, orientation,
 #                                   half_length, particle_offset,
 #                                   projected_point, size_of_domain)
 	InteractionSingle.__init__(self, domain_id, pid_particle_pair, structure, shell_id, shell,
-                 reactiontypes, interaction_type, surface, structure)
+                 reactionrules, interaction_type, surface, structure)
 
 	self.shell = self.create_new_shell(self, position, radius, length)
 
@@ -429,26 +482,18 @@ def __init__(self, domain_id, pid_particle_pair, reactiontypes,
             # (min_radius correction in the constructor).
             particle_offset = [0, particle_distance - length_of_domain.Lz]
 
-    def norm_greens_function(self):
+    def greens_function(self):
         # This is the Greens function that does not produce REACTION event
         #return GreensFunction3DAbsSYm(self.getD(), get_mobility_radius())
-        return GreensFunction2DRadSym(self.getD(), 
-                                          self.get_mobility_radius())
+        return GreensFunction2DAbsSym(self.getD(), self.get_mobility_radius())
 
-    def int_greens_function(self):
+    def iv_greens_function(self):
 	# The green's function that also modelles the association of the particle
 	# with the planar surface.
         # Todo. 1D gf Rad Abs should be sigma to a.
-        return GreensFunction1DRadAbs(self.getD, self.rt.k, self.r0, self.sigma, self.a)
-
-#        return GreensFunction(self.getD(),
-#                                              self.interaction_type.k, self.r0,
-#                                              self.sigma, self.sigma)
-#        gf.seta(a)
-#        return gf
+        return GreensFunction1DRadAbs(self.getD, self.interactionrule.k, self.r0, self.sigma, self.a)
 
         # TODO.
-
         # Cartesian domain of half_length L. Correction with getMinRadius().
         #zDomain = CartesianDomain(particle_offset[1] - self.getMinRadius(), 
         #                           size_of_domain - 2 * self.getMinRadius(), 
@@ -456,25 +501,51 @@ def int_greens_function(self):
 
 
 
-    def draw_new_position(self, dt, eventType):
-        gf_r = self.greens_function_r()
-        a = self.get_mobility_radius()
-        r = draw_displacement_wrapper(gf_r, dt, eventType, a)
-        x, y = randomVector2D(r)
-
-        # Todo. Cartesian coordinate will return absolute position.
-        gf_z = self.greens_function_z()
-        # Heads up. size_of_domain is different from the half_length of 
-        # the cylinder, because the domain ends where the surface 
-        # starts, while the cylinder is continuing into the surface.
-        a = 1 #TODO 
-        r0 = self.particle_offset
-        sigma = self.sigma
-        z = draw_displacement_wrapper(gf_z, dt, eventType, a, r0, sigma)
+    def draw_new_position(self, dt, event_type):
+	"""Draws a new position for the particle for a given event type at a given time
+	Note that it also 'moves the particle into the surface' when an interaction
+	takes place.
+	"""
+	oldpos = self.pid_particle_pair[1].position
+	if self.D == 0:
+	    newpos = oldpos
+	elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+	    newpos = oldpos		# just return oldpos, particle will be removed anyway
+	else:
+	    # calculate r vector
+            a = self.get_mobility_radius()
+	    if event_type == EventType.SINGLE_ESCAPE:
+		r = a
+	    else:
+		gf = self.greens_function()
+        	r = draw_r_wrapper(gf, dt, event_type, a)
+
+	    x, y = randomVector2D(r)
+	    vector_r = x * self.surface.unitX + y * self.surface.unitY
+
+	    # calculate z vector
+            # Todo. Cartesian coordinate will return absolute position.
+            # Heads up. size_of_domain is different from the half_length of 
+            # the cylinder, because the domain ends where the surface 
+            # starts, while the cylinder is continuing into the surface.
+            sigma = self.sigma	# left side of the domain
+	    a = self.shell.shape.half_length*2 - self.sigma # FIXME ??????
+	    if event_type == EventType.IV_INTERACTION:
+		z = sigma
+	    elif event_type == EventType.IV_ESCAPE:
+		z = a
+	    else:
+	        gf_iv = self.iv_greens_function()
+        	r0 = self.particle_offset			# TODO
+        	z = draw_displacement_wrapper(gf_z, dt, eventType, a, r0, sigma)
+
+	    vector_z = z * self.shell.unitZ
+
+            # Add displacement vector to self.particle.pos, not self.pos.
+	    newpos = oldpos + vector_r + vector_z
+
+        return newpos
 
-        # Add displacement vector to self.particle.pos, not self.pos.
-        return self.particle.pos + x * self.interactionSurface.unitX + \
-               y * self.interactionSurface.unitY + z * self.shellList[0].unitZ
 
     def __str__(self):
         return 'PlanarSurfaceInteraction' + Single.__str__(self)
@@ -490,7 +561,7 @@ class CylindricalSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: none.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
+    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
                  interaction_type, surface, projected_point, particle_distance,
                  orientation_vector, dr, dz_left, dz_right):
 
@@ -505,7 +576,7 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactiontypes,
                                       dr, dz_left, dz_right)
 
         InteractionSingle.__init__(self, domain_id, pid_particle_pair,
-                                   shell_id, shell, reactiontypes,
+                                   shell_id, shell, reactionrules,
                                    interaction_type, surface)
 
     def create_new_shell(self, domain_id, projected_point, particle_distance,
@@ -524,6 +595,7 @@ def create_new_shell(self, domain_id, projected_point, particle_distance,
                                                     half_length))
 
     def greens_function(self):
+	# The greens function not used for the interaction
         z0 = self.dz_left - self.shell.shape.half_length
 
         # Free diffusion in z direction.
@@ -532,8 +604,9 @@ def greens_function(self):
                                       self.get_mobility_radius())
 
     def iv_greens_function(self):
+	# Green's function used for the interaction
         # Interaction possible in r direction.
-        # Todo.
+        # TODO.
         #k = self.interaction_type.k
         k = 0
         r0 = self.particle_distance
@@ -543,6 +616,13 @@ def iv_greens_function(self):
         return GreensFunction3DRadAbs(self.getD(), k, r0, sigma, a_r)
 
     def draw_new_position(self, dt, event_type):
+	oldpos = self.pid_particle_pair[1].position
+
+	if self.D == 0:
+	    return oldpos
+	elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 2:
+	    return oldpos
+
         # 1) Draw z.
         if event_type == EventType.SINGLE_ESCAPE:
             # Moving this checks to the Green's functions is not a good 
@@ -576,6 +656,7 @@ def draw_new_position(self, dt, event_type):
         return self.shell.shape.position + z_vector + r_vector
 
     def get_shell_size(self):
+	# REMOVE this method, it doesn't mean anything here.
         # Heads up. The cylinder's *half_length*, not radius, 
         # determines the size in case of a cylindrical surface.
         return self.shell.shape.half_length

From 0f953abb1fbe6818fca37e081d63ff21a5263577 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 23 Aug 2011 16:04:15 +0200
Subject: [PATCH 0136/1541] drift now only possible for particles on the
 cylinder, was to general before

---
 pair.py   | 28 ++++++++++++++--------------
 single.py | 15 +++++++--------
 2 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/pair.py b/pair.py
index cd46d34e..99fca993 100644
--- a/pair.py
+++ b/pair.py
@@ -66,20 +66,6 @@ def get_D_R(self):
                 self.pid_particle_pair2[1].D) / self.D_tot
     D_R = property(get_D_R)
 
-    def get_v_tot(self):
-        return self.pid_particle_pair2[1].v - \
-               self.pid_particle_pair1[1].v
-    v_tot = property(get_v_tot)
-    
-    v_r = property(get_v_tot)
-
-    def get_v_R(self):
-        return (self.pid_particle_pair1[1].v * 
-                self.pid_particle_pair2[1].D +
-                self.pid_particle_pair2[1].v *
-                self.pid_particle_pair1[1].D) / self.D_tot
-    v_R = property(get_v_R)
-
     def getSigma(self):
         return self.pid_particle_pair1[1].radius + \
                self.pid_particle_pair2[1].radius
@@ -480,6 +466,20 @@ def __init__(self, domain_id, com, single1, single2, shell_id,
         Pair.__init__(self, domain_id, com, single1, single2, shell_id,
                       r0, shell_size, rt, structure)
 
+    def get_v_tot(self):
+        return self.pid_particle_pair2[1].v - \
+               self.pid_particle_pair1[1].v
+    v_tot = property(get_v_tot)
+    
+    v_r = property(get_v_tot)
+
+    def get_v_R(self):
+        return (self.pid_particle_pair1[1].v * 
+                self.pid_particle_pair2[1].D +
+                self.pid_particle_pair2[1].v *
+                self.pid_particle_pair1[1].D) / self.D_tot
+    v_R = property(get_v_R)
+
     def com_greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
         return GreensFunction1DAbsAbs(self.D_R, self.v_R, 0.0, -self.a_R, self.a_R)
diff --git a/single.py b/single.py
index 47c73fb6..e55613df 100644
--- a/single.py
+++ b/single.py
@@ -43,12 +43,6 @@ def getD(self):
         return self.pid_particle_pair[1].D
     D = property(getD)
 
-    def getv(self):
-	# MOVE to CylindericalSurfaceSingle (no meaning anywhere else)
-        return 0 # TODO, include drift.
-        return self.pid_particle_pair[1].v
-    v = property(getv)
-
 
 	# Note that this is the mobility RADIUS, for cylindrical domains with non-trivial
 	# length you need more information to characterize the insides of the shell
@@ -322,6 +316,11 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
                                       shell_id, reactionrules, structure)
 
+    def getv(self):
+        return 0 # TODO, include drift.
+        return self.pid_particle_pair[1].v
+    v = property(getv)
+
     def greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
         return GreensFunction1DAbsAbs(self.getD(), self.getv(), 0.0, -self.get_mobility_radius(), self.get_mobility_radius())
@@ -598,8 +597,8 @@ def greens_function(self):
 	# The greens function not used for the interaction
         z0 = self.dz_left - self.shell.shape.half_length
 
-        # Free diffusion in z direction.
-        return GreensFunction1DAbsAbs(self.getD(), self.getv(), z0,
+        # Free diffusion in z direction, drift is zero by default.
+        return GreensFunction1DAbsAbs(self.getD(), 0, z0,
                                       -self.get_mobility_radius(),
                                       self.get_mobility_radius())
 

From 4fe86669a7685800e402231aa1a2a5afa0cdeec7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 23 Aug 2011 16:54:18 +0200
Subject: [PATCH 0137/1541] partially resolved the mobility_radius issue
 Mobility radius is now inner_a, the the larger radius of the cylindrical,
 spherical or linear space that the CoM of a particle can occupy.

---
 single.py | 55 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 28 insertions(+), 27 deletions(-)

diff --git a/single.py b/single.py
index e55613df..42550cb3 100644
--- a/single.py
+++ b/single.py
@@ -44,17 +44,13 @@ def getD(self):
     D = property(getD)
 
 
-	# Note that this is the mobility RADIUS, for cylindrical domains with non-trivial
-	# length you need more information to characterize the insides of the shell
-	# RENAME to get_inner_a, for the parameter a of the 'inner shell', which demarkates
-	# the volume where the CoM of the particle can go.
-    def get_mobility_radius(self):
+    def get_inner_a(self):
+	# inner_a is the outer radius of the 'inner shell', which demarkates
+	# the space where the CoM of the particle can go. The space can be
+	# one, two or three dimensional and can be linear, round, spherical or
+	# cylindric in form.
         return self.shell.shape.radius - self.pid_particle_pair[1].radius
 
-	# FIXME: Same goes here
-    def get_shell_size(self):
-        return self.shell.shape.radius
-
     def draw_new_position(self, dt, event_type):
 	'''Draw a new position of the particle in the coordinate system given that an
 	event of event_type has occured. No periodic boundary conditions are applied yet
@@ -180,6 +176,11 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
         self.shell = self.create_new_shell(pid_particle_pair[1].position,
                                       pid_particle_pair[1].radius, domain_id)
 
+    def get_shell_size(self):
+	# Note: this method only means something for Protective Domains that can
+	# only be sized in one direction
+        return self.shell.shape.radius
+
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -204,10 +205,10 @@ def draw_new_position(self, dt, event_type):
 
 	    # TODO Either include check for non-zero drift here, or overload
 	    # this method in CylindricalSurfaceSingle to check exit interface
-        	r = self.get_mobility_radius()
+        	r = self.get_inner_a()
             else:
         	gf = self.greens_function()
-        	r = draw_r_wrapper(gf, dt, self.get_mobility_radius())
+        	r = draw_r_wrapper(gf, dt, self.get_inner_a())
 		# Note that in case of 1D diffusion r has a direction. It is
 		# the lateral displacement and can be positive or negative. 
 		# In other cases r is always positive and denotes
@@ -250,7 +251,7 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
-                                          self.get_mobility_radius())
+                                          self.get_inner_a())
 
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(self.domain_id, Sphere(position, radius))
@@ -279,7 +280,7 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
 
     def greens_function(self):
         return GreensFunction2DAbsSym(self.getD(),
-                                          self.get_mobility_radius())
+                                          self.get_inner_a())
 
     def create_new_shell(self, position, radius, domain_id):
         # The half_length (thickness) of a hockey puck is not more than 
@@ -323,7 +324,7 @@ def getv(self):
 
     def greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
-        return GreensFunction1DAbsAbs(self.getD(), self.getv(), 0.0, -self.get_mobility_radius(), self.get_mobility_radius())
+        return GreensFunction1DAbsAbs(self.getD(), self.getv(), 0.0, -self.get_inner_a(), self.get_inner_a())
 
     def create_new_shell(self, position, half_length, domain_id):
         # The radius of a rod is not more than it has to be (namely the 
@@ -336,7 +337,7 @@ def create_new_shell(self, position, half_length, domain_id):
                                                     orientation, half_length))
 
     def create_position_vector(self, z):
-        if utils.feq(z, self.get_mobility_radius()):
+        if utils.feq(z, self.get_inner_a()):
             # Escape, can be either to the left or to the right.
 	    # FIXME This is wrong in case of drift
             z = myrandom.choice(-1, 1) * z 
@@ -483,8 +484,8 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules,
 
     def greens_function(self):
         # This is the Greens function that does not produce REACTION event
-        #return GreensFunction3DAbsSYm(self.getD(), get_mobility_radius())
-        return GreensFunction2DAbsSym(self.getD(), self.get_mobility_radius())
+        #return GreensFunction3DAbsSYm(self.getD(), get_inner_a())
+        return GreensFunction2DAbsSym(self.getD(), self.get_inner_a())
 
     def iv_greens_function(self):
 	# The green's function that also modelles the association of the particle
@@ -512,7 +513,7 @@ def draw_new_position(self, dt, event_type):
 	    newpos = oldpos		# just return oldpos, particle will be removed anyway
 	else:
 	    # calculate r vector
-            a = self.get_mobility_radius()
+            a = self.get_inner_a()
 	    if event_type == EventType.SINGLE_ESCAPE:
 		r = a
 	    else:
@@ -599,8 +600,8 @@ def greens_function(self):
 
         # Free diffusion in z direction, drift is zero by default.
         return GreensFunction1DAbsAbs(self.getD(), 0, z0,
-                                      -self.get_mobility_radius(),
-                                      self.get_mobility_radius())
+                                      -self.get_inner_a(),
+                                      self.get_inner_a())
 
     def iv_greens_function(self):
 	# Green's function used for the interaction
@@ -627,10 +628,10 @@ def draw_new_position(self, dt, event_type):
             # Moving this checks to the Green's functions is not a good 
             # idea, because then you'd draw an unused random number.  
             # The same yields for the draw_new_com and draw_new_iv.  
-            z = self.get_mobility_radius()
+            z = self.get_inner_a()
         else:
             gf = self.greens_function()
-            z = draw_r_wrapper(gf, dt, self.get_mobility_radius())
+            z = draw_r_wrapper(gf, dt, self.get_inner_a())
 
         # Orientation matters, so use shell.shape.unit_z instead of 
         # structure.shape.unit_z.
@@ -654,11 +655,11 @@ def draw_new_position(self, dt, event_type):
         # Add displacement to shape.position, not to particle.position.  
         return self.shell.shape.position + z_vector + r_vector
 
-    def get_shell_size(self):
-	# REMOVE this method, it doesn't mean anything here.
-        # Heads up. The cylinder's *half_length*, not radius, 
-        # determines the size in case of a cylindrical surface.
-        return self.shell.shape.half_length
+#    def get_shell_size(self):
+#	# REMOVE this method, it doesn't mean anything here.
+#        # Heads up. The cylinder's *half_length*, not radius, 
+#        # determines the size in case of a cylindrical surface.
+#        return self.shell.shape.half_length
 
     def __str__(self):
         return 'CylindricalSurfaceInteraction' + Single.__str__(self)

From ec41bb9180498fa80aa61cb6ede88dea3e546819 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 23 Aug 2011 17:37:51 +0200
Subject: [PATCH 0138/1541] changed the comment (interpretation) of the
 initialize method

---
 domain.py | 10 ++++++++++
 pair.py   |  1 +
 single.py | 27 ++++++++++-----------------
 3 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/domain.py b/domain.py
index 477d9411..43fd380a 100644
--- a/domain.py
+++ b/domain.py
@@ -14,6 +14,16 @@ def __init__(self, domain_id):
 	self.dt = 0.0
 
     def initialize(self, time):		# this method needs to be overloaded in all subclasses
+        '''
+        Sets the local time variables for the Domain (usually to the current simulation time).
+        Do not forget to reschedule this Domain after calling this method.
+
+        For the NonInteractingSingle, the radius (shell size) should be shrunken to the actual
+        radius of the particle.
+
+        initialize allows you to reuse the same Domain (of the same class with the same particles)
+	at a different time.
+        '''
 	pass
 
 
diff --git a/pair.py b/pair.py
index 99fca993..dcbff700 100644
--- a/pair.py
+++ b/pair.py
@@ -72,6 +72,7 @@ def getSigma(self):
     sigma = property(getSigma)
 
     def initialize(self, t):
+	# re-initialize the time parameters of the Domain to reuse it.
         self.last_time = t
         self.dt = 0
         self.event_type = None
diff --git a/single.py b/single.py
index 42550cb3..3a9eb963 100644
--- a/single.py
+++ b/single.py
@@ -66,20 +66,6 @@ def draw_new_position(self, dt, event_type):
 	'''
 	pass
 
-    def initialize(self, t):
-	# MOVE to NonInteractionSingle, can't really initialize an InteractionSingle
-        '''
-        Reset the Single.
-
-        Radius (shell size) is shrunken to the actual radius of the 
-        particle.  self.dt is reset to 0.0.  Do not forget to reschedule 
-        this Single after calling this method.
-        '''
-	# self.shell.shape.radius = self.pid_particle_pair[1].radius
-        self.dt = 0.0
-        self.last_time = t
-        self.event_type = EventType.SINGLE_ESCAPE
-
     def is_reset(self):
         return self.dt == 0.0 and self.event_type == EventType.SINGLE_ESCAPE
 
@@ -181,6 +167,12 @@ def get_shell_size(self):
 	# only be sized in one direction
         return self.shell.shape.radius
 
+    def initialize(self, t):
+	# self.shell.shape.radius = self.pid_particle_pair[1].radius
+        self.dt = 0.0
+        self.last_time = t
+        self.event_type = EventType.SINGLE_ESCAPE
+
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -377,11 +369,12 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, shell,
 
 	self.surface = surface			# The surface with which the particle is trying to interact
 
-	# REMOVE: this doens't make any sence here, only for NonInteractingSingles.
-    def initialize(self, t):			# does this method make any sence??
+    def initialize(self, t):	
+	# initialize the domain object with the appropriate time to allow reuse of
+	# the Domain at different times
 	self.dt = 0
-	self.event_type = None
 	self.last_time = t
+	self.event_type = None
 
     def create_new_shell(self, position, radius, half_length):
 #        orientation = self.orientation

From f3a8492eb02f48ecb7007bc2874da76b00dcf031 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 24 Aug 2011 11:44:16 +0200
Subject: [PATCH 0139/1541] small changes to NonInteractionSingles, still
 doens't include drift

---
 single.py | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/single.py b/single.py
index 3a9eb963..c4d1a3ab 100644
--- a/single.py
+++ b/single.py
@@ -101,7 +101,7 @@ def draw_escape_time_tuple(self):
         else:
             dt = draw_time_wrapper(self.greens_function())
 
-        event_type = EventType.SINGLE_ESCAPE
+        event_type = EventType.SINGLE_ESCAPE	# TODO Event is not an ESCAPE when in 1D there is drift
         return dt, event_type
 
     def updatek_tot(self):
@@ -271,7 +271,7 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
                                       shell_id, reactionrules, structure)
 
     def greens_function(self):
-        return GreensFunction2DAbsSym(self.getD(),
+        return GreensFunction2DAbsSym(self.D,
                                           self.get_inner_a())
 
     def create_new_shell(self, position, radius, domain_id):
@@ -314,9 +314,21 @@ def getv(self):
         return self.pid_particle_pair[1].v
     v = property(getv)
 
+    def get_shell_size(self):
+        # Heads up. The cylinder's *half_length*, not radius, 
+        # determines the size in case of a cylindrical surface.
+        return self.shell.shape.half_length
+
+    def get_inner_a(self):
+	# Here the free coordinate is not the radius of the domain as in the
+	# PlanarSurfaceSingle and SphericalSingle, although it is treated as a
+	# radius in NonInteractionSingle.draw_new_position for simplicity
+	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+
     def greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
-        return GreensFunction1DAbsAbs(self.getD(), self.getv(), 0.0, -self.get_inner_a(), self.get_inner_a())
+	inner_half_length = self.get_inner_a()
+        return GreensFunction1DAbsAbs(self.D, self.v, 0.0, -inner_half_length, inner_half_length)
 
     def create_new_shell(self, position, half_length, domain_id):
         # The radius of a rod is not more than it has to be (namely the 
@@ -326,20 +338,16 @@ def create_new_shell(self, position, half_length, domain_id):
         radius = self.pid_particle_pair[1].radius
         orientation = self.structure.shape.unit_z
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 
-                                                    orientation, half_length))
 
     def create_position_vector(self, z):
         if utils.feq(z, self.get_inner_a()):
             # Escape, can be either to the left or to the right.
-	    # FIXME This is wrong in case of drift
+	    # The side of escape should be decided on by the flux through
+	    # both boundaries at the escape time
+	    # TODO, include drift
             z = myrandom.choice(-1, 1) * z 
         return z * self.shell.shape.unit_z
 
-    def get_shell_size(self):
-        # Heads up. The cylinder's *half_length*, not radius, 
-        # determines the size in case of a cylindrical surface.
-        return self.shell.shape.half_length
-
     def __str__(self):
         return 'CylindricalSurface' + Single.__str__(self)
 

From 02966dcea4177c7913f362d8c17fd39c8425215c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 24 Aug 2011 16:06:59 +0200
Subject: [PATCH 0140/1541] simplified PlanarSurfaceInteraction, should be
 mostly done now

---
 egfrd.py  |  19 +++--
 single.py | 244 ++++++++++++++++++++++++++++++------------------------
 2 files changed, 147 insertions(+), 116 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 22e60376..feeec4dd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -58,25 +58,28 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure)
 
 
 def create_default_interaction(domain_id, pid_particle_pair, shell_id,
-                               reaction_types, interaction_type, surface,
+                               reaction_rules, interaction_rules, surface,
                                projected_point, particle_distance, 
                                orientation_vector, dr, dz_left, dz_right):
     # surface is the surface with which the interaction is made
 
     if isinstance(surface, CylindricalSurface):
         return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
-                                             shell_id, reaction_types,
-                                             interaction_type, surface, 
+                                             shell_id, reaction_rules,
+                                             interaction_rules, surface, 
                                              projected_point, particle_distance,
                                              orientation_vector,
                                              dr, dz_left, dz_right)
     elif isinstance(surface, PlanarSurface):
         return PlanarSurfaceInteraction(domain_id, pid_particle_pair,
-                                        shell_id, reaction_types,
-                                        interaction_type, surface,
-                                        projected_point, particle_distance, 
-                                        orientation_vector,
-                                        dr, dz_left, dz_right)
+                                        reaction_rules, structure,
+					shell_id, shell_center, shell_radius,
+					shell_half_length, orientation_vector,
+					z0, interaction_rules, surface)
+#                                        interaction_type, surface,
+#                                        projected_point, particle_distance, 
+#                                        orientation_vector,
+#                                        dr, dz_left, dz_right)
 
 
 def create_default_pair(domain_id, com, single1, single2, shell_id, 
diff --git a/single.py b/single.py
index c4d1a3ab..cde88a9f 100644
--- a/single.py
+++ b/single.py
@@ -338,6 +338,7 @@ def create_new_shell(self, position, half_length, domain_id):
         radius = self.pid_particle_pair[1].radius
         orientation = self.structure.shape.unit_z
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 
+                                                    orientation, half_length))
 
     def create_position_vector(self, z):
         if utils.feq(z, self.get_inner_a()):
@@ -365,17 +366,23 @@ class InteractionSingle(Single):
 	* Diffusion in the direction that is normal the the direction of interaction
 	* Decay of the particle into a different or no particle
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, shell,  
-                 reactionrules, interactionrules, surface, structure):
+    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell_id,   
+                 interactionrules, surface):
 
         Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
                         structure)
 
-        self.interactionrules = interactionrules
-        self.shell_id = shell_id
-	self.shell = self.create_new_shell (self, )	# TODO: maybe this shouldn't be here but in the subclasses
+	self.shell_id = shell_id
+        self.interactionrules = interactionrules	# the surface interaction 'reactions'
+	self.surface = surface				# The surface with which the particle is
+							# trying to interact
 
-	self.surface = surface			# The surface with which the particle is trying to interact
+	# There are defined here but are overloaded later
+    def get_inner_dz_lefti(self):
+	pass
+
+    def get_inner_dz_right(self):
+	pass
 
     def initialize(self, t):	
 	# initialize the domain object with the appropriate time to allow reuse of
@@ -384,18 +391,10 @@ def initialize(self, t):
 	self.last_time = t
 	self.event_type = None
 
-    def create_new_shell(self, position, radius, half_length):
-#        orientation = self.orientation
-#        half_length = self.half_length
-#	return CylindricalShell(domain_id, Cylinder(position, radius,
-#                                                    orientation, half_length))
-
-	# TODO: Does not both shapes have a unit_z that is appropriate for the
-	# orientation?
-	orientation = crossproduct(self.surface.shape.unit_x,
-                                   self.surface.shape.unit_y)
+	# This is defined here, but only used in the subclasses
+    def create_new_shell(self, position, radius, orientation_vector, half_length):
         return CylindricalShell(self.domain_id, Cylinder(position, radius,
-                                                    orientation, half_length))
+                                                    orientation_vector, half_length))
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -423,8 +422,8 @@ def draw_iv_event_time_tuple(self):
     def draw_iv_event_type(self):
         gf = self.iv_greens_function()
         event_kind = draw_event_type_wrapper(gf, self.dt)
-        if event_kind == PairEventKind.IV_REACTION:
-            return EventType.IV_REACTION
+        if event_kind == PairEventKind.IV_REACTION:	# Note REACTION -> INTERACTION
+            return EventType.IV_INTERACTION
         elif event_kind == PairEventKind.IV_ESCAPE:
             return EventType.IV_ESCAPE
         raise NotImplemented()
@@ -432,75 +431,86 @@ def draw_iv_event_type(self):
 
 class PlanarSurfaceInteraction(InteractionSingle):
     """1 Particle close to a PlanarSurface, inside a cylindrical shell 
-    placed on top of the surface.
+    placed against the surface with its flat face.
 
         * Particle coordinates inside shell: r, theta, z.
         * Coordinates: radial r, cartesian z.
-        * Initial position: r = 0, z = z.
+        * Initial position: r = 0, z = z0 (relative to center shell).
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, reactionrules,
-                 interaction_type, surface, shell_id, shell_center, shell_radius,
-		 shell_length, orientation_vector):
-
-###TODO	One of the two constructors for InteractionSingle should be right. The one below doesn't seem so
-#        InteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-#                                   shell_id, reactionrules, surface, 
-#                                   interaction_type, origin, orientation,
-#                                   half_length, particle_offset,
-#                                   projected_point, size_of_domain)
-	InteractionSingle.__init__(self, domain_id, pid_particle_pair, structure, shell_id, shell,
-                 reactionrules, interaction_type, surface, structure)
-
-	self.shell = self.create_new_shell(self, position, radius, length)
-
-        # Compute from dr, dz_left and dz_right the length of the new 
-        # domain (only that part of the cylinder where the particle can 
-        # diffuse to) and the radius and half_length of the new 
-        # cylinder.
-
-        # a
-        # what is here sigma?
-        sigma = self.surface.shape.Lz + self.pid_particle_pair[1].radius
-        # r0
-        if isinstance(surface, PlanarSurface):
-            # Heads up: length of domain (the part of the cylinder 
-            # where the particle can get) is a bit different from the 
-            # length of the cylinder because of dz_left.
-            # Assume surface.Lz == 0
-            length_of_domain = particle_distance + dz_right
-            radius = dr
-            half_length = (particle_distance + dz_left + dz_right) / 2
-
-        # TODO. This is not correct anymore.
-        if isinstance(surface, PlanarSurface):
-            # Compute new particle offset relative to origin of the 
-            # domain in the z-direction (z=0).
-            # The surface boundary is at z=-length_of_domain / 2, the 
-            # other end in the middles*at* the surface boundary. (z=L) 
-            # is at the end of the cylinder.
-            # (min_radius correction in the constructor).
-            particle_offset = [0, particle_distance - length_of_domain.Lz]
+    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
+                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
+		 interactionrules, surface):
+	# shell_orientation_vector and z0 are supplied by arguments because Domains can't do
+	# spatial calculations (they don't know about the world)
+	# NOTE shell_orientation_vector should be normalized and pointing from the surface to the particle!
+
+	InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
+				   structure, shell_id, interactionrules, surface)
+
+	# z0 is the initial position of the particle relative to the center
+	# of the shell in the direction normal to the surface.
+	self.z0 = z0
+	self.shell = self.create_new_shell(self, shell_center, shell_radius, 
+					   shell_orientation_vector, shell_half_length)
+
+
+
+#        # Compute from dr, dz_left and dz_right the length of the new 
+#        # domain (only that part of the cylinder where the particle can 
+#        # diffuse to) and the radius and half_length of the new 
+#        # cylinder.
+#
+#        # a
+#        # what is here sigma?
+#        sigma = self.surface.shape.Lz + self.pid_particle_pair[1].radius
+#        # r0
+#        if isinstance(surface, PlanarSurface):
+#            # Heads up: length of domain (the part of the cylinder 
+#            # where the particle can get) is a bit different from the 
+#            # length of the cylinder because of dz_left.
+#            # Assume surface.Lz == 0
+#            length_of_domain = particle_distance + dz_right
+#            radius = dr
+#            half_length = (particle_distance + dz_left + dz_right) / 2
+#
+#        # TODO. This is not correct anymore.
+#        if isinstance(surface, PlanarSurface):
+#            # Compute new particle offset relative to origin of the 
+#            # domain in the z-direction (z=0).
+#            # The surface boundary is at z=-length_of_domain / 2, the 
+#            # other end in the middles*at* the surface boundary. (z=L) 
+#            # is at the end of the cylinder.
+#            # (min_radius correction in the constructor).
+#            particle_offset = [0, particle_distance - length_of_domain.Lz]
+
+
+
+    def get_inner_dz_right(self):
+	# This is the distance the particle can travel from its initial position
+	# to the flat boundary away from the surface
+	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+
+    def get_inner_dz_left(self):
+	# This is the distance the particle can traval towards the surface
+	# Note that it is implied that the shell sticks out at the other end
+	# of the planar surface by the particle radius, and that the surface
+	# has no thickness.
+	dist_to_surface = self.shell.half_length - self.pid_particle_pair[1].radius
+	return dist_to_surface - self.pid_particle_pair[1].radius
 
     def greens_function(self):
         # This is the Greens function that does not produce REACTION event
         #return GreensFunction3DAbsSYm(self.getD(), get_inner_a())
-        return GreensFunction2DAbsSym(self.getD(), self.get_inner_a())
+        return GreensFunction2DAbsSym(self.D, self.get_inner_a())
 
     def iv_greens_function(self):
 	# The green's function that also modelles the association of the particle
 	# with the planar surface.
-        # Todo. 1D gf Rad Abs should be sigma to a.
-        return GreensFunction1DRadAbs(self.getD, self.interactionrule.k, self.r0, self.sigma, self.a)
-
-        # TODO.
-        # Cartesian domain of half_length L. Correction with getMinRadius().
-        #zDomain = CartesianDomain(particle_offset[1] - self.getMinRadius(), 
-        #                           size_of_domain - 2 * self.getMinRadius(), 
-        #                           gfz)
-
-
+	# TODO choose interactionrule
+        return GreensFunction1DRadAbs(self.D, self.interactionrule.k, self.z0,
+				      self.get_inner_dz_left(), self.get_inner_dz_right())
 
     def draw_new_position(self, dt, event_type):
 	"""Draws a new position for the particle for a given event type at a given time
@@ -519,7 +529,7 @@ def draw_new_position(self, dt, event_type):
 		r = a
 	    else:
 		gf = self.greens_function()
-        	r = draw_r_wrapper(gf, dt, event_type, a)
+        	r = draw_r_wrapper(gf, dt, a)
 
 	    x, y = randomVector2D(r)
 	    vector_r = x * self.surface.unitX + y * self.surface.unitY
@@ -529,21 +539,24 @@ def draw_new_position(self, dt, event_type):
             # Heads up. size_of_domain is different from the half_length of 
             # the cylinder, because the domain ends where the surface 
             # starts, while the cylinder is continuing into the surface.
-            sigma = self.sigma	# left side of the domain
-	    a = self.shell.shape.half_length*2 - self.sigma # FIXME ??????
+            z_surface = self.get_inner_dz_left()	# left side of the inner domain
+	    z_not_surface = self.get_inner_dz_right()	# right side of the inner domain (away from the surface)
+
+	    if event_type == EventType.IV_EVENT:	# If the event was not yet fully specified
+		event_type = self.draw_iv_event_type()
+
 	    if event_type == EventType.IV_INTERACTION:
-		z = sigma
+		z = z_surface
 	    elif event_type == EventType.IV_ESCAPE:
-		z = a
+		z = z_not_surface
 	    else:
 	        gf_iv = self.iv_greens_function()
-        	r0 = self.particle_offset			# TODO
-        	z = draw_displacement_wrapper(gf_z, dt, eventType, a, r0, sigma)
+        	z = draw_r_wrapper(gf_iv, dt, z_not_surface, z_surface)
 
-	    vector_z = z * self.shell.unitZ
+	    vector_z = z * self.shell.shape.orientation_vector	# TODO Is the orientation_vector normalized?
 
-            # Add displacement vector to self.particle.pos, not self.pos.
-	    newpos = oldpos + vector_r + vector_z
+	    # The new position is relative to the center of the shell
+	    newpos = self.shell.shape.position + vector_r + vector_z
 
         return newpos
 
@@ -562,9 +575,11 @@ class CylindricalSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: none.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
-                 interaction_type, surface, projected_point, particle_distance,
-                 orientation_vector, dr, dz_left, dz_right):
+    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
+		 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector,
+		 r0, interactionrules, surface):
+#                 interaction_type, surface, projected_point, particle_distance,
+#                 orientation_vector, dr, dz_left, dz_right):
 
         self.particle_distance = particle_distance
         self.dz_left = dz_left
@@ -572,31 +587,44 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
         # Only needed for this type of Interaction.
         self.unit_r = normalize(pid_particle_pair[1].position - projected_point)
 
-        shell = self.create_new_shell(domain_id, projected_point,
-                                      particle_distance, orientation_vector,
-                                      dr, dz_left, dz_right)
-
-        InteractionSingle.__init__(self, domain_id, pid_particle_pair,
-                                   shell_id, shell, reactionrules,
-                                   interaction_type, surface)
-
-    def create_new_shell(self, domain_id, projected_point, particle_distance,
-                         orientation_vector, dr, dz_left, dz_right):
+        #shell = self.create_new_shell(domain_id, projected_point,
+        #                              particle_distance, orientation_vector,
+        #                              dr, dz_left, dz_right)
+
+        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
+				   structure, shell_id, interactionrules, surface)
+
+	# First the surface_unit_z is defined, then we can make the shell.
+	# Sort of a hack -> unit_z should be a property of surface
+	self.surface_unit_z = self.surface.shape.unit_z
+	self.shell = self.create_new_shell(self, shell_center, shell_radius, shell_half_length)
+
+#    def create_new_shell(self, domain_id, projected_point, particle_distance,
+#                         orientation_vector, dr, dz_left, dz_right):
+#
+#        # Compute origin, radius and half_length of cylinder.
+#        # This stuff is complicated. and should not be here.
+#        half_length = (dz_left + dz_right) / 2
+#        shiftZ = half_length - dz_left
+#        origin = projected_point + shiftZ * orientation_vector
+#        radius = dr + particle_distance
+#
+#        # Return shell.
+#        return CylindricalShell(domain_id, Cylinder(origin, radius, 
+#                                                    orientation_vector, 
+#                                                    half_length))
+
+    def get_inner_dz_left(self):
+	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
-        # Compute origin, radius and half_length of cylinder.
-        # This stuff is complicated. and should not be here.
-        half_length = (dz_left + dz_right) / 2
-        shiftZ = half_length - dz_left
-        origin = projected_point + shiftZ * orientation_vector
-        radius = dr + particle_distance
+    def get_inner_dz_right(self):
+	return self.get_inner_dz_left()		# domain is assumed to be symmetric
 
-        # Return shell.
-        return CylindricalShell(domain_id, Cylinder(origin, radius, 
-                                                    orientation_vector, 
-                                                    half_length))
+    def get_inner_sigma(self):
+	return self.shell.shape.radius + self.pid_particle_pair[1].radius
 
     def greens_function(self):
-	# The greens function not used for the interaction
+	# The greens function not used for the interaction but for the other coordinate
         z0 = self.dz_left - self.shell.shape.half_length
 
         # Free diffusion in z direction, drift is zero by default.

From 0495682016419aa92f41cfcf36f2932eadb1db8f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 24 Aug 2011 18:52:27 +0200
Subject: [PATCH 0141/1541] simplified CylindricalSurfaceInteraction
 form_interaction passed a lot of parameter that were specific to Miedema's
 algorithm. Changed the interactions such that it accepts the bare parameters
 to make an appropriate shell.

---
 egfrd.py  |  27 +++++++++--
 single.py | 143 ++++++++++++++++++++++++------------------------------
 2 files changed, 85 insertions(+), 85 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index feeec4dd..cdcfea2e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -64,12 +64,18 @@ def create_default_interaction(domain_id, pid_particle_pair, shell_id,
     # surface is the surface with which the interaction is made
 
     if isinstance(surface, CylindricalSurface):
+	# Only needed for this type of Interaction.
+	# TODO make sure the periodic boundary conditions don't spoil this
+        unit_r = normalize(pid_particle_pair[1].position - projected_point)
+
         return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
-                                             shell_id, reaction_rules,
-                                             interaction_rules, surface, 
-                                             projected_point, particle_distance,
-                                             orientation_vector,
-                                             dr, dz_left, dz_right)
+                                             reaction_rules, structure,
+					     shell_id, shell_center, shell_radius,
+					     shell_half_length, shell_orientation_vector,
+					     r0, unit_r, interaction_rules, surface)
+#                                             projected_point, particle_distance,
+#                                             orientation_vector,
+#                                             dr, dz_left, dz_right)
     elif isinstance(surface, PlanarSurface):
         return PlanarSurfaceInteraction(domain_id, pid_particle_pair,
                                         reaction_rules, structure,
@@ -1413,6 +1419,7 @@ def form_interaction(self, single, surface, burst):
         particle_distance = abs(projection_distance)
 
         # For interaction with a planar surface, decide orientation. 
+	# Note that the orientation_vector is normalized
         orientation_vector = cmp(projection_distance, 0) * surface.shape.unit_z 
 
         if __debug__:
@@ -1482,6 +1489,16 @@ def form_interaction(self, single, surface, burst):
                            dz_right, min_dz_right))
             return None
 
+	# FIXME For cylinder only?
+        # Compute origin, radius and half_length of cylinder.
+        # This stuff is complicated. 
+        half_length = (dz_left + dz_right) / 2
+        shiftZ = half_length - dz_left
+        origin = projected_point + shiftZ * orientation_vector
+        radius = dr + particle_distance
+
+
+
         interaction = self.create_interaction(single, surface,
                                               projected_point, 
                                               particle_distance,
diff --git a/single.py b/single.py
index cde88a9f..ff1f10a5 100644
--- a/single.py
+++ b/single.py
@@ -378,7 +378,7 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell
 							# trying to interact
 
 	# There are defined here but are overloaded later
-    def get_inner_dz_lefti(self):
+    def get_inner_dz_left(self):
 	pass
 
     def get_inner_dz_right(self):
@@ -542,9 +542,11 @@ def draw_new_position(self, dt, event_type):
             z_surface = self.get_inner_dz_left()	# left side of the inner domain
 	    z_not_surface = self.get_inner_dz_right()	# right side of the inner domain (away from the surface)
 
-	    if event_type == EventType.IV_EVENT:	# If the event was not yet fully specified
+	    # If the event was not yet fully specified
+	    if event_type == EventType.IV_EVENT:	
 		event_type = self.draw_iv_event_type()
 
+
 	    if event_type == EventType.IV_INTERACTION:
 		z = z_surface
 	    elif event_type == EventType.IV_ESCAPE:
@@ -553,7 +555,7 @@ def draw_new_position(self, dt, event_type):
 	        gf_iv = self.iv_greens_function()
         	z = draw_r_wrapper(gf_iv, dt, z_not_surface, z_surface)
 
-	    vector_z = z * self.shell.shape.orientation_vector	# TODO Is the orientation_vector normalized?
+	    vector_z = z * self.shell.shape.unit_z
 
 	    # The new position is relative to the center of the shell
 	    newpos = self.shell.shape.position + vector_r + vector_z
@@ -577,112 +579,93 @@ class CylindricalSurfaceInteraction(InteractionSingle):
     """
     def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
 		 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector,
-		 r0, interactionrules, surface):
-#                 interaction_type, surface, projected_point, particle_distance,
-#                 orientation_vector, dr, dz_left, dz_right):
-
-        self.particle_distance = particle_distance
-        self.dz_left = dz_left
-
-        # Only needed for this type of Interaction.
-        self.unit_r = normalize(pid_particle_pair[1].position - projected_point)
-
-        #shell = self.create_new_shell(domain_id, projected_point,
-        #                              particle_distance, orientation_vector,
-        #                              dr, dz_left, dz_right)
+		 r0, unit_r, interactionrules, surface):
 
         InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
 				   structure, shell_id, interactionrules, surface)
 
-	# First the surface_unit_z is defined, then we can make the shell.
-	# Sort of a hack -> unit_z should be a property of surface
-	self.surface_unit_z = self.surface.shape.unit_z
-	self.shell = self.create_new_shell(self, shell_center, shell_radius, shell_half_length)
+	# z0 is implied to be zero (the particle being in the center of the shell in the z direction)
+	self.z0 = 0
+	self.r0 = r0
+	self.unit_r = unit_r	# This is the vector from the cylinder to the particle
+        self.shell = self.create_new_shell(self, shell_center, shell_radius,
+                                           shell_orientation_vector, shell_half_length)
 
-#    def create_new_shell(self, domain_id, projected_point, particle_distance,
-#                         orientation_vector, dr, dz_left, dz_right):
-#
-#        # Compute origin, radius and half_length of cylinder.
-#        # This stuff is complicated. and should not be here.
-#        half_length = (dz_left + dz_right) / 2
-#        shiftZ = half_length - dz_left
-#        origin = projected_point + shiftZ * orientation_vector
-#        radius = dr + particle_distance
-#
-#        # Return shell.
-#        return CylindricalShell(domain_id, Cylinder(origin, radius, 
-#                                                    orientation_vector, 
-#                                                    half_length))
 
     def get_inner_dz_left(self):
-	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+	return self.shell.shape.half_length + self.z0 - self.pid_particle_pair[1].radius
 
     def get_inner_dz_right(self):
-	return self.get_inner_dz_left()		# domain is assumed to be symmetric
+	return self.get_inner_dz_left()	- self.z0 - self.pid_particle_pair[1].radius
 
     def get_inner_sigma(self):
-	return self.shell.shape.radius + self.pid_particle_pair[1].radius
+	return self.surface.shape.radius + self.pid_particle_pair[1].radius
 
     def greens_function(self):
 	# The greens function not used for the interaction but for the other coordinate
-        z0 = self.dz_left - self.shell.shape.half_length
-
-        # Free diffusion in z direction, drift is zero by default.
-        return GreensFunction1DAbsAbs(self.getD(), 0, z0,
-                                      -self.get_inner_a(),
-                                      self.get_inner_a())
+        # Free diffusion in z direction, drift is zero.
+        return GreensFunction1DAbsAbs(self.D, 0, z0,
+                                      -self.get_inner_dz_left(),
+                                      self.get_inner_dz_right())
 
     def iv_greens_function(self):
 	# Green's function used for the interaction
         # Interaction possible in r direction.
         # TODO.
-        #k = self.interaction_type.k
+        #k = self.interaction_rule.k
         k = 0
-        r0 = self.particle_distance
-        sigma = self.surface.shape.radius + self.pid_particle_pair[1].radius
-        a_r = self.shell.shape.radius - self.pid_particle_pair[1].radius
-        # Todo 2D.
-        return GreensFunction3DRadAbs(self.getD(), k, r0, sigma, a_r)
+        # TODO 2D.
+        return GreensFunction3DRadAbs(self.D, k, self.r0, self.get_inner_sigma(),
+				      self.get_inner_a())
 
     def draw_new_position(self, dt, event_type):
 	oldpos = self.pid_particle_pair[1].position
 
 	if self.D == 0:
-	    return oldpos
-	elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 2:
-	    return oldpos
+	    newpos = oldpos
+	elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+	    newpos = oldpos
+	else:
+            # 1) Draw z.
+            if event_type == EventType.SINGLE_ESCAPE:
+                # Moving this checks to the Green's functions is not a good 
+        	# idea, because then you'd draw an unused random number.  
+        	# The same yields for the draw_new_com and draw_new_iv.  
+		# Assume for now that z0 = 0 -> both boundaries are equally likely
+		z = myrandom.choice(-1, 1) * self.get_inner_dz_left()
+            else:
+        	gf = self.greens_function()
+        	z = draw_r_wrapper(gf, dt, self.get_inner_dz_left())
+
+            # Direction matters, so use shell.shape.unit_z instead of 
+            # structure.shape.unit_z.
+            z_vector = z * self.shell.shape.unit_z
 
-        # 1) Draw z.
-        if event_type == EventType.SINGLE_ESCAPE:
-            # Moving this checks to the Green's functions is not a good 
-            # idea, because then you'd draw an unused random number.  
-            # The same yields for the draw_new_com and draw_new_iv.  
-            z = self.get_inner_a()
-        else:
-            gf = self.greens_function()
-            z = draw_r_wrapper(gf, dt, self.get_inner_a())
-
-        # Orientation matters, so use shell.shape.unit_z instead of 
-        # structure.shape.unit_z.
-        z_vector = z * self.shell.shape.unit_z
-
-        # 2) Draw r and theta.
-        sigma = self.surface.shape.radius + self.pid_particle_pair[1].radius
-        a_r = self.shell.shape.radius - self.pid_particle_pair[1].radius
-        iv_gf = self.iv_greens_function()
-        if event_type == EventType.IV_ESCAPE:
-            r = a_r
-        elif event_type == EventType.IV_INTERACTION:
-            r = sigma
-        else:
-            r = draw_r_wrapper(iv_gf, dt, a_r, sigma)
-        theta = draw_theta_wrapper(iv_gf, r, dt)
 
-        r_vector = r * rotate_vector(self.unit_r, self.shell.shape.unit_z,
+            # 2) Draw r and theta.
+	    # If the event was not yet fully specified
+	    if event_type == EventType.IV_EVENT:	
+		event_type = self.draw_iv_event_type()
+
+            sigma = self.get_inner_sigma()
+            a_r = self.get_inner_a()
+            gf_iv = self.iv_greens_function()
+
+            if event_type == EventType.IV_ESCAPE:
+        	r = a_r
+            elif event_type == EventType.IV_INTERACTION:
+        	r = sigma
+            else:
+        	r = draw_r_wrapper(gf_iv, dt, a_r, sigma)
+            theta = draw_theta_wrapper(iv_gf, r, dt)
+
+            r_vector = r * rotate_vector(self.unit_r, self.shell.shape.unit_z,
                                      theta)
 
-        # Add displacement to shape.position, not to particle.position.  
-        return self.shell.shape.position + z_vector + r_vector
+            # Add displacement to shell.shape.position, not to particle.position.  
+            newpos = self.shell.shape.position + z_vector + r_vector
+
+	return newpos
 
 #    def get_shell_size(self):
 #	# REMOVE this method, it doesn't mean anything here.

From 0c5f513128e0e7f16509c8e55ddf00f4bfac7187 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 25 Aug 2011 11:46:25 +0200
Subject: [PATCH 0142/1541] fixed stupid bug -> don't import things twice!

---
 domain.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/domain.py b/domain.py
index 43fd380a..e9f2927d 100644
--- a/domain.py
+++ b/domain.py
@@ -1,4 +1,3 @@
-from _gfrd import *
 
 class Domain(object):
 # The domain is the main unit of eGFRD. Single, Pairs and Multis are all domains

From 8d6849b638d507fd77c86214b87913eac20d3284 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 26 Aug 2011 15:17:56 +0200
Subject: [PATCH 0143/1541] setup the class structure and methods for a
 MixedPair A MixedPair is when there is one particle in the membrane and one
 in the cytosol

---
 pair.py   | 320 +++++++++++++++++++++++++++++++++++-------------------
 single.py |   3 +-
 2 files changed, 211 insertions(+), 112 deletions(-)

diff --git a/pair.py b/pair.py
index dcbff700..873f5384 100644
--- a/pair.py
+++ b/pair.py
@@ -24,8 +24,8 @@ class Pair(ProtectiveDomain):
     # 5.6: ~1e-8, 6.0: ~1e-9
     CUTOFF_FACTOR = 5.6
 
-    def __init__(self, domain_id, com, single1, single2, shell_id, r0, 
-                 shell_size, rt, structure):
+    def __init__(self, domain_id, single1, single2, shell_id, r0, 
+                 rt):
 	ProtectiveDomain.__init__(self, domain_id)
 
         self.multiplicity = 2
@@ -35,27 +35,14 @@ def __init__(self, domain_id, com, single1, single2, shell_id, r0,
 	self.pid_particle_pair1 = single1.pid_particle_pair
 	self.pid_particle_pair2 = single2.pid_particle_pair
 
-        self.a_R, self.a_r = self.determine_radii(r0, shell_size)
-	# set the radii of the inner domains as a function of the outer protective domain
-
         self.rt = rt
-        self.structure = structure		# structure on which both particles live
 
-        # Create shell.
 	self.shell_id = shell_id
-        self.shell = self.create_new_shell(com, shell_size, domain_id)
 
     def __del__(self):
         if __debug__:
             log.debug('del %s' % str(self))
 
-    def get_com(self):
-        return self.shell.shape.position
-    com = property(get_com)
-
-    def get_shell_size(self):
-        return self.shell.shape.radius
-
     def get_D_tot(self):
         return self.pid_particle_pair1[1].D + \
                self.pid_particle_pair2[1].D
@@ -66,101 +53,12 @@ def get_D_R(self):
                 self.pid_particle_pair2[1].D) / self.D_tot
     D_R = property(get_D_R)
 
-    def getSigma(self):
-        return self.pid_particle_pair1[1].radius + \
-               self.pid_particle_pair2[1].radius
-    sigma = property(getSigma)
-
     def initialize(self, t):
 	# re-initialize the time parameters of the Domain to reuse it.
         self.last_time = t
         self.dt = 0
         self.event_type = None
 
-    def determine_radii(self, r0, shell_size):
-        """Determine a_r and a_R from the size of the protective domain.
-
-        Todo. Make dimension (1D/2D/3D) specific someday. Optimization only.
-
-        """
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
-
-	LD_MAX = 20 # temporary value
-	a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
-	# a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
-
-        # Make sure that D1 != 0 to avoid division by zero in the followings.
-        if D1 == 0:
-            D1, D2 = D2, D1	# shouldn't we also here swap the particle radii if we're swapping diffusion contants?
-
-        shell_size /= SAFETY	#??
-
-        D_tot = D1 + D2
-        D_geom = math.sqrt(D1 * D2)
-
-        assert r0 >= self.sigma, \
-            '%s;  r0 %g < sigma %g' % (self, r0, self.sigma)
-
-        # equalize expected mean t_r and t_R.
-        if ((D_geom - D2) * r0) / D_tot + shell_size +\
-                math.sqrt(D2 / D1) * (radius1 - shell_size) - radius2 >= 0:
-            Da = D1
-            Db = D2
-            radiusa = radius1
-            radiusb = radius2
-        else:
-            Da = D2
-            Db = D1
-            radiusa = radius2
-            radiusb = radius1
-
-
-        #aR
-        a_R = (D_geom * (Db * (shell_size - radiusa) + \
-                         Da * (shell_size - r0 - radiusa))) /\
-              (Da * Da + Da * Db + D_geom * D_tot)
-
-        #ar
-        a_r = (D_geom * r0 + D_tot * (shell_size - radiusa)) / (Da + D_geom)
-
-
-	# Now if the planned domainsize for r is too large for proper convergence of the Green's
-	# functions, make it the maximum allowed size
-	if (a_r > a_r_max):
-	    a_r = a_r_max
-	    a_R = shell_size - radiusa - a_r * Da / D_tot
-	    if __debug__:
-		log.info('domainsize changed for convergence.')
-
-        assert a_R + a_r * Da / D_tot + radius1 >= \
-               a_R + a_r * Db / D_tot + radius2
-
-        assert abs(a_R + a_r * Da / D_tot + radiusa - shell_size) \
-            < 1e-12 * shell_size			# here the shell_size is the relevant scale
-
-
-        if __debug__:
-          log.debug('a %g, r %g, R %g r0 %g' % 
-                 (shell_size, a_r, a_R, r0))
-        if __debug__:
-            tr = ((a_r - r0)**2) / (6 * self.D_tot)	# the expected escape time of the iv
-            if self.D_R == 0:
-                tR = numpy.inf 
-            else:
-                tR = (a_R**2) / (6 * self.D_R)		# the expected escape time of the CoM
-            log.debug('tr %g, tR %g' % (tr, tR))
-
-
-        assert a_r > 0
-        assert a_r > r0, '%g %g' % (a_r, r0)
-        assert a_R > 0 or (a_R == 0 and (D1 == 0 or D2 == 0))
-
-        return a_R, a_r
-
     # draws a first event time and the (not fully specified) type of event
     def draw_com_escape_or_iv_event_time_tuple(self, r0):
         """Returns a (event time, event type, reactingsingle=None) tuple.
@@ -260,13 +158,124 @@ def __str__(self):
             self.pid_particle_pair2[0],
             name1, name2)
 
-class SphericalPair(Pair):
+class SimplePair(Pair):
+    def __init__(self, domain_id, com, single1, single2, shell_id,
+                      r0, shell_size, rt, structure):
+	Pair.__init__(self, domain_id, single1, single2, shell_id,
+                      r0, rt)
+
+        self.structure = structure		# structure on which both particles live
+
+        self.a_R, self.a_r = self.determine_radii(r0, shell_size)
+	# set the radii of the inner domains as a function of the outer protective domain
+
+        self.shell = self.create_new_shell(com, shell_size, domain_id)
+
+
+    def getSigma(self):
+        return self.pid_particle_pair1[1].radius + \
+               self.pid_particle_pair2[1].radius
+    sigma = property(getSigma)
+
+    def get_com(self):
+        return self.shell.shape.position
+    com = property(get_com)
+
+    def get_shell_size(self):
+        return self.shell.shape.radius
+
+    def determine_radii(self, r0, shell_size):
+        """Determine a_r and a_R from the size of the protective domain.
+
+        Todo. Make dimension (1D/2D/3D) specific someday. Optimization only.
+
+        """
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
+
+	LD_MAX = 20 # temporary value
+	a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
+	# a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
+
+        # Make sure that D1 != 0 to avoid division by zero in the followings.
+        if D1 == 0:
+            D1, D2 = D2, D1	# shouldn't we also here swap the particle radii if we're swapping diffusion contants?
+
+        shell_size /= SAFETY	#??
+
+        D_tot = D1 + D2
+        D_geom = math.sqrt(D1 * D2)
+
+        assert r0 >= self.sigma, \
+            '%s;  r0 %g < sigma %g' % (self, r0, self.sigma)
+
+        # equalize expected mean t_r and t_R.
+        if ((D_geom - D2) * r0) / D_tot + shell_size +\
+                math.sqrt(D2 / D1) * (radius1 - shell_size) - radius2 >= 0:
+            Da = D1
+            Db = D2
+            radiusa = radius1
+            radiusb = radius2
+        else:
+            Da = D2
+            Db = D1
+            radiusa = radius2
+            radiusb = radius1
+
+
+        #aR
+        a_R = (D_geom * (Db * (shell_size - radiusa) + \
+                         Da * (shell_size - r0 - radiusa))) /\
+              (Da * Da + Da * Db + D_geom * D_tot)
+
+        #ar
+        a_r = (D_geom * r0 + D_tot * (shell_size - radiusa)) / (Da + D_geom)
+
+
+	# Now if the planned domainsize for r is too large for proper convergence of the Green's
+	# functions, make it the maximum allowed size
+	if (a_r > a_r_max):
+	    a_r = a_r_max
+	    a_R = shell_size - radiusa - a_r * Da / D_tot
+	    if __debug__:
+		log.info('domainsize changed for convergence.')
+
+        assert a_R + a_r * Da / D_tot + radius1 >= \
+               a_R + a_r * Db / D_tot + radius2
+
+        assert abs(a_R + a_r * Da / D_tot + radiusa - shell_size) \
+            < 1e-12 * shell_size			# here the shell_size is the relevant scale
+
+
+        if __debug__:
+          log.debug('a %g, r %g, R %g r0 %g' % 
+                 (shell_size, a_r, a_R, r0))
+        if __debug__:
+            tr = ((a_r - r0)**2) / (6 * self.D_tot)	# the expected escape time of the iv
+            if self.D_R == 0:
+                tR = numpy.inf 
+            else:
+                tR = (a_R**2) / (6 * self.D_R)		# the expected escape time of the CoM
+            log.debug('tr %g, tR %g' % (tr, tR))
+
+
+        assert a_r > 0
+        assert a_r > r0, '%g %g' % (a_r, r0)
+        assert a_R > 0 or (a_R == 0 and (D1 == 0 or D2 == 0))
+
+        return a_R, a_r
+
+
+class SphericalPair(SimplePair):
     """2 Particles inside a (spherical) shell not on any surface.
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
                  r0, shell_size, rt, structure):
-        Pair.__init__(self, domain_id, com, single1, single2, shell_id,
+        SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
                       r0, shell_size, rt, structure)
 
     def com_greens_function(self):
@@ -280,7 +289,7 @@ def iv_greens_function(self, r0):
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):
-        return SphericalShell(domain_id, Sphere(position, radius))
+        return SphericalShell(self.domain_id, Sphere(position, radius))
 
     # selects between the full solution or an approximation where one of
     # the boundaries is ignored
@@ -360,14 +369,14 @@ def __str__(self):
         return 'Spherical' + Pair.__str__(self)
 
 
-class PlanarSurfacePair(Pair):
+class PlanarSurfacePair(SimplePair):
     """2 Particles inside a (cylindrical) shell on a PlanarSurface. 
     (Hockey pucks).
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
                  r0, shell_size, rt, structure):
-        Pair.__init__(self, domain_id, com, single1, single2, shell_id,
+        SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
                       r0, shell_size, rt, structure)
 
     def com_greens_function(self):
@@ -457,14 +466,14 @@ def __str__(self):
         return 'PlanarSurface' + Pair.__str__(self)
 
 
-class CylindricalSurfacePair(Pair):
+class CylindricalSurfacePair(SimplePair):
     """2 Particles inside a (cylindrical) shell on a CylindricalSurface.  
     (Rods).
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
                  r0, shell_size, rt, structure):
-        Pair.__init__(self, domain_id, com, single1, single2, shell_id,
+        SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
                       r0, shell_size, rt, structure)
 
     def get_v_tot(self):
@@ -521,5 +530,94 @@ def __str__(self):
         return 'CylindricalSurface' + Pair.__str__(self)
 
 
+class MixedPair(Pair):
+
+    def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
+		 shell_half_length, shell_orientation_vector,
+		 unit_r, r0, pair_reaction_rules):
+	Pair.__init__(self, domain_id, single1, single2, shell_id, r0, 
+                 pair_reaction_rules)
+
+
+	self.surface = surface	# the surface on which particle1 lives
 
+    def determine_radii(self):
+	#TODO INCORRECT
+	a_r = self.shell.shape.half_length*2.0 - self.pid_particle_pair1[1].radius
+	a_R = self.shell.shape.radius - a_r*0.5
+	return 
+
+    def get_com(self):
+	# TODO INCORRECT
+	return self.shell.shape.position
+    com = property(get_com)
 
+    def get_sigma(self):
+	# rescale sigma to correct for the rescaling of the coordinate system
+	# TODO check if this is actually correct
+	D_1 = self.pid_particle_pair1[1].D
+	D_2 = self.pid_particle_pair2[1].D
+	xi_inv = math.sqrt(D_2/(D_1 + D_2))
+	alpha = math.acos(xi_inv)
+	sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
+	rho = abs(sigma*math.sqrt(0.5 + (alpha/(2.0*xi_inv*math.sin(alpha)))))
+	return rho
+    sigma = property (get_sigma)
+
+    def com_greensfunction(self):
+	# diffusion of the CoM of a mixed pair is only two dimensional
+	return GreensFunction2DAbsSym(self.D_R, self.a_R)
+
+    def iv_greensfunction(self):
+	# diffusion of the interparticle vector is three dimensional
+	return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
+				      self.sigma, self.a_r)
+
+    def create_new_shell(self, position, radius, orientation_vector, half_length):
+	# It is assumed that the parameter are correct -> the 'bottom' of the cylinder
+	# sticks through the membrane enough to accomodate the particle in the membrane
+	# assert that orientation_vector is on same line as surface.shape.unit_z
+	return CylindricalShell(self.domain_id, Cylinder(position, radius, orientation_vector,
+							 half_length))
+
+    def create_com_vector(self, r):
+	x, y = random_vector2D(r)
+	return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
+
+    def create_iv_vector(self, gf, r, dt, r0, old_iv):
+	# TODO This is not yet correct -> stub
+        if __debug__:
+            log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
+        theta = draw_theta_wrapper(gf, r, dt)
+
+        new_inter_particle_s = numpy.array([r, theta,
+                                         myrandom.uniform() * 2 * Pi])
+        new_iv = spherical_to_cartesian(new_inter_particle_s)
+
+        #FIXME: need better handling of angles near zero and pi.
+
+        # I rotate the new interparticle vector along the
+        # rotation axis that is perpendicular to both the
+        # z-axis and the original interparticle vector for
+        # the angle between these.
+
+        # the rotation axis is a normalized cross product of
+        # the z-axis and the original vector.
+        # rotation_axis = crossproduct([0,0,1], inter_particle)
+        angle = vector_angle_against_z_axis(old_iv)
+        if angle % numpy.pi != 0.0:
+            rotation_axis = crossproduct_against_z_axis(old_iv)
+            rotation_axis = normalize(rotation_axis)
+            rotated = rotate_vector(new_iv, rotation_axis, angle)
+        elif angle == 0.0:
+            rotated = new_iv
+        else:
+            rotated = numpy.array([new_iv[0], new_iv[1], - new_iv[2]])
+        
+	# TODO
+	# rescale z component by 1/xi (z component becomes slightly smaller, since D = D_A + D_B
+	# was used for calculation, whereas in reality D is only D_B
+	xi_inv = math.sqrt((D_2)/D_1 + D_2)
+	z /= xi
+	# position is reflected back in the membrane if necessary
+	return rotated 
diff --git a/single.py b/single.py
index ff1f10a5..2b7768c9 100644
--- a/single.py
+++ b/single.py
@@ -586,8 +586,9 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
 
 	# z0 is implied to be zero (the particle being in the center of the shell in the z direction)
 	self.z0 = 0
-	self.r0 = r0
 	self.unit_r = unit_r	# This is the vector from the cylinder to the particle
+	self.r0 = r0		# r0 is the distance from the center of the cylinder to the
+				# center of the particle
         self.shell = self.create_new_shell(self, shell_center, shell_radius,
                                            shell_orientation_vector, shell_half_length)
 

From 55e4f346f0103c280fa7ac02e31ae5b858cbd8c6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 26 Aug 2011 19:03:06 +0200
Subject: [PATCH 0144/1541] comments clarifying the shell making procedure.
 Also an attempt to keep the 3D shell away from surfaces

---
 egfrd.py | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index cdcfea2e..319fad03 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -152,6 +152,9 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.SINGLE_SHELL_FACTOR = 2.0
 	self.MAX_NUM_DT0_STEPS = 10000
         self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
+	self.SURFACE_BARRIER = 3e-8		# This is the distance that cytosolic shells should at least have
+						# when not attempting an interaction with the surface.
+						# This should be at least as big as the largest particle on the surface
 
 	# used datastructrures
         self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
@@ -961,10 +964,11 @@ def fire_single(self, single):
 	### 2. Now make a new domain
         # (2) Clear volume.
 
+	# 2.1 First check if there are shells with a radius of min_shell
+	#     of the particle (intruders)
         min_shell = single.pid_particle_pair[1].radius * \
                     self.SINGLE_SHELL_FACTOR
 
-        # Burst intruders.
         intruders, closest, closest_distance = \
             self.get_intruders(singlepos, min_shell,
                                ignore=[single.domain_id, ])
@@ -974,18 +978,21 @@ def fire_single(self, single):
                       (', '.join(str(i) for i in intruders),
                        closest, FORMAT_DOUBLE % closest_distance))
 
+        # 2.2 Burst the intruders.
+	# burst now contains all the Domains resulting from the burst (singles and multi's)
         if intruders:
             burst = self.burst_non_multis(intruders)
         else:
             burst = None
 
-        # Check closest surface.
+        # 2.3 Check if there is a surface within min_shell (also returns the closest surface)
         # Only relevant when the particle lives in the "world" or other 3D region.
         if isinstance(single.structure, CuboidalRegion):
             interaction_surface, closest_surface, surface_distance = \
                 get_closest_surface_within_radius(self.world, 
                                                   singlepos, min_shell,
                                                   ignore=[single.structure.id])
+	# 2.3.1 If there is a surface within min_shell -> try interaction
             if interaction_surface:
                 domain = self.form_interaction(single, interaction_surface, burst)
                 if domain:
@@ -994,6 +1001,9 @@ def fire_single(self, single):
             # Surfaces are not allowed to touch or overlap.
             closest_surface = None
 
+
+	# 2.4 If there were bursted Domains (intruders)
+	# 2.4.1 try making a Pair or Multi
         if burst:
             domain = self.form_pair_or_multi(single, burst)
 
@@ -1023,10 +1033,12 @@ def fire_single(self, single):
                               (s, FORMAT_DOUBLE % s.shell.shape.radius,
                                FORMAT_DOUBLE % s.dt, closest,
                                FORMAT_DOUBLE % closest_distance))
+
+	# 2.4.2 Else just continue with the NonInteractionSingle
         else:
             if closest_surface and surface_distance < closest_distance:
                 closest = closest_surface
-                closest_distance = surface_distance
+                closest_distance = surface_distance - self.SURFACE_BARRIER
             self.update_single(single, closest, closest_distance)
             
         if __debug__:
@@ -1981,6 +1993,7 @@ def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
             pass
 
     def get_intruders(self, position, radius, ignore):
+	# gets the intruders in a spherical volume of radius 'radius'?
         intruders = []   # intruders are domains within radius
         closest_domain = None   # closest domain, excluding intruders.
         closest_distance = numpy.inf # distance to the shell of the closest.

From 01cbe320ce5c96bfd29572f222e0bc3e3ae58b2b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 29 Aug 2011 17:16:07 +0200
Subject: [PATCH 0145/1541] Clarifying fire_single. Thrown out
 "get_closest_surface_within_radius" in gfrdbase.py Also major bugfix in
 get_closest_surface->distances should not be negative!

---
 egfrd.py    | 94 +++++++++++++++++++++++++++++------------------------
 gfrdbase.py | 28 ++++++++--------
 2 files changed, 65 insertions(+), 57 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 319fad03..8929afd4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -155,6 +155,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 	self.SURFACE_BARRIER = 3e-8		# This is the distance that cytosolic shells should at least have
 						# when not attempting an interaction with the surface.
 						# This should be at least as big as the largest particle on the surface
+	self.SURFACE_HORIZON = 0		# distance to a surface when it should starting trying to make an interaction
 
 	# used datastructrures
         self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
@@ -721,6 +722,9 @@ def burst_non_multis(self, neighbors):
         return bursted
 
     def fire_single_reaction(self, single, interaction_flag=False):
+	# This takes care of the identity change when a single particle decays into
+	# one or a number of other particles
+	# TODO This can also be used when a particle falls off a surface.
         if interaction_flag == True:
             raise NotImplementedError
         reactant_species_radius = single.pid_particle_pair[1].radius
@@ -892,19 +896,18 @@ def propagate_single(self, single):
                 return single
 
     def fire_single(self, single):
-#        assert abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t
-#	# why this assert -> we need to take into account that single.dt might be infinite
+	### 1. Process event produced by the single
+	### 1.1 Special cases (shortcuts)
         # In case nothing is scheduled to happen: do nothing; 
         # results also in disappearance from scheduler.
         if single.dt == numpy.inf:
-            return single 
-        
-	### 1. Process event produced by the single
+            return 
+	# Else continue
 
-        # Otherwise check timeline
+        # check timeline
         assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
-        # Reaction.
+        # If the single had a decay reaction.
         if single.event_type == EventType.SINGLE_REACTION:
             if __debug__:
                 log.info('%s' % single.event_type)
@@ -923,32 +926,32 @@ def fire_single(self, single):
 
             return
 
-#       TO BE DELETED; code shouldn't be here. 
-#       (<-> Surface binding en unbinding.)
-#
-#        if single.event_type == EventType.IV_EVENT:
-#            # Draw actual pair event for iv at very last minute.
-#            single.event_type = single.draw_iv_event_type()
-#            self.interaction_steps[single.event_type] += 1
-#        else:
-#            self.single_steps[single.event_type] += 1
+	# Else the event was either an ESCAPE (NonInteractionSingle or InteractionSingle),
+	# or IV_EVENT (InteractionSingle only), NO BURST event comes up here!
+
 
         if __debug__:
             log.info('%s' % single.event_type)
             log.info('single = %s' % single)
 
-        # Handle immobile case first.
+        # Handle immobile case (what event has taken place to get here?!).
         if single.getD() == 0:
-            # no propagation, just calculate next reaction time.
+	    # The domain has not produced an decay reaction event and is immobile
+            # ->no propagation, no other changes just calculate next reaction time
+	    # and reschedule the single. So this also takes care of the domain making part
             single.dt, single.event_type = single.determine_next_event() 
             single.last_time = self.t
             self.add_domain_event(single)
             return
         
+
+	### 1.2 General case
+	# There is a non-trivial event time for the domain
         if single.dt != 0.0:
             # Propagate this particle to the exit point on the shell.
             single = self.propagate_single(single)
 
+
         # An interaction event is similar to a single reaction.
         if single.event_type == EventType.IV_INTERACTION:
             try:
@@ -961,6 +964,7 @@ def fire_single(self, single):
 
         singlepos = single.shell.shape.position
 
+
 	### 2. Now make a new domain
         # (2) Clear volume.
 
@@ -978,48 +982,53 @@ def fire_single(self, single):
                       (', '.join(str(i) for i in intruders),
                        closest, FORMAT_DOUBLE % closest_distance))
 
-        # 2.2 Burst the intruders.
-	# burst now contains all the Domains resulting from the burst (singles and multi's)
+        # 2.2 Burst the intruders if present.
         if intruders:
             burst = self.burst_non_multis(intruders)
+	    # burst now contains all the Domains resulting from the burst (singles and multi's)
         else:
             burst = None
 
+
+
         # 2.3 Check if there is a surface within min_shell (also returns the closest surface)
         # Only relevant when the particle lives in the "world" or other 3D region.
         if isinstance(single.structure, CuboidalRegion):
-            interaction_surface, closest_surface, surface_distance = \
-                get_closest_surface_within_radius(self.world, 
-                                                  singlepos, min_shell,
-                                                  ignore=[single.structure.id])
-	# 2.3.1 If there is a surface within min_shell -> try interaction
-            if interaction_surface:
-                domain = self.form_interaction(single, interaction_surface, burst)
+            closest_surface, surface_distance = \
+                get_closest_surface(self.world, singlepos, ignore=[single.structure.id])
+	    # 2.3.1 If there is a surface within min_shell -> try interaction
+	    if surface_distance < self.SURFACE_HORIZON:
+                domain = self.form_interaction(single, closest_surface, burst)
                 if domain:
                     return
+
         else:
             # Surfaces are not allowed to touch or overlap.
             closest_surface = None
 
 
-	# 2.4 If there were bursted Domains (intruders)
-	# 2.4.1 try making a Pair or Multi
+	# 2.4 If there were bursted Domains (intruders),
+	# try making a Pair or Multi
         if burst:
             domain = self.form_pair_or_multi(single, burst)
-
             if domain:
                 return
 
-            # if nothing was formed, recheck closest and restore shells.
-            burst = uniq(burst)
+        # if nothing was formed, resize the Single shell for the 'current'
+	# domain (the domain that started it all).
+        closest, closest_distance = \
+            self.get_closest_obj(singlepos, ignore=[single.domain_id],
+                                 ignores=[single.structure.id])
+        self.update_single(single, closest, closest_distance)
+        self.add_domain_event(single)
 
-            closest, closest_distance = \
-                self.get_closest_obj(singlepos, ignore=[single.domain_id],
-                                     ignores=[single.structure.id])
-            self.update_single(single, closest, closest_distance)
+	# Then resize all the bursted domains -> WHY NOT LET THE SCHEDULER HANDLE THIS?
+        if burst:
+            burst = uniq(burst)
             for s in burst:
                 if not isinstance(s, Single):
                     continue
+
                 assert s.is_reset()
                 closest, closest_distance = self.get_closest_obj(
                     s.shell.shape.position, ignore=[s.domain_id],
@@ -1027,6 +1036,7 @@ def fire_single(self, single):
 
                 self.update_single(s, closest, closest_distance)
                 self.update_domain_event(self.t + s.dt, s)
+
                 if __debug__:
                     log.debug('restore shell %s radius %s dt %s\n'
                               'closest %s distance %s' %
@@ -1034,19 +1044,17 @@ def fire_single(self, single):
                                FORMAT_DOUBLE % s.dt, closest,
                                FORMAT_DOUBLE % closest_distance))
 
-	# 2.4.2 Else just continue with the NonInteractionSingle
-        else:
-            if closest_surface and surface_distance < closest_distance:
-                closest = closest_surface
-                closest_distance = surface_distance - self.SURFACE_BARRIER
-            self.update_single(single, closest, closest_distance)
+#        else:
+#            if closest_surface and surface_distance < closest_distance:
+#                closest = closest_surface
+#                closest_distance = surface_distance - self.SURFACE_BARRIER
+#            self.update_single(single, closest, closest_distance)
             
         if __debug__:
             log.info('updated shell: (%s,\n  Shell(%s, %s)' %
                      (single.shell_id, single.shell.did,
                       single.shell.shape.show(PRECISION)))
 
-        self.add_domain_event(single)
         return
 
     def reject_single_reaction(self, single):
diff --git a/gfrdbase.py b/gfrdbase.py
index fdfda5a7..e281360d 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -27,8 +27,8 @@
     'NoSpace',
     'create_world',
     'ParticleSimulatorBase',
-    'get_closest_surface',
-    'get_closest_surface_within_radius'
+    'get_closest_surface'#,
+#    'get_closest_surface_within_radius'
     ]
 
 World = _gfrd.World
@@ -95,7 +95,7 @@ def get_closest_surface(world, pos, ignore):
         if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
             pos_transposed = \
                 world.cyclic_transpose(pos, surface.shape.position)
-            distance = world.distance(surface.shape, pos_transposed)
+            distance = abs(world.distance(surface.shape, pos_transposed))	# This should not be here but C++ code
             surfaces_and_distances_to_surfaces.append((surface, distance))
 
     if surfaces_and_distances_to_surfaces:
@@ -103,17 +103,17 @@ def get_closest_surface(world, pos, ignore):
     else:
         return None, numpy.inf
 
-def get_closest_surface_within_radius(world, pos, radius, ignore):
-    """Return:
-      - surface within radius or None
-      - closest surface (regardless of radius)
-      - distance to closest surface"""
-
-    surface, distance = get_closest_surface(world, pos, ignore) 
-    if distance < radius:
-        return surface, surface, distance
-    else:
-        return None, surface, distance
+#def get_closest_surface_within_radius(world, pos, radius, ignore):
+#    """Return:
+#      - surface within radius or None
+#      - closest surface (regardless of radius)
+#      - distance to closest surface"""
+#
+#    surface, distance = get_closest_surface(world, pos, ignore) 
+#    if distance < radius:
+#        return surface, surface, distance
+#    else:
+#        return None, surface, distance
 
 def create_world(m, matrix_size=10):
     """Create a world object.

From 04bc716cafee68b632d55854a2f0d28498df6480 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 30 Aug 2011 13:47:21 +0200
Subject: [PATCH 0146/1541] mostly comments and clarifications

---
 egfrd.py  | 35 ++++++++++++++++++-----------------
 pair.py   |  3 ++-
 single.py |  1 +
 3 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8929afd4..2f024c31 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -152,10 +152,10 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.SINGLE_SHELL_FACTOR = 2.0
 	self.MAX_NUM_DT0_STEPS = 10000
         self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
-	self.SURFACE_BARRIER = 3e-8		# This is the distance that cytosolic shells should at least have
+	self.SURFACE_BARRIER = 1e-8		# This is the distance that cytosolic shells should at least have
 						# when not attempting an interaction with the surface.
 						# This should be at least as big as the largest particle on the surface
-	self.SURFACE_HORIZON = 0		# distance to a surface when it should starting trying to make an interaction
+	self.SURFACE_HORIZON = 3e-8		# distance to a surface when it should starting trying to make an interaction
 
 	# used datastructrures
         self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
@@ -899,12 +899,12 @@ def fire_single(self, single):
 	### 1. Process event produced by the single
 	### 1.1 Special cases (shortcuts)
         # In case nothing is scheduled to happen: do nothing; 
-        # results also in disappearance from scheduler.
+        # results also in disappearance from scheduler. (?)
         if single.dt == numpy.inf:
             return 
 	# Else continue
 
-        # check timeline
+        # check timeline (??)
         assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
         # If the single had a decay reaction.
@@ -962,12 +962,12 @@ def fire_single(self, single):
 
             return
 
-        singlepos = single.shell.shape.position
-
 
 	### 2. Now make a new domain
         # (2) Clear volume.
 
+        singlepos = single.shell.shape.position
+
 	# 2.1 First check if there are shells with a radius of min_shell
 	#     of the particle (intruders)
         min_shell = single.pid_particle_pair[1].radius * \
@@ -991,13 +991,13 @@ def fire_single(self, single):
 
 
 
-        # 2.3 Check if there is a surface within min_shell (also returns the closest surface)
+        # 2.3 Check if there is a surface within min_shell 
         # Only relevant when the particle lives in the "world" or other 3D region.
         if isinstance(single.structure, CuboidalRegion):
             closest_surface, surface_distance = \
                 get_closest_surface(self.world, singlepos, ignore=[single.structure.id])
 	    # 2.3.1 If there is a surface within min_shell -> try interaction
-	    if surface_distance < self.SURFACE_HORIZON:
+	    if surface_distance < min_shell:
                 domain = self.form_interaction(single, closest_surface, burst)
                 if domain:
                     return
@@ -1090,7 +1090,7 @@ def calculate_single_shell_size(self, single, closest,
         return shell_size
 
     def update_single(self, single, closest, distance_to_shell): 
-        assert not isinstance(single, InteractionSingle)
+        assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
 
         singlepos = single.shell.shape.position
         if isinstance(closest, Single):
@@ -1400,7 +1400,8 @@ def propagate_pair(self, pair, dt, event_type):
         return single1, single2
 
     def form_pair_or_multi(self, single, neighbors):
-    # single is the current single being treated, neighbors is a list (?) of neighboring shells
+    # single is the current single being treated, neighbors is a list of bursted shells
+    # Note! These are not necessarily its neighbors
         assert neighbors
 
         singlepos = single.shell.shape.position
@@ -1413,7 +1414,7 @@ def form_pair_or_multi(self, single, neighbors):
             neighbors = numpy.take(neighbors, n)
 
         # First, try forming a Pair if the neighbor is a single.
-        if isinstance(neighbors[0], Single):
+        if isinstance(neighbors[0], NonInteractionSingle):
             obj = self.form_pair(single, singlepos,
                                  neighbors[0], neighbors[1:])
             if obj:
@@ -1672,7 +1673,7 @@ def form_pair(self, single1, pos1, single2, burst):
                            single2.pid_particle_pair[0]))
             return None
 
-        # 1. Determine min shell size.
+        # 1. Determine min shell size for the Pair.
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
 
@@ -1703,7 +1704,7 @@ def form_pair(self, single1, pos1, single2, burst):
             min_shell_size = shell_size2
             shell_size_margin = shell_size_margin2
 
-        # 2. Check if min shell size not larger than max shell size or 
+        # 2. Check if min shell size for the Pair not larger than max shell size or 
         # sim cell size.
         com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
         com = self.world.apply_boundary(com)
@@ -1722,7 +1723,7 @@ def form_pair(self, single1, pos1, single2, burst):
                            FORMAT_DOUBLE % max_shell_size))
             return None
 
-        # 3. Check if bursted Singles not too close.
+        # 3. Check if bursted Singles can still make a minimal shell.
         # The simple check for closest below could miss
         # some of them, because sizes of these Singles for this
         # distance check has to include SINGLE_SHELL_FACTOR, while
@@ -2002,9 +2003,9 @@ def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
 
     def get_intruders(self, position, radius, ignore):
 	# gets the intruders in a spherical volume of radius 'radius'?
-        intruders = []   # intruders are domains within radius
-        closest_domain = None   # closest domain, excluding intruders.
-        closest_distance = numpy.inf # distance to the shell of the closest.
+        intruders = []   		# intruders are domains within radius
+        closest_domain = None		# closest domain, excluding intruders.
+        closest_distance = numpy.inf	# distance to the shell of the closest domain.
 
         seen = set(ignore)
         for container in self.containers:
diff --git a/pair.py b/pair.py
index 873f5384..b0ecfd8b 100644
--- a/pair.py
+++ b/pair.py
@@ -9,6 +9,8 @@
     'PlanarSurfacePair',
     'SphericalPair',
     'Pair',
+    'SimplePair',
+    'MixedPair',
     ]
 
 class Pair(ProtectiveDomain):
@@ -96,7 +98,6 @@ def determine_next_event(self, r0):
     def draw_iv_event_type(self, r0):
         gf = self.iv_greens_function(r0)
         event_kind = draw_event_type_wrapper(gf, self.dt)
-	print event_kind
         if event_kind == PairEventKind.IV_REACTION:
             return EventType.IV_REACTION
         elif event_kind == PairEventKind.IV_ESCAPE:
diff --git a/single.py b/single.py
index 2b7768c9..08a71158 100644
--- a/single.py
+++ b/single.py
@@ -10,6 +10,7 @@
     'PlanarSurfaceSingle',
     'SphericalSingle',
     'Single',
+    'NonInteractionSingle',
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'PlanarSurfaceInteraction',

From d7b23f4acb3774b8e60c04550a884daf3281d0e5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 30 Aug 2011 15:27:06 +0200
Subject: [PATCH 0147/1541] Comments and namechanges to clarify
 form_pair_or_multi

---
 egfrd.py | 58 ++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 35 insertions(+), 23 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2f024c31..dfadad8f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -714,9 +714,11 @@ def burst_non_multis(self, neighbors):
 
         for domain in neighbors:
             if not isinstance(domain, Multi):
-                d = self.burst_domain(domain)
-                bursted.extend(d)
+		# domain is Single or Pair of some subclass
+                single_list = self.burst_domain(domain)
+                bursted.extend(single_list)
             else:
+		# domain is a Multi
                 bursted.append(domain)
 
         return bursted
@@ -985,7 +987,8 @@ def fire_single(self, single):
         # 2.2 Burst the intruders if present.
         if intruders:
             burst = self.burst_non_multis(intruders)
-	    # burst now contains all the Domains resulting from the burst (singles and multi's)
+	    # burst now contains all the Domains resulting from the burst.
+	    # These are NonInteractionSingles and Multis
         else:
             burst = None
 
@@ -1010,6 +1013,9 @@ def fire_single(self, single):
 	# 2.4 If there were bursted Domains (intruders),
 	# try making a Pair or Multi
         if burst:
+	    # should first check the new distance to the bursted particles
+	    # If they haven't moved to far away, try pair or multi.
+	    # 
             domain = self.form_pair_or_multi(single, burst)
             if domain:
                 return
@@ -1399,33 +1405,39 @@ def propagate_pair(self, pair, dt, event_type):
 
         return single1, single2
 
-    def form_pair_or_multi(self, single, neighbors):
-    # single is the current single being treated, neighbors is a list of bursted shells
-    # Note! These are not necessarily its neighbors
-        assert neighbors
+    def form_pair_or_multi(self, single, bursted_neighbors):
+    # single is the current single being treated, bursted_neighbors is a list of bursted shells
+    # Note! These are not necessarily its direct neighbors but Pair or Multi can only be made
+    # with Domains that are just bursted.
+        assert bursted_neighbors
 
-        singlepos = single.shell.shape.position
+        #singlepos = single.shell.shape.position
+        singlepos = single.pid_particle_pair[1].position
 
-        # sort burst neighbors by distance
-        dists = self.obj_distance_array(singlepos, neighbors)
+        # sort bursted_neighbors by distance
+        dists = self.obj_distance_array(singlepos, bursted_neighbors)
         if len(dists) >= 2:
             n = dists.argsort()
             dists = dists.take(n)
-            neighbors = numpy.take(neighbors, n)
+            bursted_neighbors = numpy.take(bursted_neighbors, n)
+
 
-        # First, try forming a Pair if the neighbor is a single.
-        if isinstance(neighbors[0], NonInteractionSingle):
-            obj = self.form_pair(single, singlepos,
-                                 neighbors[0], neighbors[1:])
-            if obj:
-                return obj
+	domain = None
+	closest = bursted_neighbors[0]
+	rest = bursted_neighbors[1:]
+        # First, try forming a Pair if the neighbor is a NonInteractionSingle.
+        if isinstance(closest, NonInteractionSingle):
+            domain = self.form_pair(single, singlepos, closest, rest)
+            if domain:
+                return domain
 
         # If a Pair is not formed, then try forming a Multi.
-        obj = self.form_multi(single, neighbors, dists)
-        if obj:
-            return obj
+        domain = self.form_multi(single, bursted_neighbors, dists)
+        if domain:
+            return domain
+#	else:
+#	    raise RuntimeError('All bursted neighbors should be Multis or NonInteractionSingles.')
 
-	
 
     def form_interaction(self, single, surface, burst):
         # Try to form an interaction between the 'single' particle and the 'surface'.
@@ -1865,7 +1877,7 @@ def form_multi(self, single, neighbors, dists):
         closest = neighbors[0]
 
         # if the closest to this Single is a Single, create a new Multi
-        if isinstance(closest, Single):
+        if isinstance(closest, NonInteractionSingle):
 
             multi = self.create_multi()
             self.add_to_multi(single, multi)
@@ -1899,7 +1911,7 @@ def form_multi(self, single, neighbors, dists):
 
 
     def add_to_multi_recursive(self, domain, multi):
-        if isinstance(domain, Single):
+        if isinstance(domain, NonInteractionSingle):
             if multi.has_particle(domain.pid_particle_pair[0]):
                 # Already in the Multi.
                 return

From a9dd44107dc7ed22681a9fea7ebf73915036d1c8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 31 Aug 2011 19:12:37 +0200
Subject: [PATCH 0148/1541] MULTI_SHELL_FACTOR has now similar meaning as
 SINGLE_SHELL_FACTOR

---
 egfrd.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index dfadad8f..7b961528 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -148,7 +148,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.shell_id_generator = ShellIDGenerator(0)
 
 	# some constants
-        self.MULTI_SHELL_FACTOR = 0.05
+        self.MULTI_SHELL_FACTOR = 1.05
         self.SINGLE_SHELL_FACTOR = 2.0
 	self.MAX_NUM_DT0_STEPS = 10000
         self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
@@ -1028,11 +1028,13 @@ def fire_single(self, single):
         self.update_single(single, closest, closest_distance)
         self.add_domain_event(single)
 
-	# Then resize all the bursted domains -> WHY NOT LET THE SCHEDULER HANDLE THIS?
+	# Then resize all the bursted domains. This is done here because
+	# NonInteractionSingles are special. The shell size can be smaller
+	# than min_shell_size
         if burst:
             burst = uniq(burst)
             for s in burst:
-                if not isinstance(s, Single):
+                if not isinstance(s, NonInteractionSingle):
                     continue
 
                 assert s.is_reset()
@@ -1867,7 +1869,7 @@ def form_pair(self, single1, pos1, single2, burst):
     def form_multi(self, single, neighbors, dists):
 
         min_shell = single.pid_particle_pair[1].radius * \
-                    (1.0 + self.MULTI_SHELL_FACTOR)
+                    self.MULTI_SHELL_FACTOR
         # Multis shells need to be contiguous.
         if dists[0] > min_shell:
             return None
@@ -1923,7 +1925,7 @@ def add_to_multi_recursive(self, domain, multi):
             self.remove_event(domain)
 
             radius = domain.pid_particle_pair[1].radius * \
-                (1.0 + self.MULTI_SHELL_FACTOR)
+                self.MULTI_SHELL_FACTOR
             neighbors = self.get_neighbors_within_radius_no_sort(
                     objpos, radius, ignore=[domain.domain_id])
 
@@ -1961,7 +1963,7 @@ def add_to_multi(self, single, multi):
             multi.domain_id,
             single.pid_particle_pair[1].position,
             single.pid_particle_pair[1].radius * \
-                (1.0 + self.MULTI_SHELL_FACTOR))
+                self.MULTI_SHELL_FACTOR)
         multi.add_shell(sid_shell_pair)
         multi.add_particle(single.pid_particle_pair)
 

From 5bedd616a027e5fb5c92506287e88d541e698658 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Sep 2011 16:18:44 +0200
Subject: [PATCH 0149/1541] some initial changes to prepare for cleanup of
 domain making

---
 egfrd.py | 86 ++++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 59 insertions(+), 27 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7b961528..a8ba1e5f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -148,14 +148,14 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.shell_id_generator = ShellIDGenerator(0)
 
 	# some constants
-        self.MULTI_SHELL_FACTOR = 1.05
-        self.SINGLE_SHELL_FACTOR = 2.0
+        self.MULTI_SHELL_FACTOR = 1.05		# This is the threshold for when the algorithm switches from
+						# NonInteractionSingles to a Multi and also defines the Multi
+						# shell size.
+        self.SINGLE_SHELL_FACTOR = 2.0		# This is the threshold for when the algorithm switches from
+						# NonInteractionSingles to a Pair or Interaction. It also defines
+						# the radius in which the NonInteractionSingle will burst.
 	self.MAX_NUM_DT0_STEPS = 10000
         self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
-	self.SURFACE_BARRIER = 1e-8		# This is the distance that cytosolic shells should at least have
-						# when not attempting an interaction with the surface.
-						# This should be at least as big as the largest particle on the surface
-	self.SURFACE_HORIZON = 3e-8		# distance to a surface when it should starting trying to make an interaction
 
 	# used datastructrures
         self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
@@ -709,10 +709,10 @@ def clear_volume(self, pos, radius, ignore=[]):
                                                              ignore)
         return self.burst_objs(neighbors)
 
-    def burst_non_multis(self, neighbors):
+    def burst_non_multis(self, domains):
         bursted = []
 
-        for domain in neighbors:
+        for domain in domains:
             if not isinstance(domain, Multi):
 		# domain is Single or Pair of some subclass
                 single_list = self.burst_domain(domain)
@@ -964,19 +964,29 @@ def fire_single(self, single):
 
             return
 
+	self.make_new_domain(single)
+	return
 
-	### 2. Now make a new domain
-        # (2) Clear volume.
 
-        singlepos = single.shell.shape.position
+    def make_new_domain(self, single):
+	### Make a new domain
 
-	# 2.1 First check if there are shells with a radius of min_shell
-	#     of the particle (intruders)
-        min_shell = single.pid_particle_pair[1].radius * \
-                    self.SINGLE_SHELL_FACTOR
+	# can only make new domain from NonInteractionSingle
+	assert isinstance(single, NonInteractionSingle)
 
+	# 2.1
+	# We prefer to make NonInteractionSingles for efficiency.
+	# But if objects (Shells and surfaces) get close enough we want to
+	# try Interaction and/or Pairs
+
+	# Check if there are shells with the burst radius
+	# of the particle (intruders).
+        reaction_threshold = single.pid_particle_pair[1].radius * \
+                             self.SINGLE_SHELL_FACTOR
+
+        singlepos = single.shell.shape.position
         intruders, closest, closest_distance = \
-            self.get_intruders(singlepos, min_shell,
+            self.get_intruders(singlepos, reaction_threshold,
                                ignore=[single.domain_id, ])
 
         if __debug__:
@@ -984,7 +994,12 @@ def fire_single(self, single):
                       (', '.join(str(i) for i in intruders),
                        closest, FORMAT_DOUBLE % closest_distance))
 
-        # 2.2 Burst the intruders if present.
+
+        # 2.2 Burst the shells with the following conditions
+	# -shell is in the burst radius (intruder)
+	# -shell is not newly made
+	# -shell is burstable (not Multi)
+	# -shell is not already a zero shell (just bursted)
         if intruders:
             burst = self.burst_non_multis(intruders)
 	    # burst now contains all the Domains resulting from the burst.
@@ -993,14 +1008,32 @@ def fire_single(self, single):
             burst = None
 
 
+	# 2.3 get the closest object
+        closest, closest_distance = \
+        self.get_closest_obj(singlepos, ignore=[single.domain_id],
+                             ignores=[single.structure.id])
+	# 2.4 check that the object is a potential partner for an
+	# -Interaction 	(a surface)
+	# -Pair		(a zero dt NonInteractionSingle)
+	# -Multi	(a zero dt NonInteractionSingle or Multi)
+	if isinstance(closest, NonInteractionSingle) or \
+	   isinstance(closest, Multi):
+	    # try the fancy stuff
+	    pass
+	else:
+	    # just make a normal NonInteractionSingle
+	    pass
+
+
 
         # 2.3 Check if there is a surface within min_shell 
         # Only relevant when the particle lives in the "world" or other 3D region.
-        if isinstance(single.structure, CuboidalRegion):
+        if isinstance(single, SphericalSingle):
+	    interaction_horizon = reaction_threshold
             closest_surface, surface_distance = \
                 get_closest_surface(self.world, singlepos, ignore=[single.structure.id])
-	    # 2.3.1 If there is a surface within min_shell -> try interaction
-	    if surface_distance < min_shell:
+	    # 2.3.1 If there is a surface within the interaction horizon -> try interaction
+	    if surface_distance < interaction_horizon:
                 domain = self.form_interaction(single, closest_surface, burst)
                 if domain:
                     return
@@ -1029,7 +1062,9 @@ def fire_single(self, single):
         self.add_domain_event(single)
 
 	# Then resize all the bursted domains. This is done here because
-	# NonInteractionSingles are special. The shell size can be smaller
+	# NonInteractionSingles are special since they can burst. Not doing
+	# it here can result in 'flip-flop'-ing.
+	# The shell size can be smaller
 	# than min_shell_size
         if burst:
             burst = uniq(burst)
@@ -1051,12 +1086,6 @@ def fire_single(self, single):
                               (s, FORMAT_DOUBLE % s.shell.shape.radius,
                                FORMAT_DOUBLE % s.dt, closest,
                                FORMAT_DOUBLE % closest_distance))
-
-#        else:
-#            if closest_surface and surface_distance < closest_distance:
-#                closest = closest_surface
-#                closest_distance = surface_distance - self.SURFACE_BARRIER
-#            self.update_single(single, closest, closest_distance)
             
         if __debug__:
             log.info('updated shell: (%s,\n  Shell(%s, %s)' %
@@ -1879,6 +1908,7 @@ def form_multi(self, single, neighbors, dists):
         closest = neighbors[0]
 
         # if the closest to this Single is a Single, create a new Multi
+	# TODO code duplication below -> FIXME
         if isinstance(closest, NonInteractionSingle):
 
             multi = self.create_multi()
@@ -2017,6 +2047,8 @@ def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
 
     def get_intruders(self, position, radius, ignore):
 	# gets the intruders in a spherical volume of radius 'radius'?
+	# TODO make this surface specific -> in 2D only need to check in cylinder,
+	# not in sphere
         intruders = []   		# intruders are domains within radius
         closest_domain = None		# closest domain, excluding intruders.
         closest_distance = numpy.inf	# distance to the shell of the closest domain.

From b2064265a3ff661de1a1aa698ac200530141d7b7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 6 Sep 2011 18:32:22 +0200
Subject: [PATCH 0150/1541] added some comments

---
 egfrd.py | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a8ba1e5f..ad9cd18b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -969,18 +969,19 @@ def fire_single(self, single):
 
 
     def make_new_domain(self, single):
-	### Make a new domain
+	### Make a new domain out of a NonInteractionSingle that was
+	### just fired
 
 	# can only make new domain from NonInteractionSingle
 	assert isinstance(single, NonInteractionSingle)
-
+	
 	# 2.1
 	# We prefer to make NonInteractionSingles for efficiency.
-	# But if objects (Shells and surfaces) get close enough we want to
-	# try Interaction and/or Pairs
+	# But if objects (Shells and surfaces) get close enough (closer than
+	# reaction_threshold) we want to try Interaction and/or Pairs
 
-	# Check if there are shells with the burst radius
-	# of the particle (intruders).
+	# Check if there are shells with the burst radius (reaction_threshold)
+	# of the particle (these are intruders).
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
@@ -1749,8 +1750,6 @@ def form_pair(self, single1, pos1, single2, burst):
 
         # 2. Check if min shell size for the Pair not larger than max shell size or 
         # sim cell size.
-        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-        com = self.world.apply_boundary(com)
         min_shell_size_with_margin = min_shell_size + shell_size_margin
         max_shell_size = min(self.get_max_shell_size(),
                              distance_from_sigma * 100 +
@@ -1766,6 +1765,10 @@ def form_pair(self, single1, pos1, single2, burst):
                            FORMAT_DOUBLE % max_shell_size))
             return None
 
+
+	### Now check for the max size of the shell that we can make (dimension dependent)
+
+
         # 3. Check if bursted Singles can still make a minimal shell.
         # The simple check for closest below could miss
         # some of them, because sizes of these Singles for this
@@ -1773,6 +1776,8 @@ def form_pair(self, single1, pos1, single2, burst):
         # these burst objects have zero mobility radii.  This is not
         # beautiful, a cleaner framework may be possible.
 
+        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = self.world.apply_boundary(com)
         closest, closest_shell_distance = None, numpy.inf
         for b in burst:
             if isinstance(b, Single):

From 2e864fdf3289e6344b29a648ca1db3f5dfa8d780 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 7 Sep 2011 15:32:44 +0200
Subject: [PATCH 0151/1541] sizing the NonInteractionSingles is now done
 through the scheduler Bursting of domains is now done with more
 discrimination. We don't burst Multis or domains that were just formed (this
 would mean throwing away the investment of making it). This is implemented by
 not bursting domains were last_time=self.t (the current time) because no
 simulation time has passed.

---
 egfrd.py | 77 ++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 47 insertions(+), 30 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ad9cd18b..556bef89 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -665,9 +665,9 @@ def burst_domain(self, domain):
             bursted = [single1, single2]
         else:  # Multi
 #            bursted = self.burst_multi(domain)
-            bursted = self.break_up_multi(domain)	# Multi's can really be 'bursted' since the
+            bursted = self.break_up_multi(domain)	# Multi's can't really be 'bursted' since the
 							# positions of the particles are known. They
-							# are broken up to singles instead.
+							# are broken up to singles with a dt=0 shell instead.
             self.remove_event(domain)
 
         if __debug__:
@@ -981,7 +981,8 @@ def make_new_domain(self, single):
 	# reaction_threshold) we want to try Interaction and/or Pairs
 
 	# Check if there are shells with the burst radius (reaction_threshold)
-	# of the particle (these are intruders).
+	# of the particle (intruders). Note that we approximate the reaction_volume
+	# with a sphere (should be cylinder for 2D or 1D particle)
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
@@ -998,16 +999,30 @@ def make_new_domain(self, single):
 
         # 2.2 Burst the shells with the following conditions
 	# -shell is in the burst radius (intruder)
-	# -shell is not newly made
 	# -shell is burstable (not Multi)
+	# -shell is not newly made
 	# -shell is not already a zero shell (just bursted)
         if intruders:
-            burst = self.burst_non_multis(intruders)
+#            burst = self.burst_non_multis(intruders)
+	    burst = []
+	    for domain in intruders:
+        	if not isinstance(domain, Multi) and \
+                   not self.t == domain.last_time: # and \
+#		   not domain.dt == 0.0:
+                    # domain is Single or Pair of some subclass
+            	    single_list = self.burst_domain(domain)
+                    burst.extend(single_list)
+                elif isinstance(domain, Multi):
+                    # domain is a Multi
+                    burst.append(domain)
+
 	    # burst now contains all the Domains resulting from the burst.
 	    # These are NonInteractionSingles and Multis
         else:
             burst = None
 
+	# Now compile a list of all potential partners for a Pair or Interaction
+
 
 	# 2.3 get the closest object
         closest, closest_distance = \
@@ -1067,31 +1082,31 @@ def make_new_domain(self, single):
 	# it here can result in 'flip-flop'-ing.
 	# The shell size can be smaller
 	# than min_shell_size
-        if burst:
-            burst = uniq(burst)
-            for s in burst:
-                if not isinstance(s, NonInteractionSingle):
-                    continue
-
-                assert s.is_reset()
-                closest, closest_distance = self.get_closest_obj(
-                    s.shell.shape.position, ignore=[s.domain_id],
-                    ignores=[s.structure.id])
-
-                self.update_single(s, closest, closest_distance)
-                self.update_domain_event(self.t + s.dt, s)
-
-                if __debug__:
-                    log.debug('restore shell %s radius %s dt %s\n'
-                              'closest %s distance %s' %
-                              (s, FORMAT_DOUBLE % s.shell.shape.radius,
-                               FORMAT_DOUBLE % s.dt, closest,
-                               FORMAT_DOUBLE % closest_distance))
+#        if burst:
+#            burst = uniq(burst)
+#            for s in burst:
+#                if not isinstance(s, NonInteractionSingle):
+#                    continue
+
+#                assert s.is_reset()
+#                closest, closest_distance = self.get_closest_obj(
+#                    s.shell.shape.position, ignore=[s.domain_id],
+#                    ignores=[s.structure.id])
+
+#                self.update_single(s, closest, closest_distance)
+#                self.update_domain_event(self.t + s.dt, s)
+
+#                if __debug__:
+#                    log.debug('restore shell %s radius %s dt %s\n'
+#                              'closest %s distance %s' %
+#                              (s, FORMAT_DOUBLE % s.shell.shape.radius,
+#                               FORMAT_DOUBLE % s.dt, closest,
+#                               FORMAT_DOUBLE % closest_distance))
             
-        if __debug__:
-            log.info('updated shell: (%s,\n  Shell(%s, %s)' %
-                     (single.shell_id, single.shell.did,
-                      single.shell.shape.show(PRECISION)))
+#        if __debug__:
+#            log.info('updated shell: (%s,\n  Shell(%s, %s)' %
+#                     (single.shell_id, single.shell.did,
+#                      single.shell.shape.show(PRECISION)))
 
         return
 
@@ -1193,7 +1208,7 @@ def fire_pair(self, pair):
             else:
                 theothersingle = single1
 
-            self.burst_pair(pair)
+            self.burst_pair(pair)	# TODO this should be a propagate -> cleaner
 
             self.add_domain_event(theothersingle)
 
@@ -1349,6 +1364,8 @@ def burst_single(self, single):
         return newsingle
 
     def burst_pair(self, pair):
+	# TODO this should also schedule the resulting Singles and remove the
+	# Pair event -> cleaner
         if __debug__:
             log.debug('burst_pair: %s', pair)
 

From 7a5a3b9d961998c842811e50aa3a061e589fd35b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 7 Sep 2011 19:06:41 +0200
Subject: [PATCH 0152/1541] re-arranged the algorithm that decided on what
 domain to make. Mostly just reshuffeled the code, no real logic changes

---
 egfrd.py | 113 ++++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 92 insertions(+), 21 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 556bef89..55c62465 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -986,9 +986,11 @@ def make_new_domain(self, single):
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
-        singlepos = single.shell.shape.position
+	single_pos = single.pid_particle_pair[1].position
+	single_radius = single.pid_particle_pair[1].radius
+
         intruders, closest, closest_distance = \
-            self.get_intruders(singlepos, reaction_threshold,
+            self.get_intruders(single_pos, reaction_threshold,
                                ignore=[single.domain_id, ])
 
         if __debug__:
@@ -1021,24 +1023,87 @@ def make_new_domain(self, single):
         else:
             burst = None
 
-	# Now compile a list of all potential partners for a Pair or Interaction
 
+	# 2.3 get the closest object (a Domain or surface) which can be a
+	# partner for a new domain. This can be:
+	# zero-shell NonInteractionSingle -> Pair or Multi
+	# Multi -> Multi
+	# Surface -> Interaction
+
+	# Potential partners are for now just the bursted domains
+	partners = burst
+	if partners:
+            # sort partners by distance
+	    dists = self.obj_distance_array(single_pos, partners)
+            if len(dists) >= 2:
+        	n = dists.argsort()
+        	dists = dists.take(n)		# sort the distances using the index
+        	partners = numpy.take(partners, n)	# sort the neighbors using the index
+
+	    closest_domain = partners[0]
+	    domain_distance = dists[0]
+	    rest_domains = partners[1:]
+	    rest_dists = dists[1:]
+	else:
+	    closest_domain = None
+	    domain_distance = numpy.inf
+	    rest_domains = []
+	    rest_dists = []
+	
+	# Potential partners are also surfaces
+        closest_surface, surface_distance = \
+	get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
+
+
+
+	# 2.4 calculate the thresholds (horizons) for trying to form the various domains.
+	# Note that we do not differentiate between directions. This means that we
+	# look around in a sphere, the horizons are spherical
+	surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+	multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
 
-	# 2.3 get the closest object
-        closest, closest_distance = \
-        self.get_closest_obj(singlepos, ignore=[single.domain_id],
-                             ignores=[single.structure.id])
 	# 2.4 check that the object is a potential partner for an
 	# -Interaction 	(a surface)
 	# -Pair		(a zero dt NonInteractionSingle)
 	# -Multi	(a zero dt NonInteractionSingle or Multi)
-	if isinstance(closest, NonInteractionSingle) or \
-	   isinstance(closest, Multi):
-	    # try the fancy stuff
-	    pass
+	if isinstance(closest_domain, NonInteractionSingle) and \
+	   closest_domain.is_reset():
+		pair_horizon = (single_radius + \
+                       closest_domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
+		if domain_distance < pair_horizon:
+	            # try making a Pair (can still be Mixed Pair or Normal Pair)
+		    domain = self.form_pair (single, single_pos, closest_domain, rest_domains)
+		else:
+		    domain = None
+
+	elif isinstance(single, SphericalSingle) and \
+	     surface_distance < domain_distance and \
+	     surface_distance < surface_horizon:
+		# try making an Interaction
+		domain = self.form_interaction (single, closest_surface, partners)
 	else:
-	    # just make a normal NonInteractionSingle
-	    pass
+		domain = None
+
+
+	if not domain:
+	    # No Pair or Interaction could be formed
+	    # Now choose between NonInteractionSingle and Multi
+
+	    if domain_distance > multi_horizon:
+	        # just make a normal NonInteractionSingle
+	        closest_domain, domain_distance = \
+        	    self.get_closest_obj(single_pos, ignore=[single.domain_id],
+                	                 ignores=[single.structure.id])
+	        self.update_single(single, closest_domain, domain_distance)
+	        self.add_domain_event(single)
+	    else:
+		# The closest object was too close to make a NonInteractionSingle
+		    domain = self.form_multi(single, partners, dists)
+
+	return domain
+
+
+
 
 
 
@@ -1047,7 +1112,7 @@ def make_new_domain(self, single):
         if isinstance(single, SphericalSingle):
 	    interaction_horizon = reaction_threshold
             closest_surface, surface_distance = \
-                get_closest_surface(self.world, singlepos, ignore=[single.structure.id])
+                get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
 	    # 2.3.1 If there is a surface within the interaction horizon -> try interaction
 	    if surface_distance < interaction_horizon:
                 domain = self.form_interaction(single, closest_surface, burst)
@@ -1069,10 +1134,13 @@ def make_new_domain(self, single):
             if domain:
                 return
 
+
+
+
         # if nothing was formed, resize the Single shell for the 'current'
 	# domain (the domain that started it all).
         closest, closest_distance = \
-            self.get_closest_obj(singlepos, ignore=[single.domain_id],
+            self.get_closest_obj(single_pos, ignore=[single.domain_id],
                                  ignores=[single.structure.id])
         self.update_single(single, closest, closest_distance)
         self.add_domain_event(single)
@@ -1467,8 +1535,8 @@ def form_pair_or_multi(self, single, bursted_neighbors):
         dists = self.obj_distance_array(singlepos, bursted_neighbors)
         if len(dists) >= 2:
             n = dists.argsort()
-            dists = dists.take(n)
-            bursted_neighbors = numpy.take(bursted_neighbors, n)
+            dists = dists.take(n)			 	 # sort the distances using the index
+            bursted_neighbors = numpy.take(bursted_neighbors, n) # sort the neighbors using the index
 
 
 	domain = None
@@ -2129,12 +2197,15 @@ def get_closest_obj(self, pos, ignore=[], ignores=[]):
         else:
             return closest_domain, closest_distance
 
-    def obj_distance(self, pos, obj):
+    def domain_distance(self, pos, domain):
+	# calculates the shortest distance from 'pos' to A shell (a Multi
+	# can have multiple) of 'domain'.
+	# Note: it returns the distance between pos and the CENTER of the shell
         return min(self.world.distance(shell.shape, pos)
-                   for i, (_, shell) in enumerate(obj.shell_list))
+                   for i, (_, shell) in enumerate(domain.shell_list))
 
-    def obj_distance_array(self, pos, objs):
-        dists = numpy.array([self.obj_distance(pos, obj) for obj in objs])
+    def obj_distance_array(self, pos, domains):
+        dists = numpy.array([self.domain_distance(pos, domain) for domain in domains])
         return dists
             
 

From fb489c1943e5956e15fbe5746bab30b301d7a10c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 7 Sep 2011 19:12:58 +0200
Subject: [PATCH 0153/1541] redundant (old) code deleted

---
 egfrd.py | 109 -------------------------------------------------------
 1 file changed, 109 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 55c62465..a4356a0b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1103,81 +1103,6 @@ def make_new_domain(self, single):
 	return domain
 
 
-
-
-
-
-        # 2.3 Check if there is a surface within min_shell 
-        # Only relevant when the particle lives in the "world" or other 3D region.
-        if isinstance(single, SphericalSingle):
-	    interaction_horizon = reaction_threshold
-            closest_surface, surface_distance = \
-                get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
-	    # 2.3.1 If there is a surface within the interaction horizon -> try interaction
-	    if surface_distance < interaction_horizon:
-                domain = self.form_interaction(single, closest_surface, burst)
-                if domain:
-                    return
-
-        else:
-            # Surfaces are not allowed to touch or overlap.
-            closest_surface = None
-
-
-	# 2.4 If there were bursted Domains (intruders),
-	# try making a Pair or Multi
-        if burst:
-	    # should first check the new distance to the bursted particles
-	    # If they haven't moved to far away, try pair or multi.
-	    # 
-            domain = self.form_pair_or_multi(single, burst)
-            if domain:
-                return
-
-
-
-
-        # if nothing was formed, resize the Single shell for the 'current'
-	# domain (the domain that started it all).
-        closest, closest_distance = \
-            self.get_closest_obj(single_pos, ignore=[single.domain_id],
-                                 ignores=[single.structure.id])
-        self.update_single(single, closest, closest_distance)
-        self.add_domain_event(single)
-
-	# Then resize all the bursted domains. This is done here because
-	# NonInteractionSingles are special since they can burst. Not doing
-	# it here can result in 'flip-flop'-ing.
-	# The shell size can be smaller
-	# than min_shell_size
-#        if burst:
-#            burst = uniq(burst)
-#            for s in burst:
-#                if not isinstance(s, NonInteractionSingle):
-#                    continue
-
-#                assert s.is_reset()
-#                closest, closest_distance = self.get_closest_obj(
-#                    s.shell.shape.position, ignore=[s.domain_id],
-#                    ignores=[s.structure.id])
-
-#                self.update_single(s, closest, closest_distance)
-#                self.update_domain_event(self.t + s.dt, s)
-
-#                if __debug__:
-#                    log.debug('restore shell %s radius %s dt %s\n'
-#                              'closest %s distance %s' %
-#                              (s, FORMAT_DOUBLE % s.shell.shape.radius,
-#                               FORMAT_DOUBLE % s.dt, closest,
-#                               FORMAT_DOUBLE % closest_distance))
-            
-#        if __debug__:
-#            log.info('updated shell: (%s,\n  Shell(%s, %s)' %
-#                     (single.shell_id, single.shell.did,
-#                      single.shell.shape.show(PRECISION)))
-
-        return
-
     def reject_single_reaction(self, single):
         if __debug__:
             log.info('single reaction; placing product failed.')
@@ -1522,40 +1447,6 @@ def propagate_pair(self, pair, dt, event_type):
 
         return single1, single2
 
-    def form_pair_or_multi(self, single, bursted_neighbors):
-    # single is the current single being treated, bursted_neighbors is a list of bursted shells
-    # Note! These are not necessarily its direct neighbors but Pair or Multi can only be made
-    # with Domains that are just bursted.
-        assert bursted_neighbors
-
-        #singlepos = single.shell.shape.position
-        singlepos = single.pid_particle_pair[1].position
-
-        # sort bursted_neighbors by distance
-        dists = self.obj_distance_array(singlepos, bursted_neighbors)
-        if len(dists) >= 2:
-            n = dists.argsort()
-            dists = dists.take(n)			 	 # sort the distances using the index
-            bursted_neighbors = numpy.take(bursted_neighbors, n) # sort the neighbors using the index
-
-
-	domain = None
-	closest = bursted_neighbors[0]
-	rest = bursted_neighbors[1:]
-        # First, try forming a Pair if the neighbor is a NonInteractionSingle.
-        if isinstance(closest, NonInteractionSingle):
-            domain = self.form_pair(single, singlepos, closest, rest)
-            if domain:
-                return domain
-
-        # If a Pair is not formed, then try forming a Multi.
-        domain = self.form_multi(single, bursted_neighbors, dists)
-        if domain:
-            return domain
-#	else:
-#	    raise RuntimeError('All bursted neighbors should be Multis or NonInteractionSingles.')
-
-
     def form_interaction(self, single, surface, burst):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 

From d87094e2186c3321f1a8a6dd30e053ddd2792894 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 8 Sep 2011 14:52:31 +0200
Subject: [PATCH 0154/1541] moved the shell making code in 'form_pair' to
 calculate_simplepair_shell_size form_pair now contains general code for a
 SimplePair or MixedPair, but is still incomplete.

---
 egfrd.py | 387 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 203 insertions(+), 184 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a4356a0b..5947302b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -980,15 +980,15 @@ def make_new_domain(self, single):
 	# But if objects (Shells and surfaces) get close enough (closer than
 	# reaction_threshold) we want to try Interaction and/or Pairs
 
+	single_pos = single.pid_particle_pair[1].position
+	single_radius = single.pid_particle_pair[1].radius
+
 	# Check if there are shells with the burst radius (reaction_threshold)
 	# of the particle (intruders). Note that we approximate the reaction_volume
 	# with a sphere (should be cylinder for 2D or 1D particle)
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
-	single_pos = single.pid_particle_pair[1].position
-	single_radius = single.pid_particle_pair[1].radius
-
         intruders, closest, closest_distance = \
             self.get_intruders(single_pos, reaction_threshold,
                                ignore=[single.domain_id, ])
@@ -1037,8 +1037,8 @@ def make_new_domain(self, single):
 	    dists = self.obj_distance_array(single_pos, partners)
             if len(dists) >= 2:
         	n = dists.argsort()
-        	dists = dists.take(n)		# sort the distances using the index
-        	partners = numpy.take(partners, n)	# sort the neighbors using the index
+        	partners = numpy.take(partners, n)	# sort the potential partners using the index
+        	dists = dists.take(n)			# sort the distances using the index
 
 	    closest_domain = partners[0]
 	    domain_distance = dists[0]
@@ -1072,7 +1072,7 @@ def make_new_domain(self, single):
                        closest_domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
 		if domain_distance < pair_horizon:
 	            # try making a Pair (can still be Mixed Pair or Normal Pair)
-		    domain = self.form_pair (single, single_pos, closest_domain, rest_domains)
+		    domain = self.form_pair (single, closest_domain, rest_domains)
 		else:
 		    domain = None
 
@@ -1112,6 +1112,173 @@ def reject_single_reaction(self, single):
         single.initialize(self.t)
         self.add_domain_event(single)
 
+    def calculate_simplepair_shell_size(self, single1, single2, burst):
+        # 1. Determine min shell size for the SimplePair.
+
+	assert single1.structure == single2.structure
+
+        pos1 = single1.pid_particle_pair[1].position
+        pos2 = single2.pid_particle_pair[1].position
+        radius1 = single1.pid_particle_pair[1].radius
+        radius2 = single2.pid_particle_pair[1].radius
+
+        sigma = radius1 + radius2
+
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
+        D12 = D1 + D2
+
+#        assert (pos1 - single1.shell.shape.position).sum() == 0	# TODO Not sure why this is here
+        r0 = self.world.distance(pos1, pos2)
+        distance_from_sigma = r0 - sigma
+        assert distance_from_sigma >= 0, \
+            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
+            (single1, single2, FORMAT_DOUBLE % distance_from_sigma)
+
+        shell_size1 = r0 * D1 / D12 + radius1
+        shell_size2 = r0 * D2 / D12 + radius2
+        shell_size_margin1 = radius1 * 2
+        shell_size_margin2 = radius2 * 2
+        shell_size_with_margin1 = shell_size1 + shell_size_margin1
+        shell_size_with_margin2 = shell_size2 + shell_size_margin2
+        if shell_size_with_margin1  >= shell_size_with_margin2:
+            min_shell_size = shell_size1
+            shell_size_margin = shell_size_margin1
+        else:
+            min_shell_size = shell_size2
+            shell_size_margin = shell_size_margin2
+
+        # 2. Check if min shell size for the Pair not larger than max shell size or 
+        # sim cell size.
+        min_shell_size_with_margin = min_shell_size + shell_size_margin
+        max_shell_size = min(self.get_max_shell_size(),
+                             distance_from_sigma * 100 +
+                             sigma + shell_size_margin)
+
+        if min_shell_size_with_margin >= max_shell_size:
+            if __debug__:
+                log.debug('%s not formed: min_shell_size %s >='
+                          'max_shell_size %s' %
+                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
+                                             single2.pid_particle_pair[0]),
+                           FORMAT_DOUBLE % min_shell_size_with_margin,
+                           FORMAT_DOUBLE % max_shell_size))
+            return None, None, None
+
+
+        # 3. Check if bursted Singles can still make a minimal shell.
+	# TODO This should be changed to a more general algorithm
+	# that checks if the closest nearest relevant shell is a
+	# NonInteractionSingle or smt else.
+	# Now it only processes the shells that were actually bursted before.
+	#
+	# In case it's a NonInteractionSingle observe a distance of reaction_radius
+	# In case it's smt else no extra distance has to be held
+
+        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = self.world.apply_boundary(com)
+        closest, closest_shell_distance = None, numpy.inf
+        for b in burst:
+            if isinstance(b, Single):
+                bpos = b.shell.shape.position
+                d = self.world.distance(com, bpos) - \
+                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
+                if d < closest_shell_distance:
+                    closest, closest_shell_distance = b, d
+
+        if closest_shell_distance <= min_shell_size_with_margin:
+            if __debug__:
+                log.debug('%s not formed: squeezed by burst neighbor %s' %
+                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
+                                             single2.pid_particle_pair[0]),
+                           closest))
+            return None, None, None
+
+        assert closest_shell_distance > 0
+
+        # 4. Determine shell size and check if closest object not too 
+        # close (squeezing).
+        c, d = self.get_closest_obj(com, ignore=[single1.domain_id,
+                                                 single2.domain_id],
+                                    ignores=[single1.structure.id])
+        if d < closest_shell_distance:
+            closest, closest_shell_distance = c, d
+
+        if __debug__:
+            log.debug('Pair closest neighbor: %s %s, '
+                      'min_shell_with_margin %s' %
+                      (closest, FORMAT_DOUBLE % closest_shell_distance,
+                       FORMAT_DOUBLE % min_shell_size_with_margin))
+
+        assert closest_shell_distance > 0
+
+        if isinstance(closest, Single):
+
+            D_closest = closest.pid_particle_pair[1].D
+            D_tot = D_closest + D12
+            closest_particle_distance = self.world.distance(
+                    com, closest.pid_particle_pair[1].position)
+
+            closest_min_radius = closest.pid_particle_pair[1].radius
+            closest_min_shell = closest_min_radius * self.SINGLE_SHELL_FACTOR
+
+            # options for shell size:
+            # a. ideal shell size
+            # b. closest shell is from a bursted single
+            # c. closest shell is closer than ideal shell size 
+            shell_size = min((D12 / D_tot) *
+                            (closest_particle_distance - min_shell_size 
+                             - closest_min_radius) + min_shell_size,
+                            closest_particle_distance - closest_min_shell,
+                            closest_shell_distance)
+
+            shell_size /= SAFETY
+            assert shell_size < closest_shell_distance
+
+        else:
+            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
+
+            shell_size = closest_shell_distance / SAFETY
+
+        if shell_size <= min_shell_size_with_margin:
+            if __debug__:
+                log.debug('%s not formed: squeezed by %s' %
+                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
+                                             single2.pid_particle_pair[0]),
+                           closest))
+            return None, None, None
+
+
+        # 5. Check if singles would not be better.
+	# TODO clear this up -> strange rule
+        d1 = self.world.distance(com, pos1)
+        d2 = self.world.distance(com, pos2)
+
+        if shell_size < max(d1 + single1.pid_particle_pair[1].radius *
+                            self.SINGLE_SHELL_FACTOR, \
+                            d2 + single2.pid_particle_pair[1].radius * \
+                            self.SINGLE_SHELL_FACTOR) * 1.3:
+            if __debug__:
+                log.debug('%s not formed: singles are better' %
+                          'Pair(%s, %s)' % (single1.pid_particle_pair[0], 
+                                            single2.pid_particle_pair[0]))
+            return None, None, None
+
+        shell_size = min(shell_size, max_shell_size)
+
+        assert closest_shell_distance == numpy.inf or \
+               shell_size < closest_shell_distance
+        assert shell_size >= min_shell_size_with_margin
+        assert shell_size <= max_shell_size
+
+	if __debug__:
+	    log.info('SimplePair shell made. shell_size=%s, '
+                     'closest_shell_distance=%s,\nclosest = %s' %
+                     (FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % closest_shell_distance, closest))
+
+	return com, r0, shell_size
+
+
     def calculate_single_shell_size(self, single, closest, 
                                  distance, shell_distance):
         assert isinstance(closest, Single)
@@ -1677,7 +1844,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
 
         return dr, dz_left, dz_right
 
-    def form_pair(self, single1, pos1, single2, burst):
+    def form_pair(self, single1, single2, burst):
         if __debug__:
            log.debug('trying to form Pair(%s, %s)' %
                      (single1.pid_particle_pair, single2.pid_particle_pair))
@@ -1687,202 +1854,54 @@ def form_pair(self, single1, pos1, single2, burst):
 
         # Try forming a Pair only if singles are on same structure.
         if single1.structure != single2.structure:
+	    # TODO implement shell making method for MixedPair
+
             if __debug__:
                 log.debug('Pair(%s, %s) not formed: not on same structure.' %
                           (single1.pid_particle_pair[0],
                            single2.pid_particle_pair[0]))
-            return None
 
-        # 1. Determine min shell size for the Pair.
-        radius1 = single1.pid_particle_pair[1].radius
-        radius2 = single2.pid_particle_pair[1].radius
-
-        sigma = radius1 + radius2
-
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-        D12 = D1 + D2
-
-        assert (pos1 - single1.shell.shape.position).sum() == 0
-        pos2 = single2.shell.shape.position
-        r0 = self.world.distance(pos1, pos2)
-        distance_from_sigma = r0 - sigma
-        assert distance_from_sigma >= 0, \
-            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
-            (single1, single2, FORMAT_DOUBLE % distance_from_sigma)
-
-        shell_size1 = r0 * D1 / D12 + radius1
-        shell_size2 = r0 * D2 / D12 + radius2
-        shell_size_margin1 = radius1 * 2
-        shell_size_margin2 = radius2 * 2
-        shell_size_with_margin1 = shell_size1 + shell_size_margin1
-        shell_size_with_margin2 = shell_size2 + shell_size_margin2
-        if shell_size_with_margin1  >= shell_size_with_margin2:
-            min_shell_size = shell_size1
-            shell_size_margin = shell_size_margin1
-        else:
-            min_shell_size = shell_size2
-            shell_size_margin = shell_size_margin2
-
-        # 2. Check if min shell size for the Pair not larger than max shell size or 
-        # sim cell size.
-        min_shell_size_with_margin = min_shell_size + shell_size_margin
-        max_shell_size = min(self.get_max_shell_size(),
-                             distance_from_sigma * 100 +
-                             sigma + shell_size_margin)
-
-        if min_shell_size_with_margin >= max_shell_size:
-            if __debug__:
-                log.debug('%s not formed: min_shell_size %s >='
-                          'max_shell_size %s' %
-                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-                                             single2.pid_particle_pair[0]),
-                           FORMAT_DOUBLE % min_shell_size_with_margin,
-                           FORMAT_DOUBLE % max_shell_size))
-            return None
-
-
-	### Now check for the max size of the shell that we can make (dimension dependent)
-
-
-        # 3. Check if bursted Singles can still make a minimal shell.
-        # The simple check for closest below could miss
-        # some of them, because sizes of these Singles for this
-        # distance check has to include SINGLE_SHELL_FACTOR, while
-        # these burst objects have zero mobility radii.  This is not
-        # beautiful, a cleaner framework may be possible.
-
-        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-        com = self.world.apply_boundary(com)
-        closest, closest_shell_distance = None, numpy.inf
-        for b in burst:
-            if isinstance(b, Single):
-                bpos = b.shell.shape.position
-                d = self.world.distance(com, bpos) - \
-                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
-                if d < closest_shell_distance:
-                    closest, closest_shell_distance = b, d
-
-        if closest_shell_distance <= min_shell_size_with_margin:
-            if __debug__:
-                log.debug('%s not formed: squeezed by burst neighbor %s' %
-                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-                                             single2.pid_particle_pair[0]),
-                           closest))
-            return None
-
-        assert closest_shell_distance > 0
-
-        # 4. Determine shell size and check if closest object not too 
-        # close (squeezing).
-        c, d = self.get_closest_obj(com, ignore=[single1.domain_id,
-                                                 single2.domain_id],
-                                    ignores=[single1.structure.id])
-        if d < closest_shell_distance:
-            closest, closest_shell_distance = c, d
-
-        if __debug__:
-            log.debug('Pair closest neighbor: %s %s, '
-                      'min_shell_with_margin %s' %
-                      (closest, FORMAT_DOUBLE % closest_shell_distance,
-                       FORMAT_DOUBLE % min_shell_size_with_margin))
-
-        assert closest_shell_distance > 0
-
-        if isinstance(closest, Single):
-
-            D_closest = closest.pid_particle_pair[1].D
-            D_tot = D_closest + D12
-            closest_particle_distance = self.world.distance(
-                    com, closest.pid_particle_pair[1].position)
-
-            closest_min_radius = closest.pid_particle_pair[1].radius
-            closest_min_shell = closest_min_radius * self.SINGLE_SHELL_FACTOR
-
-            # options for shell size:
-            # a. ideal shell size
-            # b. closest shell is from a bursted single
-            # c. closest shell is closer than ideal shell size 
-            shell_size = min((D12 / D_tot) *
-                            (closest_particle_distance - min_shell_size 
-                             - closest_min_radius) + min_shell_size,
-                            closest_particle_distance - closest_min_shell,
-                            closest_shell_distance)
-
-            shell_size /= SAFETY
-            assert shell_size < closest_shell_distance
-
-        else:
-            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
-
-            shell_size = closest_shell_distance / SAFETY
-
-        if shell_size <= min_shell_size_with_margin:
-            if __debug__:
-                log.debug('%s not formed: squeezed by %s' %
-                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-                                             single2.pid_particle_pair[0]),
-                           closest))
-            return None
-
-
-        # 5. Check if singles would not be better.
-        d1 = self.world.distance(com, pos1)
-        d2 = self.world.distance(com, pos2)
-
-        if shell_size < max(d1 + single1.pid_particle_pair[1].radius *
-                            self.SINGLE_SHELL_FACTOR, \
-                            d2 + single2.pid_particle_pair[1].radius * \
-                            self.SINGLE_SHELL_FACTOR) * 1.3:
-            if __debug__:
-                log.debug('%s not formed: singles are better' %
-                          'Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-                                            single2.pid_particle_pair[0]))
-            return None
+            center, r0, shell_size = None, None, None
+#	    shell = self.make_mixedpair_shell (single1, single2)
+	else:
+	    # particles are on the same structure
+	    center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2, burst)
 
-        # 6. Ok, Pair makes sense. Create one.
-        shell_size = min(shell_size, max_shell_size)
 
-        pair = self.create_pair(single1, single2, com, r0, shell_size)
+	if shell_size:
+            # A shell could be made and makes sense. Create a Pair
+            pair = self.create_pair(single1, single2, center, r0, shell_size)
 
-        pair.dt, pair.event_type, pair.reactingsingle = \
+            pair.dt, pair.event_type, pair.reactingsingle = \
             pair.determine_next_event(r0)
 
-        assert pair.dt >= 0
+            assert pair.dt >= 0
 
-        self.last_time = self.t
+            self.last_time = self.t
 
-        self.remove_domain(single1)
-        self.remove_domain(single2)
+            self.remove_domain(single1)
+            self.remove_domain(single2)
 
-        # single1 will be removed by the scheduler.
-        self.remove_event(single2)
+            # single1 will be removed by the scheduler.
+            self.remove_event(single2)
 
-        assert closest_shell_distance == numpy.inf or \
-               shell_size < closest_shell_distance
-        assert shell_size >= min_shell_size_with_margin
-        assert shell_size <= max_shell_size
+            assert self.check_obj(pair)
+            self.add_domain_event(pair)
 
-        if __debug__:
-            log.info('%s,\ndt=%s, r0=%s, shell_size=%s, '
-                     'closest_shell_distance=%s,\nclosest = %s' %
-                     (pair, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % r0, 
-                      FORMAT_DOUBLE % shell_size, 
-                      FORMAT_DOUBLE % closest_shell_distance, closest))
-
-        assert self.check_obj(pair)
-        self.add_domain_event(pair)
+            if __debug__:
+                log.info('%s,\ndt=%s, r0=%s, shell_size=%s, ' %
+                         (pair, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % r0, 
+                          FORMAT_DOUBLE % shell_size)) 
 
-        return pair
+            return pair
+	else:
+	    return None
     
 
     def form_multi(self, single, neighbors, dists):
-
-        min_shell = single.pid_particle_pair[1].radius * \
-                    self.MULTI_SHELL_FACTOR
-        # Multis shells need to be contiguous.
-        if dists[0] > min_shell:
-            return None
+	# form a Multi with the 'single'
+	# The neighbors are neighboring NonInteractionSingles and Multi which
+	# can be added to the Multi
 
         neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
 

From 45a9c2a5a9fa457298160d9bce38c5a55f5653ac Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 8 Sep 2011 15:05:21 +0200
Subject: [PATCH 0155/1541] Clean form_multi -> removed code duplication

---
 egfrd.py | 46 +++++++++++++++++++++-------------------------
 1 file changed, 21 insertions(+), 25 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 5947302b..21cd4e75 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1905,41 +1905,37 @@ def form_multi(self, single, neighbors, dists):
 
         neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
 
+	# FIXME What if there are no neighbors but a surface?
         closest = neighbors[0]
 
-        # if the closest to this Single is a Single, create a new Multi
-	# TODO code duplication below -> FIXME
-        if isinstance(closest, NonInteractionSingle):
 
+	# 1. Make new Multi if Necessary
+        if isinstance(closest, NonInteractionSingle):
+        # if the closest to this Single is a Single, create a new Multi
             multi = self.create_multi()
-            self.add_to_multi(single, multi)
-            self.remove_domain(single)
-            for neighbor in neighbors:
-                self.add_to_multi_recursive(neighbor, multi)
-
-            multi.initialize(self.t)
-            
-            self.add_domain_event(multi)
-
-            return multi
-
-        # if the closest to this Single is a Multi, reuse the Multi.
         elif isinstance(closest, Multi):
+        # if the closest to this Single is a Multi, reuse the Multi.
+	    multi = closest
+	    neighbors = neighbors[1:]	# the rest of the neighbors are added
+	else:
+            assert False, 'do not reach here'
 
-            multi = closest
-            self.add_to_multi(single, multi)
-            self.remove_domain(single)
-            for neighbor in neighbors[1:]:
-                self.add_to_multi_recursive(neighbor, multi)
-
-            multi.initialize(self.t)
 
-            self.update_domain_event(self.t + multi.dt, multi)
+	# 2. Add the single and neighbors to the Multi
+        self.add_to_multi(single, multi)
+        self.remove_domain(single)
+        for neighbor in neighbors:
+            self.add_to_multi_recursive(neighbor, multi)
 
-            return multi
 
+	# 3. Initialize and (re-)schedule
+        multi.initialize(self.t)
+        if isinstance(closest, NonInteractionSingle):
+            self.add_domain_event(multi)
+        elif isinstance(closest, Multi):
+            self.update_domain_event(self.t + multi.dt, multi)
 
-        assert False, 'do not reach here'
+        return multi
 
 
     def add_to_multi_recursive(self, domain, multi):

From e7b4fdb640a925ff38dd9c2002db47ca03fad3df Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 8 Sep 2011 15:09:43 +0200
Subject: [PATCH 0156/1541] small fix: To form a multi also need to take
 surface into account

---
 egfrd.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 21cd4e75..a94e28fa 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1089,7 +1089,8 @@ def make_new_domain(self, single):
 	    # No Pair or Interaction could be formed
 	    # Now choose between NonInteractionSingle and Multi
 
-	    if domain_distance > multi_horizon:
+	    if domain_distance > multi_horizon and \
+	       surface_distance > multi_horizon:
 	        # just make a normal NonInteractionSingle
 	        closest_domain, domain_distance = \
         	    self.get_closest_obj(single_pos, ignore=[single.domain_id],
@@ -1098,7 +1099,7 @@ def make_new_domain(self, single):
 	        self.add_domain_event(single)
 	    else:
 		# The closest object was too close to make a NonInteractionSingle
-		    domain = self.form_multi(single, partners, dists)
+		    domain = self.form_multi(single, partners, dists, closest_surface, surface_distance)
 
 	return domain
 
@@ -1898,7 +1899,7 @@ def form_pair(self, single1, single2, burst):
 	    return None
     
 
-    def form_multi(self, single, neighbors, dists):
+    def form_multi(self, single, neighbors, dists, surface, surface_dist):
 	# form a Multi with the 'single'
 	# The neighbors are neighboring NonInteractionSingles and Multi which
 	# can be added to the Multi

From 9ae58ae92947feb670b4e839356a32ba0b519695 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 8 Sep 2011 15:35:18 +0200
Subject: [PATCH 0157/1541] fixed form_multi to also work with just one
 particle Needed when single particle is close to a surface and an Interaction
 has failed

---
 egfrd.py | 41 ++++++++++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 17 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a94e28fa..0d4d1c40 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1032,6 +1032,8 @@ def make_new_domain(self, single):
 
 	# Potential partners are for now just the bursted domains
 	partners = burst
+
+	dists = []
 	if partners:
             # sort partners by distance
 	    dists = self.obj_distance_array(single_pos, partners)
@@ -1099,7 +1101,7 @@ def make_new_domain(self, single):
 	        self.add_domain_event(single)
 	    else:
 		# The closest object was too close to make a NonInteractionSingle
-		    domain = self.form_multi(single, partners, dists, closest_surface, surface_distance)
+		    domain = self.form_multi(single, partners, dists)
 
 	return domain
 
@@ -1899,27 +1901,32 @@ def form_pair(self, single1, single2, burst):
 	    return None
     
 
-    def form_multi(self, single, neighbors, dists, surface, surface_dist):
+    def form_multi(self, single, neighbors, dists):
 	# form a Multi with the 'single'
-	# The neighbors are neighboring NonInteractionSingles and Multi which
+	# The 'neighbors' are neighboring NonInteractionSingles and Multi which
 	# can be added to the Multi
-
-        neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
-
-	# FIXME What if there are no neighbors but a surface?
-        closest = neighbors[0]
+	# 'dists' are the distances of the 'neighbors'
+
+	# Filter out relevant neighbors if present
+	if neighbors:
+	# only consider neighboring domains that are within the Multi horizon
+	    min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+            neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
+            closest = neighbors[0]
+	else:
+	    neighbors = []
+	    closest = None
 
 
 	# 1. Make new Multi if Necessary
-        if isinstance(closest, NonInteractionSingle):
-        # if the closest to this Single is a Single, create a new Multi
-            multi = self.create_multi()
-        elif isinstance(closest, Multi):
+        if isinstance(closest, Multi):
         # if the closest to this Single is a Multi, reuse the Multi.
 	    multi = closest
 	    neighbors = neighbors[1:]	# the rest of the neighbors are added
-	else:
-            assert False, 'do not reach here'
+        else: 
+        # the closest is not a Multi. Can be NonInteractionSingle, surface or
+	# nothing. Create new Multi
+            multi = self.create_multi()
 
 
 	# 2. Add the single and neighbors to the Multi
@@ -1931,10 +1938,10 @@ def form_multi(self, single, neighbors, dists, surface, surface_dist):
 
 	# 3. Initialize and (re-)schedule
         multi.initialize(self.t)
-        if isinstance(closest, NonInteractionSingle):
-            self.add_domain_event(multi)
-        elif isinstance(closest, Multi):
+        if isinstance(closest, Multi):
             self.update_domain_event(self.t + multi.dt, multi)
+	else:
+            self.add_domain_event(multi)
 
         return multi
 

From bbf88ef6cefd28d409042126d3a611d3437b5dd5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 8 Sep 2011 16:20:38 +0200
Subject: [PATCH 0158/1541] fixed function signature of create_interaction

---
 egfrd.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0d4d1c40..f8dbfd4c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1617,7 +1617,7 @@ def propagate_pair(self, pair, dt, event_type):
 
         return single1, single2
 
-    def form_interaction(self, single, surface, burst):
+    def form_interaction(self, single, surface, neighbors):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 
         particle = single.pid_particle_pair[1]
@@ -1682,7 +1682,7 @@ def form_interaction(self, single, surface, burst):
                                             particle_distance,
                                             orientation_vector,
                                             dr, dz_left, dz_right,
-                                            burst)
+                                            neighbors)
         dr /= SAFETY
         dz_left /= SAFETY
         dz_right /= SAFETY
@@ -1709,12 +1709,12 @@ def form_interaction(self, single, surface, burst):
         radius = dr + particle_distance
 
 
+###
 
-        interaction = self.create_interaction(single, surface,
-                                              projected_point, 
-                                              particle_distance,
-                                              orientation_vector, 
-                                              dr, dz_left, dz_right)
+
+        interaction = self.create_interaction(particle, surface,
+					      origin, radius, half_length,
+					      orientation_vector)
 
         # Below here similar as in fire_pair after creating a pair.
         interaction.dt, interaction.event_type, = \
@@ -1739,7 +1739,7 @@ def form_interaction(self, single, surface, burst):
 
     def determine_optimal_cylinder(self, single, surface, projected_point, 
                                    particle_distance, orientation_vector,
-                                   dr, dz_left, dz_right, burst):
+                                   dr, dz_left, dz_right, neighbors):
         # Find optimal cylinder around particle and surface, such that 
         # it is not interfering with other shells.
         # Todo. Finding all spheres and cylinders in the matrixspace 
@@ -1847,6 +1847,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
 
         return dr, dz_left, dz_right
 
+
     def form_pair(self, single1, single2, burst):
         if __debug__:
            log.debug('trying to form Pair(%s, %s)' %

From f35ac97f8b493258e3d05209cf88dc958c8476ad Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Sep 2011 15:43:48 +0200
Subject: [PATCH 0159/1541] shell parameters from determine_optimal_cylinder
 for interaction now correctly processed

---
 egfrd.py  | 77 +++++++++++++++++++++++++++++++------------------------
 single.py | 36 ++------------------------
 2 files changed, 46 insertions(+), 67 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f8dbfd4c..9e122ec8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -57,35 +57,38 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure)
                                    shell_id, rt, structure)
 
 
-def create_default_interaction(domain_id, pid_particle_pair, shell_id,
-                               reaction_rules, interaction_rules, surface,
-                               projected_point, particle_distance, 
-                               orientation_vector, dr, dz_left, dz_right):
+def create_default_interaction(domain_id, pid_particle_pair, reaction_rules, structure,
+                               shell_id, shell_center, shell_radius,
+			       shell_half_length, shell_unit_z,
+                               surface, interaction_rules):
     # surface is the surface with which the interaction is made
 
+    # These calculation should be closer to the Green's functions, i.e. in the
+    # PlanarSurfaceInteraction constructor but can not be performed there because
+    # it doesn't know about the world size of cyclic boundary conditions.
+    particle_pos = pid_particle_pair[1].position
+
     if isinstance(surface, CylindricalSurface):
-	# Only needed for this type of Interaction.
-	# TODO make sure the periodic boundary conditions don't spoil this
-        unit_r = normalize(pid_particle_pair[1].position - projected_point)
+	particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
+	projected_point, r0 = surface.projected_point(particle_pos)
+        shell_unit_r = normalize(particle_pos - projected_point)
+
+	z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
 
         return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
                                              reaction_rules, structure,
 					     shell_id, shell_center, shell_radius,
-					     shell_half_length, shell_orientation_vector,
-					     r0, unit_r, interaction_rules, surface)
-#                                             projected_point, particle_distance,
-#                                             orientation_vector,
-#                                             dr, dz_left, dz_right)
+					     shell_half_length, shell_unit_z, z0,
+					     shell_unit_r, r0, interaction_rules, surface)
     elif isinstance(surface, PlanarSurface):
+        particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
+	z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
+
         return PlanarSurfaceInteraction(domain_id, pid_particle_pair,
                                         reaction_rules, structure,
 					shell_id, shell_center, shell_radius,
-					shell_half_length, orientation_vector,
+					shell_half_length, shell_unit_z,
 					z0, interaction_rules, surface)
-#                                        interaction_type, surface,
-#                                        projected_point, particle_distance, 
-#                                        orientation_vector,
-#                                        dr, dz_left, dz_right)
 
 
 def create_default_pair(domain_id, com, single1, single2, shell_id, 
@@ -442,18 +445,20 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
         shell_id = self.shell_id_generator()
 
         species_id = pid_particle_pair[1].sid
+	species = self.world.get_species(species_id)
+
         reaction_types = self.network_rules.query_reaction_rule(species_id)
         #interaction_type = self.query_interaction_rule(species_id, surface)
         # TODO.
         interaction_type = None
+        structure = self.world.get_structure(species.structure_id)
 
 	# 2. create and register the proper domain object
         interaction = \
-            create_default_interaction(domain_id, pid_particle_pair, structure,
-                                       reaction_types, interaction_type,
-                                       surface, shell_id, shell_center,
-				       shell_radius, shell_length,
-                                       orientation_vector)
+            create_default_interaction(domain_id, pid_particle_pair, reaction_types,
+                                       structure, shell_id, shell_center,
+				       shell_radius, shell_length, orientation_vector,
+				       surface, interaction_type)
         assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
         self.domains[domain_id] = interaction
@@ -1621,12 +1626,15 @@ def form_interaction(self, single, surface, neighbors):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 
         particle = single.pid_particle_pair[1]
+
+	# calculate the Projected_point and distance to the surface
         # Cyclic transpose needed when calling surface.projected_point!
         pos_transposed = self.world.cyclic_transpose(particle.position, 
                                                      surface.shape.position) 
         projected_point, projection_distance = \
                 surface.projected_point(pos_transposed)
 
+	# projection_distance is relative to the unit_z of the surface -> can be negative
         particle_distance = abs(projection_distance)
 
         # For interaction with a planar surface, decide orientation. 
@@ -1681,8 +1689,7 @@ def form_interaction(self, single, surface, neighbors):
                                             projected_point,
                                             particle_distance,
                                             orientation_vector,
-                                            dr, dz_left, dz_right,
-                                            neighbors)
+                                            dr, dz_left, dz_right)
         dr /= SAFETY
         dz_left /= SAFETY
         dz_right /= SAFETY
@@ -1700,16 +1707,19 @@ def form_interaction(self, single, surface, neighbors):
                            dz_right, min_dz_right))
             return None
 
-	# FIXME For cylinder only?
         # Compute origin, radius and half_length of cylinder.
-        # This stuff is complicated. 
-        half_length = (dz_left + dz_right) / 2
-        shiftZ = half_length - dz_left
-        origin = projected_point + shiftZ * orientation_vector
-        radius = dr + particle_distance
-
+	# TODO slightly change dz, dr framework. See notes.
+        if isinstance(surface, PlanarSurface):
+#            half_length = (dz_left + dz_right) / 2.0
+            half_length = (dz_left + particle_distance + dz_right) / 2.0
+            radius = dr
+            origin = projected_point + (half_length - dz_left) * orientation_vector
 
-###
+        elif isinstance(surface, CylindricalSurface):
+	    half_length = (dz_left + dz_right) / 2.0
+#            radius = dr 
+            radius = dr + particle_distance
+	    origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
 
 
         interaction = self.create_interaction(particle, surface,
@@ -1739,11 +1749,12 @@ def form_interaction(self, single, surface, neighbors):
 
     def determine_optimal_cylinder(self, single, surface, projected_point, 
                                    particle_distance, orientation_vector,
-                                   dr, dz_left, dz_right, neighbors):
+                                   dr, dz_left, dz_right):
         # Find optimal cylinder around particle and surface, such that 
         # it is not interfering with other shells.
         # Todo. Finding all spheres and cylinders in the matrixspace 
         # should be sufficient, but domain information is now used for 
+	#
         # get_shell_size is overridden for cylindrical singles and 
         # pairs.
         all_neighbors = \
diff --git a/single.py b/single.py
index 08a71158..a5ba736a 100644
--- a/single.py
+++ b/single.py
@@ -456,38 +456,6 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
 	self.shell = self.create_new_shell(self, shell_center, shell_radius, 
 					   shell_orientation_vector, shell_half_length)
 
-
-
-#        # Compute from dr, dz_left and dz_right the length of the new 
-#        # domain (only that part of the cylinder where the particle can 
-#        # diffuse to) and the radius and half_length of the new 
-#        # cylinder.
-#
-#        # a
-#        # what is here sigma?
-#        sigma = self.surface.shape.Lz + self.pid_particle_pair[1].radius
-#        # r0
-#        if isinstance(surface, PlanarSurface):
-#            # Heads up: length of domain (the part of the cylinder 
-#            # where the particle can get) is a bit different from the 
-#            # length of the cylinder because of dz_left.
-#            # Assume surface.Lz == 0
-#            length_of_domain = particle_distance + dz_right
-#            radius = dr
-#            half_length = (particle_distance + dz_left + dz_right) / 2
-#
-#        # TODO. This is not correct anymore.
-#        if isinstance(surface, PlanarSurface):
-#            # Compute new particle offset relative to origin of the 
-#            # domain in the z-direction (z=0).
-#            # The surface boundary is at z=-length_of_domain / 2, the 
-#            # other end in the middles*at* the surface boundary. (z=L) 
-#            # is at the end of the cylinder.
-#            # (min_radius correction in the constructor).
-#            particle_offset = [0, particle_distance - length_of_domain.Lz]
-
-
-
     def get_inner_dz_right(self):
 	# This is the distance the particle can travel from its initial position
 	# to the flat boundary away from the surface
@@ -579,8 +547,8 @@ class CylindricalSurfaceInteraction(InteractionSingle):
 
     """
     def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
-		 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector,
-		 r0, unit_r, interactionrules, surface):
+		 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
+		 unit_r, r0, interactionrules, surface):
 
         InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
 				   structure, shell_id, interactionrules, surface)

From 9bacb7b5b3a3d8e047c5405a306682f480fc1a6f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Sep 2011 18:00:29 +0200
Subject: [PATCH 0160/1541] fixed typos in PlanarSurfaceInteraction

---
 single.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/single.py b/single.py
index a5ba736a..4d1b5f02 100644
--- a/single.py
+++ b/single.py
@@ -453,7 +453,7 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
 	# z0 is the initial position of the particle relative to the center
 	# of the shell in the direction normal to the surface.
 	self.z0 = z0
-	self.shell = self.create_new_shell(self, shell_center, shell_radius, 
+	self.shell = self.create_new_shell(shell_center, shell_radius, 
 					   shell_orientation_vector, shell_half_length)
 
     def get_inner_dz_right(self):
@@ -466,7 +466,7 @@ def get_inner_dz_left(self):
 	# Note that it is implied that the shell sticks out at the other end
 	# of the planar surface by the particle radius, and that the surface
 	# has no thickness.
-	dist_to_surface = self.shell.half_length - self.pid_particle_pair[1].radius
+	dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair[1].radius
 	return dist_to_surface - self.pid_particle_pair[1].radius
 
     def greens_function(self):
@@ -478,7 +478,9 @@ def iv_greens_function(self):
 	# The green's function that also modelles the association of the particle
 	# with the planar surface.
 	# TODO choose interactionrule
-        return GreensFunction1DRadAbs(self.D, self.interactionrule.k, self.z0,
+#        return GreensFunction1DRadAbs(self.D, self.interactionrule.k, self.z0,
+#				      self.get_inner_dz_left(), self.get_inner_dz_right())
+        return GreensFunction1DRadAbs(self.D, 1e-8, self.z0,
 				      self.get_inner_dz_left(), self.get_inner_dz_right())
 
     def draw_new_position(self, dt, event_type):
@@ -500,8 +502,8 @@ def draw_new_position(self, dt, event_type):
 		gf = self.greens_function()
         	r = draw_r_wrapper(gf, dt, a)
 
-	    x, y = randomVector2D(r)
-	    vector_r = x * self.surface.unitX + y * self.surface.unitY
+	    x, y = random_vector2D(r)
+	    vector_r = x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
 
 	    # calculate z vector
             # Todo. Cartesian coordinate will return absolute position.
@@ -558,7 +560,7 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
 	self.unit_r = unit_r	# This is the vector from the cylinder to the particle
 	self.r0 = r0		# r0 is the distance from the center of the cylinder to the
 				# center of the particle
-        self.shell = self.create_new_shell(self, shell_center, shell_radius,
+        self.shell = self.create_new_shell(shell_center, shell_radius,
                                            shell_orientation_vector, shell_half_length)
 
 

From 413f30f54565ffe6a5277a659b453cc2f9a0850c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Sep 2011 18:00:56 +0200
Subject: [PATCH 0161/1541] moved Interaction selection mechanism from general
 function to create_interaction method

---
 egfrd.py | 125 +++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 80 insertions(+), 45 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9e122ec8..807a21fd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -57,38 +57,38 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure)
                                    shell_id, rt, structure)
 
 
-def create_default_interaction(domain_id, pid_particle_pair, reaction_rules, structure,
-                               shell_id, shell_center, shell_radius,
-			       shell_half_length, shell_unit_z,
-                               surface, interaction_rules):
-    # surface is the surface with which the interaction is made
-
-    # These calculation should be closer to the Green's functions, i.e. in the
-    # PlanarSurfaceInteraction constructor but can not be performed there because
-    # it doesn't know about the world size of cyclic boundary conditions.
-    particle_pos = pid_particle_pair[1].position
-
-    if isinstance(surface, CylindricalSurface):
-	particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
-	projected_point, r0 = surface.projected_point(particle_pos)
-        shell_unit_r = normalize(particle_pos - projected_point)
-
-	z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
-
-        return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
-                                             reaction_rules, structure,
-					     shell_id, shell_center, shell_radius,
-					     shell_half_length, shell_unit_z, z0,
-					     shell_unit_r, r0, interaction_rules, surface)
-    elif isinstance(surface, PlanarSurface):
-        particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
-	z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
-
-        return PlanarSurfaceInteraction(domain_id, pid_particle_pair,
-                                        reaction_rules, structure,
-					shell_id, shell_center, shell_radius,
-					shell_half_length, shell_unit_z,
-					z0, interaction_rules, surface)
+#def create_default_interaction(domain_id, pid_particle_pair, reaction_rules, structure,
+#                               shell_id, shell_center, shell_radius,
+#			       shell_half_length, shell_unit_z,
+#                               surface, interaction_rules):
+#    # surface is the surface with which the interaction is made
+#
+#    # These calculation should be closer to the Green's functions, i.e. in the
+#    # PlanarSurfaceInteraction constructor but can not be performed there because
+#    # it doesn't know about the world size of cyclic boundary conditions.
+#    particle_pos = pid_particle_pair[1].position
+#
+#    if isinstance(surface, CylindricalSurface):
+#	particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
+#	projected_point, r0 = surface.projected_point(particle_pos)
+#        shell_unit_r = normalize(particle_pos - projected_point)
+#
+#	z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
+#
+#        return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
+#                                             reaction_rules, structure,
+#					     shell_id, shell_center, shell_radius,
+#					     shell_half_length, shell_unit_z, z0,
+#					     shell_unit_r, r0, interaction_rules, surface)
+#    elif isinstance(surface, PlanarSurface):
+#        particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
+#	z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
+#
+#        return PlanarSurfaceInteraction(domain_id, pid_particle_pair,
+#                                        reaction_rules, structure,
+#					shell_id, shell_center, shell_radius,
+#					shell_half_length, shell_unit_z,
+#					z0, interaction_rules, surface)
 
 
 def create_default_pair(domain_id, com, single1, single2, shell_id, 
@@ -434,7 +434,7 @@ def create_single(self, pid_particle_pair):
         return single
 
     def create_interaction(self, pid_particle_pair, surface, shell_center,
-			   shell_radius, shell_length, orientation_vector):
+			   shell_radius, shell_half_length, shell_unit_z):
 
 ##        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
 #	assert that the particle is not already associate with another domain
@@ -447,18 +447,50 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
         species_id = pid_particle_pair[1].sid
 	species = self.world.get_species(species_id)
 
-        reaction_types = self.network_rules.query_reaction_rule(species_id)
+        reaction_rules = self.network_rules.query_reaction_rule(species_id)
         #interaction_type = self.query_interaction_rule(species_id, surface)
         # TODO.
-        interaction_type = None
+        interaction_rules = None
         structure = self.world.get_structure(species.structure_id)
 
 	# 2. create and register the proper domain object
-        interaction = \
-            create_default_interaction(domain_id, pid_particle_pair, reaction_types,
-                                       structure, shell_id, shell_center,
-				       shell_radius, shell_length, orientation_vector,
-				       surface, interaction_type)
+#        interaction = \
+#            create_default_interaction(domain_id, pid_particle_pair, reaction_types,
+#                                       structure, shell_id, shell_center,
+#				       shell_radius, shell_length, shell_unit_z,
+#				       surface, interaction_type)
+
+
+
+
+	particle_pos = pid_particle_pair[1].position
+
+    	if isinstance(surface, CylindricalSurface):
+            particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
+            projected_point, r0 = surface.projected_point(particle_pos)
+            shell_unit_r = normalize(particle_pos - projected_point)
+
+            z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
+
+            interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
+                                                        reaction_rules, structure,
+                                                        shell_id, shell_center, shell_radius,
+                                                        shell_half_length, shell_unit_z, z0,
+                                                        shell_unit_r, r0, interaction_rules, surface)
+	elif isinstance(surface, PlanarSurface):
+            particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
+            z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
+
+            interaction = PlanarSurfaceInteraction(domain_id, pid_particle_pair,
+                                                   reaction_rules, structure,
+                                                   shell_id, shell_center, shell_radius,
+                                                   shell_half_length, shell_unit_z,
+                                                   z0, interaction_rules, surface)
+
+
+
+
+
         assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
         self.domains[domain_id] = interaction
@@ -1625,7 +1657,8 @@ def propagate_pair(self, pair, dt, event_type):
     def form_interaction(self, single, surface, neighbors):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 
-        particle = single.pid_particle_pair[1]
+        pid_particle_pair = single.pid_particle_pair
+	particle = pid_particle_pair[1]
 
 	# calculate the Projected_point and distance to the surface
         # Cyclic transpose needed when calling surface.projected_point!
@@ -1690,9 +1723,11 @@ def form_interaction(self, single, surface, neighbors):
                                             particle_distance,
                                             orientation_vector,
                                             dr, dz_left, dz_right)
-        dr /= SAFETY
-        dz_left /= SAFETY
-        dz_right /= SAFETY
+
+#	 This will break the conditions below
+#        dr /= SAFETY
+#        dz_left /= SAFETY
+#        dz_right /= SAFETY
 
         # Decide if interaction domain is possible.
         if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
@@ -1722,7 +1757,7 @@ def form_interaction(self, single, surface, neighbors):
 	    origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
 
 
-        interaction = self.create_interaction(particle, surface,
+        interaction = self.create_interaction(pid_particle_pair, surface,
 					      origin, radius, half_length,
 					      orientation_vector)
 

From 943e3b327585c69efb54aa138b15330f6ac98d53 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Sep 2011 18:49:01 +0200
Subject: [PATCH 0162/1541] small name changes and clarifications

---
 egfrd.py | 42 ++++++++++++++++++++++++------------------
 1 file changed, 24 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 807a21fd..52e34bf2 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1111,7 +1111,7 @@ def make_new_domain(self, single):
                        closest_domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
 		if domain_distance < pair_horizon:
 	            # try making a Pair (can still be Mixed Pair or Normal Pair)
-		    domain = self.form_pair (single, closest_domain, rest_domains)
+		    domain = self.try_pair (single, closest_domain, rest_domains)
 		else:
 		    domain = None
 
@@ -1119,7 +1119,7 @@ def make_new_domain(self, single):
 	     surface_distance < domain_distance and \
 	     surface_distance < surface_horizon:
 		# try making an Interaction
-		domain = self.form_interaction (single, closest_surface, partners)
+		domain = self.try_interaction (single, closest_surface, partners)
 	else:
 		domain = None
 
@@ -1654,7 +1654,7 @@ def propagate_pair(self, pair, dt, event_type):
 
         return single1, single2
 
-    def form_interaction(self, single, surface, neighbors):
+    def try_interaction(self, single, surface, neighbors):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 
         pid_particle_pair = single.pid_particle_pair
@@ -1677,6 +1677,9 @@ def form_interaction(self, single, surface, neighbors):
         if __debug__:
            log.debug('trying to form Interaction(%s, %s)' % (particle, surface))
 
+
+	### 1. See if there is enough space for the shell
+
         # For an interaction with a PlanarSurface (membrane):
         # * dr is the radius of the cylinder.
         # * dz_left determines how much the cylinder is sticking out on the 
@@ -1718,13 +1721,13 @@ def form_interaction(self, single, surface, neighbors):
 
         # Miedema's algorithm.
         dr, dz_left, dz_right = \
-            self.determine_optimal_cylinder(single, surface,
-                                            projected_point,
-                                            particle_distance,
-                                            orientation_vector,
-                                            dr, dz_left, dz_right)
+            self.calculate_max_cylinder(single, surface,
+                                        projected_point,
+                                        particle_distance,
+                                        orientation_vector,
+                                        dr, dz_left, dz_right)
 
-#	 This will break the conditions below
+#	 This will break the conditions below for membrane interaction
 #        dr /= SAFETY
 #        dz_left /= SAFETY
 #        dz_right /= SAFETY
@@ -1742,8 +1745,11 @@ def form_interaction(self, single, surface, neighbors):
                            dz_right, min_dz_right))
             return None
 
+
+	### 2. The shell can be made. Now do what's necessary to make it
+	###
         # Compute origin, radius and half_length of cylinder.
-	# TODO slightly change dz, dr framework. See notes.
+	# TODO slightly change dz, dr framework to simplify things. See notes.
         if isinstance(surface, PlanarSurface):
 #            half_length = (dz_left + dz_right) / 2.0
             half_length = (dz_left + particle_distance + dz_right) / 2.0
@@ -1761,7 +1767,6 @@ def form_interaction(self, single, surface, neighbors):
 					      origin, radius, half_length,
 					      orientation_vector)
 
-        # Below here similar as in fire_pair after creating a pair.
         interaction.dt, interaction.event_type, = \
             interaction.determine_next_event()
         assert interaction.dt >= 0
@@ -1771,18 +1776,19 @@ def form_interaction(self, single, surface, neighbors):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
+        assert self.check_obj(interaction)
+        self.add_domain_event(interaction)
+
         if __debug__:
             log.debug('        *create_interaction\n'
                       '            dr = %s. dz_left = %s. dz_right = %s.\n' %
                       (FORMAT_DOUBLE % dr, FORMAT_DOUBLE % dz_left,
                        FORMAT_DOUBLE % dz_right))
 
-        assert self.check_obj(interaction)
-        self.add_domain_event(interaction)
-
         return interaction
 
-    def determine_optimal_cylinder(self, single, surface, projected_point, 
+
+    def calculate_max_cylinder(self, single, surface, projected_point, 
                                    particle_distance, orientation_vector,
                                    dr, dz_left, dz_right):
         # Find optimal cylinder around particle and surface, such that 
@@ -1799,7 +1805,7 @@ def determine_optimal_cylinder(self, single, surface, projected_point,
 
         for domain in all_neighbors:
             if isinstance(domain, Multi):
-                for shell in domain.shell_list:
+                for _, shell in domain.shell_list:
                     shell_position = shell.shape.position
                     shell_size = shell.shape.radius
                     dr, dz_left, dz_right = \
@@ -1816,7 +1822,7 @@ def determine_optimal_cylinder(self, single, surface, projected_point,
                 shell_position = domain.shell.shape.position
                 shell_size = domain.get_shell_size()
 
-                # Make bursted singles look bigger, like in form_pair, 
+                # Make bursted singles look bigger,
                 # because the size of their shell is only 
                 # particle.radius (not yet multiplied by 
                 # SINGLE_SHELL_FACTOR)
@@ -1894,7 +1900,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         return dr, dz_left, dz_right
 
 
-    def form_pair(self, single1, single2, burst):
+    def try_pair(self, single1, single2, burst):
         if __debug__:
            log.debug('trying to form Pair(%s, %s)' %
                      (single1.pid_particle_pair, single2.pid_particle_pair))

From 8014be4edf07d49d4faf1dacd018cecb793d409d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Sep 2011 16:32:02 +0200
Subject: [PATCH 0163/1541] changed parameter meanings of
 calculate_max_cylinder dr and dz_right were previously relative to the
 particle now they are relative to the projected_point (which is now just a
 reference point) This reduces complexity in processing the cylinder
 parameters and makes it more general.

---
 egfrd.py | 53 ++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 34 insertions(+), 19 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 52e34bf2..2849805f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1702,20 +1702,23 @@ def try_interaction(self, single, surface, neighbors):
             # Leave enough for the particle itself to the left.
             dz_left = particle.radius
             # Make sure the cylinder stays within 1 cell.
-            dz_right = self.get_max_shell_size() * 2 - \
-                      (particle_distance + dz_left)
+#            dz_right = self.get_max_shell_size() * 2 - (particle_distance + dz_left)
+            dz_right = self.get_max_shell_size() * 2 - dz_left
 
             min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_left = dz_left
-            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
+            min_dz_right = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
 
         elif isinstance(surface, CylindricalSurface):
             # Make sure the cylinder stays within 1 cell.
-            dr = self.get_max_shell_size() - particle_distance
+#            dr = self.get_max_shell_size() - particle_distance
+            dr = self.get_max_shell_size() 
             dz_left = self.get_max_shell_size()
             dz_right = self.get_max_shell_size()
 
-            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
+            min_dr = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_left = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
 
@@ -1727,10 +1730,10 @@ def try_interaction(self, single, surface, neighbors):
                                         orientation_vector,
                                         dr, dz_left, dz_right)
 
+        dr /= SAFETY
 #	 This will break the conditions below for membrane interaction
-#        dr /= SAFETY
 #        dz_left /= SAFETY
-#        dz_right /= SAFETY
+        dz_right /= SAFETY
 
         # Decide if interaction domain is possible.
         if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
@@ -1750,17 +1753,18 @@ def try_interaction(self, single, surface, neighbors):
 	###
         # Compute origin, radius and half_length of cylinder.
 	# TODO slightly change dz, dr framework to simplify things. See notes.
-        if isinstance(surface, PlanarSurface):
-#            half_length = (dz_left + dz_right) / 2.0
-            half_length = (dz_left + particle_distance + dz_right) / 2.0
-            radius = dr
-            origin = projected_point + (half_length - dz_left) * orientation_vector
-
-        elif isinstance(surface, CylindricalSurface):
-	    half_length = (dz_left + dz_right) / 2.0
+#        if isinstance(surface, PlanarSurface):
+        half_length = (dz_left + dz_right) / 2.0
+#            half_length = (dz_left + particle_distance + dz_right) / 2.0
+        radius = dr
+#            origin = projected_point + (half_length - dz_left) * orientation_vector
+        origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
+
+#        elif isinstance(surface, CylindricalSurface):
+#	    half_length = (dz_left + dz_right) / 2.0
 #            radius = dr 
-            radius = dr + particle_distance
-	    origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
+##            radius = dr + particle_distance
+#	    origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
 
 
         interaction = self.create_interaction(pid_particle_pair, surface,
@@ -1776,7 +1780,7 @@ def try_interaction(self, single, surface, neighbors):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
-        assert self.check_obj(interaction)
+#        assert self.check_obj(interaction)
         self.add_domain_event(interaction)
 
         if __debug__:
@@ -1861,11 +1865,17 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
 
         # Calculate dr_i for this shell.
         dr_i = ri - shell_size
-        if isinstance(surface, CylindricalSurface):
+
+	if isinstance(surface, PlanarSurface):
+	    dz_right -= particle_distance
+        elif isinstance(surface, CylindricalSurface):
             # Run Miedema's algorithm in the r direction 
             # relative to the particle's position, not to 
             # projected point (r=0).
             dr_i -= particle_distance
+	    dr -= particle_distance
+	else:
+	    raise SystemError('Error in Miedema\'s algorithm: surface is not a Surface')
 
         # Calculate dz_left_i or dz_right_i (both will usually 
         # be positive values).
@@ -1897,6 +1907,11 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
                 else:
                     dr = dr_i
 
+	if isinstance(surface, PlanarSurface):
+	    dz_right += particle_distance
+	elif isinstance(surface, CylindricalSurface):
+	    dr += particle_distance
+
         return dr, dz_left, dz_right
 
 

From 6b65dd500a38cba553abc24f5d8699c66dc8973c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Sep 2011 17:20:19 +0200
Subject: [PATCH 0164/1541] small change to check_obj when checking an
 Interaction, check_obj now also ignore the surface belonging to the
 interaction. The shell will after all intersect with the surface

---
 egfrd.py | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2849805f..400a212d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2241,13 +2241,17 @@ def print_report(self, out=None):
     def check_obj(self, obj):
         obj.check()
 
+        if isinstance(obj, Multi):
+            # Ignore all surfaces, multi shells can overlap with 
+            # surfaces.
+            ignores = [s.id for s in self.world.structures]
+	elif isinstance(obj, InteractionSingle):
+	    # Ignore surface of the particle and interaction surface
+	    ignores = [obj.structure.id, obj.surface.id]
+        else:
+            ignores = [obj.structure.id]
+
         for shell_id, shell in obj.shell_list:
-            if not isinstance(obj, Multi):
-                ignores = [obj.structure.id]
-            else:
-                # Ignore all surfaces, multi shells can overlap with 
-                # surfaces.
-                ignores = [s.id for s in self.world.structures]
             closest, distance = self.get_closest_obj(shell.shape.position,
                                                      ignore=[obj.domain_id],
                                                      ignores=ignores)

From 10796ceb8ca64e76f775a2b2f577ca80d6bcfa91 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Sep 2011 17:22:34 +0200
Subject: [PATCH 0165/1541] stupid bug 'fixed'. Miedema's algorithm looks in
 RADIUS of max_shell_size, whereas the shell of an interaction could extend
 TWICE that in one direction.

---
 egfrd.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 400a212d..33d94c58 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1701,9 +1701,10 @@ def try_interaction(self, single, surface, neighbors):
             dr = self.get_max_shell_size()
             # Leave enough for the particle itself to the left.
             dz_left = particle.radius
-            # Make sure the cylinder stays within 1 cell.
+            # Make sure the cylinder stays within 1 cell, note that max length of the
+	    # cylinder is only the radius of a sphere.
 #            dz_right = self.get_max_shell_size() * 2 - (particle_distance + dz_left)
-            dz_right = self.get_max_shell_size() * 2 - dz_left
+            dz_right = self.get_max_shell_size() # - dz_left
 
             min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_left = dz_left

From af47b1bb8dec60f99181cf87180bd537c0e39dc1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Sep 2011 17:37:00 +0200
Subject: [PATCH 0166/1541] add r0 to dump() of GreensFunction1DRadAbs

---
 GreensFunction1DRadAbs.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 13e9f5f4..9bc1ca4c 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -691,6 +691,7 @@ std::string GreensFunction1DRadAbs::dump() const
     std::ostringstream ss;
     ss << "D = " << this->getD() << ", sigma = " << this->getsigma() <<
         ", a = " << this->geta() <<
+        ", r0 = " << this->getr0() <<
         ", k = " << this->getk() << std::endl;
     return ss.str();
 }

From 11081729f73f01d77d57f0c7a6356a94d123cf1c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Sep 2011 17:39:27 +0200
Subject: [PATCH 0167/1541] cleanup: throwing away old unused (commented) code
 for Interactions

---
 egfrd.py | 28 ----------------------------
 1 file changed, 28 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 33d94c58..a0e900d5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -453,16 +453,6 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
         interaction_rules = None
         structure = self.world.get_structure(species.structure_id)
 
-	# 2. create and register the proper domain object
-#        interaction = \
-#            create_default_interaction(domain_id, pid_particle_pair, reaction_types,
-#                                       structure, shell_id, shell_center,
-#				       shell_radius, shell_length, shell_unit_z,
-#				       surface, interaction_type)
-
-
-
-
 	particle_pos = pid_particle_pair[1].position
 
     	if isinstance(surface, CylindricalSurface):
@@ -488,9 +478,6 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
                                                    z0, interaction_rules, surface)
 
 
-
-
-
         assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
         self.domains[domain_id] = interaction
@@ -1703,22 +1690,18 @@ def try_interaction(self, single, surface, neighbors):
             dz_left = particle.radius
             # Make sure the cylinder stays within 1 cell, note that max length of the
 	    # cylinder is only the radius of a sphere.
-#            dz_right = self.get_max_shell_size() * 2 - (particle_distance + dz_left)
             dz_right = self.get_max_shell_size() # - dz_left
 
             min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_left = dz_left
-#            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_right = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
 
         elif isinstance(surface, CylindricalSurface):
             # Make sure the cylinder stays within 1 cell.
-#            dr = self.get_max_shell_size() - particle_distance
             dr = self.get_max_shell_size() 
             dz_left = self.get_max_shell_size()
             dz_right = self.get_max_shell_size()
 
-#            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dr = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_left = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
@@ -1753,21 +1736,10 @@ def try_interaction(self, single, surface, neighbors):
 	### 2. The shell can be made. Now do what's necessary to make it
 	###
         # Compute origin, radius and half_length of cylinder.
-	# TODO slightly change dz, dr framework to simplify things. See notes.
-#        if isinstance(surface, PlanarSurface):
         half_length = (dz_left + dz_right) / 2.0
-#            half_length = (dz_left + particle_distance + dz_right) / 2.0
         radius = dr
-#            origin = projected_point + (half_length - dz_left) * orientation_vector
         origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
 
-#        elif isinstance(surface, CylindricalSurface):
-#	    half_length = (dz_left + dz_right) / 2.0
-#            radius = dr 
-##            radius = dr + particle_distance
-#	    origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
-
-
         interaction = self.create_interaction(pid_particle_pair, surface,
 					      origin, radius, half_length,
 					      orientation_vector)

From d918a603f7958d9ed5578f203ec017c25e38ba77 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Sep 2011 19:25:14 +0200
Subject: [PATCH 0168/1541] Fixed bug in setting boundaries for GF for membrane
 interaction

---
 single.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/single.py b/single.py
index 4d1b5f02..ac70a6a1 100644
--- a/single.py
+++ b/single.py
@@ -479,9 +479,9 @@ def iv_greens_function(self):
 	# with the planar surface.
 	# TODO choose interactionrule
 #        return GreensFunction1DRadAbs(self.D, self.interactionrule.k, self.z0,
-#				      self.get_inner_dz_left(), self.get_inner_dz_right())
+#				      -self.get_inner_dz_left(), self.get_inner_dz_right())
         return GreensFunction1DRadAbs(self.D, 1e-8, self.z0,
-				      self.get_inner_dz_left(), self.get_inner_dz_right())
+				      -self.get_inner_dz_left(), self.get_inner_dz_right())
 
     def draw_new_position(self, dt, event_type):
 	"""Draws a new position for the particle for a given event type at a given time
@@ -565,10 +565,10 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
 
 
     def get_inner_dz_left(self):
-	return self.shell.shape.half_length + self.z0 - self.pid_particle_pair[1].radius
+	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_dz_right(self):
-	return self.get_inner_dz_left()	- self.z0 - self.pid_particle_pair[1].radius
+	return self.get_inner_dz_left()	- self.pid_particle_pair[1].radius
 
     def get_inner_sigma(self):
 	return self.surface.shape.radius + self.pid_particle_pair[1].radius

From 338f29ad41b47d7d47b47a1f554447e461f3ccd1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Sep 2011 19:26:30 +0200
Subject: [PATCH 0169/1541] fixed problem in setting maximum allowed cylinder
 dimensions and finding its neighbors A cylinder must be smaller than the
 maximally allowed sphere. This means that the maximal cylinder fits inside
 the maximal sphere. Otherwise you can intersect with shells in the 'corners'
 of the cylinder since the nearest neighbor search code only allows a maximal
 radius to search in (defining a sphere). Also fixed the center point from
 which nearest neighbors are sought in calculate_max_cylinder

---
 egfrd.py | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a0e900d5..df1a1f91 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1684,23 +1684,25 @@ def try_interaction(self, single, surface, neighbors):
 
         # Initialize dr, dz_left, dz_right to maximum allowed values.
         # And decide minimal dr, dz_left, dz_right.
+
+	# Make sure the maximal cylinder fits in the maximal sphere. Matrix space
+	# doesn't allow to check for shells outside the maximal sphere.
+	max_cylinder_radius      = self.get_max_shell_size()/math.sqrt(2)
+	max_cylinder_half_length = max_cylinder_radius
         if isinstance(surface, PlanarSurface):
-            dr = self.get_max_shell_size()
+            dr = max_cylinder_radius
             # Leave enough for the particle itself to the left.
             dz_left = particle.radius
-            # Make sure the cylinder stays within 1 cell, note that max length of the
-	    # cylinder is only the radius of a sphere.
-            dz_right = self.get_max_shell_size() # - dz_left
+            dz_right = max_cylinder_half_length * 2 - dz_left
 
             min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_left = dz_left
             min_dz_right = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
 
         elif isinstance(surface, CylindricalSurface):
-            # Make sure the cylinder stays within 1 cell.
-            dr = self.get_max_shell_size() 
-            dz_left = self.get_max_shell_size()
-            dz_right = self.get_max_shell_size()
+            dr = max_cylinder_radius
+            dz_left = max_cylinder_half_length
+            dz_right = max_cylinder_half_length
 
             min_dr = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
             min_dz_left = particle.radius * self.SINGLE_SHELL_FACTOR
@@ -1715,9 +1717,9 @@ def try_interaction(self, single, surface, neighbors):
                                         dr, dz_left, dz_right)
 
         dr /= SAFETY
+        dz_right /= SAFETY
 #	 This will break the conditions below for membrane interaction
 #        dz_left /= SAFETY
-        dz_right /= SAFETY
 
         # Decide if interaction domain is possible.
         if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
@@ -1734,11 +1736,10 @@ def try_interaction(self, single, surface, neighbors):
 
 
 	### 2. The shell can be made. Now do what's necessary to make it
-	###
         # Compute origin, radius and half_length of cylinder.
+        origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
         half_length = (dz_left + dz_right) / 2.0
         radius = dr
-        origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
 
         interaction = self.create_interaction(pid_particle_pair, surface,
 					      origin, radius, half_length,
@@ -1753,7 +1754,7 @@ def try_interaction(self, single, surface, neighbors):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
-#        assert self.check_obj(interaction)
+        assert self.check_obj(interaction)
         self.add_domain_event(interaction)
 
         if __debug__:
@@ -1770,13 +1771,15 @@ def calculate_max_cylinder(self, single, surface, projected_point,
                                    dr, dz_left, dz_right):
         # Find optimal cylinder around particle and surface, such that 
         # it is not interfering with other shells.
-        # Todo. Finding all spheres and cylinders in the matrixspace 
-        # should be sufficient, but domain information is now used for 
 	#
         # get_shell_size is overridden for cylindrical singles and 
         # pairs.
+
+	# the search point is the center of the sphere that surrounds the
+	# maximal cylinder
+        search_point = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
         all_neighbors = \
-            self.get_neighbors_within_radius_no_sort(projected_point, 
+            self.get_neighbors_within_radius_no_sort(search_point, 
                                                      self.get_max_shell_size(),
                                                      ignore=[single.domain_id])
 

From e115ee3c8c4eb77c600a84935b8bc57353cbc78a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Sep 2011 11:12:44 +0200
Subject: [PATCH 0170/1541] small changes and comments

---
 egfrd.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index df1a1f91..458a9e20 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -421,7 +421,7 @@ def create_single(self, pid_particle_pair):
         # CylindricalSurfaceSingle.
         single = create_default_single(domain_id, pid_particle_pair, 
                                        shell_id, rrs, structure)
-#        assert isinstance(single, NonInteractionSingle)
+        assert isinstance(single, NonInteractionSingle)
         single.initialize(self.t)
         self.domains[domain_id] = single
 
@@ -528,6 +528,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         pair = create_default_pair(domain_id, com, single1, single2, shell_id, 
                                    r0, shell_size, rr, structure)
 
+	assert isinstance(pair, Pair)
         pair.initialize(self.t)
         self.domains[domain_id] = pair
 
@@ -1118,6 +1119,8 @@ def make_new_domain(self, single):
 	    if domain_distance > multi_horizon and \
 	       surface_distance > multi_horizon:
 	        # just make a normal NonInteractionSingle
+		# TODO we need the closest RELEVANT domain, i.e. the domain in the
+		# direction in which we can scale the domain
 	        closest_domain, domain_distance = \
         	    self.get_closest_obj(single_pos, ignore=[single.domain_id],
                 	                 ignores=[single.structure.id])
@@ -1125,7 +1128,7 @@ def make_new_domain(self, single):
 	        self.add_domain_event(single)
 	    else:
 		# The closest object was too close to make a NonInteractionSingle
-		    domain = self.form_multi(single, partners, dists)
+		domain = self.form_multi(single, partners, dists)
 
 	return domain
 
@@ -1308,7 +1311,8 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 
     def calculate_single_shell_size(self, single, closest, 
                                  distance, shell_distance):
-        assert isinstance(closest, Single)
+	# only if the closest shell is also a 'simple' Single
+        assert isinstance(closest, NonInteractionSingle)
 
         min_radius1 = single.pid_particle_pair[1].radius
         D1 = single.getD()
@@ -1333,7 +1337,7 @@ def update_single(self, single, closest, distance_to_shell):
         assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
 
         singlepos = single.shell.shape.position
-        if isinstance(closest, Single):
+        if isinstance(closest, NonInteractionSingle):
             closestpos = closest.shell.shape.position
             distance_to_closest = self.world.distance(singlepos, closestpos)
             new_shell_size = self.calculate_single_shell_size(single, closest, 
@@ -1754,7 +1758,7 @@ def try_interaction(self, single, surface, neighbors):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
-        assert self.check_obj(interaction)
+#        assert self.check_obj(interaction)
         self.add_domain_event(interaction)
 
         if __debug__:
@@ -1831,6 +1835,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         # shell_position and with size (radius or half_length) 
         # shell_size.
 
+	# TODO make cyclic boundary conditions aware
         shell_vector = shell_position - projected_point
 
         # Calculate zi and ri for this shell.

From 9c7a65d25fdd650120a7f00e4b24cb14ac6897b1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Sep 2011 11:21:06 +0200
Subject: [PATCH 0171/1541] fixed cyclic boundary conditions check when making
 Interaction shell

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 458a9e20..94fe6c46 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1835,7 +1835,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         # shell_position and with size (radius or half_length) 
         # shell_size.
 
-	# TODO make cyclic boundary conditions aware
+	shell_position = self.world.cyclic_transpose(shell_position, projected_point)
         shell_vector = shell_position - projected_point
 
         # Calculate zi and ri for this shell.

From 2eb9f13203e84082d412a5e0ba81ee85011eb5e5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Sep 2011 11:23:27 +0200
Subject: [PATCH 0172/1541] cleanup of old (unused) code

---
 egfrd.py | 61 --------------------------------------------------------
 1 file changed, 61 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 94fe6c46..bba6ccba 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -57,40 +57,6 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure)
                                    shell_id, rt, structure)
 
 
-#def create_default_interaction(domain_id, pid_particle_pair, reaction_rules, structure,
-#                               shell_id, shell_center, shell_radius,
-#			       shell_half_length, shell_unit_z,
-#                               surface, interaction_rules):
-#    # surface is the surface with which the interaction is made
-#
-#    # These calculation should be closer to the Green's functions, i.e. in the
-#    # PlanarSurfaceInteraction constructor but can not be performed there because
-#    # it doesn't know about the world size of cyclic boundary conditions.
-#    particle_pos = pid_particle_pair[1].position
-#
-#    if isinstance(surface, CylindricalSurface):
-#	particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
-#	projected_point, r0 = surface.projected_point(particle_pos)
-#        shell_unit_r = normalize(particle_pos - projected_point)
-#
-#	z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
-#
-#        return CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
-#                                             reaction_rules, structure,
-#					     shell_id, shell_center, shell_radius,
-#					     shell_half_length, shell_unit_z, z0,
-#					     shell_unit_r, r0, interaction_rules, surface)
-#    elif isinstance(surface, PlanarSurface):
-#        particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
-#	z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
-#
-#        return PlanarSurfaceInteraction(domain_id, pid_particle_pair,
-#                                        reaction_rules, structure,
-#					shell_id, shell_center, shell_radius,
-#					shell_half_length, shell_unit_z,
-#					z0, interaction_rules, surface)
-
-
 def create_default_pair(domain_id, com, single1, single2, shell_id, 
                         r0, shell_size, rt, structure):
     if isinstance(structure, CuboidalRegion):
@@ -632,25 +598,6 @@ def add_domain_event(self, domain):
                       FORMAT_DOUBLE % (event_time)))
         domain.event_id = event_id			# FIXME side effect programming -> unclear!!
 
-#    def add_pair_event(self, pair):
-#        event_id = self.scheduler.add(
-#            DomainEvent(self.t + pair.dt, pair))
-#        if __debug__:
-#            log.info('add_event: %s, event=#%d, t=%s' %
-#                     (pair.domain_id, event_id,
-#                      FORMAT_DOUBLE % (self.t + pair.dt)))
-#        pair.event_id = event_id
-#
-#    def add_multi_event(self, multi):
-#        event_id = self.scheduler.add(
-#            DomainEvent(self.t + multi.dt, multi))
-#
-#        if __debug__:
-#            log.info('add_event: %s, event=#%d, t=%s' %
-#                     (multi.domain_id, event_id,
-#                      FORMAT_DOUBLE % (self.t + multi.dt)))
-#        multi.event_id = event_id
-
     def remove_event(self, event):
         if __debug__:
             log.info('remove_event: event=#%d' % event.event_id)
@@ -662,14 +609,6 @@ def update_domain_event(self, t, domain):
                      (domain.domain_id, domain.event_id, FORMAT_DOUBLE % t))
         self.scheduler.update((domain.event_id, DomainEvent(t, domain)))
 
-#    def update_multi_event(self, t, multi):
-#        if __debug__:
-#            log.info('update_event: %s, event=#%d, t=%s' %
-#                     (multi.domain_id, multi.event_id, FORMAT_DOUBLE % t))
-#        self.scheduler.update((multi.event_id, DomainEvent(t, multi)))
-
-
-
     def burst_domain(self, domain):
     # Reduces and domain (Single, Pair or Multi) to Singles with the zero shell, and dt=0
         if __debug__:

From 9a8d055c5fa676e87dfaec2f05c2676b01af5473 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 13:01:07 +0300
Subject: [PATCH 0173/1541] test online code change

---
 domain.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/domain.py b/domain.py
index e9f2927d..9aff684f 100644
--- a/domain.py
+++ b/domain.py
@@ -1,4 +1,3 @@
-
 class Domain(object):
 # The domain is the main unit of eGFRD. Single, Pairs and Multis are all domains
 # with an own domain_id
@@ -26,6 +25,7 @@ def initialize(self, time):		# this method needs to be overloaded in all subclas
 	pass
 
 
+
 class ProtectiveDomain(Domain):
 # Protective Domains are the proper eGFRD domains. The shell associated with a Protective
 # Domains really exclude other particles from the simulation. These Domains are Singles and Pairs

From 2d0f5d3e596b3f3a9fb627cd44e2545d3f87b21e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 15:28:49 +0200
Subject: [PATCH 0174/1541] online change removed again

---
 domain.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/domain.py b/domain.py
index 9aff684f..fda18365 100644
--- a/domain.py
+++ b/domain.py
@@ -25,7 +25,6 @@ def initialize(self, time):		# this method needs to be overloaded in all subclas
 	pass
 
 
-
 class ProtectiveDomain(Domain):
 # Protective Domains are the proper eGFRD domains. The shell associated with a Protective
 # Domains really exclude other particles from the simulation. These Domains are Singles and Pairs

From 84741511e13f01d51e25a4cc2efa138ac0d83304 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 16:09:04 +0200
Subject: [PATCH 0175/1541] small bugfixes/workarounds

---
 egfrd.py  | 8 ++++----
 single.py | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index bba6ccba..f8c04d79 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1459,8 +1459,8 @@ def burst_single(self, single):
         assert self.t <= single.last_time + single.dt
 
         # record important single data ~ MW
-        oldpos = single.shell.shape.position
-        old_shell_size = single.get_shell_size()
+#        oldpos = single.shell.shape.position
+#        old_shell_size = single.get_shell_size()
 
         particle_radius = single.pid_particle_pair[1].radius
 
@@ -1472,8 +1472,8 @@ def burst_single(self, single):
 
         newpos = newsingle.pid_particle_pair[1].position
         # Check if stays within domain ~MW
-        assert self.world.distance(newpos, oldpos) <= \
-               old_shell_size - particle_radius
+#        assert self.world.distance(newpos, oldpos) <= \
+#               old_shell_size - particle_radius
         # Displacement check is in NonInteractionSingle.draw_new_position.
 
         if isinstance(single, InteractionSingle):
diff --git a/single.py b/single.py
index ac70a6a1..5b31cb7d 100644
--- a/single.py
+++ b/single.py
@@ -510,7 +510,7 @@ def draw_new_position(self, dt, event_type):
             # Heads up. size_of_domain is different from the half_length of 
             # the cylinder, because the domain ends where the surface 
             # starts, while the cylinder is continuing into the surface.
-            z_surface = self.get_inner_dz_left()	# left side of the inner domain
+            z_surface = -self.get_inner_dz_left()	# left side of the inner domain
 	    z_not_surface = self.get_inner_dz_right()	# right side of the inner domain (away from the surface)
 
 	    # If the event was not yet fully specified

From 0fa056abde39f8d0ea2eed93b6a5da770d1ceb9d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 17:04:59 +0200
Subject: [PATCH 0176/1541] moved shell making for the multi from the simulator
 to the multi.py All other domain make their own shells, so why not the multi?
 Is now more consistent

---
 domain.py |  6 +++---
 egfrd.py  | 26 ++++++++++++++------------
 multi.py  |  4 ++++
 3 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/domain.py b/domain.py
index fda18365..0436fc88 100644
--- a/domain.py
+++ b/domain.py
@@ -24,6 +24,9 @@ def initialize(self, time):		# this method needs to be overloaded in all subclas
         '''
 	pass
 
+    def create_new_shell(self):		# needs to be overloaded in subclasses
+	pass				# creates an appropriate shell object
+
 
 class ProtectiveDomain(Domain):
 # Protective Domains are the proper eGFRD domains. The shell associated with a Protective
@@ -52,8 +55,5 @@ def get_shell_list(self):
 
     shell_list = property(get_shell_list)
 
-    def create_new_shell(self):		# needs to be overloaded in subclasses
-	pass				# creates an appropriate shell object
-
     def get_shell_radius(self):		# returns the radius of the shell
 	return self.shell.shape.radius
diff --git a/egfrd.py b/egfrd.py
index f8c04d79..534d16bc 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1970,23 +1970,25 @@ def add_to_multi_recursive(self, domain, multi):
         else:
             assert False, 'do not reach here.'  # Pairs are burst
 
-    def new_spherical_shell(self, domain_id, pos, size):
-        shell_id_shell_pair = (
-            self.shell_id_generator(),
-            SphericalShell(domain_id, Sphere(pos, size)))
-        self.move_shell(shell_id_shell_pair)
-        return shell_id_shell_pair
+#    def new_spherical_shell(self, domain_id, pos, size):
+#        shell_id_shell_pair = (
+#            self.shell_id_generator(),
+#            SphericalShell(domain_id, Sphere(pos, size)))
+#        self.move_shell(shell_id_shell_pair)
+#        return shell_id_shell_pair
 
     def add_to_multi(self, single, multi):
         if __debug__:
             log.info('add to multi:\n  %s\n  %s' % (single, multi))
 
-        sid_shell_pair = self.new_spherical_shell(
-            multi.domain_id,
-            single.pid_particle_pair[1].position,
-            single.pid_particle_pair[1].radius * \
-                self.MULTI_SHELL_FACTOR)
-        multi.add_shell(sid_shell_pair)
+	shell_id = self.shell_id_generator()
+#        sid_shell_pair = self.new_spherical_shell(
+#            multi.domain_id,
+	shell = multi.create_new_shell(single.pid_particle_pair[1].position,
+                single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
+	shell_id_shell_pair = (shell_id, shell)
+        self.move_shell(shell_id_shell_pair)
+        multi.add_shell(shell_id_shell_pair)
         multi.add_particle(single.pid_particle_pair)
 
     def merge_multis(self, multi1, multi2):
diff --git a/multi.py b/multi.py
index 9ff4e34f..30acb3c0 100644
--- a/multi.py
+++ b/multi.py
@@ -6,6 +6,7 @@
 import itertools
 
 import _gfrd
+from _gfrd import (SphericalShell, Sphere)
 from constants import EventType
 from domain import Domain
 
@@ -37,6 +38,9 @@ def get_multiplicity(self):
         return self.particle_container.num_particles
     multiplicity = property(get_multiplicity)
 
+    def create_new_shell(self, position, radius):
+        return SphericalShell(self.domain_id, Sphere(position, radius))
+
     def within_shell(self, pp):
         return bool(self.sphere_container.get_neighbors_within_radius(pp[1].position, -pp[1].radius))
 

From d9cc4e51a1fe404135c1f0ee0a4e2537a286abce Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 17:13:44 +0200
Subject: [PATCH 0177/1541] moved getting neighbors for NonInteractionSingle to
 update method ->more consistent with other methods that determine new shell
 size

---
 egfrd.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 534d16bc..0cced070 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1058,11 +1058,6 @@ def make_new_domain(self, single):
 	    if domain_distance > multi_horizon and \
 	       surface_distance > multi_horizon:
 	        # just make a normal NonInteractionSingle
-		# TODO we need the closest RELEVANT domain, i.e. the domain in the
-		# direction in which we can scale the domain
-	        closest_domain, domain_distance = \
-        	    self.get_closest_obj(single_pos, ignore=[single.domain_id],
-                	                 ignores=[single.structure.id])
 	        self.update_single(single, closest_domain, domain_distance)
 	        self.add_domain_event(single)
 	    else:
@@ -1275,7 +1270,13 @@ def calculate_single_shell_size(self, single, closest,
     def update_single(self, single, closest, distance_to_shell): 
         assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
 
-        singlepos = single.shell.shape.position
+	singlepos = single.pid_particle_pair[1].position
+	# TODO we need the closest RELEVANT domain, i.e. the domain in the
+	# direction in which we can scale the domain
+	closest, distance_to_shell = \
+            self.get_closest_obj(singlepos, ignore=[single.domain_id],
+               	                 ignores=[single.structure.id])
+
         if isinstance(closest, NonInteractionSingle):
             closestpos = closest.shell.shape.position
             distance_to_closest = self.world.distance(singlepos, closestpos)

From 4dda03b4370ec771c1a88a308cf646c898e5e23c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 17:13:44 +0200
Subject: [PATCH 0178/1541] moved getting neighbors for NonInteractionSingle to
 update method ->more consistent with other methods that determine new shell
 size

---
 egfrd.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 534d16bc..9398092c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1058,12 +1058,7 @@ def make_new_domain(self, single):
 	    if domain_distance > multi_horizon and \
 	       surface_distance > multi_horizon:
 	        # just make a normal NonInteractionSingle
-		# TODO we need the closest RELEVANT domain, i.e. the domain in the
-		# direction in which we can scale the domain
-	        closest_domain, domain_distance = \
-        	    self.get_closest_obj(single_pos, ignore=[single.domain_id],
-                	                 ignores=[single.structure.id])
-	        self.update_single(single, closest_domain, domain_distance)
+	        self.update_single(single)
 	        self.add_domain_event(single)
 	    else:
 		# The closest object was too close to make a NonInteractionSingle
@@ -1272,10 +1267,16 @@ def calculate_single_shell_size(self, single, closest,
 
         return shell_size
 
-    def update_single(self, single, closest, distance_to_shell): 
+    def update_single(self, single): 
         assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
 
-        singlepos = single.shell.shape.position
+	singlepos = single.pid_particle_pair[1].position
+	# TODO we need the closest RELEVANT domain, i.e. the domain in the
+	# direction in which we can scale the domain
+	closest, distance_to_shell = \
+            self.get_closest_obj(singlepos, ignore=[single.domain_id],
+               	                 ignores=[single.structure.id])
+
         if isinstance(closest, NonInteractionSingle):
             closestpos = closest.shell.shape.position
             distance_to_closest = self.world.distance(singlepos, closestpos)

From 2f21cb32243c2c91ad965fb1fd333f39a6a790af Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 17:31:54 +0200
Subject: [PATCH 0179/1541] small change to signature try_interaction

---
 egfrd.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9398092c..48c44322 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1046,7 +1046,7 @@ def make_new_domain(self, single):
 	     surface_distance < domain_distance and \
 	     surface_distance < surface_horizon:
 		# try making an Interaction
-		domain = self.try_interaction (single, closest_surface, partners)
+		domain = self.try_interaction (single, closest_surface)
 	else:
 		domain = None
 
@@ -1585,7 +1585,7 @@ def propagate_pair(self, pair, dt, event_type):
 
         return single1, single2
 
-    def try_interaction(self, single, surface, neighbors):
+    def try_interaction(self, single, surface):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 
         pid_particle_pair = single.pid_particle_pair

From e0f2e385b06fcd56d4691d090859cb8cfbdabab6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Sep 2011 19:12:29 +0200
Subject: [PATCH 0180/1541] introduced ShellContainer class The class
 encapsulates the two shell containers and implements the various nearest
 neighbors algorithms etc. This is basically a move from the simulator code to
 a separate class

---
 egfrd.py          |   1 +
 shellcontainer.py | 145 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 146 insertions(+)
 create mode 100644 shellcontainer.py

diff --git a/egfrd.py b/egfrd.py
index 48c44322..ad0238f8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -33,6 +33,7 @@
 from multi import *
 from utils import *
 from constants import *
+from shellcontainer import ShellContainer
 
 import logging
 import os
diff --git a/shellcontainer.py b/shellcontainer.py
new file mode 100644
index 00000000..2c7744a5
--- /dev/null
+++ b/shellcontainer.py
@@ -0,0 +1,145 @@
+#!/usr/env python
+
+import numpy
+
+from _gfrd import (
+    SphericalShell,
+    SphericalShellContainer,
+    CylindricalShell,
+    CylindricalShellContainer
+    )
+from utils import *
+
+class ShellContainer(object):
+
+    def __init__(self, world):
+
+	# the containers hold the spherical and cylindrical shells respectively 
+        # the containers is a cache for the shell objects in the domain and is mostly
+        # read only. The only method that writes the containers is self.move_shell
+        self.containers = [SphericalShellContainer(world.world_size,
+                                                   world.matrix_size),
+                           CylindricalShellContainer(world.world_size,
+                                                     world.matrix_size)]
+
+	self.world = world
+        self.user_max_shell_size = numpy.inf
+
+    def get_matrix_cell_size(self):
+	return self.containers[0].cell_size     # cell_size is the width of the (cubic) cell
+
+    def set_user_max_shell_size(self, size):
+        self.user_max_shell_size = size
+
+    def get_user_max_shell_size(self):
+        return self.user_max_shell_size
+
+    def get_max_shell_size(self):
+        return min(self.get_matrix_cell_size() * .5 / SAFETY,
+                   self.user_max_shell_size)
+
+    def get_container(self, shell):
+        # Returns the container that holds 'shell'
+        if type(shell) is SphericalShell:
+            return self.containers[0]
+        elif type(shell) is CylindricalShell:
+            return self.containers[1]
+
+    def move_shell(self, shell_id_shell_pair):
+    # This is the only method that writes to the shell containers
+        shell = shell_id_shell_pair[1]
+        container = self.get_container(shell)
+        container.update(shell_id_shell_pair)
+
+    def remove_shell(self, shell_id_shell_pair):
+	shell_id = shell_id_shell_pair[0]
+	shell = shell_id_shell_pair[1]
+	container = self.get_container(shell)
+	del container[shell_id]
+
+    def get_intruders(self, position, radius, ignore):
+        # gets the intruders in a spherical volume of radius 'radius'?
+        # TODO make this surface specific -> in 2D only need to check in cylinder,
+        # not in sphere
+        intruders = []                  # intruders are domains within radius
+        closest_domain = None           # closest domain, excluding intruders.
+        closest_distance = numpy.inf    # distance to the shell of the closest domain.
+
+        seen = set(ignore)
+        for container in self.containers:
+            neighbors = container.get_neighbors(position)
+            for n in neighbors:
+                domain_id = n[0][1].did
+                distance = n[1]
+                if distance > radius:
+                    if distance < closest_distance:
+                        # This is domain (the first one for this 
+                        # container) that has a shell that is more than 
+                        # radius away from pos.  If it is closer than 
+                        # the closest such one we found so far: store 
+                        # it. Always break out of the inner for loop and 
+                        # check the other containers.
+                        closest_domain = domain_id
+                        closest_distance = distance
+                        break
+                    else:
+                        break
+                elif domain_id not in seen:
+                    # Since a domain can have more than 1 shell (multis 
+                    # for example), and for each shell there is an entry 
+                    # in the shell container, we make sure each domain 
+                    # occurs only once in the returned list here.
+                    seen.add(domain_id)
+                    intruders.append(domain_id)
+
+        return intruders, closest_domain, closest_distance
+
+    def get_closest_obj(self, pos, ignore=[], ignores=[]):
+        # ignore: domain ids.
+        closest_domain = None
+        closest_distance = numpy.inf
+
+        for container in self.containers:
+            result = container.get_neighbors(pos)
+
+            for shell_id_shell_pair, distance in result:
+                domain_id = shell_id_shell_pair[1].did
+
+                if domain_id not in ignore and distance < closest_distance:
+                    closest_domain, closest_distance = domain_id, distance
+                    # Found yet a closer domain. Break out of inner for 
+                    # loop and check other containers.
+                    break
+
+        surface, distance = get_closest_surface(self.world, pos, ignores)
+
+        if distance < closest_distance:
+            return surface, distance
+        else:
+            return closest_domain, closest_distance
+
+    def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
+        # Get neighbor domains within given radius.
+	# Note that the function returns a generator
+        #
+        # ignore: domain ids.
+        #
+        # Only returns neighbors, not the distances towards their 
+        # shells. Can for example be used to try to clear all objects 
+        # from a certain volume.
+
+        try:
+            for container in self.containers:
+                result = container.get_neighbors_within_radius(pos, radius)
+                # result = [((shell_id_shell_pair), distance), ]
+                # Since a domain can have more than 1 shell (multis for 
+                # example), and for each shell there is an entry in the 
+                # shell container, we make sure each domain occurs only once 
+                # in the returned list here.
+                for did in uniq(s[0][1].did for s in result):
+                    if did not in ignore:
+                        yield did
+        except AttributeError:
+            pass
+
+

From 2ec93d7e0c984b5b9971206deda034abdadee546 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 20 Sep 2011 11:52:59 +0200
Subject: [PATCH 0181/1541] Changed Double -> Real in 1D greensfunctions.
 Simplified 1D BD.

---
 CuboidalRegion.hpp         |  9 ++++++---
 Cylinder.hpp               |  2 +-
 CylindricalSurface.hpp     | 30 +++++++-----------------------
 GreensFunction1DAbsAbs.cpp | 22 +++++++++++-----------
 GreensFunction1DAbsAbs.hpp | 20 ++++++++++----------
 PlanarSurface.hpp          |  8 +++++---
 SphericalSurface.hpp       |  8 +++++---
 Structure.hpp              |  6 +++---
 8 files changed, 48 insertions(+), 57 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 6edf70a1..decc500b 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -47,17 +47,20 @@ class CuboidalRegion
             rng.normal(0., r));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, 
+                                    Real const& D01, Real const& v) const
     {
          return drawR_gbd_3D(rnd, r01, dt, D01);
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
     {
          return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
     }
 
-    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
     {
         return random_vector( drawR_gbd(rng(), r01, dt, D01, v ), rng );
     }
diff --git a/Cylinder.hpp b/Cylinder.hpp
index c4566d35..860c2566 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -138,7 +138,7 @@ distance(Cylinder<T_> const& obj,
     typedef typename Cylinder<T_>::position_type position_type;
     typedef typename Cylinder<T_>::length_type length_type;
 
-    /* First compute the (z,r) components of pos in a coordinate system 
+    /* First compute the (r,z) components of pos in a coordinate system 
      * defined by the vectors unitR and unit_z, where unitR is
      * choosen such that unitR and unit_z define a plane in which
      * pos lies. */
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 025aac98..02b278c0 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -36,22 +36,14 @@ class CylindricalSurface
         return multiply(base_type::shape().unit_z(), rng.normal(mean, r));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
     {
         return drawR_gbd_1D(rnd, r01, dt, D01, v);
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
     {
-
-        /* The inter particle vector (ipv) points from A -> B, where A initiated overlap. */
-        Real ipv = dot_product( ipv, base_type::shape().unit_z() );
-        Real abs_ipv = fabs( ipv );
-        Real v = v1 - v0;
-        Real D01 = D0 + D1;
-
-        Real correction = exp( -ipv/abs_ipv * (abs_ipv - r01) * v/D01 );
-       
         /*
             The I_bd factors used for calculating the acceptance probability are dependent on the direction 
             of the overlap step (r = r_1 - r_0), compared to the direction of the drift. 
@@ -64,7 +56,6 @@ class CylindricalSurface
             Real numerator = g_bd_1D(ipv, r01, dt, D0, -v0);
             Real denominator = g_bd_1D(ipv, r01, dt, D0, v0)*exp( ipv/abs_ipv*(abs_ipv - r01)*v/D01 );
             Real correction = numerator/denominator;
-
             if( ipv < 0 )
                 return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, -v0) + I_bd_1D(r01, dt, D1, v1) ) );
             else
@@ -73,21 +64,14 @@ class CylindricalSurface
             Also change v -> -v in drawR for the dissociation move.
         */
 
-        return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
+        return 0.5*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
   
     }
 
-    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
     {
-        //Real I_01( I_bd_1D(r01, dt, D01,  v) );        
-        //Real I_10( I_bd_1D(r01, dt, D01, -v) ); 
-        //Real prob( rng()*(I_01 + I_10 );
-        Real prob( rng() );
-        
-        if( prob < 0.5 ) 
-            return base_type::shape().unit_z() * drawR_gbd( rnd, r01, dt, D01, v );
-        else
-            return base_type::shape().unit_z() * -1. * drawR_gbd( rnd, r01, dt, D01, v );
+        return random_vector(drawR_gbd(rng.uniform(), r01, dt, D01, v), rng);
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 1b0100d4..24584016 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -71,7 +71,7 @@ GreensFunction1DAbsAbs::p_survival (Real t) const
 	  }
 	  
 	  prev_term = term;
-	  nPI = (double)n*M_PI;
+	  nPI = (Real)n*M_PI;
 	  term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * (1.0 - cos(nPI)) / nPI;
 	  sum += term;
 	  n++;
@@ -93,7 +93,7 @@ GreensFunction1DAbsAbs::p_survival (Real t) const
 	      break;
 	  }
 	  
-	  nPI = (double)n*M_PI;
+	  nPI = (Real)n*M_PI;
 	  prev_term = term;
 	  term = exp(nPI*nPI*expo) * (exp(sigmav2D) - cos(nPI)*exp(av2D)) * nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L);
 	  sum += term;
@@ -343,8 +343,8 @@ GreensFunction1DAbsAbs::drawEventType( Real rnd, Real t ) const
 // the right form and calculates the survival probability from it (and returns it).
 // The routine drawTime uses this one to sample the next-event time from the
 // survival probability using a rootfinder from GSL.
-double
-GreensFunction1DAbsAbs::drawT_f (double t, void *p)
+Real
+GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
 {   
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
@@ -556,7 +556,7 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     return t;
 }
 
-Real GreensFunction1DAbsAbs::drawR_free_f(double r, drawR_params const* params)
+Real GreensFunction1DAbsAbs::drawR_free_f(Real r, drawR_params const* params)
 {
     const Real D(params->H[0]);
     const Real vt(params->H[1]*params->H[2]);
@@ -569,14 +569,14 @@ Real GreensFunction1DAbsAbs::drawR_free_f(double r, drawR_params const* params)
 // the right form and calculates the survival probability from it (and returns it).
 // The routine drawR uses this function to sample the exit point, making use of the
 // GSL root finder to draw the random position.
-double
-GreensFunction1DAbsAbs::drawR_f (double r, drawR_params const* params)
+Real
+GreensFunction1DAbsAbs::drawR_f (Real r, drawR_params const* params)
 {   
-    double sum = 0, term = 0, prev_term = 0;
-    double S_Cn_An, n_L;
+    Real sum = 0, term = 0, prev_term = 0;
+    Real S_Cn_An, n_L;
     int    terms = params->terms;
-    double sigma = params->H[0];
-    double v2D = params->H[1];	// =v/(2D)
+    Real sigma = params->H[0];
+    Real v2D = params->H[1];	// =v/(2D)
 
     int n=0;
     do
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 0c4a9d25..652b162c 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -168,30 +168,30 @@ class GreensFunction1DAbsAbs: public GreensFunction
     struct drawT_params
     {
         // use 10 terms in the summation for now
-        double exponent[MAX_TERMS];
-        double Xn[MAX_TERMS];
-        double prefactor;
+        Real exponent[MAX_TERMS];
+        Real Xn[MAX_TERMS];
+        Real prefactor;
         int    terms;
         Real tscale;
         // random number
-        double rnd;
+        Real rnd;
     };
 
     static double drawT_f (double t, void *p);
 
     struct drawR_params
     {
-        double S_Cn_An[MAX_TERMS];
-        double n_L[MAX_TERMS];
+        Real S_Cn_An[MAX_TERMS];
+        Real n_L[MAX_TERMS];
         // variables H: for additional terms appearing as multiplicative factors etc.
-        double H[5];
+        Real H[5];
         int terms;
         // random number
-        double rnd;
+        Real rnd;
     };
 
-    static double drawR_f (double z, drawR_params const* params);
-    static double drawR_free_f (double z, drawR_params const* params);
+    static Real drawR_f (Real z, drawR_params const* params);
+    static Real drawR_free_f (Real z, drawR_params const* params);
 
 private:
     // The diffusion constant and drift velocity
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index a2c0ebda..d65810f8 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -43,19 +43,21 @@ class PlanarSurface
             multiply(base_type::shape().unit_y(), y));
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
     {
         //TODO: use the 2D BD function instead of the 3D one.
         return drawR_gbd_3D(rnd, r01, dt, D01);
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
     {
         //TODO: use the 2D BD function instead of the 3D one.
         return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
     }
 
-    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
     {
         return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng ); 
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 6433cb7a..bdda07b6 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -32,17 +32,19 @@ class SphericalSurface
         return position_type(); // TODO
     }
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
     {    
         return length_type(); // TODO
     }
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
     {    
         return Real(); //TODO
     }
 
-    virtual position_type dissociation_vector( rng_type& rng, length_type r01, Real dt, Real D01, Real v ) const
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
     {
         return position_type(); //TODO
     }
diff --git a/Structure.hpp b/Structure.hpp
index 772a3466..55548487 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -49,11 +49,11 @@ class Structure
 
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
 
-    virtual length_type drawR_gbd(Real rnd, length_type r01, Real dt, Real D01, Real v) const = 0;
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
 
-    virtual Real p_acceptance(Real k_a, Real dt, length_type r01, position_type ipv, Real D0, Real D1, Real v0, Real v1) const = 0;
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, Real const& D0, Real const& D1, Real const& v0, Real const& v1) const = 0;
 
-    virtual position_type dissociation_vector(rng_type& rng, length_type r01, Real dt, Real D01, Real v) const = 0;
+    virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
 

From 1dca449a241c50a0a2509f8f1b6301addca73593 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Sep 2011 12:36:03 +0200
Subject: [PATCH 0182/1541] new class with the containers + methods Moved the
 containers and encapsulated in ShellContainer class The class also contains
 all the methods for finding neighbors and will/should contain methods for
 other geometric calculations involving shells and surfaces.

---
 egfrd.py          | 324 ++++++++++++++++++++++++----------------------
 shellcontainer.py |  25 +++-
 2 files changed, 192 insertions(+), 157 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ad0238f8..3d7d269c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -10,9 +10,9 @@
     EventScheduler,
     Particle,
     SphericalShell,
-    SphericalShellContainer,
+#    SphericalShellContainer,
     CylindricalShell,
-    CylindricalShellContainer,
+#    CylindricalShellContainer,
     DomainIDGenerator,
     ShellIDGenerator,
     DomainID,
@@ -125,7 +125,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 						# NonInteractionSingles to a Pair or Interaction. It also defines
 						# the radius in which the NonInteractionSingle will burst.
 	self.MAX_NUM_DT0_STEPS = 10000
-        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
+#        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
 
 	# used datastructrures
         self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
@@ -142,8 +142,8 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.reset()				# The Simulator is only initialized at the first step, allowing
 						# modifications to the world to be made before simulation starts
 
-    def get_matrix_cell_size(self):
-        return self.containers[0].cell_size	# cell_size is the width of the (cubic) cell
+#    def get_matrix_cell_size(self):
+#        return self.containers[0].cell_size	# cell_size is the width of the (cubic) cell
 
     def get_next_time(self):
         """ 
@@ -156,15 +156,15 @@ def get_next_time(self):
             return self.scheduler.top[1].time
 
     # Here shell_size is actually the shell radius (and not shell diameter)
-    def set_user_max_shell_size(self, size):
-        self.user_max_shell_size = size
+#    def set_user_max_shell_size(self, size):
+#        self.user_max_shell_size = size
 
-    def get_user_max_shell_size(self):
-        return self.user_max_shell_size
+#    def get_user_max_shell_size(self):
+#        return self.user_max_shell_size
 
-    def get_max_shell_size(self):
-        return min(self.get_matrix_cell_size() * .5 / SAFETY,
-                   self.user_max_shell_size)
+#    def get_max_shell_size(self):
+#        return min(self.get_matrix_cell_size() * .5 / SAFETY,
+#                   self.user_max_shell_size)
 
     ###
     # The next methods control the general functioning of the simulator
@@ -218,10 +218,12 @@ def initialize(self):
 	# the containers hold the spherical and cylindrical shells respectively 
 	# the containers is a cache for the shell objects in the domain and is mostly
 	# read only. The only method that writes the containers is self.move_shell
-        self.containers = [SphericalShellContainer(self.world.world_size, 
-                                                   self.world.matrix_size),
-                           CylindricalShellContainer(self.world.world_size, 
-                                                     self.world.matrix_size)]
+#        self.containers = [SphericalShellContainer(self.world.world_size, 
+#                                                   self.world.matrix_size),
+#                           CylindricalShellContainer(self.world.world_size, 
+#                                                     self.world.matrix_size)]
+
+	self.geometrycontainer = ShellContainer(self.world)
 
 	# 2. Couple all the particles in 'world' to a new 'single' in the eGFRD simulator
         # Fix order of adding particles (always, or at least in debug mode).
@@ -393,7 +395,7 @@ def create_single(self, pid_particle_pair):
         self.domains[domain_id] = single
 
 	# 3. update the proper shell container
-        self.move_shell(single.shell_id_shell_pair)
+        self.geometrycontainer.move_shell(single.shell_id_shell_pair)
 
         if __debug__:
             # Used in __str__.
@@ -450,7 +452,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
         self.domains[domain_id] = interaction
 
 	# 3. update the shell containers 
-        self.move_shell(interaction.shell_id_shell_pair)
+        self.geometrycontainer.move_shell(interaction.shell_id_shell_pair)
 
         if __debug__:
             # Used in __str__.
@@ -500,7 +502,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         self.domains[domain_id] = pair
 
 	# 3. update the shell containers with the new shell
-        self.move_shell(pair.shell_id_shell_pair)
+        self.geometrycontainer.move_shell(pair.shell_id_shell_pair)
 
         if __debug__:
             # Used in __str__.
@@ -547,7 +549,7 @@ def move_single_shell(self, single, position, radius=None):
         shell_id_shell_pair = (shell_id, shell) 
 
         single.shell_id_shell_pair = shell_id_shell_pair
-        self.move_shell(shell_id_shell_pair)
+        self.geometrycontainer.move_shell(shell_id_shell_pair)
 
     def move_single_particle(self, single, position):
         new_pid_particle_pair = (single.pid_particle_pair[0],
@@ -559,12 +561,12 @@ def move_single_particle(self, single, position):
 
         self.world.update_particle(new_pid_particle_pair)
 
-    def get_container(self, shell):
-	# Returns the container that holds 'shell'
-        if type(shell) is SphericalShell:
-            return self.containers[0]
-        elif type(shell) is CylindricalShell:
-            return self.containers[1]
+#    def get_container(self, shell):
+#	# Returns the container that holds 'shell'
+#        if type(shell) is SphericalShell:
+#            return self.containers[0]
+#        elif type(shell) is CylindricalShell:
+#            return self.containers[1]
 
     def remove_domain(self, obj):
 	# Removes all the ties to a domain (single, pair, multi) from the system.
@@ -574,15 +576,16 @@ def remove_domain(self, obj):
             log.info("remove: %s" % obj)
 	# TODO assert that the domain is not still in the scheduler
         del self.domains[obj.domain_id]
-        for shell_id, shell in obj.shell_list:
-            container = self.get_container(shell)
-            del container[shell_id]
+        for shell_id_shell_pair in obj.shell_list:
+	    self.geometrycontainer.remove_shell(shell_id_shell_pair)
+#            container = self.get_container(shell)
+#            del container[shell_id]
 
-    def move_shell(self, shell_id_shell_pair):
-    # This is the only method that writes to the shell containers
-        shell = shell_id_shell_pair[1]
-        container = self.get_container(shell)
-        container.update(shell_id_shell_pair)
+#    def move_shell(self, shell_id_shell_pair):
+#    # This is the only method that writes to the shell containers
+#        shell = shell_id_shell_pair[1]
+#        container = self.get_container(shell)
+#        container.update(shell_id_shell_pair)
 
 
 ### TODO These methods can be made methods to the scheduler class
@@ -670,8 +673,9 @@ def clear_volume(self, pos, radius, ignore=[]):
 	# It is inefficient to burst on the 'other' side of the membrane or to
 	# burst in a circle, when you want to make a new shell in the membrane.
 	# Then we may want to burst in a cylindrical volume, not a sphere
-        neighbors = self.get_neighbors_within_radius_no_sort(pos, radius,
-                                                             ignore)
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius,
+                                                                               ignore)
+	neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
         return self.burst_objs(neighbors)
 
     def burst_non_multis(self, domains):
@@ -954,9 +958,11 @@ def make_new_domain(self, single):
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
-        intruders, closest, closest_distance = \
-            self.get_intruders(single_pos, reaction_threshold,
-                               ignore=[single.domain_id, ])
+        intruder_ids, closest_id, closest_distance = \
+            self.geometrycontainer.get_intruders(single_pos, reaction_threshold,
+                                                 ignore=[single.domain_id, ])
+	intruders = [self.domains[domain_id] for domain_id in intruder_ids]
+	closest = self.domains[closest_id]
 
         if __debug__:
             log.debug("intruders: %s, closest: %s (dist=%s)" %
@@ -1072,7 +1078,7 @@ def reject_single_reaction(self, single):
         if __debug__:
             log.info('single reaction; placing product failed.')
         self.domains[single.domain_id] = single
-        self.move_shell(single.shell_id_shell_pair)
+        self.geometrycontainer.move_shell(single.shell_id_shell_pair)
         self.rejected_moves += 1
         single.initialize(self.t)
         self.add_domain_event(single)
@@ -1116,7 +1122,7 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
         # 2. Check if min shell size for the Pair not larger than max shell size or 
         # sim cell size.
         min_shell_size_with_margin = min_shell_size + shell_size_margin
-        max_shell_size = min(self.get_max_shell_size(),
+        max_shell_size = min(self.geometrycontainer.get_max_shell_size(),
                              distance_from_sigma * 100 +
                              sigma + shell_size_margin)
 
@@ -1163,9 +1169,10 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 
         # 4. Determine shell size and check if closest object not too 
         # close (squeezing).
-        c, d = self.get_closest_obj(com, ignore=[single1.domain_id,
-                                                 single2.domain_id],
-                                    ignores=[single1.structure.id])
+        c, d = self.geometrycontainer.get_closest_obj(com, self.domains, ignore=[single1.domain_id,
+                                                      single2.domain_id],
+                                                      ignores=[single1.structure.id])
+
         if d < closest_shell_distance:
             closest, closest_shell_distance = c, d
 
@@ -1275,8 +1282,8 @@ def update_single(self, single):
 	# TODO we need the closest RELEVANT domain, i.e. the domain in the
 	# direction in which we can scale the domain
 	closest, distance_to_shell = \
-            self.get_closest_obj(singlepos, ignore=[single.domain_id],
-               	                 ignores=[single.structure.id])
+            self.geometrycontainer.get_closest_obj(singlepos, self.domains, ignore=[single.domain_id],
+               	                                   ignores=[single.structure.id])
 
         if isinstance(closest, NonInteractionSingle):
             closestpos = closest.shell.shape.position
@@ -1289,7 +1296,7 @@ def update_single(self, single):
             new_shell_size = max(new_shell_size,
                                  single.pid_particle_pair[1].radius)
 
-        new_shell_size = min(new_shell_size, self.get_max_shell_size())
+        new_shell_size = min(new_shell_size, self.geometrycontainer.get_max_shell_size())
 
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.
@@ -1565,8 +1572,9 @@ def propagate_pair(self, pair, dt, event_type):
         self.move_single(single1, newpos1, particle1[1].radius)
         self.move_single(single2, newpos2, particle2[1].radius)
 
+	# TODO This is not very clear or clean now. Also doesn't support MixedPair
         if __debug__:
-            container = self.get_container(single1.shell)
+            container = self.geometrycontainer.get_container(single1.shell)
             assert container[single1.shell_id].shape.radius == \
                    single1.shell.shape.radius
             assert container[single2.shell_id].shape.radius == \
@@ -1632,7 +1640,7 @@ def try_interaction(self, single, surface):
 
 	# Make sure the maximal cylinder fits in the maximal sphere. Matrix space
 	# doesn't allow to check for shells outside the maximal sphere.
-	max_cylinder_radius      = self.get_max_shell_size()/math.sqrt(2)
+	max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
 	max_cylinder_half_length = max_cylinder_radius
         if isinstance(surface, PlanarSurface):
             dr = max_cylinder_radius
@@ -1723,10 +1731,11 @@ def calculate_max_cylinder(self, single, surface, projected_point,
 	# the search point is the center of the sphere that surrounds the
 	# maximal cylinder
         search_point = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
-        all_neighbors = \
-            self.get_neighbors_within_radius_no_sort(search_point, 
-                                                     self.get_max_shell_size(),
+        all_neighbor_ids = \
+            self.geometrycontainer.get_neighbors_within_radius_no_sort(search_point, 
+                                                     self.geometrycontainer.get_max_shell_size(),
                                                      ignore=[single.domain_id])
+	all_neighbors = [self.domains[domain_id] for domain_id in all_neighbor_ids]
 
         for domain in all_neighbors:
             if isinstance(domain, Multi):
@@ -1950,8 +1959,9 @@ def add_to_multi_recursive(self, domain, multi):
 
             radius = domain.pid_particle_pair[1].radius * \
                 self.MULTI_SHELL_FACTOR
-            neighbors = self.get_neighbors_within_radius_no_sort(
+            neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(
                     objpos, radius, ignore=[domain.domain_id])
+	    neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
             burst = self.burst_non_multis(neighbors)
             neighbor_dists = self.obj_distance_array(objpos, burst)
@@ -1989,7 +1999,7 @@ def add_to_multi(self, single, multi):
 	shell = multi.create_new_shell(single.pid_particle_pair[1].position,
                 single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
 	shell_id_shell_pair = (shell_id, shell)
-        self.move_shell(shell_id_shell_pair)
+        self.geometrycontainer.move_shell(shell_id_shell_pair)
         multi.add_shell(shell_id_shell_pair)
         multi.add_particle(single.pid_particle_pair)
 
@@ -2009,7 +2019,7 @@ def merge_multis(self, multi1, multi2):
 
         for sid_shell_pair in multi1.shell_list:
             sid_shell_pair[1].did = multi2.domain_id
-            self.move_shell(sid_shell_pair)
+            self.geometrycontainer.move_shell(sid_shell_pair)
             multi2.add_shell(sid_shell_pair)
 
         for pid_particle_pair in multi1.particles:
@@ -2018,90 +2028,90 @@ def merge_multis(self, multi1, multi2):
         del self.domains[multi1.domain_id]
         self.remove_event(multi1)
 
-    def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
-        # Get neighbor domains within given radius.
-        #
-        # ignore: domain ids.
-        #
-        # Only returns neighbors, not the distances towards their 
-        # shells. Can for example be used to try to clear all objects 
-        # from a certain volume.
-
-        try:
-            for container in self.containers:
-                result = container.get_neighbors_within_radius(pos, radius)
-                # result = [((shell_id_shell_pair), distance), ]
-                # Since a domain can have more than 1 shell (multis for 
-                # example), and for each shell there is an entry in the 
-                # shell container, we make sure each domain occurs only once 
-                # in the returned list here.
-                for did in uniq(s[0][1].did for s in result):
-                    if did not in ignore:
-                        yield self.domains[did]
-        except AttributeError:
-            pass
-
-    def get_intruders(self, position, radius, ignore):
-	# gets the intruders in a spherical volume of radius 'radius'?
-	# TODO make this surface specific -> in 2D only need to check in cylinder,
-	# not in sphere
-        intruders = []   		# intruders are domains within radius
-        closest_domain = None		# closest domain, excluding intruders.
-        closest_distance = numpy.inf	# distance to the shell of the closest domain.
-
-        seen = set(ignore)
-        for container in self.containers:
-            neighbors = container.get_neighbors(position)
-            for n in neighbors:
-                domain_id = n[0][1].did
-                distance = n[1]
-                if distance > radius:
-                    if distance < closest_distance:
-                        # This is domain (the first one for this 
-                        # container) that has a shell that is more than 
-                        # radius away from pos.  If it is closer than 
-                        # the closest such one we found so far: store 
-                        # it. Always break out of the inner for loop and 
-                        # check the other containers.
-                        closest_domain = self.domains[domain_id]
-                        closest_distance = distance
-                        break
-                    else:
-                        break
-                elif domain_id not in seen:
-                    # Since a domain can have more than 1 shell (multis 
-                    # for example), and for each shell there is an entry 
-                    # in the shell container, we make sure each domain 
-                    # occurs only once in the returned list here.
-                    seen.add(domain_id)
-                    intruders.append(self.domains[domain_id])
-
-        return intruders, closest_domain, closest_distance
-
-    def get_closest_obj(self, pos, ignore=[], ignores=[]):
-        # ignore: domain ids.
-        closest_domain = None
-        closest_distance = numpy.inf
-
-        for container in self.containers:
-            result = container.get_neighbors(pos)
-
-            for shell_id_shell_pair, distance in result:
-                domain_id = shell_id_shell_pair[1].did 
-
-                if domain_id not in ignore and distance < closest_distance:
-                    domain = self.domains[domain_id]
-                    closest_domain, closest_distance = domain, distance
-                    # Found yet a closer domain. Break out of inner for 
-                    # loop and check other containers.
-                    break   
-
-        surface, distance = get_closest_surface(self.world, pos, ignores)
-
-        if distance < closest_distance:
-            return surface, distance
-        else:
-            return closest_domain, closest_distance
+#    def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
+#        # Get neighbor domains within given radius.
+#        #
+#        # ignore: domain ids.
+#        #
+#        # Only returns neighbors, not the distances towards their 
+#        # shells. Can for example be used to try to clear all objects 
+#        # from a certain volume.
+#
+#        try:
+#            for container in self.containers:
+#                result = container.get_neighbors_within_radius(pos, radius)
+#                # result = [((shell_id_shell_pair), distance), ]
+#                # Since a domain can have more than 1 shell (multis for 
+#                # example), and for each shell there is an entry in the 
+#                # shell container, we make sure each domain occurs only once 
+#                # in the returned list here.
+#                for did in uniq(s[0][1].did for s in result):
+#                    if did not in ignore:
+#                        yield self.domains[did]
+#        except AttributeError:
+#            pass
+#
+#    def get_intruders(self, position, radius, ignore):
+#	# gets the intruders in a spherical volume of radius 'radius'?
+#	# TODO make this surface specific -> in 2D only need to check in cylinder,
+#	# not in sphere
+#        intruders = []   		# intruders are domains within radius
+#        closest_domain = None		# closest domain, excluding intruders.
+#        closest_distance = numpy.inf	# distance to the shell of the closest domain.
+#
+#        seen = set(ignore)
+#        for container in self.containers:
+#            neighbors = container.get_neighbors(position)
+#            for n in neighbors:
+#                domain_id = n[0][1].did
+#                distance = n[1]
+#                if distance > radius:
+#                    if distance < closest_distance:
+#                        # This is domain (the first one for this 
+#                        # container) that has a shell that is more than 
+#                        # radius away from pos.  If it is closer than 
+#                        # the closest such one we found so far: store 
+#                        # it. Always break out of the inner for loop and 
+#                        # check the other containers.
+#                        closest_domain = self.domains[domain_id]
+#                        closest_distance = distance
+#                        break
+#                    else:
+#                        break
+#                elif domain_id not in seen:
+#                    # Since a domain can have more than 1 shell (multis 
+#                    # for example), and for each shell there is an entry 
+#                    # in the shell container, we make sure each domain 
+#                    # occurs only once in the returned list here.
+#                    seen.add(domain_id)
+#                    intruders.append(self.domains[domain_id])
+#
+#        return intruders, closest_domain, closest_distance
+#
+#    def get_closest_obj(self, pos, ignore=[], ignores=[]):
+#        # ignore: domain ids.
+#        closest_domain = None
+#        closest_distance = numpy.inf
+#
+#        for container in self.containers:
+#            result = container.get_neighbors(pos)
+#
+#            for shell_id_shell_pair, distance in result:
+#                domain_id = shell_id_shell_pair[1].did 
+#
+#                if domain_id not in ignore and distance < closest_distance:
+#                    domain = self.domains[domain_id]
+#                    closest_domain, closest_distance = domain, distance
+#                    # Found yet a closer domain. Break out of inner for 
+#                    # loop and check other containers.
+#                    break   
+#
+#        surface, distance = get_closest_surface(self.world, pos, ignores)
+#
+#        if distance < closest_distance:
+#            return surface, distance
+#        else:
+#            return closest_domain, closest_distance
 
     def domain_distance(self, pos, domain):
 	# calculates the shortest distance from 'pos' to A shell (a Multi
@@ -2176,9 +2186,10 @@ def check_obj(self, obj):
             ignores = [obj.structure.id]
 
         for shell_id, shell in obj.shell_list:
-            closest, distance = self.get_closest_obj(shell.shape.position,
-                                                     ignore=[obj.domain_id],
-                                                     ignores=ignores)
+            closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
+								       self.domains,
+                                                                       ignore=[obj.domain_id],
+                                                                       ignores=ignores)
             if(type(shell.shape) is Cylinder and
                closest and type(closest.shell.shape) is Sphere):
                 # Note: this case is special.
@@ -2207,11 +2218,11 @@ def check_obj(self, obj):
                     shell_size = shell.shape.radius
                 diff = distance - shell_size
 
-            assert shell_size <= self.get_user_max_shell_size(), \
+            assert shell_size <= self.geometrycontainer.get_user_max_shell_size(), \
                 '%s shell size larger than user-set max shell size' % \
                 str(shell_id)
 
-            assert shell_size <= self.get_max_shell_size(), \
+            assert shell_size <= self.geometrycontainer.get_max_shell_size(), \
                 '%s shell size larger than simulator cell size / 2' % \
                 str(shell_id)
 
@@ -2242,15 +2253,17 @@ def check_event_stoichiometry(self):
                                (world_population, domain_population))
 
     def check_shell_matrix(self):
-        did_map = {}
-        shell_map = {}
-        for container in self.containers:
-            if self.world.world_size != container.world_size:
-                raise RuntimeError('self.world.world_size != '
-                                   'container.world_size')
-            for shell_id, shell in container:
-                did_map.setdefault(shell.did, []).append(shell_id)
-                shell_map[shell_id] = shell
+#        did_map = {}
+#        shell_map = {}
+#        for container in self.containers:
+#            if self.world.world_size != container.world_size:
+#                raise RuntimeError('self.world.world_size != '
+#                                   'container.world_size')
+#            for shell_id, shell in container:
+#                did_map.setdefault(shell.did, []).append(shell_id)
+#                shell_map[shell_id] = shell
+
+	did_map, shell_map = self.geometrycontainer.get_dids_shells()
 
         shell_population = 0
         for id, event in self.scheduler:
@@ -2268,8 +2281,9 @@ def check_shell_matrix(self):
                                    (len(shell_ids), domain.num_shells, 
                                     domain.domain_id, diff))
 
-        matrix_population = sum(len(container)
-                                for container in self.containers)
+        matrix_population = self.geometrycontainer.get_total_num_shells()
+#        matrix_population = sum(len(container)
+#                                for container in self.containers)
         if shell_population != matrix_population:
             raise RuntimeError('num shells (%d) != matrix population (%d)' %
                                (shell_population, matrix_population))
diff --git a/shellcontainer.py b/shellcontainer.py
index 2c7744a5..6cde81a9 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -9,6 +9,9 @@
     CylindricalShellContainer
     )
 from utils import *
+from gfrdbase import (
+    get_closest_surface
+    )
 
 class ShellContainer(object):
 
@@ -94,8 +97,10 @@ def get_intruders(self, position, radius, ignore):
 
         return intruders, closest_domain, closest_distance
 
-    def get_closest_obj(self, pos, ignore=[], ignores=[]):
+    def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
         # ignore: domain ids.
+	# TODO It's bad to pass the domains to this function, but is currently
+	# only way to be able to return a domain object (instead of domain_id)
         closest_domain = None
         closest_distance = numpy.inf
 
@@ -106,7 +111,8 @@ def get_closest_obj(self, pos, ignore=[], ignores=[]):
                 domain_id = shell_id_shell_pair[1].did
 
                 if domain_id not in ignore and distance < closest_distance:
-                    closest_domain, closest_distance = domain_id, distance
+		    domain = domains[domain_id]
+                    closest_domain, closest_distance = domain, distance
                     # Found yet a closer domain. Break out of inner for 
                     # loop and check other containers.
                     break
@@ -142,4 +148,19 @@ def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         except AttributeError:
             pass
 
+    def get_dids_shells(self):
+        did_map = {}
+        shell_map = {}
+        for container in self.containers:
+            if self.world.world_size != container.world_size:
+                raise RuntimeError('self.world.world_size != '
+                                   'container.world_size')
+            for shell_id, shell in container:
+                did_map.setdefault(shell.did, []).append(shell_id)
+                shell_map[shell_id] = shell
+
+	return did_map, shell_map
+
+    def get_total_num_shells(self):
+	return sum(len(container) for container in self.containers)
 

From 94a3d8537a10e85091db1dd602561d3b648674d1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Sep 2011 14:01:18 +0200
Subject: [PATCH 0183/1541] cleanup-> throw away old unused outcommented code

---
 egfrd.py          | 147 ----------------------------------------------
 gfrdbase.py       |  15 +----
 multi.py          |   2 -
 shellcontainer.py |   8 ++-
 4 files changed, 6 insertions(+), 166 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3d7d269c..fce25796 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -10,9 +10,7 @@
     EventScheduler,
     Particle,
     SphericalShell,
-#    SphericalShellContainer,
     CylindricalShell,
-#    CylindricalShellContainer,
     DomainIDGenerator,
     ShellIDGenerator,
     DomainID,
@@ -125,7 +123,6 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 						# NonInteractionSingles to a Pair or Interaction. It also defines
 						# the radius in which the NonInteractionSingle will burst.
 	self.MAX_NUM_DT0_STEPS = 10000
-#        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
 
 	# used datastructrures
         self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
@@ -142,9 +139,6 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.reset()				# The Simulator is only initialized at the first step, allowing
 						# modifications to the world to be made before simulation starts
 
-#    def get_matrix_cell_size(self):
-#        return self.containers[0].cell_size	# cell_size is the width of the (cubic) cell
-
     def get_next_time(self):
         """ 
         Returns the time it will be when the next egfrd timestep
@@ -155,17 +149,6 @@ def get_next_time(self):
 	else:
             return self.scheduler.top[1].time
 
-    # Here shell_size is actually the shell radius (and not shell diameter)
-#    def set_user_max_shell_size(self, size):
-#        self.user_max_shell_size = size
-
-#    def get_user_max_shell_size(self):
-#        return self.user_max_shell_size
-
-#    def get_max_shell_size(self):
-#        return min(self.get_matrix_cell_size() * .5 / SAFETY,
-#                   self.user_max_shell_size)
-
     ###
     # The next methods control the general functioning of the simulator
     ###
@@ -215,14 +198,6 @@ def initialize(self):
         self.domains = {}
 
 	# create/clear other datastructures
-	# the containers hold the spherical and cylindrical shells respectively 
-	# the containers is a cache for the shell objects in the domain and is mostly
-	# read only. The only method that writes the containers is self.move_shell
-#        self.containers = [SphericalShellContainer(self.world.world_size, 
-#                                                   self.world.matrix_size),
-#                           CylindricalShellContainer(self.world.world_size, 
-#                                                     self.world.matrix_size)]
-
 	self.geometrycontainer = ShellContainer(self.world)
 
 	# 2. Couple all the particles in 'world' to a new 'single' in the eGFRD simulator
@@ -561,13 +536,6 @@ def move_single_particle(self, single, position):
 
         self.world.update_particle(new_pid_particle_pair)
 
-#    def get_container(self, shell):
-#	# Returns the container that holds 'shell'
-#        if type(shell) is SphericalShell:
-#            return self.containers[0]
-#        elif type(shell) is CylindricalShell:
-#            return self.containers[1]
-
     def remove_domain(self, obj):
 	# Removes all the ties to a domain (single, pair, multi) from the system.
 	# Note that the particles that it represented still exist
@@ -578,15 +546,6 @@ def remove_domain(self, obj):
         del self.domains[obj.domain_id]
         for shell_id_shell_pair in obj.shell_list:
 	    self.geometrycontainer.remove_shell(shell_id_shell_pair)
-#            container = self.get_container(shell)
-#            del container[shell_id]
-
-#    def move_shell(self, shell_id_shell_pair):
-#    # This is the only method that writes to the shell containers
-#        shell = shell_id_shell_pair[1]
-#        container = self.get_container(shell)
-#        container.update(shell_id_shell_pair)
-
 
 ### TODO These methods can be made methods to the scheduler class
     def add_domain_event(self, domain):
@@ -1982,20 +1941,11 @@ def add_to_multi_recursive(self, domain, multi):
         else:
             assert False, 'do not reach here.'  # Pairs are burst
 
-#    def new_spherical_shell(self, domain_id, pos, size):
-#        shell_id_shell_pair = (
-#            self.shell_id_generator(),
-#            SphericalShell(domain_id, Sphere(pos, size)))
-#        self.move_shell(shell_id_shell_pair)
-#        return shell_id_shell_pair
-
     def add_to_multi(self, single, multi):
         if __debug__:
             log.info('add to multi:\n  %s\n  %s' % (single, multi))
 
 	shell_id = self.shell_id_generator()
-#        sid_shell_pair = self.new_spherical_shell(
-#            multi.domain_id,
 	shell = multi.create_new_shell(single.pid_particle_pair[1].position,
                 single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
 	shell_id_shell_pair = (shell_id, shell)
@@ -2028,91 +1978,6 @@ def merge_multis(self, multi1, multi2):
         del self.domains[multi1.domain_id]
         self.remove_event(multi1)
 
-#    def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
-#        # Get neighbor domains within given radius.
-#        #
-#        # ignore: domain ids.
-#        #
-#        # Only returns neighbors, not the distances towards their 
-#        # shells. Can for example be used to try to clear all objects 
-#        # from a certain volume.
-#
-#        try:
-#            for container in self.containers:
-#                result = container.get_neighbors_within_radius(pos, radius)
-#                # result = [((shell_id_shell_pair), distance), ]
-#                # Since a domain can have more than 1 shell (multis for 
-#                # example), and for each shell there is an entry in the 
-#                # shell container, we make sure each domain occurs only once 
-#                # in the returned list here.
-#                for did in uniq(s[0][1].did for s in result):
-#                    if did not in ignore:
-#                        yield self.domains[did]
-#        except AttributeError:
-#            pass
-#
-#    def get_intruders(self, position, radius, ignore):
-#	# gets the intruders in a spherical volume of radius 'radius'?
-#	# TODO make this surface specific -> in 2D only need to check in cylinder,
-#	# not in sphere
-#        intruders = []   		# intruders are domains within radius
-#        closest_domain = None		# closest domain, excluding intruders.
-#        closest_distance = numpy.inf	# distance to the shell of the closest domain.
-#
-#        seen = set(ignore)
-#        for container in self.containers:
-#            neighbors = container.get_neighbors(position)
-#            for n in neighbors:
-#                domain_id = n[0][1].did
-#                distance = n[1]
-#                if distance > radius:
-#                    if distance < closest_distance:
-#                        # This is domain (the first one for this 
-#                        # container) that has a shell that is more than 
-#                        # radius away from pos.  If it is closer than 
-#                        # the closest such one we found so far: store 
-#                        # it. Always break out of the inner for loop and 
-#                        # check the other containers.
-#                        closest_domain = self.domains[domain_id]
-#                        closest_distance = distance
-#                        break
-#                    else:
-#                        break
-#                elif domain_id not in seen:
-#                    # Since a domain can have more than 1 shell (multis 
-#                    # for example), and for each shell there is an entry 
-#                    # in the shell container, we make sure each domain 
-#                    # occurs only once in the returned list here.
-#                    seen.add(domain_id)
-#                    intruders.append(self.domains[domain_id])
-#
-#        return intruders, closest_domain, closest_distance
-#
-#    def get_closest_obj(self, pos, ignore=[], ignores=[]):
-#        # ignore: domain ids.
-#        closest_domain = None
-#        closest_distance = numpy.inf
-#
-#        for container in self.containers:
-#            result = container.get_neighbors(pos)
-#
-#            for shell_id_shell_pair, distance in result:
-#                domain_id = shell_id_shell_pair[1].did 
-#
-#                if domain_id not in ignore and distance < closest_distance:
-#                    domain = self.domains[domain_id]
-#                    closest_domain, closest_distance = domain, distance
-#                    # Found yet a closer domain. Break out of inner for 
-#                    # loop and check other containers.
-#                    break   
-#
-#        surface, distance = get_closest_surface(self.world, pos, ignores)
-#
-#        if distance < closest_distance:
-#            return surface, distance
-#        else:
-#            return closest_domain, closest_distance
-
     def domain_distance(self, pos, domain):
 	# calculates the shortest distance from 'pos' to A shell (a Multi
 	# can have multiple) of 'domain'.
@@ -2253,16 +2118,6 @@ def check_event_stoichiometry(self):
                                (world_population, domain_population))
 
     def check_shell_matrix(self):
-#        did_map = {}
-#        shell_map = {}
-#        for container in self.containers:
-#            if self.world.world_size != container.world_size:
-#                raise RuntimeError('self.world.world_size != '
-#                                   'container.world_size')
-#            for shell_id, shell in container:
-#                did_map.setdefault(shell.did, []).append(shell_id)
-#                shell_map[shell_id] = shell
-
 	did_map, shell_map = self.geometrycontainer.get_dids_shells()
 
         shell_population = 0
@@ -2282,8 +2137,6 @@ def check_shell_matrix(self):
                                     domain.domain_id, diff))
 
         matrix_population = self.geometrycontainer.get_total_num_shells()
-#        matrix_population = sum(len(container)
-#                                for container in self.containers)
         if shell_population != matrix_population:
             raise RuntimeError('num shells (%d) != matrix population (%d)' %
                                (shell_population, matrix_population))
diff --git a/gfrdbase.py b/gfrdbase.py
index e281360d..ea07cc51 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -27,8 +27,7 @@
     'NoSpace',
     'create_world',
     'ParticleSimulatorBase',
-    'get_closest_surface'#,
-#    'get_closest_surface_within_radius'
+    'get_closest_surface',
     ]
 
 World = _gfrd.World
@@ -103,18 +102,6 @@ def get_closest_surface(world, pos, ignore):
     else:
         return None, numpy.inf
 
-#def get_closest_surface_within_radius(world, pos, radius, ignore):
-#    """Return:
-#      - surface within radius or None
-#      - closest surface (regardless of radius)
-#      - distance to closest surface"""
-#
-#    surface, distance = get_closest_surface(world, pos, ignore) 
-#    if distance < radius:
-#        return surface, surface, distance
-#    else:
-#        return None, surface, distance
-
 def create_world(m, matrix_size=10):
     """Create a world object.
     
diff --git a/multi.py b/multi.py
index 30acb3c0..49ff5b8c 100644
--- a/multi.py
+++ b/multi.py
@@ -17,8 +17,6 @@ def __init__(self, domain_id, main, dt_factor):
 	Domain.__init__(self, domain_id)
 
         self.main = ref(main)
-#        self.domain_id = domain_id
-#        self.event_id = None
         self.last_event = None
 	self.event_Type = EventType.MULTI_DIFFUSION
 
diff --git a/shellcontainer.py b/shellcontainer.py
index 6cde81a9..1901635d 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -26,11 +26,12 @@ def __init__(self, world):
                                                      world.matrix_size)]
 
 	self.world = world
-        self.user_max_shell_size = numpy.inf
+        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
 
     def get_matrix_cell_size(self):
 	return self.containers[0].cell_size     # cell_size is the width of the (cubic) cell
 
+    # Here shell_size is actually the shell radius (and not shell diameter)
     def set_user_max_shell_size(self, size):
         self.user_max_shell_size = size
 
@@ -42,7 +43,8 @@ def get_max_shell_size(self):
                    self.user_max_shell_size)
 
     def get_container(self, shell):
-        # Returns the container that holds 'shell'
+    # Private method
+    # Returns the container that holds 'shell'
         if type(shell) is SphericalShell:
             return self.containers[0]
         elif type(shell) is CylindricalShell:
@@ -130,7 +132,7 @@ def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         #
         # ignore: domain ids.
         #
-        # Only returns neighbors, not the distances towards their 
+        # Only returns neighbor domain_ids, not the distances towards their 
         # shells. Can for example be used to try to clear all objects 
         # from a certain volume.
 

From 2dff481c803c74081a11c362235fe7fc0d138258 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Sep 2011 15:51:23 +0200
Subject: [PATCH 0184/1541] turned helix off in pipeline. Now default is just a
 cylinder

---
 visualization/pipeline.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/visualization/pipeline.py b/visualization/pipeline.py
index 9e7fc148..f4425ec3 100644
--- a/visualization/pipeline.py
+++ b/visualization/pipeline.py
@@ -14,7 +14,7 @@
 PARTICLES = True
 SPHERES   = True
 CYLINDERS = True
-HELIX     = True
+HELIX     = False
 SURFACES  = True
 
 DARK_BACKGROUND = True

From 8ff74273541474ad5bc06fdca83f2217930a68a5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Sep 2011 15:52:16 +0200
Subject: [PATCH 0185/1541] added some debugging lines printing stuff

---
 GreensFunction2DRadAbs.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index b87d96d4..c6dec052 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -1102,6 +1102,7 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real a_Anm (a*alpha);
         const Real r0Anm (r0*alpha);
 
+	std::clog << "|";	// DEBUG
         // calculate the needed bessel functions
         const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
         const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    // prime
@@ -1110,6 +1111,7 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
 
         const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
         const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
+	std::clog << "_";	// DEBUG
 
         // calculating An,m
         const Real h_ma (h - realm/sigma);

From 942a2e2a4c6234082000a31c98e7dfbd5e9bfcd4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Sep 2011 15:52:52 +0200
Subject: [PATCH 0186/1541] reworked comment explaining the making of
 cylindrical shell for interactions

---
 egfrd.py | 38 ++++++++++++++++++--------------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fce25796..9c3a8a6f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1579,28 +1579,14 @@ def try_interaction(self, single, surface):
 
 	### 1. See if there is enough space for the shell
 
-        # For an interaction with a PlanarSurface (membrane):
-        # * dr is the radius of the cylinder.
-        # * dz_left determines how much the cylinder is sticking out on the 
-        # other side of the surface, measured from the projected point.
-        # * dz_right is the distance between the particle position and 
-        # the edge of the cylinder in the direction normal to the membrane.
-        #
-        # For interaction with a CylindricalSurface (dna):
-        # * dr is the distance between the particle position and the 
-        # edge of the cylinder in the r direction.
-        # * dz_left is the distance from the projected point to the left edge 
-        # of the cylinder.
-        # * dz_right is the distance from the projected point to the right edge 
-        # of the cylinder.
-
-        # Initialize dr, dz_left, dz_right to maximum allowed values.
-        # And decide minimal dr, dz_left, dz_right.
 
 	# Make sure the maximal cylinder fits in the maximal sphere. Matrix space
 	# doesn't allow to check for shells outside the maximal sphere.
 	max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
 	max_cylinder_half_length = max_cylinder_radius
+
+        # Initialize dr, dz_left, dz_right to maximum allowed values.
+        # And decide minimal dr, dz_left, dz_right.
         if isinstance(surface, PlanarSurface):
             dr = max_cylinder_radius
             # Leave enough for the particle itself to the left.
@@ -1666,7 +1652,7 @@ def try_interaction(self, single, surface):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
-#        assert self.check_obj(interaction)
+        assert self.check_obj(interaction)
         self.add_domain_event(interaction)
 
         if __debug__:
@@ -1684,8 +1670,20 @@ def calculate_max_cylinder(self, single, surface, projected_point,
         # Find optimal cylinder around particle and surface, such that 
         # it is not interfering with other shells.
 	#
-        # get_shell_size is overridden for cylindrical singles and 
-        # pairs.
+	# To determine the maximal cylindrical shell a starting cylinder is defined
+	# * The projected_point is a reference point along the axis of the cylinder,
+	#   the position, z, can be chosen freely
+	# * orientation_vector is a vector along the z-axis providing orientation
+	#   It usually points in the general direction of the particle
+	#
+        # * dr is the radius of the cylinder.
+        # * dz_right is the distance between the projected_point and the face of the
+	#   cylinder on the side of the orientation_vector 
+        # * dz_left is the distance from the projected_point to the face of the cylinder
+	#   on the side oposite of the orientation_vector
+	#
+	# * particle_distance is the distance from the center of the particle to the
+	#   projected_point
 
 	# the search point is the center of the sphere that surrounds the
 	# maximal cylinder

From e2a9979d3bbabeedd6d2387308d7d3290b6210a8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Sep 2011 18:09:32 +0200
Subject: [PATCH 0187/1541] fixed (to some extend) distance calculation to
 surface

---
 gfrdbase.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index ea07cc51..1ebeb471 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -94,8 +94,8 @@ def get_closest_surface(world, pos, ignore):
         if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
             pos_transposed = \
                 world.cyclic_transpose(pos, surface.shape.position)
-            distance = abs(world.distance(surface.shape, pos_transposed))	# This should not be here but C++ code
-            surfaces_and_distances_to_surfaces.append((surface, distance))
+	    _, distance = surface.projected_point(pos_transposed)	# This should not be here but C++ code
+            surfaces_and_distances_to_surfaces.append((surface, abs(distance)))
 
     if surfaces_and_distances_to_surfaces:
         return min(surfaces_and_distances_to_surfaces)

From 889ed83921b3c2d7793e72953e724ad439a50272 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Sep 2011 15:20:06 +0200
Subject: [PATCH 0188/1541] some comments and enters to clarify the code

---
 Plane.hpp          | 29 ++++++++++++++++++-----------
 StructureUtils.hpp |  5 ++++-
 geometry.hpp       | 25 ++++++++++++++++++++-----
 3 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index 705d4b3a..c9d4957c 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -178,6 +178,7 @@ class Plane
 template<typename T_>
 inline boost::array<typename Plane<T_>::length_type, 3>
 to_internal(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// The function calculates the coefficients to express 'pos' into the base of the plane 'obj'
 {
     typedef typename Plane<T_>::position_type position_type;
     position_type pos_vector(subtract(pos, obj.position()));
@@ -192,53 +193,59 @@ template<typename T_>
 inline std::pair<typename Plane<T_>::position_type,
                  typename Plane<T_>::length_type>
 projected_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Calculates the projection of 'pos' onto the plane 'obj' and also returns the coefficient
+// for the normal component (z) of 'pos' in the basis of the plane
 {
     boost::array<typename Plane<T_>::length_type, 3> x_y_z(to_internal(obj, pos));
     return std::make_pair(
         add(add(obj.position(), multiply(obj.unit_x(), x_y_z[0])),
-            multiply(obj.unit_y(), x_y_z[1])),
+                                multiply(obj.unit_y(), x_y_z[1])),
         x_y_z[2]);
 }
 
 template<typename T_>
 inline typename Plane<T_>::length_type
 distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Calculates the distance from 'pos' to plane 'obj' Note that when the plane is finite,
+// and also calculates the distance to the edge of the plane if necessary
 {
     typedef typename Plane<T_>::length_type length_type;
     boost::array<length_type, 3> const x_y_z(to_internal(obj, pos));
 
-    length_type const dx(subtract(abs(x_y_z[0]), obj.half_extent()[0]));
-    length_type const dy(subtract(abs(x_y_z[1]), obj.half_extent()[1]));
+    length_type const dx(subtract( abs(x_y_z[0]), obj.half_extent()[0]));
+    length_type const dy(subtract( abs(x_y_z[1]), obj.half_extent()[1]));
 
     if (dx < 0 && dy < 0) {
-        // Projected point of pos is on the plane.
-        // Probably an infinite plane anyway.
-        return x_y_z[2];
+        // pos is positioned over the plane (projected point is in the plane and
+	// not next to it).
+        return abs(x_y_z[2]);
     }
 
-    if (dx > 0)
+    if (dx > 0) // outside the plane in the x direction
     {
         if (dy > 0)
         {
-            // Far away from plane.
+            // outside the plane in both x and y direction
             return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(dy) +
                              gsl_pow_2(x_y_z[2]));
         }
         else
         {
+	    // outside the plane in x, but inside in y direction
             return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(x_y_z[2]));
         }
     }
-    else
+    else   // inside the plane in x direction
     {
         if (dy > 0)
         {
+	    // outside the plane in y, but inside in x direction
             return std::sqrt(gsl_pow_2(dy) + gsl_pow_2(x_y_z[2]));
         }
         else
         {
-            // Already tested above.
-            return x_y_z[2];
+            // inside the plane in both x and y direction (see above)
+            return abs(x_y_z[2]);
         }
     }
 }
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index bc9e037b..ab847e0d 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -42,11 +42,14 @@ struct StructureUtils
         BOOST_ASSERT(is_cartesian_versor(unit_y));
         BOOST_ASSERT(is_cartesian_versor(cross_product(unit_x, unit_y)));
 
+	// Note that when calling the function the origin is in the corner and the length
+	// is the whole length of the plane, whereas for 'plane_type' the origin is in the
+	// center of the plane (pos) and that the length is only half lengths 'half_lx' and 'half_ly'.
         const length_type half_lx(lx / 2);
         const length_type half_ly(ly / 2);
 
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
-                                    multiply(unit_y, half_ly)));
+                                                multiply(unit_y, half_ly)));
 
         return new planar_surface_type(id,
                                        plane_type(pos, unit_x, unit_y,
diff --git a/geometry.hpp b/geometry.hpp
index eccc3223..87cc0c09 100644
--- a/geometry.hpp
+++ b/geometry.hpp
@@ -8,14 +8,15 @@
 
 template< typename T1_, typename T2_ >
 inline typename element_type_of< T1_ >::type distance(
-        T1_ const& p1, T2_ const p2,
+        T1_ const& p1,
+        T2_ const& p2,
         typename boost::enable_if<
             typename boost::mpl::and_<
                 is_vector3<T1_>,
                 is_vector3<T2_> > >::type* = 0)
 {
     return std::sqrt(
-        gsl_pow_2( p1[0] - p2[0] )
+          gsl_pow_2( p1[0] - p2[0] )
         + gsl_pow_2( p1[1] - p2[1] ) 
         + gsl_pow_2( p1[2] - p2[2] ) );
 }
@@ -51,7 +52,11 @@ inline T_ normalize(T_ const& p,
  * note that the returned transposed pos1 may not be within the cyclic boundary.
  */
 template<typename T_>
-inline T_ cyclic_transpose(T_ const& p0, T_ const& p1, T_ const& world_size, typename boost::enable_if<is_scalar<T_> >::type*)
+inline T_ cyclic_transpose(T_ const& p0,
+                           T_ const& p1,
+                           T_ const& world_size,
+                           typename boost::enable_if<is_scalar<T_> >::type*)
+// Used when T_ is only a number (one dimensionally)
 {
     const T_ diff(p1 - p0), half(world_size / 2);
     if (diff > half)
@@ -69,7 +74,11 @@ inline T_ cyclic_transpose(T_ const& p0, T_ const& p1, T_ const& world_size, typ
 }
 
 template<typename T_>
-inline T_ cyclic_transpose(T_ const& p0, T_ const& p1, typename element_type_of<T_>::type const& world_size, typename boost::enable_if<is_vector3<T_> >::type*)
+inline T_ cyclic_transpose(T_ const& p0,
+                           T_ const& p1,
+                           typename element_type_of<T_>::type const& world_size,
+                           typename boost::enable_if<is_vector3<T_> >::type*)
+// Used when the arguments are vectors of length three
 {
     T_ retval;
     retval[0] = cyclic_transpose(p0[0], p1[0], world_size, (void*)0);
@@ -79,11 +88,17 @@ inline T_ cyclic_transpose(T_ const& p0, T_ const& p1, typename element_type_of<
 }
 
 template<typename T1_, typename T2_>
-inline T1_ cyclic_transpose(T1_ const& p0, T1_ const& p1, T2_ const& world_size)
+inline T1_ cyclic_transpose(T1_ const& p0,
+                            T1_ const& p1,
+                            T2_ const& world_size)
+// Used when last argument is not given
 {
     return cyclic_transpose(p0, p1, world_size, (void*)0);
 }
 
+
+
+
 template<typename T_>
 inline T_ apply_boundary(T_ const& p1, T_ const& world_size, typename boost::enable_if<is_scalar<T_> >::type*)
 {

From d6796e2dd93abb430042a4a4cbd257c98a2dfcad Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Sep 2011 15:21:07 +0200
Subject: [PATCH 0189/1541] fixed bug in finding the closest surface

---
 gfrdbase.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 1ebeb471..3aad7eb4 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -88,17 +88,18 @@ def get_closest_surface(world, pos, ignore):
     origin of the surface would not be in the same or neighboring 
     cells as pos."""
 
-    surfaces_and_distances_to_surfaces = []
+    distances_and_surfaces = []
 
     for surface in world.structures:
         if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
             pos_transposed = \
                 world.cyclic_transpose(pos, surface.shape.position)
-	    _, distance = surface.projected_point(pos_transposed)	# This should not be here but C++ code
-            surfaces_and_distances_to_surfaces.append((surface, abs(distance)))
+	    distance = world.distance(surface.shape, pos_transposed)
+            distances_and_surfaces.append((distance, surface))
 
-    if surfaces_and_distances_to_surfaces:
-        return min(surfaces_and_distances_to_surfaces)
+    if distances_and_surfaces:
+	distance, surface = min(distances_and_surfaces)
+        return surface, distance
     else:
         return None, numpy.inf
 

From 643eac9604a0900a68421a18ee1b98bf2f9e3377 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Sep 2011 18:16:42 +0200
Subject: [PATCH 0190/1541] small bugfixes for CylindricalInteractionSingle

---
 single.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/single.py b/single.py
index 5b31cb7d..3d7b10bb 100644
--- a/single.py
+++ b/single.py
@@ -556,7 +556,7 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
 				   structure, shell_id, interactionrules, surface)
 
 	# z0 is implied to be zero (the particle being in the center of the shell in the z direction)
-	self.z0 = 0
+	self.z0 = z0
 	self.unit_r = unit_r	# This is the vector from the cylinder to the particle
 	self.r0 = r0		# r0 is the distance from the center of the cylinder to the
 				# center of the particle
@@ -568,7 +568,7 @@ def get_inner_dz_left(self):
 	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_dz_right(self):
-	return self.get_inner_dz_left()	- self.pid_particle_pair[1].radius
+	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_sigma(self):
 	return self.surface.shape.radius + self.pid_particle_pair[1].radius
@@ -576,7 +576,7 @@ def get_inner_sigma(self):
     def greens_function(self):
 	# The greens function not used for the interaction but for the other coordinate
         # Free diffusion in z direction, drift is zero.
-        return GreensFunction1DAbsAbs(self.D, 0, z0,
+        return GreensFunction1DAbsAbs(self.D, 0.0, self.z0,
                                       -self.get_inner_dz_left(),
                                       self.get_inner_dz_right())
 
@@ -629,7 +629,7 @@ def draw_new_position(self, dt, event_type):
         	r = sigma
             else:
         	r = draw_r_wrapper(gf_iv, dt, a_r, sigma)
-            theta = draw_theta_wrapper(iv_gf, r, dt)
+            theta = draw_theta_wrapper(gf_iv, r, dt)
 
             r_vector = r * rotate_vector(self.unit_r, self.shell.shape.unit_z,
                                      theta)

From 70a19063b29bcb635e646b2cf98fcafee2f5825a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Sep 2011 18:18:08 +0200
Subject: [PATCH 0191/1541] small changes and fixes

---
 egfrd.py    | 9 ++++-----
 gfrdbase.py | 2 +-
 pair.py     | 4 +++-
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9c3a8a6f..3efaf4a5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -921,12 +921,10 @@ def make_new_domain(self, single):
             self.geometrycontainer.get_intruders(single_pos, reaction_threshold,
                                                  ignore=[single.domain_id, ])
 	intruders = [self.domains[domain_id] for domain_id in intruder_ids]
-	closest = self.domains[closest_id]
 
         if __debug__:
-            log.debug("intruders: %s, closest: %s (dist=%s)" %
-                      (', '.join(str(i) for i in intruders),
-                       closest, FORMAT_DOUBLE % closest_distance))
+            log.debug("intruders: %s" %
+                      (', '.join(str(i) for i in intruders)))
 
 
         # 2.2 Burst the shells with the following conditions
@@ -1652,7 +1650,7 @@ def try_interaction(self, single, surface):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
-        assert self.check_obj(interaction)
+        #assert self.check_obj(interaction)
         self.add_domain_event(interaction)
 
         if __debug__:
@@ -2053,6 +2051,7 @@ def check_obj(self, obj):
 								       self.domains,
                                                                        ignore=[obj.domain_id],
                                                                        ignores=ignores)
+	#TODO
             if(type(shell.shape) is Cylinder and
                closest and type(closest.shell.shape) is Sphere):
                 # Note: this case is special.
diff --git a/gfrdbase.py b/gfrdbase.py
index 3aad7eb4..b0c3fa4d 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -79,7 +79,7 @@ def p_free(r, t, D):
 
     return p * jacobian
     
-def get_closest_surface(world, pos, ignore):
+def get_closest_surface(world, pos, ignore=[]):
     """Return
       - closest surface
       - distance to closest surface
diff --git a/pair.py b/pair.py
index b0ecfd8b..6364b45b 100644
--- a/pair.py
+++ b/pair.py
@@ -496,7 +496,9 @@ def com_greens_function(self):
         return GreensFunction1DAbsAbs(self.D_R, self.v_R, 0.0, -self.a_R, self.a_R)
 
     def iv_greens_function(self, r0):
-        return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot, r0, self.sigma, self.a_r)
+	# TODO Fix ugly hack to avoid k=0 below
+        #return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot, r0, self.sigma, self.a_r)
+        return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot + 1e-10, r0, self.sigma, self.a_r)
 
     def create_new_shell(self, position, half_length, domain_id):
         # The radius of a rod is not more than it has to be (namely the 

From 16f7d12ec85a0f039bb593363a7f86f8ae0e41c4 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 22 Sep 2011 12:25:18 +0200
Subject: [PATCH 0192/1541] Fixed bug in 1D greensfunctions when reaction rate
 k = 0 -> reflectie GFn

---
 CuboidalRegion.hpp         |   2 +-
 CylindricalSurface.hpp     |   2 +-
 GreensFunction1DAbsAbs.cpp |   5 +-
 GreensFunction1DRadAbs.cpp | 120 ++++++++++++++++++++++++-------------
 4 files changed, 84 insertions(+), 45 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index decc500b..2fcc6bc2 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -62,7 +62,7 @@ class CuboidalRegion
     virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
                                                 Real const& D01, Real const& v ) const
     {
-        return random_vector( drawR_gbd(rng(), r01, dt, D01, v ), rng );
+        return random_vector( drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v ), rng );
     }
 
 
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 02b278c0..2a9ea552 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -71,7 +71,7 @@ class CylindricalSurface
     virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
                                                 Real const& D01, Real const& v ) const
     {
-        return random_vector(drawR_gbd(rng.uniform(), r01, dt, D01, v), rng);
+        return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 24584016..e5adc568 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -523,11 +523,10 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
 	    if( fabs( low ) <= t_guess * 1.0e-6 ||
 	        fabs(value-value_prev) < EPSILON*this->t_scale )
 	    {
-		std::cerr << "Couldn't adjust low. F(" << low << ") = "
+		std::cerr << "GF1DAbs::drawTime Couldn't adjust low. F(" << low << ") = "
 		          << value << " t_guess: " << t_guess << " diff: "
 		          << (value - value_prev) << " value: " << value
-		          << " value_prev: " << value_prev << " t_scale: "
-		          << this->t_scale << std::endl;
+		          << " value_prev: " << value_prev << std::endl;
 		return low;
 	    }
 
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index b8f866f2..bc2a27e9 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -18,7 +18,6 @@
 #include "findRoot.hpp"
 #include "GreensFunction1DRadAbs.hpp"
 
-
 // This is the appropriate definition of the function defining
 // the roots of our Green's functions in GSL.
 // Later needed by the rootfinder.
@@ -32,6 +31,7 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
     const Real a = (params->a);
     const Real h = (params->h);
     const Real h_a (h*a);
+
     if ( h_a < 1 )
     {
 	// h = k/D
@@ -42,6 +42,7 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
 	// h = k/D
 	return tan(x) + x/(h_a);
     }
+    
 }
 
 // Calculates the roots of tan(x*a)=-x/h
@@ -53,6 +54,11 @@ GreensFunction1DRadAbs::root_n(int n) const
     // the drift v also comes into this constant, h=(k+v/2)/D
     Real upper, lower;
 
+    //No drift, and k = 0, use reflective solution.
+    if (h == 0.0)
+        return M_PI * ( n - 1./2 ) / L;
+    
+
     if ( h*L < 1 )
     {
 	// 1E-10 to make sure that he doesn't include the transition 
@@ -130,7 +136,7 @@ GreensFunction1DRadAbs::Bn (Real root_n) const
     const Real h2(h*h);
     const Real v2D(v/2.0/D);
 
-    if(v==0.0)	return (h2 - (rootn2 + h2)*cos(rootnL)) / (h*root_n);
+    if(v==0.0) return (h2 - (rootn2 + h2)*cos(rootnL)) / (h*root_n);
     else	return (exp(v2D*sigma)*h*k/D - exp(v2D*a)*(rootn2+h2)*cos(rootnL) ) / (h/root_n*(rootn2+v2D*v2D));
 }
 
@@ -157,6 +163,9 @@ GreensFunction1DRadAbs::p_survival (Real t) const
     const Real D(this->getD());
     const Real v(this->getv());
     const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+    const Real L(this->geta()-this->getsigma());
+    const Real r0_s(this->getr0() - this->getsigma());
+    const Real h((this->getk()+this->getv()/2.0)/this->getD());
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
@@ -170,18 +179,40 @@ GreensFunction1DRadAbs::p_survival (Real t) const
     Real sum = 0, term = 0, term_prev = 0;
     int n = 1;
 
-    do
+    if(h != 0.0)
     {
-	root_n = this->root_n(n);
-	term_prev = term;
-	term = this->Cn(root_n, t) * this->An(root_n) * this->Bn(root_n);
-	sum += term;
-	n++;
+
+        do
+        {
+	        root_n = this->root_n(n);
+	        term_prev = term;
+    	    term = this->Cn(root_n, t) * this->An(root_n) * this->Bn(root_n);
+	        sum += term;
+	        n++;
+        }
+        while ( fabs(term/sum) > EPSILON  ||
+	    fabs(term_prev/sum) > EPSILON ||
+	    n <= MIN_TERMS);
+
     }
-    while ( fabs(term/sum) > EPSILON  ||
-	fabs(term_prev/sum) > EPSILON ||
-	n <= MIN_TERMS);
+    else
+    {
+
+        do
+        {
+	        root_n = this->root_n(n);
+	        term_prev = term;
+    	    
+            term = this->Cn(root_n, t) * cos( root_n * r0_s ) * sin( root_n * L ) / ( L * root_n );
 
+	        sum += term;
+	        n++;
+        }
+        while ( fabs(term/sum) > EPSILON  ||
+	    fabs(term_prev/sum) > EPSILON ||
+	    n <= MIN_TERMS);
+
+    }
     return 2.0*exp(vexpo)*sum;
 }
 
@@ -371,7 +402,7 @@ GreensFunction1DRadAbs::drawT_f (double t, void *p)
 	if ( n >= terms )
 	{
 	    std::cerr << "Too many terms needed for GF1DRad::DrawTime. N: "
-	              << n << std::endl;
+	              << n << ", conv arg: " << exponent * t <<  std::endl;
 	    break;
 	}
 	prev_term = term;
@@ -379,6 +410,7 @@ GreensFunction1DRadAbs::drawT_f (double t, void *p)
 	Xn = params->Xn[n];
 	exponent = params->exponent[n];
 	term = Xn * exp(exponent * t);
+
 	sum += term;
 	n++;
     }
@@ -436,6 +468,7 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     // produce the coefficients and the terms in the exponent and put them
     // in the params structure. This is not very efficient at this point,
     // coefficients should be calculated on demand->TODO
+ 
     for (int n=0; n<MAX_TERMS; n++)
     {
 	root_n = this->root_n(n+1);	// get the n-th root of tan(root*a)=root/-h (Note: root numbering starts at n=1)
@@ -474,25 +507,34 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     F.function = &GreensFunction1DRadAbs::drawT_f;
     F.params = &parameters;
 
-
     // Find a good interval to determine the first passage time in
     // get the distance to absorbing boundary (disregard rad BC)
-    const Real dist(fabs(a-r0));
+    Real t_guess;
+    Real dist;
+
+    if (k != 0)
+    {
+        dist = std::min(a - r0, r0 - sigma);
+    }
+    else
+    {
+        dist = a - r0;
+    }
     //const Real dist( std::min(r0, a-r0));	// for test purposes
     // construct a guess: MSD = sqrt (2*d*D*t)
-    Real t_guess( dist * dist / ( 2.0*D ) );
+    t_guess = dist * dist / ( 2.0 * D );
+    t_guess *= .1;
     // A different guess has to be made in case of nonzero drift to account for the displacement due to it
     // TODO: This does not work properly in this case yet, but we don't know why...
     // When drifting towards the closest boundary
     //if( (r0 >= a/2.0 && v > 0.0) || (r0 <= a/2.0 && v < 0.0) )	t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
     // When drifting away from the closest boundary
-    //if( ( r0 < a/2.0 && v > 0.0) || ( r0 > a/2.0 && v < 0.0) )	t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));
-    
+    //if( ( r0 < a/2.0 && v > 0.0) || ( r0 > a/2.0 && v < 0.0) )	t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));  
+
     Real value( GSL_FN_EVAL( &F, t_guess ) );
     Real low( t_guess );
     Real high( t_guess );
 
-
     // scale the interval around the guess such that the function straddles
     if( value < 0.0 )
     {
@@ -546,7 +588,6 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     // make a new solver instance
-    // TODO: incl typecast?
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     const Real t( findRoot( F, solver, low, high, t_scale*EPSILON, EPSILON,
                             "GreensFunction1DRadAbs::drawTime" ) );
@@ -631,35 +672,31 @@ GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
     double root_n = 0;
     double S_Cn_root_n;
     double root_n2, root_n_r0_s;
+
     const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D); // exponent of the drift-prefactor, same as in survival prob.
     const Real v2D(v/2.0/D);
     const Real v2Dv2D(v2D*v2D);
-    const Real S = 2.0*exp(vexpo)/p_survival(t); // This is a prefactor to every term, so it also contains
-						 // the exponential drift-prefactor.
+    const Real S = 2.0*exp(vexpo)/p_survival(t); 
 
+    assert(p_survival(t) >= 0.0);
 
     // produce the coefficients and the terms in the exponent and put them
     // in the params structure
     for (int n=0; n<MAX_TERMS; n++)
     {
-	root_n = this->root_n(n+1);  // get the n-th root of tan(alfa*a)=alfa/-k
-	root_n2 = root_n * root_n;
-	root_n_r0_s = root_n * (r0-sigma);
-	S_Cn_root_n =	S * exp(-D*root_n2*t)
-		      * (root_n*cos(root_n_r0_s) + h*sin(root_n_r0_s)) / (L*(root_n2 + h*h) + h)
-		      * root_n / (root_n2 + v2Dv2D);
-
-	// store the coefficients in the structure
-	parameters.root_n[n] = root_n;
-	// also store the values for the exponent
-	parameters.S_Cn_root_n[n] = S_Cn_root_n;
+	    root_n = this->root_n(n+1);  // get the n-th root of tan(alfa*a)=alfa/-k
+       	root_n2 = root_n * root_n;
+       	root_n_r0_s = root_n * (r0-sigma);
+       	S_Cn_root_n =	S * exp(-D*root_n2*t)
+	         * (root_n*cos(root_n_r0_s) + h*sin(root_n_r0_s)) / (L*(root_n2 + h*h) + h)
+	         * root_n / (root_n2 + v2Dv2D);
+
+      	// store the coefficients in the structure
+	    parameters.root_n[n] = root_n;
+        // also store the values for the exponent
+        parameters.S_Cn_root_n[n] = S_Cn_root_n;
     }
     
-    // store the random number for the probability
-    parameters.rnd = rnd;
-    // store the number of terms used
-    parameters.terms = MAX_TERMS;
-    
     // also store constant prefactors that appear in the calculation of the
     // r-dependent terms
     parameters.H[0] = v2D;		// appears together with z in one of the prefactors
@@ -667,13 +704,16 @@ GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
     parameters.H[2] = h*v2D;		// further constant terms of the sine prefactor
     parameters.H[3] = sigma;
 
-
-    // find the intersection on the y-axis between the random number and
-    // the function
+    // define gsl function for rootfinder
     gsl_function F;
     F.function = &GreensFunction1DRadAbs::drawR_f;
     F.params = &parameters;
 
+    // store the random number for the probability
+    parameters.rnd = rnd;
+    // store the number of terms used
+    parameters.terms = MAX_TERMS;
+
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     // make a new solver instance

From ba6ab632ab945ba3582178bf709f60dfb48012e2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Sep 2011 15:31:28 +0200
Subject: [PATCH 0193/1541] fixed form_multi without any neighbors

---
 egfrd.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3efaf4a5..1358bbc9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -932,9 +932,9 @@ def make_new_domain(self, single):
 	# -shell is burstable (not Multi)
 	# -shell is not newly made
 	# -shell is not already a zero shell (just bursted)
+	burst = []
         if intruders:
 #            burst = self.burst_non_multis(intruders)
-	    burst = []
 	    for domain in intruders:
         	if not isinstance(domain, Multi) and \
                    not self.t == domain.last_time: # and \
@@ -948,8 +948,6 @@ def make_new_domain(self, single):
 
 	    # burst now contains all the Domains resulting from the burst.
 	    # These are NonInteractionSingles and Multis
-        else:
-            burst = None
 
 
 	# 2.3 get the closest object (a Domain or surface) which can be a
@@ -1858,17 +1856,17 @@ def try_pair(self, single1, single2, burst):
     def form_multi(self, single, neighbors, dists):
 	# form a Multi with the 'single'
 	# The 'neighbors' are neighboring NonInteractionSingles and Multi which
-	# can be added to the Multi
+	# can be added to the Multi (this can also be empty)
 	# 'dists' are the distances of the 'neighbors'
 
 	# Filter out relevant neighbors if present
+	# only consider neighboring bursted domains that are within the Multi horizon
+	min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+	dists = numpy.array(dists)	# FIXME Not sure why this is necessary, dists should already be array
+        neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
 	if neighbors:
-	# only consider neighboring domains that are within the Multi horizon
-	    min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
-            neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
             closest = neighbors[0]
 	else:
-	    neighbors = []
 	    closest = None
 
 

From aaccaeefdea7b69bdb323c3379393b25a5ff4ab7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Sep 2011 15:32:07 +0200
Subject: [PATCH 0194/1541] temporary addition of get_shell_size to Singles to
 allow Interaction making

---
 single.py | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/single.py b/single.py
index 3d7b10bb..cc90157e 100644
--- a/single.py
+++ b/single.py
@@ -166,6 +166,7 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
     def get_shell_size(self):
 	# Note: this method only means something for Protective Domains that can
 	# only be sized in one direction
+	# This is predominantly used when making Interaction domains
         return self.shell.shape.radius
 
     def initialize(self, t):
@@ -533,6 +534,12 @@ def draw_new_position(self, dt, event_type):
 
         return newpos
 
+    def get_shell_size(self):
+	# REMOVE this method, it doesn't mean anything here.
+	# THis method is only used for making an Interaction
+        # Heads up. The cylinder's *half_length*, not radius, 
+        # determines the size in case of a cylindrical surface.
+        return self.shell.shape.radius
 
     def __str__(self):
         return 'PlanarSurfaceInteraction' + Single.__str__(self)
@@ -639,11 +646,12 @@ def draw_new_position(self, dt, event_type):
 
 	return newpos
 
-#    def get_shell_size(self):
-#	# REMOVE this method, it doesn't mean anything here.
-#        # Heads up. The cylinder's *half_length*, not radius, 
-#        # determines the size in case of a cylindrical surface.
-#        return self.shell.shape.half_length
+    def get_shell_size(self):
+	# REMOVE this method, it doesn't mean anything here.
+	# THis method is only used for making an Interaction
+        # Heads up. The cylinder's *half_length*, not radius, 
+        # determines the size in case of a cylindrical surface.
+        return self.shell.shape.half_length
 
     def __str__(self):
         return 'CylindricalSurfaceInteraction' + Single.__str__(self)

From 48fa4bbdbd3d4a48e3a4ddd671653491db7d13c2 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 22 Sep 2011 15:49:19 +0200
Subject: [PATCH 0195/1541] Continued testing 2DGFs. Added small script to exec
 GF2DRadAbs.drawTheta.

---
 samples/2d/GFtool1.py | 91 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100755 samples/2d/GFtool1.py

diff --git a/samples/2d/GFtool1.py b/samples/2d/GFtool1.py
new file mode 100755
index 00000000..08c663f3
--- /dev/null
+++ b/samples/2d/GFtool1.py
@@ -0,0 +1,91 @@
+#!/usr/bin/python
+
+# This script tries to test the GF in the whole parameter regime.
+
+
+
+
+
+
+# Modules
+# ===============================
+# Standard stuff
+import sys
+import os
+import datetime
+
+from egfrd import *
+#from visualization import vtklogger
+
+import model
+import gfrdbase
+import _gfrd
+
+# GF itself
+# ===
+import _greens_functions
+
+
+
+# Some typical "crash" Constants
+# ===============================
+d = 0.931552; r = 6.10119e-08; dt = 0.00114661; D = 2e-12; sigma = 2e-09; a = 6.10119e-08; 
+kf = 0; r0 = 4.95059e-09; h = 0; rnd = 0.24;
+
+# Let's get some data 
+# ===============================
+
+mygf = _greens_functions.GreensFunction2DRadAbs(D, kf, r0, sigma, r)
+try:
+    mygf.drawTheta(rnd, r, dt)
+    print "succes!"   
+except:
+    print "fail!"
+
+
+
+# Let's try and NOT make it crash
+# ===============================
+D = 2e-12; 
+sigma = 2e-09; 
+a = sigma*5;
+r = sigma*3;
+dt = 0.03; 
+kf = 0; 
+h = 0;
+r0 = sigma*2;
+rnd = 0.1;
+
+# Let's get some data 
+# ===============================
+
+mygf = _greens_functions.GreensFunction2DRadAbs(D, kf, r0, sigma, r)
+
+try:
+    mygf.drawTheta(rnd, r, dt)
+    print "succes!"   
+except:
+    print "fail!"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From 2704782885282977831a09331b025a238fd8ab67 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 22 Sep 2011 15:53:56 +0200
Subject: [PATCH 0196/1541] Enabled 2D GFs.

---
 pair.py                       | 5 +++--
 samples/2d/2dtest.py          | 2 +-
 visualization/run_pipeline.py | 4 ++--
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/pair.py b/pair.py
index b0ecfd8b..1a2b2e1a 100644
--- a/pair.py
+++ b/pair.py
@@ -385,8 +385,9 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
 	# TODO still doesn't work with 2D Green's functions
-        return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
-                                              self.sigma, self.a_r)
+        print ":) "        
+        return GreensFunction2DRadAbs(self.D_tot, self.rt.ktot, r0,
+                                              self.sigma, self.a_r)       
 
     def create_new_shell(self, position, radius, domain_id):
         # The half_length (thickness/2) of a hockey puck is not more 
diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
index 9780d290..94944acd 100755
--- a/samples/2d/2dtest.py
+++ b/samples/2d/2dtest.py
@@ -48,7 +48,7 @@
 logging = False
 sigma = 1e-9        # Diameter particle
 D = 1e-12           # Diffusion constant
-N = 200             # Number of steps simulation will last
+N = 20000             # Number of steps simulation will last
 world_size = 1e-3   # Lengths of simulation box
 
 
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index 2d1aadcf..0de8806a 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -6,12 +6,12 @@
 """
 # Root directory of the eGFRD algorithm files:
 # Use the full path (e.g. NOT a tilde)
-egfrd_directory ='/storage1/wehrens/GF2D_implementation/'
+egfrd_directory ='/storage1/wehrens/sep2011_eGFRD'
 # Output directory of the VTK logger 
 # (This was defined when calling the logger in your
 # script.)
 simulation_data_directory =\
-    '/storage1/wehrens/2d/VTK_out' # egfrd_directory + \
+    '/storage1/wehrens/sep2011_eGFRD/samples/2d/VTK_out' # egfrd_directory + \
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From 42f5200bfab2c8c49b1ea5b69ae9683cb0a10940 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Sep 2011 16:17:59 +0200
Subject: [PATCH 0197/1541] Changed parameter k to Greensfunction1DRadAbs
 Previously, setting k to zero (reflecting surfaces) made the GF crash GF is
 now fixed and right parameters to the function can be used

---
 pair.py   | 2 +-
 single.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 6364b45b..e44c5769 100644
--- a/pair.py
+++ b/pair.py
@@ -498,7 +498,7 @@ def com_greens_function(self):
     def iv_greens_function(self, r0):
 	# TODO Fix ugly hack to avoid k=0 below
         #return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot, r0, self.sigma, self.a_r)
-        return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot + 1e-10, r0, self.sigma, self.a_r)
+        return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot, r0, self.sigma, self.a_r)
 
     def create_new_shell(self, position, half_length, domain_id):
         # The radius of a rod is not more than it has to be (namely the 
diff --git a/single.py b/single.py
index cc90157e..43d7c0ad 100644
--- a/single.py
+++ b/single.py
@@ -481,7 +481,7 @@ def iv_greens_function(self):
 	# TODO choose interactionrule
 #        return GreensFunction1DRadAbs(self.D, self.interactionrule.k, self.z0,
 #				      -self.get_inner_dz_left(), self.get_inner_dz_right())
-        return GreensFunction1DRadAbs(self.D, 1e-8, self.z0,
+        return GreensFunction1DRadAbs(self.D, 0, self.z0,
 				      -self.get_inner_dz_left(), self.get_inner_dz_right())
 
     def draw_new_position(self, dt, event_type):

From e47e15b2993419f9c0850e015d0ba4faa42685ba Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 22 Sep 2011 17:40:30 +0200
Subject: [PATCH 0198/1541] Updated tools: added tool to test whole  range of
 parameters.

*Getting closer*
---
 samples/2d/GFtool1.py           |  18 ++---
 samples/2d/v2_GFtool1(space).py | 124 ++++++++++++++++++++++++++++++++
 2 files changed, 134 insertions(+), 8 deletions(-)
 create mode 100755 samples/2d/v2_GFtool1(space).py

diff --git a/samples/2d/GFtool1.py b/samples/2d/GFtool1.py
index 08c663f3..f4a2d7c9 100755
--- a/samples/2d/GFtool1.py
+++ b/samples/2d/GFtool1.py
@@ -47,19 +47,21 @@
 # Let's try and NOT make it crash
 # ===============================
 D = 2e-12; 
-sigma = 2e-09; 
-a = sigma*5;
-r = sigma*3;
-dt = 0.03; 
-kf = 0; 
-h = 0;
-r0 = sigma*2;
-rnd = 0.1;
+sigma = 2e-09; # 
+a = sigma*5; ##
+r = sigma*3; ## 
+r0 = sigma*2; ## 
+dt = 0.03; ##
+kf = 0; ##
+h = 0; ##
+
+rnd = 0.1; ##
 
 # Let's get some data 
 # ===============================
 
 mygf = _greens_functions.GreensFunction2DRadAbs(D, kf, r0, sigma, r)
+mygf.drawTheta(rnd, r, dt)
 
 try:
     mygf.drawTheta(rnd, r, dt)
diff --git a/samples/2d/v2_GFtool1(space).py b/samples/2d/v2_GFtool1(space).py
new file mode 100755
index 00000000..0cf29b50
--- /dev/null
+++ b/samples/2d/v2_GFtool1(space).py
@@ -0,0 +1,124 @@
+#!/usr/bin/python
+
+# This script tries to test the GF in the whole parameter regime.
+
+
+
+
+
+
+# Modules
+# ===============================
+# Standard stuff
+import sys
+import os
+import datetime
+
+from egfrd import *
+#from visualization import vtklogger
+
+import model
+import gfrdbase
+import _gfrd
+
+# GF itself
+# ===
+import _greens_functions
+
+
+
+
+# List of parameters to investigate:
+# ======================================
+
+D =      2e-12
+sigma =  2e-9
+a =      [10*sigma, 100*sigma]
+r0 =     [1.001*sigma, 3*sigma, 4.999*sigma]
+dt =     [1e-4, 0.03, 0.3, 1, 1e4]
+rnd =    [1e-3, 0.05, 0.1, 0.25, (0.5-1e3)]
+kf =     0; # 2e-12 10 1e10]
+h =      0;
+
+# Let's do this the simple way:
+# ======================================
+
+if __name__=="__main__":
+
+    print "Starting tests."
+    print "========================="
+
+    for i in range(len(a)):
+        r = a[i] #!
+        for j in range(len(r0)):
+            for k in range(len(dt)):
+                 for l in range(len(rnd)):
+
+
+                    print("Parameters: {D = "+str(D)+", sigma = "+
+                          str(sigma)+", a = "+str(a[i])+", r0 = "+
+                          str(r0[j])+", dt = "+str(dt[k])+", kf = "+
+                          str(kf)+", h = "+str(h)+", r = "+str(r)+", "+
+                          "rnd = "+str(rnd[l])+"}")
+                    
+                    mygf = _greens_functions.GreensFunction2DRadAbs(D, kf, r0[j], sigma, r)
+
+                    try:
+                        mygf.drawTheta(rnd[l], r, dt[k])
+                        print "succes!"   
+                    except:
+                        print "fail!"
+                        print sys.exc_info()
+
+                            
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From f6ec138934141fd57a0feca2021440ee0192dfa8 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Thu, 22 Sep 2011 18:56:37 +0200
Subject: [PATCH 0199/1541] Some extra logging. Zeroing in on problem.

Seems to lie in alpha that is calculated way too low (~10^-317).
---
 GreensFunction2DRadAbs.cpp      | 23 ++++++++++++++++-------
 samples/2d/v2_GFtool1(space).py |  2 ++
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index c6dec052..4080c6ac 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -946,16 +946,17 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
 	const Real r0( this->getr0() );
 
+    std::clog << "[r0=" << r0 << "]";
+
 	const Real alpha_sq( alpha * alpha );
 	const Real realm( static_cast<Real>( m ) );
 	const Real msq( realm * realm);
 	const Real ssq( sigma * sigma);
 
-	const Real s_Anm (sigma*alpha);
-	const Real a_Anm (a*alpha);
-	const Real r0Anm (r0*alpha);
-	const Real r_Anm (r*alpha);
-
+	const Real s_Anm (sigma * alpha);
+	const Real a_Anm (a * alpha);
+	const Real r0Anm (r0 * alpha);
+	const Real r_Anm (r * alpha);
 
 //	const CylindricalBesselGenerator& s(CylindricalBesselGenerator::instance());
 
@@ -1093,6 +1094,8 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
 
         const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
 
+        std::clog << "{r0=" << r0 << ", alpha="<< alpha << ", r*alpha="<< r0*alpha << "}";
+
         const Real alpha_sq( alpha * alpha );
         const Real realm( static_cast<Real>( m ) );
         const Real msq( realm * realm);
@@ -1104,13 +1107,19 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
 
 	std::clog << "|";	// DEBUG
         // calculate the needed bessel functions
+        	std::clog << "1";	// DEBUG
         const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
+        	std::clog << "2";	// DEBUG
         const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    // prime
+        	std::clog << "3";	// DEBUG
         const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
-        const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
+        	std::clog << "4(" << m << ", " << r0Anm << ")";	// DEBUG
+        const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm)); // !GIVES PROBLEMS
 
+        	std::clog << "5";	// DEBUG
         const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
-        const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
+        	std::clog << "6(" << m << ", " << r0Anm << ")";	// DEBUG
+        const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm)); // !GIVES PROBLEMS
 	std::clog << "_";	// DEBUG
 
         // calculating An,m
diff --git a/samples/2d/v2_GFtool1(space).py b/samples/2d/v2_GFtool1(space).py
index 0cf29b50..77a86ef9 100755
--- a/samples/2d/v2_GFtool1(space).py
+++ b/samples/2d/v2_GFtool1(space).py
@@ -70,6 +70,8 @@
                         print "fail!"
                         print sys.exc_info()
 
+                    print ""
+
                             
 
 

From 5ced8ba99c0baeaba53c4db07a7c51c77ce6b17e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Sep 2011 19:01:28 +0200
Subject: [PATCH 0200/1541] added distance export to shellcontainer
 ShellContainer should probably be geometry container

---
 shellcontainer.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/shellcontainer.py b/shellcontainer.py
index 1901635d..9932c36a 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -62,6 +62,10 @@ def remove_shell(self, shell_id_shell_pair):
 	container = self.get_container(shell)
 	del container[shell_id]
 
+    def distance(self, pos1, pos2):
+	# Export the distance calculation
+	return self.world.distance(pos1, pos2)
+
     def get_intruders(self, position, radius, ignore):
         # gets the intruders in a spherical volume of radius 'radius'?
         # TODO make this surface specific -> in 2D only need to check in cylinder,

From 23b89ad81842e55a5df5fa928d96b8e9683d8eb2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Sep 2011 19:02:34 +0200
Subject: [PATCH 0201/1541] moved shell making code to Single class The Single
 class should know what the requirements are for a proper shell This should
 not be logic contained in the simulator itself.

---
 egfrd.py  | 46 ++++------------------------------------------
 single.py | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 53 insertions(+), 42 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1358bbc9..9e2703ac 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1206,55 +1206,17 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 	return com, r0, shell_size
 
 
-    def calculate_single_shell_size(self, single, closest, 
-                                 distance, shell_distance):
-	# only if the closest shell is also a 'simple' Single
-        assert isinstance(closest, NonInteractionSingle)
-
-        min_radius1 = single.pid_particle_pair[1].radius
-        D1 = single.getD()
-
-        if D1 == 0:
-            return min_radius1
-
-        D2 = closest.getD()
-        min_radius2 = closest.pid_particle_pair[1].radius
-        min_radius12 = min_radius1 + min_radius2
-        sqrtD1 = math.sqrt(D1)
-            
-        shell_size = min(sqrtD1 / (sqrtD1 + math.sqrt(D2))
-                        * (distance - min_radius12) + min_radius1,
-                        shell_distance / SAFETY)
-        if shell_size < min_radius1:
-            shell_size = min_radius1
-
-        return shell_size
-
     def update_single(self, single): 
         assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
 
-	singlepos = single.pid_particle_pair[1].position
-	# TODO we need the closest RELEVANT domain, i.e. the domain in the
-	# direction in which we can scale the domain
-	closest, distance_to_shell = \
-            self.geometrycontainer.get_closest_obj(singlepos, self.domains, ignore=[single.domain_id],
-               	                                   ignores=[single.structure.id])
-
-        if isinstance(closest, NonInteractionSingle):
-            closestpos = closest.shell.shape.position
-            distance_to_closest = self.world.distance(singlepos, closestpos)
-            new_shell_size = self.calculate_single_shell_size(single, closest, 
-                                                      distance_to_closest,
-                                                      distance_to_shell)
-        else:  # Pair or Multi or Surface
-            new_shell_size = distance_to_shell / SAFETY
-            new_shell_size = max(new_shell_size,
-                                 single.pid_particle_pair[1].radius)
+	new_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
 
-        new_shell_size = min(new_shell_size, self.geometrycontainer.get_max_shell_size())
+	# Make sure that the new shell size is not too small or big
+        new_shell_size = max(new_shell_size, single.pid_particle_pair[1].radius)
 
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.
+	singlepos = single.pid_particle_pair[1].position
         self.move_single_shell(single, singlepos, new_shell_size)        
 
         single.dt, single.event_type = single.determine_next_event()
diff --git a/single.py b/single.py
index 43d7c0ad..79c252d3 100644
--- a/single.py
+++ b/single.py
@@ -169,6 +169,55 @@ def get_shell_size(self):
 	# This is predominantly used when making Interaction domains
         return self.shell.shape.radius
 
+    def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycontainer):
+        # only if the closest shell is also a 'simple' Single
+        assert isinstance(closest, NonInteractionSingle)
+
+        min_radius1 = self.pid_particle_pair[1].radius
+
+        D1 = self.getD()
+        if D1 == 0:
+            return min_radius1
+
+        min_radius2 = closest.pid_particle_pair[1].radius
+        D2 = closest.getD()
+        min_radius12 = min_radius1 + min_radius2
+        sqrtD1 = math.sqrt(D1)
+
+
+	singlepos = self.pid_particle_pair[1].position
+        closestpos = closest.shell.shape.position
+        distance = geometrycontainer.distance(singlepos, closestpos)
+
+        shell_size = min(sqrtD1 / (sqrtD1 + math.sqrt(D2))
+                        * (distance - min_radius12) + min_radius1,
+                        distance_to_shell / SAFETY)
+        if shell_size < min_radius1:
+            shell_size = min_radius1
+
+        return shell_size
+
+    def get_max_shell_size(self, geometrycontainer, domains):
+	# This calculates the maximum shell size that the single can have in the current
+	# situation.
+	# TODO This is now general for all NonInteractionSingles and should be different
+	# for the different dimensions since they have different domains (spheres vs cylinders)
+	# and scale the domains in different directions (r or z).
+
+	singlepos = self.pid_particle_pair[1].position
+        closest, distance_to_shell = \
+            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
+                                              ignores=[self.structure.id])
+
+        if isinstance(closest, NonInteractionSingle):
+            new_shell_size = self.calculate_shell_size_to_single(closest, distance_to_shell,
+						                 geometrycontainer)
+        else:  # Pair or Multi or Surface
+            new_shell_size = distance_to_shell / SAFETY
+
+	return min(new_shell_size, geometrycontainer.get_max_shell_size())
+
+
     def initialize(self, t):
 	# self.shell.shape.radius = self.pid_particle_pair[1].radius
         self.dt = 0.0

From e0818c3aa77d035cca4c33ba9ee870fdb5e2f0d9 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 23 Sep 2011 18:46:15 +0200
Subject: [PATCH 0202/1541] Started on the new BD algorithm.

---
 Makefile.am         |   1 +
 multi.py            |   2 +-
 newBDPropagator.hpp | 441 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 443 insertions(+), 1 deletion(-)
 create mode 100644 newBDPropagator.hpp

diff --git a/Makefile.am b/Makefile.am
index ff4bf48d..cf32ab0e 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -47,6 +47,7 @@ noinst_HEADERS = \
 	BasicNetworkRulesImpl.hpp\
 	GreensFunction3DRadInf.hpp\
 	BDPropagator.hpp\
+    newBDPropagator.hpp\
 	BDSimulator.hpp\
 	bessel.hpp\
 	Box.hpp\
diff --git a/multi.py b/multi.py
index 49ff5b8c..fe37d32b 100644
--- a/multi.py
+++ b/multi.py
@@ -18,7 +18,7 @@ def __init__(self, domain_id, main, dt_factor):
 
         self.main = ref(main)
         self.last_event = None
-	self.event_Type = EventType.MULTI_DIFFUSION
+        self.event_Type = EventType.MULTI_DIFFUSION
 
         self.sphere_container = _gfrd.SphericalShellContainer(main.world.world_size, 3)
         self.particle_container = _gfrd.MultiParticleContainer(main.world)
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
new file mode 100644
index 00000000..9cdeca6b
--- /dev/null
+++ b/newBDPropagator.hpp
@@ -0,0 +1,441 @@
+#ifndef BD_PROPAGATOR_HPP
+#define BD_PROPAGATOR_HPP
+
+#include <algorithm>
+#include <boost/bind.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/range/size.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
+#include "Defs.hpp"
+#include "generator.hpp"
+#include "exceptions.hpp"
+#include "freeFunctions.hpp"
+#include "utils.hpp"
+#include "utils/random.hpp"
+#include "utils/get_default_impl.hpp"
+#include "Logger.hpp"
+
+template<typename Ttraits_>
+class BDPropagator
+{
+public:
+    typedef Ttraits_ traits_type;
+    typedef typename Ttraits_::world_type::particle_container_type particle_container_type;
+    typedef typename particle_container_type::species_id_type species_id_type;
+    typedef typename particle_container_type::position_type position_type;
+    typedef typename particle_container_type::particle_shape_type particle_shape_type;
+    typedef typename particle_container_type::species_type species_type;
+    typedef typename particle_container_type::length_type length_type;
+    typedef typename particle_container_type::particle_id_type particle_id_type;
+    typedef typename particle_container_type::particle_type particle_type;
+    typedef typename particle_container_type::particle_id_pair particle_id_pair;
+    typedef std::vector<particle_id_type> particle_id_vector_type;
+    typedef typename particle_container_type::particle_id_pair_generator particle_id_pair_generator;
+    typedef typename particle_container_type::particle_id_pair_and_distance particle_id_pair_and_distance;
+    typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
+    typedef typename particle_container_type::structure_type structure_type;
+    typedef typename traits_type::world_type::traits_type::rng_type rng_type;
+    typedef typename traits_type::time_type time_type;
+    typedef typename traits_type::network_rules_type network_rules_type;
+    typedef typename network_rules_type::reaction_rules reaction_rules;
+    typedef typename network_rules_type::reaction_rule_type reaction_rule_type;
+    typedef typename traits_type::reaction_record_type reaction_record_type;
+    typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
+    typedef typename traits_type::volume_clearer_type volume_clearer_type;
+
+public:
+    template<typename Trange_>
+    BDPropagator(
+        particle_container_type& tx, network_rules_type const& rules,
+        rng_type& rng, time_type dt, int max_retry_count,
+        reaction_recorder_type* rrec, volume_clearer_type* vc,
+        Trange_ const& particles)
+        : tx_(tx), rules_(rules), rng_(rng), dt_(dt),
+          max_retry_count_(max_retry_count), rrec_(rrec), vc_(vc),
+          queue_(), rejected_move_count_(0)
+    {
+        call_with_size_if_randomly_accessible(
+            boost::bind(&particle_id_vector_type::reserve, &queue_, _1),
+            particles);
+        for (typename boost::range_const_iterator<Trange_>::type
+                i(boost::begin(particles)),
+                e(boost::end(particles)); i != e; ++i)
+        {
+            queue_.push_back(*i);
+        }
+        shuffle(rng, queue_);
+    }
+
+    bool operator()()
+    {
+        if (queue_.empty())
+            return false;
+
+        particle_id_type pid(queue_.back());
+        queue_.pop_back();
+        particle_id_pair pp(tx_.get_particle(pid));
+
+        LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
+
+        try
+        {
+            if (attempt_reaction(pp))
+                return true;
+        }
+        catch (propagation_error const& reason)
+        {
+            log_.info("first-order reaction rejected (reason: %s)", reason.what());
+            ++rejected_move_count_;
+            return true;
+        }
+
+        const species_type species(tx_.get_species(pp.second.sid()));
+        if (species.D() == 0.)
+            return true;
+
+        position_type const displacement(drawR_free(species));
+        position_type const new_pos(
+            tx_.apply_boundary(
+                add(pp.second.position(), displacement)));
+
+        particle_id_pair particle_to_update(
+                pp.first, particle_type(species.id(),
+                    particle_shape_type(new_pos, species.radius()),
+                    species.D()));
+
+	/*Use a spherical shape with  radius = particle_radius + reaction_radius.
+	  We use it to check for overlaps with other particels (and surfaces). */
+        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+            tx_.check_overlap(reaction_shape(new_pos, species.radius() + reaction_radius ),
+			      particle_to_update.first));
+        switch (overlapped ? overlapped->size(): 0)
+        {
+        case 0:
+            break;
+
+        case 1:
+            {
+                particle_id_pair_and_distance const& closest(overlapped->at(0));
+
+		if( closest.second < pp.second.radius() + closest.first.second.radius() ){
+		  ++rejected_move_count_;
+		  return true;
+		}
+		
+                try
+                {
+                    if (!attempt_reaction(pp, closest.first))
+                    {
+                        LOG_DEBUG(("collision with a nonreactive particle %s. move rejected", boost::lexical_cast<std::string>(closest.first.first).c_str()));
+                        ++rejected_move_count_;
+                    }
+                }
+                catch (propagation_error const& reason)
+                {
+                    log_.info("second-order reaction rejected (reason: %s)", reason.what());
+                    ++rejected_move_count_;
+                }
+            }
+            /* reject the move even if the reaction has not occurred */
+            return true;
+
+        default:
+            log_.info("collision involving two or more particles; move rejected");
+            ++rejected_move_count_;
+            return true;
+        }
+        if (vc_)
+        {
+            if (!(*vc_)(particle_to_update.second.shape(), 
+                        particle_to_update.first))
+            {
+                log_.info("propagation move rejected.");
+                return true;
+            }
+        }
+        tx_.update_particle(particle_to_update);
+        return true;
+    }
+
+    std::size_t get_rejected_move_count() const
+    {
+        return rejected_move_count_;
+    }
+
+private:
+    position_type drawR_free(species_type const& species)
+    {
+        return tx_.get_structure(species.structure_id())->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_);
+    }
+
+    bool attempt_reaction(particle_id_pair const& pp)
+    {
+        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
+        if (::size(rules) == 0)
+        {
+            return false;
+        }
+
+        const Real rnd(rng_() / dt_);
+        Real prob = 0.;
+
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            reaction_rule_type const& r(*i);
+            prob += r.k();
+            if (prob > rnd)
+            {
+                typename reaction_rule_type::species_id_range products(
+                        r.get_products());
+                switch (::size(products))
+                {
+                case 0:
+                    remove_particle(pp.first);
+                    break;
+
+                case 1:
+                    {
+                        const species_type s0(tx_.get_species(products[0]));
+                        const particle_id_pair new_p(
+                            pp.first, particle_type(products[0],
+                                particle_shape_type(pp.second.position(),
+                                                    s0.radius()),
+                                                    s0.D()));
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_p.second.shape(), new_p.first));
+                        if (overlapped && overlapped->size() > 0)
+                        {
+                            throw propagation_error("no space");
+                        }
+
+                        if (vc_)
+                        {
+                            if (!(*vc_)(new_p.second.shape(), pp.first))
+                            {
+                                throw propagation_error("no space");
+                            }
+                        }
+
+                        tx_.update_particle(new_p);
+
+                        if (rrec_)
+                        {
+                            (*rrec_)(
+                                reaction_record_type(
+                                    r.id(), array_gen(new_p.first), pp.first));
+                        }
+                    }
+                    break;
+
+                case 2:
+                    {
+                        const species_type s0(tx_.get_species(products[0])),
+                                s1(tx_.get_species(products[1]));
+                        const Real D01(s0.D() + s1.D());
+                        const length_type r01(s0.radius() + s1.radius());
+                        int i = max_retry_count_;
+                        position_type np0, np1;
+
+                        for (;;)
+                        {
+                            if (--i < 0)
+                            {
+                                throw propagation_error("no space");
+                            }
+
+                            boost::shared_ptr<structure_type> pp_structure( 
+                                tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) );  
+               
+                            position_type m( pp_structure->
+                                        dissociation_vector( rng_, r01, dt_, D01, s0.v() - s1.v() ) );
+                            
+                            np0 = tx_.apply_boundary(pp.second.position()
+                                    - m * (s0.D() / D01));
+                            np1 = tx_.apply_boundary(pp.second.position()
+                                    + m * (s1.D() / D01));
+                           
+                            boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_s0(
+                                tx_.check_overlap(
+                                    particle_shape_type(np0, s0.radius()),
+                                    pp.first));
+                            boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_s1(
+                                tx_.check_overlap(
+                                    particle_shape_type(np1, s1.radius()),
+                                    pp.first));
+                            if (!(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0))
+                                break;
+                        }
+
+                        if (vc_)
+                        {
+                            if (!(*vc_)(particle_shape_type(np0, s0.radius()), pp.first) || !(*vc_)(particle_shape_type(np1, s1.radius()), pp.first))
+                            {
+                                throw propagation_error("no space");
+                            }
+                        }
+
+                        tx_.remove_particle(pp.first);
+                        const particle_id_pair
+                            npp0(tx_.new_particle(s0.id(), np0)),
+                            npp1(tx_.new_particle(s1.id(), np1));
+
+                        if (rrec_)
+                        {
+                            (*rrec_)(
+                                reaction_record_type(
+                                    r.id(),
+                                    array_gen(npp0.first, npp1.first),
+                                    pp.first));
+                        }
+                    }
+                    break;
+                default:
+                    throw not_implemented("monomolecular reactions that produce more than two products are not supported");
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+
+    bool attempt_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1)
+    {
+        reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
+        if (::size(rules) == 0)
+        {
+            return false;
+        }
+
+        const species_type s0(tx_.get_species(pp0.second.sid())),
+                s1(tx_.get_species(pp1.second.sid()));
+        length_type r01(s0.radius() + s1.radius());
+
+        const Real rnd(rng_());
+        Real prob = 0;
+
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            reaction_rule_type const& r(*i);
+
+            boost::shared_ptr<structure_type> pp_structure( 
+               tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
+
+            const Real p(pp_structure->p_acceptance( r.k(), dt_, r01, subtract( pp1.second.position(), 
+                                                pp0.second.position() ), s0.D(), s1.D(), s0.v(), s1.v() ));
+            BOOST_ASSERT(p >= 0.);
+            prob += p;
+            if (prob >= 1.)
+            {
+                throw propagation_error(
+                    "invalid acceptance ratio ("
+                    + boost::lexical_cast<std::string>(p)
+                    + ") for reaction rate "
+                    + boost::lexical_cast<std::string>(r.k())
+                    + ".");
+            }
+            if (prob > rnd)
+            {
+                LOG_DEBUG(("fire reaction"));
+                const typename reaction_rule_type::species_id_range products(
+                    r.get_products());
+
+                switch (::size(products))
+                {
+                case 1:
+                    {
+                        const species_id_type product(products[0]);
+                        const species_type sp(tx_.get_species(product));
+
+                        const position_type new_pos(
+                            tx_.apply_boundary(
+                                divide(
+                                    add(multiply(pp0.second.position(), s1.D()),
+                                        multiply(tx_.cyclic_transpose(
+                                            pp1.second.position(),
+                                            pp0.second.position()), s0.D())),
+                                    (s0.D() + s1.D()))));
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+                            tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
+                                              pp0.first, pp1.first));
+                        if (overlapped && overlapped->size() > 0)
+                        {
+                            throw propagation_error("no space");
+                        }
+
+                        if (vc_)
+                        {
+                            if (!(*vc_)(
+                                    particle_shape_type(new_pos, sp.radius()), 
+                                    pp0.first, pp1.first))
+                            {
+                                throw propagation_error("no space");
+                            }
+                        }
+
+                        remove_particle(pp0.first);
+                        remove_particle(pp1.first);
+                        particle_id_pair npp(tx_.new_particle(product, new_pos));
+                        if (rrec_)
+                        {
+                            (*rrec_)(
+                                reaction_record_type(
+                                    r.id(), array_gen(npp.first), pp0.first, pp1.first));
+                        }
+                        break;
+                    }
+                case 0:
+                    remove_particle(pp0.first);
+                    remove_particle(pp1.first);
+                    break;
+                
+                default:
+                    throw not_implemented("bimolecular reactions that produce more than one product are not supported");
+                }
+
+                return true;
+            }
+        }
+        return false;
+    }
+
+    void remove_particle(particle_id_type const& pid)
+    {
+        LOG_DEBUG(("remove particle %s", boost::lexical_cast<std::string>(pid).c_str()));
+        tx_.remove_particle(pid);
+        typename particle_id_vector_type::iterator i(
+            std::find(queue_.begin(), queue_.end(), pid));
+        if (queue_.end() != i)
+            queue_.erase(i);
+    }
+
+private:
+    position_type random_unit_vector()
+    {
+        position_type v(rng_() - .5, rng_() - .5, rng_() - .5);
+        return v / length(v);
+    }
+
+private:
+    particle_container_type& tx_;
+    network_rules_type const& rules_;
+    rng_type& rng_;
+    Real const dt_;
+    int const max_retry_count_;
+    reaction_recorder_type* const rrec_;
+    volume_clearer_type* const vc_;
+    particle_id_vector_type queue_;
+    int rejected_move_count_;
+    static Logger& log_;
+};
+
+template<typename Ttraits_>
+Logger& BDPropagator<Ttraits_>::log_(Logger::get_logger("ecell.BDPropagator"));
+
+#endif /* BD_PROPAGATOR_HPP */
+

From e91f20ed368455e4907ecd13b0af702d6c0b5a06 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 13:34:07 +0200
Subject: [PATCH 0203/1541] small changes to code order for
 NonInteractionSingle shell size determination

---
 single.py | 105 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 57 insertions(+), 48 deletions(-)

diff --git a/single.py b/single.py
index 79c252d3..443cf3b9 100644
--- a/single.py
+++ b/single.py
@@ -169,54 +169,6 @@ def get_shell_size(self):
 	# This is predominantly used when making Interaction domains
         return self.shell.shape.radius
 
-    def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycontainer):
-        # only if the closest shell is also a 'simple' Single
-        assert isinstance(closest, NonInteractionSingle)
-
-        min_radius1 = self.pid_particle_pair[1].radius
-
-        D1 = self.getD()
-        if D1 == 0:
-            return min_radius1
-
-        min_radius2 = closest.pid_particle_pair[1].radius
-        D2 = closest.getD()
-        min_radius12 = min_radius1 + min_radius2
-        sqrtD1 = math.sqrt(D1)
-
-
-	singlepos = self.pid_particle_pair[1].position
-        closestpos = closest.shell.shape.position
-        distance = geometrycontainer.distance(singlepos, closestpos)
-
-        shell_size = min(sqrtD1 / (sqrtD1 + math.sqrt(D2))
-                        * (distance - min_radius12) + min_radius1,
-                        distance_to_shell / SAFETY)
-        if shell_size < min_radius1:
-            shell_size = min_radius1
-
-        return shell_size
-
-    def get_max_shell_size(self, geometrycontainer, domains):
-	# This calculates the maximum shell size that the single can have in the current
-	# situation.
-	# TODO This is now general for all NonInteractionSingles and should be different
-	# for the different dimensions since they have different domains (spheres vs cylinders)
-	# and scale the domains in different directions (r or z).
-
-	singlepos = self.pid_particle_pair[1].position
-        closest, distance_to_shell = \
-            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
-                                              ignores=[self.structure.id])
-
-        if isinstance(closest, NonInteractionSingle):
-            new_shell_size = self.calculate_shell_size_to_single(closest, distance_to_shell,
-						                 geometrycontainer)
-        else:  # Pair or Multi or Surface
-            new_shell_size = distance_to_shell / SAFETY
-
-	return min(new_shell_size, geometrycontainer.get_max_shell_size())
-
 
     def initialize(self, t):
 	# self.shell.shape.radius = self.pid_particle_pair[1].radius
@@ -276,6 +228,63 @@ def draw_new_position(self, dt, event_type):
 
         return newpos
 
+    def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycontainer):
+        # only if the closest shell is also a 'simple' Single
+        assert isinstance(closest, NonInteractionSingle)
+
+        min_radius1 = self.get_min_shell_size()
+
+        D1 = self.getD()
+        if D1 == 0:
+            return min_radius1
+
+        min_radius2 = closest.pid_particle_pair[1].radius
+        D2 = closest.getD()
+        min_radius12 = min_radius1 + min_radius2
+        sqrtD1 = math.sqrt(D1)
+
+
+	singlepos = self.pid_particle_pair[1].position
+        closestpos = closest.shell.shape.position
+        distance = geometrycontainer.distance(singlepos, closestpos)
+
+        shell_size = min(sqrtD1 / (sqrtD1 + math.sqrt(D2))
+                        * (distance - min_radius12) + min_radius1,
+                        distance_to_shell / SAFETY)
+        if shell_size < min_radius1:
+            shell_size = min_radius1
+
+        return shell_size
+
+    def get_min_shell_size(self):
+	return self.pid_particle_pair[1].radius
+
+    def get_max_shell_size(self, geometrycontainer, domains):
+	# This calculates the maximum shell size that the single can have in the current
+	# situation.
+	# TODO This is now general for all NonInteractionSingles and should be different
+	# for the different dimensions since they have different domains (spheres vs cylinders)
+	# and scale the domains in different directions (r or z).
+
+	# 1. Calculate the maximal dimensions of the shell
+	# TODO We now just check in a sphere around the particle and size accordingly. For
+	# NonInteractionSingles on the dna and membrane this is quite inefficient-> want to
+	# size in the appropriate coordinate (r or z).
+	singlepos = self.pid_particle_pair[1].position
+        closest, distance_to_shell = \
+            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
+                                              ignores=[self.structure.id])
+
+	# 2. In case the nearest neighbor was a NonInteractionSingle we need to tweak the size
+	# TODO shell size has no real meaning for cylinderical domains
+        if isinstance(closest, NonInteractionSingle):
+            new_shell_size = self.calculate_shell_size_to_single(closest, distance_to_shell,
+						                 geometrycontainer)
+        else:  # Pair or Multi or Surface
+            new_shell_size = distance_to_shell / SAFETY
+
+	return min(new_shell_size, geometrycontainer.get_max_shell_size())
+
 
 class SphericalSingle(NonInteractionSingle):
     """1 Particle inside a (spherical) shell not on any surface.

From 35f0ebde4739bf5c640ec736644124efba3fa69a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 13:35:12 +0200
Subject: [PATCH 0204/1541] moved calculation of minimal shell for SimplePair
 to class method

---
 egfrd.py | 35 ++++++++++-------------------------
 pair.py  | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 25 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9e2703ac..59f88545 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1039,10 +1039,14 @@ def reject_single_reaction(self, single):
         self.add_domain_event(single)
 
     def calculate_simplepair_shell_size(self, single1, single2, burst):
-        # 1. Determine min shell size for the SimplePair.
-
 	assert single1.structure == single2.structure
 
+	# 1. calculate the minimal shell size
+        min_shell_size, shell_size_margin = \
+	    SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
+        min_shell_size_with_margin = min_shell_size + shell_size_margin
+
+
         pos1 = single1.pid_particle_pair[1].position
         pos2 = single2.pid_particle_pair[1].position
         radius1 = single1.pid_particle_pair[1].radius
@@ -1054,32 +1058,13 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
         D2 = single2.pid_particle_pair[1].D
         D12 = D1 + D2
 
-#        assert (pos1 - single1.shell.shape.position).sum() == 0	# TODO Not sure why this is here
         r0 = self.world.distance(pos1, pos2)
-        distance_from_sigma = r0 - sigma
-        assert distance_from_sigma >= 0, \
-            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
-            (single1, single2, FORMAT_DOUBLE % distance_from_sigma)
-
-        shell_size1 = r0 * D1 / D12 + radius1
-        shell_size2 = r0 * D2 / D12 + radius2
-        shell_size_margin1 = radius1 * 2
-        shell_size_margin2 = radius2 * 2
-        shell_size_with_margin1 = shell_size1 + shell_size_margin1
-        shell_size_with_margin2 = shell_size2 + shell_size_margin2
-        if shell_size_with_margin1  >= shell_size_with_margin2:
-            min_shell_size = shell_size1
-            shell_size_margin = shell_size_margin1
-        else:
-            min_shell_size = shell_size2
-            shell_size_margin = shell_size_margin2
+        distance_from_sigma = r0 - sigma	# the distance between the surfaces of the particles
 
         # 2. Check if min shell size for the Pair not larger than max shell size or 
         # sim cell size.
-        min_shell_size_with_margin = min_shell_size + shell_size_margin
         max_shell_size = min(self.geometrycontainer.get_max_shell_size(),
-                             distance_from_sigma * 100 +
-                             sigma + shell_size_margin)
+                             distance_from_sigma * 100 + sigma + shell_size_margin)
 
         if min_shell_size_with_margin >= max_shell_size:
             if __debug__:
@@ -1105,7 +1090,7 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
         com = self.world.apply_boundary(com)
         closest, closest_shell_distance = None, numpy.inf
         for b in burst:
-            if isinstance(b, Single):
+            if isinstance(b, NonInteractionSingle):
                 bpos = b.shell.shape.position
                 d = self.world.distance(com, bpos) - \
                     b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
@@ -1139,7 +1124,7 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 
         assert closest_shell_distance > 0
 
-        if isinstance(closest, Single):
+        if isinstance(closest, NonInteractionSingle):
 
             D_closest = closest.pid_particle_pair[1].D
             D_tot = D_closest + D12
diff --git a/pair.py b/pair.py
index e44c5769..0ed62ef0 100644
--- a/pair.py
+++ b/pair.py
@@ -160,6 +160,54 @@ def __str__(self):
             name1, name2)
 
 class SimplePair(Pair):
+
+    @staticmethod
+    def get_min_shell_size(single1, single2, geometrycontainer):
+        # 1. Determine min shell size for a putative SimplePair.
+	# TODO Note that the calculation is dimension independent. Alse
+	# 'size' is not the right term here
+
+        assert single1.structure == single2.structure
+
+        pos1 = single1.pid_particle_pair[1].position
+        pos2 = single2.pid_particle_pair[1].position
+        radius1 = single1.pid_particle_pair[1].radius
+        radius2 = single2.pid_particle_pair[1].radius
+
+        sigma = radius1 + radius2
+
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
+        D12 = D1 + D2
+
+#        assert (pos1 - single1.shell.shape.position).sum() == 0        # TODO Not sure why this is here
+        r0 = geometrycontainer.world.distance(pos1, pos2)
+        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
+        assert distance_from_sigma >= 0, \
+            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
+            (single1, single2, FORMAT_DOUBLE % distance_from_sigma)
+
+        shell_size1 = r0 * D1 / D12 + radius1
+        shell_size2 = r0 * D2 / D12 + radius2
+        shell_size_margin1 = radius1 * 2
+        shell_size_margin2 = radius2 * 2
+        shell_size_with_margin1 = shell_size1 + shell_size_margin1
+        shell_size_with_margin2 = shell_size2 + shell_size_margin2
+        if shell_size_with_margin1  >= shell_size_with_margin2:
+            min_shell_size = shell_size1
+            shell_size_margin = shell_size_margin1
+        else:
+            min_shell_size = shell_size2
+            shell_size_margin = shell_size_margin2
+
+	return min_shell_size, shell_size_margin
+
+    @staticmethod
+    def get_max_shell_size():
+	pass
+
+
+
     def __init__(self, domain_id, com, single1, single2, shell_id,
                       r0, shell_size, rt, structure):
 	Pair.__init__(self, domain_id, single1, single2, shell_id,

From 1bef2fce8beb61cc502999dc7c46109f64453cce Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 15:28:43 +0200
Subject: [PATCH 0205/1541] moved determination of max domain size pair to
 class method

---
 domain.py |   2 +
 egfrd.py  | 157 ++++++++++++++++++++++++++++++------------------------
 pair.py   |  67 ++++++++++++++++++++++-
 3 files changed, 153 insertions(+), 73 deletions(-)

diff --git a/domain.py b/domain.py
index 0436fc88..d53affa5 100644
--- a/domain.py
+++ b/domain.py
@@ -2,6 +2,8 @@ class Domain(object):
 # The domain is the main unit of eGFRD. Single, Pairs and Multis are all domains
 # with an own domain_id
 
+    SINGLE_SHELL_FACTOR = 2.0
+
     def __init__(self, domain_id):
 	self.domain_id = domain_id	# identifier for this domain object
 	self.event_id = None		# identifier for the event coupled to this domain
diff --git a/egfrd.py b/egfrd.py
index 59f88545..a31179e0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1063,8 +1063,12 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 
         # 2. Check if min shell size for the Pair not larger than max shell size or 
         # sim cell size.
-        max_shell_size = min(self.geometrycontainer.get_max_shell_size(),
-                             distance_from_sigma * 100 + sigma + shell_size_margin)
+	max_shell_size = SimplePair.get_max_shell_size(single1, single2,
+						       self.geometrycontainer, self.domains)
+
+#        max_shell_size = min(self.geometrycontainer.get_max_shell_size(),
+        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin
+	max_shell_size = min(max_shell_size, convergence_max)
 
         if min_shell_size_with_margin >= max_shell_size:
             if __debug__:
@@ -1086,83 +1090,94 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 	# In case it's a NonInteractionSingle observe a distance of reaction_radius
 	# In case it's smt else no extra distance has to be held
 
-        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-        com = self.world.apply_boundary(com)
-        closest, closest_shell_distance = None, numpy.inf
-        for b in burst:
-            if isinstance(b, NonInteractionSingle):
-                bpos = b.shell.shape.position
-                d = self.world.distance(com, bpos) - \
-                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
-                if d < closest_shell_distance:
-                    closest, closest_shell_distance = b, d
-
-        if closest_shell_distance <= min_shell_size_with_margin:
-            if __debug__:
-                log.debug('%s not formed: squeezed by burst neighbor %s' %
-                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-                                             single2.pid_particle_pair[0]),
-                           closest))
-            return None, None, None
-
-        assert closest_shell_distance > 0
-
-        # 4. Determine shell size and check if closest object not too 
-        # close (squeezing).
-        c, d = self.geometrycontainer.get_closest_obj(com, self.domains, ignore=[single1.domain_id,
-                                                      single2.domain_id],
-                                                      ignores=[single1.structure.id])
-
-        if d < closest_shell_distance:
-            closest, closest_shell_distance = c, d
-
-        if __debug__:
-            log.debug('Pair closest neighbor: %s %s, '
-                      'min_shell_with_margin %s' %
-                      (closest, FORMAT_DOUBLE % closest_shell_distance,
-                       FORMAT_DOUBLE % min_shell_size_with_margin))
-
-        assert closest_shell_distance > 0
-
-        if isinstance(closest, NonInteractionSingle):
-
-            D_closest = closest.pid_particle_pair[1].D
-            D_tot = D_closest + D12
-            closest_particle_distance = self.world.distance(
-                    com, closest.pid_particle_pair[1].position)
-
-            closest_min_radius = closest.pid_particle_pair[1].radius
-            closest_min_shell = closest_min_radius * self.SINGLE_SHELL_FACTOR
-
+#        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+#        com = self.world.apply_boundary(com)
+#        closest, closest_shell_distance = None, numpy.inf
+#        for b in burst:
+#            if isinstance(b, NonInteractionSingle):
+#                bpos = b.shell.shape.position
+#                d = self.world.distance(com, bpos) - \
+#                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
+#                if d < closest_shell_distance:
+#                    closest, closest_shell_distance = b, d
+#
+#        if closest_shell_distance <= min_shell_size_with_margin:
+#            if __debug__:
+#                log.debug('%s not formed: squeezed by burst neighbor %s' %
+#                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
+#                                             single2.pid_particle_pair[0]),
+#                           closest))
+#            return None, None, None
+
+#        assert closest_shell_distance > 0
+
+#        # 4. Determine shell size and check if closest object not too 
+#        # close (squeezing).
+#        c, d = self.geometrycontainer.get_closest_obj(com, self.domains, ignore=[single1.domain_id,
+#                                                      single2.domain_id],
+#                                                      ignores=[single1.structure.id])
+#
+#        if d < closest_shell_distance:
+#            closest, closest_shell_distance = c, d
+#
+#        if __debug__:
+#            log.debug('Pair closest neighbor: %s %s, '
+#                      'min_shell_with_margin %s' %
+#                      (closest, FORMAT_DOUBLE % closest_shell_distance,
+#                       FORMAT_DOUBLE % min_shell_size_with_margin))
+#
+#        assert closest_shell_distance > 0
+#
+#        if isinstance(closest, NonInteractionSingle):
+#
+#            D_closest = closest.pid_particle_pair[1].D
+#            D_tot = D_closest + D12
+#            closest_particle_distance = self.world.distance(
+#                    com, closest.pid_particle_pair[1].position)
+#
+#            closest_min_radius = closest.pid_particle_pair[1].radius
+#            closest_min_shell = closest_min_radius * self.SINGLE_SHELL_FACTOR
+#
             # options for shell size:
             # a. ideal shell size
             # b. closest shell is from a bursted single
             # c. closest shell is closer than ideal shell size 
-            shell_size = min((D12 / D_tot) *
-                            (closest_particle_distance - min_shell_size 
-                             - closest_min_radius) + min_shell_size,
-                            closest_particle_distance - closest_min_shell,
-                            closest_shell_distance)
-
-            shell_size /= SAFETY
-            assert shell_size < closest_shell_distance
+#            shell_size = min((D12 / D_tot) *
+#                            (closest_particle_distance - min_shell_size - closest_min_radius) +
+#			     min_shell_size,
+#                            closest_particle_distance - closest_min_shell,
+#                            closest_shell_distance)
+#
+#            shell_size /= SAFETY
+#            assert shell_size < closest_shell_distance
+#
+#        else:
+#            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
+#
+#            shell_size = closest_shell_distance / SAFETY
 
-        else:
-            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
 
-            shell_size = closest_shell_distance / SAFETY
+#        if max_shell_size <= min_shell_size_with_margin:
+#            if __debug__:
+#                log.debug('%s not formed: domain is squeezed' %
+#                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
+#                                             single2.pid_particle_pair[0]))) #,
+#                           closest))
+#            return None, None, None
 
-        if shell_size <= min_shell_size_with_margin:
-            if __debug__:
-                log.debug('%s not formed: squeezed by %s' %
-                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-                                             single2.pid_particle_pair[0]),
-                           closest))
-            return None, None, None
+#        D_closest = closest.pid_particle_pair[1].D
+#        D_tot = D_closest + D12
+#        ideal_shell_size = min((D12 / D_tot) *
+#                            (closest_particle_distance - min_shell_size - closest_min_radius) +
+#			     min_shell_size,
+	ideal_shell_size = numpy.inf
+	shell_size = min(max_shell_size, ideal_shell_size)
 
 
         # 5. Check if singles would not be better.
 	# TODO clear this up -> strange rule
+        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = self.world.apply_boundary(com)
         d1 = self.world.distance(com, pos1)
         d2 = self.world.distance(com, pos2)
 
@@ -1178,15 +1193,15 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 
         shell_size = min(shell_size, max_shell_size)
 
-        assert closest_shell_distance == numpy.inf or \
-               shell_size < closest_shell_distance
+#        assert closest_shell_distance == numpy.inf or \
+#               shell_size < closest_shell_distance
         assert shell_size >= min_shell_size_with_margin
         assert shell_size <= max_shell_size
 
 	if __debug__:
 	    log.info('SimplePair shell made. shell_size=%s, '
                      'closest_shell_distance=%s,\nclosest = %s' %
-                     (FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % closest_shell_distance, closest))
+                     (FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % 0, None))
 
 	return com, r0, shell_size
 
diff --git a/pair.py b/pair.py
index 0ed62ef0..97c97fd0 100644
--- a/pair.py
+++ b/pair.py
@@ -3,6 +3,8 @@
 from _greens_functions import *
 from greens_function_wrapper import *
 from domain import *
+from single import (
+    NonInteractionSingle)
 
 __all__ = [
     'CylindricalSurfacePair',
@@ -202,10 +204,71 @@ def get_min_shell_size(single1, single2, geometrycontainer):
 
 	return min_shell_size, shell_size_margin
 
+
     @staticmethod
-    def get_max_shell_size():
-	pass
+    def get_max_shell_size(single1, single2, geometrycontainer, domains):
+	# returns the maximum shell size based on geometric constraints
+	# It makes sure that surrounding NonInteractionSingles have at least the
+	# 'bursting volume' of space.
+
+        pos1 = single1.pid_particle_pair[1].position
+        pos2 = single2.pid_particle_pair[1].position
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
+        D12 = D1 + D2
+
+	# TODO it makes no sence to calculate the CoM in the world object
+        com = geometrycontainer.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = geometrycontainer.world.apply_boundary(com)
+
+	# TODO get_closest_obj searches the spherical surrounding although this doesn't make sence for
+	# a 2D or 1D pair
+        closest, closest_distance = geometrycontainer.get_closest_obj(com, domains, ignore=[single1.domain_id,
+                                                                      single2.domain_id],
+                                                                      ignores=[single1.structure.id])
+
+#        if __debug__:
+#            log.debug('Pair closest neighbor: %s %s' %
+#                      'min_shell_with_margin %s' %
+#                      (closest, FORMAT_DOUBLE % closest_distance))
+#                       FORMAT_DOUBLE % min_shell_size_with_margin))
+
+        assert closest_distance > 0
+
+
+
+        if isinstance(closest, NonInteractionSingle):
+#            D_closest = closest.pid_particle_pair[1].D
+#            D_tot = D_closest + D12
+            closest_particle_distance = geometrycontainer.world.distance(
+                    com, closest.pid_particle_pair[1].position)
+
+            closest_min_radius = closest.pid_particle_pair[1].radius
+            closest_min_shell = closest_min_radius * Domain.SINGLE_SHELL_FACTOR
+
+#            # options for shell size:
+#            # a. ideal shell size (there is actuall more space but we don't use it)
+#            # b. The distance to a bursted single including its minimal shell
+#            # c. smaller than the ideal shell size but still bigger than the minimum
+#            shell_size = min((D12 / D_tot) *
+#                            (closest_particle_distance - min_shell_size
+#                             - closest_min_radius) + min_shell_size,
+#                            closest_particle_distance - closest_min_shell,
+#                            closest_distance)
+
+            shell_size = min(closest_distance, closest_particle_distance - closest_min_shell)
+#            assert shell_size < closest_distance
+
+	# TODO this is not correct. If the closest domain is not a NonInteractionSingle
+	# we still have to make sure that the (non closest) NonInteractionSingles have
+	# the required space
+        else:
+            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
+            shell_size = closest_distance 
+
 
+	return min(geometrycontainer.get_max_shell_size(),
+		   shell_size)
 
 
     def __init__(self, domain_id, com, single1, single2, shell_id,

From f74f42dbed0df2eca981ea8b65e3b7f9f8e34663 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 16:37:00 +0200
Subject: [PATCH 0206/1541] changes to get_max_shell_size for the simple pair

---
 egfrd.py | 126 ++++++++++---------------------------------------------
 pair.py  |  64 ++++++++++++++++------------
 2 files changed, 60 insertions(+), 130 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a31179e0..30214cbf 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1041,35 +1041,43 @@ def reject_single_reaction(self, single):
     def calculate_simplepair_shell_size(self, single1, single2, burst):
 	assert single1.structure == single2.structure
 
-	# 1. calculate the minimal shell size
-        min_shell_size, shell_size_margin = \
-	    SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
-        min_shell_size_with_margin = min_shell_size + shell_size_margin
-
-
+	# 0. Get some necessary information
         pos1 = single1.pid_particle_pair[1].position
         pos2 = single2.pid_particle_pair[1].position
+
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
-
         sigma = radius1 + radius2
 
+        r0 = self.world.distance(pos1, pos2)
+        distance_from_sigma = r0 - sigma	# the distance between the surfaces of the particles
+
         D1 = single1.pid_particle_pair[1].D
         D2 = single2.pid_particle_pair[1].D
         D12 = D1 + D2
 
-        r0 = self.world.distance(pos1, pos2)
-        distance_from_sigma = r0 - sigma	# the distance between the surfaces of the particles
+        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = self.world.apply_boundary(com)
 
-        # 2. Check if min shell size for the Pair not larger than max shell size or 
-        # sim cell size.
-	max_shell_size = SimplePair.get_max_shell_size(single1, single2,
+
+	# 1. Get the minimal possible shell size (including margin?)
+        min_shell_size, shell_size_margin = \
+	    SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
+        min_shell_size_with_margin = min_shell_size + shell_size_margin
+
+
+	# 2. Get the maximum possible shell size
+	max_shell_size = SimplePair.get_max_shell_size(com, single1, single2,
 						       self.geometrycontainer, self.domains)
 
-#        max_shell_size = min(self.geometrycontainer.get_max_shell_size(),
+
+	# 3. Calculate the maximum based on some other criterium (convergence?)
         convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin
 	max_shell_size = min(max_shell_size, convergence_max)
 
+
+        # 4. Check if min shell size for the Pair not larger than max shell size or 
+        # sim cell size.
         if min_shell_size_with_margin >= max_shell_size:
             if __debug__:
                 log.debug('%s not formed: min_shell_size %s >='
@@ -1080,91 +1088,7 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
                            FORMAT_DOUBLE % max_shell_size))
             return None, None, None
 
-
-        # 3. Check if bursted Singles can still make a minimal shell.
-	# TODO This should be changed to a more general algorithm
-	# that checks if the closest nearest relevant shell is a
-	# NonInteractionSingle or smt else.
-	# Now it only processes the shells that were actually bursted before.
-	#
-	# In case it's a NonInteractionSingle observe a distance of reaction_radius
-	# In case it's smt else no extra distance has to be held
-
-#        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-#        com = self.world.apply_boundary(com)
-#        closest, closest_shell_distance = None, numpy.inf
-#        for b in burst:
-#            if isinstance(b, NonInteractionSingle):
-#                bpos = b.shell.shape.position
-#                d = self.world.distance(com, bpos) - \
-#                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
-#                if d < closest_shell_distance:
-#                    closest, closest_shell_distance = b, d
-#
-#        if closest_shell_distance <= min_shell_size_with_margin:
-#            if __debug__:
-#                log.debug('%s not formed: squeezed by burst neighbor %s' %
-#                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-#                                             single2.pid_particle_pair[0]),
-#                           closest))
-#            return None, None, None
-
-#        assert closest_shell_distance > 0
-
-#        # 4. Determine shell size and check if closest object not too 
-#        # close (squeezing).
-#        c, d = self.geometrycontainer.get_closest_obj(com, self.domains, ignore=[single1.domain_id,
-#                                                      single2.domain_id],
-#                                                      ignores=[single1.structure.id])
-#
-#        if d < closest_shell_distance:
-#            closest, closest_shell_distance = c, d
-#
-#        if __debug__:
-#            log.debug('Pair closest neighbor: %s %s, '
-#                      'min_shell_with_margin %s' %
-#                      (closest, FORMAT_DOUBLE % closest_shell_distance,
-#                       FORMAT_DOUBLE % min_shell_size_with_margin))
-#
-#        assert closest_shell_distance > 0
-#
-#        if isinstance(closest, NonInteractionSingle):
-#
-#            D_closest = closest.pid_particle_pair[1].D
-#            D_tot = D_closest + D12
-#            closest_particle_distance = self.world.distance(
-#                    com, closest.pid_particle_pair[1].position)
-#
-#            closest_min_radius = closest.pid_particle_pair[1].radius
-#            closest_min_shell = closest_min_radius * self.SINGLE_SHELL_FACTOR
-#
-            # options for shell size:
-            # a. ideal shell size
-            # b. closest shell is from a bursted single
-            # c. closest shell is closer than ideal shell size 
-#            shell_size = min((D12 / D_tot) *
-#                            (closest_particle_distance - min_shell_size - closest_min_radius) +
-#			     min_shell_size,
-#                            closest_particle_distance - closest_min_shell,
-#                            closest_shell_distance)
-#
-#            shell_size /= SAFETY
-#            assert shell_size < closest_shell_distance
-#
-#        else:
-#            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
-#
-#            shell_size = closest_shell_distance / SAFETY
-
-
-#        if max_shell_size <= min_shell_size_with_margin:
-#            if __debug__:
-#                log.debug('%s not formed: domain is squeezed' %
-#                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-#                                             single2.pid_particle_pair[0]))) #,
-#                           closest))
-#            return None, None, None
-
+	# 5. Calculate the 'ideal' shell size
 #        D_closest = closest.pid_particle_pair[1].D
 #        D_tot = D_closest + D12
 #        ideal_shell_size = min((D12 / D_tot) *
@@ -1174,10 +1098,8 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 	shell_size = min(max_shell_size, ideal_shell_size)
 
 
-        # 5. Check if singles would not be better.
+        # 6. Check if singles would not be better.
 	# TODO clear this up -> strange rule
-        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-        com = self.world.apply_boundary(com)
         d1 = self.world.distance(com, pos1)
         d2 = self.world.distance(com, pos2)
 
@@ -1193,8 +1115,6 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
 
         shell_size = min(shell_size, max_shell_size)
 
-#        assert closest_shell_distance == numpy.inf or \
-#               shell_size < closest_shell_distance
         assert shell_size >= min_shell_size_with_margin
         assert shell_size <= max_shell_size
 
diff --git a/pair.py b/pair.py
index 97c97fd0..f31388a3 100644
--- a/pair.py
+++ b/pair.py
@@ -15,6 +15,11 @@
     'MixedPair',
     ]
 
+if __debug__:
+    PRECISION = 3
+    FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
+
+
 class Pair(ProtectiveDomain):
     """There are 3 types of pairs:
         * SphericalPair
@@ -206,58 +211,63 @@ def get_min_shell_size(single1, single2, geometrycontainer):
 
 
     @staticmethod
-    def get_max_shell_size(single1, single2, geometrycontainer, domains):
+    def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
 	# returns the maximum shell size based on geometric constraints
 	# It makes sure that surrounding NonInteractionSingles have at least the
 	# 'bursting volume' of space.
 
-        pos1 = single1.pid_particle_pair[1].position
-        pos2 = single2.pid_particle_pair[1].position
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-        D12 = D1 + D2
+#        pos1 = single1.pid_particle_pair[1].position
+#        pos2 = single2.pid_particle_pair[1].position
+#        D1 = single1.pid_particle_pair[1].D
+#        D2 = single2.pid_particle_pair[1].D
+#        D12 = D1 + D2
 
 	# TODO it makes no sence to calculate the CoM in the world object
-        com = geometrycontainer.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-        com = geometrycontainer.world.apply_boundary(com)
+#        com = geometrycontainer.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+#        com = geometrycontainer.world.apply_boundary(com)
 
 	# TODO get_closest_obj searches the spherical surrounding although this doesn't make sence for
 	# a 2D or 1D pair
         closest, closest_distance = geometrycontainer.get_closest_obj(com, domains, ignore=[single1.domain_id,
                                                                       single2.domain_id],
                                                                       ignores=[single1.structure.id])
-
-#        if __debug__:
-#            log.debug('Pair closest neighbor: %s %s' %
-#                      'min_shell_with_margin %s' %
-#                      (closest, FORMAT_DOUBLE % closest_distance))
-#                       FORMAT_DOUBLE % min_shell_size_with_margin))
+        if __debug__:
+            log.debug('Pair closest neighbor: %s %s' % \
+                      (closest, FORMAT_DOUBLE % closest_distance))
 
         assert closest_distance > 0
 
 
 
+        # 3. Check if bursted Singles can still make a minimal shell.
+        # TODO This should be changed to a more general algorithm
+        # that checks if the closest nearest relevant shell is a
+        # NonInteractionSingle or smt else.
+        # Now it only processes the shells that were actually bursted before.
+
+#        closest, closest_shell_distance = None, numpy.inf
+#        for b in burst:
+#            if isinstance(b, NonInteractionSingle):
+#                bpos = b.shell.shape.position
+#                d = self.world.distance(com, bpos) - \
+#                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
+#                if d < closest_shell_distance:
+#                    closest, closest_shell_distance = b, d
+#
+
+
         if isinstance(closest, NonInteractionSingle):
-#            D_closest = closest.pid_particle_pair[1].D
-#            D_tot = D_closest + D12
             closest_particle_distance = geometrycontainer.world.distance(
                     com, closest.pid_particle_pair[1].position)
 
             closest_min_radius = closest.pid_particle_pair[1].radius
             closest_min_shell = closest_min_radius * Domain.SINGLE_SHELL_FACTOR
 
-#            # options for shell size:
-#            # a. ideal shell size (there is actuall more space but we don't use it)
-#            # b. The distance to a bursted single including its minimal shell
-#            # c. smaller than the ideal shell size but still bigger than the minimum
-#            shell_size = min((D12 / D_tot) *
-#                            (closest_particle_distance - min_shell_size
-#                             - closest_min_radius) + min_shell_size,
-#                            closest_particle_distance - closest_min_shell,
-#                            closest_distance)
-
+            # options for shell size:
+            # a. upto the closest shell assuming that this shell is bigger than the minimum
+            # b. The distance to a bursted single including its minimal shell
             shell_size = min(closest_distance, closest_particle_distance - closest_min_shell)
-#            assert shell_size < closest_distance
+            assert shell_size <= closest_distance
 
 	# TODO this is not correct. If the closest domain is not a NonInteractionSingle
 	# we still have to make sure that the (non closest) NonInteractionSingles have

From 9aae1a33891c44e216c9b14f60b615207d0e3b16 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 17:38:23 +0200
Subject: [PATCH 0207/1541] added some comment

---
 single.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/single.py b/single.py
index 443cf3b9..16bc1cfc 100644
--- a/single.py
+++ b/single.py
@@ -280,6 +280,8 @@ def get_max_shell_size(self, geometrycontainer, domains):
         if isinstance(closest, NonInteractionSingle):
             new_shell_size = self.calculate_shell_size_to_single(closest, distance_to_shell,
 						                 geometrycontainer)
+	# TODO This is incorrect. The closest can be a Pair but still NonInteractionSingles may need
+	# more space
         else:  # Pair or Multi or Surface
             new_shell_size = distance_to_shell / SAFETY
 

From 794765c1d5a360241e0d2770e9144b65e7655bbb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 17:58:04 +0200
Subject: [PATCH 0208/1541] small change to NonInteractionSingle shell making

---
 egfrd.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 30214cbf..a7bba430 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1129,10 +1129,11 @@ def calculate_simplepair_shell_size(self, single1, single2, burst):
     def update_single(self, single): 
         assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
 
-	new_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
+	min_shell_size = single.get_min_shell_size()
+	max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
 
 	# Make sure that the new shell size is not too small or big
-        new_shell_size = max(new_shell_size, single.pid_particle_pair[1].radius)
+        new_shell_size = max(max_shell_size, min_shell_size)
 
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.

From 0765b37d6b878cae3d679114124a3f20fe108d91 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 18:18:22 +0200
Subject: [PATCH 0209/1541] added calc_ktot and draw_reaction_rule as method to
 domain class These functions can now be used by all instances (single, pair,
 multi) of the Domain class to draw an appropriate reaction rule

---
 domain.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/domain.py b/domain.py
index d53affa5..335cff3d 100644
--- a/domain.py
+++ b/domain.py
@@ -26,6 +26,23 @@ def initialize(self, time):		# this method needs to be overloaded in all subclas
         '''
 	pass
 
+    def calc_ktot(reactionrules):
+	# calculates the total rate for a list of reaction rules
+        for rr in reactionrules:
+            k_tot += rr.k
+	return k_tot
+
+    def draw_reaction_rule(reactionrules):
+	# draws a reaction rules out of a list of reaction rules based on their
+	# relative rates
+        k_array = numpy.add.accumulate([rr.k for rr in reactionrules])
+        k_max = k_array[-1]
+
+        rnd = myrandom.uniform()
+        i = numpy.searchsorted(k_array, rnd * k_max)
+
+        return reactionrules[i]
+
     def create_new_shell(self):		# needs to be overloaded in subclasses
 	pass				# creates an appropriate shell object
 

From 5c7eeb7a00b40107079ba7ae94db7a751a49458f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 18:44:24 +0200
Subject: [PATCH 0210/1541] moved ktot calculation for pair to constructor,
 also draw reaction rules only when needed

---
 domain.py |  5 +++--
 egfrd.py  | 32 +++++++++++++++++---------------
 pair.py   | 43 +++++++++++++++++++++----------------------
 3 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/domain.py b/domain.py
index 335cff3d..8d73e0c3 100644
--- a/domain.py
+++ b/domain.py
@@ -26,13 +26,14 @@ def initialize(self, time):		# this method needs to be overloaded in all subclas
         '''
 	pass
 
-    def calc_ktot(reactionrules):
+    def calc_ktot(self, reactionrules):
 	# calculates the total rate for a list of reaction rules
+	k_tot = 0
         for rr in reactionrules:
             k_tot += rr.k
 	return k_tot
 
-    def draw_reaction_rule(reactionrules):
+    def draw_reaction_rule(self, reactionrules):
 	# draws a reaction rules out of a list of reaction rules based on their
 	# relative rates
         k_array = numpy.add.accumulate([rr.k for rr in reactionrules])
diff --git a/egfrd.py b/egfrd.py
index a7bba430..32a14f23 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -57,16 +57,16 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure)
 
 
 def create_default_pair(domain_id, com, single1, single2, shell_id, 
-                        r0, shell_size, rt, structure):
+                        r0, shell_size, rrs, structure):
     if isinstance(structure, CuboidalRegion):
         return SphericalPair(domain_id, com, single1, single2,
-                             shell_id, r0, shell_size, rt, structure)
+                             shell_id, r0, shell_size, rrs, structure)
     elif isinstance(structure, CylindricalSurface):
         return CylindricalSurfacePair(domain_id, com, single1, single2,
-                                      shell_id, r0, shell_size, rt, structure)
+                                      shell_id, r0, shell_size, rrs, structure)
     elif isinstance(structure, PlanarSurface):
         return PlanarSurfacePair(domain_id, com, single1, single2,
-                                 shell_id, r0, shell_size, rt, structure)
+                                 shell_id, r0, shell_size, rrs, structure)
 
 
 class DomainEvent(Event):
@@ -450,14 +450,14 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         rrs = self.network_rules.query_reaction_rule(
                 pid_particle_pair1[1].sid,
                 pid_particle_pair2[1].sid)
-        k_array = numpy.add.accumulate([rr.k for rr in rrs])
-        k_max = k_array[-1]
-        rnd = myrandom.uniform()
-        i = numpy.searchsorted(k_array, rnd * k_max)
-        rr = rrs[i]
+#        k_array = numpy.add.accumulate([rr.k for rr in rrs])
+#        k_max = k_array[-1]
+#        rnd = myrandom.uniform()
+#        i = numpy.searchsorted(k_array, rnd * k_max)
+#        rr = rrs[i]
         # The probability for this reaction to happen is proportional to 
         # the sum of the rates of all the possible reaction types. 
-        rr.ktot = k_max
+#        rr.ktot = k_max
 
         # Get structure (region or surface) where particle1 lives (assuming particle2
 	# also lives here -> TODO).
@@ -470,7 +470,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         # Either SphericalPair, PlanarSurfacePair, or 
         # CylindricalSurfacePair.
         pair = create_default_pair(domain_id, com, single1, single2, shell_id, 
-                                   r0, shell_size, rr, structure)
+                                   r0, shell_size, rrs, structure)
 
 	assert isinstance(pair, Pair)
         pair.initialize(self.t)
@@ -1206,12 +1206,14 @@ def fire_pair(self, pair):
             self.world.remove_particle(single1.pid_particle_pair[0])
             self.world.remove_particle(single2.pid_particle_pair[0])
 
-            if len(pair.rt.products) == 0:
+	    rr = pair.draw_reaction_rule(pair.interparticle_rrs)
+
+            if len(rr.products) == 0:
 		# no product particles, nothing new to be made
                 product = []
 
-	    elif len(pair.rt.products) == 1:
-                species3 = self.world.get_species(pair.rt.products[0])
+	    elif len(rr.products) == 1:
+                species3 = self.world.get_species(rr.products[0])
                 # calculate new position
                 event_type = pair.event_type
                 new_com = pair.draw_new_com(pair.dt, event_type)
@@ -1233,7 +1235,7 @@ def fire_pair(self, pair):
 
 		# update counters
                 self.reaction_events += 1
-                self.last_reaction = (pair.rt, (particle1, particle2),
+                self.last_reaction = (rr, (particle1, particle2),
                                       [particle])
             else:
                 raise NotImplementedError('num products >= 2 not supported.')
diff --git a/pair.py b/pair.py
index f31388a3..18734891 100644
--- a/pair.py
+++ b/pair.py
@@ -34,7 +34,7 @@ class Pair(ProtectiveDomain):
     CUTOFF_FACTOR = 5.6
 
     def __init__(self, domain_id, single1, single2, shell_id, r0, 
-                 rt):
+                 rrs):
 	ProtectiveDomain.__init__(self, domain_id)
 
         self.multiplicity = 2
@@ -44,7 +44,8 @@ def __init__(self, domain_id, single1, single2, shell_id, r0,
 	self.pid_particle_pair1 = single1.pid_particle_pair
 	self.pid_particle_pair2 = single2.pid_particle_pair
 
-        self.rt = rt
+	self.interparticle_rrs = rrs
+	self.interparticle_ktot = self.calc_ktot(rrs)
 
 	self.shell_id = shell_id
 
@@ -282,9 +283,9 @@ def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
 
 
     def __init__(self, domain_id, com, single1, single2, shell_id,
-                      r0, shell_size, rt, structure):
+                      r0, shell_size, rrs, structure):
 	Pair.__init__(self, domain_id, single1, single2, shell_id,
-                      r0, rt)
+                      r0, rrs)
 
         self.structure = structure		# structure on which both particles live
 
@@ -396,9 +397,9 @@ class SphericalPair(SimplePair):
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
-                 r0, shell_size, rt, structure):
+                 r0, shell_size, rrs, structure):
         SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
-                      r0, shell_size, rt, structure)
+                      r0, shell_size, rrs, structure)
 
     def com_greens_function(self):
         # Green's function for centre of mass inside absorbing sphere.
@@ -407,7 +408,7 @@ def com_greens_function(self):
     def iv_greens_function(self, r0):
         # Green's function for interparticle vector inside absorbing 
         # sphere.  This exact solution is used for drawing times.
-        return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
+        return GreensFunction3DRadAbs(self.D_tot, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):
@@ -436,7 +437,7 @@ def choose_pair_greens_function(self, r0, t):
                 # near sigma; use GreensFunction3DRadInf
                 if __debug__:
                     log.debug('GF: only sigma')
-                return GreensFunction3DRadInf(self.D_tot, self.rt.ktot, r0,
+                return GreensFunction3DRadInf(self.D_tot, self.interparticle_ktot, r0,
                                                self.sigma)
 
         # sigma unreachable
@@ -445,8 +446,7 @@ def choose_pair_greens_function(self, r0, t):
                 # near a;
                 if __debug__:
                     log.debug('GF: only a')
-                return GreensFunction3DAbs(self.D_tot,
-                                                                 r0, self.a_r)
+                return GreensFunction3DAbs(self.D_tot, r0, self.a_r)
                 
             else:
                 # distant from both a and sigma; 
@@ -497,16 +497,16 @@ class PlanarSurfacePair(SimplePair):
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
-                 r0, shell_size, rt, structure):
+                 r0, shell_size, rrs, structure):
         SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
-                      r0, shell_size, rt, structure)
+                      r0, shell_size, rrs, structure)
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greens_function(self, r0):
 	# TODO still doesn't work with 2D Green's functions
-        return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
+        return GreensFunction3DRadAbs(self.D_tot, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):
@@ -545,7 +545,7 @@ def choose_pair_greens_function(self, r0, t):
                     log.debug('GF2D: only sigma')
                 return self.iv_greens_function(r0)
         	# Todo
-                # return GreensFunction2DRadInf(self.D_tot, self.rt.ktot, r0, self.sigma)
+                # return GreensFunction2DRadInf(self.D_tot, self.interparticle_ktot, r0, self.sigma)
         else:
             if distance_from_shell < threshold_distance:
                 # near a;
@@ -594,9 +594,9 @@ class CylindricalSurfacePair(SimplePair):
 
     """
     def __init__(self, domain_id, com, single1, single2, shell_id,
-                 r0, shell_size, rt, structure):
+                 r0, shell_size, rrs, structure):
         SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
-                      r0, shell_size, rt, structure)
+                      r0, shell_size, rrs, structure)
 
     def get_v_tot(self):
         return self.pid_particle_pair2[1].v - \
@@ -618,8 +618,8 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
 	# TODO Fix ugly hack to avoid k=0 below
-        #return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot, r0, self.sigma, self.a_r)
-        return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.rt.ktot, r0, self.sigma, self.a_r)
+        #return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
+        return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
     def create_new_shell(self, position, half_length, domain_id):
         # The radius of a rod is not more than it has to be (namely the 
@@ -658,9 +658,8 @@ class MixedPair(Pair):
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
 		 shell_half_length, shell_orientation_vector,
-		 unit_r, r0, pair_reaction_rules):
-	Pair.__init__(self, domain_id, single1, single2, shell_id, r0, 
-                 pair_reaction_rules)
+		 unit_r, r0, rrs):
+	Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
 
 	self.surface = surface	# the surface on which particle1 lives
@@ -694,7 +693,7 @@ def com_greensfunction(self):
 
     def iv_greensfunction(self):
 	# diffusion of the interparticle vector is three dimensional
-	return GreensFunction3DRadAbs(self.D_tot, self.rt.ktot, r0,
+	return GreensFunction3DRadAbs(self.D_tot, self.interparticle_ktot, r0,
 				      self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, orientation_vector, half_length):

From a3409c3b5fdf5c3228319f7960e80bb222de2aeb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 26 Sep 2011 19:38:12 +0200
Subject: [PATCH 0211/1541] migrated single and pair to use calc_ktot and
 draw_reaction_rule from superclass

---
 domain.py | 11 +++++++++++
 egfrd.py  |  2 +-
 pair.py   |  4 +++-
 single.py | 36 ++++++++++++++++++++++--------------
 4 files changed, 37 insertions(+), 16 deletions(-)

diff --git a/domain.py b/domain.py
index 8d73e0c3..8469684a 100644
--- a/domain.py
+++ b/domain.py
@@ -1,3 +1,14 @@
+#!/usr/env python
+
+import numpy
+import myrandom
+
+__all__ = [
+    'Domain',
+    'ProtectiveDomain',
+    ]
+
+
 class Domain(object):
 # The domain is the main unit of eGFRD. Single, Pairs and Multis are all domains
 # with an own domain_id
diff --git a/egfrd.py b/egfrd.py
index 32a14f23..7a7c0547 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -661,7 +661,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
         oldpos = single.pid_particle_pair[1].position
         current_structure = single.structure
         
-        rt = single.draw_reaction_rule()
+        rt = single.reactionrule
 
         if len(rt.products) == 0:
             
diff --git a/pair.py b/pair.py
index 18734891..777316f3 100644
--- a/pair.py
+++ b/pair.py
@@ -2,7 +2,9 @@
 from constants import EventType
 from _greens_functions import *
 from greens_function_wrapper import *
-from domain import *
+from domain import (
+    Domain,
+    ProtectiveDomain)
 from single import (
     NonInteractionSingle)
 
diff --git a/single.py b/single.py
index 16bc1cfc..e215a849 100644
--- a/single.py
+++ b/single.py
@@ -3,7 +3,10 @@
 from greens_function_wrapper import *
 from constants import EventType
 import utils
-from domain import *
+
+from domain import (
+    Domain,
+    ProtectiveDomain)
 
 __all__ = [
     'CylindricalSurfaceSingle',
@@ -36,14 +39,19 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
         self.structure = structure			# the structure in/on which the particle lives
 
         self.reactionrules = reactionrules		# the reaction rules for mono molecular reactions
-	self.reactionrule = None			# with this particle as the reactant
-        self.k_tot = 0
-        self.updatek_tot()				# RENAME to calc_ktot and MOVE to ProtectiveDomain
+	self.rrule = None			# with this particle as the reactant
+        self.k_tot = self.calc_ktot(reactionrules)
+        #self.updatek_tot()				# RENAME to calc_ktot and MOVE to ProtectiveDomain
 
     def getD(self):
         return self.pid_particle_pair[1].D
     D = property(getD)
 
+    def get_reaction_rule(self):
+	if self.rrule == None:
+	    self.rrule = self.draw_reaction_rule(self.reactionrules)
+	return self.rrule
+    reactionrule = property(get_reaction_rule)
 
     def get_inner_a(self):
 	# inner_a is the outer radius of the 'inner shell', which demarkates
@@ -116,16 +124,16 @@ def updatek_tot(self):
         for rr in self.reactionrules:
             self.k_tot += rr.k
 
-    def draw_reaction_rule(self):
-	# MOVE to ProtectiveDomain class
-        k_array = [rr.k for rr in self.reactionrules]
-        k_array = numpy.add.accumulate(k_array)
-        k_max = k_array[-1]
-
-        rnd = myrandom.uniform()
-        i = numpy.searchsorted(k_array, rnd * k_max)
-
-        return self.reactionrules[i]
+#    def draw_reaction_rule(self):
+#	# MOVE to ProtectiveDomain class
+#        k_array = [rr.k for rr in self.reactionrules]
+#        k_array = numpy.add.accumulate(k_array)
+#        k_max = k_array[-1]
+#
+#        rnd = myrandom.uniform()
+#        i = numpy.searchsorted(k_array, rnd * k_max)
+#
+#        return self.reactionrules[i]
 
     def check(self):
         pass

From de7e4f7566999ca9b8cdccdcc0371e7a0696452c Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 26 Sep 2011 19:39:22 +0200
Subject: [PATCH 0212/1541] Included newBDPropagator in the makefiles and
 bindings. Added reaction volume en dissociation vector - fuctions in
 surfaces. Only equal dimension reactions are possible, no surfaces included
 yet.

---
 BDSimulator.hpp            |  4 ++--
 CuboidalRegion.hpp         | 24 ++++++++++++++++++++++-
 CylindricalSurface.hpp     | 17 +++++++++++++++--
 PlanarSurface.hpp          | 27 ++++++++++++++++++++++++--
 SphericalSurface.hpp       | 11 +++++++++++
 Structure.hpp              |  4 ++++
 binding/Makefile.am        |  5 ++++-
 binding/binding_common.hpp |  2 ++
 newBDPropagator.hpp        | 39 +++++++++++++++++++-------------------
 pyGFRD.cpp                 |  2 ++
 10 files changed, 107 insertions(+), 28 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index d2db63e1..3f5949f5 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -6,7 +6,7 @@
 #include <boost/foreach.hpp>
 #include <boost/random/mersenne_twister.hpp>
 #include "NetworkRules.hpp"
-#include "BDPropagator.hpp"
+#include "newBDPropagator.hpp"
 #include "World.hpp"
 #include "ParticleSimulator.hpp"
 #include "utils/pair.hpp"
@@ -97,7 +97,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     void _step(time_type dt)
     {
         {
-            BDPropagator<traits_type> propagator(
+            newBDPropagator<traits_type> propagator(
                 base_type::world_,
                 base_type::network_rules_,
                 base_type::rng_,
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 2fcc6bc2..747e9421 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -4,7 +4,7 @@
 #include <boost/bind.hpp>
 #include "Region.hpp"
 #include "Box.hpp"
-//#include "freeFunctions.hpp"
+#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class CuboidalRegion
@@ -65,6 +65,28 @@ class CuboidalRegion
         return random_vector( drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v ), rng );
     }
 
+    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    {
+        length_type r01( r0 + r1 );
+        length_type r01l( r01 + rl );
+        length_type r01l_sq( r01l * r01l );
+        length_type r01_sq( r01 * r01 );
+
+        return 4.0/3.0 * M_PI * ( r01l_sq * r01l - r01_sq * r01 );
+    }
+
+    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    {
+        Real X( rng.uniform(0.,1.) );
+
+        length_type r01l( r01 + rl );
+        length_type r01l_sq( r01l * r01l );
+        length_type r01_sq( r01 * r01 );
+        
+        length_type diss_vec_length( cbrt( X * (r01l_sq * r01l - r01_sq * r01) + r01_sq*r01 ) );
+
+        return random_vector( diss_vec_length, rng );
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 2a9ea552..668a8938 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -2,10 +2,9 @@
 #define CYLINDRICAL_SURFACE_HPP
 
 #include <boost/bind.hpp>
-#include <iostream>
 #include "Surface.hpp"
 #include "Cylinder.hpp"
-//#include "freeFunctions.hpp"
+#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class CylindricalSurface
@@ -74,6 +73,20 @@ class CylindricalSurface
         return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
     }
 
+    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    {
+        return rl;
+    }
+
+    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    {
+        Real X( rng.uniform(0.,1.) );
+        
+        length_type diss_vec_length( X*rl + r01 );
+
+        return random_vector( diss_vec_length, rng );
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         length_type cylinder_radius = base_type::shape().radius();
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index d65810f8..3414f975 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -4,7 +4,7 @@
 #include <boost/bind.hpp>
 #include "Surface.hpp"
 #include "Plane.hpp"
-//#include "freeFunctions.hpp"
+#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class PlanarSurface
@@ -45,7 +45,7 @@ class PlanarSurface
 
     virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
     {
-        //TODO: use the 2D BD function instead of the 3D one.
+        //TODO: use the 2D BD function instead of the 3D one - failed on very hard integral.
         return drawR_gbd_3D(rnd, r01, dt, D01);
     }
 
@@ -62,6 +62,29 @@ class PlanarSurface
         return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng ); 
     }
 
+    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    {
+        length_type r01( r0 + r1 );
+        length_type r01l( r01 + rl );
+        length_type r01l_sq( r01l * r01l );
+        length_type r01_sq( r01 * r01 );
+
+        return M_PI * ( r01l_sq - r01_sq );
+    }
+
+    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    {
+        Real X( rng.uniform(0.,1.) );
+
+        length_type r01l( r01 + rl );
+        length_type r01l_sq( r01l * r01l );
+        length_type r01_sq( r01 * r01 );
+        
+        length_type diss_vec_length( sqrt( X * (r01l_sq - r01_sq) + r01_sq ) );
+
+        return random_vector( diss_vec_length, rng );
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         // PlanarSurface has thickness of 0.
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index bdda07b6..3c498bc7 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -3,6 +3,7 @@
 
 #include "Surface.hpp"
 #include "Sphere.hpp"
+#include "freeFunctions.hpp"
 
 template<typename Ttraits_>
 class SphericalSurface
@@ -49,6 +50,16 @@ class SphericalSurface
         return position_type(); //TODO
     }
 
+    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    {
+        return length_type(); //TODO
+    }
+
+    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    {
+        return position_type(); //TODO
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         return 0.; // TODO
diff --git a/Structure.hpp b/Structure.hpp
index 55548487..5bcadb0f 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -55,6 +55,10 @@ class Structure
 
     virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
 
+    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const = 0;
+
+    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const = 0;
+
     virtual projected_type projected_point(position_type const& pos) const = 0;
 
     virtual std::size_t hash() const
diff --git a/binding/Makefile.am b/binding/Makefile.am
index 0d859e68..be047fa5 100644
--- a/binding/Makefile.am
+++ b/binding/Makefile.am
@@ -8,8 +8,10 @@ AM_CPPFLAGS = @CPPFLAGS@ -DNO_IMPORT
 noinst_LTLIBRARIES = libbinding_utils.la
 
 noinst_HEADERS = \
-	bd_propagator_class.hpp \
+    bd_propagator_class.hpp \
+	new_bd_propagator_class.hpp \
 	BDPropagator.hpp \
+    newBDPropagator.hpp \
 	binding_common.hpp \
 	box_class.hpp \
 	Box.hpp \
@@ -88,6 +90,7 @@ noinst_HEADERS = \
 
 libbinding_utils_la_SOURCES = \
 	bd_propagator_class.cpp \
+    new_bd_propagator_class.cpp \
 	box_class.cpp \
 	ConsoleAppender.cpp \
 	cylinder_class.cpp \
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index 1ea2f523..e2aaf2e4 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -28,6 +28,7 @@
 #include "../ParticleSimulator.hpp"
 #include "../EGFRDSimulator.hpp"
 #include "../BDPropagator.hpp"
+#include "../newBDPropagator.hpp"
 #include "../BDSimulator.hpp"
 #include "../StructureUtils.hpp"
 #include "../AnalyticalSingle.hpp"
@@ -69,6 +70,7 @@ typedef EGFRDSimulator::sphere_type Sphere;
 typedef EGFRDSimulator::cylinder_type Cylinder;
 typedef EGFRDSimulator::plane_type Plane;
 typedef ::BDPropagator<EGFRDSimulatorTraits> BDPropagator;
+typedef ::newBDPropagator<EGFRDSimulatorTraits> newBDPropagator;
 typedef EGFRDSimulatorTraits::shell_id_type ShellID;
 typedef EGFRDSimulatorTraits::domain_id_type DomainID;
 typedef EGFRDSimulatorTraits::reaction_rule_type ReactionRuleInfo;
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 9cdeca6b..20729958 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -1,5 +1,5 @@
-#ifndef BD_PROPAGATOR_HPP
-#define BD_PROPAGATOR_HPP
+#ifndef NEW_BD_PROPAGATOR_HPP
+#define NEW_BD_PROPAGATOR_HPP
 
 #include <algorithm>
 #include <boost/bind.hpp>
@@ -21,7 +21,7 @@
 #include "Logger.hpp"
 
 template<typename Ttraits_>
-class BDPropagator
+class newBDPropagator
 {
 public:
     typedef Ttraits_ traits_type;
@@ -50,14 +50,14 @@ class BDPropagator
 
 public:
     template<typename Trange_>
-    BDPropagator(
+    newBDPropagator(
         particle_container_type& tx, network_rules_type const& rules,
         rng_type& rng, time_type dt, int max_retry_count,
         reaction_recorder_type* rrec, volume_clearer_type* vc,
         Trange_ const& particles)
         : tx_(tx), rules_(rules), rng_(rng), dt_(dt),
           max_retry_count_(max_retry_count), rrec_(rrec), vc_(vc),
-          queue_(), rejected_move_count_(0)
+          queue_(), rejected_move_count_(0), reaction_length_( sqrt( 4 * 1E-12 * dt ) )
     {
         call_with_size_if_randomly_accessible(
             boost::bind(&particle_id_vector_type::reserve, &queue_, _1),
@@ -108,11 +108,10 @@ class BDPropagator
                     particle_shape_type(new_pos, species.radius()),
                     species.D()));
 
-	/*Use a spherical shape with  radius = particle_radius + reaction_radius.
-	  We use it to check for overlaps with other particels (and surfaces). */
+	    /*Use a spherical shape with radius = particle_radius + reaction_radius.
+	      We use it to check for overlaps with other particels (and surfaces).*/
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
-            tx_.check_overlap(reaction_shape(new_pos, species.radius() + reaction_radius ),
-			      particle_to_update.first));
+            tx_.check_overlap(particle_shape_type( new_pos, species.radius() + reaction_length_ ), particle_to_update.first));
         switch (overlapped ? overlapped->size(): 0)
         {
         case 0:
@@ -122,10 +121,11 @@ class BDPropagator
             {
                 particle_id_pair_and_distance const& closest(overlapped->at(0));
 
-		if( closest.second < pp.second.radius() + closest.first.second.radius() ){
-		  ++rejected_move_count_;
-		  return true;
-		}
+                /* Check if we generated an overlap of the particle cores. If so; return. (dist < r01) */
+		        if( closest.second < pp.second.radius() + closest.first.second.radius() ){
+		            ++rejected_move_count_;
+		            return true;
+		        }
 		
                 try
                 {
@@ -251,8 +251,7 @@ class BDPropagator
                             boost::shared_ptr<structure_type> pp_structure( 
                                 tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) );  
                
-                            position_type m( pp_structure->
-                                        dissociation_vector( rng_, r01, dt_, D01, s0.v() - s1.v() ) );
+                            position_type m( pp_structure->newbd_dissociation_vector( rng_, r01, reaction_length_ ) );
                             
                             np0 = tx_.apply_boundary(pp.second.position()
                                     - m * (s0.D() / D01));
@@ -313,7 +312,7 @@ class BDPropagator
 
         const species_type s0(tx_.get_species(pp0.second.sid())),
                 s1(tx_.get_species(pp1.second.sid()));
-        length_type r01(s0.radius() + s1.radius());
+        //length_type r01(s0.radius() + s1.radius());
 
         const Real rnd(rng_());
         Real prob = 0;
@@ -326,8 +325,7 @@ class BDPropagator
             boost::shared_ptr<structure_type> pp_structure( 
                tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
 
-            const Real p(pp_structure->p_acceptance( r.k(), dt_, r01, subtract( pp1.second.position(), 
-                                                pp0.second.position() ), s0.D(), s1.D(), s0.v(), s1.v() ));
+            const Real p( r.k() * dt_ / pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) );
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
@@ -431,11 +429,12 @@ class BDPropagator
     volume_clearer_type* const vc_;
     particle_id_vector_type queue_;
     int rejected_move_count_;
+    Real const reaction_length_;
     static Logger& log_;
 };
 
 template<typename Ttraits_>
-Logger& BDPropagator<Ttraits_>::log_(Logger::get_logger("ecell.BDPropagator"));
+Logger& newBDPropagator<Ttraits_>::log_(Logger::get_logger("ecell.newBDPropagator"));
 
-#endif /* BD_PROPAGATOR_HPP */
+#endif /* NEW_BD_PROPAGATOR_HPP */
 
diff --git a/pyGFRD.cpp b/pyGFRD.cpp
index 800d78f9..7819b9bd 100644
--- a/pyGFRD.cpp
+++ b/pyGFRD.cpp
@@ -28,6 +28,7 @@
 #include "peer/numpy/scalar_converters.hpp"
 
 #include "binding/bd_propagator_class.hpp"
+#include "binding/new_bd_propagator_class.hpp"
 #include "binding/binding_common.hpp"
 #include "binding/box_class.hpp"
 #include "binding/cylinder_class.hpp"
@@ -79,6 +80,7 @@ peer::util::register_exception_translator<PyExc_IndexError, std::out_of_range>()
 
     b::register_model_class();
     b::register_bd_propagator_class();
+    b::register_new_bd_propagator_class();
     b::register_box_class();
     b::register_domain_id_class();
     b::register_domain_classes();

From d69546cb868fcdc37a01945b97fb96d9e71b1630 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 27 Sep 2011 10:04:38 +0200
Subject: [PATCH 0213/1541] Added new files for the binding of the new newBD
 class.

---
 binding/newBDPropagator.hpp         | 52 +++++++++++++++++++++++++++++
 binding/new_bd_propagator_class.cpp | 15 +++++++++
 binding/new_bd_propagator_class.hpp | 10 ++++++
 3 files changed, 77 insertions(+)
 create mode 100644 binding/newBDPropagator.hpp
 create mode 100644 binding/new_bd_propagator_class.cpp
 create mode 100644 binding/new_bd_propagator_class.hpp

diff --git a/binding/newBDPropagator.hpp b/binding/newBDPropagator.hpp
new file mode 100644
index 00000000..cb2965db
--- /dev/null
+++ b/binding/newBDPropagator.hpp
@@ -0,0 +1,52 @@
+#ifndef BINDING_NEW_BD_PROPAGATOR_HPP
+#define BINDING_NEW_BD_PROPAGATOR_HPP
+
+#include <boost/python.hpp>
+#include "utils/pair.hpp"
+#include "peer/utils.hpp"
+#include "peer/wrappers/range/pyiterable_range.hpp"
+#include "peer/converters/sequence.hpp"
+
+namespace binding {
+
+template<typename Timpl_>
+static void newBDPropagator_propagate_all(Timpl_& self)
+{
+    while (self());
+}
+
+template<typename Timpl_>
+inline boost::python::objects::class_base register_new_bd_propagator_class(char const* name)
+{
+    using namespace boost::python;
+    typedef Timpl_ impl_type;
+    typedef typename impl_type::traits_type simulator_traits_type;
+    typedef typename simulator_traits_type::world_type world_type;
+    typedef typename world_type::particle_id_type particle_id_type;
+    typedef typename simulator_traits_type::network_rules_type network_rules_type;
+    typedef typename world_type::traits_type::rng_type rng_type;
+    typedef typename simulator_traits_type::time_type time_type;
+    typedef typename world_type::particle_container_type particle_container_type;
+    typedef typename impl_type::reaction_recorder_type reaction_recorder_type;
+    typedef typename impl_type::volume_clearer_type volume_clearer_type;
+
+    peer::converters::register_pyiterable_range_converter<particle_id_type>();
+    return class_<impl_type, boost::noncopyable>(
+        name, init<
+            particle_container_type&, network_rules_type const&, rng_type&,
+            time_type, int, reaction_recorder_type*, volume_clearer_type*,
+            peer::wrappers::pyiterable_range<particle_id_type> >())
+        .def(init<
+            particle_container_type&, network_rules_type const&, rng_type&,
+            time_type, int, reaction_recorder_type*, volume_clearer_type*,
+            typename get_select_first_range<typename world_type::particle_id_pair_range>::type>())
+        .add_property("rejected_move_count",
+            &impl_type::get_rejected_move_count)
+        .def("__call__", &impl_type::operator())
+        .def("propagate_all", &newBDPropagator_propagate_all<impl_type>)
+        ;
+}
+
+} // namespace binding
+
+#endif /* BINDING_NEW_BD_PROPAGATOR_HPP */
diff --git a/binding/new_bd_propagator_class.cpp b/binding/new_bd_propagator_class.cpp
new file mode 100644
index 00000000..920741d2
--- /dev/null
+++ b/binding/new_bd_propagator_class.cpp
@@ -0,0 +1,15 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include "newBDPropagator.hpp"
+#include "binding_common.hpp"
+
+namespace binding {
+
+void register_new_bd_propagator_class()
+{
+    register_new_bd_propagator_class<newBDPropagator>("newBDPropagator");
+}
+
+} // namespace binding
diff --git a/binding/new_bd_propagator_class.hpp b/binding/new_bd_propagator_class.hpp
new file mode 100644
index 00000000..7758a254
--- /dev/null
+++ b/binding/new_bd_propagator_class.hpp
@@ -0,0 +1,10 @@
+#ifndef BINDING_NEW_BD_PROPAGATOR_CLASS_HPP
+#define BINDING_NEW_BD_PROPAGATOR_CLASS_HPP
+
+namespace binding {
+
+void register_new_bd_propagator_class();
+
+} // namespace binding
+
+#endif /* BINDING_NEW_BD_PROPAGATOR_CLASS_HPP */

From c5c23897a52d678c7a1a53f9935f168ac76c1d42 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 11:21:58 +0200
Subject: [PATCH 0214/1541] added comments

---
 domain.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/domain.py b/domain.py
index 8469684a..d1c07dcd 100644
--- a/domain.py
+++ b/domain.py
@@ -39,6 +39,8 @@ def initialize(self, time):		# this method needs to be overloaded in all subclas
 
     def calc_ktot(self, reactionrules):
 	# calculates the total rate for a list of reaction rules
+        # The probability for the reaction to happen is proportional to 
+        # the sum of the rates of all the possible reaction types.
 	k_tot = 0
         for rr in reactionrules:
             k_tot += rr.k

From a178f977730a16cf73246e009f9a6418bfb4683e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 11:22:46 +0200
Subject: [PATCH 0215/1541] cleanup of unused code for drawing the reactionrule

---
 egfrd.py | 18 +++++-------------
 1 file changed, 5 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7a7c0547..e180e994 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -392,9 +392,10 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 	species = self.world.get_species(species_id)
 
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
-        #interaction_type = self.query_interaction_rule(species_id, surface)
         # TODO.
-        interaction_rules = None
+        #interaction_rules = self.network_rules.query_reaction_rule(species_id, surface)
+        interaction_rules = []
+
         structure = self.world.get_structure(species.structure_id)
 
 	particle_pos = pid_particle_pair[1].position
@@ -447,17 +448,8 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         shell_id = self.shell_id_generator()
 
         # Select 1 reaction type out of all possible reaction types between the two particles.
-        rrs = self.network_rules.query_reaction_rule(
-                pid_particle_pair1[1].sid,
-                pid_particle_pair2[1].sid)
-#        k_array = numpy.add.accumulate([rr.k for rr in rrs])
-#        k_max = k_array[-1]
-#        rnd = myrandom.uniform()
-#        i = numpy.searchsorted(k_array, rnd * k_max)
-#        rr = rrs[i]
-        # The probability for this reaction to happen is proportional to 
-        # the sum of the rates of all the possible reaction types. 
-#        rr.ktot = k_max
+        rrs = self.network_rules.query_reaction_rule(pid_particle_pair1[1].sid,
+					             pid_particle_pair2[1].sid)
 
         # Get structure (region or surface) where particle1 lives (assuming particle2
 	# also lives here -> TODO).

From 7f060cc2539d4b1d86a480876e5577f6ed75c691 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 11:24:33 +0200
Subject: [PATCH 0216/1541] Interaction singles now also use Domain method for
 ktot and drawing interaction rule

---
 single.py | 43 ++++++++++++++++++++++++-------------------
 1 file changed, 24 insertions(+), 19 deletions(-)

diff --git a/single.py b/single.py
index e215a849..1025f7f2 100644
--- a/single.py
+++ b/single.py
@@ -39,7 +39,7 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
         self.structure = structure			# the structure in/on which the particle lives
 
         self.reactionrules = reactionrules		# the reaction rules for mono molecular reactions
-	self.rrule = None			# with this particle as the reactant
+	self.rrule = None				# the reaction rule of the actual reaction (property reactionrule)
         self.k_tot = self.calc_ktot(reactionrules)
         #self.updatek_tot()				# RENAME to calc_ktot and MOVE to ProtectiveDomain
 
@@ -113,17 +113,17 @@ def draw_escape_time_tuple(self):
         event_type = EventType.SINGLE_ESCAPE	# TODO Event is not an ESCAPE when in 1D there is drift
         return dt, event_type
 
-    def updatek_tot(self):
-	# MOVE to ProtectiveDomain class. See also reasoning above for
-	# draw_reaction_time_tuple
-        self.k_tot = 0
-
-        if not self.reactionrules:
-            return
-
-        for rr in self.reactionrules:
-            self.k_tot += rr.k
-
+#    def updatek_tot(self):
+#	# MOVE to ProtectiveDomain class. See also reasoning above for
+#	# draw_reaction_time_tuple
+#        self.k_tot = 0
+#
+#        if not self.reactionrules:
+#            return
+#
+#        for rr in self.reactionrules:
+#            self.k_tot += rr.k
+#
 #    def draw_reaction_rule(self):
 #	# MOVE to ProtectiveDomain class
 #        k_array = [rr.k for rr in self.reactionrules]
@@ -444,9 +444,17 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell
 
 	self.shell_id = shell_id
         self.interactionrules = interactionrules	# the surface interaction 'reactions'
+	self.intrule = None
+	self.interaction_ktot = self.calc_ktot(interactionrules)
 	self.surface = surface				# The surface with which the particle is
 							# trying to interact
 
+    def get_interaction_rule(self):
+	if self.intrule == []:
+	    self.intrule = self.draw_reaction_rule(self.interactionrules)
+	return self.intrule
+    interactionrule = property(get_interaction_rule)
+
 	# There are defined here but are overloaded later
     def get_inner_dz_left(self):
 	pass
@@ -547,10 +555,10 @@ def iv_greens_function(self):
 	# The green's function that also modelles the association of the particle
 	# with the planar surface.
 	# TODO choose interactionrule
-#        return GreensFunction1DRadAbs(self.D, self.interactionrule.k, self.z0,
-#				      -self.get_inner_dz_left(), self.get_inner_dz_right())
-        return GreensFunction1DRadAbs(self.D, 0, self.z0,
+        return GreensFunction1DRadAbs(self.D, self.interaction_ktot, self.z0,
 				      -self.get_inner_dz_left(), self.get_inner_dz_right())
+#        return GreensFunction1DRadAbs(self.D, 0, self.z0,
+#				      -self.get_inner_dz_left(), self.get_inner_dz_right())
 
     def draw_new_position(self, dt, event_type):
 	"""Draws a new position for the particle for a given event type at a given time
@@ -658,11 +666,8 @@ def greens_function(self):
     def iv_greens_function(self):
 	# Green's function used for the interaction
         # Interaction possible in r direction.
-        # TODO.
-        #k = self.interaction_rule.k
-        k = 0
         # TODO 2D.
-        return GreensFunction3DRadAbs(self.D, k, self.r0, self.get_inner_sigma(),
+        return GreensFunction3DRadAbs(self.D, self.interaction_ktot, self.r0, self.get_inner_sigma(),
 				      self.get_inner_a())
 
     def draw_new_position(self, dt, event_type):

From ba097d662a767e1f92b5b32dfc6900771eb135c2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 11:25:18 +0200
Subject: [PATCH 0217/1541] added some imports for get_max_shell_size

---
 pair.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 777316f3..07c1a248 100644
--- a/pair.py
+++ b/pair.py
@@ -2,11 +2,15 @@
 from constants import EventType
 from _greens_functions import *
 from greens_function_wrapper import *
+
 from domain import (
     Domain,
     ProtectiveDomain)
 from single import (
-    NonInteractionSingle)
+    NonInteractionSingle,
+    InteractionSingle)
+from multi import (
+    Multi)
 
 __all__ = [
     'CylindricalSurfacePair',

From 583d54975f773acf4efa9ab55293b242b7722733 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 11:36:11 +0200
Subject: [PATCH 0218/1541] name change of clear_volume -> burst_volume

---
 egfrd.py | 12 ++++--------
 multi.py |  2 +-
 2 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index e180e994..9dfd4677 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -605,13 +605,9 @@ def burst_objs(self, domains):
 
         return bursted
 
-    def clear_volume(self, pos, radius, ignore=[]):
+    def burst_volume(self, pos, radius, ignore=[]):
         """ Burst domains within a certain volume and give their ids.
 
-        This function actually has a confusing name, as it only bursts 
-        domains within a certain radius, and gives their ids. It doesn't
-        remove the particles or something like that.
-
         (Bursting means it propagates the particles within the domain until
         the current time, and then creates a new, minimum-sized domain.)
 
@@ -620,7 +616,7 @@ def clear_volume(self, pos, radius, ignore=[]):
             - radius: radius of area to be "bursted"
             - ignore: domains that should be ignored, none by default.
         """ # ~ MW
-	# TODO clear_volume now always assumes a spherical volume to burst.
+	# TODO burst_volume now always assumes a spherical volume to burst.
 	# It is inefficient to burst on the 'other' side of the membrane or to
 	# burst in a circle, when you want to make a new shell in the membrane.
 	# Then we may want to burst in a cylindrical volume, not a sphere
@@ -667,7 +663,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
             product_species = self.world.get_species(rt.products[0])
 
             if reactant_species_radius < product_species.radius:
-                self.clear_volume(oldpos, product_species.radius)
+                self.burst_volume(oldpos, product_species.radius)
 
             if self.world.check_overlap((oldpos, product_species.radius),
                                         single.pid_particle_pair[0]):
@@ -703,7 +699,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
             rad = max(particle_radius12 * (D1 / D12) + particle_radius1,
                       particle_radius12 * (D2 / D12) + particle_radius2)
 
-            self.clear_volume(oldpos, rad)
+            self.burst_volume(oldpos, rad)
 
             for _ in range(self.dissociation_retry_moves):
                 vector = _random_vector(current_structure, particle_radius12 *
diff --git a/multi.py b/multi.py
index 49ff5b8c..318249aa 100644
--- a/multi.py
+++ b/multi.py
@@ -78,7 +78,7 @@ def __call__(self, shape, ignore0, ignore1=None):
                     main = self.outer_.main()
                     if self.outer_.last_event == None:
                         self.outer_.last_event = EventType.MULTI_ESCAPE
-                    main.clear_volume(shape.position, shape.radius, 
+                    main.burst_volume(shape.position, shape.radius, 
                                       ignore=[self.outer_.domain_id, ])
                     if ignore1 is None:
                         return not main.world.check_overlap(

From 64472dd44bc319be7344c648a051e17080206e4c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 11:51:28 +0200
Subject: [PATCH 0219/1541] name change fire_single/pair/multi ->
 proc_event_by_single/pair/multi

---
 egfrd.py | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9dfd4677..1431ce1b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -317,7 +317,7 @@ def step(self):
         # Dispatch is a dictionary (hash) of what function to use to fire
         # different classes of shells (see bottom egfrd.py) 
         # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
-        # e.g. "if class is Single, then fire_single" ~ MW
+        # e.g. "if class is Single, then proc_event_by_single" ~ MW
         for klass, f in self.dispatch:
             if isinstance(domain, klass):
                 f(self, domain)		# fire the correct method for the class (e.g. fire_singel(self, Single))
@@ -577,7 +577,7 @@ def burst_domain(self, domain):
             single1, single2 = self.burst_pair(domain)
             # Don't schedule events in burst/propagate_pair, because 
             # scheduling is different after a single reaction in 
-            # fire_pair.
+            # proc_event_by_pair.
             self.add_domain_event(single1)
             self.add_domain_event(single2)
             self.remove_event(domain)
@@ -813,7 +813,7 @@ def propagate_single(self, single):
                                  single.pid_particle_pair[1].radius)
                 return single
 
-    def fire_single(self, single):
+    def proc_event_by_single(self, single):
 	### 1. Process event produced by the single
 	### 1.1 Special cases (shortcuts)
         # In case nothing is scheduled to happen: do nothing; 
@@ -1131,7 +1131,7 @@ def update_single(self, single):
         single.dt, single.event_type = single.determine_next_event()
         single.last_time = self.t
 
-    def fire_pair(self, pair):
+    def proc_event_by_pair(self, pair):
         assert self.check_obj(pair)
 
         single1 = pair.single1
@@ -1250,7 +1250,7 @@ def fire_pair(self, pair):
 
         return
 
-    def fire_multi(self, multi):
+    def proc_event_by_multi(self, multi):
         self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
         multi.step()
 
@@ -1384,9 +1384,9 @@ def propagate_pair(self, pair, dt, event_type):
             newpos2 = particle2[1].position
 
         if __debug__:
-            log.debug("fire_pair: #1 { %s: %s => %s }" %
+            log.debug("proc_event_by_pair: #1 { %s: %s => %s }" %
                       (single1, pos1, newpos1))
-            log.debug("fire_pair: #2 { %s: %s => %s }" %
+            log.debug("proc_event_by_pair: #2 { %s: %s => %s }" %
                       (single2, str(pos2), str(newpos2)))
 
         single1.initialize(self.t)
@@ -2113,9 +2113,9 @@ def count_domains(self):
         return (num_singles, num_pairs, num_multis)
 
     dispatch = [
-        (Single, fire_single),
-        (Pair, fire_pair),
-        (Multi, fire_multi)
+        (Single, proc_event_by_single),
+        (Pair, proc_event_by_pair),
+        (Multi, proc_event_by_multi)
         ]
 
 

From b893ab851790ede6d53b75ec207c0bc89e5c0ead Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 14:59:06 +0200
Subject: [PATCH 0220/1541] added comments for TODO

---
 pair.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pair.py b/pair.py
index 07c1a248..6ede4243 100644
--- a/pair.py
+++ b/pair.py
@@ -124,6 +124,8 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         inter-particle vector.
 
         """
+	# If the two particles have reacted this should return the
+	# new position twice
         new_com = self.draw_new_com(dt, event_type)
         new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
 

From 41f6af2acf3288e41a9b85a4b2818a01c80aa4d0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 14:59:44 +0200
Subject: [PATCH 0221/1541] initial cleanup of code in proc_event_by_single
 (fire_single)

---
 egfrd.py | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1431ce1b..1dd6ce3c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -659,6 +659,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
 
             
         elif len(rt.products) == 1:
+	# TODO product particle can live on different structure
             
             product_species = self.world.get_species(rt.products[0])
 
@@ -684,6 +685,7 @@ def fire_single_reaction(self, single, interaction_flag=False):
 
             
         elif len(rt.products) == 2:
+	# TODO (one of the) product particles can live on different structure
             product_species1 = self.world.get_species(rt.products[0])
             product_species2 = self.world.get_species(rt.products[1])
             
@@ -815,16 +817,33 @@ def propagate_single(self, single):
 
     def proc_event_by_single(self, single):
 	### 1. Process event produced by the single
+
+        if __debug__:
+            log.info('%s' % single.event_type)
+            log.info('single = %s' % single)
+
 	### 1.1 Special cases (shortcuts)
+
         # In case nothing is scheduled to happen: do nothing; 
-        # results also in disappearance from scheduler. (?)
+        # No event for the single is now in scheduler->FIXME.
         if single.dt == numpy.inf:
             return 
-	# Else continue
 
-        # check timeline (??)
+        # check that the event time of the single (last_time + dt) is equal to the
+	# simulator time
         assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
+        # Handle immobile case (what event has taken place to get here?!).
+        if single.getD() == 0:
+	    # The domain has not produced an decay reaction event and is immobile
+            # ->no propagation, no other changes just calculate next reaction time
+	    # and reschedule the single. So this also takes care of the domain making part
+            single.dt, single.event_type = single.determine_next_event() 
+            single.last_time = self.t
+            self.add_domain_event(single)
+            return
+
+
         # If the single had a decay reaction.
         if single.event_type == EventType.SINGLE_REACTION:
             if __debug__:
@@ -844,25 +863,6 @@ def proc_event_by_single(self, single):
 
             return
 
-	# Else the event was either an ESCAPE (NonInteractionSingle or InteractionSingle),
-	# or IV_EVENT (InteractionSingle only), NO BURST event comes up here!
-
-
-        if __debug__:
-            log.info('%s' % single.event_type)
-            log.info('single = %s' % single)
-
-        # Handle immobile case (what event has taken place to get here?!).
-        if single.getD() == 0:
-	    # The domain has not produced an decay reaction event and is immobile
-            # ->no propagation, no other changes just calculate next reaction time
-	    # and reschedule the single. So this also takes care of the domain making part
-            single.dt, single.event_type = single.determine_next_event() 
-            single.last_time = self.t
-            self.add_domain_event(single)
-            return
-        
-
 	### 1.2 General case
 	# There is a non-trivial event time for the domain
         if single.dt != 0.0:

From 7e098f03218122e78e45b764c2ce87fb7e6d0b93 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 17:39:24 +0200
Subject: [PATCH 0222/1541] small fix

---
 pair.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 6ede4243..8331d5bd 100644
--- a/pair.py
+++ b/pair.py
@@ -124,7 +124,7 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         inter-particle vector.
 
         """
-	# If the two particles have reacted this should return the
+	# TODO If the two particles have reacted this should return the
 	# new position twice
         new_com = self.draw_new_com(dt, event_type)
         new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
@@ -282,7 +282,7 @@ def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
 	# we still have to make sure that the (non closest) NonInteractionSingles have
 	# the required space
         else:
-            assert isinstance(closest, (Pair, Multi, Surface, None.__class__))
+            assert isinstance(closest, (InteractionSingle, Pair, Multi, Surface, None.__class__))
             shell_size = closest_distance 
 
 

From 6b35fc7d7532c469cc02dd4d2eab0dea630fc15d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 17:39:33 +0200
Subject: [PATCH 0223/1541] polishing of burst methods

---
 egfrd.py | 86 +++++++++++++++++++++++++++-----------------------------
 1 file changed, 42 insertions(+), 44 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1dd6ce3c..c5e73441 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -365,8 +365,9 @@ def create_single(self, pid_particle_pair):
         # CylindricalSurfaceSingle.
         single = create_default_single(domain_id, pid_particle_pair, 
                                        shell_id, rrs, structure)
+
         assert isinstance(single, NonInteractionSingle)
-        single.initialize(self.t)
+        single.initialize(self.t)		# set the initial event and event time
         self.domains[domain_id] = single
 
 	# 3. update the proper shell container
@@ -575,12 +576,6 @@ def burst_domain(self, domain):
             bursted = [domain, ]
         elif isinstance(domain, Pair):  # Pair
             single1, single2 = self.burst_pair(domain)
-            # Don't schedule events in burst/propagate_pair, because 
-            # scheduling is different after a single reaction in 
-            # proc_event_by_pair.
-            self.add_domain_event(single1)
-            self.add_domain_event(single2)
-            self.remove_event(domain)
             bursted = [single1, single2]
         else:  # Multi
 #            bursted = self.burst_multi(domain)
@@ -1134,6 +1129,10 @@ def update_single(self, single):
     def proc_event_by_pair(self, pair):
         assert self.check_obj(pair)
 
+	# check that the time is the currect simulator time 
+        assert self.t >= pair.last_time
+        assert self.t == pair.last_time + pair.dt
+
         single1 = pair.single1
         single2 = pair.single2
         particle1 = single1.pid_particle_pair
@@ -1173,7 +1172,8 @@ def proc_event_by_pair(self, pair):
             else:
                 theothersingle = single1
 
-            self.burst_pair(pair)	# TODO this should be a propagate -> cleaner
+	    # note method has side effect on single1 and single2
+            self.propagate_pair(pair)
 
             self.add_domain_event(theothersingle)
 
@@ -1240,9 +1240,7 @@ def proc_event_by_pair(self, pair):
         #
         elif(pair.event_type == EventType.IV_ESCAPE or
              pair.event_type == EventType.COM_ESCAPE):
-            dt = pair.dt
-            event_type = pair.event_type
-            single1, single2 = self.propagate_pair(pair, dt, event_type)
+            single1, single2 = self.propagate_pair(pair)
             self.add_domain_event(single1)
             self.add_domain_event(single2)
         else:
@@ -1287,66 +1285,66 @@ def break_up_multi(self, multi):
 #        return singles
 
     def burst_single(self, single):
-        # Sets next event time of single domain in such a way it will end 
-        # up at current time if fired, and then outputs newly created 
-        # single that is result of firing old single
+        # Sets next event time of 'single' to current time and event to burst event
+        # returns a new single that is the result of firing the old single
+	# new single also has proper zero shell and is rescheduled
+
+	if __debug__:
+	    log.debug('burst single: %s', single)
 
         # Check correct timeline ~ MW
-        assert self.t >= single.last_time
+        assert single.last_time <= self.t
         assert self.t <= single.last_time + single.dt
 
-        # record important single data ~ MW
-#        oldpos = single.shell.shape.position
-#        old_shell_size = single.get_shell_size()
-
-        particle_radius = single.pid_particle_pair[1].radius
-
         # Override dt, burst happens before single's scheduled event.
+        # Override event_type. 
         single.dt = self.t - single.last_time
-        # Override event_type. Always call gf.drawR on BURST.
         single.event_type = EventType.BURST
+
         newsingle = self.propagate_single(single)
 
         newpos = newsingle.pid_particle_pair[1].position
-        # Check if stays within domain ~MW
-#        assert self.world.distance(newpos, oldpos) <= \
-#               old_shell_size - particle_radius
-        # Displacement check is in NonInteractionSingle.draw_new_position.
+        # TODO? Check if stays within domain ~MW
 
         if isinstance(single, InteractionSingle):
-            # Removing the event has to be done for *bursting* 
-            # *Interaction*Singles, not for propagating 
-            # InteractionSingles nor for bursting 
-            # NonInteractionSingles.
+            # When bursting an InteractionSingle, the domain changes from Interaction
+	    # NonInteraction domain. This needs to be reflected in the event 
             self.remove_event(single)
             self.add_domain_event(newsingle)
         else:
             assert single == newsingle
             self.update_domain_event(self.t, single)
 
+        particle_radius = single.pid_particle_pair[1].radius
         assert newsingle.shell.shape.radius == particle_radius
 
-        # Returned single is different from original single in the case 
-        # of an InteractionSingle only.
         return newsingle
 
     def burst_pair(self, pair):
-	# TODO this should also schedule the resulting Singles and remove the
-	# Pair event -> cleaner
+	# Sets next event time of 'pair' to current time and event to burst event
+	# returns two new singles that are the result of firing the pair
+	# new singles also have proper zero shell and are rescheduled
+
         if __debug__:
             log.debug('burst_pair: %s', pair)
 
-        assert self.t >= pair.last_time
+	# make sure that the current time is between the last time and the event time
+        assert pair.last_time <= self.t
         assert self.t <= pair.last_time + pair.dt
 
-        dt = self.t - pair.last_time 
-        # Override event_type. Always call sgf.drawR and pgf.drawR on BURST.
-        event_type = EventType.BURST
-        single1, single2 = self.propagate_pair(pair, dt, event_type)
+        # Override event time and event_type. 
+        pair.dt = self.t - pair.last_time 
+        pair.event_type = EventType.BURST
+
+        single1, single2 = self.propagate_pair(pair)
+
+        self.remove_event(pair)		# remove the event -> was still in the scheduler
+        self.add_domain_event(single1)
+        self.add_domain_event(single2)
 
         return single1, single2
 
-    def propagate_pair(self, pair, dt, event_type):
+    def propagate_pair(self, pair):
         single1 = pair.single1
         single2 = pair.single2
 
@@ -1356,7 +1354,7 @@ def propagate_pair(self, pair, dt, event_type):
         pos1 = particle1[1].position
         pos2 = particle2[1].position
 
-        if dt > 0.0:
+        if pair.dt > 0.0:
             D1 = particle1[1].D
             D2 = particle2[1].D
 
@@ -1367,9 +1365,8 @@ def propagate_pair(self, pair, dt, event_type):
 
             old_com = pair.com
 
-            newpos1, newpos2 = pair.draw_new_positions(dt, r0, 
-                                                     old_inter_particle, 
-                                                     event_type)
+            newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
+                                                       pair.event_type)
 
             newpos1 = self.world.apply_boundary(newpos1)
             newpos2 = self.world.apply_boundary(newpos2)
@@ -1380,6 +1377,7 @@ def propagate_pair(self, pair, dt, event_type):
             assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
                                        pair.get_shell_size())
         else:
+	# no time has passed
             newpos1 = particle1[1].position
             newpos2 = particle2[1].position
 

From 0465f2edd6d3ead685eaeadef1793d5a3390a362 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 19:20:02 +0200
Subject: [PATCH 0224/1541] small cleanup

---
 egfrd.py | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c5e73441..0b9418f6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -638,8 +638,14 @@ def fire_single_reaction(self, single, interaction_flag=False):
 	# This takes care of the identity change when a single particle decays into
 	# one or a number of other particles
 	# TODO This can also be used when a particle falls off a surface.
+
+	# THis is supposed to take care of the movement and identity change that
+	# happens when an Interaction event has occurred
         if interaction_flag == True:
             raise NotImplementedError
+	
+
+
         reactant_species_radius = single.pid_particle_pair[1].radius
         oldpos = single.pid_particle_pair[1].position
         current_structure = single.structure
@@ -783,6 +789,8 @@ def propagate_single(self, single):
 
         if(single.event_type == EventType.SINGLE_REACTION or
            single.event_type == EventType.IV_INTERACTION):
+	    # An identity change of the particle needs to take place
+
             # Single reaction or interaction, and not a burst. Only 
             # update particle, single is removed anyway.
             self.move_single_particle(single, newpos)
@@ -1185,12 +1193,10 @@ def proc_event_by_pair(self, pair):
             except NoSpace:
                 self.reject_single_reaction(reactingsingle)
 
-            return
-        
         #
         # 2. Pair reaction
         #
-        if pair.event_type == EventType.IV_REACTION:
+        elif pair.event_type == EventType.IV_REACTION:
             self.world.remove_particle(single1.pid_particle_pair[0])
             self.world.remove_particle(single2.pid_particle_pair[0])
 
@@ -1203,15 +1209,17 @@ def proc_event_by_pair(self, pair):
 	    elif len(rr.products) == 1:
                 species3 = self.world.get_species(rr.products[0])
                 # calculate new position
+		# TODO make this just one of the positions of the particles (they are on top of eachother)
                 event_type = pair.event_type
                 new_com = pair.draw_new_com(pair.dt, event_type)
+                new_com = self.world.apply_boundary(new_com)
 
+		# not sure what this check does 
                 if __debug__:
                     shell_size = pair.get_shell_size()
                     assert self.world.distance(old_com, new_com) < \
                            shell_size - species3.radius
 
-                new_com = self.world.apply_boundary(new_com)
 
 		# make product particle
                 particle = self.world.new_particle(species3.id, new_com)
@@ -1232,8 +1240,6 @@ def proc_event_by_pair(self, pair):
                 log.info('product = %s' % product)
             self.remove_domain(pair)
 
-            return
-
         #
         # 3a. Escaping through a_r.
         # 3b. Escaping through a_R.

From 5a83bc2dd43c82c6c60a65e49fb8438ac8352ff1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Sep 2011 19:20:19 +0200
Subject: [PATCH 0225/1541] draw_new_positions now returns the same position
 twice in case of IVreaction

---
 pair.py | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/pair.py b/pair.py
index 8331d5bd..dfb507bd 100644
--- a/pair.py
+++ b/pair.py
@@ -124,16 +124,22 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         inter-particle vector.
 
         """
-	# TODO If the two particles have reacted this should return the
+	# If the two particles have reacted this returns the
 	# new position twice
         new_com = self.draw_new_com(dt, event_type)
-        new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
 
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
+	if event_type == EventType.IV_REACTION:
+	    newpos1 = new_com
+	    newpos2 = new_com
+	else:
+            new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
+
+            D1 = self.pid_particle_pair1[1].D
+            D2 = self.pid_particle_pair2[1].D
+
+            newpos1 = new_com - new_iv * (D1 / self.D_tot)
+            newpos2 = new_com + new_iv * (D2 / self.D_tot)
 
-        newpos1 = new_com - new_iv * (D1 / self.D_tot)
-        newpos2 = new_com + new_iv * (D2 / self.D_tot)
         return newpos1, newpos2
 
     def draw_new_com(self, dt, event_type):

From 46892d701b447dc0365223aaca6995afcfda0fb0 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 27 Sep 2011 19:21:04 +0200
Subject: [PATCH 0226/1541] Found and fixed general problem concerning non-zero
 initialized alphatables.

Fix involved copying constructor from 3D RadAbs function (which clears the
alpha table).

Green's Functions now do give output, but crash (in a different way) with
certain input parameters.

RadAbs function now gives a load of output, this should be removed when
debugging is finished.
---
 GreensFunction2DRadAbs.cpp      | 76 +++++++++++++++++++++++++++++++--
 GreensFunction2DRadAbs.hpp      | 59 +++----------------------
 samples/2d/v2_GFtool1(space).py | 24 ++++++++++-
 3 files changed, 101 insertions(+), 58 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 4080c6ac..6e6898e8 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -10,6 +10,7 @@
 
 #include <boost/bind.hpp>
 #include <boost/tuple/tuple.hpp>
+#include <boost/format.hpp>
 
 #include <gsl/gsl_errno.h>
 #include <gsl/gsl_math.h>
@@ -42,6 +43,16 @@ GreensFunction2DRadAbs( const Real D,
     h( kf / (D * 2.0 * M_PI * Sigma) ),
     a( a )
 {
+    // print alphaTable value at construction
+    const Real sigma(this->getSigma());
+
+    if (a < sigma)
+    {
+        throw std::invalid_argument((boost::format("a >= sigma : a=%.16g, sigma=%.16g") % a % sigma).str());
+    }
+    GreensFunction2DRadAbs::clearAlphaTable();
+
+    std::clog << "[alphaoffsettable[0]=" << this->alphaOffsetTable[0] << "]"; //DEBUG
     ; // do nothing
 }
 
@@ -56,12 +67,13 @@ GreensFunction2DRadAbs::~GreensFunction2DRadAbs()
 
 void GreensFunction2DRadAbs::clearAlphaTable() const
 {
+    std::clog << "[clearing..";
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
 		   boost::mem_fn( &RealVector::clear ) );
     this->alphaOffsetTable[0] = 0;
     std::fill( this->alphaOffsetTable.begin()+1, this->alphaOffsetTable.end(),
 	       -1 );
-
+    std::clog << " done]";
 }
 
 // The method evaluates the equation for finding the alphas for given alpha. This
@@ -231,7 +243,8 @@ GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
 {
     if( this->alphaOffsetTable[n] > 0 )		// if the offset has already been calculated
     {
-	return this->alphaOffsetTable[n];	// don't do all the work again
+    std::clog << "[returning because already calculated;]" ;// DEBUG
+	return this->alphaOffsetTable[n];	// don't do all the work again   
     }
     assert( this->alphaOffsetTable.size() >= n );	// assume the table is large enough to
 							// accomodate the requested index
@@ -240,6 +253,8 @@ GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
     const Real a( this->geta() );
     const Real interval( M_PI_2 / ( a - sigma ));	// the x-axis of the function scales with a-sigma
 
+    std::clog << "[calculating offset; input={n=" << n << ",sigma="<< sigma <<" , a="<< a <<" , interval="<< interval <<"}]" ;// DEBUG
+
 	Real offset (0);	// by default the offset is zero
 	if (n != 0)
 	{	offset = ( this->alphaOffsetTable[n-1] );
@@ -469,6 +484,60 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	return boost::make_tuple (Ai0_expT*Y0_aAn, Ai0_expT*J0_aAn, Ai0_expT*Y0J1_J0Y1);
 }
 
+const Real GreensFunction2DRadAbs::getAlpha( size_t n, RealVector::size_type i ) const 
+{
+RealVector& alphaTable( this->alphaTable[n] );		// get the ref to the roots of order n
+    const RealVector::size_type oldSize( alphaTable.size() );	// get it's size
+
+if( i >= oldSize )
+{
+    alphaTable.resize( i+1, 0 );	// resize the vector and fill the empty slots with 0
+}
+
+if (alphaTable[i] == 0)		// if the requested root was not calculated yet
+{
+	if (i==0)		// if the requested root is the first one
+	{	const Real offset (alphaOffset(n));	// The offset is the first root
+        std::clog << "[offset=" << offset << "]";
+		alphaTable[i]= offset;
+	}
+	else			// the requested root is dependent on the previous one
+	{
+		const Real previous (getAlpha(n, i-1));		// get the previous root
+		alphaTable[i] = this->alpha_i( previous , n );	// find the requested root based on
+								// the previous one
+	}
+}
+return alphaTable[i];
+
+}
+
+const Real GreensFunction2DRadAbs::getAlpha0( const RealVector::size_type i ) const
+{
+RealVector& alphaTable( this->alphaTable[0] );
+    const RealVector::size_type oldSize( alphaTable.size() );
+
+if( i >= oldSize )
+{
+    alphaTable.resize( i+1, 0 );// fill the empty spaces with zeros
+}
+
+if (alphaTable[i] == 0)         // if the requested root was not calculated yet
+{
+            if (i==0)               // if the requested root is the first one
+            {       const Real offset (alphaOffset(0));     // The offset is the first root
+                    alphaTable[i]= offset;
+            }
+            else                    // the requested root is dependent on the previous one
+            {
+                    const Real previous (getAlpha0(i-1));		// get the previous root
+                    alphaTable[i] = this->alpha0_i( previous );	// find the requested root based on
+                                                                    // the previous one
+            }
+}
+
+return alphaTable[i];
+}
 
 // calculates the ith term with exponent and time for the survival probability
 const Real 
@@ -1092,8 +1161,9 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real D( this->getD() );
         const Real r0( this->getr0() );
 
+        std::clog << "[feed the alpha: (m=" << m << ", n= " << n << ")]";
         const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
-
+       
         std::clog << "{r0=" << r0 << ", alpha="<< alpha << ", r*alpha="<< r0*alpha << "}";
 
         const Real alpha_sq( alpha * alpha );
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 4066c4b1..218aa21b 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -1,6 +1,7 @@
 #if !defined( __FIRSTPASSAGEPAIRGREENSFUNCTION2D_HPP )
 #define __FIRSTPASSAGEPAIRGREENSFUNCTION2D_HPP 
 
+#include <vector>
 #include <boost/tuple/tuple.hpp>
 #include <boost/function.hpp>
 #include <boost/array.hpp>
@@ -15,7 +16,9 @@ class GreensFunction2DRadAbs
     public PairGreensFunction
 {
 
-public: 
+public:
+    // defines vector from template defined in standard template library,
+    // gives it's membervalues type Real. std:: clarifies the std namespace.
     typedef std::vector<Real> RealVector;
 
 private:
@@ -120,59 +123,9 @@ class GreensFunction2DRadAbs
     const boost::tuple<Real,Real,Real> Y0J0J1_constants ( const Real alpha,
                                                           const Real t) const;
 
-    const Real getAlpha( const size_t n, const RealVector::size_type i ) const
-    {
-	RealVector& alphaTable( this->alphaTable[n] );		// get the ref to the roots of order n
-        const RealVector::size_type oldSize( alphaTable.size() );	// get it's size
-
-	if( i >= oldSize )
-	{
-	    alphaTable.resize( i+1, 0 );	// resize the vector and fill the empty slots with 0
-	}
-
-	if (alphaTable[i] == 0)		// if the requested root was not calculated yet
-	{
-		if (i==0)		// if the requested root is the first one
-		{	const Real offset (alphaOffset(n));	// The offset is the first root
-			alphaTable[i]= offset;
-		}
-		else			// the requested root is dependent on the previous one
-		{
-			const Real previous (getAlpha(n, i-1));		// get the previous root
-			alphaTable[i] = this->alpha_i( previous , n );	// find the requested root based on
-									// the previous one
-		}
-	}
-	return alphaTable[i];
-
-    }
+    const Real getAlpha( const size_t n, const RealVector::size_type i ) const;
 
-    const Real getAlpha0( const RealVector::size_type i ) const
-    {
-	RealVector& alphaTable( this->alphaTable[0] );
-        const RealVector::size_type oldSize( alphaTable.size() );
-
-	if( i >= oldSize )
-	{
-	    alphaTable.resize( i+1, 0 );// fill the empty spaces with zeros
-	}
-
-	if (alphaTable[i] == 0)         // if the requested root was not calculated yet
-	{
-                if (i==0)               // if the requested root is the first one
-                {       const Real offset (alphaOffset(0));     // The offset is the first root
-                        alphaTable[i]= offset;
-                }
-                else                    // the requested root is dependent on the previous one
-                {
-                        const Real previous (getAlpha0(i-1));		// get the previous root
-                        alphaTable[i] = this->alpha0_i( previous );	// find the requested root based on
-                                                                        // the previous one
-                }
-	}
-
-	return alphaTable[i];
-    }
+    const Real getAlpha0( const RealVector::size_type i ) const;
 
 protected:
 
diff --git a/samples/2d/v2_GFtool1(space).py b/samples/2d/v2_GFtool1(space).py
index 77a86ef9..9ec9184d 100755
--- a/samples/2d/v2_GFtool1(space).py
+++ b/samples/2d/v2_GFtool1(space).py
@@ -36,10 +36,20 @@
 a =      [10*sigma, 100*sigma]
 r0 =     [1.001*sigma, 3*sigma, 4.999*sigma]
 dt =     [1e-4, 0.03, 0.3, 1, 1e4]
-rnd =    [1e-3, 0.05, 0.1, 0.25, (0.5-1e3)]
+rnd =    [1e-3, 0.05, 0.1, 0.25, (0.5-1e-3)]
 kf =     0; # 2e-12 10 1e10]
 h =      0;
 
+# Convenient for display later on
+# ======================================
+
+codinga = [' - ', ' + ']
+codingr0 = [' - ', ' 0 ', ' + ']
+codingdt = [' --', '  -', ' 0 ', ' + ', ' ++']
+codingrnd = [' --', '  -', ' 0 ', ' + ', ' ++']
+
+resultstable = ['| a | r0| dt|rnd|  -> Result']
+
 # Let's do this the simple way:
 # ======================================
 
@@ -66,14 +76,24 @@
                     try:
                         mygf.drawTheta(rnd[l], r, dt[k])
                         print "succes!"   
+                        succes = True;
                     except:
                         print "fail!"
                         print sys.exc_info()
+                        succes = False;
 
                     print ""
 
-                            
+                    resultstable.append("|"+str(codinga[i])+"|"+
+                                    str(codingr0[i])+"|"+
+                                    str(codingdt[i])+"|"+
+                                    str(codingrnd[i])+
+                                    "|  -> "+str(succes)+"")
 
+print "\n\nRESULTS\n========================\n\n"
+for a in range(len(resultstable)):
+    print str(resultstable[a]);                            
+print "\n\n===========================\n\n"
 
 
 

From 46a5a6afd57e41bc3d1267d8800bcc46dc10d7d8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 28 Sep 2011 18:15:07 +0200
Subject: [PATCH 0227/1541] small comments clarifying the role of two methods

---
 single.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/single.py b/single.py
index 1025f7f2..4483be07 100644
--- a/single.py
+++ b/single.py
@@ -456,6 +456,8 @@ def get_interaction_rule(self):
     interactionrule = property(get_interaction_rule)
 
 	# There are defined here but are overloaded later
+	# These ProtectiveDomains have a Cylindrical shell that is scaled in r and z
+	# Below methods go together with this property
     def get_inner_dz_left(self):
 	pass
 

From e45ae0b39bb64b0ae34d5dc62a93d213bb7f17f9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 28 Sep 2011 18:15:33 +0200
Subject: [PATCH 0228/1541] started changes to fire single -> is now broken,
 doesn't reschedule after propagation

---
 egfrd.py | 105 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 59 insertions(+), 46 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0b9418f6..485ae7ab 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -124,6 +124,8 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 						# the radius in which the NonInteractionSingle will burst.
 	self.MAX_NUM_DT0_STEPS = 10000
 
+	self.MAX_TIME_STEP = 10
+
 	# used datastructrures
         self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
 
@@ -301,7 +303,10 @@ def step(self):
 	#
         id, event = self.scheduler.pop()
 	domain = self.domains[event.data]
-        self.t, self.last_event = event.time, event
+	if event.time == numpy.inf:
+	    self.t, self.last_event = self.MAX_TIME_STEP, event
+	else:
+	    self.t, self.last_event = event.time, event
 
         if __debug__:
             domain_counts = self.count_domains()
@@ -819,71 +824,79 @@ def propagate_single(self, single):
                 return single
 
     def proc_event_by_single(self, single):
-	### 1. Process event produced by the single
 
+	### log Single event
         if __debug__:
             log.info('%s' % single.event_type)
             log.info('single = %s' % single)
 
-	### 1.1 Special cases (shortcuts)
 
-        # In case nothing is scheduled to happen: do nothing; 
-        # No event for the single is now in scheduler->FIXME.
-        if single.dt == numpy.inf:
-            return 
 
-        # check that the event time of the single (last_time + dt) is equal to the
-	# simulator time
-        assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
+	if single.is_reset():
+	### If no event event really happened and just need to make new domain
+	    self.make_new_domain(single)
+	    # domain is already scheduled in make_new_domain
 
-        # Handle immobile case (what event has taken place to get here?!).
-        if single.getD() == 0:
-	    # The domain has not produced an decay reaction event and is immobile
-            # ->no propagation, no other changes just calculate next reaction time
-	    # and reschedule the single. So this also takes care of the domain making part
-            single.dt, single.event_type = single.determine_next_event() 
-            single.last_time = self.t
-            self.add_domain_event(single)
-            return
+	else:
+	### 1. Process event produced by the single
+
+	    ### 1.1 Special cases (shortcuts)
+            # In case nothing is scheduled to happen: do nothing and just reschedule
+            if single.dt == numpy.inf:
+        	self.add_domain_event(single)
+                return 
+
+            # check that the event time of the single (last_time + dt) is equal to the
+	    # simulator time
+            assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
+
+            # Handle immobile case (what event has taken place to get here?!).
+            if single.getD() == 0:
+		# The domain has not produced an decay reaction event and is immobile
+		# ->no propagation, no other changes just calculate next reaction time
+	        # and reschedule the single. So this also takes care of the domain making part
+                single.dt, single.event_type = single.determine_next_event() 
+                single.last_time = self.t
+                self.add_domain_event(single)
+                return
 
 
-        # If the single had a decay reaction.
-        if single.event_type == EventType.SINGLE_REACTION:
-            if __debug__:
-                log.info('%s' % single.event_type)
-                log.info('reactant = %s' % single)
+            # If the single had a decay reaction.
+            if single.event_type == EventType.SINGLE_REACTION:
+                if __debug__:
+                    log.info('%s' % single.event_type)
+                    log.info('reactant = %s' % single)
 
-            self.single_steps[single.event_type] += 1
+                self.single_steps[single.event_type] += 1
 
 
-            single = self.propagate_single(single)
+                single = self.propagate_single(single)
 
-            try:
-                self.remove_domain(single)
-                self.fire_single_reaction(single)
-            except NoSpace:
-                self.reject_single_reaction(single)
+                try:
+                    self.remove_domain(single)
+                    self.fire_single_reaction(single)
+                except NoSpace:
+                    self.reject_single_reaction(single)
 
-            return
+                return
 
-	### 1.2 General case
-	# There is a non-trivial event time for the domain
-        if single.dt != 0.0:
-            # Propagate this particle to the exit point on the shell.
-            single = self.propagate_single(single)
+	    ### 1.2 General case
+	    # There is a non-trivial event time for the domain
+            if single.dt != 0.0:
+                # Propagate this particle to the exit point on the shell.
+                single = self.propagate_single(single)
 
 
-        # An interaction event is similar to a single reaction.
-        if single.event_type == EventType.IV_INTERACTION:
-            try:
-                self.remove_domain(single)
-                self.fire_single_reaction(single, interaction_flag=True)
-            except NoSpace:
-                self.reject_single_reaction(single)
+            # An interaction event is similar to a single reaction.
+            if single.event_type == EventType.IV_INTERACTION:
+                try:
+                    self.remove_domain(single)
+                    self.fire_single_reaction(single, interaction_flag=True)
+                except NoSpace:
+                    self.reject_single_reaction(single)
 
-            return
+                return
 
-	self.make_new_domain(single)
 	return
 
 

From b08a356ca1c54b163e6019180d0f85a5f4bec718 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 29 Sep 2011 09:47:29 +0200
Subject: [PATCH 0229/1541] Continued working on the newBD scheme.

---
 BDSimulator.hpp     | 12 ++++--
 gfrdbase.py         |  2 +
 newBDPropagator.hpp | 93 +++++++++++++++++++++++++++------------------
 3 files changed, 66 insertions(+), 41 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 61718d65..5eb80f9f 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -43,7 +43,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
 
     BDSimulator(boost::shared_ptr<world_type> world, 
                 boost::shared_ptr<network_rules_type const> network_rules,
-                rng_type& rng, Real dt_factor = 1.,
+                rng_type& rng, Real dt_factor = 1.0E-5,
                 int dissociation_retry_moves = 1)
         : base_type(world, network_rules, rng),
           dt_factor_(dt_factor), num_retries_(dissociation_retry_moves)
@@ -92,14 +92,20 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         }
         return gsl_pow_2(radius_min * 2) / (D_max * 2);
     }
+    
+    static Real determine_reaction_length(world_type const& world, time_type dt)
+    {
+        //TODO
+        return sqrt( 2 * 1E-12 * dt );
+    }
 
 protected:
     void _step(time_type dt)
     {
         {
             newBDPropagator<traits_type> propagator(
-                base_type::world_,
-                base_type::network_rules_,
+                *base_type::world_,
+                *base_type::network_rules_,
                 base_type::rng_,
                 dt, num_retries_,
                 base_type::rrec_.get(), 0,
diff --git a/gfrdbase.py b/gfrdbase.py
index b0c3fa4d..454cff4d 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -28,6 +28,8 @@
     'create_world',
     'ParticleSimulatorBase',
     'get_closest_surface',
+    'create_network_rules_wrapper',
+    'place_particle'
     ]
 
 World = _gfrd.World
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 05febf72..8c434000 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -20,6 +20,8 @@
 #include "utils/get_default_impl.hpp"
 #include "Logger.hpp"
 
+#include <iostream>
+
 template<typename Ttraits_>
 class newBDPropagator
 {
@@ -57,7 +59,7 @@ class newBDPropagator
         Trange_ const& particles)
         : tx_(tx), rules_(rules), rng_(rng), dt_(dt),
           max_retry_count_(max_retry_count), rrec_(rrec), vc_(vc),
-          queue_(), rejected_move_count_(0), reaction_length_( sqrt( 4 * 1E-12 * dt ) )
+          queue_(), rejected_move_count_(0), reaction_length_( sqrt( 4000 * 1E-12 * dt ) )
     {
         call_with_size_if_randomly_accessible(
             boost::bind(&particle_id_vector_type::reserve, &queue_, _1),
@@ -102,74 +104,89 @@ class newBDPropagator
         position_type const displacement( tx_.get_structure(species.structure_id())->
                                             bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
 
-        position_type const new_pos(
-            tx_.apply_boundary(
-                add(pp.second.position(), displacement)));
+        position_type const new_pos(tx_.apply_boundary( add( pp.second.position(), displacement ) ));
 
 	    /*Use a spherical shape with radius = particle_radius + reaction_length.
 	      We use it to check for overlaps with other particels (and surfaces).*/
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
             tx_.check_overlap(particle_shape_type( new_pos, species.radius() + reaction_length_ ), pp.first));
+                     
         switch (overlapped ? overlapped->size(): 0)
         {
         case 0:
-            {
-                particle_id_pair particle_to_update( pp.first, 
-                        particle_type(species.id(), particle_shape_type(new_pos, species.radius()), species.D()) );    
+            break;
 
-                if (vc_)
+        case 1:
+        {
+            particle_id_pair_and_distance const& closest(overlapped->at(0));
+            length_type r01( pp.second.radius() + closest.first.second.radius() );
+            
+            /* If the particle cores overlapped, the move is rejected but the particles can still react. */
+		    if( closest.second < pp.second.radius() )
+            {
+                LOG_DEBUG(("Hard core collision with a particle %s. Particle bounced", boost::lexical_cast<std::string>(closest.first.first).c_str()));
+		        ++rejected_move_count_;
+
+                /* If the particle was outside the reaction volume before the move, nothing is to be done for this particle => return*/
+                if(tx_.distance( pp.second.position(), closest.first.second.position() ) > r01 + reaction_length_ )
+    		        return true;
+    		        
+    		    try
                 {
-                    if (!(*vc_)(particle_to_update.second.shape(), 
-                            particle_to_update.first))
+                    if (!attempt_reaction(pp, closest.first))
                     {
-                        log_.info("propagation move rejected.");
-                        return true;
+                        LOG_DEBUG(("Bounced particle attempted a reaction with a nonreactive particle %s.", boost::lexical_cast<std::string>(closest.first.first).c_str()));
+                        ++rejected_move_count_;
                     }
                 }
-
-                tx_.update_particle(particle_to_update);
+                catch (propagation_error const& reason)
+                {
+                    log_.info("second-order reaction rejected (reason: %s)", reason.what());
+                    ++rejected_move_count_;
+                }
+                /* reject the move even if the reaction has not occurred */    
                 return true;
             }
-
-        case 1:
+            else
             {
-                particle_id_pair_and_distance const& closest(overlapped->at(0));
-                length_type r01( pp.second.radius() + closest.first.second.radius() );
-
-                /* Check if we generated an overlap of the particle cores. If so, new_pos -> pp.pos */
-		        if( closest.second < r01)
+                
+                try
                 {
-                    LOG_DEBUG(("Hard core collision with a particle %s. particle bounced", boost::lexical_cast<std::string>(closest.first.first).c_str()));
-		            ++rejected_move_count_;
-
-                    /* If the particle was outside the reation volume before the try move, nothing is to be done and we exit the propagator.*/
-                    if(tx_.distance( pp.second.position(), closest.first.second.position() ) > r01 + reaction_length_ )
-    		            return true;
+                    if( attempt_reaction(pp, closest.first) )
+                        return true;
 
-		        }
+                    LOG_DEBUG(("Non-bounced particle attempted a reaction with a nonreactive particle %s.", boost::lexical_cast<std::string>(closest.first.first).c_str()));
 
-                try
-                {
-                    if (!attempt_reaction(pp, closest.first))
-                    {
-                        LOG_DEBUG(("Reaction attempt with a nonreactive particle %s.", boost::lexical_cast<std::string>(closest.first.first).c_str()));
-                        ++rejected_move_count_;
-                    }
                 }
                 catch (propagation_error const& reason)
                 {
                     log_.info("second-order reaction rejected (reason: %s)", reason.what());
                     ++rejected_move_count_;
-                }
+                }                    
             }
-            /* reject the move even if the reaction has not occurred */
-            return true;
+            break;              
+        }
 
         default:
             log_.info("collision involving two or more particles; move rejected");
             ++rejected_move_count_;
             return true;
         }
+        
+        particle_id_pair particle_to_update( pp.first, 
+                    particle_type(species.id(), particle_shape_type(new_pos, species.radius()), species.D()) );
+                
+        if (vc_)
+        {
+            if (!(*vc_)(particle_to_update.second.shape(), particle_to_update.first))
+            {
+                log_.info("propagation move rejected.");
+                return true;
+            }
+        }
+                
+        tx_.update_particle(particle_to_update);
+        return true;
     }
 
     std::size_t get_rejected_move_count() const

From 4bc3d4edb24712c58b5da5394c665a60fbb2159f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Sep 2011 12:08:04 +0200
Subject: [PATCH 0230/1541] adding comments to fire_single_reaction clearing up
 purpose/functioning Also removed putative function to process identity change
 associated with an Interaction -> not supposed to be here.

---
 egfrd.py | 55 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 34 insertions(+), 21 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 485ae7ab..f21a2f16 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -639,52 +639,59 @@ def burst_non_multis(self, domains):
 
         return bursted
 
-    def fire_single_reaction(self, single, interaction_flag=False):
+    def fire_single_reaction(self, single):
 	# This takes care of the identity change when a single particle decays into
 	# one or a number of other particles
 	# TODO This can also be used when a particle falls off a surface.
 
-	# THis is supposed to take care of the movement and identity change that
-	# happens when an Interaction event has occurred
-        if interaction_flag == True:
-            raise NotImplementedError
-	
-
 
-        reactant_species_radius = single.pid_particle_pair[1].radius
+	# 0. get reactant info
         oldpos = single.pid_particle_pair[1].position
+        reactant_species_radius = single.pid_particle_pair[1].radius
         current_structure = single.structure
-        
         rt = single.reactionrule
 
         if len(rt.products) == 0:
             
+	    # 1. No products, no info
+	    # 2. No space required
+	    # 3. No space required
+	    # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(single.pid_particle_pair[0])
 
+	    # 5. No new single to be made
+	    # 6. Log the change
             self.last_reaction = (rt, (single.pid_particle_pair[1], None), [])
 
             
         elif len(rt.products) == 1:
 	# TODO product particle can live on different structure
             
+	    # 1. get product info
             product_species = self.world.get_species(rt.products[0])
 
+            # 2. make space for the products.
             if reactant_species_radius < product_species.radius:
                 self.burst_volume(oldpos, product_species.radius)
 
+	    # 3. check that there is space for the products 
             if self.world.check_overlap((oldpos, product_species.radius),
                                         single.pid_particle_pair[0]):
                 if __debug__:
                     log.info('no space for product particle.')
                 raise NoSpace()
 
+	    # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(single.pid_particle_pair[0])
             newparticle = self.world.new_particle(product_species.id, oldpos)
+
+	    # 5. make new single and schedule
             newsingle = self.create_single(newparticle)
-            if __debug__:
-                log.info('product = %s' % newsingle)
             self.add_domain_event(newsingle)
 
+	    # 6. Log the change
+            if __debug__:
+                log.info('product = %s' % newsingle)
             self.last_reaction = (rt, (single.pid_particle_pair[1], None),
                                   [newparticle])
 
@@ -692,6 +699,8 @@ def fire_single_reaction(self, single, interaction_flag=False):
             
         elif len(rt.products) == 2:
 	# TODO (one of the) product particles can live on different structure
+
+	    # 1. get product info
             product_species1 = self.world.get_species(rt.products[0])
             product_species2 = self.world.get_species(rt.products[1])
             
@@ -703,12 +712,13 @@ def fire_single_reaction(self, single, interaction_flag=False):
             particle_radius2 = product_species2.radius
             particle_radius12 = particle_radius1 + particle_radius2
 
-            # clean up space.
+            # 2. make space for the products.
             rad = max(particle_radius12 * (D1 / D12) + particle_radius1,
                       particle_radius12 * (D2 / D12) + particle_radius2)
 
             self.burst_volume(oldpos, rad)
 
+	    # 3. check that there is space for the products (try different positions if possible)
             for _ in range(self.dissociation_retry_moves):
                 vector = _random_vector(current_structure, particle_radius12 *
                                         MINIMAL_SEPARATION_FACTOR, self.rng)
@@ -742,22 +752,24 @@ def fire_single_reaction(self, single, interaction_flag=False):
                     log.info('no space for product particles.')
                 raise NoSpace()
 
+	    # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(single.pid_particle_pair[0])
+            pid_particle_pair1 = self.world.new_particle(product_species1.id, newpos1)
+            pid_particle_pair2 = self.world.new_particle(product_species2.id, newpos2)
 
-            particle1 = self.world.new_particle(product_species1.id, newpos1)
-            particle2 = self.world.new_particle(product_species2.id, newpos2)
-            newsingle1 = self.create_single(particle1)
-            newsingle2 = self.create_single(particle2)
-
-            if __debug__:
-                log.info('product1 = %s\nproduct2 = %s' % 
-                     (newsingle1, newsingle2))
 
+	    # 5. make new singles and schedule
+            newsingle1 = self.create_single(pid_particle_pair1)
+            newsingle2 = self.create_single(pid_particle_pair2)
             self.add_domain_event(newsingle1)
             self.add_domain_event(newsingle2)
 
+	    # 6. Log the change
+            if __debug__:
+                log.info('product1 = %s\nproduct2 = %s' % 
+                     (newsingle1, newsingle2))
             self.last_reaction = (rt, (single.pid_particle_pair[1], None),
-                                  [particle1, particle2])
+                                  [pid_particle_pair1, pid_particle_pair2])
 
 
         else:
@@ -861,6 +873,7 @@ def proc_event_by_single(self, single):
                 return
 
 
+
             # If the single had a decay reaction.
             if single.event_type == EventType.SINGLE_REACTION:
                 if __debug__:

From 9bb0b3cc819f631196b18ff39dca5626032ee813 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Sep 2011 12:10:06 +0200
Subject: [PATCH 0231/1541] draw_new_position now returns position in membrane
 when interaction takes place Not next to membrane

---
 single.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/single.py b/single.py
index 4483be07..c7d10f3a 100644
--- a/single.py
+++ b/single.py
@@ -598,12 +598,13 @@ def draw_new_position(self, dt, event_type):
 
 
 	    if event_type == EventType.IV_INTERACTION:
-		z = z_surface
+		# also move the particle into the surface
+		z = z_surface - self.pid_particle_pair[1].radius
 	    elif event_type == EventType.IV_ESCAPE:
 		z = z_not_surface
 	    else:
 	        gf_iv = self.iv_greens_function()
-        	z = draw_r_wrapper(gf_iv, dt, z_not_surface, z_surface)
+        	z = draw_r_wrapper(gf_iv, dt, z_not_surface, z_surface)	# last two args= a, sigma
 
 	    vector_z = z * self.shell.shape.unit_z
 
@@ -612,6 +613,7 @@ def draw_new_position(self, dt, event_type):
 
         return newpos
 
+
     def get_shell_size(self):
 	# REMOVE this method, it doesn't mean anything here.
 	# THis method is only used for making an Interaction

From 40d3bc61c1d9110b5237fd96ec531c90e96bf072 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Sep 2011 16:58:34 +0200
Subject: [PATCH 0232/1541] restructuring reaction handling in fire_pair

---
 egfrd.py | 119 +++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 76 insertions(+), 43 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f21a2f16..0416fd0a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -646,12 +646,16 @@ def fire_single_reaction(self, single):
 
 
 	# 0. get reactant info
-        oldpos = single.pid_particle_pair[1].position
+        oldpos        = single.pid_particle_pair[1].position
+	oldspecies_id = single.pid_particle_pair[1].sid
         reactant_species_radius = single.pid_particle_pair[1].radius
         current_structure = single.structure
-        rt = single.reactionrule
+        rr = single.reactionrule
 
-        if len(rt.products) == 0:
+	# 1. remove the particle
+#        self.world.remove_particle(single.pid_particle_pair[0])
+
+        if len(rr.products) == 0:
             
 	    # 1. No products, no info
 	    # 2. No space required
@@ -661,14 +665,14 @@ def fire_single_reaction(self, single):
 
 	    # 5. No new single to be made
 	    # 6. Log the change
-            self.last_reaction = (rt, (single.pid_particle_pair[1], None), [])
+            self.last_reaction = (rr, (single.pid_particle_pair[1], None), [])
 
             
-        elif len(rt.products) == 1:
+        elif len(rr.products) == 1:
 	# TODO product particle can live on different structure
             
 	    # 1. get product info
-            product_species = self.world.get_species(rt.products[0])
+            product_species = self.world.get_species(rr.products[0])
 
             # 2. make space for the products.
             if reactant_species_radius < product_species.radius:
@@ -692,17 +696,17 @@ def fire_single_reaction(self, single):
 	    # 6. Log the change
             if __debug__:
                 log.info('product = %s' % newsingle)
-            self.last_reaction = (rt, (single.pid_particle_pair[1], None),
+            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
                                   [newparticle])
 
 
             
-        elif len(rt.products) == 2:
+        elif len(rr.products) == 2:
 	# TODO (one of the) product particles can live on different structure
 
 	    # 1. get product info
-            product_species1 = self.world.get_species(rt.products[0])
-            product_species2 = self.world.get_species(rt.products[1])
+            product_species1 = self.world.get_species(rr.products[0])
+            product_species2 = self.world.get_species(rr.products[1])
             
             D1 = product_species1.D
             D2 = product_species2.D
@@ -768,7 +772,7 @@ def fire_single_reaction(self, single):
             if __debug__:
                 log.info('product1 = %s\nproduct2 = %s' % 
                      (newsingle1, newsingle2))
-            self.last_reaction = (rt, (single.pid_particle_pair[1], None),
+            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
                                   [pid_particle_pair1, pid_particle_pair2])
 
 
@@ -1169,10 +1173,10 @@ def proc_event_by_pair(self, pair):
 
         single1 = pair.single1
         single2 = pair.single2
-        particle1 = single1.pid_particle_pair
-        particle2 = single2.pid_particle_pair
-        pos1 = particle1[1].position
-        pos2 = particle2[1].position
+        pid_particle_pair1 = single1.pid_particle_pair
+        pid_particle_pair2 = single2.pid_particle_pair
+        pos1 = pid_particle_pair1[1].position
+        pos2 = pid_particle_pair2[1].position
         
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
@@ -1223,47 +1227,71 @@ def proc_event_by_pair(self, pair):
         # 2. Pair reaction
         #
         elif pair.event_type == EventType.IV_REACTION:
-            self.world.remove_particle(single1.pid_particle_pair[0])
-            self.world.remove_particle(single2.pid_particle_pair[0])
 
+            # calculate new position
+            new_com = pair.draw_new_com(pair.dt, pair.event_type)
+            new_com = self.world.apply_boundary(new_com)
+
+	    # 0. get reactant info
 	    rr = pair.draw_reaction_rule(pair.interparticle_rrs)
+	    reactant1_species_id = pid_particle_pair1[1].sid
+	    reactant2_species_id = pid_particle_pair2[1].sid
+
+	    # 1. remove the particles
 
             if len(rr.products) == 0:
-		# no product particles, nothing new to be made
-                product = []
+
+		# 1. no product particles, no info
+		# 2. No space required
+		# 3. No space required
+		# 4. process the change (remove particles, make new ones)
+                self.world.remove_particle(pid_particle_pair1[0])
+                self.world.remove_particle(pid_particle_pair2[0])
+		products = []
+
+		# 5. No new single to be made
+		# 6. Log the change
+                self.last_reaction = (rr, (pid_particle_pair1[1], pid_particle_pair2[1]), products)
 
 	    elif len(rr.products) == 1:
-                species3 = self.world.get_species(rr.products[0])
-                # calculate new position
-		# TODO make this just one of the positions of the particles (they are on top of eachother)
-                event_type = pair.event_type
-                new_com = pair.draw_new_com(pair.dt, event_type)
-                new_com = self.world.apply_boundary(new_com)
-
-		# not sure what this check does 
-                if __debug__:
-                    shell_size = pair.get_shell_size()
-                    assert self.world.distance(old_com, new_com) < \
-                           shell_size - species3.radius
 
+		# 1. get product info
+                product_species = self.world.get_species(rr.products[0])
 
-		# make product particle
-                particle = self.world.new_particle(species3.id, new_com)
+		# 1.5 no change in position due to reaction
+		# position = new_com
 
-		# create a new domain for the new particle
-                product = self.create_single(particle)
-		# schedule domain
-                self.add_domain_event(product)
+		# 2. make space for products
+		# if the product particle sticks out of the shell
+		if self.world.distance(old_com, new_com) > (pair.get_shell_size() - product_species.radius):
+		    self.burst_volume(new_com, product_species.radius)
 
-		# update counters
-                self.reaction_events += 1
-                self.last_reaction = (rr, (particle1, particle2),
-                                      [particle])
+		    # 3. check that there is space for the products
+		    if self.world.check_overlap((new_com, product_species.radius), ):
+			if __debug__:
+	                    log.info('no space for product particle.')
+        	        raise NoSpace()
+
+		# 4. process the changes (remove particle, make new ones)
+                self.world.remove_particle(pid_particle_pair[0])
+                self.world.remove_particle(pid_particle_pair[0])
+                particle = self.world.new_particle(product_species.id, new_com)
+		products = [particle, ]
+
+		# 5. make a new single and schedule
+                single = self.create_single(particle)
+                self.add_domain_event(single)
+
+		# 6. Log the change
+            	if __debug__:
+                    log.info('product = %s' % single)
+                self.last_reaction = (rr, (pid_particle_pair1, pid_particle_pair2),
+                                      products)
             else:
                 raise NotImplementedError('num products >= 2 not supported.')
 
-            if __debug__:
-                log.info('product = %s' % product)
+	    # 7. update counter
+            self.reaction_events += 1
             self.remove_domain(pair)
 
         #
@@ -1272,9 +1300,14 @@ def proc_event_by_pair(self, pair):
         #
         elif(pair.event_type == EventType.IV_ESCAPE or
              pair.event_type == EventType.COM_ESCAPE):
+
+	    # get new positions for particles, move them and make singles
             single1, single2 = self.propagate_pair(pair)
+
+	    # reschedule single domains
             self.add_domain_event(single1)
             self.add_domain_event(single2)
+
         else:
             raise SystemError('Bug: invalid event_type.')
 

From c62f34ae04c2ffd660ba904e6c955660bbc8410d Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 29 Sep 2011 17:54:00 +0200
Subject: [PATCH 0233/1541] Included a reaction_length get and set in
 BDSimulator

---
 BDSimulator.hpp             | 33 ++++++++++++++++++++++++---------
 binding/BDSimulator.hpp     |  2 ++
 binding/newBDPropagator.hpp |  5 +++--
 newBDPropagator.hpp         | 12 ++++++------
 4 files changed, 35 insertions(+), 17 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 5eb80f9f..59554843 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -25,13 +25,13 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     typedef typename world_type::traits_type::rng_type rng_type;
     typedef typename world_type::species_id_type species_id_type;
     typedef typename world_type::species_type species_type;
-    typedef typename traits_type::time_type time_type;
+    typedef typename world_type::length_type length_type;
+    typedef typename traits_type::time_type time_type;  
     typedef typename traits_type::network_rules_type network_rules_type;
     typedef typename traits_type::reaction_rule_type reaction_rule_type;
     typedef typename traits_type::rate_type rate_type;
     typedef typename traits_type::reaction_record_type reaction_record_type;
-    typedef typename traits_type::reaction_recorder_type 
-    reaction_recorder_type;
+    typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
 
 public:
     Real const& dt_factor()
@@ -43,12 +43,14 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
 
     BDSimulator(boost::shared_ptr<world_type> world, 
                 boost::shared_ptr<network_rules_type const> network_rules,
-                rng_type& rng, Real dt_factor = 1.0E-5,
-                int dissociation_retry_moves = 1)
+                rng_type& rng, Real dt_factor = traits_type::DEFAULT_DT_FACTOR,
+                int dissociation_retry_moves = 1, length_type reaction_length_factor = 1)
         : base_type(world, network_rules, rng),
-          dt_factor_(dt_factor), num_retries_(dissociation_retry_moves)
+          dt_factor_(dt_factor), num_retries_(dissociation_retry_moves), 
+          reaction_length_factor_(reaction_length_factor)
     {
         calculate_dt();
+        reaction_length_ = determine_reaction_length( *world, base_type::dt_, reaction_length_factor_ );
     }
 
     virtual void calculate_dt()
@@ -93,10 +95,21 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return gsl_pow_2(radius_min * 2) / (D_max * 2);
     }
     
-    static Real determine_reaction_length(world_type const& world, time_type dt)
+    static length_type determine_reaction_length(world_type const& world, time_type dt, length_type const& reaction_length_factor)
     {
         //TODO
-        return sqrt( 2 * 1E-12 * dt );
+        return reaction_length_factor * sqrt( 2 * 1E-12 * dt );
+    }
+    
+    Real get_reaction_length() const
+    {
+        return reaction_length_;    
+    }
+    
+    void set_reaction_length_factor(length_type new_reaction_length_factor)
+    {
+        reaction_length_factor_ = new_reaction_length_factor;
+        reaction_length_ = determine_reaction_length( *base_type::world_, base_type::dt_, reaction_length_factor_ );        
     }
 
 protected:
@@ -107,7 +120,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
                 *base_type::world_,
                 *base_type::network_rules_,
                 base_type::rng_,
-                dt, num_retries_,
+                dt, num_retries_, reaction_length_,
                 base_type::rrec_.get(), 0,
                 make_select_first_range(base_type::world_->
                                         get_particles_range()));
@@ -122,6 +135,8 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
 private:
     Real const dt_factor_;
     int const num_retries_;
+    length_type reaction_length_factor_;
+    length_type reaction_length_;
     static Logger& log_;
 };
 
diff --git a/binding/BDSimulator.hpp b/binding/BDSimulator.hpp
index edf654e0..10561d83 100644
--- a/binding/BDSimulator.hpp
+++ b/binding/BDSimulator.hpp
@@ -27,6 +27,8 @@ void register_bd_simulator_class(char const* name)
         .def(init<boost::shared_ptr<typename impl_type::world_type>,
                  boost::shared_ptr<typename impl_type::network_rules_type const>,
                  typename impl_type::rng_type&, double, int>())
+        .def("get_reaction_length", &impl_type::get_reaction_length)
+        .def("set_reaction_length_factor",&impl_type::set_reaction_length_factor)
 //        .def("check", &impl_type::check)
 //        .def("__len__", &impl_type::num_domains)
 //        .def("__getitem__", &impl_type::get_domain)
diff --git a/binding/newBDPropagator.hpp b/binding/newBDPropagator.hpp
index cb2965db..d06d19ef 100644
--- a/binding/newBDPropagator.hpp
+++ b/binding/newBDPropagator.hpp
@@ -23,6 +23,7 @@ inline boost::python::objects::class_base register_new_bd_propagator_class(char
     typedef typename impl_type::traits_type simulator_traits_type;
     typedef typename simulator_traits_type::world_type world_type;
     typedef typename world_type::particle_id_type particle_id_type;
+    typedef typename world_type::traits_type::length_type length_type;
     typedef typename simulator_traits_type::network_rules_type network_rules_type;
     typedef typename world_type::traits_type::rng_type rng_type;
     typedef typename simulator_traits_type::time_type time_type;
@@ -34,11 +35,11 @@ inline boost::python::objects::class_base register_new_bd_propagator_class(char
     return class_<impl_type, boost::noncopyable>(
         name, init<
             particle_container_type&, network_rules_type const&, rng_type&,
-            time_type, int, reaction_recorder_type*, volume_clearer_type*,
+            time_type, int, length_type, reaction_recorder_type*, volume_clearer_type*,
             peer::wrappers::pyiterable_range<particle_id_type> >())
         .def(init<
             particle_container_type&, network_rules_type const&, rng_type&,
-            time_type, int, reaction_recorder_type*, volume_clearer_type*,
+            time_type, int, length_type, reaction_recorder_type*, volume_clearer_type*,
             typename get_select_first_range<typename world_type::particle_id_pair_range>::type>())
         .add_property("rejected_move_count",
             &impl_type::get_rejected_move_count)
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 8c434000..b8b6fd7a 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -54,19 +54,19 @@ class newBDPropagator
     template<typename Trange_>
     newBDPropagator(
         particle_container_type& tx, network_rules_type const& rules,
-        rng_type& rng, time_type dt, int max_retry_count,
+        rng_type& rng, time_type dt, int max_retry_count, length_type reaction_length,
         reaction_recorder_type* rrec, volume_clearer_type* vc,
-        Trange_ const& particles)
+        Trange_ const& particle_ids)
         : tx_(tx), rules_(rules), rng_(rng), dt_(dt),
           max_retry_count_(max_retry_count), rrec_(rrec), vc_(vc),
-          queue_(), rejected_move_count_(0), reaction_length_( sqrt( 4000 * 1E-12 * dt ) )
+          queue_(), rejected_move_count_(0), reaction_length_( reaction_length )
     {
         call_with_size_if_randomly_accessible(
             boost::bind(&particle_id_vector_type::reserve, &queue_, _1),
-            particles);
+            particle_ids);
         for (typename boost::range_const_iterator<Trange_>::type
-                i(boost::begin(particles)),
-                e(boost::end(particles)); i != e; ++i)
+                i(boost::begin(particle_ids)),
+                e(boost::end(particle_ids)); i != e; ++i)
         {
             queue_.push_back(*i);
         }

From 7b4016f74a00b304f7b063aaee1a5622297986ec Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Sep 2011 18:00:11 +0200
Subject: [PATCH 0234/1541] some rename/reshuffeling of propagate_pair

---
 egfrd.py | 100 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 60 insertions(+), 40 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0416fd0a..d434253b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1173,8 +1173,8 @@ def proc_event_by_pair(self, pair):
 
         single1 = pair.single1
         single2 = pair.single2
-        pid_particle_pair1 = single1.pid_particle_pair
-        pid_particle_pair2 = single2.pid_particle_pair
+        pid_particle_pair1 = pair.pid_particle_pair
+        pid_particle_pair2 = pair.pid_particle_pair
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
         
@@ -1261,19 +1261,21 @@ def proc_event_by_pair(self, pair):
 		# 1.5 no change in position due to reaction
 		# position = new_com
 
-		# 2. make space for products
-		# if the product particle sticks out of the shell
+		# 2.  make space for products
+		# 2.1 if the product particle sticks out of the shell
 		if self.world.distance(old_com, new_com) > (pair.get_shell_size() - product_species.radius):
 		    self.burst_volume(new_com, product_species.radius)
 
-		    # 3. check that there is space for the products
-		    if self.world.check_overlap((new_com, product_species.radius), ):
+		    # 3. check that there is space for the products ignoring the reactants
+		    if self.world.check_overlap((new_com, product_species.radius),
+						pid_particle_pair1[0],
+						pid_particle_pair2[0]):
 			if __debug__:
 	                    log.info('no space for product particle.')
         	        raise NoSpace()
 
 		# 4. process the changes (remove particle, make new ones)
-                self.world.remove_particle(pid_particle_pair[0])
+	        self.world.remove_particle(pid_particle_pair[0])
                 self.world.remove_particle(pid_particle_pair[0])
                 particle = self.world.new_particle(product_species.id, new_com)
 		products = [particle, ]
@@ -1410,60 +1412,67 @@ def burst_pair(self, pair):
         return single1, single2
 
     def propagate_pair(self, pair):
-        single1 = pair.single1
-        single2 = pair.single2
+	# takes a pair and returns two singles after propagation
 
-        particle1 = single1.pid_particle_pair
-        particle2 = single2.pid_particle_pair
+        pid_particle_pair1 = pair.pid_particle_pair
+        pid_particle_pair2 = pair.pid_particle_pair
 
-        pos1 = particle1[1].position
-        pos2 = particle2[1].position
+        pos1 = pid_particle_pair1[1].position
+        pos2 = pid_particle_pair2[1].position
 
+	# if time has passed (should be always)
         if pair.dt > 0.0:
-            D1 = particle1[1].D
-            D2 = particle2[1].D
+#            D1 = pid_particle_pair1[1].D
+#            D2 = pid_particle_pair2[1].D
 
+	    # store for later check
+            old_com = pair.com
+
+
+	    # TODO this should be done when the pair is made -> passed to the constructor
             pos2t = self.world.cyclic_transpose(pos2, pos1)
             old_inter_particle = pos2t - pos1
             r0 = self.world.distance(pos1, pos2)
             assert feq(r0, length(old_inter_particle))
 
-            old_com = pair.com
-
+	    # draw the new positions of the particles
             newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
                                                        pair.event_type)
-
             newpos1 = self.world.apply_boundary(newpos1)
             newpos2 = self.world.apply_boundary(newpos2)
-            assert not self.world.check_overlap((newpos1, particle1[1].radius),
-                                                particle1[0], particle2[0])
-            assert not self.world.check_overlap((newpos2, particle2[1].radius),
-                                                particle1[0], particle2[0])
+
+	    # check that the particle do not overlap with any other particles in the world
+            assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
+                                                pid_particle_pair1[0], pid_particle_pair2[0])
+            assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
+                                                pid_particle_pair1[0], pid_particle_pair2[0])
+
+	    # some more consistency checking of the positions
             assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
                                        pair.get_shell_size())
+
         else:
 	# no time has passed
-            newpos1 = particle1[1].position
-            newpos2 = particle2[1].position
+            newpos1 = pid_particle_pair1[1].position
+            newpos2 = pid_particle_pair2[1].position
 
-        if __debug__:
-            log.debug("proc_event_by_pair: #1 { %s: %s => %s }" %
-                      (single1, pos1, newpos1))
-            log.debug("proc_event_by_pair: #2 { %s: %s => %s }" %
-                      (single2, str(pos2), str(newpos2)))
+
+	# re-use single domains for particles
+        single1 = pair.single1
+        single2 = pair.single2
+
+        assert single1.domain_id not in self.domains
+        assert single2.domain_id not in self.domains
 
         single1.initialize(self.t)
         single2.initialize(self.t)
         
-        self.remove_domain(pair)
-        assert single1.domain_id not in self.domains
-        assert single2.domain_id not in self.domains
         self.domains[single1.domain_id] = single1
         self.domains[single2.domain_id] = single2
-        self.move_single(single1, newpos1, particle1[1].radius)
-        self.move_single(single2, newpos2, particle2[1].radius)
+        self.move_single(single1, newpos1, pid_particle_pair1[1].radius)
+        self.move_single(single2, newpos2, pid_particle_pair2[1].radius)
 
-	# TODO This is not very clear or clean now. Also doesn't support MixedPair
+	# Thoroughly check the sizes of the shells of the singles
         if __debug__:
             container = self.geometrycontainer.get_container(single1.shell)
             assert container[single1.shell_id].shape.radius == \
@@ -1477,11 +1486,22 @@ def propagate_pair(self, pair):
                 assert container[single2.shell_id].shape.half_length == \
                        single2.shell.shape.half_length
 
-        assert single1.shell.shape.radius == particle1[1].radius
-        assert single2.shell.shape.radius == particle2[1].radius
-
+        assert single1.shell.shape.radius == pid_particle_pair1[1].radius
+        assert single2.shell.shape.radius == pid_particle_pair2[1].radius
+	# even more checking
         assert self.check_obj(single1)
         assert self.check_obj(single2)
+	# Now finally we are convinced that the singles were actually made correctly
+
+	# Log the event
+        if __debug__:
+            log.debug("proc_event_by_pair: #1 { %s: %s => %s }" %
+                      (single1, str(pos1), str(newpos1)))
+            log.debug("proc_event_by_pair: #2 { %s: %s => %s }" %
+                      (single2, str(pos2), str(newpos2)))
+
+	# remove the old domain
+        self.remove_domain(pair)
 
         return single1, single2
 
@@ -2090,8 +2110,8 @@ def check_domains(self):
                                'Event Scheduler: %s' % str(tuple(event_ids)))
 
     def check_pair_pos(self, pair, pos1, pos2, com, radius):
-        particle1 = pair.single1.pid_particle_pair[1]
-        particle2 = pair.single2.pid_particle_pair[1]
+        particle1 = pair.pid_particle_pair[1]
+        particle2 = pair.pid_particle_pair[1]
 
         old_com = com
         

From 71539d3cb652fcc48c2867a3d381fb3ebf69aa0d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Sep 2011 18:12:27 +0200
Subject: [PATCH 0235/1541] Now burst_single and burst_pair are the same in
 structure Removed the reuse of an Event in the schedules. THis is slightly
 inefficient but really cleans up the code. Later find a way to optimize this

---
 egfrd.py | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d434253b..408d48ca 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1367,23 +1367,26 @@ def burst_single(self, single):
         # Override event_type. 
         single.dt = self.t - single.last_time
         single.event_type = EventType.BURST
+	self.remove_event(single)
 
-        newsingle = self.propagate_single(single)
+        newsingle = self.propagate_single(single)	# TODO this can now also just be a proc_event_by_single
+	self.add_domain_event(newsingle)
 
-        newpos = newsingle.pid_particle_pair[1].position
-        # TODO? Check if stays within domain ~MW
-
-        if isinstance(single, InteractionSingle):
-            # When bursting an InteractionSingle, the domain changes from Interaction
-	    # NonInteraction domain. This needs to be reflected in the event 
-            self.remove_event(single)
-            self.add_domain_event(newsingle)
-        else:
-            assert single == newsingle
-            self.update_domain_event(self.t, single)
-
-        particle_radius = single.pid_particle_pair[1].radius
-        assert newsingle.shell.shape.radius == particle_radius
+# NOTE Be inefficient for just now and don't reuse the event in the schedules
+#        newpos = newsingle.pid_particle_pair[1].position
+#        # TODO? Check if stays within domain ~MW
+#
+#        if isinstance(single, InteractionSingle):
+#            # When bursting an InteractionSingle, the domain changes from Interaction
+#	    # NonInteraction domain. This needs to be reflected in the event 
+#            self.remove_event(single)
+#            self.add_domain_event(newsingle)
+#        else:
+#            assert single == newsingle
+#            self.update_domain_event(self.t, single)
+#
+#        particle_radius = single.pid_particle_pair[1].radius
+#        assert newsingle.shell.shape.radius == particle_radius
 
         return newsingle
 
@@ -1402,10 +1405,9 @@ def burst_pair(self, pair):
         # Override event time and event_type. 
         pair.dt = self.t - pair.last_time 
         pair.event_type = EventType.BURST
-
-        single1, single2 = self.propagate_pair(pair)
-
         self.remove_event(pair)		# remove the event -> was still in the scheduler
+
+        single1, single2 = self.propagate_pair(pair)	# TODO this can now also just be a proc_event_by_pair
         self.add_domain_event(single1)
         self.add_domain_event(single2)
 

From d8129b697c70d7de37b3b5dd36443fdeb50388c8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Sep 2011 19:15:54 +0200
Subject: [PATCH 0236/1541] fixed typos, comments, clarification of
 proc_event_by_single

---
 egfrd.py | 92 ++++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 62 insertions(+), 30 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 408d48ca..dc763ef2 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -790,6 +790,9 @@ def propagate_single(self, single):
         # reschedules (update_event) the single, while just calling 
         # propagate does not.  So whoever calls propagate_single 
         # directly should reschedule the single afterwards.
+
+	pid_particle_pair = single.pid_particle_pair
+
         if __debug__:
             log.debug("single.dt=%s, single.last_time=%s, self.t=%s" %
                       (FORMAT_DOUBLE % single.dt,
@@ -801,11 +804,10 @@ def propagate_single(self, single):
 
         if __debug__:
             log.debug("propagate %s: %s => %s" %
-                      (single, single.pid_particle_pair[1].position, newpos))
+                      (single, pid_particle_pair[1].position, newpos))
 
-            if self.world.check_overlap((newpos,
-                                        single.pid_particle_pair[1].radius),
-                                        single.pid_particle_pair[0]):
+            if self.world.check_overlap((newpos, pid_particle_pair[1].radius),
+                                        pid_particle_pair[0]):
                 raise RuntimeError('propagate_single: check_overlap failed.')
 
         if(single.event_type == EventType.SINGLE_REACTION or
@@ -814,7 +816,13 @@ def propagate_single(self, single):
 
             # Single reaction or interaction, and not a burst. Only 
             # update particle, single is removed anyway.
+
+	    # reuse the old single
+	    # 4. process the changes
             self.move_single_particle(single, newpos)
+
+	    # 6. No logging??
+
             return single
         else:
             if isinstance(single, InteractionSingle):
@@ -824,19 +832,30 @@ def propagate_single(self, single):
                 # fire_single_reaction.
                 # For escapes and bursts of interaction singles we do 
                 # it here.
+
+		# 4. process the changes (actually move the particle)
                 self.move_single_particle(single, newpos)
-                newsingle = self.create_single(single.pid_particle_pair)
+
+		# remove the old domain
                 self.remove_domain(single)
+
+		# 5. single domain for the particle (scheduling is done later)
+                newsingle = self.create_single(pid_particle_pair)
+
+		# 6. Log the changes
                 if __debug__:
                     log.debug('    *New %s.\n'
                               '        radius = %.3g. dt = %.3g.' %
                               (newsingle, newsingle.shell.shape.radius,
                                newsingle.dt))
                 return newsingle
+
             else:
+		# reuse the old single
                 single.initialize(self.t)
-                self.move_single(single, newpos,
-                                 single.pid_particle_pair[1].radius)
+
+		# 4. process the changes
+                self.move_single(single, newpos, pid_particle_pair[1].radius)
                 return single
 
     def proc_event_by_single(self, single):
@@ -876,8 +895,6 @@ def proc_event_by_single(self, single):
                 self.add_domain_event(single)
                 return
 
-
-
             # If the single had a decay reaction.
             if single.event_type == EventType.SINGLE_REACTION:
                 if __debug__:
@@ -886,7 +903,7 @@ def proc_event_by_single(self, single):
 
                 self.single_steps[single.event_type] += 1
 
-
+		# get the new position
                 single = self.propagate_single(single)
 
                 try:
@@ -897,23 +914,35 @@ def proc_event_by_single(self, single):
 
                 return
 
-	    ### 1.2 General case
-	    # There is a non-trivial event time for the domain
-            if single.dt != 0.0:
-                # Propagate this particle to the exit point on the shell.
-                single = self.propagate_single(single)
-
-
             # An interaction event is similar to a single reaction.
             if single.event_type == EventType.IV_INTERACTION:
+                if __debug__:
+                    log.info('%s' % single.event_type)
+                    log.info('reactant = %s' % single)
+
+                self.interaction_steps[single.event_type] += 1
+
+		# get the new position
+                single = self.propagate_single(single)
+
                 try:
                     self.remove_domain(single)
-                    self.fire_single_reaction(single, interaction_flag=True)
+                    self.fire_single_reaction(single)	# TODO change to smt Interaction specific?!
                 except NoSpace:
                     self.reject_single_reaction(single)
 
                 return
 
+	    ### 1.2 General case
+	    # There is a non-trivial event time for the domain
+            if single.dt != 0.0:
+                # Propagate this particle to the exit point on the shell.
+                single = self.propagate_single(single)
+
+		# 5. schedule domain
+		self.add_domain_event(single)
+
+
 	return
 
 
@@ -1173,8 +1202,8 @@ def proc_event_by_pair(self, pair):
 
         single1 = pair.single1
         single2 = pair.single2
-        pid_particle_pair1 = pair.pid_particle_pair
-        pid_particle_pair2 = pair.pid_particle_pair
+        pid_particle_pair1 = pair.pid_particle_pair1
+        pid_particle_pair2 = pair.pid_particle_pair2
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
         
@@ -1275,8 +1304,8 @@ def proc_event_by_pair(self, pair):
         	        raise NoSpace()
 
 		# 4. process the changes (remove particle, make new ones)
-	        self.world.remove_particle(pid_particle_pair[0])
-                self.world.remove_particle(pid_particle_pair[0])
+	        self.world.remove_particle(pid_particle_pair1[0])
+                self.world.remove_particle(pid_particle_pair2[0])
                 particle = self.world.new_particle(product_species.id, new_com)
 		products = [particle, ]
 
@@ -1416,8 +1445,8 @@ def burst_pair(self, pair):
     def propagate_pair(self, pair):
 	# takes a pair and returns two singles after propagation
 
-        pid_particle_pair1 = pair.pid_particle_pair
-        pid_particle_pair2 = pair.pid_particle_pair
+        pid_particle_pair1 = pair.pid_particle_pair1
+        pid_particle_pair2 = pair.pid_particle_pair2
 
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
@@ -1460,12 +1489,18 @@ def propagate_pair(self, pair):
 
 
 	# re-use single domains for particles
+	# normally we would take the particles + new positions from the old pair
+	# and use them to make new singles. Now we re-use the singles stored in the
+	# pair
         single1 = pair.single1
         single2 = pair.single2
-
         assert single1.domain_id not in self.domains
         assert single2.domain_id not in self.domains
 
+	# remove the old domain
+        self.remove_domain(pair)
+
+	# 'make' the singles
         single1.initialize(self.t)
         single2.initialize(self.t)
         
@@ -1502,9 +1537,6 @@ def propagate_pair(self, pair):
             log.debug("proc_event_by_pair: #2 { %s: %s => %s }" %
                       (single2, str(pos2), str(newpos2)))
 
-	# remove the old domain
-        self.remove_domain(pair)
-
         return single1, single2
 
     def try_interaction(self, single, surface):
@@ -2112,8 +2144,8 @@ def check_domains(self):
                                'Event Scheduler: %s' % str(tuple(event_ids)))
 
     def check_pair_pos(self, pair, pos1, pos2, com, radius):
-        particle1 = pair.pid_particle_pair[1]
-        particle2 = pair.pid_particle_pair[1]
+        particle1 = pair.pid_particle_pair1[1]
+        particle2 = pair.pid_particle_pair2[1]
 
         old_com = com
         

From 8c41f284024842a75a888655171c3c37169e301b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 30 Sep 2011 18:43:08 +0200
Subject: [PATCH 0237/1541] Trying to implement surfaces into Transaction
 class.

---
 Multi.hpp                     | 19 ++++++++++++++++++-
 ParticleContainer.hpp         | 13 ++++++++++++-
 Transaction.hpp               | 34 +++++++++++++++++++++++++++++++++-
 World.hpp                     |  3 ++-
 binding/ParticleContainer.hpp | 29 ++++++++++++++++++++++++++++-
 newBDPropagator.hpp           |  1 -
 6 files changed, 93 insertions(+), 6 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 6f3dcba0..a1389450 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -13,10 +13,12 @@
 #include "BDPropagator.hpp"
 #include "Logger.hpp"
 #include "PairGreensFunction.hpp"
+#include "Transaction.hpp"
 #include "VolumeClearer.hpp"
 #include "utils/array_helper.hpp"
 #include "utils/range.hpp"
 
+
 template<typename Ttraits_>
 class MultiParticleContainer
     : public Ttraits_::world_type::particle_container_type
@@ -43,6 +45,16 @@ class MultiParticleContainer
     typedef std::map<particle_id_type, particle_type> particle_map;
     typedef sized_iterator_range<typename particle_map::const_iterator> particle_id_pair_range;
 
+private:
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
+    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+
+public:    
+    typedef boost::transform_iterator<surface_second_selector_type,
+            typename structure_map::const_iterator> surface_iterator;
+    typedef sized_iterator_range<surface_iterator> structures_range;
+
+
     virtual ~MultiParticleContainer() {}
 
     virtual size_type num_particles() const
@@ -64,7 +76,12 @@ class MultiParticleContainer
     {
         return world_.get_structure(id);
     }
-
+    
+    structures_range get_structures() const
+    {
+        return world_.get_structures();
+    }
+        
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
     {
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index da1399e0..73493344 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -31,6 +31,15 @@ class ParticleContainer
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
+private:
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
+    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+
+public:    
+    typedef boost::transform_iterator<surface_second_selector_type,
+            typename structure_map::const_iterator> surface_iterator;
+    typedef sized_iterator_range<surface_iterator> structures_range;
+
     virtual ~ParticleContainer() {};
 
     virtual size_type num_particles() const = 0;
@@ -40,6 +49,8 @@ class ParticleContainer
     virtual species_type const& get_species(species_id_type const& id) const = 0;
 
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
+    
+    virtual structures_range get_structures() const = 0;
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos) = 0;
@@ -49,7 +60,7 @@ class ParticleContainer
     virtual bool remove_particle(particle_id_type const& id) = 0;
 
     virtual particle_id_pair get_particle(particle_id_type const& id) const = 0;
-
+    
     virtual bool has_particle(particle_id_type const& id) const = 0;
 
     virtual particle_id_pair_and_distance_list* check_overlap(particle_shape_type const& s) const = 0;
diff --git a/Transaction.hpp b/Transaction.hpp
index af7e6b68..666d7971 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -60,6 +60,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
+    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
     typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
@@ -68,8 +69,15 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef std::map<typename particle_id_pair::first_type,
             typename particle_id_pair::second_type> particle_id_pair_set_type;
     typedef sorted_list<std::vector<particle_id_type> > particle_id_list_type;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
+    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+
+public:    
+    typedef boost::transform_iterator<surface_second_selector_type,
+            typename structure_map::const_iterator> surface_iterator;
+    typedef sized_iterator_range<surface_iterator> structures_range;
+
 
-public:
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
     {
@@ -154,6 +162,30 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_structure(id);
     }
+    
+    virtual structures_range get_structures() const
+    {
+        return pc_.get_structures();
+    }    
+        
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos)
+    {
+    
+        typedef boost::iterator_range<surface_iterator> base_type;
+        
+        structures_range structures = pc_.get_structures();
+        
+        base_type::size_type size = structures.size();
+
+        boost::shared_ptr<structure_type> structure;
+        
+        /*
+        length_type distance( (*structures)::base_type.distance( pos ) );
+    
+        return structure_id_and_distance_pair( (*structure).id() ,distance );
+        */
+        return structure_id_and_distance_pair();
+    }
 
     virtual species_type const& get_species(species_id_type const& id) const
     {
diff --git a/World.hpp b/World.hpp
index 97d93244..eda805d4 100644
--- a/World.hpp
+++ b/World.hpp
@@ -24,6 +24,7 @@
 #include "GSLRandomNumberGenerator.hpp"
 #include "Point.hpp" // XXX: workaround. should be removed later.
 #include "utils/pair.hpp"
+#include "utils/range.hpp"
 
 template<typename Tderived_, typename Tlen_, typename TD_>
 struct WorldTraitsBase
@@ -275,7 +276,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return (*i).second;
     }
 
-    structures_range get_structures() const
+    virtual structures_range get_structures() const
     {
         return structures_range(
             surface_iterator(structure_map_.begin(), surface_second_selector_type()),
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 6c1ef59e..673e106e 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -1,11 +1,24 @@
 #ifndef BINDING_PARTICLE_CONTAINER_HPP
 #define BINDING_PARTICLE_CONTAINER_HPP
 
+#include <utility>
+#include <map>
+
 #include <boost/python.hpp>
 #include <boost/python/tuple.hpp>
 #include <boost/python/override.hpp>
 #include <boost/python/wrapper.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/array.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
 #include "../exceptions.hpp"
+#include "../utils/get_default_impl.hpp"
+#include "../generator.hpp"
+#include "../utils/pair.hpp"
+
 #include "peer/compat.h"
 #include "peer/wrappers/generator/pyiterator_generator.hpp"
 #include "peer/wrappers/generator/generator_wrapper.hpp"
@@ -180,7 +193,15 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::particle_id_pair_generator particle_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
 
-public:
+private:
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
+    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+
+public:    
+    typedef boost::transform_iterator<surface_second_selector_type,
+            typename structure_map::const_iterator> surface_iterator;
+    typedef sized_iterator_range<surface_iterator> structures_range;
+
     virtual ~ParticleContainerWrapper() {}
 
     virtual size_type num_particles() const
@@ -212,6 +233,11 @@ class ParticleContainerWrapper
     {
         return py_wrapper_type::get_override("get_structure")(id);
     }
+    
+    virtual structures_range get_structures() const
+    {
+        return py_wrapper_type::get_override("get_structures")();
+    }
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
@@ -325,6 +351,7 @@ inline boost::python::objects::class_base register_particle_container_class(
             pure_virtual((typename impl_type::species_type const&(impl_type::*)(typename impl_type::species_id_type const&) const)&impl_type::get_species),
             return_internal_reference<>())
         .def("get_structure", pure_virtual(&impl_type::get_structure))
+        .def("get_structures", pure_virtual(&impl_type::get_structures))
         .def("new_particle", pure_virtual(&impl_type::new_particle))
         .def("update_particle", pure_virtual(&impl_type::update_particle))
         .def("remove_particle", pure_virtual(&impl_type::remove_particle))
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b8b6fd7a..c601f0d8 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -149,7 +149,6 @@ class newBDPropagator
             }
             else
             {
-                
                 try
                 {
                     if( attempt_reaction(pp, closest.first) )

From 70671e5e4cfbe1c912497da91ee5b8b874b8a2a1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 11:13:00 +0200
Subject: [PATCH 0238/1541] some added comments

---
 egfrd.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index dc763ef2..14595ca6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -812,10 +812,11 @@ def propagate_single(self, single):
 
         if(single.event_type == EventType.SINGLE_REACTION or
            single.event_type == EventType.IV_INTERACTION):
-	    # An identity change of the particle needs to take place
+            # Single reaction or interaction, and not a burst.
+	    # domain is removed in proc_event_by_single.
 
-            # Single reaction or interaction, and not a burst. Only 
-            # update particle, single is removed anyway.
+	    # An identity change of the particle needs to take place
+	    # This is done in fire_single_reaction
 
 	    # reuse the old single
 	    # 4. process the changes
@@ -852,10 +853,15 @@ def propagate_single(self, single):
 
             else:
 		# reuse the old single
+		# domain is not removed
                 single.initialize(self.t)
 
 		# 4. process the changes
                 self.move_single(single, newpos, pid_particle_pair[1].radius)
+
+		# 5. No new single is made(reuse), rescheduling is done elsewhere
+		# 6. Logging is done else?
+
                 return single
 
     def proc_event_by_single(self, single):
@@ -885,6 +891,8 @@ def proc_event_by_single(self, single):
 	    # simulator time
             assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
+	    # FIXME This should be somewhere else, now it doesn't process SINGLE_REACTION
+	    # events.
             # Handle immobile case (what event has taken place to get here?!).
             if single.getD() == 0:
 		# The domain has not produced an decay reaction event and is immobile
@@ -942,6 +950,7 @@ def proc_event_by_single(self, single):
 		# 5. schedule domain
 		self.add_domain_event(single)
 
+		# 6. Logging?
 
 	return
 
@@ -1472,7 +1481,7 @@ def propagate_pair(self, pair):
             newpos1 = self.world.apply_boundary(newpos1)
             newpos2 = self.world.apply_boundary(newpos2)
 
-	    # check that the particle do not overlap with any other particles in the world
+	    # check that the particles do not overlap with any other particles in the world
             assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
                                                 pid_particle_pair1[0], pid_particle_pair2[0])
             assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),

From 7a72c1bbef9aa65d84320d8168f46021b0c6d0c5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 12:40:57 +0200
Subject: [PATCH 0239/1541] added tex files about shell making and event
 processing

---
 doc/Makefile.am          |   4 +-
 doc/event_processing.tex |  67 ++++++++++
 doc/shell_making.tex     | 269 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 339 insertions(+), 1 deletion(-)
 create mode 100644 doc/event_processing.tex
 create mode 100644 doc/shell_making.tex

diff --git a/doc/Makefile.am b/doc/Makefile.am
index 44ad9b22..84c40f14 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -9,7 +9,9 @@ if HAVE_PDFLATEX
 pdf_DATA = \
 	implementation_notes.pdf\
 	p1_fp.pdf\
-    interface_functions.pdf
+	interface_functions.pdf\
+	shell_making.pdf\
+	event_processing.pdf
 endif
 
 
diff --git a/doc/event_processing.tex b/doc/event_processing.tex
new file mode 100644
index 00000000..76b4b76d
--- /dev/null
+++ b/doc/event_processing.tex
@@ -0,0 +1,67 @@
+\documentclass[a4paper, 11pt]{article}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+
+\title{Realization of the main eGFRD algorithm in the current python code}
+\author{Laurens Bossen}
+
+\begin{document}
+\maketitle
+
+A number of independent processes or 'coordinates' take place inside a Domain. Independent processes are:
+-Diffusion in a number of dimensions
+-Decay reactions
+
+When one of the processes in the domain has produced the current event, then a fire_domain is executed. However, when an other
+event external to the domain is the current event but the processes need to be propagated anyhow (a burst), then a burst_domain
+is executed.
+Fire happens when the domain produced the top event of the scheduler. A burst event happens when the event associated with the
+domain is still in the scheduler.
+Fire->Event is no longer in scheduler
+Burst->Event is is still in scheduler
+
+
+Fire_Single
+-process event causing coordinate (a coordinate is an independent process in a domain, eg diffusion, decay)
+-process all other coordinates
+
+Burst_Single
+-process all coordinates (event was external)
+
+After a fire or burst the domain is 'reduced' to a default NonInteractionSingle and a new domain (Pair, Interaction,
+NonInteractionSingle) should be made.
+
+Then reschedule the event
+
+
+Note that from a Pair, Interaction (Multi) after a Fire or Burst you always 'go back' to a NonInteractionSingle. This means
+that you change domain.
+A speedup trick for this is to 'save' the original single in the Pair or Interaction domain so that we can potentially reuse
+them when a fire or burst event takes place
+
+
+Processing the event means:
+Test if Single && zero-shell && D != 0 then
+  skip (the single was a special single->zero shell)
+if diffusion == true (D != 0)
+  determine new position(s) of particle(s)
+   -check also if still in shell
+if event is (not Burst, not Escape, Single_Reaction, IV_Reaction, IV_Interaction)
+  get new identity for the resulting particle
+  calculate new position for particles (for example Interaction, Decay reactions)
+apply boundary conditions to new position(s)
+actually move/remove/add the particle (update_world)
+
+determine if we need to make a different domain (for example when bursting an Interaction)
+draw new event time
+reschedule event and domain
+
+
+
+Create a Protective Domain:
+-generate identifiers for domain and shell
+-make domain object (instantiate with particle, shell dimensions, structure/surface, reaction_rules, misc info)
+ -make appropriate shell (done by constructor or later in case of Multi)
+-place shell in container (move_shell)
+-
+\end{document}
diff --git a/doc/shell_making.tex b/doc/shell_making.tex
new file mode 100644
index 00000000..49459b49
--- /dev/null
+++ b/doc/shell_making.tex
@@ -0,0 +1,269 @@
+\documentclass[a4paper,11pt]{article}
+\usepackage{amsmath}
+\usepackage{amsfonts}
+
+\title{Algorithm for deciding on, and dimensioning a new shell}
+\author{Laurens Bossen}
+
+
+\begin{document}
+\maketitle
+
+\section{Introduction}
+The eGFRD algorithm works with protective domains. In each domain one or two partcles can exist. Also a surface can be
+involved and the particles can live on different structures or surfaces. The domains produde event that are organized
+in the scheduler.
+
+When an event from the scheduler is processes, the changed position (and potentially its identity) of the particles is
+processed and a new domain for the particles has to be formed. The processing of the event
+namely leaves the particles in the old domain as NonInteractionSingles with a size equal to the size of the particle
+(they are zero-dt domains). The system will now decide what domain to make next.
+
+There are a number of different domains that can be created from a NonInteractionSingle, and we need to decide which one is
+the most appropriate. The options for a domain in descending order of computational cost per unit clock time are:
+\begin{itemize}
+ \item A NonInteractionSingle (a single particle in a symmetric domain modeling diffusion and potential decay of the
+			       particle)
+ \item An InteractionSingle (a single particle in the 3D space in a cylindrical domain modeling the diffusion of the particle
+			     and non-specific binding of the particle to a surface).
+ \item A Pair (two particles potentially on two different structures in a domain modeling diffusion and reaction between
+	       the particles).
+ \item A Multi (any number of particles in a collection of connected shells performing Brownian Dynamics)
+\end{itemize}
+
+\paragraph{Goal of algorithm}
+The goal of the algorithm is to minimize the total time spent on computations while still allowing for reactions between
+particles and non-specific association of a particle with a surface such as the membrane or DNA. This means in practice
+that we want to make NonInteractionSingles for as long as possible and that only when a reaction or interaction becomes
+probable switch to
+making Pairs and InteractionSingles. We also want to defer the creation of a Multi a long a possible, since this really
+takes up a lot of computation time.
+
+Also we don't want to waste investments. This means that when we have just made a new
+shell, we don't want it to be bursted right away. In short:
+\begin{itemize}
+ \item allow reactions and interactions
+ \item spend CPU time well
+ \item don't waste CPU time
+\end{itemize}
+
+There two different classes of domains, NonInteractionSingles and the rest. The rest is composed of
+Pairs, Interactions and Multis. The separation in these two classes is caused by the fact that the NonInteractionSingle
+is the default domain since they are the most efficient, and from the NonInteractionSingles we can go to other domains.
+Also, the most appararent property of the NonInteractionSingle is then that it can 'burst' other domains to initiate the
+creation of a more complex domain, typically a Pair or Interaction.
+The making of a new Domain such as a Pair/Interaction/Multi is therefore initiated by a NonInteractionSingle, and it is
+not possible to go from an Interaction domain directly to a Pair domain, we first need to 'go back' to the
+NonInteractionSingle.
+
+\section{Algorithm}
+\subsection{Burst or reaction volume}
+First, we define a $burst volume$ or $reaction volume$. The
+$reaction volume$ effectively defines the threshold for when the algorithm should stop trying to make NonInteractionSingles and
+should start trying to do Interactions or Pairs.
+More specifically, it defines a domain in which the particle can move, and when other shells enter into this space it is a
+signal that a reaction or interaction between the particle and the intruding object is probable and that a Pair or Interaction
+should be attempted.
+
+This also means that the algorithm will make NonInteractionSingles as long as no other object intrude into its
+$reaction volume$. Making the $reaction volume$ small, therefore makes sure that we use the efficient NonInteractionSingles
+for as long as possible and that the algorithm will only attempt a Pair or Interaction when the particles get 'close'.
+
+For three dimensionally diffusing particles, the threshold is simply a $burst radius$, since the diffusoin is in three
+dimensions, and the protective domain is spherical.
+For particles that only diffuse in two or one dimension, there is a certain direction in which the reaction takes place.
+For these particles we define the $reaction volume$ in the same shape as its appropriate protective domain, where the
+$reaction radius$ is in the same dimension as we would size its domain.
+
+Note that since overlap calculation between spheres and cylinders are annoying, we approximate the $reaction volume$ using
+a sphere. The approximation introduces some inefficiency, since space that is not relevant for the particle is also covered
+by the spherical $reaction volume$. However, when the size of the $reaction radius$ is small (typically 1.1 times the radius
+of the particle), then the effect should be only small.
+Note also that although the approximation could in principle allow two shell to overlap, since the corners of the cylinders
+are not covered by the sphere, it still makes sure that no particles
+overlap because the particle cannot leave the sphere. In this sence, the approximation does not introduce any errors.
+
+
+\subsection{Bursting and finding potential partners for domains}
+When objects intrude into the $reaction volume$, the algorithm will burst the objects and will start to try
+to make a more complex domain than a NonInterationSingle. Bursting of domains should not be indiscriminatively though.
+When an intruding domain has just been made (no time has passed since the making of the domain), then the domain should not
+be bursted.
+This prevents us from going back to the situation before the domain was made, eliminating the potential for a cycle. A newly
+made Pair, Interaction or Mixed Pair domain is always sized such that it will not directly be bursted (see below),
+however, a NonInteractionSingle could be made in the $reaction volume$ of another NonInteractionSingle. In this case the
+NonInteractionSingle will not be bursted when no time has passed since its creation.
+
+However, when sizing a NonInteractionSingle we will burst intruding domains in which time has passed. This means that if the
+domain is just freshly made, we assume that it has been done with some wisdom (socially), and we shouldn't throw away the
+investment.
+
+Also note that object such as surfaces and Multi cannot be bursted.
+
+We can only partner up with objects whose position is exactly known. Objects whose position is exactly known are:
+\begin{itemize}
+ \item surfaces
+ \item particles in Multis
+ \item just bursted (initialized) NonInteractionSingles ($dt=0$ shells)
+ \item 'dead' NonInteractionSingles (note that $dt=\infty$ for these shells)
+\end{itemize}
+The position of a surface or particles in a Multi is always known, so we can use them directly as partners in domain making.
+The position of particles in a non-zero shell ($dt \neq 0$) is not exactly known, and therefore we first have to burst the
+domain if we want to use its contents as partners. A burst will propagate the particles in the domain and make a
+NonInteractionSingle domain for each particle.
+In the same way we can burst 'dead' NonInteractionSingles, although little would change. The particle will stay in the
+same position, just the $dt$ for the domain will be reset to zero, and a new event time will be drawn ($dt=\infty$) if the
+particle was not used in the new domain.
+
+
+\subsection{Deciding what domain to try, defining the horizon}
+To define a threshold to determine if a reaction or interaction with an other object is a good idea, we define the $horizon$.
+To form a new domain that includes an other particle or surface than the current one, the current particle 'looks around' in
+its $horizon$ after bursting the domains in its $reaction volume$. Since partners can
+not only be found in the same structure, but also in other structures, we look around in 3D. This means that the horizon
+defines a sphere with $horizon$ radius.
+
+The $horizon$ is different for different partners, but in general
+is the distance between two objects (two particles for example) that is the sum of their $reaction radii$. The
+reasoning is
+that if the two particles are so far away from each other that two NonInteractionSingles can be made with sizes larger than the
+$reaction volume$, then a reaction is no longer probable between the objects and making one (or two) NonInteractionSingles
+would be better. However, if the $reaction radii$ still overlap, a reaction is deamed probably and a Pair, Interaction or Multi
+should be attempted.
+
+When we would make the $horizon$ smaller, the algorithm would still make NonInteractionSingles when the $reaction volumes$
+overlap. After an event of one of the domains, this would also lead to a burst of the other domain without attempting a more
+complex domain. This is inefficient use the domain. Making the $horizon$ larger would result in larger Pair or Interaction
+domains which have a lower probability of success.
+
+The $horizon$ varies for different partners. For the interaction of a 3D diffusing particle with a membrane for
+example, a different threshold is used than for a reaction between two particles in 3D.
+For a Pair in the same structure, we define the $horizon$
+as the sum of the $reaction radii$, although this is possibly slightly different for a MixedPair domain.
+The $horizon$ for an Interaction on the other hand, is defined as the $reaction radius$ of the particle since the surface is
+immobile and the domain making decision lies solely with the particle.
+
+Note that when a Pair or Interaction is not possible, the algorithm will fall back to making NonInteractionSingles.
+However, when also NonInteractionSingles become inefficient and no Pair or Interaction can be made, the algorithm will need to
+decide to swith to a Multi. The threshold for a Multi can also be regarded as a horizon since a Multi is only efficient when
+the two objects are close enough.
+The $horizon$ for a Multi therefore denotes when NonInteractionSingles are no longer efficient and a Multi should be
+made to propagate the particle. In general the Multi horizon is really small reflecting the efficiency of the Green's functions
+over brute force Brownian Dynamics.
+
+
+\subsection{Sizing up different domains}
+Above we discussed how we try to make certain domains.
+When we try to make a certain domain, such as an Interaction, we need to know if the domain will fit in the current configuration
+of domains in the system.
+The different domain such as a 2D Pair, an Interaction or 3D NonInteractionSingle have different shapes and requirements, and
+can be sized in different directions. The currently possible domains and their shapes are:
+\begin{itemize}
+ \item 1D NonInteractionSingle -> cylinder, scale in 1D ($z$)
+ \item 2D NonInteractionSingle -> cylinder, scale in 2D ($r$)
+ \item 3D NonInteractionSingle -> sphere, scale in 3D ($r$)
+ \item Pairs -> same shape as NonInteractionSingle, minimal size
+ \item Interaction -> cylinder, scale in 3D ($r$ and $z$), minimal size, stick to membrane or rod
+ \item Mixed Pair -> cylinder, scale in 3D ($r$ and $z$), minimal size, stick to membrane
+ \item Multi -> same as NonInteractionSingle but fixed in scalable coordinate
+\end{itemize}
+
+\paragraph{Sizing up an Interaction, Pair or Mixed Pair}
+Although the shapes and requirements for the domains are all quite different, there are some fixed rules for the maximum size
+of the domains.
+When we are making a Pair, Interaction or Mixed Pair, we want to make it such that NonInteractionSingles do not have the
+tendency to burst this domain. The reasoning is that we are making the current domain because a reaction or interaction
+between the object is probable and other particles should be kept at a distance. Sizing such a domain into the $reaction
+volume$ of a NonInteractionSingle suggests that this NonInteractionSingle should attempt to make a reaction with the contents
+of the current domain, which is against making the domain in the first place.
+
+So, since we don't want to throw away the investment in the current shell, and we decided that it was a good idea to make this
+domain in the first place, we leave all NonInteractionSingles at a distance such that the $reaction volume$ of the
+NonInteractionSingle in question does not overlap with the new domain. This way these Single won't immediately try to
+interfere and burst the newly made domain.
+Note that domains on a surface are only sized in the coordinates 'in' the surface and that NonInteractionSingles in the bulk
+are mostly irrelevant.
+
+As an approximation, the $reaction volume$ of the NonInteractionSingle is chosen to be spherical also in the case of a 1D or
+2D diffusing particle
+(see above). This means that also when making a Pair, Interaction or Mixed Pair, the particles in a NonInteractionSingle will
+be kept at a distance of $reaction radius$.
+
+When the nearest relevant object is an object other than a NonInteractionSingle, such as a surface (or 'dead'
+NonInteractionSingle), a
+Pair, Interaction or Multi domain, then the maximum size of the domain is the distance to the object, since these objects do
+not have a $reaction volume$ and cannot burst the domain directly.
+
+\paragraph{Sizing up NonInteractionSingles}
+To size up a NonInteractionSingle, the rules are similar.
+The maximum size of a NonInteractionSingle is the distance to the nearest relevant object when the nearest relevant object is
+a surface (or 'dead' NonInteractionSingle), Pair, Interaction or Multi.
+In the case the nearest relevant neighbor is another NonInteractionSingle we should be more careful
+and leave enough space for the other one (the maximum size is then for example half-way), especially if the $reaction volumes$
+of the two NonInteractionSingles overlap.
+This is to prevent unnecessary mutual bursting of the two NonInteractionSingles.
+
+Note again that the nearest relevant object is the object
+that is met first when scaling the domain in its coordinate. This is for example the $r$ coordinate for a 2D
+NonInteractionSingle and the $z$ coordinate for a 1D NonInteractionSingle.
+Note also that when the closest relevant Pair or Interaction domain was just made (no time has passed since its creation), it is
+trivial for a NonInteractionSingle to make a domain of at least the $reaction volume$, since the $reaction volume$ was taken
+into account when the Pair or Interaction was made (see above).
+
+\paragraph{Sizing up Multis}
+The shell for a particle participating in a Multi should be at least the size of the Multi horizon. The reasoning is that
+when the particle leaves its shell it is at least horizon away from the multi. Making the shell smaller that the horizon,
+will cause repeated re-creation of the Multi, since the particle can leave its domain but is not yet $horizon$ away from the
+Multi. Making the shells bigger than the horizon will cause more Multi-ing than necessary to get out of the Multi horizon.
+Making the shell exactly the size of the Multi horizon will then make sure that the Multi is not used longer than strictly
+necessary.
+
+Note that the shape of the shells for the particles in the Multi depends on the dimensions in which the particle can diffuse,
+similarly as the domains for NonInteractionSingles and Pairs. This means that for a particle in
+the bulk the shell is a sphere, for a particle in 2D and 1D it is a cylinder. As an approximation, however, we currently use
+spheres as shells for all particles in a Multi.
+
+
+\subsection{The algorithm in short}
+From a NonInteractionSingle that has just been processed we will make a new domain. The NonInteractionSingle is the default
+domain from which other domains can be formed. To decide what domain to make we use the following algorithm.
+\begin{enumerate}
+ \item First we check if there are any intruders in our $reaction volume$. The $reaction volume$ has in principle the same
+       shape as the shell of the NonInteractionSingle, but we approximate it with a sphere. Note that these can be Singles,
+       Pairs, Multis and even surfaces. If there are intruders, then this means that an other particle or surface so close
+       in the relevant direction that a reaction or
+       interaction is probable and that we should start thinking about making Interactions, Pairs or Multis.
+ \item burst the 'burstable' intruders within the $burstradius=reaction volume$ with the exception of domains in which no
+       time has passed yet (not burstable are: Multi, Surface, zero-shell NonInteractionSingles ($dt=0$ or 'dead')).
+ \item compile a list of neighboring potential partners in all three dimensions (Multis, surface, zero-shell
+       NonInteractionSingles).
+ \item get the closest potential partner and decide on the domain to make. Note that the closest potential partner does not
+       always leads to an allowed
+       interaction. A combination of a 1D diffusing particle and a 3D diffusing particle is for example not possible.
+ \begin{itemize}
+  \item if the closest potential partner is a surface AND is within the $surface horizon$, then try an Interaction.
+  \item elseif the closest potential partner is a NonInteractionSingle AND within the Pair horizon, then try a Pair
+  \item if the above fails, then the closest partner is a surface AND outside the surface horizon OR a NonInteractionSingle
+        AND outside the Pair horizon OR the domain could not be made.
+  \item If the closest potential partner is further than the Multi horizon, then make a NonInteractionSingle.
+  \item else make/join a Multi.
+ \end{itemize}
+ \item Make sure that the domain has the proper size.
+\end{enumerate}
+
+
+
+\section{Notes on special domains}
+Note that a surface behaves similarly to a stationary (D=0), non-decaying particle. It doens't produce any events and is
+therefore never fired and never bursts other domains. Since it is stationary it also doesn't contribute to the horizon.
+
+A zero shell is made in a number of situations. They are made when a new particle is introduced in the simulation system
+(for example at the beginning of a simulation run), or when a shell is bursted and is reduced to a collection of zero-dt
+NonInteractionSingles.
+Since zero shells have a dt of zero their events are all at the top of the
+scheduler, and consequently these events will be processed before and other events. Note that these shells always produce
+an $ESCAPE$ event, and that there can be only other zero shells in the simulation system if the shell that is associated with
+the currently event is also a zero shell.
+
+
+\end{document}

From ecbccd368ca431dcdd11f119b92d9d150f7221e0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 14:39:54 +0200
Subject: [PATCH 0240/1541] name change move_single_particle -> move_particle

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 14595ca6..cc81d672 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -506,7 +506,7 @@ def create_multi(self):
 
     def move_single(self, single, position, radius=None):
         self.move_single_shell(single, position, radius)
-        self.move_single_particle(single, position)
+        self.move_particle(single, position)
 
     def move_single_shell(self, single, position, radius=None):
         if radius == None:
@@ -524,7 +524,7 @@ def move_single_shell(self, single, position, radius=None):
         single.shell_id_shell_pair = shell_id_shell_pair
         self.geometrycontainer.move_shell(shell_id_shell_pair)
 
-    def move_single_particle(self, single, position):
+    def move_particle(self, single, position):
         new_pid_particle_pair = (single.pid_particle_pair[0],
                           Particle(position,
                                    single.pid_particle_pair[1].radius,
@@ -820,7 +820,7 @@ def propagate_single(self, single):
 
 	    # reuse the old single
 	    # 4. process the changes
-            self.move_single_particle(single, newpos)
+            self.move_particle(single, newpos)
 
 	    # 6. No logging??
 
@@ -835,7 +835,7 @@ def propagate_single(self, single):
                 # it here.
 
 		# 4. process the changes (actually move the particle)
-                self.move_single_particle(single, newpos)
+                self.move_particle(single, newpos)
 
 		# remove the old domain
                 self.remove_domain(single)

From 0c49c1d8278150c4ff9efb6f7b5537da265346a6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 14:55:34 +0200
Subject: [PATCH 0241/1541] changed function of move_particle to not have side
 effect on single that contains the particle

---
 egfrd.py | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index cc81d672..029713ca 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -506,7 +506,7 @@ def create_multi(self):
 
     def move_single(self, single, position, radius=None):
         self.move_single_shell(single, position, radius)
-        self.move_particle(single, position)
+        single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
 
     def move_single_shell(self, single, position, radius=None):
         if radius == None:
@@ -524,15 +524,18 @@ def move_single_shell(self, single, position, radius=None):
         single.shell_id_shell_pair = shell_id_shell_pair
         self.geometrycontainer.move_shell(shell_id_shell_pair)
 
-    def move_particle(self, single, position):
-        new_pid_particle_pair = (single.pid_particle_pair[0],
-                          Particle(position,
-                                   single.pid_particle_pair[1].radius,
-                                   single.pid_particle_pair[1].D,
-                                   single.pid_particle_pair[1].sid))
-        single.pid_particle_pair = new_pid_particle_pair
+    def move_particle(self, pid_particle_pair, position):
+	# moves a particle in world based on an existing particle
+
+        new_pid_particle_pair = (pid_particle_pair[0],
+	                         Particle(position,
+                                          pid_particle_pair[1].radius,
+                                   	  pid_particle_pair[1].D,
+                                   	  pid_particle_pair[1].sid))
+#        single.pid_particle_pair = new_pid_particle_pair
 
         self.world.update_particle(new_pid_particle_pair)
+	return new_pid_particle_pair
 
     def remove_domain(self, obj):
 	# Removes all the ties to a domain (single, pair, multi) from the system.
@@ -820,7 +823,7 @@ def propagate_single(self, single):
 
 	    # reuse the old single
 	    # 4. process the changes
-            self.move_particle(single, newpos)
+	    single.pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
 
 	    # 6. No logging??
 
@@ -835,7 +838,7 @@ def propagate_single(self, single):
                 # it here.
 
 		# 4. process the changes (actually move the particle)
-                self.move_particle(single, newpos)
+                pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
 
 		# remove the old domain
                 self.remove_domain(single)

From a1d9036c0cd5b5ed881bc9f9fe6884942e3e9a60 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 15:17:56 +0200
Subject: [PATCH 0242/1541] small changes to the use of move_single

---
 egfrd.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 029713ca..2f8600eb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -505,8 +505,8 @@ def create_multi(self):
 
 
     def move_single(self, single, position, radius=None):
-        self.move_single_shell(single, position, radius)
         single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
+        self.move_single_shell(single, position, radius)
 
     def move_single_shell(self, single, position, radius=None):
         if radius == None:
@@ -860,7 +860,8 @@ def propagate_single(self, single):
                 single.initialize(self.t)
 
 		# 4. process the changes
-                self.move_single(single, newpos, pid_particle_pair[1].radius)
+        	single.pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+        	self.move_single_shell(single, newpos, single.pid_particle_pair[1].radius)
 
 		# 5. No new single is made(reuse), rescheduling is done elsewhere
 		# 6. Logging is done else?
@@ -1515,11 +1516,11 @@ def propagate_pair(self, pair):
 	# 'make' the singles
         single1.initialize(self.t)
         single2.initialize(self.t)
+        self.move_single(single1, newpos1, pid_particle_pair1[1].radius)
+        self.move_single(single2, newpos2, pid_particle_pair2[1].radius)
         
         self.domains[single1.domain_id] = single1
         self.domains[single2.domain_id] = single2
-        self.move_single(single1, newpos1, pid_particle_pair1[1].radius)
-        self.move_single(single2, newpos2, pid_particle_pair2[1].radius)
 
 	# Thoroughly check the sizes of the shells of the singles
         if __debug__:

From f6e65f58ee22c3cfd279accc6aa22740bf0ddfb9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 15:19:09 +0200
Subject: [PATCH 0243/1541] name change move_single_shell ->
 update_single_shell

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2f8600eb..0f5f6f9b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -506,9 +506,9 @@ def create_multi(self):
 
     def move_single(self, single, position, radius=None):
         single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
-        self.move_single_shell(single, position, radius)
+        self.update_single_shell(single, position, radius)
 
-    def move_single_shell(self, single, position, radius=None):
+    def update_single_shell(self, single, position, radius=None):
         if radius == None:
             # By default, don't change radius.
             radius = single.shell.shape.radius
@@ -861,7 +861,7 @@ def propagate_single(self, single):
 
 		# 4. process the changes
         	single.pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
-        	self.move_single_shell(single, newpos, single.pid_particle_pair[1].radius)
+        	self.update_single_shell(single, newpos, single.pid_particle_pair[1].radius)
 
 		# 5. No new single is made(reuse), rescheduling is done elsewhere
 		# 6. Logging is done else?
@@ -1201,7 +1201,7 @@ def update_single(self, single):
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.
 	singlepos = single.pid_particle_pair[1].position
-        self.move_single_shell(single, singlepos, new_shell_size)        
+        self.update_single_shell(single, singlepos, new_shell_size)        
 
         single.dt, single.event_type = single.determine_next_event()
         single.last_time = self.t

From 72094846f3fd0baf1751ed8218954d1bdd5120e9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 16:40:57 +0200
Subject: [PATCH 0244/1541] basically removed the move_single method The move
 single combined the moving of a particle and the moving of the shell in one
 method. In the current model where we first apply the changes made to
 particle position and identity to the world and only later decide on what new
 domain to use, this combination seems undesirable.

---
 egfrd.py | 23 ++++++++++++++++-------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0f5f6f9b..c1d8d5fa 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -504,9 +504,9 @@ def create_multi(self):
         return multi
 
 
-    def move_single(self, single, position, radius=None):
-        single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
-        self.update_single_shell(single, position, radius)
+#    def move_single(self, single, position, radius=None):
+#        single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
+#        self.update_single_shell(single, position, radius)
 
     def update_single_shell(self, single, position, radius=None):
         if radius == None:
@@ -823,7 +823,8 @@ def propagate_single(self, single):
 
 	    # reuse the old single
 	    # 4. process the changes
-	    single.pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+	    pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+	    single.pid_particle_pair = pid_particle_pair
 
 	    # 6. No logging??
 
@@ -863,7 +864,7 @@ def propagate_single(self, single):
         	single.pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
         	self.update_single_shell(single, newpos, single.pid_particle_pair[1].radius)
 
-		# 5. No new single is made(reuse), rescheduling is done elsewhere
+		# 5. No new single is made(reuse) (scheduling is done later)
 		# 6. Logging is done else?
 
                 return single
@@ -1500,6 +1501,9 @@ def propagate_pair(self, pair):
             newpos1 = pid_particle_pair1[1].position
             newpos2 = pid_particle_pair2[1].position
 
+        pid_particle_pair1 = self.move_particle(pid_particle_pair1, newpos1)
+        pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
+
 
 	# re-use single domains for particles
 	# normally we would take the particles + new positions from the old pair
@@ -1509,6 +1513,9 @@ def propagate_pair(self, pair):
         single2 = pair.single2
         assert single1.domain_id not in self.domains
         assert single2.domain_id not in self.domains
+	single1.pid_particle_pair = pid_particle_pair1	# this is probably redundant
+	single2.pid_particle_pair = pid_particle_pair2
+
 
 	# remove the old domain
         self.remove_domain(pair)
@@ -1516,9 +1523,11 @@ def propagate_pair(self, pair):
 	# 'make' the singles
         single1.initialize(self.t)
         single2.initialize(self.t)
-        self.move_single(single1, newpos1, pid_particle_pair1[1].radius)
-        self.move_single(single2, newpos2, pid_particle_pair2[1].radius)
         
+        self.update_single_shell(single1, newpos1, pid_particle_pair1[1].radius)
+        self.update_single_shell(single2, newpos2, pid_particle_pair2[1].radius)
+
+
         self.domains[single1.domain_id] = single1
         self.domains[single2.domain_id] = single2
 

From 0507f6fbece7472d5538d709dc6e64e0061130a1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 16:44:14 +0200
Subject: [PATCH 0245/1541] better explanation of event processing algorithm

---
 doc/event_processing.tex | 81 ++++++++++++++++++++++++++++++----------
 1 file changed, 62 insertions(+), 19 deletions(-)

diff --git a/doc/event_processing.tex b/doc/event_processing.tex
index 76b4b76d..96f9adc4 100644
--- a/doc/event_processing.tex
+++ b/doc/event_processing.tex
@@ -12,8 +12,8 @@
 -Diffusion in a number of dimensions
 -Decay reactions
 
-When one of the processes in the domain has produced the current event, then a fire_domain is executed. However, when an other
-event external to the domain is the current event but the processes need to be propagated anyhow (a burst), then a burst_domain
+When one of the processes in the domain has produced the current event, then a fire\_domain is executed. However, when an other
+event external to the domain is the current event but the processes need to be propagated anyhow (a burst), then a burst\_domain
 is executed.
 Fire happens when the domain produced the top event of the scheduler. A burst event happens when the event associated with the
 domain is still in the scheduler.
@@ -21,11 +21,11 @@
 Burst->Event is is still in scheduler
 
 
-Fire_Single
+Fire\_Single
 -process event causing coordinate (a coordinate is an independent process in a domain, eg diffusion, decay)
 -process all other coordinates
 
-Burst_Single
+Burst\_Single
 -process all coordinates (event was external)
 
 After a fire or burst the domain is 'reduced' to a default NonInteractionSingle and a new domain (Pair, Interaction,
@@ -41,27 +41,70 @@
 
 
 Processing the event means:
-Test if Single && zero-shell && D != 0 then
-  skip (the single was a special single->zero shell)
-if diffusion == true (D != 0)
-  determine new position(s) of particle(s)
-   -check also if still in shell
-if event is (not Burst, not Escape, Single_Reaction, IV_Reaction, IV_Interaction)
-  get new identity for the resulting particle
-  calculate new position for particles (for example Interaction, Decay reactions)
-apply boundary conditions to new position(s)
-actually move/remove/add the particle (update_world)
+if Single && zero-shell && D != 0 then
+  the single was a 'special' single (zero shell) -> make\_new\_domain
+else
+  the single was a 'normal' domain and event should be processed
 
-determine if we need to make a different domain (for example when bursting an Interaction)
-draw new event time
-reschedule event and domain
+  (calculate new position(s))
+  if (D != 0) && dt>0 (time has passed)
+    (there was actual relevant diffusion)
+    determine new position(s) of particle(s)
+    apply boundary conditions
+    -check if still in shell
+  else
+    (no diffusion has taken place)
+    positions are old position(s)
+
+  (determine identitie(s))
+  if event is Single\_Reaction, IV\_Reaction, IV\_Interaction
+    get new identity for the resulting particle
+    calculate new position for particles (for example Interaction, Decay reactions)
+    apply boundary conditions to new position(s)
+    actually move/remove/add the particle (update\_world)
+
+  else
+    (event was Burst or one of the possible Escape events)
+    positions are 'old' positions
+    particle identities are old identities
+    particle number is old number
+
+    apply boundary conditions to position(s)
+    move particles to new positions (make change in the world)
+
+  (we now have n particles in the world with certain identity and position)
+  (In principle all particles should still be in the domain)
+
+  remove old domain 
+  for all particles
+    create default NonInteractionSingle for particle
+    schedule domain
+    log newly created NonInteractionSingle
+
+
+
+    (we now have n particles with certain identity and position)
+    move particles
+    NonInteractionSingle(s) = cached NonInteractionSingle(s)
+    remove old domain
+    re-initialize time and size of NonInteractionSingle(s)
+    add 
+
+
+
+
+Note that when a Pair or Interaction is made, the shells and domain\_id are removed from the shell container and
+domain hash respectively. This doesn't mean that the objects too have gone. The NonInteractionSingles are subsequently
+cached in the made domain (Pair, Interaction, Multi?). When the made domain is now fired --the event produced by the
+domain is processed-- and the resulting particle has not changed its identity, then the cached domain can be used. The
+shell of the cached domain will recreated in the shell container and its domain\_id will be added to the domains hash.
 
 
 
 Create a Protective Domain:
 -generate identifiers for domain and shell
--make domain object (instantiate with particle, shell dimensions, structure/surface, reaction_rules, misc info)
+-make domain object (instantiate with particle, shell dimensions, structure/surface, reaction\_rules, misc info)
  -make appropriate shell (done by constructor or later in case of Multi)
--place shell in container (move_shell)
+-place shell in container (move\_shell)
 -
 \end{document}

From 30590dc65f62913d91c1808da8bb9c5c97ad5a11 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 17:28:03 +0200
Subject: [PATCH 0246/1541] small changes

---
 egfrd.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c1d8d5fa..8ea00fea 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -532,9 +532,9 @@ def move_particle(self, pid_particle_pair, position):
                                           pid_particle_pair[1].radius,
                                    	  pid_particle_pair[1].D,
                                    	  pid_particle_pair[1].sid))
-#        single.pid_particle_pair = new_pid_particle_pair
 
         self.world.update_particle(new_pid_particle_pair)
+
 	return new_pid_particle_pair
 
     def remove_domain(self, obj):
@@ -865,7 +865,7 @@ def propagate_single(self, single):
         	self.update_single_shell(single, newpos, single.pid_particle_pair[1].radius)
 
 		# 5. No new single is made(reuse) (scheduling is done later)
-		# 6. Logging is done else?
+		# 6. Logging is done elsewhere?
 
                 return single
 

From 96f76c50aae94062b15a19fc4adfec3fd5205c5c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 18:53:16 +0200
Subject: [PATCH 0247/1541] small change

---
 doc/event_processing.tex | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/event_processing.tex b/doc/event_processing.tex
index 96f9adc4..9078f4a0 100644
--- a/doc/event_processing.tex
+++ b/doc/event_processing.tex
@@ -70,6 +70,7 @@
     particle number is old number
 
     apply boundary conditions to position(s)
+    check that particles do not leave domain and do not overlap with other particles
     move particles to new positions (make change in the world)
 
   (we now have n particles in the world with certain identity and position)

From 60f6a7e4c5f353b8430d65a227531b9717b90909 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 18:53:51 +0200
Subject: [PATCH 0248/1541] reworking the event processing method

---
 egfrd.py | 152 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 87 insertions(+), 65 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8ea00fea..d9cb872b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -665,10 +665,11 @@ def fire_single_reaction(self, single):
 	    # 3. No space required
 	    # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(single.pid_particle_pair[0])
+	    products = []
 
 	    # 5. No new single to be made
 	    # 6. Log the change
-            self.last_reaction = (rr, (single.pid_particle_pair[1], None), [])
+            self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
 
             
         elif len(rr.products) == 1:
@@ -691,16 +692,17 @@ def fire_single_reaction(self, single):
 	    # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(single.pid_particle_pair[0])
             newparticle = self.world.new_particle(product_species.id, oldpos)
+	    products = [newparticle]
 
-	    # 5. make new single and schedule
-            newsingle = self.create_single(newparticle)
-            self.add_domain_event(newsingle)
+#	    # 5. make new single and schedule
+#            newsingle = self.create_single(newparticle)
+#            self.add_domain_event(newsingle)
 
 	    # 6. Log the change
-            if __debug__:
-                log.info('product = %s' % newsingle)
+#            if __debug__:
+#                log.info('product = %s' % newsingle)
             self.last_reaction = (rr, (single.pid_particle_pair[1], None),
-                                  [newparticle])
+                                  products)
 
 
             
@@ -763,26 +765,28 @@ def fire_single_reaction(self, single):
             self.world.remove_particle(single.pid_particle_pair[0])
             pid_particle_pair1 = self.world.new_particle(product_species1.id, newpos1)
             pid_particle_pair2 = self.world.new_particle(product_species2.id, newpos2)
+	    products = [pid_particle_pair1, pid_particle_pair2]
 
-
-	    # 5. make new singles and schedule
-            newsingle1 = self.create_single(pid_particle_pair1)
-            newsingle2 = self.create_single(pid_particle_pair2)
-            self.add_domain_event(newsingle1)
-            self.add_domain_event(newsingle2)
+#	    # 5. make new singles and schedule
+#            newsingle1 = self.create_single(pid_particle_pair1)
+#            newsingle2 = self.create_single(pid_particle_pair2)
+#            self.add_domain_event(newsingle1)
+#            self.add_domain_event(newsingle2)
 
 	    # 6. Log the change
-            if __debug__:
-                log.info('product1 = %s\nproduct2 = %s' % 
-                     (newsingle1, newsingle2))
+#            if __debug__:
+#                log.info('product1 = %s\nproduct2 = %s' % 
+#                     (newsingle1, newsingle2))
             self.last_reaction = (rr, (single.pid_particle_pair[1], None),
-                                  [pid_particle_pair1, pid_particle_pair2])
+                                  products)
 
 
         else:
             raise RuntimeError('num products >= 3 not supported.')
 
         self.reaction_events += 1
+	return products
+
 
     def propagate_single(self, single):
         # The difference between a burst and a propagate is that a burst 
@@ -861,7 +865,8 @@ def propagate_single(self, single):
                 single.initialize(self.t)
 
 		# 4. process the changes
-        	single.pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+        	pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+		single.pid_particle_pair = pid_particle_pair
         	self.update_single_shell(single, newpos, single.pid_particle_pair[1].radius)
 
 		# 5. No new single is made(reuse) (scheduling is done later)
@@ -896,65 +901,72 @@ def proc_event_by_single(self, single):
 	    # simulator time
             assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
-	    # FIXME This should be somewhere else, now it doesn't process SINGLE_REACTION
-	    # events.
-            # Handle immobile case (what event has taken place to get here?!).
-            if single.getD() == 0:
-		# The domain has not produced an decay reaction event and is immobile
-		# ->no propagation, no other changes just calculate next reaction time
-	        # and reschedule the single. So this also takes care of the domain making part
-                single.dt, single.event_type = single.determine_next_event() 
-                single.last_time = self.t
-                self.add_domain_event(single)
-                return
 
-            # If the single had a decay reaction.
-            if single.event_type == EventType.SINGLE_REACTION:
-                if __debug__:
-                    log.info('%s' % single.event_type)
-                    log.info('reactant = %s' % single)
+	    pid_particle_pair = single.pid_particle_pair
+            self.remove_domain(single)
 
-                self.single_steps[single.event_type] += 1
-
-		# get the new position
-                single = self.propagate_single(single)
+	    # get the (new) position
+            if single.getD() != 0 and single.dt > 0.0:
+		# If the particle had the possibility to diffuse
+		newpos = single.draw_new_position(single.dt, single.event_type)
+	        newpos = self.world.apply_boundary(newpos)
+	    else:
+		newpos = pid_particle_pair[1].position
 
-                try:
-                    self.remove_domain(single)
-                    self.fire_single_reaction(single)
-                except NoSpace:
-                    self.reject_single_reaction(single)
 
-                return
 
-            # An interaction event is similar to a single reaction.
-            if single.event_type == EventType.IV_INTERACTION:
+            # If the single had a decay reaction.
+            if single.event_type == EventType.SINGLE_REACTION or \
+	       single.event_type == EventType.IV_INTERACTION:
                 if __debug__:
                     log.info('%s' % single.event_type)
                     log.info('reactant = %s' % single)
 
-                self.interaction_steps[single.event_type] += 1
+		if single.event_type == EventType.SINGLE_REACTION:
+                    self.single_steps[single.event_type] += 1
+                    try:
+#                        self.remove_domain(single)
+                        particles = self.fire_single_reaction(single)
+                    except NoSpace:
+                        self.reject_single_reaction(single)	# TODO
 
-		# get the new position
-                single = self.propagate_single(single)
-
-                try:
-                    self.remove_domain(single)
-                    self.fire_single_reaction(single)	# TODO change to smt Interaction specific?!
-                except NoSpace:
-                    self.reject_single_reaction(single)
+		else:
+                    self.interaction_steps[single.event_type] += 1
+                    try:
+#                        self.remove_domain(single)
+                        particles = self.fire_single_reaction(single)	# TODO change to smt Interaction specific?!
+                    except NoSpace:
+                        self.reject_single_reaction(single)
 
-                return
+	    else:
+		# No reactions/Interactions have taken place -> no identity change of the particle
+                if self.world.check_overlap((newpos, pid_particle_pair[1].radius),
+                                            pid_particle_pair[0]):
+                    raise RuntimeError('proc_event_by_single: particle overlap failed.')
+	        particles = [self.move_particle(pid_particle_pair, newpos)]
 
-	    ### 1.2 General case
-	    # There is a non-trivial event time for the domain
-            if single.dt != 0.0:
-                # Propagate this particle to the exit point on the shell.
-                single = self.propagate_single(single)
 
-		# 5. schedule domain
+	    # Make a new domain (reuse) domain for each particle(s)
+	    for pid_particle_pair in particles:
+#	        single.pid_particle_pair = pid_particle_pair	# reuse single
+		single = self.create_single(pid_particle_pair)
 		self.add_domain_event(single)
+		
+
+#		# get the new position
+#                single = self.propagate_single(single)
+
 
+
+#	    ### 1.2 General case
+#	    # There is a non-trivial event time for the domain
+#            if single.dt != 0.0:
+#                # Propagate this particle to the exit point on the shell.
+#                single = self.propagate_single(single)
+#
+#		# 5. schedule domain
+#		self.add_domain_event(single)
+#
 		# 6. Logging?
 
 	return
@@ -967,14 +979,24 @@ def make_new_domain(self, single):
 	# can only make new domain from NonInteractionSingle
 	assert isinstance(single, NonInteractionSingle)
 	
+	# Special case: When D=0, nothing needs to change and only new event
+	# time is drawn
+	# TODO find nicer constructrion than just this if statement
+	if single.getD() == 0:
+            single.dt, single.event_type = single.determine_next_event() 
+            single.last_time = self.t
+            self.add_domain_event(single)
+            return
+
+
+	single_pos = single.pid_particle_pair[1].position
+	single_radius = single.pid_particle_pair[1].radius
+
 	# 2.1
 	# We prefer to make NonInteractionSingles for efficiency.
 	# But if objects (Shells and surfaces) get close enough (closer than
 	# reaction_threshold) we want to try Interaction and/or Pairs
 
-	single_pos = single.pid_particle_pair[1].position
-	single_radius = single.pid_particle_pair[1].radius
-
 	# Check if there are shells with the burst radius (reaction_threshold)
 	# of the particle (intruders). Note that we approximate the reaction_volume
 	# with a sphere (should be cylinder for 2D or 1D particle)

From ede7446939c3acecf5c0b08a99bab0f92a7203ef Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 3 Oct 2011 18:54:44 +0200
Subject: [PATCH 0249/1541] reworking event processing method part 2

---
 egfrd.py | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d9cb872b..bf1782fb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -669,7 +669,7 @@ def fire_single_reaction(self, single):
 
 	    # 5. No new single to be made
 	    # 6. Log the change
-            self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
+#            self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
 
             
         elif len(rr.products) == 1:
@@ -688,11 +688,11 @@ def fire_single_reaction(self, single):
                 if __debug__:
                     log.info('no space for product particle.')
                 raise NoSpace()
-
-	    # 4. process the changes (remove particle, make new ones)
-            self.world.remove_particle(single.pid_particle_pair[0])
-            newparticle = self.world.new_particle(product_species.id, oldpos)
-	    products = [newparticle]
+	    else:
+	        # 4. process the changes (remove particle, make new ones)
+                self.world.remove_particle(single.pid_particle_pair[0])
+                newparticle = self.world.new_particle(product_species.id, oldpos)
+	        products = [newparticle]
 
 #	    # 5. make new single and schedule
 #            newsingle = self.create_single(newparticle)
@@ -701,8 +701,8 @@ def fire_single_reaction(self, single):
 	    # 6. Log the change
 #            if __debug__:
 #                log.info('product = %s' % newsingle)
-            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
-                                  products)
+#            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
+#                                  products)
 
 
             
@@ -777,14 +777,15 @@ def fire_single_reaction(self, single):
 #            if __debug__:
 #                log.info('product1 = %s\nproduct2 = %s' % 
 #                     (newsingle1, newsingle2))
-            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
-                                  products)
+#            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
+#                                  products)
 
 
         else:
             raise RuntimeError('num products >= 3 not supported.')
 
         self.reaction_events += 1
+        self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
 	return products
 
 
@@ -928,7 +929,10 @@ def proc_event_by_single(self, single):
 #                        self.remove_domain(single)
                         particles = self.fire_single_reaction(single)
                     except NoSpace:
-                        self.reject_single_reaction(single)	# TODO
+#                        self.reject_single_reaction(single)	# TODO
+        		if __debug__:
+            		    log.info('single reaction; placing product failed.')
+        		self.rejected_moves += 1
 
 		else:
                     self.interaction_steps[single.event_type] += 1

From 0e3030c5b876a92da262b507e7332367fd32c447 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 4 Oct 2011 12:05:32 +0200
Subject: [PATCH 0250/1541] more notes on the event processing methods

---
 doc/event_processing.tex | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/doc/event_processing.tex b/doc/event_processing.tex
index 9078f4a0..638a553d 100644
--- a/doc/event_processing.tex
+++ b/doc/event_processing.tex
@@ -39,6 +39,34 @@
 A speedup trick for this is to 'save' the original single in the Pair or Interaction domain so that we can potentially reuse
 them when a fire or burst event takes place
 
+In the old code, the processing of the coordinates is dealt with differently. When possible the particles in the domain are
+first 'propagated'. This means that the particles in the domain are propagated to their new positions and that then new
+zero shells are made for the particles. The putative decay reaction is then handled separately after the 'propagation'. In this
+way the processes are modular. Similarly we could perform an interaction reaction after performing the propagation of the particle
+towards the surface.
+Doing a pair reaction however requires a different procedure since the two particles cannot be propagated on top of eachother.
+
+Since the procedures of firing and bursting are similar, the current approach leads to a lot of code duplication. Since we also
+intoduced a great number of new domains with different interactions, the number of combination grow introducing even more code
+duplication.
+To keep the code clear, we chose to generalize the procedure and perform the 'propagation' and 'reaction' steps in one step. In
+this way also the pair reaction fits in the same framework.
+This means that we first calculate the new position(s) of the particle(s) and directly perform the putative identity change. So,
+we do not make new domains after calculating the new positions, but only do this after the putative reaction has taken place.
+
+It is important to note that the reaction can fail because there is no space for the product particles. Currently this is caught
+by an exception (the procedure for the decay reaction fails) and no changes are made to the system. In the new framework we will
+have to handle it differently. We will need to make sure that the positional change still gets processed (the propagation) whereas
+the identity change (the reaction) is not, the identity of the particle(s) stays the same.
+
+A lot of the procedures have to be generalized anyway to facilitate the different dimensions. Also the fire\_pair method needs to
+facilitate a mixed pair and therefore needs to be generalized to avoid code duplication.
+Also the procedures are all very similar and should be easily generalized. This will make the code clearer and easier to understand.
+
+Originally, the pair consists of two singles. These are also used after the propagation and are only removed when a reaction takes
+place. There is in a sence a sort of a cache of the domains from which the pair domain was formed.
+
+
 
 Processing the event means:
 if Single && zero-shell && D != 0 then

From 32fc4e38afebfc00f8a5f86988d5224595f19bba Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 4 Oct 2011 12:06:01 +0200
Subject: [PATCH 0251/1541] small comment for clarification

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index bf1782fb..19b89ef3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -914,7 +914,7 @@ def proc_event_by_single(self, single):
 	    else:
 		newpos = pid_particle_pair[1].position
 
-
+	    # if we would here move the particles and make new shells, then it would be similar to a propagate
 
             # If the single had a decay reaction.
             if single.event_type == EventType.SINGLE_REACTION or \

From 380d5ddba9b5fc2b837e5dd7401dbbc73c313a20 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 4 Oct 2011 18:35:48 +0200
Subject: [PATCH 0252/1541] some small changes to the algorithm

---
 doc/event_processing.tex | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/doc/event_processing.tex b/doc/event_processing.tex
index 638a553d..18b743d6 100644
--- a/doc/event_processing.tex
+++ b/doc/event_processing.tex
@@ -64,7 +64,11 @@
 Also the procedures are all very similar and should be easily generalized. This will make the code clearer and easier to understand.
 
 Originally, the pair consists of two singles. These are also used after the propagation and are only removed when a reaction takes
-place. There is in a sence a sort of a cache of the domains from which the pair domain was formed.
+place. There is in a sence a sort of a cache of the domains from which the pair domain was formed. When the event of the pair is then
+processed we can make use of the cached singles to make the domains for the product particles. In the old structure, the singles
+are also used to draw the decay times for single particles.
+In the new framework we can reuse the singles if the particle identity has not changed, otherwise reuse is not possible. The domains
+are coupled to the particles (their size, structure and reactionrules).
 
 
 
@@ -84,7 +88,11 @@
     (no diffusion has taken place)
     positions are old position(s)
 
+
   (determine identitie(s))
+  remove old domain (domain should be removed because otherwise it interferes with
+  bursting during the 'reaction process'
+
   if event is Single\_Reaction, IV\_Reaction, IV\_Interaction
     get new identity for the resulting particle
     calculate new position for particles (for example Interaction, Decay reactions)
@@ -104,21 +112,16 @@
   (we now have n particles in the world with certain identity and position)
   (In principle all particles should still be in the domain)
 
-  remove old domain 
   for all particles
-    create default NonInteractionSingle for particle
+    if particle\_id is old\_particle\_id
+      NonInteractionSingle = cached NonInteractionSingle
+      re-initialize time and size of NonInteractionSingle(s)
+      add to shell container and domain hash
+      log reused NonInteractionSingle
+    else
+      create default NonInteractionSingle for particle
+      log newly created NonInteractionSingle
     schedule domain
-    log newly created NonInteractionSingle
-
-
-
-    (we now have n particles with certain identity and position)
-    move particles
-    NonInteractionSingle(s) = cached NonInteractionSingle(s)
-    remove old domain
-    re-initialize time and size of NonInteractionSingle(s)
-    add 
-
 
 
 

From 1db1e1966c7535a7b593088fdf542e645b93946b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 4 Oct 2011 18:38:05 +0200
Subject: [PATCH 0253/1541] reworked fire_single_reaction some name changes to
 clarify the meaning of variables fire_single_reaction should know the
 position where the reaction takes place since it also commits the changes to
 the world added some logging reject_single_reaction is now redundant

---
 egfrd.py | 131 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 73 insertions(+), 58 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 19b89ef3..0f28a0b6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -642,17 +642,17 @@ def burst_non_multis(self, domains):
 
         return bursted
 
-    def fire_single_reaction(self, single):
+    def fire_single_reaction(self, single, reactant_pos):
 	# This takes care of the identity change when a single particle decays into
 	# one or a number of other particles
 	# TODO This can also be used when a particle falls off a surface.
 
 
 	# 0. get reactant info
-        oldpos        = single.pid_particle_pair[1].position
-	oldspecies_id = single.pid_particle_pair[1].sid
-        reactant_species_radius = single.pid_particle_pair[1].radius
-        current_structure = single.structure
+	reactant           = single.pid_particle_pair
+#        reactant_pos       = reactant[1].position
+        reactant_radius    = reactant[1].radius
+        reactant_structure = single.structure
         rr = single.reactionrule
 
 	# 1. remove the particle
@@ -664,7 +664,7 @@ def fire_single_reaction(self, single):
 	    # 2. No space required
 	    # 3. No space required
 	    # 4. process the changes (remove particle, make new ones)
-            self.world.remove_particle(single.pid_particle_pair[0])
+            self.world.remove_particle(reactant[0])
 	    products = []
 
 	    # 5. No new single to be made
@@ -677,34 +677,42 @@ def fire_single_reaction(self, single):
             
 	    # 1. get product info
             product_species = self.world.get_species(rr.products[0])
+	    product_radius  = product_species.radius
+
+	    # 1.5 get putative new position of particle
+	    displacement = 0	# TODO for change of structure get displacement
+	    product_pos = reactant_pos + displacement
+	    product_pos = self.world.apply_boundary(product_pos)
 
             # 2. make space for the products.
-            if reactant_species_radius < product_species.radius:
-                self.burst_volume(oldpos, product_species.radius)
+            if displacement != 0.0 or reactant_radius < product_radius:
+                self.burst_volume(product_pos, product_radius)
 
 	    # 3. check that there is space for the products 
-            if self.world.check_overlap((oldpos, product_species.radius),
-                                        single.pid_particle_pair[0]):
+            if self.world.check_overlap((product_pos, product_radius), reactant[0]):
                 if __debug__:
-                    log.info('no space for product particle.')
-                raise NoSpace()
+            	    log.info('single reaction; placing product failed.')
+                products = [reactant]	# no change
+        	self.rejected_moves += 1
+
 	    else:
 	        # 4. process the changes (remove particle, make new ones)
-                self.world.remove_particle(single.pid_particle_pair[0])
-                newparticle = self.world.new_particle(product_species.id, oldpos)
+                self.world.remove_particle(reactant[0])
+                newparticle = self.world.new_particle(product_species.id, product_pos)
 	        products = [newparticle]
 
+		# 5. update counters
+        	self.reaction_events += 1
+        	self.last_reaction = (rr, (reactant[1], None), products)
+
+	        # 6. Log the change
+                if __debug__:
+                     log.info('product (%s) = %s' % (len(products), products))
+
 #	    # 5. make new single and schedule
 #            newsingle = self.create_single(newparticle)
 #            self.add_domain_event(newsingle)
 
-	    # 6. Log the change
-#            if __debug__:
-#                log.info('product = %s' % newsingle)
-#            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
-#                                  products)
-
-
             
         elif len(rr.products) == 2:
 	# TODO (one of the) product particles can live on different structure
@@ -725,11 +733,11 @@ def fire_single_reaction(self, single):
             rad = max(particle_radius12 * (D1 / D12) + particle_radius1,
                       particle_radius12 * (D2 / D12) + particle_radius2)
 
-            self.burst_volume(oldpos, rad)
+            self.burst_volume(reactant_pos, rad)
 
 	    # 3. check that there is space for the products (try different positions if possible)
             for _ in range(self.dissociation_retry_moves):
-                vector = _random_vector(current_structure, particle_radius12 *
+                vector = _random_vector(reactant_structure, particle_radius12 *
                                         MINIMAL_SEPARATION_FACTOR, self.rng)
             
                 # place particles according to the ratio D1:D2
@@ -737,8 +745,8 @@ def fire_single_reaction(self, single):
                 # FIXME: what if D1 == D2 == 0?
 
                 while 1:
-                    newpos1 = oldpos + vector * (D1 / D12)
-                    newpos2 = oldpos - vector * (D2 / D12)
+                    newpos1 = reactant_pos + vector * (D1 / D12)
+                    newpos2 = reactant_pos - vector * (D2 / D12)
                     newpos1 = self.world.apply_boundary(newpos1)
                     newpos2 = self.world.apply_boundary(newpos2)
 
@@ -751,21 +759,31 @@ def fire_single_reaction(self, single):
 
                 # accept the new positions if there is enough space.
                 if(not self.world.check_overlap((newpos1, particle_radius1),
-                                                 single.pid_particle_pair[0])
+                                                 reactant[0])
                    and
                    not self.world.check_overlap((newpos2, particle_radius2),
-                                                 single.pid_particle_pair[0])):
+                                                 reactant[0])):
+		    
+	    	    # 4. process the changes (remove particle, make new ones)
+            	    self.world.remove_particle(reactant[0])
+            	    product1_pair = self.world.new_particle(product_species1.id, newpos1)
+            	    product2_pair = self.world.new_particle(product_species2.id, newpos2)
+	    	    products = [product1_pair, product2_pair]
+
+            	    self.reaction_events += 1
+            	    self.last_reaction = (rr, (reactant[1], None), products)
+
+	    	    # 6. Log the change
+            	    if __debug__:
+                	log.info('products (%s) = %s' % (len(products), products))
+
                     break
             else:
                 if __debug__:
-                    log.info('no space for product particles.')
-                raise NoSpace()
-
-	    # 4. process the changes (remove particle, make new ones)
-            self.world.remove_particle(single.pid_particle_pair[0])
-            pid_particle_pair1 = self.world.new_particle(product_species1.id, newpos1)
-            pid_particle_pair2 = self.world.new_particle(product_species2.id, newpos2)
-	    products = [pid_particle_pair1, pid_particle_pair2]
+            	    log.info('single reaction; placing products failed.')
+		products = [reactant]
+        	self.rejected_moves += 1
+#                raise NoSpace()
 
 #	    # 5. make new singles and schedule
 #            newsingle1 = self.create_single(pid_particle_pair1)
@@ -773,10 +791,6 @@ def fire_single_reaction(self, single):
 #            self.add_domain_event(newsingle1)
 #            self.add_domain_event(newsingle2)
 
-	    # 6. Log the change
-#            if __debug__:
-#                log.info('product1 = %s\nproduct2 = %s' % 
-#                     (newsingle1, newsingle2))
 #            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
 #                                  products)
 
@@ -784,8 +798,6 @@ def fire_single_reaction(self, single):
         else:
             raise RuntimeError('num products >= 3 not supported.')
 
-        self.reaction_events += 1
-        self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
 	return products
 
 
@@ -916,7 +928,7 @@ def proc_event_by_single(self, single):
 
 	    # if we would here move the particles and make new shells, then it would be similar to a propagate
 
-            # If the single had a decay reaction.
+            # If the single had a decay reaction or interaction.
             if single.event_type == EventType.SINGLE_REACTION or \
 	       single.event_type == EventType.IV_INTERACTION:
                 if __debug__:
@@ -925,22 +937,22 @@ def proc_event_by_single(self, single):
 
 		if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1
-                    try:
+#                    try:
 #                        self.remove_domain(single)
-                        particles = self.fire_single_reaction(single)
-                    except NoSpace:
-#                        self.reject_single_reaction(single)	# TODO
-        		if __debug__:
-            		    log.info('single reaction; placing product failed.')
-        		self.rejected_moves += 1
+                    particles = self.fire_single_reaction(single, newpos)
+#                    except NoSpace:
+#                        self.reject_single_reaction(single)
+#        		if __debug__:
+#            		    log.info('single reaction; placing product failed.')
+#        		self.rejected_moves += 1
 
 		else:
                     self.interaction_steps[single.event_type] += 1
-                    try:
+#                    try:
 #                        self.remove_domain(single)
-                        particles = self.fire_single_reaction(single)	# TODO change to smt Interaction specific?!
-                    except NoSpace:
-                        self.reject_single_reaction(single)
+                    particles = self.fire_interaction(single, newpos)	# TODO 
+#                    except NoSpace:
+#                        self.reject_single_reaction(single)
 
 	    else:
 		# No reactions/Interactions have taken place -> no identity change of the particle
@@ -1286,11 +1298,14 @@ def proc_event_by_pair(self, pair):
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
-            try:
-                self.remove_domain(reactingsingle)
-                self.fire_single_reaction(reactingsingle)
-            except NoSpace:
-                self.reject_single_reaction(reactingsingle)
+#            try:
+            self.remove_domain(reactingsingle)
+            particles = self.fire_single_reaction(reactingsingle)
+#            except NoSpace:
+#                self.reject_single_reaction(reactingsingle)
+	    for pid_particle_pair in particles:
+		single = self.create_single(pid_particle_pair)
+		self.add_domain_event(single)
 
         #
         # 2. Pair reaction

From 660eca28753a7656c9900ab91c5180fc6ba88b02 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 4 Oct 2011 19:15:34 +0200
Subject: [PATCH 0254/1541] cleanup old outcommented (unused) code. Also
 commented reject_single_reaction

---
 egfrd.py | 50 +++++++++++++-------------------------------------
 1 file changed, 13 insertions(+), 37 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0f28a0b6..bed73727 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -926,6 +926,7 @@ def proc_event_by_single(self, single):
 	    else:
 		newpos = pid_particle_pair[1].position
 
+	    # newpos now hold the new position of the particle (not yet committed to the world)
 	    # if we would here move the particles and make new shells, then it would be similar to a propagate
 
             # If the single had a decay reaction or interaction.
@@ -937,22 +938,11 @@ def proc_event_by_single(self, single):
 
 		if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1
-#                    try:
-#                        self.remove_domain(single)
                     particles = self.fire_single_reaction(single, newpos)
-#                    except NoSpace:
-#                        self.reject_single_reaction(single)
-#        		if __debug__:
-#            		    log.info('single reaction; placing product failed.')
-#        		self.rejected_moves += 1
 
 		else:
                     self.interaction_steps[single.event_type] += 1
-#                    try:
-#                        self.remove_domain(single)
                     particles = self.fire_interaction(single, newpos)	# TODO 
-#                    except NoSpace:
-#                        self.reject_single_reaction(single)
 
 	    else:
 		# No reactions/Interactions have taken place -> no identity change of the particle
@@ -962,29 +952,15 @@ def proc_event_by_single(self, single):
 	        particles = [self.move_particle(pid_particle_pair, newpos)]
 
 
-	    # Make a new domain (reuse) domain for each particle(s)
+	    # 5. Make a (new) domain (reuse) domain for each particle(s)
+	    #    (Re)schedule the (new) domain
 	    for pid_particle_pair in particles:
 #	        single.pid_particle_pair = pid_particle_pair	# reuse single
 		single = self.create_single(pid_particle_pair)
 		self.add_domain_event(single)
-		
-
-#		# get the new position
-#                single = self.propagate_single(single)
-
-
-
-#	    ### 1.2 General case
-#	    # There is a non-trivial event time for the domain
-#            if single.dt != 0.0:
-#                # Propagate this particle to the exit point on the shell.
-#                single = self.propagate_single(single)
-#
-#		# 5. schedule domain
-#		self.add_domain_event(single)
-#
-		# 6. Logging?
 
+	    # 6. Log change?
+		
 	return
 
 
@@ -1131,14 +1107,14 @@ def make_new_domain(self, single):
 	return domain
 
 
-    def reject_single_reaction(self, single):
-        if __debug__:
-            log.info('single reaction; placing product failed.')
-        self.domains[single.domain_id] = single
-        self.geometrycontainer.move_shell(single.shell_id_shell_pair)
-        self.rejected_moves += 1
-        single.initialize(self.t)
-        self.add_domain_event(single)
+#    def reject_single_reaction(self, single):
+#        if __debug__:
+#            log.info('single reaction; placing product failed.')
+#        self.domains[single.domain_id] = single
+#        self.geometrycontainer.move_shell(single.shell_id_shell_pair)
+#        self.rejected_moves += 1
+#        single.initialize(self.t)
+#        self.add_domain_event(single)
 
     def calculate_simplepair_shell_size(self, single1, single2, burst):
 	assert single1.structure == single2.structure

From c7172fb241d546974ebd1a139512bb567c999ab7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 4 Oct 2011 19:37:02 +0200
Subject: [PATCH 0255/1541] burst_single now also used the proc_event_by_single
 method

---
 egfrd.py | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index bed73727..b83d80ed 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -580,8 +580,8 @@ def burst_domain(self, domain):
 
         if isinstance(domain, Single):
             # TODO. Compare with gfrd.
-            domain = self.burst_single(domain)
-            bursted = [domain, ]
+            domains = self.burst_single(domain)
+            bursted = domains
         elif isinstance(domain, Pair):  # Pair
             single1, single2 = self.burst_pair(domain)
             bursted = [single1, single2]
@@ -898,7 +898,7 @@ def proc_event_by_single(self, single):
 
 	if single.is_reset():
 	### If no event event really happened and just need to make new domain
-	    self.make_new_domain(single)
+	    domains = [self.make_new_domain(single)]
 	    # domain is already scheduled in make_new_domain
 
 	else:
@@ -908,7 +908,7 @@ def proc_event_by_single(self, single):
             # In case nothing is scheduled to happen: do nothing and just reschedule
             if single.dt == numpy.inf:
         	self.add_domain_event(single)
-                return 
+                return [single]
 
             # check that the event time of the single (last_time + dt) is equal to the
 	    # simulator time
@@ -954,14 +954,16 @@ def proc_event_by_single(self, single):
 
 	    # 5. Make a (new) domain (reuse) domain for each particle(s)
 	    #    (Re)schedule the (new) domain
+	    domains = []
 	    for pid_particle_pair in particles:
 #	        single.pid_particle_pair = pid_particle_pair	# reuse single
 		single = self.create_single(pid_particle_pair)
 		self.add_domain_event(single)
+		domains.append(single) 
 
 	    # 6. Log change?
 		
-	return
+	return domains
 
 
     def make_new_domain(self, single):
@@ -1429,8 +1431,9 @@ def burst_single(self, single):
         single.event_type = EventType.BURST
 	self.remove_event(single)
 
-        newsingle = self.propagate_single(single)	# TODO this can now also just be a proc_event_by_single
-	self.add_domain_event(newsingle)
+#        newsingle = self.propagate_single(single)	# TODO this can now also just be a proc_event_by_single
+#	self.add_domain_event(newsingle)
+	newsingles = self.proc_event_by_single(single)
 
 # NOTE Be inefficient for just now and don't reuse the event in the schedules
 #        newpos = newsingle.pid_particle_pair[1].position
@@ -1448,7 +1451,7 @@ def burst_single(self, single):
 #        particle_radius = single.pid_particle_pair[1].radius
 #        assert newsingle.shell.shape.radius == particle_radius
 
-        return newsingle
+        return newsingles
 
     def burst_pair(self, pair):
 	# Sets next event time of 'pair' to current time and event to burst event

From 10e8a7c7182c05798f948b1a146fb5134f813eb3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 11:31:45 +0200
Subject: [PATCH 0256/1541] reverted draw_new_position to the state where the
 position is not in the membrane but next to the membrane

---
 single.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/single.py b/single.py
index c7d10f3a..ac2595dc 100644
--- a/single.py
+++ b/single.py
@@ -598,8 +598,7 @@ def draw_new_position(self, dt, event_type):
 
 
 	    if event_type == EventType.IV_INTERACTION:
-		# also move the particle into the surface
-		z = z_surface - self.pid_particle_pair[1].radius
+		z = z_surface 
 	    elif event_type == EventType.IV_ESCAPE:
 		z = z_not_surface
 	    else:

From f78d6d87407b4eb1bcc9536f1f7a9c509069d5f9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 11:40:00 +0200
Subject: [PATCH 0257/1541] small cleanup of proc_event_by_single

---
 egfrd.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b83d80ed..fd874741 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -901,14 +901,14 @@ def proc_event_by_single(self, single):
 	    domains = [self.make_new_domain(single)]
 	    # domain is already scheduled in make_new_domain
 
-	else:
-	### 1. Process event produced by the single
+	### 1.1 Special cases (shortcuts)
+        # In case nothing is scheduled to happen: do nothing and just reschedule
+        elif single.dt == numpy.inf:
+            self.add_domain_event(single)
+            domains = [single]
 
-	    ### 1.1 Special cases (shortcuts)
-            # In case nothing is scheduled to happen: do nothing and just reschedule
-            if single.dt == numpy.inf:
-        	self.add_domain_event(single)
-                return [single]
+	else:
+	### 1. Process 'normal' event produced by the single
 
             # check that the event time of the single (last_time + dt) is equal to the
 	    # simulator time

From cf0510b8fe357a72eeb491d1471f31987083a981 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 11:42:26 +0200
Subject: [PATCH 0258/1541] name change: proc_event_by_domain ->
 process_domain_event

---
 egfrd.py | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fd874741..15636e90 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -322,7 +322,7 @@ def step(self):
         # Dispatch is a dictionary (hash) of what function to use to fire
         # different classes of shells (see bottom egfrd.py) 
         # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
-        # e.g. "if class is Single, then proc_event_by_single" ~ MW
+        # e.g. "if class is Single, then process_single_event" ~ MW
         for klass, f in self.dispatch:
             if isinstance(domain, klass):
                 f(self, domain)		# fire the correct method for the class (e.g. fire_singel(self, Single))
@@ -833,7 +833,7 @@ def propagate_single(self, single):
         if(single.event_type == EventType.SINGLE_REACTION or
            single.event_type == EventType.IV_INTERACTION):
             # Single reaction or interaction, and not a burst.
-	    # domain is removed in proc_event_by_single.
+	    # domain is removed in process_single_event.
 
 	    # An identity change of the particle needs to take place
 	    # This is done in fire_single_reaction
@@ -887,7 +887,7 @@ def propagate_single(self, single):
 
                 return single
 
-    def proc_event_by_single(self, single):
+    def process_single_event(self, single):
 
 	### log Single event
         if __debug__:
@@ -948,7 +948,7 @@ def proc_event_by_single(self, single):
 		# No reactions/Interactions have taken place -> no identity change of the particle
                 if self.world.check_overlap((newpos, pid_particle_pair[1].radius),
                                             pid_particle_pair[0]):
-                    raise RuntimeError('proc_event_by_single: particle overlap failed.')
+                    raise RuntimeError('process_single_event: particle overlap failed.')
 	        particles = [self.move_particle(pid_particle_pair, newpos)]
 
 
@@ -1223,7 +1223,7 @@ def update_single(self, single):
         single.dt, single.event_type = single.determine_next_event()
         single.last_time = self.t
 
-    def proc_event_by_pair(self, pair):
+    def process_pair_event(self, pair):
         assert self.check_obj(pair)
 
 	# check that the time is the currect simulator time 
@@ -1377,7 +1377,7 @@ def proc_event_by_pair(self, pair):
 
         return
 
-    def proc_event_by_multi(self, multi):
+    def process_multi_event(self, multi):
         self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
         multi.step()
 
@@ -1431,9 +1431,9 @@ def burst_single(self, single):
         single.event_type = EventType.BURST
 	self.remove_event(single)
 
-#        newsingle = self.propagate_single(single)	# TODO this can now also just be a proc_event_by_single
+#        newsingle = self.propagate_single(single)	# TODO this can now also just be a process_single_event
 #	self.add_domain_event(newsingle)
-	newsingles = self.proc_event_by_single(single)
+	newsingles = self.process_single_event(single)
 
 # NOTE Be inefficient for just now and don't reuse the event in the schedules
 #        newpos = newsingle.pid_particle_pair[1].position
@@ -1470,7 +1470,7 @@ def burst_pair(self, pair):
         pair.event_type = EventType.BURST
         self.remove_event(pair)		# remove the event -> was still in the scheduler
 
-        single1, single2 = self.propagate_pair(pair)	# TODO this can now also just be a proc_event_by_pair
+        single1, single2 = self.propagate_pair(pair)	# TODO this can now also just be a process_pair_event
         self.add_domain_event(single1)
         self.add_domain_event(single2)
 
@@ -1574,9 +1574,9 @@ def propagate_pair(self, pair):
 
 	# Log the event
         if __debug__:
-            log.debug("proc_event_by_pair: #1 { %s: %s => %s }" %
+            log.debug("process_pair_event: #1 { %s: %s => %s }" %
                       (single1, str(pos1), str(newpos1)))
-            log.debug("proc_event_by_pair: #2 { %s: %s => %s }" %
+            log.debug("process_pair_event: #2 { %s: %s => %s }" %
                       (single2, str(pos2), str(newpos2)))
 
         return single1, single2
@@ -2272,9 +2272,9 @@ def count_domains(self):
         return (num_singles, num_pairs, num_multis)
 
     dispatch = [
-        (Single, proc_event_by_single),
-        (Pair, proc_event_by_pair),
-        (Multi, proc_event_by_multi)
+        (Single, process_single_event),
+        (Pair, process_pair_event),
+        (Multi, process_multi_event)
         ]
 
 

From f355efa8dc4902ca9fadbdeae27809d5896367a4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 15:43:36 +0200
Subject: [PATCH 0259/1541] small fix

---
 single.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/single.py b/single.py
index ac2595dc..4d715f5a 100644
--- a/single.py
+++ b/single.py
@@ -450,7 +450,7 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell
 							# trying to interact
 
     def get_interaction_rule(self):
-	if self.intrule == []:
+	if self.intrule == None:
 	    self.intrule = self.draw_reaction_rule(self.interactionrules)
 	return self.intrule
     interactionrule = property(get_interaction_rule)

From 0086e2ef06dea3de86abd4a3e3a824c8d6974d5a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 15:44:10 +0200
Subject: [PATCH 0260/1541] propagate_single is now definitely replaced by
 fire_move fire_move is like fire_single_reaction and fire_interaction, but it
 does not do any identity change, but just commits the new position of the
 particle to the world.

---
 egfrd.py | 220 ++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 146 insertions(+), 74 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 15636e90..da50b2ab 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -800,92 +800,169 @@ def fire_single_reaction(self, single, reactant_pos):
 
 	return products
 
+    def fire_interaction(self, single, reactant_pos):
+	# This takes care of the identity change when a particle associates with a surface
 
-    def propagate_single(self, single):
-        # The difference between a burst and a propagate is that a burst 
-        # always takes place before the actual scheduled event for the 
-        # single, while propagate_single can be called for an escape event.
+	# 0. get reactant info
+	reactant        = single.pid_particle_pair
+        reactant_radius    = reactant[1].radius
+        rr = single.interactionrule
 
-        # Another subtle difference is that burst_single always 
-        # reschedules (update_event) the single, while just calling 
-        # propagate does not.  So whoever calls propagate_single 
-        # directly should reschedule the single afterwards.
+	# 1. remove the particle
+#        self.world.remove_particle(single.pid_particle_pair[0])
 
-	pid_particle_pair = single.pid_particle_pair
+        if len(rr.products) == 0:
+            
+	    # 1. No products, no info
+	    # 2. No space required
+	    # 3. No space required
+	    # 4. process the changes (remove particle, make new ones)
+            self.world.remove_particle(reactant[0])
+	    products = []
 
-        if __debug__:
-            log.debug("single.dt=%s, single.last_time=%s, self.t=%s" %
-                      (FORMAT_DOUBLE % single.dt,
-                       FORMAT_DOUBLE % single.last_time,
-                       FORMAT_DOUBLE % self.t))
+	    # 5. No new single to be made
+	    # 6. Log the change
+#            self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
 
-        newpos = single.draw_new_position(single.dt, single.event_type) 
-        newpos = self.world.apply_boundary(newpos)
+            
+        elif len(rr.products) == 1:
+            
+	    # 1. get product info
+            product_species = self.world.get_species(rr.products[0])
+	    product_radius  = product_species.radius
+            product_surface = single.surface
 
-        if __debug__:
-            log.debug("propagate %s: %s => %s" %
-                      (single, pid_particle_pair[1].position, newpos))
+	    # 1.5 get new position of particle
+	    transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
+            product_pos, _ = product_surface.projected_point(transposed_pos)
+	    product_pos = self.world.apply_boundary(product_pos)	# not sure this is still necessary
 
-            if self.world.check_overlap((newpos, pid_particle_pair[1].radius),
-                                        pid_particle_pair[0]):
-                raise RuntimeError('propagate_single: check_overlap failed.')
+            # 2. burst the volume that will contain the products.
+            self.burst_volume(product_pos, product_radius)
 
-        if(single.event_type == EventType.SINGLE_REACTION or
-           single.event_type == EventType.IV_INTERACTION):
-            # Single reaction or interaction, and not a burst.
-	    # domain is removed in process_single_event.
+	    # 3. check that there is space for the products 
+            if self.world.check_overlap((product_pos, product_radius), reactant[0]):
+                if __debug__:
+            	    log.info('interaction; placing product failed.')
+                products = [reactant]	# no change TODO the particle should still be moved!
+        	self.rejected_moves += 1
 
-	    # An identity change of the particle needs to take place
-	    # This is done in fire_single_reaction
+	    else:
+	        # 4. process the changes (remove particle, make new ones)
+                self.world.remove_particle(reactant[0])
+                newparticle = self.world.new_particle(product_species.id, product_pos)
+	        products = [newparticle]
 
-	    # reuse the old single
-	    # 4. process the changes
-	    pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
-	    single.pid_particle_pair = pid_particle_pair
+		# 5. update counters
+        	self.reaction_events += 1
+        	self.last_reaction = (rr, (reactant[1], None), products)
 
-	    # 6. No logging??
+	        # 6. Log the change
+                if __debug__:
+                     log.info('product (%s) = %s' % (len(products), products))
 
-            return single
         else:
-            if isinstance(single, InteractionSingle):
-                # If for an interaction single a single reaction or iv 
-                # interaction occurs, we create a new single and get 
-                # rid of the old interactionSingle in 
-                # fire_single_reaction.
-                # For escapes and bursts of interaction singles we do 
-                # it here.
-
-		# 4. process the changes (actually move the particle)
-                pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+            raise RuntimeError('fire_interaction: num products >= 2 not supported.')
 
-		# remove the old domain
-                self.remove_domain(single)
-
-		# 5. single domain for the particle (scheduling is done later)
-                newsingle = self.create_single(pid_particle_pair)
+	return products
 
-		# 6. Log the changes
-                if __debug__:
-                    log.debug('    *New %s.\n'
-                              '        radius = %.3g. dt = %.3g.' %
-                              (newsingle, newsingle.shell.shape.radius,
-                               newsingle.dt))
-                return newsingle
+    def fire_move(self, single, reactant_pos):
+	# No reactions/Interactions have taken place -> no identity change of the particle
+	# Just only move the particles
 
-            else:
-		# reuse the old single
-		# domain is not removed
-                single.initialize(self.t)
+	reactant = single.pid_particle_pair
 
-		# 4. process the changes
-        	pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
-		single.pid_particle_pair = pid_particle_pair
-        	self.update_single_shell(single, newpos, single.pid_particle_pair[1].radius)
+        if self.world.check_overlap((reactant_pos, reactant[1].radius),
+                                    reactant[0]):
+            raise RuntimeError('fire_move: particle overlap failed.')
+	moved_reactant = self.move_particle(reactant, reactant_pos)
+	return [moved_reactant]
 
-		# 5. No new single is made(reuse) (scheduling is done later)
-		# 6. Logging is done elsewhere?
-
-                return single
+#    def propagate_single(self, single):
+#        # The difference between a burst and a propagate is that a burst 
+#        # always takes place before the actual scheduled event for the 
+#        # single, while propagate_single can be called for an escape event.
+#
+#        # Another subtle difference is that burst_single always 
+#        # reschedules (update_event) the single, while just calling 
+#        # propagate does not.  So whoever calls propagate_single 
+#        # directly should reschedule the single afterwards.
+#
+#	pid_particle_pair = single.pid_particle_pair
+#
+#        if __debug__:
+#            log.debug("single.dt=%s, single.last_time=%s, self.t=%s" %
+#                      (FORMAT_DOUBLE % single.dt,
+#                       FORMAT_DOUBLE % single.last_time,
+#                       FORMAT_DOUBLE % self.t))
+#
+#        newpos = single.draw_new_position(single.dt, single.event_type) 
+#        newpos = self.world.apply_boundary(newpos)
+#
+#        if __debug__:
+#            log.debug("propagate %s: %s => %s" %
+#                      (single, pid_particle_pair[1].position, newpos))
+#
+#            if self.world.check_overlap((newpos, pid_particle_pair[1].radius),
+#                                        pid_particle_pair[0]):
+#                raise RuntimeError('propagate_single: check_overlap failed.')
+#
+#        if(single.event_type == EventType.SINGLE_REACTION or
+#           single.event_type == EventType.IV_INTERACTION):
+#            # Single reaction or interaction, and not a burst.
+#	    # domain is removed in process_single_event.
+#
+#	    # An identity change of the particle needs to take place
+#	    # This is done in fire_single_reaction
+#
+#	    # reuse the old single
+#	    # 4. process the changes
+#	    pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+#	    single.pid_particle_pair = pid_particle_pair
+#
+#	    # 6. No logging??
+#
+#            return single
+#        else:
+#            if isinstance(single, InteractionSingle):
+#                # If for an interaction single a single reaction or iv 
+#                # interaction occurs, we create a new single and get 
+#                # rid of the old interactionSingle in 
+#                # fire_single_reaction.
+#                # For escapes and bursts of interaction singles we do 
+#                # it here.
+#
+#		# 4. process the changes (actually move the particle)
+#                pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+#
+#		# remove the old domain
+#                self.remove_domain(single)
+#
+#		# 5. single domain for the particle (scheduling is done later)
+#                newsingle = self.create_single(pid_particle_pair)
+#
+#		# 6. Log the changes
+#                if __debug__:
+#                    log.debug('    *New %s.\n'
+#                              '        radius = %.3g. dt = %.3g.' %
+#                              (newsingle, newsingle.shell.shape.radius,
+#                               newsingle.dt))
+#                return newsingle
+#
+#            else:
+#		# reuse the old single
+#		# domain is not removed
+#                single.initialize(self.t)
+#
+#		# 4. process the changes
+#        	pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
+#		single.pid_particle_pair = pid_particle_pair
+#        	self.update_single_shell(single, newpos, single.pid_particle_pair[1].radius)
+#
+#		# 5. No new single is made(reuse) (scheduling is done later)
+#		# 6. Logging is done elsewhere?
+#
+#                return single
 
     def process_single_event(self, single):
 
@@ -945,12 +1022,7 @@ def process_single_event(self, single):
                     particles = self.fire_interaction(single, newpos)	# TODO 
 
 	    else:
-		# No reactions/Interactions have taken place -> no identity change of the particle
-                if self.world.check_overlap((newpos, pid_particle_pair[1].radius),
-                                            pid_particle_pair[0]):
-                    raise RuntimeError('process_single_event: particle overlap failed.')
-	        particles = [self.move_particle(pid_particle_pair, newpos)]
-
+		particles = self.fire_move(single, newpos)
 
 	    # 5. Make a (new) domain (reuse) domain for each particle(s)
 	    #    (Re)schedule the (new) domain

From 949cbcc5fde6ae7db908a2dfccaca8d77f8aceff Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 15:56:50 +0200
Subject: [PATCH 0261/1541] bursting for interaction only needed when particle
 becomes larger

---
 egfrd.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index da50b2ab..a4c06c96 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -838,7 +838,10 @@ def fire_interaction(self, single, reactant_pos):
 	    product_pos = self.world.apply_boundary(product_pos)	# not sure this is still necessary
 
             # 2. burst the volume that will contain the products.
-            self.burst_volume(product_pos, product_radius)
+	    #    Note that an interaction domain is already sized such that it includes the
+	    #    reactant particle moving into the surface.
+	    if product_radius > reactant_radius:
+                self.burst_volume(product_pos, product_radius)
 
 	    # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
@@ -862,7 +865,7 @@ def fire_interaction(self, single, reactant_pos):
                      log.info('product (%s) = %s' % (len(products), products))
 
         else:
-            raise RuntimeError('fire_interaction: num products >= 2 not supported.')
+            raise RuntimeError('fire_interaction: num products > 1 not supported.')
 
 	return products
 

From e08123ab641037d2ff18036ebf8a945fd67fa016 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 17:03:03 +0200
Subject: [PATCH 0262/1541] Interaction now works. This is now done with UGLY
 HACK to get the reaction rules The reaction rules cannot be properly defined
 yet, so I take the reaction rules for the interaction from the reaction A + A
 -> B(membrane) to model A + membrane -> B(membrane) The commit also includes
 some small fixes

---
 egfrd.py | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a4c06c96..17b75013 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -399,8 +399,9 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
         # TODO.
-        #interaction_rules = self.network_rules.query_reaction_rule(species_id, surface)
-        interaction_rules = []
+#        interaction_rules = self.network_rules.query_reaction_rule(species_id, surface)
+        interaction_rules = self.network_rules.query_reaction_rule(species_id, species_id)
+#        interaction_rules = []
 
         structure = self.world.get_structure(species.structure_id)
 
@@ -690,11 +691,16 @@ def fire_single_reaction(self, single, reactant_pos):
 
 	    # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
-                if __debug__:
-            	    log.info('single reaction; placing product failed.')
-                products = [reactant]	# no change
+		# 4. Process (the lack of) change
+		moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]	# no change
+
+		# 5. update counters
         	self.rejected_moves += 1
 
+		# 6. Log the event
+                if __debug__:
+            	    log.info('single reaction; placing product failed.')
 	    else:
 	        # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(reactant[0])
@@ -770,6 +776,7 @@ def fire_single_reaction(self, single, reactant_pos):
             	    product2_pair = self.world.new_particle(product_species2.id, newpos2)
 	    	    products = [product1_pair, product2_pair]
 
+		    # 5. update counters
             	    self.reaction_events += 1
             	    self.last_reaction = (rr, (reactant[1], None), products)
 
@@ -781,7 +788,8 @@ def fire_single_reaction(self, single, reactant_pos):
             else:
                 if __debug__:
             	    log.info('single reaction; placing products failed.')
-		products = [reactant]
+		moved_reactant = self.move_particle(reactant, reactant_pos)
+		products = [moved_reactant]
         	self.rejected_moves += 1
 #                raise NoSpace()
 
@@ -847,7 +855,8 @@ def fire_interaction(self, single, reactant_pos):
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
                 if __debug__:
             	    log.info('interaction; placing product failed.')
-                products = [reactant]	# no change TODO the particle should still be moved!
+		moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]	# no change 
         	self.rejected_moves += 1
 
 	    else:
@@ -1009,6 +1018,9 @@ def process_single_event(self, single):
 	    # newpos now hold the new position of the particle (not yet committed to the world)
 	    # if we would here move the particles and make new shells, then it would be similar to a propagate
 
+	    if single.event_type == EventType.IV_EVENT:
+		single.event_type = single.draw_iv_event_type()
+
             # If the single had a decay reaction or interaction.
             if single.event_type == EventType.SINGLE_REACTION or \
 	       single.event_type == EventType.IV_INTERACTION:

From 55e32aa6d5e7ddf3dd81ac0d6705fd2f6384d28d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 17:08:46 +0200
Subject: [PATCH 0263/1541] throw out some outcommented code

---
 egfrd.py | 117 -------------------------------------------------------
 1 file changed, 117 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 17b75013..493da859 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -651,13 +651,11 @@ def fire_single_reaction(self, single, reactant_pos):
 
 	# 0. get reactant info
 	reactant           = single.pid_particle_pair
-#        reactant_pos       = reactant[1].position
         reactant_radius    = reactant[1].radius
         reactant_structure = single.structure
         rr = single.reactionrule
 
 	# 1. remove the particle
-#        self.world.remove_particle(single.pid_particle_pair[0])
 
         if len(rr.products) == 0:
             
@@ -670,7 +668,6 @@ def fire_single_reaction(self, single, reactant_pos):
 
 	    # 5. No new single to be made
 	    # 6. Log the change
-#            self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
 
             
         elif len(rr.products) == 1:
@@ -715,10 +712,6 @@ def fire_single_reaction(self, single, reactant_pos):
                 if __debug__:
                      log.info('product (%s) = %s' % (len(products), products))
 
-#	    # 5. make new single and schedule
-#            newsingle = self.create_single(newparticle)
-#            self.add_domain_event(newsingle)
-
             
         elif len(rr.products) == 2:
 	# TODO (one of the) product particles can live on different structure
@@ -791,17 +784,6 @@ def fire_single_reaction(self, single, reactant_pos):
 		moved_reactant = self.move_particle(reactant, reactant_pos)
 		products = [moved_reactant]
         	self.rejected_moves += 1
-#                raise NoSpace()
-
-#	    # 5. make new singles and schedule
-#            newsingle1 = self.create_single(pid_particle_pair1)
-#            newsingle2 = self.create_single(pid_particle_pair2)
-#            self.add_domain_event(newsingle1)
-#            self.add_domain_event(newsingle2)
-
-#            self.last_reaction = (rr, (single.pid_particle_pair[1], None),
-#                                  products)
-
 
         else:
             raise RuntimeError('num products >= 3 not supported.')
@@ -817,7 +799,6 @@ def fire_interaction(self, single, reactant_pos):
         rr = single.interactionrule
 
 	# 1. remove the particle
-#        self.world.remove_particle(single.pid_particle_pair[0])
 
         if len(rr.products) == 0:
             
@@ -830,7 +811,6 @@ def fire_interaction(self, single, reactant_pos):
 
 	    # 5. No new single to be made
 	    # 6. Log the change
-#            self.last_reaction = (rr, (single.pid_particle_pair[1], None), products)
 
             
         elif len(rr.products) == 1:
@@ -890,91 +870,6 @@ def fire_move(self, single, reactant_pos):
 	moved_reactant = self.move_particle(reactant, reactant_pos)
 	return [moved_reactant]
 
-#    def propagate_single(self, single):
-#        # The difference between a burst and a propagate is that a burst 
-#        # always takes place before the actual scheduled event for the 
-#        # single, while propagate_single can be called for an escape event.
-#
-#        # Another subtle difference is that burst_single always 
-#        # reschedules (update_event) the single, while just calling 
-#        # propagate does not.  So whoever calls propagate_single 
-#        # directly should reschedule the single afterwards.
-#
-#	pid_particle_pair = single.pid_particle_pair
-#
-#        if __debug__:
-#            log.debug("single.dt=%s, single.last_time=%s, self.t=%s" %
-#                      (FORMAT_DOUBLE % single.dt,
-#                       FORMAT_DOUBLE % single.last_time,
-#                       FORMAT_DOUBLE % self.t))
-#
-#        newpos = single.draw_new_position(single.dt, single.event_type) 
-#        newpos = self.world.apply_boundary(newpos)
-#
-#        if __debug__:
-#            log.debug("propagate %s: %s => %s" %
-#                      (single, pid_particle_pair[1].position, newpos))
-#
-#            if self.world.check_overlap((newpos, pid_particle_pair[1].radius),
-#                                        pid_particle_pair[0]):
-#                raise RuntimeError('propagate_single: check_overlap failed.')
-#
-#        if(single.event_type == EventType.SINGLE_REACTION or
-#           single.event_type == EventType.IV_INTERACTION):
-#            # Single reaction or interaction, and not a burst.
-#	    # domain is removed in process_single_event.
-#
-#	    # An identity change of the particle needs to take place
-#	    # This is done in fire_single_reaction
-#
-#	    # reuse the old single
-#	    # 4. process the changes
-#	    pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
-#	    single.pid_particle_pair = pid_particle_pair
-#
-#	    # 6. No logging??
-#
-#            return single
-#        else:
-#            if isinstance(single, InteractionSingle):
-#                # If for an interaction single a single reaction or iv 
-#                # interaction occurs, we create a new single and get 
-#                # rid of the old interactionSingle in 
-#                # fire_single_reaction.
-#                # For escapes and bursts of interaction singles we do 
-#                # it here.
-#
-#		# 4. process the changes (actually move the particle)
-#                pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
-#
-#		# remove the old domain
-#                self.remove_domain(single)
-#
-#		# 5. single domain for the particle (scheduling is done later)
-#                newsingle = self.create_single(pid_particle_pair)
-#
-#		# 6. Log the changes
-#                if __debug__:
-#                    log.debug('    *New %s.\n'
-#                              '        radius = %.3g. dt = %.3g.' %
-#                              (newsingle, newsingle.shell.shape.radius,
-#                               newsingle.dt))
-#                return newsingle
-#
-#            else:
-#		# reuse the old single
-#		# domain is not removed
-#                single.initialize(self.t)
-#
-#		# 4. process the changes
-#        	pid_particle_pair = self.move_particle(pid_particle_pair, newpos)
-#		single.pid_particle_pair = pid_particle_pair
-#        	self.update_single_shell(single, newpos, single.pid_particle_pair[1].radius)
-#
-#		# 5. No new single is made(reuse) (scheduling is done later)
-#		# 6. Logging is done elsewhere?
-#
-#                return single
 
     def process_single_event(self, single):
 
@@ -1196,15 +1091,6 @@ def make_new_domain(self, single):
 	return domain
 
 
-#    def reject_single_reaction(self, single):
-#        if __debug__:
-#            log.info('single reaction; placing product failed.')
-#        self.domains[single.domain_id] = single
-#        self.geometrycontainer.move_shell(single.shell_id_shell_pair)
-#        self.rejected_moves += 1
-#        single.initialize(self.t)
-#        self.add_domain_event(single)
-
     def calculate_simplepair_shell_size(self, single1, single2, burst):
 	assert single1.structure == single2.structure
 
@@ -1363,11 +1249,8 @@ def process_pair_event(self, pair):
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
-#            try:
             self.remove_domain(reactingsingle)
             particles = self.fire_single_reaction(reactingsingle)
-#            except NoSpace:
-#                self.reject_single_reaction(reactingsingle)
 	    for pid_particle_pair in particles:
 		single = self.create_single(pid_particle_pair)
 		self.add_domain_event(single)

From 905b43fd5e3244174abc2d84d19af93151ad417e Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 5 Oct 2011 18:40:50 +0200
Subject: [PATCH 0264/1541] Closer to return distance to surface - function.
 All bindings are done.

---
 Multi.hpp                     |  8 ++++-
 ParticleContainer.hpp         |  3 ++
 Transaction.hpp               | 16 +--------
 World.hpp                     | 63 +++++++++++++++++++++++++++++++++++
 binding/ParticleContainer.hpp |  8 +++++
 5 files changed, 82 insertions(+), 16 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index a1389450..e8f134a9 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -38,6 +38,7 @@ class MultiParticleContainer
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
+    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
     typedef Transaction<traits_type> transaction_type;
     typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
@@ -77,10 +78,15 @@ class MultiParticleContainer
         return world_.get_structure(id);
     }
     
-    structures_range get_structures() const
+    virtual structures_range get_structures() const
     {
         return world_.get_structures();
     }
+    
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
+    {        
+        return world_.get_closest_surface( pos );
+    }
         
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 73493344..c3849ec1 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -26,6 +26,7 @@ class ParticleContainer
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
+    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
     typedef Transaction<traits_type> transaction_type;
     typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
@@ -51,6 +52,8 @@ class ParticleContainer
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
     virtual structures_range get_structures() const = 0;
+    
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const = 0;
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos) = 0;
diff --git a/Transaction.hpp b/Transaction.hpp
index 666d7971..4f5441cc 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -168,22 +168,8 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.get_structures();
     }    
         
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos)
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
     {
-    
-        typedef boost::iterator_range<surface_iterator> base_type;
-        
-        structures_range structures = pc_.get_structures();
-        
-        base_type::size_type size = structures.size();
-
-        boost::shared_ptr<structure_type> structure;
-        
-        /*
-        length_type distance( (*structures)::base_type.distance( pos ) );
-    
-        return structure_id_and_distance_pair( (*structure).id() ,distance );
-        */
         return structure_id_and_distance_pair();
     }
 
diff --git a/World.hpp b/World.hpp
index eda805d4..a7a351b3 100644
--- a/World.hpp
+++ b/World.hpp
@@ -1,6 +1,8 @@
 #ifndef WORLD_HPP
 #define WORLD_HPP
 
+#include <iostream>
+
 #include "ParticleContainerBase.hpp"
 
 #include <map>
@@ -172,6 +174,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
+    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
 
 protected:
     typedef std::map<species_id_type, species_type> species_map;
@@ -283,6 +286,66 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             surface_iterator(structure_map_.end(), surface_second_selector_type()),
             structure_map_.size());
     }
+    
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
+    {        
+        structures_range structures = get_structures();
+        
+        size_type size ( structures.size() );
+        
+        std::cerr << "# = " << size << std::endl;
+        
+        switch(size)
+        {        
+        case 1:
+            return structure_id_and_distance_pair( NULL , 0 );
+        
+        case 2:
+        {
+            surface_iterator structure = structures.begin();
+            std::pair<position_type, length_type> prj_point( (*structure)->projected_point( pos ) );
+            return structure_id_and_distance_pair( (*structure)->id() , prj_point.second );
+        }
+        
+        default:
+            
+            surface_iterator structure = structures.end();
+        
+            while( structure != structures.begin() ); 
+            {
+                std::cerr << "id = " << (*structure)->id() << std::endl;
+                structure--;
+            }
+   
+            structure = structures.end();
+            structure--;
+            surface_iterator ret_structure( structure );
+        
+            std::pair<position_type, length_type> prj_point( (*structure)->projected_point( pos ) );
+        
+            length_type ret_distance( prj_point.second );
+            length_type distance;    
+            
+            std::cerr << "id = " << (*structure)->id() << ", dist = " << ret_distance << std::endl;
+        
+            structure--;
+            while( structure != structures.begin() ); 
+            {
+                distance = (*structure)->projected_point( pos ).second;
+                
+                if( distance < ret_distance )
+                {
+                    ret_distance = distance;
+                    ret_structure = structure;
+                }
+                std::cerr << "id = " << (*structure)->id() << ", dist = " << distance << std::endl;
+                structure--;
+            }
+        
+            return structure_id_and_distance_pair( (*ret_structure)->id() , ret_distance );
+
+        }
+    }
 
     particle_id_set get_particle_ids(species_id_type const& sid) const
     {
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 673e106e..e1985cd7 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -192,6 +192,7 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::transaction_type transaction_type;
     typedef typename wrapped_type::particle_id_pair_generator particle_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
+    typedef typename wrapped_type::structure_id_and_distance_pair structure_id_and_distance_pair;
 
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
@@ -239,6 +240,11 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_structures")();
     }
 
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
+    {
+        return py_wrapper_type::get_override("get_closest_surface")(pos);
+    }
+
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
     {
@@ -339,6 +345,7 @@ inline boost::python::objects::class_base register_particle_container_class(
     using namespace boost::python;
     typedef Timpl impl_type;
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair>();
+    peer::converters::register_tuple_converter<typename impl_type::structure_id_and_distance_pair>();
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair_and_distance>();
 
     particle_id_pair_and_distance_list_converter<typename impl_type::particle_id_pair_and_distance_list>::__register();
@@ -352,6 +359,7 @@ inline boost::python::objects::class_base register_particle_container_class(
             return_internal_reference<>())
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
+        .def("get_closest_surface", pure_virtual(&impl_type::get_closest_surface))
         .def("new_particle", pure_virtual(&impl_type::new_particle))
         .def("update_particle", pure_virtual(&impl_type::update_particle))
         .def("remove_particle", pure_virtual(&impl_type::remove_particle))

From ed78c8886d5f1b1a4bce6ff005bb81fd07286a5a Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 5 Oct 2011 19:51:42 +0200
Subject: [PATCH 0265/1541] World function for returning dist to surface now
 works!

---
 World.hpp | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

diff --git a/World.hpp b/World.hpp
index a7a351b3..92325ea7 100644
--- a/World.hpp
+++ b/World.hpp
@@ -308,28 +308,15 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         
         default:
-            
-            surface_iterator structure = structures.end();
-        
-            while( structure != structures.begin() ); 
-            {
-                std::cerr << "id = " << (*structure)->id() << std::endl;
-                structure--;
-            }
-   
-            structure = structures.end();
-            structure--;
+        {   
+            surface_iterator structure = structures.begin();               
             surface_iterator ret_structure( structure );
-        
-            std::pair<position_type, length_type> prj_point( (*structure)->projected_point( pos ) );
-        
-            length_type ret_distance( prj_point.second );
-            length_type distance;    
-            
-            std::cerr << "id = " << (*structure)->id() << ", dist = " << ret_distance << std::endl;
-        
-            structure--;
-            while( structure != structures.begin() ); 
+                
+            length_type distance;  
+            length_type ret_distance( (*structure)->projected_point( pos ).second );              
+                   
+            structure++;
+            for(size_type i = 2; i < size; i++)
             {
                 distance = (*structure)->projected_point( pos ).second;
                 
@@ -338,12 +325,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
                     ret_distance = distance;
                     ret_structure = structure;
                 }
-                std::cerr << "id = " << (*structure)->id() << ", dist = " << distance << std::endl;
-                structure--;
+                //std::cerr << "id = " << (*structure)->id() << ", dist = " << distance << std::endl;
+                structure++;
             }
         
             return structure_id_and_distance_pair( (*ret_structure)->id() , ret_distance );
-
+        }
+        
         }
     }
 

From 19bac9598ec489772104ada087357424a7b9ab1d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 5 Oct 2011 20:16:42 +0200
Subject: [PATCH 0266/1541] implemented decay reactions from surfaces

---
 egfrd.py | 33 +++++++++++++++++++++++++++------
 1 file changed, 27 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 493da859..326a054f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -410,6 +410,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
     	if isinstance(surface, CylindricalSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
             projected_point, r0 = surface.projected_point(particle_pos)
+	    r0 = abs(r0)
             shell_unit_r = normalize(particle_pos - projected_point)
 
             z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
@@ -676,15 +677,36 @@ def fire_single_reaction(self, single, reactant_pos):
 	    # 1. get product info
             product_species = self.world.get_species(rr.products[0])
 	    product_radius  = product_species.radius
+	    product_structure = self.world.get_structure(product_species.structure_id) 
+
+	    # 1.5 produce a number of new possible positions for the product particle
+	    # TODO make these generators for efficiency
+	    if product_structure != reactant_structure:
+		if isinstance(reactant_structure, PlanarSurface):
+		    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR	# the thickness of the membrane is 0.0
+		    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
+					for direction in [-1,1]]
+
+		elif isinstance(reactant_structure, CylindricalSurface):
+		    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
+		    product_pos_list = []
+		    for _ in range(self.dissociation_retry_moves):
+			unit_vector3D = random_unit_vector()
+			unit_vector2D = normalize(unit_vector3D - numpy.dot(unit_vector3D, reactant_structure.shape.unit_z))
+			vector = reactant_pos + vector_length * unit_vector2D
+			product_pos_list.append(vector)
+		else:
+		    # raise horrible error
+            	    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+	    else:
+	        product_pos_list = [reactant_pos]		# no change of position is required if structure doesn't change
 
-	    # 1.5 get putative new position of particle
-	    displacement = 0	# TODO for change of structure get displacement
-	    product_pos = reactant_pos + displacement
+	    product_pos = product_pos_list[0]			# TODO try alternatives
 	    product_pos = self.world.apply_boundary(product_pos)
 
             # 2. make space for the products.
-            if displacement != 0.0 or reactant_radius < product_radius:
-                self.burst_volume(product_pos, product_radius)
+#            if product_pos != reactant_pos or product_radius > reactant_radius:
+            self.burst_volume(product_pos, product_radius)
 
 	    # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
@@ -1630,7 +1652,6 @@ def try_interaction(self, single, surface):
                            dz_right, min_dz_right))
             return None
 
-
 	### 2. The shell can be made. Now do what's necessary to make it
         # Compute origin, radius and half_length of cylinder.
         origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector

From d0f4b14a66ba7b8c8845425aec9342103fb720f9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 6 Oct 2011 12:02:55 +0200
Subject: [PATCH 0267/1541] if IV_EVENT is determined then remember for domain
 otherwise this may lead to inconsistencies -> May get position according to
 IV_INTERACTION but perform identity change based on IV_ESCAPE

---
 egfrd.py  | 7 +++----
 single.py | 6 ++++--
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 326a054f..a57f7cad 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -410,7 +410,6 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
     	if isinstance(surface, CylindricalSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
             projected_point, r0 = surface.projected_point(particle_pos)
-	    r0 = abs(r0)
             shell_unit_r = normalize(particle_pos - projected_point)
 
             z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
@@ -924,6 +923,9 @@ def process_single_event(self, single):
 	    pid_particle_pair = single.pid_particle_pair
             self.remove_domain(single)
 
+	    if single.event_type == EventType.IV_EVENT:
+		single.event_type = single.draw_iv_event_type()
+
 	    # get the (new) position
             if single.getD() != 0 and single.dt > 0.0:
 		# If the particle had the possibility to diffuse
@@ -935,9 +937,6 @@ def process_single_event(self, single):
 	    # newpos now hold the new position of the particle (not yet committed to the world)
 	    # if we would here move the particles and make new shells, then it would be similar to a propagate
 
-	    if single.event_type == EventType.IV_EVENT:
-		single.event_type = single.draw_iv_event_type()
-
             # If the single had a decay reaction or interaction.
             if single.event_type == EventType.SINGLE_REACTION or \
 	       single.event_type == EventType.IV_INTERACTION:
diff --git a/single.py b/single.py
index 4d715f5a..b92c721f 100644
--- a/single.py
+++ b/single.py
@@ -594,7 +594,8 @@ def draw_new_position(self, dt, event_type):
 
 	    # If the event was not yet fully specified
 	    if event_type == EventType.IV_EVENT:	
-		event_type = self.draw_iv_event_type()
+		self.event_type = self.draw_iv_event_type()
+		event_type = self.event_type
 
 
 	    if event_type == EventType.IV_INTERACTION:
@@ -700,7 +701,8 @@ def draw_new_position(self, dt, event_type):
             # 2) Draw r and theta.
 	    # If the event was not yet fully specified
 	    if event_type == EventType.IV_EVENT:	
-		event_type = self.draw_iv_event_type()
+		self.event_type = self.draw_iv_event_type()
+		event_type = self.event_type
 
             sigma = self.get_inner_sigma()
             a_r = self.get_inner_a()

From 264173699f49c09a3b5ae01e3a27403079be4dc0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 6 Oct 2011 14:39:28 +0200
Subject: [PATCH 0268/1541] small fix to make_new_domain The partners that were
 tried to make a new domain were first only the burst domains Now it takes the
 closest object also if it was not burst in the previous burst round. This
 prevents that a good partner is overlooked (and a pair not formed) because it
 was not burst right before.

---
 egfrd.py | 45 ++++++++++++++++++++++++++-------------------
 1 file changed, 26 insertions(+), 19 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a57f7cad..8a96be45 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -921,11 +921,11 @@ def process_single_event(self, single):
 
 
 	    pid_particle_pair = single.pid_particle_pair
-            self.remove_domain(single)
-
+	    # in case of an interaction domain: determine real event before doing anything
 	    if single.event_type == EventType.IV_EVENT:
 		single.event_type = single.draw_iv_event_type()
 
+
 	    # get the (new) position
             if single.getD() != 0 and single.dt > 0.0:
 		# If the particle had the possibility to diffuse
@@ -937,6 +937,8 @@ def process_single_event(self, single):
 	    # newpos now hold the new position of the particle (not yet committed to the world)
 	    # if we would here move the particles and make new shells, then it would be similar to a propagate
 
+            self.remove_domain(single)
+
             # If the single had a decay reaction or interaction.
             if single.event_type == EventType.SINGLE_REACTION or \
 	       single.event_type == EventType.IV_INTERACTION:
@@ -950,7 +952,7 @@ def process_single_event(self, single):
 
 		else:
                     self.interaction_steps[single.event_type] += 1
-                    particles = self.fire_interaction(single, newpos)	# TODO 
+                    particles = self.fire_interaction(single, newpos)
 
 	    else:
 		particles = self.fire_move(single, newpos)
@@ -1038,8 +1040,11 @@ def make_new_domain(self, single):
 	# zero-shell NonInteractionSingle -> Pair or Multi
 	# Multi -> Multi
 	# Surface -> Interaction
+	closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
+									ignore=[single.domain_id],
+									ignores=[single.structure.id])
 
-	# Potential partners are for now just the bursted domains
+	# TODO Potential partners are for now just the bursted domains
 	partners = burst
 
 	dists = []
@@ -1074,34 +1079,36 @@ def make_new_domain(self, single):
 	multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
 
 	# 2.4 check that the object is a potential partner for an
-	# -Interaction 	(a surface)
 	# -Pair		(a zero dt NonInteractionSingle)
+	# -Interaction 	(a surface)
 	# -Multi	(a zero dt NonInteractionSingle or Multi)
-	if isinstance(closest_domain, NonInteractionSingle) and \
-	   closest_domain.is_reset():
+	if isinstance(closest_obj, NonInteractionSingle) and \
+	   closest_obj.is_reset():
 		pair_horizon = (single_radius + \
-                       closest_domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
-		if domain_distance < pair_horizon:
+                       closest_obj.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
+		if closest_distance < pair_horizon:
 	            # try making a Pair (can still be Mixed Pair or Normal Pair)
-		    domain = self.try_pair (single, closest_domain, rest_domains)
+		    domain = self.try_pair (single, closest_obj)
 		else:
 		    domain = None
 
 	elif isinstance(single, SphericalSingle) and \
-	     surface_distance < domain_distance and \
-	     surface_distance < surface_horizon:
+	     (isinstance(closest_obj, CylindricalSurface) or isinstance(closest_obj, PlanarSurface)) and \
+	     closest_distance < surface_horizon:
+#	     surface_distance < domain_distance and \
+#	     surface_distance < surface_horizon:
 		# try making an Interaction
-		domain = self.try_interaction (single, closest_surface)
+	    domain = self.try_interaction (single, closest_obj)
 	else:
-		domain = None
+	    domain = None
 
 
 	if not domain:
 	    # No Pair or Interaction could be formed
 	    # Now choose between NonInteractionSingle and Multi
 
-	    if domain_distance > multi_horizon and \
-	       surface_distance > multi_horizon:
+	    if closest_distance > multi_horizon: # and \
+#	       surface_distance > multi_horizon:
 	        # just make a normal NonInteractionSingle
 	        self.update_single(single)
 	        self.add_domain_event(single)
@@ -1112,7 +1119,7 @@ def make_new_domain(self, single):
 	return domain
 
 
-    def calculate_simplepair_shell_size(self, single1, single2, burst):
+    def calculate_simplepair_shell_size(self, single1, single2):
 	assert single1.structure == single2.structure
 
 	# 0. Get some necessary information
@@ -1821,7 +1828,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         return dr, dz_left, dz_right
 
 
-    def try_pair(self, single1, single2, burst):
+    def try_pair(self, single1, single2):
         if __debug__:
            log.debug('trying to form Pair(%s, %s)' %
                      (single1.pid_particle_pair, single2.pid_particle_pair))
@@ -1842,7 +1849,7 @@ def try_pair(self, single1, single2, burst):
 #	    shell = self.make_mixedpair_shell (single1, single2)
 	else:
 	    # particles are on the same structure
-	    center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2, burst)
+	    center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
 
 
 	if shell_size:

From da35aa3074dccb0e87b86d983d9068e62c2b0e7c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 6 Oct 2011 18:29:40 +0200
Subject: [PATCH 0269/1541] some namechanges and added some clarifications to
 fire_* methods

---
 egfrd.py | 44 ++++++++++++++++++++++++++++++++------------
 1 file changed, 32 insertions(+), 12 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8a96be45..c90f7320 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -646,8 +646,10 @@ def burst_non_multis(self, domains):
     def fire_single_reaction(self, single, reactant_pos):
 	# This takes care of the identity change when a single particle decays into
 	# one or a number of other particles
-	# TODO This can also be used when a particle falls off a surface.
-
+	# It performs the reactions:
+	# A(any structure) -> 0
+	# A(any structure) -> B(same structure or 3D)
+	# A(any structure) -> B(same structure) + C(same structure or 3D)
 
 	# 0. get reactant info
 	reactant           = single.pid_particle_pair
@@ -681,6 +683,8 @@ def fire_single_reaction(self, single, reactant_pos):
 	    # 1.5 produce a number of new possible positions for the product particle
 	    # TODO make these generators for efficiency
 	    if product_structure != reactant_structure:
+		assert isinstance(product_structure, CuboidalRegion)
+
 		if isinstance(reactant_structure, PlanarSurface):
 		    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR	# the thickness of the membrane is 0.0
 		    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
@@ -695,12 +699,14 @@ def fire_single_reaction(self, single, reactant_pos):
 			vector = reactant_pos + vector_length * unit_vector2D
 			product_pos_list.append(vector)
 		else:
-		    # raise horrible error
+		    # cannot decay from 3D to other structure
             	    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 	    else:
 	        product_pos_list = [reactant_pos]		# no change of position is required if structure doesn't change
 
-	    product_pos = product_pos_list[0]			# TODO try alternatives
+
+	    # TODO try alternatives if surrounding is crowded
+	    product_pos = product_pos_list[0]
 	    product_pos = self.world.apply_boundary(product_pos)
 
             # 2. make space for the products.
@@ -738,15 +744,17 @@ def fire_single_reaction(self, single, reactant_pos):
 	# TODO (one of the) product particles can live on different structure
 
 	    # 1. get product info
-            product_species1 = self.world.get_species(rr.products[0])
-            product_species2 = self.world.get_species(rr.products[1])
+            product1_species = self.world.get_species(rr.products[0])
+            product2_species = self.world.get_species(rr.products[1])
+	    product1_structure = self.world.get_structure(product1_species.structure_id) 
+	    product2_structure = self.world.get_structure(product2_species.structure_id) 
             
-            D1 = product_species1.D
-            D2 = product_species2.D
+            D1 = product1_species.D
+            D2 = product2_species.D
             D12 = D1 + D2
             
-            particle_radius1 = product_species1.radius
-            particle_radius2 = product_species2.radius
+            particle_radius1 = product1_species.radius
+            particle_radius2 = product2_species.radius
             particle_radius12 = particle_radius1 + particle_radius2
 
             # 2. make space for the products.
@@ -786,8 +794,8 @@ def fire_single_reaction(self, single, reactant_pos):
 		    
 	    	    # 4. process the changes (remove particle, make new ones)
             	    self.world.remove_particle(reactant[0])
-            	    product1_pair = self.world.new_particle(product_species1.id, newpos1)
-            	    product2_pair = self.world.new_particle(product_species2.id, newpos2)
+            	    product1_pair = self.world.new_particle(product1_species.id, newpos1)
+            	    product2_pair = self.world.new_particle(product2_species.id, newpos2)
 	    	    products = [product1_pair, product2_pair]
 
 		    # 5. update counters
@@ -813,6 +821,9 @@ def fire_single_reaction(self, single, reactant_pos):
 
     def fire_interaction(self, single, reactant_pos):
 	# This takes care of the identity change when a particle associates with a surface
+	# It performs the reactions:
+	# A(3D) + surface -> 0
+	# A(3D) + surface -> B(surface)
 
 	# 0. get reactant info
 	reactant        = single.pid_particle_pair
@@ -879,6 +890,15 @@ def fire_interaction(self, single, reactant_pos):
 
 	return products
 
+
+    def fire_pair_reaction(self, pair):
+	# This takes care of the identity change when two particles react with each other
+	# It performs the reactions:
+	# A(any structure) + B(same structure) -> 0
+	# A(any structure) + B(same structure or 3D) -> C(same structure)
+	pass
+
+
     def fire_move(self, single, reactant_pos):
 	# No reactions/Interactions have taken place -> no identity change of the particle
 	# Just only move the particles

From 4643b2216a828a2db42916e08ed9779347ba55f0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 6 Oct 2011 19:33:53 +0200
Subject: [PATCH 0270/1541] cleanup of two particle placements at
 fire_single_reaction

---
 egfrd.py | 55 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 29 insertions(+), 26 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c90f7320..c6f47887 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -753,43 +753,46 @@ def fire_single_reaction(self, single, reactant_pos):
             D2 = product2_species.D
             D12 = D1 + D2
             
-            particle_radius1 = product1_species.radius
-            particle_radius2 = product2_species.radius
-            particle_radius12 = particle_radius1 + particle_radius2
+            product1_radius = product1_species.radius
+            product2_radius = product2_species.radius
+            particle_radius12 = product1_radius + product2_radius
+
+            # calculate the displace of the particles according to the ratio D1:D2
+            # this way, species with small D only have small displacement from the reaction point.
+	    if D1 == D2:
+	    # special case (this should also catch D1==D2==0.0)
+		product1_displacement = particle_radius12 * 0.5
+		product2_displacement = particle_radius12 * 0.5
+	    else:
+	        product1_displacement = particle_radius12 * (D1 / D12)
+	        product2_displacement = particle_radius12 * (D2 / D12)
 
-            # 2. make space for the products.
-            rad = max(particle_radius12 * (D1 / D12) + particle_radius1,
-                      particle_radius12 * (D2 / D12) + particle_radius2)
+	    product1_displacement *= MINIMAL_SEPARATION_FACTOR
+	    product2_displacement *= MINIMAL_SEPARATION_FACTOR
 
+            # 2. make space for the products. 
+	    #    calculate the sphere around the two product particles
+            rad = max(product1_displacement + product1_radius,
+                      product2_displacement + product2_radius)
             self.burst_volume(reactant_pos, rad)
 
 	    # 3. check that there is space for the products (try different positions if possible)
             for _ in range(self.dissociation_retry_moves):
-                vector = _random_vector(reactant_structure, particle_radius12 *
-                                        MINIMAL_SEPARATION_FACTOR, self.rng)
+		# calculate a random vector in the structure with unit length
+                orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
             
-                # place particles according to the ratio D1:D2
-                # this way, species with D=0 doesn't move.
-                # FIXME: what if D1 == D2 == 0?
-
-                while 1:
-                    newpos1 = reactant_pos + vector * (D1 / D12)
-                    newpos2 = reactant_pos - vector * (D2 / D12)
-                    newpos1 = self.world.apply_boundary(newpos1)
-                    newpos2 = self.world.apply_boundary(newpos2)
-
-                    if(self.world.distance(newpos1, newpos2) >= 
-                       particle_radius12):
-                        break
-
-                    vector *= 1.0 + 1e-7
+		newpos1 = reactant_pos + product1_displacement * orientation_vector
+		newpos2 = reactant_pos - product2_displacement * orientation_vector
+                newpos1 = self.world.apply_boundary(newpos1)
+                newpos2 = self.world.apply_boundary(newpos2)
 
+                assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
 
                 # accept the new positions if there is enough space.
-                if(not self.world.check_overlap((newpos1, particle_radius1),
+                if(not self.world.check_overlap((newpos1, product1_radius),
                                                  reactant[0])
                    and
-                   not self.world.check_overlap((newpos2, particle_radius2),
+                   not self.world.check_overlap((newpos2, product2_radius),
                                                  reactant[0])):
 		    
 	    	    # 4. process the changes (remove particle, make new ones)
@@ -1298,7 +1301,7 @@ def process_pair_event(self, pair):
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
             self.remove_domain(reactingsingle)
-            particles = self.fire_single_reaction(reactingsingle)
+            particles = self.fire_single_reaction(reactingsingle, reactingsingle.pid_particle_pair[1].position)
 	    for pid_particle_pair in particles:
 		single = self.create_single(pid_particle_pair)
 		self.add_domain_event(single)

From 65dc0327e7a7a61fdc4ccd4b52ac139200c7e9b0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 7 Oct 2011 19:28:49 +0200
Subject: [PATCH 0271/1541] implemented decay reaction from 2D particle to 2D
 and 3D particle Also changed implementation of decay reaction where both
 particles remain on the same structure. Should be made more efficient ->
 generators or functions Now too many random numbers are being drawn.

---
 egfrd.py | 140 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 110 insertions(+), 30 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c6f47887..c9f221e8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -688,7 +688,7 @@ def fire_single_reaction(self, single, reactant_pos):
 		if isinstance(reactant_structure, PlanarSurface):
 		    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR	# the thickness of the membrane is 0.0
 		    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
-					for direction in [-1,1]]
+					for direction in [-1,1]]	# FIXME the direction should be randomized
 
 		elif isinstance(reactant_structure, CylindricalSurface):
 		    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
@@ -751,7 +751,6 @@ def fire_single_reaction(self, single, reactant_pos):
             
             D1 = product1_species.D
             D2 = product2_species.D
-            D12 = D1 + D2
             
             product1_radius = product1_species.radius
             product2_radius = product2_species.radius
@@ -764,50 +763,131 @@ def fire_single_reaction(self, single, reactant_pos):
 		product1_displacement = particle_radius12 * 0.5
 		product2_displacement = particle_radius12 * 0.5
 	    else:
+                D12 = D1 + D2
 	        product1_displacement = particle_radius12 * (D1 / D12)
 	        product2_displacement = particle_radius12 * (D2 / D12)
 
 	    product1_displacement *= MINIMAL_SEPARATION_FACTOR
 	    product2_displacement *= MINIMAL_SEPARATION_FACTOR
 
+
+	    if product1_structure != product2_structure:
+		# make sure that the reactant was on a 2D or 1D surface
+		assert not isinstance(reactant_structure, CuboidalRegion)
+		# make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
+		assert (isinstance(product1_structure, CuboidalRegion) ^ isinstance(product2_structure, CuboidalRegion))
+
+		# figure out which product stays in the surface and which one goes to 3D
+		if isinstance(product2_structure, CuboidalRegion):
+		    # product2 goes to 3D and is now particleB (product1 is particleA)
+		    productA_displacement = product1_displacement
+		    productB_displacement = product2_displacement
+		    productB_radius = product2_radius
+		    default = True	# we like to think of this as the default
+		else:
+		    # product1 goes to 3D and is now particleB (product2 is particleA)
+		    productA_displacement = product2_displacement
+		    productB_displacement = product1_displacement
+		    productB_radius = product1_radius
+		    default = False
+		# Note that A is a particle in the surface and B is in the 3D
+
+		if isinstance(reactant_structure, PlanarSurface):
+
+		    # draw a number of new positions for the two product particles
+		    # TODO make this into a generator
+		    phi_min = math.asin (productB_radius / particle_radius12)	# we assume the membrane to have zero thickness
+		    phi_min *= MINIMAL_SEPARATION_FACTOR	# make sure that there's some distance from the membrane
+
+		    product_pos_list = []
+		    for _ in range(self.dissociation_retry_moves):
+			# draw the random angle for the 3D particle relative to the particle left in the membrane
+			# not all angles are available because particle cannot intersect with the membrane
+		        phi = myrandom.uniform(phi_min, Pi - phi_min)
+
+		        cos_phi = math.cos(phi) 
+			sin_phi = math.sin(phi)
+
+		        productA_displacement_xy = productA_displacement * cos_phi
+		        productB_displacement_xy = productB_displacement * cos_phi
+			productB_displacement_z  = particle_radius12 * sin_phi
+
+			# pick a random orientation
+			orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
+			# pick a random side of the membrane
+			orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+
+			newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
+			newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
+						 productB_displacement_z  * orientation_vector_z
+                        newposA = self.world.apply_boundary(newposA)
+                        newposB = self.world.apply_boundary(newposB)
+
+                        assert (self.world.distance(newposA, newposB) >= particle_radius12)
+			assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
+
+			if default:
+			    newpos1, newpos2 = newposA, newposB
+			else:
+			    newpos1, newpos2 = newposB, newposA
+
+			product_pos_list.append((newpos1, newpos2))
+
+		elif isinstance(reactant_structure, CylindricalSurface):
+
+		    # TODO
+		    surface_displace = product3D_radius + reactant_structure.shape.radius
+
+		else:
+		    # cannot decay from 3D to other structure
+            	    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+
+	    else:
+		# The two particles stay on the same structure.
+
+		# generate new positions in the structure
+	        # TODO Make this into a generator
+		product_pos_list = []
+                for _ in range(self.dissociation_retry_moves):
+		    # calculate a random vector in the structure with unit length
+		    # FIXME for particles on the cylinder there are only two possibilities
+                    orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
+            
+		    newpos1 = reactant_pos + product1_displacement * orientation_vector
+		    newpos2 = reactant_pos - product2_displacement * orientation_vector
+                    newpos1 = self.world.apply_boundary(newpos1)
+                    newpos2 = self.world.apply_boundary(newpos2)
+
+                    assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
+		    product_pos_list.append((newpos1, newpos2))
+
             # 2. make space for the products. 
+	    # TODO
 	    #    calculate the sphere around the two product particles
             rad = max(product1_displacement + product1_radius,
                       product2_displacement + product2_radius)
             self.burst_volume(reactant_pos, rad)
 
 	    # 3. check that there is space for the products (try different positions if possible)
-            for _ in range(self.dissociation_retry_moves):
-		# calculate a random vector in the structure with unit length
-                orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
-            
-		newpos1 = reactant_pos + product1_displacement * orientation_vector
-		newpos2 = reactant_pos - product2_displacement * orientation_vector
-                newpos1 = self.world.apply_boundary(newpos1)
-                newpos2 = self.world.apply_boundary(newpos2)
-
-                assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
-
-                # accept the new positions if there is enough space.
-                if(not self.world.check_overlap((newpos1, product1_radius),
-                                                 reactant[0])
+            # accept the new positions if there is enough space.
+	    for newpos1, newpos2 in product_pos_list:
+                if (not self.world.check_overlap((newpos1, product1_radius), reactant[0])
                    and
-                   not self.world.check_overlap((newpos2, product2_radius),
-                                                 reactant[0])):
+                   not self.world.check_overlap((newpos2, product2_radius), reactant[0])):
 		    
 	    	    # 4. process the changes (remove particle, make new ones)
-            	    self.world.remove_particle(reactant[0])
-            	    product1_pair = self.world.new_particle(product1_species.id, newpos1)
-            	    product2_pair = self.world.new_particle(product2_species.id, newpos2)
-	    	    products = [product1_pair, product2_pair]
-
-		    # 5. update counters
-            	    self.reaction_events += 1
-            	    self.last_reaction = (rr, (reactant[1], None), products)
-
-	    	    # 6. Log the change
-            	    if __debug__:
-                	log.info('products (%s) = %s' % (len(products), products))
+                    self.world.remove_particle(reactant[0])
+                    product1_pair = self.world.new_particle(product1_species.id, newpos1)
+                    product2_pair = self.world.new_particle(product2_species.id, newpos2)
+	            products = [product1_pair, product2_pair]
+
+	            # 5. update counters
+                    self.reaction_events += 1
+                    self.last_reaction = (rr, (reactant[1], None), products)
+
+	            # 6. Log the change
+                    if __debug__:
+                        log.info('products (%s) = %s' % (len(products), products))
 
                     break
             else:

From c6c927886bc8e70b6da204fab1e9d3634e9acea3 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 7 Oct 2011 19:30:15 +0200
Subject: [PATCH 0272/1541] Included proper distance function in structure
 class. Working on newBDPropagator.

---
 Region.hpp          |   8 +-
 Structure.hpp       |   2 +
 Surface.hpp         |   8 +-
 World.hpp           |  20 ++---
 newBDPropagator.hpp | 174 +++++++++++++++++++++++++++++++++++++++-----
 5 files changed, 179 insertions(+), 33 deletions(-)

diff --git a/Region.hpp b/Region.hpp
index a9a211b9..d34a595f 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -75,11 +75,15 @@ class BasicRegionImpl: public Region<Ttraits_>
         return out.str();
     }
 
-    std::pair<position_type, length_type>
-    projected_point(position_type const& pos) const
+    virtual std::pair<position_type, length_type> projected_point(position_type const& pos) const
     {
         return ::projected_point(shape(), pos);
     }
+    
+    virtual length_type distance(position_type const& pos) const
+    {
+        return ::distance(shape(), pos);
+    }
 
     BasicRegionImpl(identifier_type const& id, shape_type const& shape)
         : base_type(id), shape_(shape) {}
diff --git a/Structure.hpp b/Structure.hpp
index 5bcadb0f..c71a558e 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -60,6 +60,8 @@ class Structure
     virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const = 0;
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
+    
+    virtual length_type distance(position_type const& pos) const = 0;
 
     virtual std::size_t hash() const
     {
diff --git a/Surface.hpp b/Surface.hpp
index d653fbff..8615d1cc 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -81,11 +81,15 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return out.str();
     }
 
-    projected_type
-    projected_point(position_type const& pos) const
+    virtual projected_type projected_point(position_type const& pos) const
     {
         return ::projected_point(shape(), pos);
     }
+    
+    virtual length_type distance(position_type const& pos) const
+    {
+        return ::distance(shape(), pos);
+    }
 
     BasicSurfaceImpl(identifier_type const& id, shape_type const& shape)
         : base_type(id), shape_(shape) {}
diff --git a/World.hpp b/World.hpp
index 92325ea7..f4068ab2 100644
--- a/World.hpp
+++ b/World.hpp
@@ -292,19 +292,19 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         structures_range structures = get_structures();
         
         size_type size ( structures.size() );
-        
-        std::cerr << "# = " << size << std::endl;
-        
+                
         switch(size)
-        {        
+        {
+        case 0:
+            throw not_found(std::string("No structures found."));
+                 
         case 1:
-            return structure_id_and_distance_pair( NULL , 0 );
+            return structure_id_and_distance_pair( NULL , 2*base_type::world_size() );
         
         case 2:
         {
             surface_iterator structure = structures.begin();
-            std::pair<position_type, length_type> prj_point( (*structure)->projected_point( pos ) );
-            return structure_id_and_distance_pair( (*structure)->id() , prj_point.second );
+            return structure_id_and_distance_pair( (*structure)->id() , (*structure)->distance( pos ) );
         }
         
         default:
@@ -312,13 +312,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             surface_iterator structure = structures.begin();               
             surface_iterator ret_structure( structure );
                 
-            length_type distance;  
-            length_type ret_distance( (*structure)->projected_point( pos ).second );              
+            length_type distance;            
+            length_type ret_distance( (*structure)->distance( pos ) );              
                    
             structure++;
             for(size_type i = 2; i < size; i++)
             {
-                distance = (*structure)->projected_point( pos ).second;
+                distance = (*structure)->distance( pos );
                 
                 if( distance < ret_distance )
                 {
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index c601f0d8..98ce89d6 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -36,11 +36,13 @@ class newBDPropagator
     typedef typename particle_container_type::particle_id_type particle_id_type;
     typedef typename particle_container_type::particle_type particle_type;
     typedef typename particle_container_type::particle_id_pair particle_id_pair;
+    typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
     typedef std::vector<particle_id_type> particle_id_vector_type;
     typedef typename particle_container_type::particle_id_pair_generator particle_id_pair_generator;
     typedef typename particle_container_type::particle_id_pair_and_distance particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
     typedef typename particle_container_type::structure_type structure_type;
+    typedef typename particle_container_type::structure_id_type structure_id_type;    
     typedef typename traits_type::world_type::traits_type::rng_type rng_type;
     typedef typename traits_type::time_type time_type;
     typedef typename traits_type::network_rules_type network_rules_type;
@@ -84,10 +86,13 @@ class newBDPropagator
 
         LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
 
+        /* Consider decay reactions first. Particles can move after decay, but this is done
+           inside the 'attempt_reaction' function; for this particle can only react once . */
+        bool pp_reaction = false;
         try
         {
             if (attempt_reaction(pp))
-                return true;
+                pp_reaction = true;
         }
         catch (propagation_error const& reason)
         {
@@ -107,10 +112,11 @@ class newBDPropagator
         position_type const new_pos(tx_.apply_boundary( add( pp.second.position(), displacement ) ));
 
 	    /*Use a spherical shape with radius = particle_radius + reaction_length.
-	      We use it to check for overlaps with other particels (and surfaces).*/
+	      We use it to check for overlaps with other particels and surfaces.*/
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
             tx_.check_overlap(particle_shape_type( new_pos, species.radius() + reaction_length_ ), pp.first));
-                     
+                  
+        bool bounced = false;      
         switch (overlapped ? overlapped->size(): 0)
         {
         case 0:
@@ -121,19 +127,23 @@ class newBDPropagator
             particle_id_pair_and_distance const& closest(overlapped->at(0));
             length_type r01( pp.second.radius() + closest.first.second.radius() );
             
-            /* If the particle cores overlapped, the move is rejected but the particles can still react. */
+            /* If the particle cores overlapped, the move is rejected (bounced) but the particles can still react. */
 		    if( closest.second < pp.second.radius() )
             {
+                bounced = true;
+            
                 LOG_DEBUG(("Hard core collision with a particle %s. Particle bounced", boost::lexical_cast<std::string>(closest.first.first).c_str()));
 		        ++rejected_move_count_;
 
-                /* If the particle was outside the reaction volume before the move, nothing is to be done for this particle => return*/
+                /* If the particle was outside the reaction volume before the move, nothing is to be done for this particle => break*/
                 if(tx_.distance( pp.second.position(), closest.first.second.position() ) > r01 + reaction_length_ )
-    		        return true;
+    		        break;
     		        
     		    try
                 {
-                    if (!attempt_reaction(pp, closest.first))
+                    if( attempt_reaction(pp, closest.first) )
+                        return true;
+                    else                
                     {
                         LOG_DEBUG(("Bounced particle attempted a reaction with a nonreactive particle %s.", boost::lexical_cast<std::string>(closest.first.first).c_str()));
                         ++rejected_move_count_;
@@ -144,8 +154,8 @@ class newBDPropagator
                     log_.info("second-order reaction rejected (reason: %s)", reason.what());
                     ++rejected_move_count_;
                 }
-                /* reject the move even if the reaction has not occurred */    
-                return true;
+                /* If no reaction has occurred */    
+                break;
             }
             else
             {
@@ -172,21 +182,48 @@ class newBDPropagator
             return true;
         }
         
-        particle_id_pair particle_to_update( pp.first, 
-                    particle_type(species.id(), particle_shape_type(new_pos, species.radius()), species.D()) );
-                
-        if (vc_)
+        //Check for overlap with nearest surface.
+        structure_id_and_distance_pair str_id_distance( tx_.get_closest_surface( new_pos ) );
+        
+        //If surface is within reaction volume, check for reactions
+        if( str_id_distance.second < ( pp.second.radius() + reaction_length_ ) )
         {
-            if (!(*vc_)(particle_to_update.second.shape(), particle_to_update.first))
+            if
+            
+            try
+            {
+                if (attempt_reaction(pp, str_id_distance.first))
+                    return true;
+            }
+            catch (propagation_error const& reason)
             {
-                log_.info("propagation move rejected.");
+                log_.info("surface interaction rejected (reason: %s)", reason.what());
+                ++rejected_move_count_;
                 return true;
             }
+            bounced = true;
         }
+        
+        //if the particle did not bounce, update to new position.
+        if(!bounced)
+        {
                 
-        tx_.update_particle(particle_to_update);
-        return true;
-    }
+            particle_id_pair particle_to_update( pp.first, 
+                        particle_type(species.id(), particle_shape_type(new_pos, species.radius()), species.D()) );
+                
+            if (vc_)
+            {
+                if (!(*vc_)(particle_to_update.second.shape(), particle_to_update.first))
+                {
+                    log_.info("propagation move rejected.");
+                    return true;
+                }
+            }
+                
+            tx_.update_particle(particle_to_update);
+        }
+
+        return true
 
     std::size_t get_rejected_move_count() const
     {
@@ -334,7 +371,6 @@ class newBDPropagator
 
         const species_type s0(tx_.get_species(pp0.second.sid())),
                 s1(tx_.get_species(pp1.second.sid()));
-        //length_type r01(s0.radius() + s1.radius());
 
         const Real rnd(rng_());
         Real prob = 0;
@@ -425,7 +461,107 @@ class newBDPropagator
         }
         return false;
     }
+    
+    /*
+    bool attempt_reaction(particle_id_pair const& pp, structure_id_type const& structure_id)
+    {
+        reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), structure_id));
+        if (::size(rules) == 0)
+        {
+            return false;
+        }
+
+        const species_type s0(tx_.get_species(pp0.second.sid()));
+
+        const Real rnd(rng_());
+        Real prob = 0;
+
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            reaction_rule_type const& r(*i);
+
+            boost::shared_ptr<structure_type> pp_structure( 
+               tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
+
+            const Real p( r.k() * dt_ / pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) );
+            BOOST_ASSERT(p >= 0.);
+            prob += p;
+            if (prob >= 1.)
+            {
+                throw propagation_error(
+                    "invalid acceptance ratio ("
+                    + boost::lexical_cast<std::string>(p)
+                    + ") for reaction rate "
+                    + boost::lexical_cast<std::string>(r.k())
+                    + ".");
+            }
+            if (prob > rnd)
+            {
+                LOG_DEBUG(("fire reaction"));
+                const typename reaction_rule_type::species_id_range products(
+                    r.get_products());
 
+                switch (::size(products))
+                {
+                case 1:
+                    {
+                        const species_id_type product(products[0]);
+                        const species_type sp(tx_.get_species(product));
+
+                        const position_type new_pos(
+                            tx_.apply_boundary(
+                                divide(
+                                    add(multiply(pp0.second.position(), s1.D()),
+                                        multiply(tx_.cyclic_transpose(
+                                            pp1.second.position(),
+                                            pp0.second.position()), s0.D())),
+                                    (s0.D() + s1.D()))));
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+                            tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
+                                              pp0.first, pp1.first));
+                        if (overlapped && overlapped->size() > 0)
+                        {
+                            throw propagation_error("no space");
+                        }
+
+                        if (vc_)
+                        {
+                            if (!(*vc_)(
+                                    particle_shape_type(new_pos, sp.radius()), 
+                                    pp0.first, pp1.first))
+                            {
+                                throw propagation_error("no space");
+                            }
+                        }
+
+                        remove_particle(pp.first);
+                        particle_id_pair npp(tx_.new_particle(product, new_pos));
+                        if (rrec_)
+                        {
+                            (*rrec_)(
+                                reaction_record_type(
+                                    r.id(), array_gen(npp.first), pp0.first, pp1.first));
+                        }
+                        break;
+                    }
+                case 0:
+                    {
+                        remove_particle(pp.first);
+                        break;
+                    }
+                
+                default:
+                    throw not_implemented("surface interactions that produce more than one product are not supported");
+                }
+
+                return true;
+            }
+        }
+        return false;
+    }
+    */
+    
     void remove_particle(particle_id_type const& pid)
     {
         LOG_DEBUG(("remove particle %s", boost::lexical_cast<std::string>(pid).c_str()));

From 6be985abd0131fe0330d337f92b4b4f3512934d2 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 10 Oct 2011 17:12:43 +0200
Subject: [PATCH 0273/1541] Changed newBDPropegator such that it works for
 equal dimension reactions. However no quit sure this is correct.

---
 newBDPropagator.hpp | 68 ++++++++++++++++++++++++++-------------------
 1 file changed, 39 insertions(+), 29 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 98ce89d6..34688c8c 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -88,11 +88,10 @@ class newBDPropagator
 
         /* Consider decay reactions first. Particles can move after decay, but this is done
            inside the 'attempt_reaction' function; for this particle can only react once . */
-        bool pp_reaction = false;
         try
         {
             if (attempt_reaction(pp))
-                pp_reaction = true;
+                return true;
         }
         catch (propagation_error const& reason)
         {
@@ -182,29 +181,10 @@ class newBDPropagator
             return true;
         }
         
-        //Check for overlap with nearest surface.
-        structure_id_and_distance_pair str_id_distance( tx_.get_closest_surface( new_pos ) );
-        
-        //If surface is within reaction volume, check for reactions
-        if( str_id_distance.second < ( pp.second.radius() + reaction_length_ ) )
-        {
-            if
-            
-            try
-            {
-                if (attempt_reaction(pp, str_id_distance.first))
-                    return true;
-            }
-            catch (propagation_error const& reason)
-            {
-                log_.info("surface interaction rejected (reason: %s)", reason.what());
-                ++rejected_move_count_;
-                return true;
-            }
-            bounced = true;
-        }
-        
-        //if the particle did not bounce, update to new position.
+        //Check for overlap with nearest surface. -NO SURFACES YET.
+        //structure_id_and_distance_pair str_id_distance( tx_.get_closest_surface( new_pos ) );
+                
+        //If the particle did not bounce, update to new position.
         if(!bounced)
         {
                 
@@ -224,6 +204,8 @@ class newBDPropagator
         }
 
         return true
+        
+    }
 
     std::size_t get_rejected_move_count() const
     {
@@ -300,15 +282,16 @@ class newBDPropagator
                         int i = max_retry_count_;
                         position_type np0, np1;
 
+                        boost::shared_ptr<structure_type> pp_structure( 
+                                tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) ); 
+                                
+                        /* Place the two product particles inside the reaction volume and check if the volume is empty. */
                         for (;;)
                         {
                             if (--i < 0)
                             {
                                 throw propagation_error("no space");
-                            }
-
-                            boost::shared_ptr<structure_type> pp_structure( 
-                                tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) );  
+                            } 
                
                             position_type m( pp_structure->newbd_dissociation_vector( rng_, r01, reaction_length_ ) );
                             
@@ -329,6 +312,33 @@ class newBDPropagator
                                 break;
                         }
 
+                        /* After dissociation both particles are allowed to move. 
+                           Move particle #0 
+                        position_type displacement( pp_structure->
+                                            bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
+
+                        position_type new_pos(tx_.apply_boundary( add( np0, displacement ) ));
+                        
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+                                tx_.check_overlap(
+                                    particle_shape_type(new_pos, s0.radius()),
+                                    pp.first));
+                                    
+                        if ( !(overlapped && overlapped->size() > 0) )
+                            np0 = new_pos;
+                        
+                           
+                        displacement( pp_structure->bd_displacement(s1.v() * dt_, std::sqrt(2.0 * s1.D() * dt_), rng_) );
+
+                        new_pos(tx_.apply_boundary( add( np1, displacement ) ));
+                        
+                        overlapped(  tx_.check_overlap( particle_shape_type(new_pos, s0.radius()),pp.first )  );
+                                    
+                        if ( !(overlapped && overlapped->size() > 0) )
+                            np1 = new_pos;
+                            
+                        */
+
                         if (vc_)
                         {
                             if (!(*vc_)(particle_shape_type(np0, s0.radius()), pp.first) || !(*vc_)(particle_shape_type(np1, s1.radius()), pp.first))

From 87e3c10fb0779297c00a6ca233e9353513ed9410 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 10 Oct 2011 17:16:32 +0200
Subject: [PATCH 0274/1541] ; - error

---
 newBDPropagator.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 34688c8c..ce178144 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -203,7 +203,7 @@ class newBDPropagator
             tx_.update_particle(particle_to_update);
         }
 
-        return true
+        return true;
         
     }
 

From bd1e89c0429d02c7a2cf76cd2fee626132a7c621 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 11 Oct 2011 12:21:35 +0200
Subject: [PATCH 0275/1541] A number of changes are included in this commit:
 added get_scaling_factor method namechange D_tot -> D_r where appropriate (to
 clarify its meaning) added do_back_transform method to take care of
 anisotropic backtransform of new coordinates added com and r0 as outside
 parameters, these cannot be calculated in the MixedPair class

---
 pair.py | 90 ++++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 61 insertions(+), 29 deletions(-)

diff --git a/pair.py b/pair.py
index dfb507bd..21217b46 100644
--- a/pair.py
+++ b/pair.py
@@ -63,6 +63,7 @@ def get_D_tot(self):
         return self.pid_particle_pair1[1].D + \
                self.pid_particle_pair2[1].D
     D_tot = property(get_D_tot)
+    D_r   = property(get_D_tot)
 
     def get_D_R(self):
         return (self.pid_particle_pair1[1].D *
@@ -71,6 +72,7 @@ def get_D_R(self):
 
     def initialize(self, t):
 	# re-initialize the time parameters of the Domain to reuse it.
+	# THIS IS PROBABLY USELESS
         self.last_time = t
         self.dt = 0
         self.event_type = None
@@ -126,6 +128,8 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         """
 	# If the two particles have reacted this returns the
 	# new position twice
+	# TODO move this to SimplePair, this is not applicable to a MixedPair
+	# or make scaling factor in last line a parameter of the class
         new_com = self.draw_new_com(dt, event_type)
 
 	if event_type == EventType.IV_REACTION:
@@ -133,12 +137,7 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
 	    newpos2 = new_com
 	else:
             new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
-
-            D1 = self.pid_particle_pair1[1].D
-            D2 = self.pid_particle_pair2[1].D
-
-            newpos1 = new_com - new_iv * (D1 / self.D_tot)
-            newpos2 = new_com + new_iv * (D2 / self.D_tot)
+	    newpos1, newpos2 = self.do_back_transform(new_com, new_iv)
 
         return newpos1, newpos2
 
@@ -318,6 +317,15 @@ def get_com(self):
         return self.shell.shape.position
     com = property(get_com)
 
+    def do_back_transform(self, com, iv):
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
+
+        pos1 = com - iv * (D1 / self.D_tot)
+        pos2 = com + iv * (D2 / self.D_tot)
+
+	return pos1, pos2
+
     def get_shell_size(self):
         return self.shell.shape.radius
 
@@ -391,7 +399,7 @@ def determine_radii(self, r0, shell_size):
           log.debug('a %g, r %g, R %g r0 %g' % 
                  (shell_size, a_r, a_R, r0))
         if __debug__:
-            tr = ((a_r - r0)**2) / (6 * self.D_tot)	# the expected escape time of the iv
+            tr = ((a_r - r0)**2) / (6 * self.D_r)	# the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
@@ -422,7 +430,7 @@ def com_greens_function(self):
     def iv_greens_function(self, r0):
         # Green's function for interparticle vector inside absorbing 
         # sphere.  This exact solution is used for drawing times.
-        return GreensFunction3DRadAbs(self.D_tot, self.interparticle_ktot, r0,
+        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):
@@ -435,7 +443,7 @@ def choose_pair_greens_function(self, r0, t):
         distance_from_shell = self.a_r - r0
 
         threshold_distance = Pair.CUTOFF_FACTOR * \
-            math.sqrt(6.0 * self.D_tot * t)
+            math.sqrt(6.0 * self.D_r * t)
 
         # if sigma reachable
         if distance_from_sigma < threshold_distance:
@@ -451,7 +459,7 @@ def choose_pair_greens_function(self, r0, t):
                 # near sigma; use GreensFunction3DRadInf
                 if __debug__:
                     log.debug('GF: only sigma')
-                return GreensFunction3DRadInf(self.D_tot, self.interparticle_ktot, r0,
+                return GreensFunction3DRadInf(self.D_r, self.interparticle_ktot, r0,
                                                self.sigma)
 
         # sigma unreachable
@@ -460,13 +468,13 @@ def choose_pair_greens_function(self, r0, t):
                 # near a;
                 if __debug__:
                     log.debug('GF: only a')
-                return GreensFunction3DAbs(self.D_tot, r0, self.a_r)
+                return GreensFunction3DAbs(self.D_r, r0, self.a_r)
                 
             else:
                 # distant from both a and sigma; 
                 if __debug__:
                     log.debug('GF: free')
-                return GreensFunction3D(self.D_tot, r0)
+                return GreensFunction3D(self.D_r, r0)
 
     def create_com_vector(self, r):
         return random_vector(r)
@@ -520,7 +528,7 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
 	# TODO still doesn't work with 2D Green's functions
-        return GreensFunction3DRadAbs(self.D_tot, self.interparticle_ktot, r0,
+        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):
@@ -543,7 +551,7 @@ def choose_pair_greens_function(self, r0, t):
         distance_from_shell = self.a_r - r0
 
         threshold_distance = Pair.CUTOFF_FACTOR * \
-            math.sqrt(4.0 * self.D_tot * t)
+            math.sqrt(4.0 * self.D_r * t)
 
         if distance_from_sigma < threshold_distance:
         
@@ -559,7 +567,7 @@ def choose_pair_greens_function(self, r0, t):
                     log.debug('GF2D: only sigma')
                 return self.iv_greens_function(r0)
         	# Todo
-                # return GreensFunction2DRadInf(self.D_tot, self.interparticle_ktot, r0, self.sigma)
+                # return GreensFunction2DRadInf(self.D_r, self.interparticle_ktot, r0, self.sigma)
         else:
             if distance_from_shell < threshold_distance:
                 # near a;
@@ -567,7 +575,7 @@ def choose_pair_greens_function(self, r0, t):
                     log.debug('GF2D: only a')
                 return self.iv_greens_function(r0)
 	        # Todo
-                # return GreensFunction2DAbs(self.D_tot, r0, self.a_r)
+                # return GreensFunction2DAbs(self.D_r, r0, self.a_r)
                 
             else:
                 # distant from both a and sigma; 
@@ -575,7 +583,7 @@ def choose_pair_greens_function(self, r0, t):
                     log.debug('GF2D: free')
                 return self.iv_greens_function(r0)
         	# Todo
-                # return GreensFunction2D(self.D_tot, r0)
+                # return GreensFunction2D(self.D_r, r0)
 
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
@@ -632,8 +640,8 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
 	# TODO Fix ugly hack to avoid k=0 below
-        #return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
-        return GreensFunction1DRadAbs(self.D_tot, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
+        #return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
+        return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
     def create_new_shell(self, position, half_length, domain_id):
         # The radius of a rod is not more than it has to be (namely the 
@@ -671,12 +679,13 @@ def __str__(self):
 class MixedPair(Pair):
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
-		 shell_half_length, shell_orientation_vector,
+		 shell_half_length, shell_orientation_vector, com,
 		 unit_r, r0, rrs):
 	Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
-
 	self.surface = surface	# the surface on which particle1 lives
+	self.com = com
+	self.r0 = r0	# TODO this needs to be rescaled too
 
     def determine_radii(self):
 	#TODO INCORRECT
@@ -689,15 +698,37 @@ def get_com(self):
 	return self.shell.shape.position
     com = property(get_com)
 
+    def get_scaling_factor(self):
+	D_2 = self.pid_particle_pair2[1].D	# particle 2 is in 3D and is the only contributor to diffusion
+						# normal to the plane
+	return math.sqrt(self.D_r/D_2)
+
+    def do_back_transform(self, com, iv):
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
+
+	weight1 = D1 / self.D_tot
+	weight2 = D2 / self.D_tot
+
+        pos1[0] = com[0] - iv[0] * weight1
+        pos1[1] = com[1] - iv[1] * weight1
+        pos1[2] = com[2]
+
+        pos2[0] = com[0] + iv[0] * weight2
+        pos2[1] = com[1] + iv[1] * weight2
+        pos2[2] = com[2] + iv[2] / self.get_scaling_factor()	# scale the z component of the 3D particle back
+
+	return pos1, pos2
+
     def get_sigma(self):
 	# rescale sigma to correct for the rescaling of the coordinate system
-	# TODO check if this is actually correct
-	D_1 = self.pid_particle_pair1[1].D
-	D_2 = self.pid_particle_pair2[1].D
-	xi_inv = math.sqrt(D_2/(D_1 + D_2))
+	# This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
+	# different than the sums of the radii of the particleso
+	xi = self.get_scaling_factor()
+	xi_inv = 1/xi
 	alpha = math.acos(xi_inv)
 	sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
-	rho = abs(sigma*math.sqrt(0.5 + (alpha/(2.0*xi_inv*math.sin(alpha)))))
+	rho = abs(sigma*math.sqrt(0.5 + (alpha*xi/(2.0*math.sin(alpha)))))
 	return rho
     sigma = property (get_sigma)
 
@@ -707,7 +738,7 @@ def com_greensfunction(self):
 
     def iv_greensfunction(self):
 	# diffusion of the interparticle vector is three dimensional
-	return GreensFunction3DRadAbs(self.D_tot, self.interparticle_ktot, r0,
+	return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, self.r0,
 				      self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, orientation_vector, half_length):
@@ -751,10 +782,11 @@ def create_iv_vector(self, gf, r, dt, r0, old_iv):
         else:
             rotated = numpy.array([new_iv[0], new_iv[1], - new_iv[2]])
         
-	# TODO
+	# TODO move this to draw_new_positions or method that defines the scaling factor
 	# rescale z component by 1/xi (z component becomes slightly smaller, since D = D_A + D_B
 	# was used for calculation, whereas in reality D is only D_B
-	xi_inv = math.sqrt((D_2)/D_1 + D_2)
+	xi = self.get_scaling_factor()
 	z /= xi
+	# TODO
 	# position is reflected back in the membrane if necessary
 	return rotated 

From f518171fed0f42e507acb1e9206c11724da1f348 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@amolf.nl>
Date: Tue, 11 Oct 2011 14:13:56 +0200
Subject: [PATCH 0276/1541] Added some comments.

-MW.
---
 funcSum.cpp | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/funcSum.cpp b/funcSum.cpp
index 82bac5d0..1af7767a 100644
--- a/funcSum.cpp
+++ b/funcSum.cpp
@@ -10,6 +10,10 @@
 #include "Logger.hpp"
 #include "funcSum.hpp"
 
+#include <iostream> // debug REMOVEME
+#include <stdexcept> // debug REMOVEME
+#include <sstream> // debug REMOVEME
+
 typedef std::vector<Real> RealVector;
 
 static Logger& _log(Logger::get_logger("funcSum"));
@@ -74,6 +78,7 @@ funcSum_all_accel(boost::function<Real(unsigned int i)> f,
                   " (rel error: %.16g), terms_used = %d (%d given)",
                   fabs(error), fabs(error / sum),
                   workspace->terms_used, pTable.size());
+        // TODO look into this crashing behaviour
     }
 
     gsl_sum_levin_utrunc_free(workspace);
@@ -84,6 +89,24 @@ funcSum_all_accel(boost::function<Real(unsigned int i)> f,
 
 Real 
 funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
+// funcSum
+// ==
+// Will simply calculate the sum over a certain function f, until it converges
+// (i.e. the sum > tolerance*current_term), or a maximum number of terms is 
+// summed (usually 2000).
+//
+// Input:
+// - f: A       function object
+// - max_i:     maximum number of terms it will evaluate
+// - tolerance: convergence condition, default value 1-e8 (see .hpp)
+// 
+// About Boost::function
+// ===
+// Boost::function doesn't do any type checking: It will take any object 
+// and any signature you provide in its template parameter, and create an 
+// object that's callable according to your signature and calls the object. 
+// If that's impossible, it's a compile error.
+// (From: http://stackoverflow.com/questions/527413/how-boostfunction-and-boostbind-work)
 {
     const unsigned int CONVERGENCE_CHECK(4);
 
@@ -93,6 +116,7 @@ funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
     const Real p_0(f(0));
     if (p_0 == 0.0)
     {
+//        std::clog << "[[p_0(f(0))=0]]"; // DEBUG *REMOVEME*
         return 0.0;
     }
 

From 5532d0e49f3ed0d518ad7263f20d7a6eacd52fad Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 11 Oct 2011 16:46:16 +0200
Subject: [PATCH 0277/1541] made get_scaling_factor into property
 z_scaling_factor and.. some changes to calculation of the CoM Also some
 comments

---
 pair.py | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 deletions(-)

diff --git a/pair.py b/pair.py
index 21217b46..3d14d964 100644
--- a/pair.py
+++ b/pair.py
@@ -130,7 +130,7 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
 	# new position twice
 	# TODO move this to SimplePair, this is not applicable to a MixedPair
 	# or make scaling factor in last line a parameter of the class
-        new_com = self.draw_new_com(dt, event_type)
+        new_com = self.com + self.draw_new_com(dt, event_type)
 
 	if event_type == EventType.IV_REACTION:
 	    newpos1 = new_com
@@ -142,25 +142,26 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         return newpos1, newpos2
 
     def draw_new_com(self, dt, event_type):
+	# draws a new coordinate for the CoM in world coordinates
         if event_type == EventType.COM_ESCAPE:
             r = self.a_R
         else:
             gf = self.com_greens_function()
             r = draw_r_wrapper(gf, dt, self.a_R)
 
-        displacement = self.create_com_vector(r)
+        return self.create_com_vector(r)
 
         # Add displacement to old CoM. This assumes (correctly) that 
         # r0=0 for the CoM. Compare this to 1D singles, where r0 is not  
         # necesseraly 0.
-        return self.com + displacement
+#        return displacement
 
     def draw_new_iv(self, dt, r0, old_iv, event_type):
         gf = self.choose_pair_greens_function(r0, dt)
         if event_type == EventType.IV_ESCAPE:
             r = self.a_r
         elif event_type == EventType.IV_REACTION:
-            r = self.sigma
+            r = self.sigma	# maybe this should be zero (product particle is at CoM)
         else:
             r = draw_r_wrapper(gf, dt, self.a_r, self.sigma)
 
@@ -666,6 +667,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
         # Note: using self.structure.shape.unit_z here might accidently 
         # interchange the particles.
+	# That's why we would use self.shell.shape.unit_z right?!
         return r * normalize(old_iv)
 
     def get_shell_size(self):
@@ -679,12 +681,11 @@ def __str__(self):
 class MixedPair(Pair):
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
-		 shell_half_length, shell_orientation_vector, com,
+		 shell_half_length, shell_orientation_vector, 
 		 unit_r, r0, rrs):
 	Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
 	self.surface = surface	# the surface on which particle1 lives
-	self.com = com
 	self.r0 = r0	# TODO this needs to be rescaled too
 
     def determine_radii(self):
@@ -694,14 +695,17 @@ def determine_radii(self):
 	return 
 
     def get_com(self):
-	# TODO INCORRECT
-	return self.shell.shape.position
+	# Note that it is implied that the center of the shell is chosen such that its projection on the
+	# membrane is the CoM of the particles.
+	dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair1[1].radius
+	return self.shell.shape.position - dist_to_surface * self.shell.shape.unit_z
     com = property(get_com)
 
     def get_scaling_factor(self):
 	D_2 = self.pid_particle_pair2[1].D	# particle 2 is in 3D and is the only contributor to diffusion
 						# normal to the plane
 	return math.sqrt(self.D_r/D_2)
+    z_scaling_factor = property(get_scaling_factor)
 
     def do_back_transform(self, com, iv):
         D1 = self.pid_particle_pair1[1].D
@@ -716,7 +720,7 @@ def do_back_transform(self, com, iv):
 
         pos2[0] = com[0] + iv[0] * weight2
         pos2[1] = com[1] + iv[1] * weight2
-        pos2[2] = com[2] + iv[2] / self.get_scaling_factor()	# scale the z component of the 3D particle back
+        pos2[2] = com[2] + iv[2] / self.z_scaling_factor	# scale the z component of the 3D particle back
 
 	return pos1, pos2
 
@@ -724,7 +728,7 @@ def get_sigma(self):
 	# rescale sigma to correct for the rescaling of the coordinate system
 	# This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
 	# different than the sums of the radii of the particleso
-	xi = self.get_scaling_factor()
+	xi = self.z_scaling_factor
 	xi_inv = 1/xi
 	alpha = math.acos(xi_inv)
 	sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
@@ -752,7 +756,8 @@ def create_com_vector(self, r):
 	x, y = random_vector2D(r)
 	return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
 
-    def create_iv_vector(self, gf, r, dt, r0, old_iv):
+    def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
+	# Note: old_iv is actually the r0_vector
 	# TODO This is not yet correct -> stub
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
@@ -785,7 +790,7 @@ def create_iv_vector(self, gf, r, dt, r0, old_iv):
 	# TODO move this to draw_new_positions or method that defines the scaling factor
 	# rescale z component by 1/xi (z component becomes slightly smaller, since D = D_A + D_B
 	# was used for calculation, whereas in reality D is only D_B
-	xi = self.get_scaling_factor()
+	xi = self.z_scaling_factor
 	z /= xi
 	# TODO
 	# position is reflected back in the membrane if necessary

From e9196ca2d4f8888e04ad47b2e976f35ce43e2cd8 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 12 Oct 2011 11:22:21 +0200
Subject: [PATCH 0278/1541] Included moving both particles after dissociation
 for the dissociation move. Added cyclic volume condition (2*Delta) for the
 volume factor in Cylindrical surface.

Note: All particles should have a D != 0 for now.
---
 CylindricalSurface.hpp |  2 +-
 newBDPropagator.hpp    | 24 ++++++++++++++----------
 2 files changed, 15 insertions(+), 11 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 668a8938..2cfaa40d 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -75,7 +75,7 @@ class CylindricalSurface
 
     virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
     {
-        return rl;
+        return 2*rl;
     }
 
     virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index ce178144..dae74c41 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -100,6 +100,7 @@ class newBDPropagator
             return true;
         }
 
+        //TODO Particels D = 0 can still react with particles in their reaction volume.
         const species_type species(tx_.get_species(pp.second.sid()));
         if (species.D() == 0.)
             return true;
@@ -313,31 +314,34 @@ class newBDPropagator
                         }
 
                         /* After dissociation both particles are allowed to move. 
-                           Move particle #0 
+                           Move particle #0 */
                         position_type displacement( pp_structure->
                                             bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
 
                         position_type new_pos(tx_.apply_boundary( add( np0, displacement ) ));
                         
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped1(
                                 tx_.check_overlap(
                                     particle_shape_type(new_pos, s0.radius()),
                                     pp.first));
                                     
-                        if ( !(overlapped && overlapped->size() > 0) )
+                        if ( !(overlapped1 && overlapped1->size() > 0) )
                             np0 = new_pos;
                         
-                           
-                        displacement( pp_structure->bd_displacement(s1.v() * dt_, std::sqrt(2.0 * s1.D() * dt_), rng_) );
+                        //Move particle #1   
+                        displacement = pp_structure->bd_displacement(s1.v() * dt_, std::sqrt(2.0 * s1.D() * dt_), rng_);
 
-                        new_pos(tx_.apply_boundary( add( np1, displacement ) ));
+                        new_pos = tx_.apply_boundary( add( np1, displacement ) );
                         
-                        overlapped(  tx_.check_overlap( particle_shape_type(new_pos, s0.radius()),pp.first )  );
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped2(
+                                tx_.check_overlap(
+                                    particle_shape_type(new_pos, s1.radius()),
+                                    pp.first ));
                                     
-                        if ( !(overlapped && overlapped->size() > 0) )
+                        if ( !(overlapped2 && overlapped2->size() > 0) )
                             np1 = new_pos;
                             
-                        */
+                        
 
                         if (vc_)
                         {
@@ -393,7 +397,7 @@ class newBDPropagator
             boost::shared_ptr<structure_type> pp_structure( 
                tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
 
-            const Real p( r.k() * dt_ / pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) );
+            const Real p( r.k() * dt_ / ( 2 * pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) ) );
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)

From 7ff3d401a134ec62e92f40cb0c15a8a23d02167b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 12 Oct 2011 12:12:51 +0200
Subject: [PATCH 0279/1541] changed com->shell_center where appropriate and
 made com relative to shell_center

---
 egfrd.py | 11 ++++++++---
 pair.py  | 31 ++++++++++++++++---------------
 2 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c9f221e8..5b9da25f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -835,7 +835,7 @@ def fire_single_reaction(self, single, reactant_pos):
 
 		elif isinstance(reactant_structure, CylindricalSurface):
 
-		    # TODO
+		    # TODO insert reverse transformation for 3D/1D here
 		    surface_displace = product3D_radius + reactant_structure.shape.radius
 
 		else:
@@ -1340,10 +1340,10 @@ def process_pair_event(self, pair):
         pid_particle_pair2 = pair.pid_particle_pair2
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
+        r0 = self.world.distance(pos1, pos2)
         
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
-            r0 = self.world.distance(pos1, pos2)
             pair.event_type = pair.draw_iv_event_type(r0)
 
         self.pair_steps[pair.event_type] += 1
@@ -1392,9 +1392,14 @@ def process_pair_event(self, pair):
         elif pair.event_type == EventType.IV_REACTION:
 
             # calculate new position
-            new_com = pair.draw_new_com(pair.dt, pair.event_type)
+            pos2t = self.world.cyclic_transpose(pos2, pos1)
+            old_iv = pos2t - pos1
+            new_com, _ = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
             new_com = self.world.apply_boundary(new_com)
 
+	    # TODO make this a fire_pair_reaction method
+
+
 	    # 0. get reactant info
 	    rr = pair.draw_reaction_rule(pair.interparticle_rrs)
 	    reactant1_species_id = pid_particle_pair1[1].sid
diff --git a/pair.py b/pair.py
index 3d14d964..ec6bac43 100644
--- a/pair.py
+++ b/pair.py
@@ -128,9 +128,10 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         """
 	# If the two particles have reacted this returns the
 	# new position twice
+	# The positions are relative to the center of the shell
 	# TODO move this to SimplePair, this is not applicable to a MixedPair
 	# or make scaling factor in last line a parameter of the class
-        new_com = self.com + self.draw_new_com(dt, event_type)
+        new_com = self.shell.shape.position + self.draw_new_com(dt, event_type)
 
 	if event_type == EventType.IV_REACTION:
 	    newpos1 = new_com
@@ -226,7 +227,7 @@ def get_min_shell_size(single1, single2, geometrycontainer):
 
 
     @staticmethod
-    def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
+    def get_max_shell_size(shell_center, single1, single2, geometrycontainer, domains):
 	# returns the maximum shell size based on geometric constraints
 	# It makes sure that surrounding NonInteractionSingles have at least the
 	# 'bursting volume' of space.
@@ -238,12 +239,12 @@ def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
 #        D12 = D1 + D2
 
 	# TODO it makes no sence to calculate the CoM in the world object
-#        com = geometrycontainer.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-#        com = geometrycontainer.world.apply_boundary(com)
+#        com  = geometrycontainer.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+#        shell_center = geometrycontainer.world.apply_boundary(com)
 
 	# TODO get_closest_obj searches the spherical surrounding although this doesn't make sence for
 	# a 2D or 1D pair
-        closest, closest_distance = geometrycontainer.get_closest_obj(com, domains, ignore=[single1.domain_id,
+        closest, closest_distance = geometrycontainer.get_closest_obj(shell_center, domains, ignore=[single1.domain_id,
                                                                       single2.domain_id],
                                                                       ignores=[single1.structure.id])
         if __debug__:
@@ -264,7 +265,7 @@ def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
 #        for b in burst:
 #            if isinstance(b, NonInteractionSingle):
 #                bpos = b.shell.shape.position
-#                d = self.world.distance(com, bpos) - \
+#                d = self.world.distance(shell_center, bpos) - \
 #                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
 #                if d < closest_shell_distance:
 #                    closest, closest_shell_distance = b, d
@@ -273,7 +274,7 @@ def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
 
         if isinstance(closest, NonInteractionSingle):
             closest_particle_distance = geometrycontainer.world.distance(
-                    com, closest.pid_particle_pair[1].position)
+                    shell_center, closest.pid_particle_pair[1].position)
 
             closest_min_radius = closest.pid_particle_pair[1].radius
             closest_min_shell = closest_min_radius * Domain.SINGLE_SHELL_FACTOR
@@ -296,7 +297,7 @@ def get_max_shell_size(com, single1, single2, geometrycontainer, domains):
 		   shell_size)
 
 
-    def __init__(self, domain_id, com, single1, single2, shell_id,
+    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure):
 	Pair.__init__(self, domain_id, single1, single2, shell_id,
                       r0, rrs)
@@ -306,7 +307,7 @@ def __init__(self, domain_id, com, single1, single2, shell_id,
         self.a_R, self.a_r = self.determine_radii(r0, shell_size)
 	# set the radii of the inner domains as a function of the outer protective domain
 
-        self.shell = self.create_new_shell(com, shell_size, domain_id)
+        self.shell = self.create_new_shell(shell_center, shell_size, domain_id)
 
 
     def getSigma(self):
@@ -419,9 +420,9 @@ class SphericalPair(SimplePair):
     """2 Particles inside a (spherical) shell not on any surface.
 
     """
-    def __init__(self, domain_id, com, single1, single2, shell_id,
+    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
-        SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
+        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 
     def com_greens_function(self):
@@ -519,9 +520,9 @@ class PlanarSurfacePair(SimplePair):
     (Hockey pucks).
 
     """
-    def __init__(self, domain_id, com, single1, single2, shell_id,
+    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
-        SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
+        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 
     def com_greens_function(self):
@@ -616,9 +617,9 @@ class CylindricalSurfacePair(SimplePair):
     (Rods).
 
     """
-    def __init__(self, domain_id, com, single1, single2, shell_id,
+    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
-        SimplePair.__init__(self, domain_id, com, single1, single2, shell_id,
+        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 
     def get_v_tot(self):

From ed6a8f676c2ed9896c45267fc31bd628a0e4b68c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 12 Oct 2011 18:38:44 +0200
Subject: [PATCH 0280/1541] started work on static methods for shellmaking
 MixedPair

---
 pair.py | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/pair.py b/pair.py
index ec6bac43..a8e8cacb 100644
--- a/pair.py
+++ b/pair.py
@@ -681,6 +681,27 @@ def __str__(self):
 
 class MixedPair(Pair):
 
+    @staticmethod
+    def get_min_shell_dimensions(single1, single2, reference_point, geometrycontainer):
+	# TODO incomplete
+
+	assert isinstance (single1.structure, PlanarSurface)
+	assert isinstance (single2.structure, CuboidalRegion)
+
+	pid_particle_pair1 = single1.pid_particle_pair
+	pid_particle_pair2 = single2.pid_particle_pair
+
+	dz_left = pid_particle_pair1[1].radius
+	dz_right = particle12_dist_z + pid_particle_pair2[1].radius * SINGLE_SHELL_FACTOR
+	dr = max(particle1com_dist_r + radius1 * SINGLE_SHELL_FACTOR,
+		 particle2com_dist_r + radius2 * SINGLE_SHELL_FACTOR)
+
+	return dr, dz_left, dz_right
+
+    @staticmethod
+    def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer, domains):
+	pass
+
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
 		 shell_half_length, shell_orientation_vector, 
 		 unit_r, r0, rrs):

From c2dfef240be92d20d4a0fbb24a3428c9e45c9700 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 13 Oct 2011 19:01:29 +0200
Subject: [PATCH 0281/1541] r0 is the length of the interparticle vector -> now
 clearer

---
 egfrd.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 5b9da25f..7021ee2d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1338,9 +1338,12 @@ def process_pair_event(self, pair):
         single2 = pair.single2
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
+
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
-        r0 = self.world.distance(pos1, pos2)
+        pos2t = self.world.cyclic_transpose(pos2, pos1)
+        old_iv = pos2t - pos1
+        r0 = length (old_iv)
         
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
@@ -1392,8 +1395,6 @@ def process_pair_event(self, pair):
         elif pair.event_type == EventType.IV_REACTION:
 
             # calculate new position
-            pos2t = self.world.cyclic_transpose(pos2, pos1)
-            old_iv = pos2t - pos1
             new_com, _ = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
             new_com = self.world.apply_boundary(new_com)
 

From dd172044433ade42dea3126c1941b815f253680d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 13 Oct 2011 19:02:16 +0200
Subject: [PATCH 0282/1541] added comments to utils.py clarifying the functions

---
 utils.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index 19fd1702..6eec6edc 100644
--- a/utils.py
+++ b/utils.py
@@ -143,8 +143,12 @@ def cartesian_to_spherical(c):
     return numpy.array([r, theta, phi])
 
 def spherical_to_cartesian(s):
-    #FIXME: it's possible that the below is a source of some bias.
+    #FIXME: it's possible that the below is a source of some bias. (why??)
     r, theta, phi = s
+    # theta is the angle with zenith axis z, phi is the angle with the azimuthal axis x in the direction of the y axis
+    # -Pi < theta < Pi
+    # -Pi/2 < phi < Pi/2 although since phi is usually a free parameter and drawn from a uniform distribution
+    #                    it can also be 0 < phi < 2Pi or 0 < phi < Pi
     sintheta = math.sin(theta)
     return numpy.array([r * math.cos(phi) * sintheta,
                         r * math.sin(phi) * sintheta,
@@ -194,6 +198,8 @@ def normalize(a, l=1):
     return _gfrd.normalize(a, l)
 
 def vector_angle(a, b):
+    # returns the angle tussen vector a en b
+    # the range of the angle is (0 - Pi)
     cosangle = numpy.dot(a, b) / (length(a) * length(b))
     return math.acos(cosangle)
 
@@ -208,6 +214,7 @@ def crossproduct(a, b):
     return numpy.dot(M, b)
 
 def crossproduct_against_z_axis(a):
+    # this is crossproduct (a, z-axis)
     return numpy.array([- a[1], a[0], 0.0])
 
 def rotate_vector(v, r, alpha):

From 4eddcde169eab35b6e7a5774c715fa2153cece5b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 13 Oct 2011 19:04:46 +0200
Subject: [PATCH 0283/1541] cleanup of create_interparticle_vector methods,
 also implemented back_transform for MixedPair draw_new_positions should now
 work correctly also for MixedPair Note that the reflective property and
 rescaling are done in MixedPair.do_back_transform method. The
 MixedPair.create_interparticle_vector is actually the same as in the
 spherical case

---
 pair.py | 156 ++++++++++++++++++++++++++++++++++----------------------
 1 file changed, 94 insertions(+), 62 deletions(-)

diff --git a/pair.py b/pair.py
index a8e8cacb..23bf5ab9 100644
--- a/pair.py
+++ b/pair.py
@@ -482,34 +482,55 @@ def create_com_vector(self, r):
         return random_vector(r)
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
+	# FIXME code doesn't handle r=0 
+
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
         theta = draw_theta_wrapper(gf, r, dt)
 
-        new_inter_particle_s = numpy.array([r, theta, 
-                                         myrandom.uniform() * 2 * Pi])
-        new_iv = spherical_to_cartesian(new_inter_particle_s)
+#        new_inter_particle_s = numpy.array([r, theta, phi])
+#        new_iv = spherical_to_cartesian(new_inter_particle_s)
 
-        #FIXME: need better handling of angles near zero and pi.
+	# calculate the old_iv theta (theta is the angle with the zenith (z-axis) of the system)
+#        old_iv_theta = vector_angle_against_z_axis(old_iv)
+	# the old_iv phi is taken to be zero. This means that the theta is in the plane of
+	# the z-axis and the old_iv
 
-        # I rotate the new interparticle vector along the
-        # rotation axis that is perpendicular to both the
-        # z-axis and the original interparticle vector for
-        # the angle between these.
+            # We now rotate the new interparticle vector in the plane of
+	    # the old_iv and the z axis. This menas along the
+            # rotation axis that is perpendicular to both the
+            # z-axis and the original interparticle vector. The rotation
+            # angle is the angle between the old_iv and z axis.
         
-        # the rotation axis is a normalized cross product of
-        # the z-axis and the original vector.
-        # rotation_axis = crossproduct([0,0,1], inter_particle)
-        angle = vector_angle_against_z_axis(old_iv)
-        if angle % numpy.pi != 0.0:
+            # the rotation axis is a normalized cross product of
+            # the z-axis and the original vector.
+            # rotation_axis = crossproduct([0,0,1], inter_particle)
+
+#            rotation_axis = crossproduct_against_z_axis(old_iv)
+#            rotation_axis = normalize(rotation_axis)
+#            new_iv = rotate_vector(new_iv, rotation_axis, old_iv_theta)
+
+        if theta == 0.0:
+	    # no rotation is necessary -> new_iv = new_iv
+	    new_iv = old_iv
+        elif old_iv_theta % numpy.pi != 0.0:
+	    # alternative calculation
+	    # rotate the old_iv to the new theta
             rotation_axis = crossproduct_against_z_axis(old_iv)
             rotation_axis = normalize(rotation_axis)
-            rotated = rotate_vector(new_iv, rotation_axis, angle)
-        elif angle == 0.0:
-            rotated = new_iv
+            new_iv = rotate_vector(old_iv, rotation_axis, theta)
+
+	    # rotate the new_iv around the old_iv with angle phi and adjust length
+	    phi = myrandom.uniform() * 2 * Pi
+	    old_iv = normalize(old_iv)
+	    new_iv = rotate_vector(new_iv, old_iv, phi)
         else:
-            rotated = numpy.array([new_iv[0], new_iv[1], - new_iv[2]])
-        return rotated
+	    # angle == numpi.pi -> just mirror the old_iv 
+            new_iv = -old_iv
+
+	new_iv = (r/r0) * new_iv
+
+        return new_iv
 
     def __str__(self):
         return 'Spherical' + Pair.__str__(self)
@@ -592,19 +613,26 @@ def create_com_vector(self, r):
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
+	# note that r0 = length (old_iv)
+
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
         theta = draw_theta_wrapper(gf, r, dt)
 
-        #FIXME: need better handling of angles near zero and pi?
-        unit_x = self.structure.shape.unit_x
-        unit_y = self.structure.shape.unit_y
-        angle = vector_angle(unit_x, old_iv)
+#        unit_x = self.structure.shape.unit_x
+#        unit_y = self.structure.shape.unit_y
+#        angle = vector_angle(unit_x, old_iv)
+	# FIXME THIS IS WRONG: angle returns the angle between the vectors regardsless of order
+	#       now we do not see the different if the old_iv is mirrored in the unit_x
         # Todo. Test if nothing changes when theta == 0.
-        new_angle = angle + theta
+#        new_angle = angle + theta
+#
+#        new_iv = r * math.cos(new_angle) * unit_x + \
+#                 r * math.sin(new_angle) * unit_y
 
-        new_iv = r * math.cos(new_angle) * unit_x + \
-                 r * math.sin(new_angle) * unit_y
+	new_iv = (r/r0) * rotate_vector(old_iv, unit_z, theta)
+	# note that unit_z can point two ways rotating the vector clockwise or counterclockwise
+	# because theta is symmetric this doesn't matter.
 
         return new_iv
 
@@ -664,12 +692,13 @@ def create_com_vector(self, r):
         return r * self.structure.shape.unit_z
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
+	# note that r0 = length (old_iv)
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
         # Note: using self.structure.shape.unit_z here might accidently 
         # interchange the particles.
 	# That's why we would use self.shell.shape.unit_z right?!
-        return r * normalize(old_iv)
+        return (r/r0) * old_iv
 
     def get_shell_size(self):
         # Heads up.
@@ -691,6 +720,8 @@ def get_min_shell_dimensions(single1, single2, reference_point, geometrycontaine
 	pid_particle_pair1 = single1.pid_particle_pair
 	pid_particle_pair2 = single2.pid_particle_pair
 
+	
+
 	dz_left = pid_particle_pair1[1].radius
 	dz_right = particle12_dist_z + pid_particle_pair2[1].radius * SINGLE_SHELL_FACTOR
 	dr = max(particle1com_dist_r + radius1 * SINGLE_SHELL_FACTOR,
@@ -736,13 +767,20 @@ def do_back_transform(self, com, iv):
 	weight1 = D1 / self.D_tot
 	weight2 = D2 / self.D_tot
 
-        pos1[0] = com[0] - iv[0] * weight1
-        pos1[1] = com[1] - iv[1] * weight1
-        pos1[2] = com[2]
+	# get the coordinates of the iv relative to the system of the surface (or actually the shell)
+	iv_x = self.surface.shape.unit_x * numpy.dot(iv, self.surface.shape.unit_x)
+	iv_y = self.surface.shape.unit_y * numpy.dot(iv, self.surface.shape.unit_y)
+	iv_z = self.shell.shape.unit_z * numpy.dot(iv, self.shell.shape.unit_z)
+
+	# reflect the coordinates in the unit_z direction back to the side of the membrane
+	# where the domain is. Note that it's implied that the origin of the coordinate system lies in the
+	# plane of the membrane
+	iv_z = abs(iv_z)
 
-        pos2[0] = com[0] + iv[0] * weight2
-        pos2[1] = com[1] + iv[1] * weight2
-        pos2[2] = com[2] + iv[2] / self.z_scaling_factor	# scale the z component of the 3D particle back
+	pos1 = com - weight1 * (iv_x + iv_y)
+	pos2 = com + weight2 * (iv_x + iv_y) + \
+               iv_z/self.z_scaling_factor + \
+               self.shell.shape.unit_z * self.pid_particle_pair2[1].radius
 
 	return pos1, pos2
 
@@ -780,40 +818,34 @@ def create_com_vector(self, r):
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 	# Note: old_iv is actually the r0_vector
-	# TODO This is not yet correct -> stub
+	# FIXME This is actually the same method as for SphericalPair
+
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
-        theta = draw_theta_wrapper(gf, r, dt)
 
-        new_inter_particle_s = numpy.array([r, theta,
-                                         myrandom.uniform() * 2 * Pi])
-        new_iv = spherical_to_cartesian(new_inter_particle_s)
+        theta = draw_theta_wrapper(gf, r, dt)	# draw_theta return a value between -Pi and Pi
 
-        #FIXME: need better handling of angles near zero and pi.
-
-        # I rotate the new interparticle vector along the
-        # rotation axis that is perpendicular to both the
-        # z-axis and the original interparticle vector for
-        # the angle between these.
-
-        # the rotation axis is a normalized cross product of
-        # the z-axis and the original vector.
-        # rotation_axis = crossproduct([0,0,1], inter_particle)
-        angle = vector_angle_against_z_axis(old_iv)
-        if angle % numpy.pi != 0.0:
+        if theta == 0.0:
+            new_iv = old_iv
+        elif theta % numpy.pi != 0.0:
+	    # rotate the old_iv to the new theta
             rotation_axis = crossproduct_against_z_axis(old_iv)
             rotation_axis = normalize(rotation_axis)
-            rotated = rotate_vector(new_iv, rotation_axis, angle)
-        elif angle == 0.0:
-            rotated = new_iv
+            new_iv = rotate_vector(old_iv, rotation_axis, theta)
+
+	    # rotate the new_iv around the old_iv with angle phi
+	    phi = myrandom.uniform() * 2 * Pi
+	    old_iv = normalize(old_iv)
+	    new_iv = rotate_vector(new_iv, old_iv, phi)
         else:
-            rotated = numpy.array([new_iv[0], new_iv[1], - new_iv[2]])
-        
-	# TODO move this to draw_new_positions or method that defines the scaling factor
-	# rescale z component by 1/xi (z component becomes slightly smaller, since D = D_A + D_B
-	# was used for calculation, whereas in reality D is only D_B
-	xi = self.z_scaling_factor
-	z /= xi
-	# TODO
-	# position is reflected back in the membrane if necessary
-	return rotated 
+	    # theta == Pi -> just mirror the old_iv
+            new_iv = -old_iv
+
+	#adjust length of the vector to new r
+        new_iv = (r/r0) * new_iv
+
+	return new_iv
+
+    def __str__(self):
+        return 'Mixed' + Pair.__str__(self)
+

From 0eefd539e9f6e51589b6c544d090fe9c5f167fd5 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 14 Oct 2011 12:25:59 +0200
Subject: [PATCH 0284/1541] Starting to build the full newBDPropegator, for
 both particle-particle reactions and surface interactions.

---
 Multi.hpp             |   2 +-
 ParticleContainer.hpp |   2 +-
 PlanarSurface.hpp     |   2 +-
 Transaction.hpp       |   2 +-
 World.hpp             |   4 +-
 newBDPropagator.hpp   | 233 +++++++++++++++++++++++++-----------------
 6 files changed, 143 insertions(+), 102 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index e8f134a9..3f925981 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -37,8 +37,8 @@ class MultiParticleContainer
     typedef typename traits_type::size_type size_type;
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
+    typedef typename Ttraits_::world_type::particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
     typedef Transaction<traits_type> transaction_type;
     typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index c3849ec1..63584b0b 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -26,7 +26,7 @@ class ParticleContainer
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
+    typedef std::pair<structure_id_type, length_type> structure_id_and_distance_pair;
     typedef Transaction<traits_type> transaction_type;
     typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 3414f975..f43b3f85 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -52,7 +52,7 @@ class PlanarSurface
     virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
                                 Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
     {
-        //TODO: use the 2D BD function instead of the 3D one.
+        //TODO: use the 2D BD function instead of the 3D one. - Solution known
         return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
     }
 
diff --git a/Transaction.hpp b/Transaction.hpp
index 4f5441cc..d538365d 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -60,7 +60,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
+    typedef std::pair<structure_id_type, length_type> structure_id_and_distance_pair;
     typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
diff --git a/World.hpp b/World.hpp
index f4068ab2..26ccb18f 100644
--- a/World.hpp
+++ b/World.hpp
@@ -174,7 +174,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<const structure_id_type, length_type> structure_id_and_distance_pair;
+    typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
 
 protected:
     typedef std::map<species_id_type, species_type> species_map;
@@ -299,7 +299,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             throw not_found(std::string("No structures found."));
                  
         case 1:
-            return structure_id_and_distance_pair( NULL , 2*base_type::world_size() );
+            return structure_id_and_distance_pair( (*structures.begin())->id() , 2*base_type::world_size() );
         
         case 2:
         {
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index dae74c41..c5fb5dde 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -52,6 +52,7 @@ class newBDPropagator
     typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
     typedef typename traits_type::volume_clearer_type volume_clearer_type;
 
+
 public:
     template<typename Trange_>
     newBDPropagator(
@@ -99,98 +100,143 @@ class newBDPropagator
             ++rejected_move_count_;
             return true;
         }
+        
+        species_type const species(tx_.get_species(pp.second.sid()));
+        length_type const r0( species.radius() );
+        boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( species.structure_id() ) );
+        
+        structure_id_and_distance_pair struct_id_distance_pair;
+        length_type core_surface_distance = 0;
+        position_type new_pos;
+        
+       /* Sample a potential move, and check if the particle _core_ has overlapped with another 
+          particle or surface. If this is the case the particlem bounces, and is returned
+          to it's original position. For a particle with D = 0, new_pos = old_pos */        
+        if (species.D() != 0.)
+        {
 
-        //TODO Particels D = 0 can still react with particles in their reaction volume.
-        const species_type species(tx_.get_species(pp.second.sid()));
-        if (species.D() == 0.)
-            return true;
-
-        /* Make a step, dependent on the surface the particle lives on. */
-        position_type const displacement( tx_.get_structure(species.structure_id())->
+            // Make a step, dependent on the surface the particle lives on.
+            position_type const displacement( tx_.get_structure(species.structure_id())->
                                             bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
 
-        position_type const new_pos(tx_.apply_boundary( add( pp.second.position(), displacement ) ));
-
-	    /*Use a spherical shape with radius = particle_radius + reaction_length.
-	      We use it to check for overlaps with other particels and surfaces.*/
-        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
-            tx_.check_overlap(particle_shape_type( new_pos, species.radius() + reaction_length_ ), pp.first));
-                  
-        bool bounced = false;      
-        switch (overlapped ? overlapped->size(): 0)
+            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
+            
+        }
+        else
         {
-        case 0:
-            break;
+            new_pos = pp.second.position();
+        }
+        
+        /* Use a spherical shape with radius = particle_radius + reaction_length.
+	       We use it to check for overlaps with other particels. */
+        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+                tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
+        int particles_in_overlap(overlapped ? overlapped->size(): 0);
 
-        case 1:
+        /* Check if the particle at new_pos overlaps with any particle cores. */        
+        bool bounced = false;       
+        for( int i = 0; i < particles_in_overlap; i++ )
         {
-            particle_id_pair_and_distance const& closest(overlapped->at(0));
-            length_type r01( pp.second.radius() + closest.first.second.radius() );
-            
-            /* If the particle cores overlapped, the move is rejected (bounced) but the particles can still react. */
-		    if( closest.second < pp.second.radius() )
+            if( overlapped->at(i).second < r0 )
             {
                 bounced = true;
+                break;
+            }
+        }
+        
+        /* If the particle has not bounced with a particle and lives in the bulk: 
+           check for core overlap with a surface. */
+        if(!bounced && pp_structure->id() == "world")
+        {
+            /* Check for overlap with nearest surface. */
+            struct_id_distance_pair = tx_.get_closest_surface( new_pos );
+            core_surface_distance = struct_id_distance_pair.second - r0;
+        
+            if(core_surface_distance < 0)
+                bounced = true;
+        }         
+         
+        /* If particle is bounced, check reaction_volume for reaction parners at old_pos. */     
+        if(bounced)
+        {
+            new_pos = pp.second.position();
             
-                LOG_DEBUG(("Hard core collision with a particle %s. Particle bounced", boost::lexical_cast<std::string>(closest.first.first).c_str()));
-		        ++rejected_move_count_;
-
-                /* If the particle was outside the reaction volume before the move, nothing is to be done for this particle => break*/
-                if(tx_.distance( pp.second.position(), closest.first.second.position() ) > r01 + reaction_length_ )
-    		        break;
-    		        
-    		    try
-                {
-                    if( attempt_reaction(pp, closest.first) )
-                        return true;
-                    else                
-                    {
-                        LOG_DEBUG(("Bounced particle attempted a reaction with a nonreactive particle %s.", boost::lexical_cast<std::string>(closest.first.first).c_str()));
-                        ++rejected_move_count_;
-                    }
-                }
-                catch (propagation_error const& reason)
+            boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_after_bounce( 
+                    tx_.check_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), 
+                            pp.first) );
+                            
+            overlapped.swap( overlapped_after_bounce );
+                                            
+            particles_in_overlap = overlapped ? overlapped->size(): 0; 
+                
+            struct_id_distance_pair = tx_.get_closest_surface( new_pos );
+            core_surface_distance = struct_id_distance_pair.second - r0;  
+        }
+        
+        /* If their is only a surface in the reaction volume, attempt interaction. */
+        if(particles_in_overlap == 0 && core_surface_distance < reaction_length_ && pp_structure->id() == "world")
+        {
+            try
+            {
+                if( false /*attempt_reaction(pp, pp_surface)*/ )
+                    return true;
+                else                
                 {
-                    log_.info("second-order reaction rejected (reason: %s)", reason.what());
+                    LOG_DEBUG(("Particle attempted an interaction with the nonreactive surface %s.", 
+                        boost::lexical_cast<std::string>(pp_structure->id()).c_str()));
                     ++rejected_move_count_;
                 }
-                /* If no reaction has occurred */    
-                break;
             }
-            else
+            catch (propagation_error const& reason)
             {
-                try
-                {
-                    if( attempt_reaction(pp, closest.first) )
-                        return true;
-
-                    LOG_DEBUG(("Non-bounced particle attempted a reaction with a nonreactive particle %s.", boost::lexical_cast<std::string>(closest.first.first).c_str()));
+                log_.info("surface interaction rejected (reason: %s)", reason.what());
+                ++rejected_move_count_;
+            }
+        }
+         
+        switch (particles_in_overlap)
+        {
+        case 0:
+            break;
 
-                }
-                catch (propagation_error const& reason)
+        case 1:
+        {
+            
+        
+            particle_id_pair_and_distance const& closest(overlapped->at(0));
+            //length_type r01( pp.second.radius() + closest.first.second.radius() );
+ 		        
+    		try
+            {
+                if( attempt_reaction(pp, closest.first) )
+                    return true;
+                else                
                 {
-                    log_.info("second-order reaction rejected (reason: %s)", reason.what());
+                    LOG_DEBUG(("Particle attempted a reaction with a nonreactive particle %s.", 
+                        boost::lexical_cast<std::string>(closest.first.first).c_str()));
                     ++rejected_move_count_;
-                }                    
+                }
+            }
+            catch (propagation_error const& reason)
+            {
+                log_.info("second-order reaction rejected (reason: %s)", reason.what());
+                ++rejected_move_count_;
             }
-            break;              
+            /* If no reaction has occurred */    
+            break;
         }
-
         default:
-            log_.info("collision involving two or more particles; move rejected");
+            log_.info("Multiple objects (surface and/or particle) in reaction volume; moved but no reaction initiated.");
             ++rejected_move_count_;
-            return true;
+            break;
         }
-        
-        //Check for overlap with nearest surface. -NO SURFACES YET.
-        //structure_id_and_distance_pair str_id_distance( tx_.get_closest_surface( new_pos ) );
-                
-        //If the particle did not bounce, update to new position.
+                       
+        /* If the particle did not bounce, update to new position. */
         if(!bounced)
         {
                 
             particle_id_pair particle_to_update( pp.first, 
-                        particle_type(species.id(), particle_shape_type(new_pos, species.radius()), species.D()) );
+                        particle_type(species.id(), particle_shape_type(new_pos, r0), species.D()) );
                 
             if (vc_)
             {
@@ -215,6 +261,26 @@ class newBDPropagator
 
 private:
 
+    position_type const make_move(species_type const& species, position_type const& np, particle_id_type const& ignore)
+    {
+        boost::shared_ptr<structure_type> pp_structure( tx_.get_structure( species.structure_id() ) );
+    
+        position_type displacement( pp_structure->
+                                        bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
+
+        position_type new_pos(tx_.apply_boundary( add( np, displacement ) ));
+                        
+        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+                                    tx_.check_overlap(
+                                    particle_shape_type(new_pos, species.radius()),
+                                    ignore));
+                                    
+        if ( !(overlapped && overlapped->size() > 0) )
+            return new_pos;
+        else
+            return np;    
+    }
+
     bool attempt_reaction(particle_id_pair const& pp)
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
@@ -286,7 +352,7 @@ class newBDPropagator
                         boost::shared_ptr<structure_type> pp_structure( 
                                 tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) ); 
                                 
-                        /* Place the two product particles inside the reaction volume and check if the volume is empty. */
+                        /* Create an ipv between the products which lies within the reation volume; check for free space. */
                         for (;;)
                         {
                             if (--i < 0)
@@ -313,35 +379,10 @@ class newBDPropagator
                                 break;
                         }
 
-                        /* After dissociation both particles are allowed to move. 
-                           Move particle #0 */
-                        position_type displacement( pp_structure->
-                                            bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
-
-                        position_type new_pos(tx_.apply_boundary( add( np0, displacement ) ));
-                        
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped1(
-                                tx_.check_overlap(
-                                    particle_shape_type(new_pos, s0.radius()),
-                                    pp.first));
-                                    
-                        if ( !(overlapped1 && overlapped1->size() > 0) )
-                            np0 = new_pos;
-                        
-                        //Move particle #1   
-                        displacement = pp_structure->bd_displacement(s1.v() * dt_, std::sqrt(2.0 * s1.D() * dt_), rng_);
-
-                        new_pos = tx_.apply_boundary( add( np1, displacement ) );
-                        
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped2(
-                                tx_.check_overlap(
-                                    particle_shape_type(new_pos, s1.radius()),
-                                    pp.first ));
-                                    
-                        if ( !(overlapped2 && overlapped2->size() > 0) )
-                            np1 = new_pos;
-                            
+                        /* After dissociation both particles are allowed to move. */
+                        np0 = make_move(s0, np0, pp.first);
                         
+                        np1 = make_move(s1, np1, pp.first);                      
 
                         if (vc_)
                         {
@@ -477,7 +518,7 @@ class newBDPropagator
     }
     
     /*
-    bool attempt_reaction(particle_id_pair const& pp, structure_id_type const& structure_id)
+    bool attempt_reaction(particle_id_pair const& pp, structure_type const& structure)
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), structure_id));
         if (::size(rules) == 0)

From 9135a6efe16341b2b81f8995c1146ec64a0108b3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 14 Oct 2011 14:20:19 +0200
Subject: [PATCH 0285/1541] implemented forward transform for MixedPair

---
 pair.py | 39 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 23bf5ab9..db0b579b 100644
--- a/pair.py
+++ b/pair.py
@@ -630,7 +630,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 #        new_iv = r * math.cos(new_angle) * unit_x + \
 #                 r * math.sin(new_angle) * unit_y
 
-	new_iv = (r/r0) * rotate_vector(old_iv, unit_z, theta)
+	new_iv = (r/r0) * rotate_vector(old_iv, self.structure.shape.unit_z, theta)
 	# note that unit_z can point two ways rotating the vector clockwise or counterclockwise
 	# because theta is symmetric this doesn't matter.
 
@@ -760,6 +760,43 @@ def get_scaling_factor(self):
 	return math.sqrt(self.D_r/D_2)
     z_scaling_factor = property(get_scaling_factor)
 
+    @staticmethod
+    def do_transform(single1, single2, world):
+
+	pos1 = single1.pid_particle_pair[1].position
+	pos2 = single2.pid_particle_pair[1].position
+	D_1 = single1.pid_particle_pair[1].D
+	D_2 = single2.pid_particle_pair[1].D
+
+	surface = single1.structure
+	# we assume that the particle of single1 lives on the membrane
+	assert isinstance(surface, PlanarSurface)
+
+	# the CoM is calculated in a similar way to a normal 3D pair
+	com = (D_2 * pos1 + D_1 * pos) / (D_1 + D_2)
+	# and then projected onto the plane
+	com = world.cyclic_transpose(com, surface.shape.position)
+	com, _ = surface.projected_point (com)
+
+
+	# calculate the interparticle vector
+	pos2t = world.cyclic_transpose(pos2, pos1)
+        iv = pos2t - pos1
+
+	# calculate the scaling factor due to anisotropic diffusion of iv
+	z_scaling_factor = math.sqrt((D_1 + D_2)/D_2)
+
+	# move and recale the iv in the axis normal to the plane
+	iv_z = surface.shape.unit_z * numpy.dot (iv, surface.shape.unit_z)
+	iv_z_length = length(iv_z)
+
+	new_iv_z_length = (iv_z_length - single2.pid_particle_pair[1].radius) * z_scaling_factor
+	new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
+
+	iv = iv - iv_z + new_iv_z
+
+	return com, iv
+
     def do_back_transform(self, com, iv):
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D

From 9b7011e8c31dc67c55de3f80d7494a684888245b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 14 Oct 2011 15:04:54 +0200
Subject: [PATCH 0286/1541] implemented do_transform for SimplePair too

---
 pair.py | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/pair.py b/pair.py
index db0b579b..e563df67 100644
--- a/pair.py
+++ b/pair.py
@@ -319,6 +319,22 @@ def get_com(self):
         return self.shell.shape.position
     com = property(get_com)
 
+    @staticmethod
+    def do_transform(single1, single2, world):
+
+	pos1 = single1.pid_particle_pair[1].position
+	pos2 = single2.pid_particle_pair[1].position
+	D1 = single1.pid_particle_pair[1].D
+	D2 = single2.pid_particle_pair[1].D
+
+	com = world.calculate_pair_CoM(pos1, pos2, D1, D2)
+	com = world.apply_boundary(com)
+
+        pos2t = world.cyclic_transpose(pos2, pos1)
+        iv = pos2t - pos1
+
+	return com, iv
+
     def do_back_transform(self, com, iv):
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
@@ -632,7 +648,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
 	new_iv = (r/r0) * rotate_vector(old_iv, self.structure.shape.unit_z, theta)
 	# note that unit_z can point two ways rotating the vector clockwise or counterclockwise
-	# because theta is symmetric this doesn't matter.
+	# Since theta is symmetric this doesn't matter.
 
         return new_iv
 
@@ -772,12 +788,13 @@ def do_transform(single1, single2, world):
 	# we assume that the particle of single1 lives on the membrane
 	assert isinstance(surface, PlanarSurface)
 
+
 	# the CoM is calculated in a similar way to a normal 3D pair
 	com = (D_2 * pos1 + D_1 * pos) / (D_1 + D_2)
 	# and then projected onto the plane
 	com = world.cyclic_transpose(com, surface.shape.position)
 	com, _ = surface.projected_point (com)
-
+	com = world.apply_boundary(com)
 
 	# calculate the interparticle vector
 	pos2t = world.cyclic_transpose(pos2, pos1)
@@ -826,10 +843,10 @@ def get_sigma(self):
 	# This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
 	# different than the sums of the radii of the particleso
 	xi = self.z_scaling_factor
-	xi_inv = 1/xi
+	xi_inv = 1.0/xi
 	alpha = math.acos(xi_inv)
 	sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
-	rho = abs(sigma*math.sqrt(0.5 + (alpha*xi/(2.0*math.sin(alpha)))))
+	rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
 	return rho
     sigma = property (get_sigma)
 

From 6cdab894e115842fa0b0a077faa307576e6fab64 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 14 Oct 2011 17:13:24 +0200
Subject: [PATCH 0287/1541] small fixes + comments

---
 egfrd.py |  3 +--
 pair.py  | 10 +++++-----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7021ee2d..02075a78 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -741,8 +741,6 @@ def fire_single_reaction(self, single, reactant_pos):
 
             
         elif len(rr.products) == 2:
-	# TODO (one of the) product particles can live on different structure
-
 	    # 1. get product info
             product1_species = self.world.get_species(rr.products[0])
             product2_species = self.world.get_species(rr.products[1])
@@ -889,6 +887,7 @@ def fire_single_reaction(self, single, reactant_pos):
                     if __debug__:
                         log.info('products (%s) = %s' % (len(products), products))
 
+		    # exit the loop, we have found new positions
                     break
             else:
                 if __debug__:
diff --git a/pair.py b/pair.py
index e563df67..108348e4 100644
--- a/pair.py
+++ b/pair.py
@@ -210,9 +210,9 @@ def get_min_shell_size(single1, single2, geometrycontainer):
             'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
             (single1, single2, FORMAT_DOUBLE % distance_from_sigma)
 
-        shell_size1 = r0 * D1 / D12 + radius1
+        shell_size1 = r0 * D1 / D12 + radius1	# distance_from_CoM + particle_radius
         shell_size2 = r0 * D2 / D12 + radius2
-        shell_size_margin1 = radius1 * 2
+        shell_size_margin1 = radius1 * 2	# SINGLE_SHELL_FACTOR??
         shell_size_margin2 = radius2 * 2
         shell_size_with_margin1 = shell_size1 + shell_size_margin1
         shell_size_with_margin2 = shell_size2 + shell_size_margin2
@@ -739,9 +739,9 @@ def get_min_shell_dimensions(single1, single2, reference_point, geometrycontaine
 	
 
 	dz_left = pid_particle_pair1[1].radius
-	dz_right = particle12_dist_z + pid_particle_pair2[1].radius * SINGLE_SHELL_FACTOR
-	dr = max(particle1com_dist_r + radius1 * SINGLE_SHELL_FACTOR,
-		 particle2com_dist_r + radius2 * SINGLE_SHELL_FACTOR)
+	dz_right = particle12_dist_z + pid_particle_pair2[1].radius * Domain.SINGLE_SHELL_FACTOR
+	dr = max(particle1com_dist_r + radius1 * Domain.SINGLE_SHELL_FACTOR,
+		 particle2com_dist_r + radius2 * Domain.SINGLE_SHELL_FACTOR)
 
 	return dr, dz_left, dz_right
 

From 7ab55914ce0aa2cd3ff6f15bb26a82779672030a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 17 Oct 2011 14:41:33 +0200
Subject: [PATCH 0288/1541] cleaned up get_min_shell_size for SimplePair Not
 that much changed but its meaning is much clearer now

---
 egfrd.py | 14 +++++++-------
 pair.py  | 41 ++++++++++++++++++++---------------------
 2 files changed, 27 insertions(+), 28 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 02075a78..f8011748 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1244,9 +1244,9 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
 
 	# 1. Get the minimal possible shell size (including margin?)
-        min_shell_size, shell_size_margin = \
+        min_shell_size = \
 	    SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
-        min_shell_size_with_margin = min_shell_size + shell_size_margin
+#        min_shell_size_with_margin = min_shell_size + shell_size_margin
 
 
 	# 2. Get the maximum possible shell size
@@ -1255,19 +1255,19 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
 
 	# 3. Calculate the maximum based on some other criterium (convergence?)
-        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin
-	max_shell_size = min(max_shell_size, convergence_max)
+#        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin		# FIXME
+#	max_shell_size = min(max_shell_size, convergence_max)
 
 
         # 4. Check if min shell size for the Pair not larger than max shell size or 
         # sim cell size.
-        if min_shell_size_with_margin >= max_shell_size:
+        if min_shell_size >= max_shell_size:
             if __debug__:
                 log.debug('%s not formed: min_shell_size %s >='
                           'max_shell_size %s' %
                           ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
                                              single2.pid_particle_pair[0]),
-                           FORMAT_DOUBLE % min_shell_size_with_margin,
+                           FORMAT_DOUBLE % min_shell_size,
                            FORMAT_DOUBLE % max_shell_size))
             return None, None, None
 
@@ -1298,7 +1298,7 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
         shell_size = min(shell_size, max_shell_size)
 
-        assert shell_size >= min_shell_size_with_margin
+        assert shell_size >= min_shell_size
         assert shell_size <= max_shell_size
 
 	if __debug__:
diff --git a/pair.py b/pair.py
index 108348e4..2371be19 100644
--- a/pair.py
+++ b/pair.py
@@ -187,7 +187,7 @@ class SimplePair(Pair):
     @staticmethod
     def get_min_shell_size(single1, single2, geometrycontainer):
         # 1. Determine min shell size for a putative SimplePair.
-	# TODO Note that the calculation is dimension independent. Alse
+	# TODO Note that the calculation is dimension independent. Also
 	# 'size' is not the right term here
 
         assert single1.structure == single2.structure
@@ -197,33 +197,32 @@ def get_min_shell_size(single1, single2, geometrycontainer):
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
 
+#        assert (pos1 - single1.shell.shape.position).sum() == 0        # TODO Not sure why this is here
         sigma = radius1 + radius2
+        r0 = geometrycontainer.world.distance(pos1, pos2)
+#        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
+        assert r0 >= sigma, \
+            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
+            (single1, single2, FORMAT_DOUBLE % (r0 - sigma))
 
+	# calculate the minimum shell size for the interparticle domain
         D1 = single1.pid_particle_pair[1].D
         D2 = single2.pid_particle_pair[1].D
         D12 = D1 + D2
+        dist_from_com1 = r0 * D1 / D12			# distance_from_CoM
+        dist_from_com2 = r0 * D2 / D12
+        iv_shell_size1 = dist_from_com1 + radius1	# radius surrounds the particles
+        iv_shell_size2 = dist_from_com2 + radius2
 
-#        assert (pos1 - single1.shell.shape.position).sum() == 0        # TODO Not sure why this is here
-        r0 = geometrycontainer.world.distance(pos1, pos2)
-        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
-        assert distance_from_sigma >= 0, \
-            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
-            (single1, single2, FORMAT_DOUBLE % distance_from_sigma)
-
-        shell_size1 = r0 * D1 / D12 + radius1	# distance_from_CoM + particle_radius
-        shell_size2 = r0 * D2 / D12 + radius2
-        shell_size_margin1 = radius1 * 2	# SINGLE_SHELL_FACTOR??
-        shell_size_margin2 = radius2 * 2
-        shell_size_with_margin1 = shell_size1 + shell_size_margin1
-        shell_size_with_margin2 = shell_size2 + shell_size_margin2
-        if shell_size_with_margin1  >= shell_size_with_margin2:
-            min_shell_size = shell_size1
-            shell_size_margin = shell_size_margin1
-        else:
-            min_shell_size = shell_size2
-            shell_size_margin = shell_size_margin2
+	# also fix the minimum shellsize for the CoM domain
+	com_shell_size1 = radius1
+	com_shell_size2 = radius2
+
+	# calculate total radii including the minimal shell size for the particles
+	shell_size1 = iv_shell_size1 + com_shell_size1 + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR)
+	shell_size2 = iv_shell_size2 + com_shell_size2 + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR)
 
-	return min_shell_size, shell_size_margin
+	return max(shell_size1, shell_size2)
 
 
     @staticmethod

From 6d182a458506b68bc93559adfe9fc5a249e3c0ae Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 17 Oct 2011 14:56:09 +0200
Subject: [PATCH 0289/1541] small cleanup and changes to shell making for
 SimplePair

---
 egfrd.py | 23 ++++++++++-------------
 pair.py  |  6 +++---
 2 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f8011748..987862f6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1232,28 +1232,25 @@ def calculate_simplepair_shell_size(self, single1, single2):
         radius2 = single2.pid_particle_pair[1].radius
         sigma = radius1 + radius2
 
-        r0 = self.world.distance(pos1, pos2)
-        distance_from_sigma = r0 - sigma	# the distance between the surfaces of the particles
-
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-        D12 = D1 + D2
+#        r0 = self.world.distance(pos1, pos2)
 
-        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-        com = self.world.apply_boundary(com)
+#        D1 = single1.pid_particle_pair[1].D
+#        D2 = single2.pid_particle_pair[1].D
+#        D12 = D1 + D2
 
+#        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+#        com = self.world.apply_boundary(com)
+	com, iv = SimplePair.do_transform(single1, single2, self.world)
+	r0 = length (iv)
+        distance_from_sigma = r0 - sigma	# the distance between the surfaces of the particles
 
 	# 1. Get the minimal possible shell size (including margin?)
-        min_shell_size = \
-	    SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
-#        min_shell_size_with_margin = min_shell_size + shell_size_margin
-
+        min_shell_size = SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
 
 	# 2. Get the maximum possible shell size
 	max_shell_size = SimplePair.get_max_shell_size(com, single1, single2,
 						       self.geometrycontainer, self.domains)
 
-
 	# 3. Calculate the maximum based on some other criterium (convergence?)
 #        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin		# FIXME
 #	max_shell_size = min(max_shell_size, convergence_max)
diff --git a/pair.py b/pair.py
index 2371be19..9296c2b5 100644
--- a/pair.py
+++ b/pair.py
@@ -209,16 +209,16 @@ def get_min_shell_size(single1, single2, geometrycontainer):
         D1 = single1.pid_particle_pair[1].D
         D2 = single2.pid_particle_pair[1].D
         D12 = D1 + D2
-        dist_from_com1 = r0 * D1 / D12			# distance_from_CoM
+        dist_from_com1 = r0 * D1 / D12			# particle distance from CoM
         dist_from_com2 = r0 * D2 / D12
-        iv_shell_size1 = dist_from_com1 + radius1	# radius surrounds the particles
+        iv_shell_size1 = dist_from_com1 + radius1	# the shell should surround the particles
         iv_shell_size2 = dist_from_com2 + radius2
 
 	# also fix the minimum shellsize for the CoM domain
 	com_shell_size1 = radius1
 	com_shell_size2 = radius2
 
-	# calculate total radii including the minimal shell size for the particles
+	# calculate total radii including the margin for the burst volume for the particles
 	shell_size1 = iv_shell_size1 + com_shell_size1 + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR)
 	shell_size2 = iv_shell_size2 + com_shell_size2 + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR)
 

From 0db5dd398aa54235a89b40fd6a12bf44c3e740ac Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 17 Oct 2011 16:06:44 +0200
Subject: [PATCH 0290/1541] completed MixedPair.get_min_shell_dimensions

---
 pair.py | 53 ++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 38 insertions(+), 15 deletions(-)

diff --git a/pair.py b/pair.py
index 9296c2b5..9b672abc 100644
--- a/pair.py
+++ b/pair.py
@@ -215,14 +215,13 @@ def get_min_shell_size(single1, single2, geometrycontainer):
         iv_shell_size2 = dist_from_com2 + radius2
 
 	# also fix the minimum shellsize for the CoM domain
-	com_shell_size1 = radius1
-	com_shell_size2 = radius2
+	com_shell_size = max(radius1, radius2)
 
 	# calculate total radii including the margin for the burst volume for the particles
-	shell_size1 = iv_shell_size1 + com_shell_size1 + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR)
-	shell_size2 = iv_shell_size2 + com_shell_size2 + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR)
+	shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
+			 iv_shell_size2 + com_shell_size + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
 
-	return max(shell_size1, shell_size2)
+	return shell_size
 
 
     @staticmethod
@@ -727,20 +726,44 @@ class MixedPair(Pair):
 
     @staticmethod
     def get_min_shell_dimensions(single1, single2, reference_point, geometrycontainer):
-	# TODO incomplete
 
 	assert isinstance (single1.structure, PlanarSurface)
 	assert isinstance (single2.structure, CuboidalRegion)
 
-	pid_particle_pair1 = single1.pid_particle_pair
-	pid_particle_pair2 = single2.pid_particle_pair
-
-	
-
-	dz_left = pid_particle_pair1[1].radius
-	dz_right = particle12_dist_z + pid_particle_pair2[1].radius * Domain.SINGLE_SHELL_FACTOR
-	dr = max(particle1com_dist_r + radius1 * Domain.SINGLE_SHELL_FACTOR,
-		 particle2com_dist_r + radius2 * Domain.SINGLE_SHELL_FACTOR)
+	pos1 = single1.pid_particle_pair[1].position
+	pos2 = single2.pid_particle_pair[1].position
+	radius1 = single1.pid_particle_pair[1].radius
+	radius2 = single2.pid_particle_pair[1].radius
+	D1 = single1.pid_particle_pair[1].D
+	D2 = single2.pid_particle_pair[1].D
+	D12 = D1 + D2
+
+	# calculate the interparticle vector and project it onto the coordinate system of the structure
+	# of particle1
+	pos2_t = geometrycontainer.world.cyclic_transpose(pos2, pos1)
+	iv = pos2_t - pos1
+	iv_x = numpy.dot(iv, single1.structure.shape.unit_x)
+	iv_y = numpy.dot(iv, single1.structure.shape.unit_y)
+	iv_z = numpy.dot(iv, single1.structure.shape.unit_z)
+
+	# calculate the minimal dimensions of the iv shell (it fits perfectly around the particles)
+	iv_shell_z = abs(iv_z) + radius2
+
+	len_iv_projected = math.sqrt(iv_x*iv_x + iv_y*iv_y)
+	dist_r_from_com1 = len_iv_projected * D1 / D12
+	dist_r_from_com2 = len_iv_projected * D2 / D12
+	iv_shell_radius1 = dist_r_from_com1 + radius1
+	iv_shell_radius2 = dist_r_from_com2 + radius2
+
+	# fix the minimum shell size for the CoM domain
+	com_shell_radius = max(radius1, radius2)
+
+	# calculate the minimal dimensions of the protective domain including space for the
+	# burst volumes of the particles
+	dz_left = radius1
+	dz_right = iv_shell_z + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR)
+	dr = max(iv_shell_radius1 + com_shell_radius + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
+		 iv_shell_radius2 + com_shell_radius + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
 
 	return dr, dz_left, dz_right
 

From 9eb6f06021829d760b0ad1dd726da76fec62981c Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 17 Oct 2011 18:04:45 +0200
Subject: [PATCH 0291/1541] Added decay-from-surface methods to the structure
 classes. special_geminate_dissociation_vector method for decay of a particle
 in two particles in bulk and surface. And added method for direct decay into
 bulk.

---
 CuboidalRegion.hpp     | 33 +++++++++++------
 CylindricalSurface.hpp | 54 ++++++++++++++++++++++++++--
 PlanarSurface.hpp      | 45 ++++++++++++++++++++++-
 Structure.hpp          |  8 +++--
 newBDPropagator.hpp    | 81 ++++++++++++++++++++++++++++++++++++------
 5 files changed, 193 insertions(+), 28 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 747e9421..11d916c1 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -67,26 +67,37 @@ class CuboidalRegion
 
     virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
     {
-        length_type r01( r0 + r1 );
-        length_type r01l( r01 + rl );
-        length_type r01l_sq( r01l * r01l );
-        length_type r01_sq( r01 * r01 );
+        length_type const r01( r0 + r1 );
+        length_type const r01l( r01 + rl );
+        length_type const r01l_cb( r01l * r01l * r01l );
+        length_type const r01_cb( r01 * r01 * r01 );
 
-        return 4.0/3.0 * M_PI * ( r01l_sq * r01l - r01_sq * r01 );
+        return 4.0/3.0 * M_PI * ( r01l_cb - r01_cb );
     }
 
-    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
-        Real X( rng.uniform(0.,1.) );
+        return position_type(); //No dissociation 'from' the bulk
+    }
+
+    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    {
+        Real const X( rng.uniform(0.,1.) );
 
-        length_type r01l( r01 + rl );
-        length_type r01l_sq( r01l * r01l );
-        length_type r01_sq( r01 * r01 );
+        length_type const r01l( r01 + rl );
+        length_type const r01l_cb( r01l * r01l * r01l );
+        length_type const r01_cb( r01 * r01 * r01 );
         
-        length_type diss_vec_length( cbrt( X * (r01l_sq * r01l - r01_sq * r01) + r01_sq*r01 ) );
+        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );
 
         return random_vector( diss_vec_length, rng );
     }
+    
+    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_bulk, length_type const& r_surf, 
+                                                                length_type const& rl ) const
+    {
+        return position_type(); //No dissociation 'from' the bulk
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 2cfaa40d..c621f3e3 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -77,15 +77,63 @@ class CylindricalSurface
     {
         return 2*rl;
     }
-
-    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    
+    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         Real X( rng.uniform(0.,1.) );
+        length_type const rod_radius = base_type::shape().radius();
+        position_type const unit_z = base_type::shape().unit_z();
+
+        length_type const r0rrl( rod_radius + r0 + rl );
+        length_type const r0rrl_sq( r0rrl * r0rrl );
+        length_type const r0rr_sq( (r0 + rod_radius) * (r0 + rod_radius) );
         
-        length_type diss_vec_length( X*rl + r01 );
+        length_type const diss_vec_length( sqrt( X * (r0rrl_sq - r0rr_sq) + r0rr_sq ) );
+
+
+        position_type v(rng_() - .5, rng_() - .5, rng_() - .5);        
+        v = normalize( substract(v, dot_product( unit_z, v ) * unit_z) );
+         
+        return multiply( v, diss_vec_length); 
+    }
+
+    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    {
+        Real const X( rng.uniform(0.,1.) );
+        
+        length_type const diss_vec_length( X*rl + r01 );
 
         return random_vector( diss_vec_length, rng );
     }
+    
+    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_bulk, length_type const& r_surf, 
+                                                                length_type const& rl ) const
+    {
+        length_type const r01( r_bulk + r_surf );
+          
+        Real const theta_min( asin(r_bulk / ( r01 )) );       
+        Real const theta( theta_min + rng.uniform(0.,1.) * (M_PI - 2 * theta_min) );        
+        Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
+        
+        Real const X( rng.uniform(0.,1.) );
+        length_type const r01l( r01 + rl );
+        length_type const r01l_cb( r01l * r01l * r01l );
+        length_type const r01_cb( r01 * r01 * r01 );
+        
+        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb) + r01_cb ) );
+        
+        position_type const unit_z( base_type::shape().unit_z() );      
+        position_type const unit_x( normalize( substract( [1,1,1], 
+                                        product( dot_product([1,1,1], unit_z), unit_z ) ) ) );
+        position_type const unit_y( normalize( cross_product( unit_x, unit_z ) ) );
+                
+        length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
+        length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
+        length_type const z( diss_vec_length * cos( theta ) );
+                        
+        return position_type diss_vec( add( unit_x * x, 
+                                        add( unit_y * y, unit_z * z ) ) ); 
+    }
 
     virtual length_type minimal_distance(length_type const& radius) const
     {
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index f43b3f85..b2e64323 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -71,8 +71,21 @@ class PlanarSurface
 
         return M_PI * ( r01l_sq - r01_sq );
     }
+    
+    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
+    {
+        Real X( rng.uniform(0.,1.) );
+        
+        length_type diss_vec_length( X*rl + r0 );
+
+        position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
 
-    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+        unit_z = normalize ( unit_z );
+
+        return multiply( unit_z, (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
+    }
+
+    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
     {
         Real X( rng.uniform(0.,1.) );
 
@@ -84,6 +97,36 @@ class PlanarSurface
 
         return random_vector( diss_vec_length, rng );
     }
+    
+    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_surf, length_type const& r_bulk, 
+                                                                length_type const& rl ) const
+    {
+        length_type const r01( r_bulk + r_surf );
+        
+        Real const theta_max( asin(r_bulk / ( r01 )) );
+        Real const theta( rng.uniform(0.,1.) * theta_max );        
+        Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
+        
+        Real const X( rng.uniform(0.,1.) );
+
+        length_type const r01l( r01 + rl );
+        length_type const r01l_cb( r01l * r01l * r01l );
+        length_type const r01_cb( r01 * r01 * r01 );
+        
+        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );
+        
+        position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
+        unit_z = normalize ( unit_z );
+        
+        unit_z = multiply(unit_z, rng.uniform_int(0, 1));
+        
+        length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
+        length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
+        length_type const z( diss_vec_length * cos( theta ) );
+                        
+        return position_type diss_vec( add( base_type::shape().unit_x() * x,
+                                        add( base_type::shape().unit_y() * y, unit_z * z ) ) );      
+    }
 
     virtual length_type minimal_distance(length_type const& radius) const
     {
diff --git a/Structure.hpp b/Structure.hpp
index c71a558e..50c4543f 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -56,8 +56,12 @@ class Structure
     virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
 
     virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const = 0;
-
-    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const = 0;
+    
+    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const = 0;
+    
+    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const = 0;
+    
+    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_bulk, length_type const& r_surf, length_type const& rl ) const = 0;
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
     
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index c5fb5dde..c77e3099 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -204,7 +204,6 @@ class newBDPropagator
             
         
             particle_id_pair_and_distance const& closest(overlapped->at(0));
-            //length_type r01( pp.second.radius() + closest.first.second.radius() );
  		        
     		try
             {
@@ -273,12 +272,18 @@ class newBDPropagator
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                                     tx_.check_overlap(
                                     particle_shape_type(new_pos, species.radius()),
-                                    ignore));
+                                    ignore));                            
                                     
-        if ( !(overlapped && overlapped->size() > 0) )
-            return new_pos;
-        else
-            return np;    
+        if ( (overlapped && overlapped->size() > 0) )
+            return np;
+        
+        structure_id_and_distance_pair const struct_id_distance_pair = tx_.get_closest_surface( new_pos );
+        length_type const core_surface_distance = struct_id_distance_pair.second - s0.radius();
+                                    
+        if( core_surface_distance < 0 )
+            return np;
+            
+        return new_pos;
     }
 
     bool attempt_reaction(particle_id_pair const& pp)
@@ -310,11 +315,24 @@ class newBDPropagator
                 case 1:
                     {
                         const species_type s0(tx_.get_species(products[0]));
+                        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species(pp.second.sid()).structure_id() ) );
+                        
+                        position_type new_pos = pp.second.position();
+                        /* If the product particle does NOT live of the same structure => surface -> bulk dissociation. */
+                        if( s0_struct->id() != pp_struct->id() )
+                        {
+                            position_type const displacement( pp_struct->surface_dissociation_vector(rng_, s0.radius(), reaction_length_ ) );
+
+                            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
+                        }
+                      
                         const particle_id_pair new_p(
                             pp.first, particle_type(products[0],
-                                particle_shape_type(pp.second.position(),
+                                particle_shape_type(new_pos,
                                                     s0.radius()),
                                                     s0.D()));
+                                                    
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_p.second.shape(), new_p.first));
                         if (overlapped && overlapped->size() > 0)
                         {
@@ -349,9 +367,46 @@ class newBDPropagator
                         int i = max_retry_count_;
                         position_type np0, np1;
 
-                        boost::shared_ptr<structure_type> pp_structure( 
-                                tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) ); 
+                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id() ) ); 
+                        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+                        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
+                        
+                        /* If the product particles do NOT live on the same structure => surface -> surface + bulk dissociation. */
+                        if( s0_struct->id() != s1_struct->id() )
+                        {
+                            D0_Dr = s0.D() / ( s0.D() + s1.D() );
+                            D1_Dr = s1.D() / ( s0.D() + s1.D() );                        
+                        
+                            if(s0_struct->id() == "world")
+                            {
+                                position_type m( pp_struct->
+                                    special_geminate_dissociation_vector( rng_, s0.radius(), s1.radius(), reaction_length_ ) );
                                 
+                                
+                                
+                                np0 = tx_.apply_boundary(pp.second.position()
+                                    - m * (s0.D() / D01));
+                                np1 = tx_.apply_boundary(pp.second.position()
+                                    + m * (s1.D() / D01));
+                            }
+                            else
+                            {
+                                position_type m( pp_struct->
+                                    special_geminate_dissociation_vector( rng_, s1.radius(), s0.radius(), reaction_length_ ) );
+                                
+                                np0 = tx_.apply_boundary(pp.second.position()
+                                    - m * (s0.D() / D01));
+                                np1 = tx_.apply_boundary(pp.second.position()
+                                    + m * (s1.D() / D01));
+                            }
+                            
+
+
+                            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
+                        }
+                        
+                        //Don't forget make_move after dissociation!
+                        
                         /* Create an ipv between the products which lies within the reation volume; check for free space. */
                         for (;;)
                         {
@@ -360,7 +415,7 @@ class newBDPropagator
                                 throw propagation_error("no space");
                             } 
                
-                            position_type m( pp_structure->newbd_dissociation_vector( rng_, r01, reaction_length_ ) );
+                            position_type m( pp_struct->geminate_dissociation_vector( rng_, r01, reaction_length_ ) );
                             
                             np0 = tx_.apply_boundary(pp.second.position()
                                     - m * (s0.D() / D01));
@@ -384,6 +439,8 @@ class newBDPropagator
                         
                         np1 = make_move(s1, np1, pp.first);                      
 
+			            //Check wether new positions dont overlap.
+
                         if (vc_)
                         {
                             if (!(*vc_)(particle_shape_type(np0, s0.radius()), pp.first) || !(*vc_)(particle_shape_type(np1, s1.radius()), pp.first))
@@ -438,7 +495,9 @@ class newBDPropagator
             boost::shared_ptr<structure_type> pp_structure( 
                tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
 
-            const Real p( r.k() * dt_ / ( 2 * pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) ) );
+            Real p( r.k() * dt_ / ( pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) ) );
+	    //TODO: Check if it works.
+	    p /= (2 - p);
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)

From 4fa8c252be8dc9dad4b1c3fda2a17d3d61cfd8ed Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 18 Oct 2011 15:11:57 +0200
Subject: [PATCH 0292/1541] imlemented MixedPair.determine_radii Method is much
 simpler than for SimplePair because it doesn't include the balancing of
 estimated first-passage times of CoM and IV. It is implied that the cylinder
 is chosen correctly and only the a_R and a_r have to be derived.

---
 pair.py | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/pair.py b/pair.py
index 9b672abc..d30eefd5 100644
--- a/pair.py
+++ b/pair.py
@@ -527,7 +527,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
         if theta == 0.0:
 	    # no rotation is necessary -> new_iv = new_iv
 	    new_iv = old_iv
-        elif old_iv_theta % numpy.pi != 0.0:
+        elif theta % numpy.pi != 0.0:
 	    # alternative calculation
 	    # rotate the old_iv to the new theta
             rotation_axis = crossproduct_against_z_axis(old_iv)
@@ -779,11 +779,24 @@ def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_ra
 	self.surface = surface	# the surface on which particle1 lives
 	self.r0 = r0	# TODO this needs to be rescaled too
 
-    def determine_radii(self):
-	#TODO INCORRECT
-	a_r = self.shell.shape.half_length*2.0 - self.pid_particle_pair1[1].radius
-	a_R = self.shell.shape.radius - a_r*0.5
-	return 
+    def determine_radii(self, half_length, radius):
+	# determines the dimensions of the domains used for the Green's functions from the dimensions
+	# of the cylindrical shell.
+	# Note that the function assumes that the cylinder is dimensioned properly
+	radius1 = self.pid_particle_pair1[1].radius
+	radius2 = self.pid_particle_pair2[1].radius
+	D1 = self.pid_particle_pair1[1].D
+	D2 = self.pid_particle_pair2[1].D
+	D12 = D1 + D2
+
+	a_r = ((half_length * 2) - radius1 - (2 * radius2)) * self.z_scaling_factor
+
+	# calculate the maximal displacement of a particle given an a_r. Also include its radius
+	space_for_iv = max( (D1/D12) * a_r + radius1,
+			    (D2/D12) * a_r + radius2)
+	a_R = radius - space_for_iv
+
+	return a_R, a_r
 
     def get_com(self):
 	# Note that it is implied that the center of the shell is chosen such that its projection on the

From 382d4ee69dc209a2650a79946d7566a90c744a40 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 18 Oct 2011 18:45:47 +0200
Subject: [PATCH 0293/1541] added some logging to MixedPair.determine_radii

---
 pair.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/pair.py b/pair.py
index d30eefd5..7557deda 100644
--- a/pair.py
+++ b/pair.py
@@ -796,6 +796,18 @@ def determine_radii(self, half_length, radius):
 			    (D2/D12) * a_r + radius2)
 	a_R = radius - space_for_iv
 
+
+        if __debug__:
+            tr = ((a_r - self.r0)**2) / (6 * self.D_r)	# the expected escape time of the iv
+            if self.D_R == 0:
+                tR = numpy.inf 
+            else:
+                tR = (a_R**2) / (4 * self.D_R)		# the expected escape time of the CoM
+            log.debug('tr %g, tR %g' % (tr, tR))
+
+	assert (self.sigma < a_r) and (a_r < half_length*2)
+	assert (0 < a_R) and (a_R < radius)
+
 	return a_R, a_r
 
     def get_com(self):

From 525ce2a043b7e201f2935faf549f34cf1c653e2f Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Wed, 19 Oct 2011 13:44:22 +0200
Subject: [PATCH 0294/1541] Some random changes, not really important, e.g.
 added some comments.

---
 GreensFunction2DRadAbs.cpp      | 123 ++++++++++++++++++---------
 funcSum.cpp                     |   4 +-
 pair.py                         |   1 -
 samples/2d/2dtest.py            |  20 +++--
 samples/2d/GFtool1.py           |  93 --------------------
 samples/2d/v2_GFtool1(space).py | 146 --------------------------------
 6 files changed, 100 insertions(+), 287 deletions(-)
 delete mode 100755 samples/2d/GFtool1.py
 delete mode 100755 samples/2d/v2_GFtool1(space).py

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 6e6898e8..8c0efb19 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -52,7 +52,7 @@ GreensFunction2DRadAbs( const Real D,
     }
     GreensFunction2DRadAbs::clearAlphaTable();
 
-    std::clog << "[alphaoffsettable[0]=" << this->alphaOffsetTable[0] << "]"; //DEBUG
+    // std::clog << "[alphaoffsettable[0]=" << this->alphaOffsetTable[0] << "]"; //DEBUG *REMOVEME*
     ; // do nothing
 }
 
@@ -67,13 +67,13 @@ GreensFunction2DRadAbs::~GreensFunction2DRadAbs()
 
 void GreensFunction2DRadAbs::clearAlphaTable() const
 {
-    std::clog << "[clearing..";
+    // std::clog << "[clearing.."; // DEBUG *REMOVEME*
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
 		   boost::mem_fn( &RealVector::clear ) );
     this->alphaOffsetTable[0] = 0;
     std::fill( this->alphaOffsetTable.begin()+1, this->alphaOffsetTable.end(),
 	       -1 );
-    std::clog << " done]";
+    // std::clog << " done]"; // DEBUG *REMOVEME*
 }
 
 // The method evaluates the equation for finding the alphas for given alpha. This
@@ -243,7 +243,7 @@ GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
 {
     if( this->alphaOffsetTable[n] > 0 )		// if the offset has already been calculated
     {
-    std::clog << "[returning because already calculated;]" ;// DEBUG
+    // std::clog << "[returning because already calculated;]" ;// DEBUG *REMOVEME*
 	return this->alphaOffsetTable[n];	// don't do all the work again   
     }
     assert( this->alphaOffsetTable.size() >= n );	// assume the table is large enough to
@@ -253,7 +253,7 @@ GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
     const Real a( this->geta() );
     const Real interval( M_PI_2 / ( a - sigma ));	// the x-axis of the function scales with a-sigma
 
-    std::clog << "[calculating offset; input={n=" << n << ",sigma="<< sigma <<" , a="<< a <<" , interval="<< interval <<"}]" ;// DEBUG
+    // std::clog << "[calculating offset; input={n=" << n << ",sigma="<< sigma <<" , a="<< a <<" , interval="<< interval <<"}]" ;// DEBUG *REMOVEME*
 
 	Real offset (0);	// by default the offset is zero
 	if (n != 0)
@@ -437,7 +437,7 @@ GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 
 	boost::tuple<Real,Real,Real> result;
 
-	std::clog << "building Y0J0Tables... ";	// DEBUG
+	// std::clog << "building Y0J0Tables... ";	// DEBUG *REMOVEME*
 	
 	for (unsigned int count = 0; count < alphaTable_0.size(); count++)
 	{	result = Y0J0J1_constants(alphaTable_0[count], t);
@@ -447,7 +447,7 @@ GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 		Y0J1J0Y1_Table.push_back (result.get<2>());
 	}
 
-	std::clog << "done" << std::endl;	// DEBUG
+	// std::clog << "done" << std::endl;	// DEBUG *REMOVEME*
 }
 
 
@@ -498,7 +498,7 @@ if (alphaTable[i] == 0)		// if the requested root was not calculated yet
 {
 	if (i==0)		// if the requested root is the first one
 	{	const Real offset (alphaOffset(n));	// The offset is the first root
-        std::clog << "[offset=" << offset << "]";
+        // std::clog << "[offset=" << offset << "]"; // DEBUG *REMOVEME*
 		alphaTable[i]= offset;
 	}
 	else			// the requested root is dependent on the previous one
@@ -649,9 +649,9 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
         if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
         {						// that the table is filled
         	IGNORE_RETURN getAlpha0( maxi );	// this updates the table of roots
-		std::clog << "creating PsurvTable... ";	// DEBUG
+		// std::clog << "creating PsurvTable... ";	// DEBUG *REMOVEME*
                 this->createPsurvTable( psurvTable);	// then the table is filled with data
-		std::clog << "done" << std::endl;	// DEBUG
+		// std::clog << "done" << std::endl;	// DEBUG *REMOVEME*
         }
 //std::cout << "p_survival_2DPair ";
         p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
@@ -1015,7 +1015,7 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
 	const Real r0( this->getr0() );
 
-    std::clog << "[r0=" << r0 << "]";
+    // std::clog << "[r0=" << r0 << "]"; // DEBUG *REMOVEME*
 
 	const Real alpha_sq( alpha * alpha );
 	const Real realm( static_cast<Real>( m ) );
@@ -1035,12 +1035,12 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 //	const Real Jm_sAnm   (s.J(m, s_Anm));
 //	const Real Jmp1_sAnm (s.J(m+1, s_Anm));	// prime
 
-	std::clog << "|";	// DEBUG
+	// std::clog << "|";	// DEBUG *REMOVEME*
 	const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
 	const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
 //	const Real Jm_aAnm   (s.J(m, a_Anm));
 //	const Real Ym_aAnm   (s.Y(m, a_Anm));
-	std::clog << "_";	// DEBUG
+	// std::clog << "_";	// DEBUG *REMOVEME*
 
 	const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
 	const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
@@ -1070,6 +1070,11 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	// calculating the result
 	const Real result( A_n_m * B_n_m_r * exp(-D*alpha_sq*t) );
 
+    // DEBUG *REMOVEME*
+    if (result == 0.0) {
+        std::clog << "Ladies and gentlemen, we've got alpha=0.";
+    }
+    // END DEBUG
 	return result;
 }
 
@@ -1099,12 +1104,12 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 	const Real p_0 ( this->p_m( 0, r, t ) );	// This is the p_m where m is 0, for the denominator
 	p_mTable.push_back( p_0 );			// put it in the table
 
-	std::clog << "m=0, ";	// DEBUG
+	// std::clog << "m=0, ";	// DEBUG *REMOVEME*
 
 	const Real p_1 ( this->p_m( 1, r, t ) / p_0 );
 	p_mTable.push_back( p_1 );			// put the first result in the table
 
-	std::clog << "m=1, ";	// DEBUG
+	// std::clog << "m=1, ";	// DEBUG *REMOVEME*
 
 	if( p_1 == 0 )
 	{
@@ -1125,12 +1130,12 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 			break;
 		}
 
-		std::clog << "m=" << m ;	// DEBUG
+		// std::clog << "m=" << m ;	// DEBUG *REMOVEME*
 
 		p_m_prev_abs = p_m_abs;					// store the previous term
 		const Real p_m( this->p_m( m, r, t ) / p_0 );	// get the next term
 
-		std::clog << ", ";		// DEBUG
+		// std::clog << ", ";		// DEBUG *REMOVEME*
 
 		if( ! std::isfinite( p_m ) )		// if the calculated value is not valid->exit
 		{
@@ -1161,10 +1166,10 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real D( this->getD() );
         const Real r0( this->getr0() );
 
-        std::clog << "[feed the alpha: (m=" << m << ", n= " << n << ")]";
+        // std::clog << "[feed the alpha: (m=" << m << ", n= " << n << ")]"; // DEBUG *REMOVEME*
         const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
        
-        std::clog << "{r0=" << r0 << ", alpha="<< alpha << ", r*alpha="<< r0*alpha << "}";
+        // std::clog << "{r0=" << r0 << ", alpha="<< alpha << ", r*alpha="<< r0*alpha << "}"; // DEBUG *REMOVEME*
 
         const Real alpha_sq( alpha * alpha );
         const Real realm( static_cast<Real>( m ) );
@@ -1175,34 +1180,47 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real a_Anm (a*alpha);
         const Real r0Anm (r0*alpha);
 
-	std::clog << "|";	// DEBUG
+	// std::clog << "|";	// DEBUG *REMOVEME*
         // calculate the needed bessel functions
-        	std::clog << "1";	// DEBUG
+        	// std::clog << "1";	// DEBUG *REMOVEME*
         const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
-        	std::clog << "2";	// DEBUG
+        	// std::clog << "2";	// DEBUG *REMOVEME*
         const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    // prime
-        	std::clog << "3";	// DEBUG
+        	// std::clog << "3";	// DEBUG *REMOVEME*
         const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
-        	std::clog << "4(" << m << ", " << r0Anm << ")";	// DEBUG
+        	// std::clog << "4(" << m << ", " << r0Anm << ")";	// DEBUG *REMOVEME*
         const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm)); // !GIVES PROBLEMS
 
-        	std::clog << "5";	// DEBUG
+        	// std::clog << "5";	// DEBUG *REMOVEME*
         const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
-        	std::clog << "6(" << m << ", " << r0Anm << ")";	// DEBUG
+        	// std::clog << "6(" << m << ", " << r0Anm << ")";	// DEBUG *REMOVEME*
         const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm)); // !GIVES PROBLEMS
-	std::clog << "_";	// DEBUG
+	// std::clog << "_";	// DEBUG *REMOVEME*
 
         // calculating An,m
         const Real h_ma (h - realm/sigma);
+//        std::clog << "\n[$ h_ma = "<< h_ma <<"$]\n"; // DEBUG *REMOVEME*
         const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
+//        std::clog << "\n[$ rho = "<< rho <<"$]\n"; // DEBUG *REMOVEME*
         const Real rho_sq (rho*rho);
+
         // calculating Bn,m(r')
         const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
+//        std::clog << "\n[$ B_n_m_r0 = "<< B_n_m_r0 <<"$]\n"; // DEBUG *REMOVEME*
 
         const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
+//        std::clog << "\n[$ A_n_m = "<< A_n_m <<"$]\n"; // DEBUG *REMOVEME*
 
         // calculating the result
         const Real result( A_n_m * exp(-D*alpha_sq*t) );
+
+        // DEBUG *REMOVEME*
+        if (result == 0.0) {
+            std::clog << "\nLadies and gentlemen, we've got result=0.";
+            std::clog << "\nShowing add. information:\nInput parameters: {n=" << n << ",m=" << m << ",t=" << t << "}\n"
+                      << "\nObtained parameters {sigma=" << sigma << ", h=" << h << ", a=" << a << ", D=" << D << ", r0=" << r0 << ", alpha="<< alpha <<"}\n";
+        }
+        // END DEBUG
 	return result;
 }
 
@@ -1211,10 +1229,31 @@ const Real
 GreensFunction2DRadAbs::dp_m_at_a( const Integer m,
 					   const Real t ) const
 {
-    const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::dp_m_alpha_at_a,
-					this,
-					_1, m,t ),
-			   MAX_ALPHA_SEQ, EPSILON ) );
+    
+    // DEBUG *REMOVEME*; seems to be correct
+    // std::clog << "\n[$$$ We're giving funcsum: " << m << ", " << t  << ", " << MAX_ALPHA_SEQ << ","<< EPSILON <<",  $$$]";    
+
+    const Real p( funcSum( 
+                        boost::bind( 
+                            &GreensFunction2DRadAbs::dp_m_alpha_at_a,
+			                    this,
+			                    _1, 
+                                m,
+                                t 
+                        ),
+		                MAX_ALPHA_SEQ, 
+                        EPSILON 
+                  ) 
+                );
+
+               // boost::bind 
+               // explanation by example:
+               // "bind(f, _1, 5)(x)"  is equivalent to "f(x, 5)"
+               // this means funcsum receives f(x, m=.., t=..) as
+               // input, with m and t already determined.
+    
+                // Arguments of dp_m_alpha_at_a:
+                // n, m, t
 
     return p;
 }
@@ -1229,7 +1268,6 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
         const Real p_0 ( this->dp_m_at_a( 0, t ) );	// This is the p_m where m is 0, for the denominator
         p_mTable.push_back( p_0 );                      // put it in the table
 
-
         const Real p_1 ( this->dp_m_at_a( 1, t ) / p_0 );
         p_mTable.push_back( p_1 );                      // put the first result in the table
 
@@ -1257,10 +1295,17 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
                 p_m_prev_abs = p_m_abs;					// store the previous term
                 const Real p_m( this->dp_m_at_a( m, t ) / p_0 );	// get the next term
 
+                // DEBUG 
+                if (p_m_abs == 0) {
+                    std::cerr << "Zero valued term found, but convergence is:" <<
+                        p_mTable[p_mTable.size()-1-1]/p_mTable[p_mTable.size()-2-1];
+                }
+                // END DEBUG
+
                 if( ! std::isfinite( p_m ) )			// if the calculated value is not valid->exit
                 {
                         std::cerr << "makedp_m_at_aTable: invalid value; " <<
-                                p_m << "( m= " << m << ")." << std::endl;
+                                p_m << "( m= " << m << ")." << "( t= " << t << ")."<< "( p_0= " << p_0 << ")." << std::endl;
                         break;
                 }
 
@@ -1346,28 +1391,30 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 	}
 
 	// making the tables with constants
-	std::clog << "Making table p_mTable... ";
+	// std::clog << "Making table p_mTable... "; // DEBUG *REMOVEME*
 
 	RealVector p_mTable;			// a table with constants to make calculations much faster
 	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
 	{
-		std::clog << "at a... ";
+		// std::clog << "at a... "; // DEBUG *REMOVEME*
 		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
 	}
 	else
 	{
-		std::clog << "NOT at a... ";
+		// std::clog << "NOT at a... "; // DEBUG *REMOVEME*
 		makep_mTable( p_mTable, r, t );	// making the table of constants for the regular case
 	}
 
-	std::clog << "done" << std::endl;
+	// std::clog << "done" << std::endl; // DEBUG *REMOVEME*
 
 	// preparing the function
 	ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 };	// r, r0, t are not required
 	gsl_function F = 
 	{
-	    reinterpret_cast<typeof(F.function)>( &ip_theta_F ),
+	    reinterpret_cast<typeof(F.function)>( &ip_theta_F ),     
 	    &params 
+        // reinterpret_cast converts any pointer type to any other pointer type.
+        // reinterpret_cast<new_type> variable
 	};
 
 	// finding the root
diff --git a/funcSum.cpp b/funcSum.cpp
index 1af7767a..8e4b4ad1 100644
--- a/funcSum.cpp
+++ b/funcSum.cpp
@@ -92,8 +92,8 @@ funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
 // funcSum
 // ==
 // Will simply calculate the sum over a certain function f, until it converges
-// (i.e. the sum > tolerance*current_term), or a maximum number of terms is 
-// summed (usually 2000).
+// (i.e. the sum > tolerance*current_term for a CONVERGENCE_CHECK number of 
+// terms), or a maximum number of terms is summed (usually 2000).
 //
 // Input:
 // - f: A       function object
diff --git a/pair.py b/pair.py
index dc70626a..7122529b 100644
--- a/pair.py
+++ b/pair.py
@@ -385,7 +385,6 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
 	# TODO still doesn't work with 2D Green's functions
-        print ":) "        
         return GreensFunction2DRadAbs(self.D_tot, self.rt.ktot, r0,
                                               self.sigma, self.a_r)       
 
diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
index 94944acd..d36d730d 100755
--- a/samples/2d/2dtest.py
+++ b/samples/2d/2dtest.py
@@ -48,9 +48,10 @@
 logging = False
 sigma = 1e-9        # Diameter particle
 D = 1e-12           # Diffusion constant
-N = 20000             # Number of steps simulation will last
-world_size = 1e-3   # Lengths of simulation box
-
+N = 10000             # Number of steps simulation will last
+world_size = 1e-6   # Lengths of simulation box
+NParticles = 50     # Number of particles in the simulation
+k = -6e-13          # Reaction constant
 
 # VTK Logger
 # ===============================
@@ -73,10 +74,14 @@
 m.add_structure(the_plane)
 
 # Species
-Xp = model.Species('Xp', D, sigma, 'the_plane')                                   
-m.add_species_type(Xp)
+A = model.Species('A', D, sigma, 'the_plane')                                   
+m.add_species_type(A)
+B = model.Species('B', D, 3*sigma, 'the_plane')                                   
+m.add_species_type(B)
+C = model.Species('C', D, 3*sigma, 'the_plane')                                   
+m.add_species_type(C)
 # Reaction rules
-#r1 = model.create_binding_reaction_rule(A, B, X, k)
+#r1 = model.create_binding_reaction_rule(A, B, C, k)
 #m.network_rules.add_reaction_rule(r1)
 
 
@@ -91,7 +96,8 @@
     l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
 
 # Throw in particles
-throw_in_particles(w, Xp, 5)
+throw_in_particles(w, A, NParticles)
+throw_in_particles(w, B, int(NParticles/2))
 
 # Running 2
 # ===============================
diff --git a/samples/2d/GFtool1.py b/samples/2d/GFtool1.py
deleted file mode 100755
index f4a2d7c9..00000000
--- a/samples/2d/GFtool1.py
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/usr/bin/python
-
-# This script tries to test the GF in the whole parameter regime.
-
-
-
-
-
-
-# Modules
-# ===============================
-# Standard stuff
-import sys
-import os
-import datetime
-
-from egfrd import *
-#from visualization import vtklogger
-
-import model
-import gfrdbase
-import _gfrd
-
-# GF itself
-# ===
-import _greens_functions
-
-
-
-# Some typical "crash" Constants
-# ===============================
-d = 0.931552; r = 6.10119e-08; dt = 0.00114661; D = 2e-12; sigma = 2e-09; a = 6.10119e-08; 
-kf = 0; r0 = 4.95059e-09; h = 0; rnd = 0.24;
-
-# Let's get some data 
-# ===============================
-
-mygf = _greens_functions.GreensFunction2DRadAbs(D, kf, r0, sigma, r)
-try:
-    mygf.drawTheta(rnd, r, dt)
-    print "succes!"   
-except:
-    print "fail!"
-
-
-
-# Let's try and NOT make it crash
-# ===============================
-D = 2e-12; 
-sigma = 2e-09; # 
-a = sigma*5; ##
-r = sigma*3; ## 
-r0 = sigma*2; ## 
-dt = 0.03; ##
-kf = 0; ##
-h = 0; ##
-
-rnd = 0.1; ##
-
-# Let's get some data 
-# ===============================
-
-mygf = _greens_functions.GreensFunction2DRadAbs(D, kf, r0, sigma, r)
-mygf.drawTheta(rnd, r, dt)
-
-try:
-    mygf.drawTheta(rnd, r, dt)
-    print "succes!"   
-except:
-    print "fail!"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/samples/2d/v2_GFtool1(space).py b/samples/2d/v2_GFtool1(space).py
deleted file mode 100755
index 9ec9184d..00000000
--- a/samples/2d/v2_GFtool1(space).py
+++ /dev/null
@@ -1,146 +0,0 @@
-#!/usr/bin/python
-
-# This script tries to test the GF in the whole parameter regime.
-
-
-
-
-
-
-# Modules
-# ===============================
-# Standard stuff
-import sys
-import os
-import datetime
-
-from egfrd import *
-#from visualization import vtklogger
-
-import model
-import gfrdbase
-import _gfrd
-
-# GF itself
-# ===
-import _greens_functions
-
-
-
-
-# List of parameters to investigate:
-# ======================================
-
-D =      2e-12
-sigma =  2e-9
-a =      [10*sigma, 100*sigma]
-r0 =     [1.001*sigma, 3*sigma, 4.999*sigma]
-dt =     [1e-4, 0.03, 0.3, 1, 1e4]
-rnd =    [1e-3, 0.05, 0.1, 0.25, (0.5-1e-3)]
-kf =     0; # 2e-12 10 1e10]
-h =      0;
-
-# Convenient for display later on
-# ======================================
-
-codinga = [' - ', ' + ']
-codingr0 = [' - ', ' 0 ', ' + ']
-codingdt = [' --', '  -', ' 0 ', ' + ', ' ++']
-codingrnd = [' --', '  -', ' 0 ', ' + ', ' ++']
-
-resultstable = ['| a | r0| dt|rnd|  -> Result']
-
-# Let's do this the simple way:
-# ======================================
-
-if __name__=="__main__":
-
-    print "Starting tests."
-    print "========================="
-
-    for i in range(len(a)):
-        r = a[i] #!
-        for j in range(len(r0)):
-            for k in range(len(dt)):
-                 for l in range(len(rnd)):
-
-
-                    print("Parameters: {D = "+str(D)+", sigma = "+
-                          str(sigma)+", a = "+str(a[i])+", r0 = "+
-                          str(r0[j])+", dt = "+str(dt[k])+", kf = "+
-                          str(kf)+", h = "+str(h)+", r = "+str(r)+", "+
-                          "rnd = "+str(rnd[l])+"}")
-                    
-                    mygf = _greens_functions.GreensFunction2DRadAbs(D, kf, r0[j], sigma, r)
-
-                    try:
-                        mygf.drawTheta(rnd[l], r, dt[k])
-                        print "succes!"   
-                        succes = True;
-                    except:
-                        print "fail!"
-                        print sys.exc_info()
-                        succes = False;
-
-                    print ""
-
-                    resultstable.append("|"+str(codinga[i])+"|"+
-                                    str(codingr0[i])+"|"+
-                                    str(codingdt[i])+"|"+
-                                    str(codingrnd[i])+
-                                    "|  -> "+str(succes)+"")
-
-print "\n\nRESULTS\n========================\n\n"
-for a in range(len(resultstable)):
-    print str(resultstable[a]);                            
-print "\n\n===========================\n\n"
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

From b8446d390bce349518b40537b695cd0c99e92949 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 19 Oct 2011 16:03:07 +0200
Subject: [PATCH 0295/1541] fixed stupid mistake

---
 pair.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 7557deda..563e83c8 100644
--- a/pair.py
+++ b/pair.py
@@ -404,8 +404,8 @@ def determine_radii(self, r0, shell_size):
 	    if __debug__:
 		log.info('domainsize changed for convergence.')
 
-        assert a_R + a_r * Da / D_tot + radius1 >= \
-               a_R + a_r * Db / D_tot + radius2
+        assert a_R + a_r * Da / D_tot + radiusa >= \
+               a_R + a_r * Db / D_tot + radiusb
 
         assert abs(a_R + a_r * Da / D_tot + radiusa - shell_size) \
             < 1e-12 * shell_size			# here the shell_size is the relevant scale

From 526e51a20dac47d3406a892993692fb670052c50 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 19 Oct 2011 16:05:23 +0200
Subject: [PATCH 0296/1541] Implemented structure_type to allow reaction
 between particle and surface patch is implemented by Kaizu A structure_type
 is the equivalent for surfaces of a Species for a particle. Note that now
 every surface still needs a unique structure_type. Also note that the
 interface to define surfaces in the simulation system now has also changed!

---
 ParticleModel.cpp                | 21 +++++++++++----------
 Structure.hpp                    | 17 +++++++++++++++++
 StructureType.hpp                |  4 +++-
 World.hpp                        |  1 +
 binding/Structure.hpp            | 11 +++++++++++
 binding/binding_common.hpp       |  2 ++
 binding/structure_type_class.cpp |  2 +-
 model.py                         |  4 ++--
 pyGFRD.cpp                       |  2 ++
 9 files changed, 50 insertions(+), 14 deletions(-)

diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index 1f3a81ac..90a026d9 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -20,16 +20,17 @@ ParticleModel::~ParticleModel()
 
 void ParticleModel::add_structure_type(boost::shared_ptr<structure_type_type> const& structure)
 {
-    std::pair<structure_type_map_type::iterator, bool> r(
-        structure_type_map_.insert(std::make_pair(structure->id(), structure)));
-    if (!r.second)
-    {
-        throw already_exists(
-            (boost::format("structure id \"%s\" is already used by %s") %
-                structure->id() %
-                boost::lexical_cast<std::string>(*(*(r.first)).second)).str());
-    }
-    structure->bind_to_model(this, structure->id());
+    // std::pair<structure_type_map_type::iterator, bool> r(
+    //     structure_type_map_.insert(std::make_pair(structure->id(), structure)));
+    // if (!r.second)
+    // {
+    //     throw already_exists(
+    //         (boost::format("structure id \"%s\" is already used by %s") %
+    //             structure->id() %
+    //             boost::lexical_cast<std::string>(*(*(r.first)).second)).str());
+    // }
+    structure->bind_to_model(this, species_type_id_generator_());
+    structure_type_map_.insert(std::make_pair(structure->id(), structure));
 }
 
 boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structure_type_by_id(structure_id_type const& id) const
diff --git a/Structure.hpp b/Structure.hpp
index 55548487..3bcbd044 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -13,6 +13,7 @@
 #include <sstream>
 #include "Vector3.hpp"
 #include "freeFunctions.hpp"
+#include "SpeciesTypeID.hpp"
 
 template<typename Ttraits_>
 class Structure
@@ -23,6 +24,7 @@ class Structure
     typedef typename traits_type::structure_id_type identifier_type;
     typedef typename traits_type::length_type length_type;
     typedef typename traits_type::position_type position_type;
+    typedef SpeciesTypeID species_id_type;
     typedef std::pair<position_type, length_type> projected_type;
 
 public:
@@ -33,6 +35,20 @@ class Structure
         return id_;
     }
 
+    species_id_type const& sid() const
+    {
+        if (!sid_)
+        {
+            throw illegal_state("not bound to SpeciesType");
+        }
+        return sid_;
+    }
+
+    species_id_type& sid()
+    {
+        return sid_;
+    }
+
     virtual bool operator==(Structure const& rhs) const
     {
         return id_ == rhs.id();
@@ -81,6 +97,7 @@ class Structure
 
 protected:
     identifier_type id_;
+    species_id_type sid_;
 };
 
 template<typename Tstrm, typename Ttraits, typename T_traits>
diff --git a/StructureType.hpp b/StructureType.hpp
index 9adedc93..ad81d673 100644
--- a/StructureType.hpp
+++ b/StructureType.hpp
@@ -10,6 +10,7 @@
 
 #include "exceptions.hpp"
 #include "utils/get_mapper_mf.hpp"
+#include "SpeciesTypeID.hpp"
 
 class ParticleModel;
 
@@ -20,7 +21,8 @@ class StructureType
     typedef get_mapper_mf<std::string, std::string>::type string_map_type;
 
 public:
-    typedef std::string identifier_type;
+    // typedef std::string identifier_type;
+    typedef SpeciesTypeID identifier_type;
     typedef string_map_type::const_iterator string_map_iterator;
     typedef boost::iterator_range<string_map_iterator> attributes_range;
 
diff --git a/World.hpp b/World.hpp
index 97d93244..ae3f21d3 100644
--- a/World.hpp
+++ b/World.hpp
@@ -37,6 +37,7 @@ struct WorldTraitsBase
     typedef SpeciesTypeID species_id_type;
     typedef Particle<length_type, D_type, species_id_type> particle_type;
     typedef std::string structure_id_type;
+    // typedef SpeciesTypeID structure_id_type;
     typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type> species_type;
     typedef Vector3<length_type> point_type;
     typedef typename particle_type::shape_type::position_type position_type;
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 2fc6ca4f..6b3238f8 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -20,6 +20,17 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .add_property("id", 
             make_function(&impl_type::id,
                           return_value_policy<return_by_value>()))
+        .add_property("sid",
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type, typename impl_type::species_id_type,
+                    &impl_type::sid,
+                    &impl_type::sid>::get,
+                return_value_policy<return_by_value>()),
+            &peer::util::reference_accessor_wrapper<
+                impl_type, typename impl_type::species_id_type,
+                &impl_type::sid,
+                &impl_type::sid>::set)
         .def("random_position", &impl_type::random_position)
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index 1ea2f523..fd46403c 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -34,6 +34,7 @@
 #include "../AnalyticalPair.hpp"
 #include "../EventScheduler.hpp"
 #include "../Logger.hpp"
+#include "../StructureType.hpp"
 
 #include "peer/wrappers/range/pyiterable_range.hpp"
 
@@ -49,6 +50,7 @@ typedef WorldTraits::structure_id_type StructureID;
 typedef WorldTraits::species_id_type SpeciesID;
 typedef WorldTraits::species_type SpeciesInfo;
 typedef WorldTraits::structure_type Structure;
+typedef StructureType::identifier_type StructureTypeID;
 typedef WorldTraits::length_type Length;
 typedef WorldTraits::position_type Position;
 typedef ::World<WorldTraits> World;
diff --git a/binding/structure_type_class.cpp b/binding/structure_type_class.cpp
index c60a6aa6..435b27e6 100644
--- a/binding/structure_type_class.cpp
+++ b/binding/structure_type_class.cpp
@@ -42,7 +42,7 @@ struct structure_type_to_structure_id_converter
 void register_structure_type_class()
 {
     structure_type_class = register_structure_type_class<StructureType>("StructureType");
-    peer::util::to_native_converter<StructureID, structure_type_to_structure_id_converter<StructureID, StructureType> >();
+    peer::util::to_native_converter<StructureTypeID, structure_type_to_structure_id_converter<StructureTypeID, StructureType> >();
 }
 
 } // namespace binding
diff --git a/model.py b/model.py
index f2ac8eac..af185e64 100644
--- a/model.py
+++ b/model.py
@@ -145,7 +145,7 @@ def Species(name, D, radius=0, structure="world", drift=0):
     return st
 
 
-class ParticleModel(_gfrd.Model):
+class ParticleModel(_gfrd.ParticleModel):
     """
     """
     def __init__(self, world_size):
@@ -162,7 +162,7 @@ def __init__(self, world_size):
         [world_size, world_size, world_size].
 
         """
-        _gfrd.Model.__init__(self)
+        _gfrd.ParticleModel.__init__(self)
         self.world_size = world_size
         self.structures = {}
 
diff --git a/pyGFRD.cpp b/pyGFRD.cpp
index 98ff1839..f3a2b1ad 100644
--- a/pyGFRD.cpp
+++ b/pyGFRD.cpp
@@ -61,6 +61,7 @@
 #include "binding/species_type_class.hpp"
 #include "binding/sphere_class.hpp"
 #include "binding/structure_classes.hpp"
+#include "binding/structure_type_class.hpp"
 #include "binding/transaction_classes.hpp"
 #include "binding/world_class.hpp"
 
@@ -111,6 +112,7 @@ BOOST_PYTHON_MODULE(_gfrd)
     b::register_transaction_classes();
     b::register_world_class();
     b::register_structure_classes();
+    b::register_structure_type_class();
     b::register_module_functions();
     b::register_volume_clearer_classes();
     b::register_reaction_record_classes();

From dc6c8dbf5e37df2be2608138a735d0df22120855 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 19 Oct 2011 16:10:03 +0200
Subject: [PATCH 0297/1541] implemented the proper use of reaction_rules for
 the reaction between a particle and a surface

---
 egfrd.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 987862f6..5ac40d10 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -396,14 +396,16 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
         species_id = pid_particle_pair[1].sid
 	species = self.world.get_species(species_id)
+	# the structure on which the particle lives
+        structure = self.world.get_structure(species.structure_id)
+	# the surface_id if the interaction surface
+	surface_id = surface.sid
 
+	# get unimolecular reaction rules
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
-        # TODO.
-#        interaction_rules = self.network_rules.query_reaction_rule(species_id, surface)
-        interaction_rules = self.network_rules.query_reaction_rule(species_id, species_id)
-#        interaction_rules = []
+	# get reaction rules for interaction
+        interaction_rules = self.network_rules.query_reaction_rule(species_id, surface_id)
 
-        structure = self.world.get_structure(species.structure_id)
 
 	particle_pos = pid_particle_pair[1].position
 

From f2e8cda4ab187abc7fa404c9e9da90c59f1ca8a0 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 19 Oct 2011 17:19:52 +0200
Subject: [PATCH 0298/1541] Updated dissociation from surfaces. Both surface
 classes and newBDPorpegator now support particels dissociation A->B, A->B+C.

---
 CuboidalRegion.hpp     |  21 ++++--
 CylindricalSurface.hpp |  50 ++++++++++----
 PlanarSurface.hpp      |  48 +++++++++----
 SphericalSurface.hpp   |  16 ++++-
 Structure.hpp          |   6 +-
 newBDPropagator.hpp    | 153 ++++++++++++++++++++++-------------------
 6 files changed, 188 insertions(+), 106 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 11d916c1..be003032 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -18,6 +18,8 @@ class CuboidalRegion
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
     typedef typename base_type::length_type length_type;
+    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef std::pair<position_type, position_type> position_pair_type;
 
     identifier_type const& id() const
     {
@@ -77,11 +79,15 @@ class CuboidalRegion
 
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
-        return position_type(); //No dissociation 'from' the bulk
+        return position_type(); //No surface dissociation 'from' the bulk
     }
 
-    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
+        length_type const& rl ) const
     {
+        length_type const r01( s0.radius() + s1.radius() );
+        Real const D01( s0.D() + s1.D() );
+
         Real const X( rng.uniform(0.,1.) );
 
         length_type const r01l( r01 + rl );
@@ -90,13 +96,16 @@ class CuboidalRegion
         
         length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );
 
-        return random_vector( diss_vec_length, rng );
+        position_type const m( random_vector( diss_vec_length, rng ) );
+        
+        return position_pair_type( op - m * s0.D() / D01,
+                                    op + m * s1.D() / D01 );
     }
     
-    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_bulk, length_type const& r_surf, 
-                                                                length_type const& rl ) const
+    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
+        position_type const& op_surf, length_type const& rl ) const
     {
-        return position_type(); //No dissociation 'from' the bulk
+        return position_pair_type(); //No special geminate dissociation 'from' the bulk
     }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index c621f3e3..ec9c7d97 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -18,6 +18,8 @@ class CylindricalSurface
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
     typedef typename base_type::length_type length_type;
+    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef std::pair<position_type, position_type> position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
@@ -90,28 +92,37 @@ class CylindricalSurface
         
         length_type const diss_vec_length( sqrt( X * (r0rrl_sq - r0rr_sq) + r0rr_sq ) );
 
-
-        position_type v(rng_() - .5, rng_() - .5, rng_() - .5);        
-        v = normalize( substract(v, dot_product( unit_z, v ) * unit_z) );
+        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);        
+        v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
          
         return multiply( v, diss_vec_length); 
     }
 
-    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
+        length_type const& rl ) const
     {
+        length_type const r01( s0.radius() + s1.radius() );
+        Real const D01( s0.D() + s1.D() );
+        
         Real const X( rng.uniform(0.,1.) );
         
         length_type const diss_vec_length( X*rl + r01 );
 
-        return random_vector( diss_vec_length, rng );
+        position_type const m( random_vector( diss_vec_length, rng ) );
+        
+        return position_pair_type( op - m * s0.D() / D01,
+                                    op + m * s1.D() / D01 );
     }
     
-    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_bulk, length_type const& r_surf, 
-                                                                length_type const& rl ) const
+    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
+        position_type const& op_surf, length_type const& rl ) const
     {
-        length_type const r01( r_bulk + r_surf );
+        length_type const r01( s_bulk.radius() + s_surf.radius() );
+        Real const D01( s_bulk.D() + s_surf.D() );
+        Real const D_bulk_D01( s_bulk.D() / D01 );
+        Real const D_surf_D01( s_surf.D() / D01 );
           
-        Real const theta_min( asin(r_bulk / ( r01 )) );       
+        Real const theta_min( asin(s_bulk.radius() / ( r01 )) );       
         Real const theta( theta_min + rng.uniform(0.,1.) * (M_PI - 2 * theta_min) );        
         Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
         
@@ -122,17 +133,32 @@ class CylindricalSurface
         
         length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb) + r01_cb ) );
         
+        position_type v;
+        v[0] = 1; v[1] = 1; v[2] = 1;
+        
         position_type const unit_z( base_type::shape().unit_z() );      
-        position_type const unit_x( normalize( substract( [1,1,1], 
-                                        product( dot_product([1,1,1], unit_z), unit_z ) ) ) );
+        position_type const unit_x( normalize( subtract( v, 
+                                        multiply( unit_z, dot_product(v, unit_z) ) ) ) );
         position_type const unit_y( normalize( cross_product( unit_x, unit_z ) ) );
                 
         length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
         length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
         length_type const z( diss_vec_length * cos( theta ) );
                         
-        return position_type diss_vec( add( unit_x * x, 
+        position_type const m( add( unit_x * x, 
                                         add( unit_y * y, unit_z * z ) ) ); 
+        
+        position_pair_type pp01;
+                                        
+        pp01.first[0] = op_surf[0] - D_surf_D01 * m[0]; 
+        pp01.first[1] = op_surf[1];
+        pp01.first[2] = op_surf[2];
+        
+        pp01.second[0] = op_surf[0] + D_bulk_D01 * m[0]; 
+        pp01.second[1] = op_surf[1] + m[1];
+        pp01.second[2] = op_surf[2] + m[2];                          
+        
+        return pp01;
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index b2e64323..a4401112 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -18,6 +18,8 @@ class PlanarSurface
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
     typedef typename base_type::length_type length_type;
+    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef std::pair<position_type, position_type> position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
@@ -85,25 +87,35 @@ class PlanarSurface
         return multiply( unit_z, (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
     }
 
-    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
+        length_type const& rl ) const
     {
+        length_type const r01( s0.radius() + s1.radius() );
+        Real const D01( s0.D() + s1.D() );
+    
         Real X( rng.uniform(0.,1.) );
 
-        length_type r01l( r01 + rl );
-        length_type r01l_sq( r01l * r01l );
-        length_type r01_sq( r01 * r01 );
+        length_type const r01l( r01 + rl );
+        length_type const r01l_sq( r01l * r01l );
+        length_type const r01_sq( r01 * r01 );
         
-        length_type diss_vec_length( sqrt( X * (r01l_sq - r01_sq) + r01_sq ) );
+        length_type const diss_vec_length( sqrt( X * (r01l_sq - r01_sq) + r01_sq ) );
 
-        return random_vector( diss_vec_length, rng );
+        position_type const m( random_vector( diss_vec_length, rng ) );
+        
+        return position_pair_type( op - m * s0.D() / D01,
+                                    op + m * s1.D() / D01 );
     }
     
-    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_surf, length_type const& r_bulk, 
-                                                                length_type const& rl ) const
+    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
+        position_type const& op_surf, length_type const& rl ) const
     {
-        length_type const r01( r_bulk + r_surf );
+        length_type const r01( s_bulk.radius() + s_surf.radius() );
+        Real const D01( s_bulk.D() + s_surf.D() );
+        Real const D_bulk_D01( s_bulk.D() / D01 );
+        Real const D_surf_D01( s_surf.D() / D01 );
         
-        Real const theta_max( asin(r_bulk / ( r01 )) );
+        Real const theta_max( asin(s_bulk.radius() / ( r01 )) );
         Real const theta( rng.uniform(0.,1.) * theta_max );        
         Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
         
@@ -124,8 +136,20 @@ class PlanarSurface
         length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
         length_type const z( diss_vec_length * cos( theta ) );
                         
-        return position_type diss_vec( add( base_type::shape().unit_x() * x,
-                                        add( base_type::shape().unit_y() * y, unit_z * z ) ) );      
+        position_type const m( add( base_type::shape().unit_x() * x,
+                                        add( base_type::shape().unit_y() * y, unit_z * z ) ) );
+        
+        position_pair_type pp01;
+        
+        pp01.first[0] = op_surf[0] - D_surf_D01 * m[0]; 
+        pp01.first[1] = op_surf[1] - D_surf_D01 * m[1];
+        pp01.first[2] = op_surf[2];
+        
+        pp01.second[0] = op_surf[0] + D_bulk_D01 * m[0]; 
+        pp01.second[1] = op_surf[1] + D_bulk_D01 * m[1];
+        pp01.second[2] = op_surf[2] + m[2];
+        
+        return pp01;
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 3c498bc7..653a2702 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -17,6 +17,8 @@ class SphericalSurface
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
     typedef typename base_type::length_type length_type;
+    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef std::pair<position_type, position_type> position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
@@ -55,9 +57,19 @@ class SphericalSurface
         return length_type(); //TODO
     }
 
-    virtual position_type newbd_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const
+    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
-        return position_type(); //TODO
+        return position_type();       
+    }
+    
+    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const
+    {
+        return position_pair_type();
+    }
+    
+    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const
+    {
+        return position_pair_type();    
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/Structure.hpp b/Structure.hpp
index 50c4543f..6404e9d5 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -23,7 +23,9 @@ class Structure
     typedef typename traits_type::structure_id_type identifier_type;
     typedef typename traits_type::length_type length_type;
     typedef typename traits_type::position_type position_type;
+    typedef typename traits_type::base_type::species_type species_type;
     typedef std::pair<position_type, length_type> projected_type;
+    typedef std::pair<position_type, position_type> position_pair_type;
 
 public:
     virtual ~Structure() {}
@@ -59,9 +61,9 @@ class Structure
     
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const = 0;
     
-    virtual position_type geminate_dissociation_vector( rng_type& rng, length_type const& r01, length_type const& rl ) const = 0;
+    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const = 0;
     
-    virtual position_type special_geminate_dissociation_vector( rng_type& rng, length_type const& r_bulk, length_type const& r_surf, length_type const& rl ) const = 0;
+    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const = 0;
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
     
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index c77e3099..d99bdac1 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -38,6 +38,7 @@ class newBDPropagator
     typedef typename particle_container_type::particle_id_pair particle_id_pair;
     typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
     typedef std::vector<particle_id_type> particle_id_vector_type;
+    typedef std::pair<position_type, position_type> position_pair_type;
     typedef typename particle_container_type::particle_id_pair_generator particle_id_pair_generator;
     typedef typename particle_container_type::particle_id_pair_and_distance particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
@@ -156,7 +157,7 @@ class newBDPropagator
                 bounced = true;
         }         
          
-        /* If particle is bounced, check reaction_volume for reaction parners at old_pos. */     
+        /* If particle is bounced, check reaction_volume for reaction partners at old_pos. */     
         if(bounced)
         {
             new_pos = pp.second.position();
@@ -260,25 +261,58 @@ class newBDPropagator
 
 private:
 
-    position_type const make_move(species_type const& species, position_type const& np, particle_id_type const& ignore)
+    /* Given a position pair and two species, the function generates two new 
+       positions based on two moves drawn from the free propegator. */
+    position_pair_type const make_pair_move(species_type const& s0, species_type const& s1, position_pair_type const& pp01, 
+                                                particle_id_type const& ignore)
     {
-        boost::shared_ptr<structure_type> pp_structure( tx_.get_structure( species.structure_id() ) );
-    
-        position_type displacement( pp_structure->
-                                        bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
+        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
+
+        length_type const r01( s0.radius() + s1.radius() );
+        
+        position_type temp_pos0, temp_pos1;
+        position_pair_type new_pp01( pp01 );
+        
+        //First step: random between s0 and s1.
+        if( rng_.uniform_int(0, 1) )
+        {
+            temp_pos0 = make_move(s0, pp01.first, ignore);
+            new_pp01.first = tx_.distance(temp_pos0, pp01.second) - r01 < 0 ? pp01.first : temp_pos0;
+        }                       
+        else
+        {
+            temp_pos1 = make_move(s1, pp01.second, ignore);
+            new_pp01.second = tx_.distance(temp_pos1, pp01.first) - r01 < 0 ? pp01.second : temp_pos1;
+        }
+        
+        /* Make a second step only with a certain probability in order for detailed balance to hold.
+           For Pacc << 1, two moves in 50% of the cases. */
+
+        //TODO check what is correct.
+            
+        return new_pp01;
+    }
+
+    position_type const make_move(species_type const& s0, position_type const& np, particle_id_type const& ignore)
+    {
+        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+
+        position_type displacement( s0_struct->
+                                        bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
 
         position_type new_pos(tx_.apply_boundary( add( np, displacement ) ));
                         
-        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( 
                                     tx_.check_overlap(
-                                    particle_shape_type(new_pos, species.radius()),
-                                    ignore));                            
-                                    
+                                    particle_shape_type(new_pos, s0.radius()),
+                                    ignore));
+                                                                
         if ( (overlapped && overlapped->size() > 0) )
             return np;
         
-        structure_id_and_distance_pair const struct_id_distance_pair = tx_.get_closest_surface( new_pos );
-        length_type const core_surface_distance = struct_id_distance_pair.second - s0.radius();
+        structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
+        length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
                                     
         if( core_surface_distance < 0 )
             return np;
@@ -360,90 +394,67 @@ class newBDPropagator
 
                 case 2:
                     {
-                        const species_type s0(tx_.get_species(products[0])),
+                        species_type s0(tx_.get_species(products[0])),
                                 s1(tx_.get_species(products[1]));
-                        const Real D01(s0.D() + s1.D());
-                        const length_type r01(s0.radius() + s1.radius());
                         int i = max_retry_count_;
-                        position_type np0, np1;
+                        position_pair_type pp01;
 
                         boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id() ) ); 
                         boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
                         boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
                         
-                        /* If the product particles do NOT live on the same structure => surface -> surface + bulk dissociation. */
-                        if( s0_struct->id() != s1_struct->id() )
+                        /* Create positions (np0, np1) for the reaction products. 
+                        The ipv between the products lies within the reation volume. */
+                        for (;;)
                         {
-                            D0_Dr = s0.D() / ( s0.D() + s1.D() );
-                            D1_Dr = s1.D() / ( s0.D() + s1.D() );                        
-                        
-                            if(s0_struct->id() == "world")
-                            {
-                                position_type m( pp_struct->
-                                    special_geminate_dissociation_vector( rng_, s0.radius(), s1.radius(), reaction_length_ ) );
-                                
-                                
-                                
-                                np0 = tx_.apply_boundary(pp.second.position()
-                                    - m * (s0.D() / D01));
-                                np1 = tx_.apply_boundary(pp.second.position()
-                                    + m * (s1.D() / D01));
-                            }
-                            else
+                            if (--i < 0)
                             {
-                                position_type m( pp_struct->
-                                    special_geminate_dissociation_vector( rng_, s1.radius(), s0.radius(), reaction_length_ ) );
-                                
-                                np0 = tx_.apply_boundary(pp.second.position()
-                                    - m * (s0.D() / D01));
-                                np1 = tx_.apply_boundary(pp.second.position()
-                                    + m * (s1.D() / D01));
+                                throw propagation_error("no space");
                             }
                             
-
-
-                            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
-                        }
-                        
-                        //Don't forget make_move after dissociation!
+                            /* If the product particles do NOT live on the same structure => surface -> surface + bulk dissociation.
+                               Else, the products live on the same structure AND on the same structure as the reactant. 
+                               => standard geminate dissociation. 
+                               
+                               We set: species 0 lives on the surface; species 1 lives in the bulk. */
+                            if( s0_struct->id() != s1_struct->id() )
+                            {                      
                         
-                        /* Create an ipv between the products which lies within the reation volume; check for free space. */
-                        for (;;)
-                        {
-                            if (--i < 0)
+                                if(s0_struct->id() == "world")    
+                                     std::swap(s0,s1);
+
+                                pp01 = pp_struct->
+                                        special_geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ );
+                            
+                            }
+                            else
                             {
-                                throw propagation_error("no space");
-                            } 
-               
-                            position_type m( pp_struct->geminate_dissociation_vector( rng_, r01, reaction_length_ ) );
+                                pp01 = pp_struct->
+                                        geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ );
+                            }
                             
-                            np0 = tx_.apply_boundary(pp.second.position()
-                                    - m * (s0.D() / D01));
-                            np1 = tx_.apply_boundary(pp.second.position()
-                                    + m * (s1.D() / D01));
-                           
+                            pp01.first = tx_.apply_boundary( pp01.first );
+                            pp01.second = tx_.apply_boundary( pp01.second );
+                                                                                   
                             boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_s0(
                                 tx_.check_overlap(
-                                    particle_shape_type(np0, s0.radius()),
+                                    particle_shape_type(pp01.first, s0.radius()),
                                     pp.first));
                             boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_s1(
                                 tx_.check_overlap(
-                                    particle_shape_type(np1, s1.radius()),
+                                    particle_shape_type(pp01.second, s1.radius()),
                                     pp.first));
+                                    
                             if (!(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0))
                                 break;
                         }
 
                         /* After dissociation both particles are allowed to move. */
-                        np0 = make_move(s0, np0, pp.first);
-                        
-                        np1 = make_move(s1, np1, pp.first);                      
-
-			            //Check wether new positions dont overlap.
+                        pp01 = make_pair_move(s0, s1, pp01, pp.first);
 
                         if (vc_)
                         {
-                            if (!(*vc_)(particle_shape_type(np0, s0.radius()), pp.first) || !(*vc_)(particle_shape_type(np1, s1.radius()), pp.first))
+                            if (!(*vc_)(particle_shape_type(pp01.first, s0.radius()), pp.first) || !(*vc_)(particle_shape_type(pp01.second, s1.radius()), pp.first))
                             {
                                 throw propagation_error("no space");
                             }
@@ -451,8 +462,8 @@ class newBDPropagator
 
                         tx_.remove_particle(pp.first);
                         const particle_id_pair
-                            npp0(tx_.new_particle(s0.id(), np0)),
-                            npp1(tx_.new_particle(s1.id(), np1));
+                            npp0(tx_.new_particle(s0.id(), pp01.first)),
+                            npp1(tx_.new_particle(s1.id(), pp01.second));
 
                         if (rrec_)
                         {
@@ -496,8 +507,6 @@ class newBDPropagator
                tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
 
             Real p( r.k() * dt_ / ( pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) ) );
-	    //TODO: Check if it works.
-	    p /= (2 - p);
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)

From c1fe981ee4078a13f7985fe20a32fe77996dcadf Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 19 Oct 2011 19:22:34 +0200
Subject: [PATCH 0299/1541] Reactions between particles on different surfaces.
 Added second order reactions between particles living on different
 structures.

---
 newBDPropagator.hpp | 57 ++++++++++++++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 21 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index d99bdac1..36985f4b 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -39,6 +39,7 @@ class newBDPropagator
     typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
     typedef std::vector<particle_id_type> particle_id_vector_type;
     typedef std::pair<position_type, position_type> position_pair_type;
+    typedef std::pair<position_type, length_type> projected_type;
     typedef typename particle_container_type::particle_id_pair_generator particle_id_pair_generator;
     typedef typename particle_container_type::particle_id_pair_and_distance particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
@@ -349,12 +350,11 @@ class newBDPropagator
                 case 1:
                     {
                         const species_type s0(tx_.get_species(products[0]));
-                        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
                         boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species(pp.second.sid()).structure_id() ) );
                         
                         position_type new_pos = pp.second.position();
                         /* If the product particle does NOT live of the same structure => surface -> bulk dissociation. */
-                        if( s0_struct->id() != pp_struct->id() )
+                        if( s0.structure_id() != pp_struct->id() )
                         {
                             position_type const displacement( pp_struct->surface_dissociation_vector(rng_, s0.radius(), reaction_length_ ) );
 
@@ -399,9 +399,7 @@ class newBDPropagator
                         int i = max_retry_count_;
                         position_pair_type pp01;
 
-                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id() ) ); 
-                        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
-                        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
+                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id() ) );
                         
                         /* Create positions (np0, np1) for the reaction products. 
                         The ipv between the products lies within the reation volume. */
@@ -417,10 +415,10 @@ class newBDPropagator
                                => standard geminate dissociation. 
                                
                                We set: species 0 lives on the surface; species 1 lives in the bulk. */
-                            if( s0_struct->id() != s1_struct->id() )
+                            if( s0.structure_id() != s1.structure_id() )
                             {                      
                         
-                                if(s0_struct->id() == "world")    
+                                if(s0.structure_id() == "world")    
                                      std::swap(s0,s1);
 
                                 pp01 = pp_struct->
@@ -492,21 +490,29 @@ class newBDPropagator
             return false;
         }
 
-        const species_type s0(tx_.get_species(pp0.second.sid())),
+        species_type s0(tx_.get_species(pp0.second.sid())),
                 s1(tx_.get_species(pp1.second.sid()));
+        
+        /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
+           and we let this be s1, and the particle from the surface s0. */     
+        if(s0.structure_id() != s1.structure_id())
+        {
+            if(s0.structure_id() == "world")
+                std::swap(s0,s1);
+        }
 
         const Real rnd(rng_());
         Real prob = 0;
 
+        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
+
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
-            reaction_rule_type const& r(*i);
+            reaction_rule_type const& r(*i);  
 
-            boost::shared_ptr<structure_type> pp_structure( 
-               tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
-
-            Real p( r.k() * dt_ / ( pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) ) );
+            //TODO Do I need special reaction volumes for surface-bulk interaction? Or allways the 3D case?
+            Real p( r.k() * dt_ / ( s1_struct->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) ) );
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
@@ -530,15 +536,24 @@ class newBDPropagator
                     {
                         const species_id_type product(products[0]);
                         const species_type sp(tx_.get_species(product));
+                        
+                        position_type new_pos( tx_.apply_boundary(
+                                        divide(
+                                        add(multiply(pp0.second.position(), s1.D()),
+                                            multiply(tx_.cyclic_transpose(
+                                                pp1.second.position(),
+                                                pp0.second.position()), s0.D())),
+                                        (s0.D() + s1.D()))) );
+
+                        //For unequal structures, project new_pos on surface.
+                        if(sp.structure_id() != s1.structure_id())
+                        {
+                            boost::shared_ptr<structure_type> sp_struct( tx_.get_structure( sp.structure_id() ) );
+                            projected_type position_on_surface sp_struct->projected_point(new_pos);
+                            
+                            new_pos = position_on_surface.first;                                
+                        }
 
-                        const position_type new_pos(
-                            tx_.apply_boundary(
-                                divide(
-                                    add(multiply(pp0.second.position(), s1.D()),
-                                        multiply(tx_.cyclic_transpose(
-                                            pp1.second.position(),
-                                            pp0.second.position()), s0.D())),
-                                    (s0.D() + s1.D()))));
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                             tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
                                               pp0.first, pp1.first));

From f6454ab3e912693b6a484891e0d0f574199c7deb Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 21 Oct 2011 09:24:57 +0200
Subject: [PATCH 0300/1541] Included surface interaction in forward move.

---
 CuboidalRegion.hpp     |   8 ++-
 CylindricalSurface.hpp |  30 ++++----
 PlanarSurface.hpp      |  32 +++++----
 SphericalSurface.hpp   |  15 ++--
 Structure.hpp          |   4 +-
 newBDPropagator.hpp    | 158 ++++++++++++++++++++++++++++-------------
 6 files changed, 162 insertions(+), 85 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index be003032..9ae2b0a0 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -67,15 +67,19 @@ class CuboidalRegion
         return random_vector( drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v ), rng );
     }
 
-    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
-        length_type const r01( r0 + r1 );
         length_type const r01l( r01 + rl );
         length_type const r01l_cb( r01l * r01l * r01l );
         length_type const r01_cb( r01 * r01 * r01 );
 
         return 4.0/3.0 * M_PI * ( r01l_cb - r01_cb );
     }
+    
+    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
+    {
+        return Real(); //No surface interaction with the bulk
+    }
 
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index ec9c7d97..0b18ef6e 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -75,10 +75,20 @@ class CylindricalSurface
         return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
     }
 
-    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
         return 2*rl;
     }
+
+    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
+    {
+        length_type r01( r0 + base_type::shape().radius() );
+        length_type r01l( r01 + rl );
+        length_type r01l_sq( r01l * r01l );
+        length_type r01_sq( r01 * r01 );
+
+        return M_PI * ( r01l_sq - r01_sq );
+    }
     
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
@@ -144,19 +154,15 @@ class CylindricalSurface
         length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
         length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
         length_type const z( diss_vec_length * cos( theta ) );
-                        
-        position_type const m( add( unit_x * x, 
-                                        add( unit_y * y, unit_z * z ) ) ); 
-        
+                                
         position_pair_type pp01;
-                                        
-        pp01.first[0] = op_surf[0] - D_surf_D01 * m[0]; 
-        pp01.first[1] = op_surf[1];
-        pp01.first[2] = op_surf[2];
         
-        pp01.second[0] = op_surf[0] + D_bulk_D01 * m[0]; 
-        pp01.second[1] = op_surf[1] + m[1];
-        pp01.second[2] = op_surf[2] + m[2];                          
+        pp01.first = subtract( op_surf, unit_z * (z * D_surf_D01) );
+        
+        pp01.second = add( op_surf, 
+                        add( unit_x * x,
+                          add( unit_y * y, 
+                                 unit_z * (z * D_bulk_D01) ) ) );
         
         return pp01;
     }
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index a4401112..899c34e0 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -64,9 +64,8 @@ class PlanarSurface
         return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng ); 
     }
 
-    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
-        length_type r01( r0 + r1 );
         length_type r01l( r01 + rl );
         length_type r01l_sq( r01l * r01l );
         length_type r01_sq( r01 * r01 );
@@ -74,6 +73,11 @@ class PlanarSurface
         return M_PI * ( r01l_sq - r01_sq );
     }
     
+    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
+    {
+        return 2*rl;
+    }
+    
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         Real X( rng.uniform(0.,1.) );
@@ -115,7 +119,9 @@ class PlanarSurface
         Real const D_bulk_D01( s_bulk.D() / D01 );
         Real const D_surf_D01( s_surf.D() / D01 );
         
-        Real const theta_max( asin(s_bulk.radius() / ( r01 )) );
+        Real theta_max( M_PI/2 - asin(s_bulk.radius() / ( r01 )) );
+        theta_max = theta_max < 0 ? 0 : theta_max;
+        
         Real const theta( rng.uniform(0.,1.) * theta_max );        
         Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
         
@@ -130,25 +136,23 @@ class PlanarSurface
         position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
         unit_z = normalize ( unit_z );
         
-        unit_z = multiply(unit_z, rng.uniform_int(0, 1));
+        unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
         
         length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
         length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
         length_type const z( diss_vec_length * cos( theta ) );
-                        
-        position_type const m( add( base_type::shape().unit_x() * x,
-                                        add( base_type::shape().unit_y() * y, unit_z * z ) ) );
         
         position_pair_type pp01;
         
-        pp01.first[0] = op_surf[0] - D_surf_D01 * m[0]; 
-        pp01.first[1] = op_surf[1] - D_surf_D01 * m[1];
-        pp01.first[2] = op_surf[2];
-        
-        pp01.second[0] = op_surf[0] + D_bulk_D01 * m[0]; 
-        pp01.second[1] = op_surf[1] + D_bulk_D01 * m[1];
-        pp01.second[2] = op_surf[2] + m[2];
+        pp01.first = subtract( op_surf, 
+                       add( base_type::shape().unit_x() * (x * D_surf_D01),
+                              base_type::shape().unit_y() * (y * D_surf_D01) ) );
         
+        pp01.second = add( op_surf, 
+                       add( base_type::shape().unit_x() * (x * D_bulk_D01),
+                         add( base_type::shape().unit_y() * (y * D_bulk_D01),
+                                unit_z * z ) ) );
+
         return pp01;
     }
 
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 653a2702..4ec6f2a5 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -52,24 +52,29 @@ class SphericalSurface
         return position_type(); //TODO
     }
 
-    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const
+    virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
-        return length_type(); //TODO
+        return Real(); //TODO
+    }
+    
+    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
+    {
+        return Real(); //TODO
     }
 
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
-        return position_type();       
+        return position_type(); //TODO  
     }
     
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const
     {
-        return position_pair_type();
+        return position_pair_type(); //TODO
     }
     
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const
     {
-        return position_pair_type();    
+        return position_pair_type(); //TODO
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/Structure.hpp b/Structure.hpp
index 6404e9d5..ae643dd6 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -57,7 +57,9 @@ class Structure
 
     virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
 
-    virtual Real reaction_volume( length_type const& r0, length_type const& r1, length_type const& rl ) const = 0;
+    virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const = 0;
+    
+    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const = 0;
     
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const = 0;
     
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 36985f4b..819f8f9f 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -81,7 +81,7 @@ class newBDPropagator
     bool operator()()
     {
         if (queue_.empty())
-            return false;
+            return false;        
 
         particle_id_type pid(queue_.back());
         queue_.pop_back();
@@ -89,6 +89,41 @@ class newBDPropagator
 
         LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
 
+        /* START SOME SAMPLES, after which we return. */
+        position_pair_type pp01;
+        species_type const sp(tx_.get_species(pp.second.sid()));
+        boost::shared_ptr<structure_type> const pp_struct( tx_.get_structure( sp.structure_id() ) );
+        
+        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
+
+        typename boost::range_const_iterator<reaction_rules>::type i(boost::begin(rules));
+        reaction_rule_type const& r(*i);
+        
+        typename reaction_rule_type::species_id_range products(r.get_products());
+        
+        species_type s0(tx_.get_species(products[0])), s1(tx_.get_species(products[1]));
+        
+        std::cerr<< s0.structure_id() << " " << s1.structure_id() << std::endl;
+        
+        if(s0.structure_id() == "world")    
+            std::swap(s0,s1);
+            
+        std::cerr<< s0.structure_id() << " " << s1.structure_id() << std::endl;
+        
+        for(int i = 0; i < 2000; i++)
+        {
+            pp01 = pp_struct->
+                special_geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ ); 
+                
+            std::cout << pp01.first[0] << " " << pp01.first[1] << " " << pp01.first[2] << " " 
+                      << pp01.second[0] << " " << pp01.second[1] << " " << pp01.second[2] << std::endl;
+                      
+            //std::cerr << "pp dist: " << tx_.distance(pp01.first, pp01.second) << std::endl;
+            //std::cerr << "ps dist: " << tx_.distance(pp_struct->projected_point( pp01.second ).first, pp01.second) << std::endl;
+        }     
+                    
+        return false;  
+
         /* Consider decay reactions first. Particles can move after decay, but this is done
            inside the 'attempt_reaction' function; for this particle can only react once . */
         try
@@ -111,9 +146,9 @@ class newBDPropagator
         length_type core_surface_distance = 0;
         position_type new_pos;
         
-       /* Sample a potential move, and check if the particle _core_ has overlapped with another 
-          particle or surface. If this is the case the particlem bounces, and is returned
-          to it's original position. For a particle with D = 0, new_pos = old_pos */        
+        /* Sample a potential move, and check if the particle _core_ has overlapped with another 
+           particle or surface. If this is the case the particlem bounces, and is returned
+           to it's original position. For a particle with D = 0, new_pos = old_pos */        
         if (species.D() != 0.)
         {
 
@@ -136,15 +171,10 @@ class newBDPropagator
         int particles_in_overlap(overlapped ? overlapped->size(): 0);
 
         /* Check if the particle at new_pos overlaps with any particle cores. */        
-        bool bounced = false;       
-        for( int i = 0; i < particles_in_overlap; i++ )
-        {
-            if( overlapped->at(i).second < r0 )
-            {
-                bounced = true;
-                break;
-            }
-        }
+        bool bounced = false;
+        int j = 0;
+        while(!bounced && j < particles_in_overlap)
+            bounced = overlapped->at(j++).second < r0;
         
         /* If the particle has not bounced with a particle and lives in the bulk: 
            check for core overlap with a surface. */
@@ -180,7 +210,7 @@ class newBDPropagator
         {
             try
             {
-                if( false /*attempt_reaction(pp, pp_surface)*/ )
+                if( false /*attempt_interaction(pp, pp_surface)*/ )
                     return true;
                 else                
                 {
@@ -203,8 +233,6 @@ class newBDPropagator
 
         case 1:
         {
-            
-        
             particle_id_pair_and_distance const& closest(overlapped->at(0));
  		        
     		try
@@ -234,8 +262,7 @@ class newBDPropagator
                        
         /* If the particle did not bounce, update to new position. */
         if(!bounced)
-        {
-                
+        {   
             particle_id_pair particle_to_update( pp.first, 
                         particle_type(species.id(), particle_shape_type(new_pos, r0), species.D()) );
                 
@@ -252,7 +279,6 @@ class newBDPropagator
         }
 
         return true;
-        
     }
 
     std::size_t get_rejected_move_count() const
@@ -370,17 +396,26 @@ class newBDPropagator
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_p.second.shape(), new_p.first));
                         if (overlapped && overlapped->size() > 0)
                         {
-                            throw propagation_error("no space");
+                            throw propagation_error("no space due to particle");
                         }
 
                         if (vc_)
                         {
                             if (!(*vc_)(new_p.second.shape(), pp.first))
                             {
-                                throw propagation_error("no space");
+                                throw propagation_error("no space due to particle");
                             }
                         }
 
+                        if( s0.structure_id() == "world" )
+                        {
+                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
+                            length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
+                                    
+                            if( core_surface_distance < 0 )
+                                throw propagation_error("no space due to surface");
+                        }
+
                         tx_.update_particle(new_p);
 
                         if (rrec_)
@@ -417,13 +452,11 @@ class newBDPropagator
                                We set: species 0 lives on the surface; species 1 lives in the bulk. */
                             if( s0.structure_id() != s1.structure_id() )
                             {                      
-                        
                                 if(s0.structure_id() == "world")    
                                      std::swap(s0,s1);
 
                                 pp01 = pp_struct->
                                         special_geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ );
-                            
                             }
                             else
                             {
@@ -443,7 +476,26 @@ class newBDPropagator
                                     particle_shape_type(pp01.second, s1.radius()),
                                     pp.first));
                                     
-                            if (!(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0))
+                            //Only when both products live in the bulk, check for possible overlap with a surface.
+                            bool surface_overlap = false;
+                            if( s0.structure_id() == "world" && s1.structure_id() == "world" )
+                            {
+                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first ) );
+                                length_type core_surface_distance( struct_id_distance_pair.second - s0.radius() );
+                                    
+                                if( core_surface_distance < 0 )
+                                {
+                                    surface_overlap = true;
+                                }
+                                    
+                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second );
+                                core_surface_distance = struct_id_distance_pair.second - s1.radius();
+
+                                if( core_surface_distance < 0 )
+                                    surface_overlap = true;                                
+                            }
+                                    
+                            if (!(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0) && !surface_overlap)
                                 break;
                         }
 
@@ -494,7 +546,7 @@ class newBDPropagator
                 s1(tx_.get_species(pp1.second.sid()));
         
         /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
-           and we let this be s1, and the particle from the surface s0. */     
+           and we let this be s1, the particle from the surface is named s0. */     
         if(s0.structure_id() != s1.structure_id())
         {
             if(s0.structure_id() == "world")
@@ -512,7 +564,7 @@ class newBDPropagator
             reaction_rule_type const& r(*i);  
 
             //TODO Do I need special reaction volumes for surface-bulk interaction? Or allways the 3D case?
-            Real p( r.k() * dt_ / ( s1_struct->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) ) );
+            Real p( r.k() * dt_ / ( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ) );
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
@@ -549,9 +601,9 @@ class newBDPropagator
                         if(sp.structure_id() != s1.structure_id())
                         {
                             boost::shared_ptr<structure_type> sp_struct( tx_.get_structure( sp.structure_id() ) );
-                            projected_type position_on_surface sp_struct->projected_point(new_pos);
+                            projected_type const position_on_surface( sp_struct->projected_point(new_pos) );
                             
-                            new_pos = position_on_surface.first;                                
+                            new_pos = tx_.apply_boundary( position_on_surface.first );
                         }
 
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
@@ -571,6 +623,15 @@ class newBDPropagator
                                 throw propagation_error("no space");
                             }
                         }
+                        
+                        if( sp.structure_id() == "world" )
+                        {
+                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
+                            length_type const core_surface_distance( struct_id_distance_pair.second - sp.radius() );
+                                    
+                            if( core_surface_distance < 0 )
+                                throw propagation_error("no space due to surface");     
+                        }
 
                         remove_particle(pp0.first);
                         remove_particle(pp1.first);
@@ -600,29 +661,31 @@ class newBDPropagator
         return false;
     }
     
-    /*
-    bool attempt_reaction(particle_id_pair const& pp, structure_type const& structure)
+    
+    bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
     {
-        reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), structure_id));
+        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), structure->sid() ));
         if (::size(rules) == 0)
         {
             return false;
         }
+        
+        const species_type s0(tx_.get_species(pp.second.sid()));
+        
+        boost::shared_ptr<structure_type> pp_structure( tx_.get_structure( s0.structure_id() ) ); 
 
-        const species_type s0(tx_.get_species(pp0.second.sid()));
-
+        if(pp_structure->id() != "world")
+            throw not_implemented("only particles living in the bulk are allowed to interact with surfaces");
+        
         const Real rnd(rng_());
         Real prob = 0;
 
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
-            reaction_rule_type const& r(*i);
+            reaction_rule_type const& r(*i); 
 
-            boost::shared_ptr<structure_type> pp_structure( 
-               tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
-
-            const Real p( r.k() * dt_ / pp_structure->reaction_volume( s0.radius(), s1.radius(), reaction_length_ ) );
+            const Real p( r.k() * dt_ / structure->surface_reaction_volume( s0.radius(), reaction_length_ ) );
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
@@ -636,7 +699,7 @@ class newBDPropagator
             }
             if (prob > rnd)
             {
-                LOG_DEBUG(("fire reaction"));
+                LOG_DEBUG(("fire surface interaction"));
                 const typename reaction_rule_type::species_id_range products(
                     r.get_products());
 
@@ -647,17 +710,11 @@ class newBDPropagator
                         const species_id_type product(products[0]);
                         const species_type sp(tx_.get_species(product));
 
-                        const position_type new_pos(
-                            tx_.apply_boundary(
-                                divide(
-                                    add(multiply(pp0.second.position(), s1.D()),
-                                        multiply(tx_.cyclic_transpose(
-                                            pp1.second.position(),
-                                            pp0.second.position()), s0.D())),
-                                    (s0.D() + s1.D()))));
+                        const position_type new_pos( tx_.apply_boundary( structure->projected_point( pp.second.position() ) ) );
+                            
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                             tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
-                                              pp0.first, pp1.first));
+                                              pp.first));
                         if (overlapped && overlapped->size() > 0)
                         {
                             throw propagation_error("no space");
@@ -667,7 +724,7 @@ class newBDPropagator
                         {
                             if (!(*vc_)(
                                     particle_shape_type(new_pos, sp.radius()), 
-                                    pp0.first, pp1.first))
+                                    pp.first))
                             {
                                 throw propagation_error("no space");
                             }
@@ -679,7 +736,7 @@ class newBDPropagator
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(npp.first), pp0.first, pp1.first));
+                                    r.id(), array_gen(npp.first), pp.first));
                         }
                         break;
                     }
@@ -698,7 +755,6 @@ class newBDPropagator
         }
         return false;
     }
-    */
     
     void remove_particle(particle_id_type const& pid)
     {

From 4d3275272291e3a70aa5a31e14aab1c0384a05db Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 21 Oct 2011 15:43:32 +0200
Subject: [PATCH 0301/1541] changed all tabs to spaces in python files

---
 domain.py         |   50 +-
 egfrd.py          | 1298 ++++++++++++++++++++++-----------------------
 gfrdbase.py       |    4 +-
 model.py          |    8 +-
 multi.py          |    4 +-
 pair.py           |  476 ++++++++---------
 shellcontainer.py |   32 +-
 single.py         |  430 +++++++--------
 8 files changed, 1151 insertions(+), 1151 deletions(-)

diff --git a/domain.py b/domain.py
index d1c07dcd..0fd78d5c 100644
--- a/domain.py
+++ b/domain.py
@@ -16,15 +16,15 @@ class Domain(object):
     SINGLE_SHELL_FACTOR = 2.0
 
     def __init__(self, domain_id):
-	self.domain_id = domain_id	# identifier for this domain object
-	self.event_id = None		# identifier for the event coupled to this domain
+        self.domain_id = domain_id      # identifier for this domain object
+        self.event_id = None            # identifier for the event coupled to this domain
 
-	self.event_type = None
+        self.event_type = None
 
-	self.last_time = 0.0
-	self.dt = 0.0
+        self.last_time = 0.0
+        self.dt = 0.0
 
-    def initialize(self, time):		# this method needs to be overloaded in all subclasses
+    def initialize(self, time):         # this method needs to be overloaded in all subclasses
         '''
         Sets the local time variables for the Domain (usually to the current simulation time).
         Do not forget to reschedule this Domain after calling this method.
@@ -33,22 +33,22 @@ def initialize(self, time):		# this method needs to be overloaded in all subclas
         radius of the particle.
 
         initialize allows you to reuse the same Domain (of the same class with the same particles)
-	at a different time.
+        at a different time.
         '''
-	pass
+        pass
 
     def calc_ktot(self, reactionrules):
-	# calculates the total rate for a list of reaction rules
+        # calculates the total rate for a list of reaction rules
         # The probability for the reaction to happen is proportional to 
         # the sum of the rates of all the possible reaction types.
-	k_tot = 0
+        k_tot = 0
         for rr in reactionrules:
             k_tot += rr.k
-	return k_tot
+        return k_tot
 
     def draw_reaction_rule(self, reactionrules):
-	# draws a reaction rules out of a list of reaction rules based on their
-	# relative rates
+        # draws a reaction rules out of a list of reaction rules based on their
+        # relative rates
         k_array = numpy.add.accumulate([rr.k for rr in reactionrules])
         k_max = k_array[-1]
 
@@ -57,8 +57,8 @@ def draw_reaction_rule(self, reactionrules):
 
         return reactionrules[i]
 
-    def create_new_shell(self):		# needs to be overloaded in subclasses
-	pass				# creates an appropriate shell object
+    def create_new_shell(self):         # needs to be overloaded in subclasses
+        pass                            # creates an appropriate shell object
 
 
 class ProtectiveDomain(Domain):
@@ -68,25 +68,25 @@ class ProtectiveDomain(Domain):
 # their shell within a timestep, breaking the principle of a Protective Domain
 
     def __init__(self, domain_id):
-	Domain.__init__(self, domain_id)
+        Domain.__init__(self, domain_id)
 
-	self.shell_id = None
-	self.shell = None
-	self.num_shells = 1		# all protective domains have only one shell
+        self.shell_id = None
+        self.shell = None
+        self.num_shells = 1             # all protective domains have only one shell
 
     def get_shell_id_shell_pair(self):
-	return (self.shell_id, self.shell)
+        return (self.shell_id, self.shell)
 
     def set_shell_id_shell_pair(self, shell_id_shell_pair):
-	self.shell_id = shell_id_shell_pair[0]
-	self.shell = shell_id_shell_pair[1]
+        self.shell_id = shell_id_shell_pair[0]
+        self.shell = shell_id_shell_pair[1]
 
     shell_id_shell_pair = property(get_shell_id_shell_pair, set_shell_id_shell_pair)
 
     def get_shell_list(self):
-	return [(self.shell_id, self.shell), ]
+        return [(self.shell_id, self.shell), ]
 
     shell_list = property(get_shell_list)
 
-    def get_shell_radius(self):		# returns the radius of the shell
-	return self.shell.shape.radius
+    def get_shell_radius(self):         # returns the radius of the shell
+        return self.shell.shape.radius
diff --git a/egfrd.py b/egfrd.py
index 5ac40d10..c968e85f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -73,8 +73,8 @@ class DomainEvent(Event):
     __slot__ = ['data']
     def __init__(self, time, domain):
         Event.__init__(self, time)
-        self.data = domain.domain_id		# Store the domain_id key refering to the domain
-						# in domains{} in the scheduler
+        self.data = domain.domain_id            # Store the domain_id key refering to the domain
+                                                # in domains{} in the scheduler
 
 class Delegate(object):
     def __init__(self, obj, method, arg):
@@ -115,31 +115,31 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.domain_id_generator = DomainIDGenerator(0)
         self.shell_id_generator = ShellIDGenerator(0)
 
-	# some constants
-        self.MULTI_SHELL_FACTOR = 1.05		# This is the threshold for when the algorithm switches from
-						# NonInteractionSingles to a Multi and also defines the Multi
-						# shell size.
-        self.SINGLE_SHELL_FACTOR = 2.0		# This is the threshold for when the algorithm switches from
-						# NonInteractionSingles to a Pair or Interaction. It also defines
-						# the radius in which the NonInteractionSingle will burst.
-	self.MAX_NUM_DT0_STEPS = 10000
+        # some constants
+        self.MULTI_SHELL_FACTOR = 1.05          # This is the threshold for when the algorithm switches from
+                                                # NonInteractionSingles to a Multi and also defines the Multi
+                                                # shell size.
+        self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
+                                                # NonInteractionSingles to a Pair or Interaction. It also defines
+                                                # the radius in which the NonInteractionSingle will burst.
+        self.MAX_NUM_DT0_STEPS = 10000
 
-	self.MAX_TIME_STEP = 10
+        self.MAX_TIME_STEP = 10
 
-	# used datastructrures
-        self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
+        # used datastructrures
+        self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
 
-        self.domains = {}			# a dictionary containing references to the domains that are defined
-						# in the simulation system. The id of the domain (domain_id) is the key.
-						# The domains can be a single, pair or multi of any type.
+        self.domains = {}                       # a dictionary containing references to the domains that are defined
+                                                # in the simulation system. The id of the domain (domain_id) is the key.
+                                                # The domains can be a single, pair or multi of any type.
 
-	# other stuff
-        self.is_dirty = True			# The simulator is dirty if the state if the simulator is not
-						# consistent with the content of the world that it represents
-						# (or if we don't know for sure)
+        # other stuff
+        self.is_dirty = True                    # The simulator is dirty if the state if the simulator is not
+                                                # consistent with the content of the world that it represents
+                                                # (or if we don't know for sure)
 
-        self.reset()				# The Simulator is only initialized at the first step, allowing
-						# modifications to the world to be made before simulation starts
+        self.reset()                            # The Simulator is only initialized at the first step, allowing
+                                                # modifications to the world to be made before simulation starts
 
     def get_next_time(self):
         """ 
@@ -147,8 +147,8 @@ def get_next_time(self):
         is completed.        
         """ #~MW
         if self.scheduler.size == 0:
-            return self.t			# self.t is the current time of the simulator
-	else:
+            return self.t                       # self.t is the current time of the simulator
+        else:
             return self.scheduler.top[1].time
 
     ###
@@ -160,7 +160,7 @@ def reset(self):
         the simulator time is reset, the step counter is reset, events
         are reset, etc.
         Can be for example usefull when users want to first do an equilibration
-	run before starting the "real experiment".
+        run before starting the "real experiment".
         """ #~ MW
         self.t = 0.0
         self.dt = 0.0
@@ -182,27 +182,27 @@ def reset(self):
         self.last_event = None
         self.last_reaction = None
 
-        self.is_dirty = True		# simulator needs to be re-initialized
+        self.is_dirty = True            # simulator needs to be re-initialized
 
     def initialize(self):
-	"""Initialize the eGFRD simulator
-
-	This method (re-)initializes the simulator with the current state of the 'world'
-	that it represents.
-	Call this method if you change the 'world' using methods outside of the Simulator
-	thereby invalidating the state of the eGFRD simulator (the simulator is dirty), or
-	in an other case that the state of the simulator is inconsistent with the state of
-	the world.
-	"""
-	# 1. (re-)initialize previously set datastructures
+        """Initialize the eGFRD simulator
+
+        This method (re-)initializes the simulator with the current state of the 'world'
+        that it represents.
+        Call this method if you change the 'world' using methods outside of the Simulator
+        thereby invalidating the state of the eGFRD simulator (the simulator is dirty), or
+        in an other case that the state of the simulator is inconsistent with the state of
+        the world.
+        """
+        # 1. (re-)initialize previously set datastructures
         ParticleSimulatorBase.initialize(self)
         self.scheduler.clear()
         self.domains = {}
 
-	# create/clear other datastructures
-	self.geometrycontainer = ShellContainer(self.world)
+        # create/clear other datastructures
+        self.geometrycontainer = ShellContainer(self.world)
 
-	# 2. Couple all the particles in 'world' to a new 'single' in the eGFRD simulator
+        # 2. Couple all the particles in 'world' to a new 'single' in the eGFRD simulator
         # Fix order of adding particles (always, or at least in debug mode).
         singles = []
         pid_particle_pairs = list(self.world)
@@ -218,13 +218,13 @@ def initialize(self):
         for single in singles:
             self.add_domain_event(single)
 
-	# 3. The simulator is now consistent with 'world'
+        # 3. The simulator is now consistent with 'world'
         self.is_dirty = False
 
     def stop(self, t):
         """Bring the simulation to a full stop, which synchronizes all
-	particles at time t. The state is similar to the state after
-	initialization.
+        particles at time t. The state is similar to the state after
+        initialization.
 
         With eGFRD, particle positions are normally updated 
         asynchronously. This method bursts all protective domains so that 
@@ -246,10 +246,10 @@ def stop(self, t):
         if __debug__:
             log.info('stop at %s' % (FORMAT_DOUBLE % t))
 
-        if self.t == t:				# We actually already stopped?
-            return				# FIXME: is this accurate? Probably use feq from utils.py
+        if self.t == t:                         # We actually already stopped?
+            return                              # FIXME: is this accurate? Probably use feq from utils.py
 
-        if t >= self.scheduler.top[1].time:	# Can't schedule a stop later than the next event time
+        if t >= self.scheduler.top[1].time:     # Can't schedule a stop later than the next event time
             raise RuntimeError('Stop time >= next event time.')
 
         if t < self.t:
@@ -298,15 +298,15 @@ def step(self):
         if __debug__:
             if self.scheduler.size == 0:
                 raise RuntimeError('No Events in scheduler.')
-	
-	# 1. Get the next event from the scheduler
-	#
+        
+        # 1. Get the next event from the scheduler
+        #
         id, event = self.scheduler.pop()
-	domain = self.domains[event.data]
-	if event.time == numpy.inf:
-	    self.t, self.last_event = self.MAX_TIME_STEP, event
-	else:
-	    self.t, self.last_event = event.time, event
+        domain = self.domains[event.data]
+        if event.time == numpy.inf:
+            self.t, self.last_event = self.MAX_TIME_STEP, event
+        else:
+            self.t, self.last_event = event.time, event
 
         if __debug__:
             domain_counts = self.count_domains()
@@ -317,22 +317,22 @@ def step(self):
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
        
-	# 2. Use the correct method to process (fire) the shell that produced the event
-	#
+        # 2. Use the correct method to process (fire) the shell that produced the event
+        #
         # Dispatch is a dictionary (hash) of what function to use to fire
         # different classes of shells (see bottom egfrd.py) 
         # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
         # e.g. "if class is Single, then process_single_event" ~ MW
         for klass, f in self.dispatch:
             if isinstance(domain, klass):
-                f(self, domain)		# fire the correct method for the class (e.g. fire_singel(self, Single))
+                f(self, domain)         # fire the correct method for the class (e.g. fire_singel(self, Single))
 
         if __debug__:
             if self.scheduler.size == 0:
                 raise RuntimeError('Zero events left.')
 
-	# 3. Adjust the simulation time
-	#
+        # 3. Adjust the simulation time
+        #
         next_time = self.scheduler.top[1].time
         self.dt = next_time - self.t
 
@@ -353,8 +353,8 @@ def step(self):
 
 
     def create_single(self, pid_particle_pair):
-	# 1. generate identifiers for the domain and shell. The event_id is
-	# generated by the scheduler
+        # 1. generate identifiers for the domain and shell. The event_id is
+        # generated by the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
@@ -364,7 +364,7 @@ def create_single(self, pid_particle_pair):
         structure = self.world.get_structure(species.structure_id)
 
         # 2. Create and register the single domain.
-	# The type of the single that will be created 
+        # The type of the single that will be created 
         # depends on the structure (region or surface) this particle is 
         # in/on. Either SphericalSingle, PlanarSurfaceSingle, or 
         # CylindricalSurfaceSingle.
@@ -372,10 +372,10 @@ def create_single(self, pid_particle_pair):
                                        shell_id, rrs, structure)
 
         assert isinstance(single, NonInteractionSingle)
-        single.initialize(self.t)		# set the initial event and event time
+        single.initialize(self.t)               # set the initial event and event time
         self.domains[domain_id] = single
 
-	# 3. update the proper shell container
+        # 3. update the proper shell container
         self.geometrycontainer.move_shell(single.shell_id_shell_pair)
 
         if __debug__:
@@ -384,32 +384,32 @@ def create_single(self, pid_particle_pair):
         return single
 
     def create_interaction(self, pid_particle_pair, surface, shell_center,
-			   shell_radius, shell_half_length, shell_unit_z):
+                           shell_radius, shell_half_length, shell_unit_z):
 
 ##        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
-#	assert that the particle is not already associate with another domain
+#       assert that the particle is not already associate with another domain
 
-	# 1. generate identifiers for the domain and shell. event_id is generated by
-	# the scheduler
+        # 1. generate identifiers for the domain and shell. event_id is generated by
+        # the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
         species_id = pid_particle_pair[1].sid
-	species = self.world.get_species(species_id)
-	# the structure on which the particle lives
+        species = self.world.get_species(species_id)
+        # the structure on which the particle lives
         structure = self.world.get_structure(species.structure_id)
-	# the surface_id if the interaction surface
-	surface_id = surface.sid
+        # the surface_id if the interaction surface
+        surface_id = surface.sid
 
-	# get unimolecular reaction rules
+        # get unimolecular reaction rules
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
-	# get reaction rules for interaction
+        # get reaction rules for interaction
         interaction_rules = self.network_rules.query_reaction_rule(species_id, surface_id)
 
 
-	particle_pos = pid_particle_pair[1].position
+        particle_pos = pid_particle_pair[1].position
 
-    	if isinstance(surface, CylindricalSurface):
+        if isinstance(surface, CylindricalSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
             projected_point, r0 = surface.projected_point(particle_pos)
             shell_unit_r = normalize(particle_pos - projected_point)
@@ -421,7 +421,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
                                                         shell_id, shell_center, shell_radius,
                                                         shell_half_length, shell_unit_z, z0,
                                                         shell_unit_r, r0, interaction_rules, surface)
-	elif isinstance(surface, PlanarSurface):
+        elif isinstance(surface, PlanarSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
             z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
 
@@ -436,7 +436,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
         interaction.initialize(self.t)
         self.domains[domain_id] = interaction
 
-	# 3. update the shell containers 
+        # 3. update the shell containers 
         self.geometrycontainer.move_shell(interaction.shell_id_shell_pair)
 
         if __debug__:
@@ -449,19 +449,19 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         assert single1.dt == 0.0
         assert single2.dt == 0.0
 
-	pid_particle_pair1 = single1.pid_particle_pair
-	pid_particle_pair2 = single2.pid_particle_pair
+        pid_particle_pair1 = single1.pid_particle_pair
+        pid_particle_pair2 = single2.pid_particle_pair
 
-	# 1. generate needed identifiers
+        # 1. generate needed identifiers
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
         # Select 1 reaction type out of all possible reaction types between the two particles.
         rrs = self.network_rules.query_reaction_rule(pid_particle_pair1[1].sid,
-					             pid_particle_pair2[1].sid)
+                                                     pid_particle_pair2[1].sid)
 
         # Get structure (region or surface) where particle1 lives (assuming particle2
-	# also lives here -> TODO).
+        # also lives here -> TODO).
         species1 = self.world.get_species(pid_particle_pair1[1].sid)
         structure = self.world.get_structure(species1.structure_id)
 
@@ -473,11 +473,11 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         pair = create_default_pair(domain_id, com, single1, single2, shell_id, 
                                    r0, shell_size, rrs, structure)
 
-	assert isinstance(pair, Pair)
+        assert isinstance(pair, Pair)
         pair.initialize(self.t)
         self.domains[domain_id] = pair
 
-	# 3. update the shell containers with the new shell
+        # 3. update the shell containers with the new shell
         self.geometrycontainer.move_shell(pair.shell_id_shell_pair)
 
         if __debug__:
@@ -486,7 +486,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         return pair
 
     def create_multi(self):
-	# 1. generate necessary id's
+        # 1. generate necessary id's
         domain_id = self.domain_id_generator()
 
         if __debug__:
@@ -498,12 +498,12 @@ def create_multi(self):
         else:
             dt_factor = DEFAULT_DT_FACTOR
 
-	# 2. Create and register domain object
+        # 2. Create and register domain object
         multi = Multi(domain_id, self, dt_factor)
         self.domains[domain_id] = multi
 
-	# 3. no shells are yet made, since these are added later
-	# -> a multi can have 0 shells
+        # 3. no shells are yet made, since these are added later
+        # -> a multi can have 0 shells
         return multi
 
 
@@ -528,42 +528,42 @@ def update_single_shell(self, single, position, radius=None):
         self.geometrycontainer.move_shell(shell_id_shell_pair)
 
     def move_particle(self, pid_particle_pair, position):
-	# moves a particle in world based on an existing particle
+        # moves a particle in world based on an existing particle
 
         new_pid_particle_pair = (pid_particle_pair[0],
-	                         Particle(position,
+                                 Particle(position,
                                           pid_particle_pair[1].radius,
-                                   	  pid_particle_pair[1].D,
-                                   	  pid_particle_pair[1].sid))
+                                          pid_particle_pair[1].D,
+                                          pid_particle_pair[1].sid))
 
         self.world.update_particle(new_pid_particle_pair)
 
-	return new_pid_particle_pair
+        return new_pid_particle_pair
 
     def remove_domain(self, obj):
-	# Removes all the ties to a domain (single, pair, multi) from the system.
-	# Note that the particles that it represented still exist
-	# in 'world' and that obj also still persits (?!)
+        # Removes all the ties to a domain (single, pair, multi) from the system.
+        # Note that the particles that it represented still exist
+        # in 'world' and that obj also still persits (?!)
         if __debug__:
             log.info("remove: %s" % obj)
-	# TODO assert that the domain is not still in the scheduler
+        # TODO assert that the domain is not still in the scheduler
         del self.domains[obj.domain_id]
         for shell_id_shell_pair in obj.shell_list:
-	    self.geometrycontainer.remove_shell(shell_id_shell_pair)
+            self.geometrycontainer.remove_shell(shell_id_shell_pair)
 
 ### TODO These methods can be made methods to the scheduler class
     def add_domain_event(self, domain):
     # This method makes an event for domain 'domain' in the scheduler.
     # The event will have the domain_id pointing to the appropriate domain in 'domains{}'.
     # The domain will have the event_id pointing to the appropriate event in the scheduler.
-	event_time = self.t + domain.dt
+        event_time = self.t + domain.dt
         event_id = self.scheduler.add(
             DomainEvent(event_time, domain))
         if __debug__:
             log.info('add_event: %s, event=#%d, t=%s' %
                      (domain.domain_id, event_id,
                       FORMAT_DOUBLE % (event_time)))
-        domain.event_id = event_id			# FIXME side effect programming -> unclear!!
+        domain.event_id = event_id                      # FIXME side effect programming -> unclear!!
 
     def remove_event(self, event):
         if __debug__:
@@ -590,9 +590,9 @@ def burst_domain(self, domain):
             bursted = [single1, single2]
         else:  # Multi
 #            bursted = self.burst_multi(domain)
-            bursted = self.break_up_multi(domain)	# Multi's can't really be 'bursted' since the
-							# positions of the particles are known. They
-							# are broken up to singles with a dt=0 shell instead.
+            bursted = self.break_up_multi(domain)       # Multi's can't really be 'bursted' since the
+                                                        # positions of the particles are known. They
+                                                        # are broken up to singles with a dt=0 shell instead.
             self.remove_event(domain)
 
         if __debug__:
@@ -622,13 +622,13 @@ def burst_volume(self, pos, radius, ignore=[]):
             - radius: radius of area to be "bursted"
             - ignore: domains that should be ignored, none by default.
         """ # ~ MW
-	# TODO burst_volume now always assumes a spherical volume to burst.
-	# It is inefficient to burst on the 'other' side of the membrane or to
-	# burst in a circle, when you want to make a new shell in the membrane.
-	# Then we may want to burst in a cylindrical volume, not a sphere
+        # TODO burst_volume now always assumes a spherical volume to burst.
+        # It is inefficient to burst on the 'other' side of the membrane or to
+        # burst in a circle, when you want to make a new shell in the membrane.
+        # Then we may want to burst in a cylindrical volume, not a sphere
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius,
                                                                                ignore)
-	neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
         return self.burst_objs(neighbors)
 
     def burst_non_multis(self, domains):
@@ -636,118 +636,118 @@ def burst_non_multis(self, domains):
 
         for domain in domains:
             if not isinstance(domain, Multi):
-		# domain is Single or Pair of some subclass
+                # domain is Single or Pair of some subclass
                 single_list = self.burst_domain(domain)
                 bursted.extend(single_list)
             else:
-		# domain is a Multi
+                # domain is a Multi
                 bursted.append(domain)
 
         return bursted
 
     def fire_single_reaction(self, single, reactant_pos):
-	# This takes care of the identity change when a single particle decays into
-	# one or a number of other particles
-	# It performs the reactions:
-	# A(any structure) -> 0
-	# A(any structure) -> B(same structure or 3D)
-	# A(any structure) -> B(same structure) + C(same structure or 3D)
-
-	# 0. get reactant info
-	reactant           = single.pid_particle_pair
+        # This takes care of the identity change when a single particle decays into
+        # one or a number of other particles
+        # It performs the reactions:
+        # A(any structure) -> 0
+        # A(any structure) -> B(same structure or 3D)
+        # A(any structure) -> B(same structure) + C(same structure or 3D)
+
+        # 0. get reactant info
+        reactant           = single.pid_particle_pair
         reactant_radius    = reactant[1].radius
         reactant_structure = single.structure
         rr = single.reactionrule
 
-	# 1. remove the particle
+        # 1. remove the particle
 
         if len(rr.products) == 0:
             
-	    # 1. No products, no info
-	    # 2. No space required
-	    # 3. No space required
-	    # 4. process the changes (remove particle, make new ones)
+            # 1. No products, no info
+            # 2. No space required
+            # 3. No space required
+            # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(reactant[0])
-	    products = []
+            products = []
 
-	    # 5. No new single to be made
-	    # 6. Log the change
+            # 5. No new single to be made
+            # 6. Log the change
 
             
         elif len(rr.products) == 1:
-	# TODO product particle can live on different structure
+        # TODO product particle can live on different structure
             
-	    # 1. get product info
+            # 1. get product info
             product_species = self.world.get_species(rr.products[0])
-	    product_radius  = product_species.radius
-	    product_structure = self.world.get_structure(product_species.structure_id) 
-
-	    # 1.5 produce a number of new possible positions for the product particle
-	    # TODO make these generators for efficiency
-	    if product_structure != reactant_structure:
-		assert isinstance(product_structure, CuboidalRegion)
-
-		if isinstance(reactant_structure, PlanarSurface):
-		    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR	# the thickness of the membrane is 0.0
-		    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
-					for direction in [-1,1]]	# FIXME the direction should be randomized
-
-		elif isinstance(reactant_structure, CylindricalSurface):
-		    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
-		    product_pos_list = []
-		    for _ in range(self.dissociation_retry_moves):
-			unit_vector3D = random_unit_vector()
-			unit_vector2D = normalize(unit_vector3D - numpy.dot(unit_vector3D, reactant_structure.shape.unit_z))
-			vector = reactant_pos + vector_length * unit_vector2D
-			product_pos_list.append(vector)
-		else:
-		    # cannot decay from 3D to other structure
-            	    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
-	    else:
-	        product_pos_list = [reactant_pos]		# no change of position is required if structure doesn't change
-
-
-	    # TODO try alternatives if surrounding is crowded
-	    product_pos = product_pos_list[0]
-	    product_pos = self.world.apply_boundary(product_pos)
+            product_radius  = product_species.radius
+            product_structure = self.world.get_structure(product_species.structure_id) 
+
+            # 1.5 produce a number of new possible positions for the product particle
+            # TODO make these generators for efficiency
+            if product_structure != reactant_structure:
+                assert isinstance(product_structure, CuboidalRegion)
+
+                if isinstance(reactant_structure, PlanarSurface):
+                    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # the thickness of the membrane is 0.0
+                    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
+                                        for direction in [-1,1]]        # FIXME the direction should be randomized
+
+                elif isinstance(reactant_structure, CylindricalSurface):
+                    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
+                    product_pos_list = []
+                    for _ in range(self.dissociation_retry_moves):
+                        unit_vector3D = random_unit_vector()
+                        unit_vector2D = normalize(unit_vector3D - numpy.dot(unit_vector3D, reactant_structure.shape.unit_z))
+                        vector = reactant_pos + vector_length * unit_vector2D
+                        product_pos_list.append(vector)
+                else:
+                    # cannot decay from 3D to other structure
+                    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+            else:
+                product_pos_list = [reactant_pos]               # no change of position is required if structure doesn't change
+
+
+            # TODO try alternatives if surrounding is crowded
+            product_pos = product_pos_list[0]
+            product_pos = self.world.apply_boundary(product_pos)
 
             # 2. make space for the products.
 #            if product_pos != reactant_pos or product_radius > reactant_radius:
             self.burst_volume(product_pos, product_radius)
 
-	    # 3. check that there is space for the products 
+            # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
-		# 4. Process (the lack of) change
-		moved_reactant = self.move_particle(reactant, reactant_pos)
-                products = [moved_reactant]	# no change
+                # 4. Process (the lack of) change
+                moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]     # no change
 
-		# 5. update counters
-        	self.rejected_moves += 1
+                # 5. update counters
+                self.rejected_moves += 1
 
-		# 6. Log the event
+                # 6. Log the event
                 if __debug__:
-            	    log.info('single reaction; placing product failed.')
-	    else:
-	        # 4. process the changes (remove particle, make new ones)
+                    log.info('single reaction; placing product failed.')
+            else:
+                # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(reactant[0])
                 newparticle = self.world.new_particle(product_species.id, product_pos)
-	        products = [newparticle]
+                products = [newparticle]
 
-		# 5. update counters
-        	self.reaction_events += 1
-        	self.last_reaction = (rr, (reactant[1], None), products)
+                # 5. update counters
+                self.reaction_events += 1
+                self.last_reaction = (rr, (reactant[1], None), products)
 
-	        # 6. Log the change
+                # 6. Log the change
                 if __debug__:
                      log.info('product (%s) = %s' % (len(products), products))
 
             
         elif len(rr.products) == 2:
-	    # 1. get product info
+            # 1. get product info
             product1_species = self.world.get_species(rr.products[0])
             product2_species = self.world.get_species(rr.products[1])
-	    product1_structure = self.world.get_structure(product1_species.structure_id) 
-	    product2_structure = self.world.get_structure(product2_species.structure_id) 
+            product1_structure = self.world.get_structure(product1_species.structure_id) 
+            product2_structure = self.world.get_structure(product2_species.structure_id) 
             
             D1 = product1_species.D
             D2 = product2_species.D
@@ -758,358 +758,358 @@ def fire_single_reaction(self, single, reactant_pos):
 
             # calculate the displace of the particles according to the ratio D1:D2
             # this way, species with small D only have small displacement from the reaction point.
-	    if D1 == D2:
-	    # special case (this should also catch D1==D2==0.0)
-		product1_displacement = particle_radius12 * 0.5
-		product2_displacement = particle_radius12 * 0.5
-	    else:
+            if D1 == D2:
+            # special case (this should also catch D1==D2==0.0)
+                product1_displacement = particle_radius12 * 0.5
+                product2_displacement = particle_radius12 * 0.5
+            else:
                 D12 = D1 + D2
-	        product1_displacement = particle_radius12 * (D1 / D12)
-	        product2_displacement = particle_radius12 * (D2 / D12)
-
-	    product1_displacement *= MINIMAL_SEPARATION_FACTOR
-	    product2_displacement *= MINIMAL_SEPARATION_FACTOR
-
-
-	    if product1_structure != product2_structure:
-		# make sure that the reactant was on a 2D or 1D surface
-		assert not isinstance(reactant_structure, CuboidalRegion)
-		# make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
-		assert (isinstance(product1_structure, CuboidalRegion) ^ isinstance(product2_structure, CuboidalRegion))
-
-		# figure out which product stays in the surface and which one goes to 3D
-		if isinstance(product2_structure, CuboidalRegion):
-		    # product2 goes to 3D and is now particleB (product1 is particleA)
-		    productA_displacement = product1_displacement
-		    productB_displacement = product2_displacement
-		    productB_radius = product2_radius
-		    default = True	# we like to think of this as the default
-		else:
-		    # product1 goes to 3D and is now particleB (product2 is particleA)
-		    productA_displacement = product2_displacement
-		    productB_displacement = product1_displacement
-		    productB_radius = product1_radius
-		    default = False
-		# Note that A is a particle in the surface and B is in the 3D
-
-		if isinstance(reactant_structure, PlanarSurface):
-
-		    # draw a number of new positions for the two product particles
-		    # TODO make this into a generator
-		    phi_min = math.asin (productB_radius / particle_radius12)	# we assume the membrane to have zero thickness
-		    phi_min *= MINIMAL_SEPARATION_FACTOR	# make sure that there's some distance from the membrane
-
-		    product_pos_list = []
-		    for _ in range(self.dissociation_retry_moves):
-			# draw the random angle for the 3D particle relative to the particle left in the membrane
-			# not all angles are available because particle cannot intersect with the membrane
-		        phi = myrandom.uniform(phi_min, Pi - phi_min)
-
-		        cos_phi = math.cos(phi) 
-			sin_phi = math.sin(phi)
-
-		        productA_displacement_xy = productA_displacement * cos_phi
-		        productB_displacement_xy = productB_displacement * cos_phi
-			productB_displacement_z  = particle_radius12 * sin_phi
-
-			# pick a random orientation
-			orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
-			# pick a random side of the membrane
-			orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-
-			newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
-			newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
-						 productB_displacement_z  * orientation_vector_z
+                product1_displacement = particle_radius12 * (D1 / D12)
+                product2_displacement = particle_radius12 * (D2 / D12)
+
+            product1_displacement *= MINIMAL_SEPARATION_FACTOR
+            product2_displacement *= MINIMAL_SEPARATION_FACTOR
+
+
+            if product1_structure != product2_structure:
+                # make sure that the reactant was on a 2D or 1D surface
+                assert not isinstance(reactant_structure, CuboidalRegion)
+                # make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
+                assert (isinstance(product1_structure, CuboidalRegion) ^ isinstance(product2_structure, CuboidalRegion))
+
+                # figure out which product stays in the surface and which one goes to 3D
+                if isinstance(product2_structure, CuboidalRegion):
+                    # product2 goes to 3D and is now particleB (product1 is particleA)
+                    productA_displacement = product1_displacement
+                    productB_displacement = product2_displacement
+                    productB_radius = product2_radius
+                    default = True      # we like to think of this as the default
+                else:
+                    # product1 goes to 3D and is now particleB (product2 is particleA)
+                    productA_displacement = product2_displacement
+                    productB_displacement = product1_displacement
+                    productB_radius = product1_radius
+                    default = False
+                # Note that A is a particle in the surface and B is in the 3D
+
+                if isinstance(reactant_structure, PlanarSurface):
+
+                    # draw a number of new positions for the two product particles
+                    # TODO make this into a generator
+                    phi_min = math.asin (productB_radius / particle_radius12)   # we assume the membrane to have zero thickness
+                    phi_min *= MINIMAL_SEPARATION_FACTOR        # make sure that there's some distance from the membrane
+
+                    product_pos_list = []
+                    for _ in range(self.dissociation_retry_moves):
+                        # draw the random angle for the 3D particle relative to the particle left in the membrane
+                        # not all angles are available because particle cannot intersect with the membrane
+                        phi = myrandom.uniform(phi_min, Pi - phi_min)
+
+                        cos_phi = math.cos(phi) 
+                        sin_phi = math.sin(phi)
+
+                        productA_displacement_xy = productA_displacement * cos_phi
+                        productB_displacement_xy = productB_displacement * cos_phi
+                        productB_displacement_z  = particle_radius12 * sin_phi
+
+                        # pick a random orientation
+                        orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
+                        # pick a random side of the membrane
+                        orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+
+                        newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
+                        newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
+                                                 productB_displacement_z  * orientation_vector_z
                         newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
 
                         assert (self.world.distance(newposA, newposB) >= particle_radius12)
-			assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
+                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
 
-			if default:
-			    newpos1, newpos2 = newposA, newposB
-			else:
-			    newpos1, newpos2 = newposB, newposA
+                        if default:
+                            newpos1, newpos2 = newposA, newposB
+                        else:
+                            newpos1, newpos2 = newposB, newposA
 
-			product_pos_list.append((newpos1, newpos2))
+                        product_pos_list.append((newpos1, newpos2))
 
-		elif isinstance(reactant_structure, CylindricalSurface):
+                elif isinstance(reactant_structure, CylindricalSurface):
 
-		    # TODO insert reverse transformation for 3D/1D here
-		    surface_displace = product3D_radius + reactant_structure.shape.radius
+                    # TODO insert reverse transformation for 3D/1D here
+                    surface_displace = product3D_radius + reactant_structure.shape.radius
 
-		else:
-		    # cannot decay from 3D to other structure
-            	    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+                else:
+                    # cannot decay from 3D to other structure
+                    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
-	    else:
-		# The two particles stay on the same structure.
+            else:
+                # The two particles stay on the same structure.
 
-		# generate new positions in the structure
-	        # TODO Make this into a generator
-		product_pos_list = []
+                # generate new positions in the structure
+                # TODO Make this into a generator
+                product_pos_list = []
                 for _ in range(self.dissociation_retry_moves):
-		    # calculate a random vector in the structure with unit length
-		    # FIXME for particles on the cylinder there are only two possibilities
+                    # calculate a random vector in the structure with unit length
+                    # FIXME for particles on the cylinder there are only two possibilities
                     orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
             
-		    newpos1 = reactant_pos + product1_displacement * orientation_vector
-		    newpos2 = reactant_pos - product2_displacement * orientation_vector
+                    newpos1 = reactant_pos + product1_displacement * orientation_vector
+                    newpos2 = reactant_pos - product2_displacement * orientation_vector
                     newpos1 = self.world.apply_boundary(newpos1)
                     newpos2 = self.world.apply_boundary(newpos2)
 
                     assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
-		    product_pos_list.append((newpos1, newpos2))
+                    product_pos_list.append((newpos1, newpos2))
 
             # 2. make space for the products. 
-	    # TODO
-	    #    calculate the sphere around the two product particles
+            # TODO
+            #    calculate the sphere around the two product particles
             rad = max(product1_displacement + product1_radius,
                       product2_displacement + product2_radius)
             self.burst_volume(reactant_pos, rad)
 
-	    # 3. check that there is space for the products (try different positions if possible)
+            # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
-	    for newpos1, newpos2 in product_pos_list:
+            for newpos1, newpos2 in product_pos_list:
                 if (not self.world.check_overlap((newpos1, product1_radius), reactant[0])
                    and
                    not self.world.check_overlap((newpos2, product2_radius), reactant[0])):
-		    
-	    	    # 4. process the changes (remove particle, make new ones)
+                    
+                    # 4. process the changes (remove particle, make new ones)
                     self.world.remove_particle(reactant[0])
                     product1_pair = self.world.new_particle(product1_species.id, newpos1)
                     product2_pair = self.world.new_particle(product2_species.id, newpos2)
-	            products = [product1_pair, product2_pair]
+                    products = [product1_pair, product2_pair]
 
-	            # 5. update counters
+                    # 5. update counters
                     self.reaction_events += 1
                     self.last_reaction = (rr, (reactant[1], None), products)
 
-	            # 6. Log the change
+                    # 6. Log the change
                     if __debug__:
                         log.info('products (%s) = %s' % (len(products), products))
 
-		    # exit the loop, we have found new positions
+                    # exit the loop, we have found new positions
                     break
             else:
                 if __debug__:
-            	    log.info('single reaction; placing products failed.')
-		moved_reactant = self.move_particle(reactant, reactant_pos)
-		products = [moved_reactant]
-        	self.rejected_moves += 1
+                    log.info('single reaction; placing products failed.')
+                moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]
+                self.rejected_moves += 1
 
         else:
             raise RuntimeError('num products >= 3 not supported.')
 
-	return products
+        return products
 
     def fire_interaction(self, single, reactant_pos):
-	# This takes care of the identity change when a particle associates with a surface
-	# It performs the reactions:
-	# A(3D) + surface -> 0
-	# A(3D) + surface -> B(surface)
+        # This takes care of the identity change when a particle associates with a surface
+        # It performs the reactions:
+        # A(3D) + surface -> 0
+        # A(3D) + surface -> B(surface)
 
-	# 0. get reactant info
-	reactant        = single.pid_particle_pair
+        # 0. get reactant info
+        reactant        = single.pid_particle_pair
         reactant_radius    = reactant[1].radius
         rr = single.interactionrule
 
-	# 1. remove the particle
+        # 1. remove the particle
 
         if len(rr.products) == 0:
             
-	    # 1. No products, no info
-	    # 2. No space required
-	    # 3. No space required
-	    # 4. process the changes (remove particle, make new ones)
+            # 1. No products, no info
+            # 2. No space required
+            # 3. No space required
+            # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(reactant[0])
-	    products = []
+            products = []
 
-	    # 5. No new single to be made
-	    # 6. Log the change
+            # 5. No new single to be made
+            # 6. Log the change
 
             
         elif len(rr.products) == 1:
             
-	    # 1. get product info
+            # 1. get product info
             product_species = self.world.get_species(rr.products[0])
-	    product_radius  = product_species.radius
+            product_radius  = product_species.radius
             product_surface = single.surface
 
-	    # 1.5 get new position of particle
-	    transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
+            # 1.5 get new position of particle
+            transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
             product_pos, _ = product_surface.projected_point(transposed_pos)
-	    product_pos = self.world.apply_boundary(product_pos)	# not sure this is still necessary
+            product_pos = self.world.apply_boundary(product_pos)        # not sure this is still necessary
 
             # 2. burst the volume that will contain the products.
-	    #    Note that an interaction domain is already sized such that it includes the
-	    #    reactant particle moving into the surface.
-	    if product_radius > reactant_radius:
+            #    Note that an interaction domain is already sized such that it includes the
+            #    reactant particle moving into the surface.
+            if product_radius > reactant_radius:
                 self.burst_volume(product_pos, product_radius)
 
-	    # 3. check that there is space for the products 
+            # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
                 if __debug__:
-            	    log.info('interaction; placing product failed.')
-		moved_reactant = self.move_particle(reactant, reactant_pos)
-                products = [moved_reactant]	# no change 
-        	self.rejected_moves += 1
+                    log.info('interaction; placing product failed.')
+                moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]     # no change 
+                self.rejected_moves += 1
 
-	    else:
-	        # 4. process the changes (remove particle, make new ones)
+            else:
+                # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(reactant[0])
                 newparticle = self.world.new_particle(product_species.id, product_pos)
-	        products = [newparticle]
+                products = [newparticle]
 
-		# 5. update counters
-        	self.reaction_events += 1
-        	self.last_reaction = (rr, (reactant[1], None), products)
+                # 5. update counters
+                self.reaction_events += 1
+                self.last_reaction = (rr, (reactant[1], None), products)
 
-	        # 6. Log the change
+                # 6. Log the change
                 if __debug__:
                      log.info('product (%s) = %s' % (len(products), products))
 
         else:
             raise RuntimeError('fire_interaction: num products > 1 not supported.')
 
-	return products
+        return products
 
 
     def fire_pair_reaction(self, pair):
-	# This takes care of the identity change when two particles react with each other
-	# It performs the reactions:
-	# A(any structure) + B(same structure) -> 0
-	# A(any structure) + B(same structure or 3D) -> C(same structure)
-	pass
+        # This takes care of the identity change when two particles react with each other
+        # It performs the reactions:
+        # A(any structure) + B(same structure) -> 0
+        # A(any structure) + B(same structure or 3D) -> C(same structure)
+        pass
 
 
     def fire_move(self, single, reactant_pos):
-	# No reactions/Interactions have taken place -> no identity change of the particle
-	# Just only move the particles
+        # No reactions/Interactions have taken place -> no identity change of the particle
+        # Just only move the particles
 
-	reactant = single.pid_particle_pair
+        reactant = single.pid_particle_pair
 
         if self.world.check_overlap((reactant_pos, reactant[1].radius),
                                     reactant[0]):
             raise RuntimeError('fire_move: particle overlap failed.')
-	moved_reactant = self.move_particle(reactant, reactant_pos)
-	return [moved_reactant]
+        moved_reactant = self.move_particle(reactant, reactant_pos)
+        return [moved_reactant]
 
 
     def process_single_event(self, single):
 
-	### log Single event
+        ### log Single event
         if __debug__:
             log.info('%s' % single.event_type)
             log.info('single = %s' % single)
 
 
 
-	if single.is_reset():
-	### If no event event really happened and just need to make new domain
-	    domains = [self.make_new_domain(single)]
-	    # domain is already scheduled in make_new_domain
+        if single.is_reset():
+        ### If no event event really happened and just need to make new domain
+            domains = [self.make_new_domain(single)]
+            # domain is already scheduled in make_new_domain
 
-	### 1.1 Special cases (shortcuts)
+        ### 1.1 Special cases (shortcuts)
         # In case nothing is scheduled to happen: do nothing and just reschedule
         elif single.dt == numpy.inf:
             self.add_domain_event(single)
             domains = [single]
 
-	else:
-	### 1. Process 'normal' event produced by the single
+        else:
+        ### 1. Process 'normal' event produced by the single
 
             # check that the event time of the single (last_time + dt) is equal to the
-	    # simulator time
+            # simulator time
             assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
 
 
-	    pid_particle_pair = single.pid_particle_pair
-	    # in case of an interaction domain: determine real event before doing anything
-	    if single.event_type == EventType.IV_EVENT:
-		single.event_type = single.draw_iv_event_type()
+            pid_particle_pair = single.pid_particle_pair
+            # in case of an interaction domain: determine real event before doing anything
+            if single.event_type == EventType.IV_EVENT:
+                single.event_type = single.draw_iv_event_type()
 
 
-	    # get the (new) position
+            # get the (new) position
             if single.getD() != 0 and single.dt > 0.0:
-		# If the particle had the possibility to diffuse
-		newpos = single.draw_new_position(single.dt, single.event_type)
-	        newpos = self.world.apply_boundary(newpos)
-	    else:
-		newpos = pid_particle_pair[1].position
+                # If the particle had the possibility to diffuse
+                newpos = single.draw_new_position(single.dt, single.event_type)
+                newpos = self.world.apply_boundary(newpos)
+            else:
+                newpos = pid_particle_pair[1].position
 
-	    # newpos now hold the new position of the particle (not yet committed to the world)
-	    # if we would here move the particles and make new shells, then it would be similar to a propagate
+            # newpos now hold the new position of the particle (not yet committed to the world)
+            # if we would here move the particles and make new shells, then it would be similar to a propagate
 
             self.remove_domain(single)
 
             # If the single had a decay reaction or interaction.
             if single.event_type == EventType.SINGLE_REACTION or \
-	       single.event_type == EventType.IV_INTERACTION:
+               single.event_type == EventType.IV_INTERACTION:
                 if __debug__:
                     log.info('%s' % single.event_type)
                     log.info('reactant = %s' % single)
 
-		if single.event_type == EventType.SINGLE_REACTION:
+                if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1
                     particles = self.fire_single_reaction(single, newpos)
 
-		else:
+                else:
                     self.interaction_steps[single.event_type] += 1
                     particles = self.fire_interaction(single, newpos)
 
-	    else:
-		particles = self.fire_move(single, newpos)
-
-	    # 5. Make a (new) domain (reuse) domain for each particle(s)
-	    #    (Re)schedule the (new) domain
-	    domains = []
-	    for pid_particle_pair in particles:
-#	        single.pid_particle_pair = pid_particle_pair	# reuse single
-		single = self.create_single(pid_particle_pair)
-		self.add_domain_event(single)
-		domains.append(single) 
+            else:
+                particles = self.fire_move(single, newpos)
+
+            # 5. Make a (new) domain (reuse) domain for each particle(s)
+            #    (Re)schedule the (new) domain
+            domains = []
+            for pid_particle_pair in particles:
+#               single.pid_particle_pair = pid_particle_pair    # reuse single
+                single = self.create_single(pid_particle_pair)
+                self.add_domain_event(single)
+                domains.append(single) 
 
-	    # 6. Log change?
-		
-	return domains
+            # 6. Log change?
+                
+        return domains
 
 
     def make_new_domain(self, single):
-	### Make a new domain out of a NonInteractionSingle that was
-	### just fired
-
-	# can only make new domain from NonInteractionSingle
-	assert isinstance(single, NonInteractionSingle)
-	
-	# Special case: When D=0, nothing needs to change and only new event
-	# time is drawn
-	# TODO find nicer constructrion than just this if statement
-	if single.getD() == 0:
+        ### Make a new domain out of a NonInteractionSingle that was
+        ### just fired
+
+        # can only make new domain from NonInteractionSingle
+        assert isinstance(single, NonInteractionSingle)
+        
+        # Special case: When D=0, nothing needs to change and only new event
+        # time is drawn
+        # TODO find nicer constructrion than just this if statement
+        if single.getD() == 0:
             single.dt, single.event_type = single.determine_next_event() 
             single.last_time = self.t
             self.add_domain_event(single)
             return
 
 
-	single_pos = single.pid_particle_pair[1].position
-	single_radius = single.pid_particle_pair[1].radius
+        single_pos = single.pid_particle_pair[1].position
+        single_radius = single.pid_particle_pair[1].radius
 
-	# 2.1
-	# We prefer to make NonInteractionSingles for efficiency.
-	# But if objects (Shells and surfaces) get close enough (closer than
-	# reaction_threshold) we want to try Interaction and/or Pairs
+        # 2.1
+        # We prefer to make NonInteractionSingles for efficiency.
+        # But if objects (Shells and surfaces) get close enough (closer than
+        # reaction_threshold) we want to try Interaction and/or Pairs
 
-	# Check if there are shells with the burst radius (reaction_threshold)
-	# of the particle (intruders). Note that we approximate the reaction_volume
-	# with a sphere (should be cylinder for 2D or 1D particle)
+        # Check if there are shells with the burst radius (reaction_threshold)
+        # of the particle (intruders). Note that we approximate the reaction_volume
+        # with a sphere (should be cylinder for 2D or 1D particle)
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
         intruder_ids, closest_id, closest_distance = \
             self.geometrycontainer.get_intruders(single_pos, reaction_threshold,
                                                  ignore=[single.domain_id, ])
-	intruders = [self.domains[domain_id] for domain_id in intruder_ids]
+        intruders = [self.domains[domain_id] for domain_id in intruder_ids]
 
         if __debug__:
             log.debug("intruders: %s" %
@@ -1117,116 +1117,116 @@ def make_new_domain(self, single):
 
 
         # 2.2 Burst the shells with the following conditions
-	# -shell is in the burst radius (intruder)
-	# -shell is burstable (not Multi)
-	# -shell is not newly made
-	# -shell is not already a zero shell (just bursted)
-	burst = []
+        # -shell is in the burst radius (intruder)
+        # -shell is burstable (not Multi)
+        # -shell is not newly made
+        # -shell is not already a zero shell (just bursted)
+        burst = []
         if intruders:
 #            burst = self.burst_non_multis(intruders)
-	    for domain in intruders:
-        	if not isinstance(domain, Multi) and \
+            for domain in intruders:
+                if not isinstance(domain, Multi) and \
                    not self.t == domain.last_time: # and \
-#		   not domain.dt == 0.0:
+#                  not domain.dt == 0.0:
                     # domain is Single or Pair of some subclass
-            	    single_list = self.burst_domain(domain)
+                    single_list = self.burst_domain(domain)
                     burst.extend(single_list)
                 elif isinstance(domain, Multi):
                     # domain is a Multi
                     burst.append(domain)
 
-	    # burst now contains all the Domains resulting from the burst.
-	    # These are NonInteractionSingles and Multis
+            # burst now contains all the Domains resulting from the burst.
+            # These are NonInteractionSingles and Multis
 
 
-	# 2.3 get the closest object (a Domain or surface) which can be a
-	# partner for a new domain. This can be:
-	# zero-shell NonInteractionSingle -> Pair or Multi
-	# Multi -> Multi
-	# Surface -> Interaction
-	closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
-									ignore=[single.domain_id],
-									ignores=[single.structure.id])
+        # 2.3 get the closest object (a Domain or surface) which can be a
+        # partner for a new domain. This can be:
+        # zero-shell NonInteractionSingle -> Pair or Multi
+        # Multi -> Multi
+        # Surface -> Interaction
+        closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
+                                                                        ignore=[single.domain_id],
+                                                                        ignores=[single.structure.id])
 
-	# TODO Potential partners are for now just the bursted domains
-	partners = burst
+        # TODO Potential partners are for now just the bursted domains
+        partners = burst
 
-	dists = []
-	if partners:
+        dists = []
+        if partners:
             # sort partners by distance
-	    dists = self.obj_distance_array(single_pos, partners)
+            dists = self.obj_distance_array(single_pos, partners)
             if len(dists) >= 2:
-        	n = dists.argsort()
-        	partners = numpy.take(partners, n)	# sort the potential partners using the index
-        	dists = dists.take(n)			# sort the distances using the index
-
-	    closest_domain = partners[0]
-	    domain_distance = dists[0]
-	    rest_domains = partners[1:]
-	    rest_dists = dists[1:]
-	else:
-	    closest_domain = None
-	    domain_distance = numpy.inf
-	    rest_domains = []
-	    rest_dists = []
-	
-	# Potential partners are also surfaces
+                n = dists.argsort()
+                partners = numpy.take(partners, n)      # sort the potential partners using the index
+                dists = dists.take(n)                   # sort the distances using the index
+
+            closest_domain = partners[0]
+            domain_distance = dists[0]
+            rest_domains = partners[1:]
+            rest_dists = dists[1:]
+        else:
+            closest_domain = None
+            domain_distance = numpy.inf
+            rest_domains = []
+            rest_dists = []
+        
+        # Potential partners are also surfaces
         closest_surface, surface_distance = \
-	get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
+        get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
 
 
 
-	# 2.4 calculate the thresholds (horizons) for trying to form the various domains.
-	# Note that we do not differentiate between directions. This means that we
-	# look around in a sphere, the horizons are spherical
-	surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
-	multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
+        # 2.4 calculate the thresholds (horizons) for trying to form the various domains.
+        # Note that we do not differentiate between directions. This means that we
+        # look around in a sphere, the horizons are spherical
+        surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+        multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
 
-	# 2.4 check that the object is a potential partner for an
-	# -Pair		(a zero dt NonInteractionSingle)
-	# -Interaction 	(a surface)
-	# -Multi	(a zero dt NonInteractionSingle or Multi)
-	if isinstance(closest_obj, NonInteractionSingle) and \
-	   closest_obj.is_reset():
-		pair_horizon = (single_radius + \
+        # 2.4 check that the object is a potential partner for an
+        # -Pair         (a zero dt NonInteractionSingle)
+        # -Interaction  (a surface)
+        # -Multi        (a zero dt NonInteractionSingle or Multi)
+        if isinstance(closest_obj, NonInteractionSingle) and \
+           closest_obj.is_reset():
+                pair_horizon = (single_radius + \
                        closest_obj.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
-		if closest_distance < pair_horizon:
-	            # try making a Pair (can still be Mixed Pair or Normal Pair)
-		    domain = self.try_pair (single, closest_obj)
-		else:
-		    domain = None
-
-	elif isinstance(single, SphericalSingle) and \
-	     (isinstance(closest_obj, CylindricalSurface) or isinstance(closest_obj, PlanarSurface)) and \
-	     closest_distance < surface_horizon:
-#	     surface_distance < domain_distance and \
-#	     surface_distance < surface_horizon:
-		# try making an Interaction
-	    domain = self.try_interaction (single, closest_obj)
-	else:
-	    domain = None
-
-
-	if not domain:
-	    # No Pair or Interaction could be formed
-	    # Now choose between NonInteractionSingle and Multi
-
-	    if closest_distance > multi_horizon: # and \
-#	       surface_distance > multi_horizon:
-	        # just make a normal NonInteractionSingle
-	        self.update_single(single)
-	        self.add_domain_event(single)
-	    else:
-		# The closest object was too close to make a NonInteractionSingle
-		domain = self.form_multi(single, partners, dists)
-
-	return domain
+                if closest_distance < pair_horizon:
+                    # try making a Pair (can still be Mixed Pair or Normal Pair)
+                    domain = self.try_pair (single, closest_obj)
+                else:
+                    domain = None
+
+        elif isinstance(single, SphericalSingle) and \
+             (isinstance(closest_obj, CylindricalSurface) or isinstance(closest_obj, PlanarSurface)) and \
+             closest_distance < surface_horizon:
+#            surface_distance < domain_distance and \
+#            surface_distance < surface_horizon:
+                # try making an Interaction
+            domain = self.try_interaction (single, closest_obj)
+        else:
+            domain = None
+
+
+        if not domain:
+            # No Pair or Interaction could be formed
+            # Now choose between NonInteractionSingle and Multi
+
+            if closest_distance > multi_horizon: # and \
+#              surface_distance > multi_horizon:
+                # just make a normal NonInteractionSingle
+                self.update_single(single)
+                self.add_domain_event(single)
+            else:
+                # The closest object was too close to make a NonInteractionSingle
+                domain = self.form_multi(single, partners, dists)
+
+        return domain
 
 
     def calculate_simplepair_shell_size(self, single1, single2):
-	assert single1.structure == single2.structure
+        assert single1.structure == single2.structure
 
-	# 0. Get some necessary information
+        # 0. Get some necessary information
         pos1 = single1.pid_particle_pair[1].position
         pos2 = single2.pid_particle_pair[1].position
 
@@ -1242,20 +1242,20 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
 #        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
 #        com = self.world.apply_boundary(com)
-	com, iv = SimplePair.do_transform(single1, single2, self.world)
-	r0 = length (iv)
-        distance_from_sigma = r0 - sigma	# the distance between the surfaces of the particles
+        com, iv = SimplePair.do_transform(single1, single2, self.world)
+        r0 = length (iv)
+        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
 
-	# 1. Get the minimal possible shell size (including margin?)
+        # 1. Get the minimal possible shell size (including margin?)
         min_shell_size = SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
 
-	# 2. Get the maximum possible shell size
-	max_shell_size = SimplePair.get_max_shell_size(com, single1, single2,
-						       self.geometrycontainer, self.domains)
+        # 2. Get the maximum possible shell size
+        max_shell_size = SimplePair.get_max_shell_size(com, single1, single2,
+                                                       self.geometrycontainer, self.domains)
 
-	# 3. Calculate the maximum based on some other criterium (convergence?)
-#        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin		# FIXME
-#	max_shell_size = min(max_shell_size, convergence_max)
+        # 3. Calculate the maximum based on some other criterium (convergence?)
+#        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin                # FIXME
+#       max_shell_size = min(max_shell_size, convergence_max)
 
 
         # 4. Check if min shell size for the Pair not larger than max shell size or 
@@ -1270,18 +1270,18 @@ def calculate_simplepair_shell_size(self, single1, single2):
                            FORMAT_DOUBLE % max_shell_size))
             return None, None, None
 
-	# 5. Calculate the 'ideal' shell size
+        # 5. Calculate the 'ideal' shell size
 #        D_closest = closest.pid_particle_pair[1].D
 #        D_tot = D_closest + D12
 #        ideal_shell_size = min((D12 / D_tot) *
 #                            (closest_particle_distance - min_shell_size - closest_min_radius) +
-#			     min_shell_size,
-	ideal_shell_size = numpy.inf
-	shell_size = min(max_shell_size, ideal_shell_size)
+#                            min_shell_size,
+        ideal_shell_size = numpy.inf
+        shell_size = min(max_shell_size, ideal_shell_size)
 
 
         # 6. Check if singles would not be better.
-	# TODO clear this up -> strange rule
+        # TODO clear this up -> strange rule
         d1 = self.world.distance(com, pos1)
         d2 = self.world.distance(com, pos2)
 
@@ -1300,26 +1300,26 @@ def calculate_simplepair_shell_size(self, single1, single2):
         assert shell_size >= min_shell_size
         assert shell_size <= max_shell_size
 
-	if __debug__:
-	    log.info('SimplePair shell made. shell_size=%s, '
+        if __debug__:
+            log.info('SimplePair shell made. shell_size=%s, '
                      'closest_shell_distance=%s,\nclosest = %s' %
                      (FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % 0, None))
 
-	return com, r0, shell_size
+        return com, r0, shell_size
 
 
     def update_single(self, single): 
-        assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
+        assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
-	min_shell_size = single.get_min_shell_size()
-	max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
+        min_shell_size = single.get_min_shell_size()
+        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
 
-	# Make sure that the new shell size is not too small or big
+        # Make sure that the new shell size is not too small or big
         new_shell_size = max(max_shell_size, min_shell_size)
 
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.
-	singlepos = single.pid_particle_pair[1].position
+        singlepos = single.pid_particle_pair[1].position
         self.update_single_shell(single, singlepos, new_shell_size)        
 
         single.dt, single.event_type = single.determine_next_event()
@@ -1328,7 +1328,7 @@ def update_single(self, single):
     def process_pair_event(self, pair):
         assert self.check_obj(pair)
 
-	# check that the time is the currect simulator time 
+        # check that the time is the currect simulator time 
         assert self.t >= pair.last_time
         assert self.t == pair.last_time + pair.dt
 
@@ -1374,7 +1374,7 @@ def process_pair_event(self, pair):
             else:
                 theothersingle = single1
 
-	    # note method has side effect on single1 and single2
+            # note method has side effect on single1 and single2
             self.propagate_pair(pair)
 
             self.add_domain_event(theothersingle)
@@ -1383,9 +1383,9 @@ def process_pair_event(self, pair):
                 log.info('reactant = %s' % reactingsingle)
             self.remove_domain(reactingsingle)
             particles = self.fire_single_reaction(reactingsingle, reactingsingle.pid_particle_pair[1].position)
-	    for pid_particle_pair in particles:
-		single = self.create_single(pid_particle_pair)
-		self.add_domain_event(single)
+            for pid_particle_pair in particles:
+                single = self.create_single(pid_particle_pair)
+                self.add_domain_event(single)
 
         #
         # 2. Pair reaction
@@ -1396,70 +1396,70 @@ def process_pair_event(self, pair):
             new_com, _ = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
             new_com = self.world.apply_boundary(new_com)
 
-	    # TODO make this a fire_pair_reaction method
+            # TODO make this a fire_pair_reaction method
 
 
-	    # 0. get reactant info
-	    rr = pair.draw_reaction_rule(pair.interparticle_rrs)
-	    reactant1_species_id = pid_particle_pair1[1].sid
-	    reactant2_species_id = pid_particle_pair2[1].sid
+            # 0. get reactant info
+            rr = pair.draw_reaction_rule(pair.interparticle_rrs)
+            reactant1_species_id = pid_particle_pair1[1].sid
+            reactant2_species_id = pid_particle_pair2[1].sid
 
-	    # 1. remove the particles
+            # 1. remove the particles
 
             if len(rr.products) == 0:
 
-		# 1. no product particles, no info
-		# 2. No space required
-		# 3. No space required
-		# 4. process the change (remove particles, make new ones)
+                # 1. no product particles, no info
+                # 2. No space required
+                # 3. No space required
+                # 4. process the change (remove particles, make new ones)
                 self.world.remove_particle(pid_particle_pair1[0])
                 self.world.remove_particle(pid_particle_pair2[0])
-		products = []
+                products = []
 
-		# 5. No new single to be made
-		# 6. Log the change
+                # 5. No new single to be made
+                # 6. Log the change
                 self.last_reaction = (rr, (pid_particle_pair1[1], pid_particle_pair2[1]), products)
 
-	    elif len(rr.products) == 1:
+            elif len(rr.products) == 1:
 
-		# 1. get product info
+                # 1. get product info
                 product_species = self.world.get_species(rr.products[0])
 
-		# 1.5 no change in position due to reaction
-		# position = new_com
+                # 1.5 no change in position due to reaction
+                # position = new_com
 
-		# 2.  make space for products
-		# 2.1 if the product particle sticks out of the shell
-		if self.world.distance(old_com, new_com) > (pair.get_shell_size() - product_species.radius):
-		    self.burst_volume(new_com, product_species.radius)
+                # 2.  make space for products
+                # 2.1 if the product particle sticks out of the shell
+                if self.world.distance(old_com, new_com) > (pair.get_shell_size() - product_species.radius):
+                    self.burst_volume(new_com, product_species.radius)
 
-		    # 3. check that there is space for the products ignoring the reactants
-		    if self.world.check_overlap((new_com, product_species.radius),
-						pid_particle_pair1[0],
-						pid_particle_pair2[0]):
-			if __debug__:
-	                    log.info('no space for product particle.')
-        	        raise NoSpace()
+                    # 3. check that there is space for the products ignoring the reactants
+                    if self.world.check_overlap((new_com, product_species.radius),
+                                                pid_particle_pair1[0],
+                                                pid_particle_pair2[0]):
+                        if __debug__:
+                            log.info('no space for product particle.')
+                        raise NoSpace()
 
-		# 4. process the changes (remove particle, make new ones)
-	        self.world.remove_particle(pid_particle_pair1[0])
+                # 4. process the changes (remove particle, make new ones)
+                self.world.remove_particle(pid_particle_pair1[0])
                 self.world.remove_particle(pid_particle_pair2[0])
                 particle = self.world.new_particle(product_species.id, new_com)
-		products = [particle, ]
+                products = [particle, ]
 
-		# 5. make a new single and schedule
+                # 5. make a new single and schedule
                 single = self.create_single(particle)
                 self.add_domain_event(single)
 
-		# 6. Log the change
-            	if __debug__:
+                # 6. Log the change
+                if __debug__:
                     log.info('product = %s' % single)
                 self.last_reaction = (rr, (pid_particle_pair1, pid_particle_pair2),
                                       products)
             else:
                 raise NotImplementedError('num products >= 2 not supported.')
 
-	    # 7. update counter
+            # 7. update counter
             self.reaction_events += 1
             self.remove_domain(pair)
 
@@ -1470,10 +1470,10 @@ def process_pair_event(self, pair):
         elif(pair.event_type == EventType.IV_ESCAPE or
              pair.event_type == EventType.COM_ESCAPE):
 
-	    # get new positions for particles, move them and make singles
+            # get new positions for particles, move them and make singles
             single1, single2 = self.propagate_pair(pair)
 
-	    # reschedule single domains
+            # reschedule single domains
             self.add_domain_event(single1)
             self.add_domain_event(single2)
 
@@ -1494,7 +1494,7 @@ def process_multi_event(self, multi):
             self.reaction_events += 1
             self.last_reaction = multi.last_reaction
 
-        if multi.last_event is not None:		# if an event took place
+        if multi.last_event is not None:                # if an event took place
             self.break_up_multi(multi)
             self.multi_steps[multi.last_event] += 1
         else:
@@ -1521,10 +1521,10 @@ def break_up_multi(self, multi):
     def burst_single(self, single):
         # Sets next event time of 'single' to current time and event to burst event
         # returns a new single that is the result of firing the old single
-	# new single also has proper zero shell and is rescheduled
+        # new single also has proper zero shell and is rescheduled
 
-	if __debug__:
-	    log.debug('burst single: %s', single)
+        if __debug__:
+            log.debug('burst single: %s', single)
 
         # Check correct timeline ~ MW
         assert single.last_time <= self.t
@@ -1534,11 +1534,11 @@ def burst_single(self, single):
         # Override event_type. 
         single.dt = self.t - single.last_time
         single.event_type = EventType.BURST
-	self.remove_event(single)
+        self.remove_event(single)
 
-#        newsingle = self.propagate_single(single)	# TODO this can now also just be a process_single_event
-#	self.add_domain_event(newsingle)
-	newsingles = self.process_single_event(single)
+#        newsingle = self.propagate_single(single)      # TODO this can now also just be a process_single_event
+#       self.add_domain_event(newsingle)
+        newsingles = self.process_single_event(single)
 
 # NOTE Be inefficient for just now and don't reuse the event in the schedules
 #        newpos = newsingle.pid_particle_pair[1].position
@@ -1546,7 +1546,7 @@ def burst_single(self, single):
 #
 #        if isinstance(single, InteractionSingle):
 #            # When bursting an InteractionSingle, the domain changes from Interaction
-#	    # NonInteraction domain. This needs to be reflected in the event 
+#           # NonInteraction domain. This needs to be reflected in the event 
 #            self.remove_event(single)
 #            self.add_domain_event(newsingle)
 #        else:
@@ -1559,30 +1559,30 @@ def burst_single(self, single):
         return newsingles
 
     def burst_pair(self, pair):
-	# Sets next event time of 'pair' to current time and event to burst event
-	# returns two new singles that are the result of firing the pair
-	# new singles also have proper zero shell and are rescheduled
+        # Sets next event time of 'pair' to current time and event to burst event
+        # returns two new singles that are the result of firing the pair
+        # new singles also have proper zero shell and are rescheduled
 
         if __debug__:
             log.debug('burst_pair: %s', pair)
 
-	# make sure that the current time is between the last time and the event time
+        # make sure that the current time is between the last time and the event time
         assert pair.last_time <= self.t
         assert self.t <= pair.last_time + pair.dt
 
         # Override event time and event_type. 
         pair.dt = self.t - pair.last_time 
         pair.event_type = EventType.BURST
-        self.remove_event(pair)		# remove the event -> was still in the scheduler
+        self.remove_event(pair)         # remove the event -> was still in the scheduler
 
-        single1, single2 = self.propagate_pair(pair)	# TODO this can now also just be a process_pair_event
+        single1, single2 = self.propagate_pair(pair)    # TODO this can now also just be a process_pair_event
         self.add_domain_event(single1)
         self.add_domain_event(single2)
 
         return single1, single2
 
     def propagate_pair(self, pair):
-	# takes a pair and returns two singles after propagation
+        # takes a pair and returns two singles after propagation
 
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
@@ -1590,39 +1590,39 @@ def propagate_pair(self, pair):
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
 
-	# if time has passed (should be always)
+        # if time has passed (should be always)
         if pair.dt > 0.0:
 #            D1 = pid_particle_pair1[1].D
 #            D2 = pid_particle_pair2[1].D
 
-	    # store for later check
+            # store for later check
             old_com = pair.com
 
 
-	    # TODO this should be done when the pair is made -> passed to the constructor
+            # TODO this should be done when the pair is made -> passed to the constructor
             pos2t = self.world.cyclic_transpose(pos2, pos1)
             old_inter_particle = pos2t - pos1
             r0 = self.world.distance(pos1, pos2)
             assert feq(r0, length(old_inter_particle))
 
-	    # draw the new positions of the particles
+            # draw the new positions of the particles
             newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
                                                        pair.event_type)
             newpos1 = self.world.apply_boundary(newpos1)
             newpos2 = self.world.apply_boundary(newpos2)
 
-	    # check that the particles do not overlap with any other particles in the world
+            # check that the particles do not overlap with any other particles in the world
             assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
                                                 pid_particle_pair1[0], pid_particle_pair2[0])
             assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
                                                 pid_particle_pair1[0], pid_particle_pair2[0])
 
-	    # some more consistency checking of the positions
+            # some more consistency checking of the positions
             assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
                                        pair.get_shell_size())
 
         else:
-	# no time has passed
+        # no time has passed
             newpos1 = pid_particle_pair1[1].position
             newpos2 = pid_particle_pair2[1].position
 
@@ -1630,22 +1630,22 @@ def propagate_pair(self, pair):
         pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
 
 
-	# re-use single domains for particles
-	# normally we would take the particles + new positions from the old pair
-	# and use them to make new singles. Now we re-use the singles stored in the
-	# pair
+        # re-use single domains for particles
+        # normally we would take the particles + new positions from the old pair
+        # and use them to make new singles. Now we re-use the singles stored in the
+        # pair
         single1 = pair.single1
         single2 = pair.single2
         assert single1.domain_id not in self.domains
         assert single2.domain_id not in self.domains
-	single1.pid_particle_pair = pid_particle_pair1	# this is probably redundant
-	single2.pid_particle_pair = pid_particle_pair2
+        single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
+        single2.pid_particle_pair = pid_particle_pair2
 
 
-	# remove the old domain
+        # remove the old domain
         self.remove_domain(pair)
 
-	# 'make' the singles
+        # 'make' the singles
         single1.initialize(self.t)
         single2.initialize(self.t)
         
@@ -1656,7 +1656,7 @@ def propagate_pair(self, pair):
         self.domains[single1.domain_id] = single1
         self.domains[single2.domain_id] = single2
 
-	# Thoroughly check the sizes of the shells of the singles
+        # Thoroughly check the sizes of the shells of the singles
         if __debug__:
             container = self.geometrycontainer.get_container(single1.shell)
             assert container[single1.shell_id].shape.radius == \
@@ -1672,12 +1672,12 @@ def propagate_pair(self, pair):
 
         assert single1.shell.shape.radius == pid_particle_pair1[1].radius
         assert single2.shell.shape.radius == pid_particle_pair2[1].radius
-	# even more checking
+        # even more checking
         assert self.check_obj(single1)
         assert self.check_obj(single2)
-	# Now finally we are convinced that the singles were actually made correctly
+        # Now finally we are convinced that the singles were actually made correctly
 
-	# Log the event
+        # Log the event
         if __debug__:
             log.debug("process_pair_event: #1 { %s: %s => %s }" %
                       (single1, str(pos1), str(newpos1)))
@@ -1690,33 +1690,33 @@ def try_interaction(self, single, surface):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 
         pid_particle_pair = single.pid_particle_pair
-	particle = pid_particle_pair[1]
+        particle = pid_particle_pair[1]
 
-	# calculate the Projected_point and distance to the surface
+        # calculate the Projected_point and distance to the surface
         # Cyclic transpose needed when calling surface.projected_point!
         pos_transposed = self.world.cyclic_transpose(particle.position, 
                                                      surface.shape.position) 
         projected_point, projection_distance = \
                 surface.projected_point(pos_transposed)
 
-	# projection_distance is relative to the unit_z of the surface -> can be negative
+        # projection_distance is relative to the unit_z of the surface -> can be negative
         particle_distance = abs(projection_distance)
 
         # For interaction with a planar surface, decide orientation. 
-	# Note that the orientation_vector is normalized
+        # Note that the orientation_vector is normalized
         orientation_vector = cmp(projection_distance, 0) * surface.shape.unit_z 
 
         if __debug__:
            log.debug('trying to form Interaction(%s, %s)' % (particle, surface))
 
 
-	### 1. See if there is enough space for the shell
+        ### 1. See if there is enough space for the shell
 
 
-	# Make sure the maximal cylinder fits in the maximal sphere. Matrix space
-	# doesn't allow to check for shells outside the maximal sphere.
-	max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
-	max_cylinder_half_length = max_cylinder_radius
+        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
+        # doesn't allow to check for shells outside the maximal sphere.
+        max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
+        max_cylinder_half_length = max_cylinder_radius
 
         # Initialize dr, dz_left, dz_right to maximum allowed values.
         # And decide minimal dr, dz_left, dz_right.
@@ -1749,7 +1749,7 @@ def try_interaction(self, single, surface):
 
         dr /= SAFETY
         dz_right /= SAFETY
-#	 This will break the conditions below for membrane interaction
+#        This will break the conditions below for membrane interaction
 #        dz_left /= SAFETY
 
         # Decide if interaction domain is possible.
@@ -1765,15 +1765,15 @@ def try_interaction(self, single, surface):
                            dz_right, min_dz_right))
             return None
 
-	### 2. The shell can be made. Now do what's necessary to make it
+        ### 2. The shell can be made. Now do what's necessary to make it
         # Compute origin, radius and half_length of cylinder.
         origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
         half_length = (dz_left + dz_right) / 2.0
         radius = dr
 
         interaction = self.create_interaction(pid_particle_pair, surface,
-					      origin, radius, half_length,
-					      orientation_vector)
+                                              origin, radius, half_length,
+                                              orientation_vector)
 
         interaction.dt, interaction.event_type, = \
             interaction.determine_next_event()
@@ -1801,30 +1801,30 @@ def calculate_max_cylinder(self, single, surface, projected_point,
                                    dr, dz_left, dz_right):
         # Find optimal cylinder around particle and surface, such that 
         # it is not interfering with other shells.
-	#
-	# To determine the maximal cylindrical shell a starting cylinder is defined
-	# * The projected_point is a reference point along the axis of the cylinder,
-	#   the position, z, can be chosen freely
-	# * orientation_vector is a vector along the z-axis providing orientation
-	#   It usually points in the general direction of the particle
-	#
+        #
+        # To determine the maximal cylindrical shell a starting cylinder is defined
+        # * The projected_point is a reference point along the axis of the cylinder,
+        #   the position, z, can be chosen freely
+        # * orientation_vector is a vector along the z-axis providing orientation
+        #   It usually points in the general direction of the particle
+        #
         # * dr is the radius of the cylinder.
         # * dz_right is the distance between the projected_point and the face of the
-	#   cylinder on the side of the orientation_vector 
+        #   cylinder on the side of the orientation_vector 
         # * dz_left is the distance from the projected_point to the face of the cylinder
-	#   on the side oposite of the orientation_vector
-	#
-	# * particle_distance is the distance from the center of the particle to the
-	#   projected_point
+        #   on the side oposite of the orientation_vector
+        #
+        # * particle_distance is the distance from the center of the particle to the
+        #   projected_point
 
-	# the search point is the center of the sphere that surrounds the
-	# maximal cylinder
+        # the search point is the center of the sphere that surrounds the
+        # maximal cylinder
         search_point = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
         all_neighbor_ids = \
             self.geometrycontainer.get_neighbors_within_radius_no_sort(search_point, 
                                                      self.geometrycontainer.get_max_shell_size(),
                                                      ignore=[single.domain_id])
-	all_neighbors = [self.domains[domain_id] for domain_id in all_neighbor_ids]
+        all_neighbors = [self.domains[domain_id] for domain_id in all_neighbor_ids]
 
         for domain in all_neighbors:
             if isinstance(domain, Multi):
@@ -1874,7 +1874,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         # shell_position and with size (radius or half_length) 
         # shell_size.
 
-	shell_position = self.world.cyclic_transpose(shell_position, projected_point)
+        shell_position = self.world.cyclic_transpose(shell_position, projected_point)
         shell_vector = shell_position - projected_point
 
         # Calculate zi and ri for this shell.
@@ -1886,16 +1886,16 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         # Calculate dr_i for this shell.
         dr_i = ri - shell_size
 
-	if isinstance(surface, PlanarSurface):
-	    dz_right -= particle_distance
+        if isinstance(surface, PlanarSurface):
+            dz_right -= particle_distance
         elif isinstance(surface, CylindricalSurface):
             # Run Miedema's algorithm in the r direction 
             # relative to the particle's position, not to 
             # projected point (r=0).
             dr_i -= particle_distance
-	    dr -= particle_distance
-	else:
-	    raise SystemError('Error in Miedema\'s algorithm: surface is not a Surface')
+            dr -= particle_distance
+        else:
+            raise SystemError('Error in Miedema\'s algorithm: surface is not a Surface')
 
         # Calculate dz_left_i or dz_right_i (both will usually 
         # be positive values).
@@ -1927,10 +1927,10 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
                 else:
                     dr = dr_i
 
-	if isinstance(surface, PlanarSurface):
-	    dz_right += particle_distance
-	elif isinstance(surface, CylindricalSurface):
-	    dr += particle_distance
+        if isinstance(surface, PlanarSurface):
+            dz_right += particle_distance
+        elif isinstance(surface, CylindricalSurface):
+            dr += particle_distance
 
         return dr, dz_left, dz_right
 
@@ -1945,7 +1945,7 @@ def try_pair(self, single1, single2):
 
         # Try forming a Pair only if singles are on same structure.
         if single1.structure != single2.structure:
-	    # TODO implement shell making method for MixedPair
+            # TODO implement shell making method for MixedPair
 
             if __debug__:
                 log.debug('Pair(%s, %s) not formed: not on same structure.' %
@@ -1953,13 +1953,13 @@ def try_pair(self, single1, single2):
                            single2.pid_particle_pair[0]))
 
             center, r0, shell_size = None, None, None
-#	    shell = self.make_mixedpair_shell (single1, single2)
-	else:
-	    # particles are on the same structure
-	    center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
+#           shell = self.make_mixedpair_shell (single1, single2)
+        else:
+            # particles are on the same structure
+            center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
 
 
-	if shell_size:
+        if shell_size:
             # A shell could be made and makes sense. Create a Pair
             pair = self.create_pair(single1, single2, center, r0, shell_size)
 
@@ -1985,50 +1985,50 @@ def try_pair(self, single1, single2):
                           FORMAT_DOUBLE % shell_size)) 
 
             return pair
-	else:
-	    return None
+        else:
+            return None
     
 
     def form_multi(self, single, neighbors, dists):
-	# form a Multi with the 'single'
-	# The 'neighbors' are neighboring NonInteractionSingles and Multi which
-	# can be added to the Multi (this can also be empty)
-	# 'dists' are the distances of the 'neighbors'
-
-	# Filter out relevant neighbors if present
-	# only consider neighboring bursted domains that are within the Multi horizon
-	min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
-	dists = numpy.array(dists)	# FIXME Not sure why this is necessary, dists should already be array
+        # form a Multi with the 'single'
+        # The 'neighbors' are neighboring NonInteractionSingles and Multi which
+        # can be added to the Multi (this can also be empty)
+        # 'dists' are the distances of the 'neighbors'
+
+        # Filter out relevant neighbors if present
+        # only consider neighboring bursted domains that are within the Multi horizon
+        min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+        dists = numpy.array(dists)      # FIXME Not sure why this is necessary, dists should already be array
         neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
-	if neighbors:
+        if neighbors:
             closest = neighbors[0]
-	else:
-	    closest = None
+        else:
+            closest = None
 
 
-	# 1. Make new Multi if Necessary
+        # 1. Make new Multi if Necessary
         if isinstance(closest, Multi):
         # if the closest to this Single is a Multi, reuse the Multi.
-	    multi = closest
-	    neighbors = neighbors[1:]	# the rest of the neighbors are added
+            multi = closest
+            neighbors = neighbors[1:]   # the rest of the neighbors are added
         else: 
         # the closest is not a Multi. Can be NonInteractionSingle, surface or
-	# nothing. Create new Multi
+        # nothing. Create new Multi
             multi = self.create_multi()
 
 
-	# 2. Add the single and neighbors to the Multi
+        # 2. Add the single and neighbors to the Multi
         self.add_to_multi(single, multi)
         self.remove_domain(single)
         for neighbor in neighbors:
             self.add_to_multi_recursive(neighbor, multi)
 
 
-	# 3. Initialize and (re-)schedule
+        # 3. Initialize and (re-)schedule
         multi.initialize(self.t)
         if isinstance(closest, Multi):
             self.update_domain_event(self.t + multi.dt, multi)
-	else:
+        else:
             self.add_domain_event(multi)
 
         return multi
@@ -2050,7 +2050,7 @@ def add_to_multi_recursive(self, domain, multi):
                 self.MULTI_SHELL_FACTOR
             neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(
                     objpos, radius, ignore=[domain.domain_id])
-	    neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+            neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
             burst = self.burst_non_multis(neighbors)
             neighbor_dists = self.obj_distance_array(objpos, burst)
@@ -2075,10 +2075,10 @@ def add_to_multi(self, single, multi):
         if __debug__:
             log.info('add to multi:\n  %s\n  %s' % (single, multi))
 
-	shell_id = self.shell_id_generator()
-	shell = multi.create_new_shell(single.pid_particle_pair[1].position,
+        shell_id = self.shell_id_generator()
+        shell = multi.create_new_shell(single.pid_particle_pair[1].position,
                 single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
-	shell_id_shell_pair = (shell_id, shell)
+        shell_id_shell_pair = (shell_id, shell)
         self.geometrycontainer.move_shell(shell_id_shell_pair)
         multi.add_shell(shell_id_shell_pair)
         multi.add_particle(single.pid_particle_pair)
@@ -2109,9 +2109,9 @@ def merge_multis(self, multi1, multi2):
         self.remove_event(multi1)
 
     def domain_distance(self, pos, domain):
-	# calculates the shortest distance from 'pos' to A shell (a Multi
-	# can have multiple) of 'domain'.
-	# Note: it returns the distance between pos and the CENTER of the shell
+        # calculates the shortest distance from 'pos' to A shell (a Multi
+        # can have multiple) of 'domain'.
+        # Note: it returns the distance between pos and the CENTER of the shell
         return min(self.world.distance(shell.shape, pos)
                    for i, (_, shell) in enumerate(domain.shell_list))
 
@@ -2174,18 +2174,18 @@ def check_obj(self, obj):
             # Ignore all surfaces, multi shells can overlap with 
             # surfaces.
             ignores = [s.id for s in self.world.structures]
-	elif isinstance(obj, InteractionSingle):
-	    # Ignore surface of the particle and interaction surface
-	    ignores = [obj.structure.id, obj.surface.id]
+        elif isinstance(obj, InteractionSingle):
+            # Ignore surface of the particle and interaction surface
+            ignores = [obj.structure.id, obj.surface.id]
         else:
             ignores = [obj.structure.id]
 
         for shell_id, shell in obj.shell_list:
             closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
-								       self.domains,
+                                                                       self.domains,
                                                                        ignore=[obj.domain_id],
                                                                        ignores=ignores)
-	#TODO
+        #TODO
             if(type(shell.shape) is Cylinder and
                closest and type(closest.shell.shape) is Sphere):
                 # Note: this case is special.
@@ -2232,16 +2232,16 @@ def check_obj(self, obj):
 
     def check_obj_for_all(self):
         for id, event in self.scheduler:
-	    domain = self.domains[event.data]
+            domain = self.domains[event.data]
             self.check_obj(domain)
 
     def check_event_stoichiometry(self):
     # checks if the number of particles in the world is equal to the number
     # of particles represented in the EGFRD simulator
-	world_population = self.world.num_particles
+        world_population = self.world.num_particles
         domain_population = 0
         for id, event in self.scheduler:
-	    domain = self.domains[event.data]
+            domain = self.domains[event.data]
             domain_population += domain.multiplicity
 
         if world_population != domain_population:
@@ -2249,11 +2249,11 @@ def check_event_stoichiometry(self):
                                (world_population, domain_population))
 
     def check_shell_matrix(self):
-	did_map, shell_map = self.geometrycontainer.get_dids_shells()
+        did_map, shell_map = self.geometrycontainer.get_dids_shells()
 
         shell_population = 0
         for id, event in self.scheduler:
-	    domain = self.domains[event.data]
+            domain = self.domains[event.data]
             shell_population += domain.num_shells
             shell_ids = did_map[domain.domain_id]
             if len(shell_ids) != domain.num_shells:
@@ -2273,15 +2273,15 @@ def check_shell_matrix(self):
                                (shell_population, matrix_population))
 
     def check_domains(self):
-	# make set of event_id that are stored in all the domains
+        # make set of event_id that are stored in all the domains
         event_ids = set(domain.event_id
                         for domain in self.domains.itervalues())
-	# check that all the event_id in the scheduler are also stored in a domain
+        # check that all the event_id in the scheduler are also stored in a domain
         for id, event in self.scheduler:
             if id not in event_ids:
                 raise RuntimeError('Event %s in EventScheduler has no domain in self.domains' %
                                    event)
-	    else:
+            else:
                 event_ids.remove(id)
 
         # self.domains always include a None  --> this can change in future
diff --git a/gfrdbase.py b/gfrdbase.py
index b0c3fa4d..8e9452f9 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -94,11 +94,11 @@ def get_closest_surface(world, pos, ignore=[]):
         if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
             pos_transposed = \
                 world.cyclic_transpose(pos, surface.shape.position)
-	    distance = world.distance(surface.shape, pos_transposed)
+            distance = world.distance(surface.shape, pos_transposed)
             distances_and_surfaces.append((distance, surface))
 
     if distances_and_surfaces:
-	distance, surface = min(distances_and_surfaces)
+        distance, surface = min(distances_and_surfaces)
         return surface, distance
     else:
         return None, numpy.inf
diff --git a/model.py b/model.py
index af185e64..21e984e2 100644
--- a/model.py
+++ b/model.py
@@ -281,10 +281,10 @@ def create_creation_reaction_rule(product, k):
     """Example: 0 -> A.
 
     Arguments:
-	- product
-	    a Species
-	- k
-	    reaction rate. Units: per second.
+        - product
+            a Species
+        - k
+            reaction rate. Units: per second.
 
     A creation reaction rule defines a Poissonian process.
 
diff --git a/multi.py b/multi.py
index 318249aa..fa161695 100644
--- a/multi.py
+++ b/multi.py
@@ -14,11 +14,11 @@
 
 class Multi(Domain):
     def __init__(self, domain_id, main, dt_factor):
-	Domain.__init__(self, domain_id)
+        Domain.__init__(self, domain_id)
 
         self.main = ref(main)
         self.last_event = None
-	self.event_Type = EventType.MULTI_DIFFUSION
+        self.event_Type = EventType.MULTI_DIFFUSION
 
         self.sphere_container = _gfrd.SphericalShellContainer(main.world.world_size, 3)
         self.particle_container = _gfrd.MultiParticleContainer(main.world)
diff --git a/pair.py b/pair.py
index 563e83c8..aa9918f4 100644
--- a/pair.py
+++ b/pair.py
@@ -41,19 +41,19 @@ class Pair(ProtectiveDomain):
 
     def __init__(self, domain_id, single1, single2, shell_id, r0, 
                  rrs):
-	ProtectiveDomain.__init__(self, domain_id)
+        ProtectiveDomain.__init__(self, domain_id)
 
         self.multiplicity = 2
 
         self.single1 = single1
         self.single2 = single2 
-	self.pid_particle_pair1 = single1.pid_particle_pair
-	self.pid_particle_pair2 = single2.pid_particle_pair
+        self.pid_particle_pair1 = single1.pid_particle_pair
+        self.pid_particle_pair2 = single2.pid_particle_pair
 
-	self.interparticle_rrs = rrs
-	self.interparticle_ktot = self.calc_ktot(rrs)
+        self.interparticle_rrs = rrs
+        self.interparticle_ktot = self.calc_ktot(rrs)
 
-	self.shell_id = shell_id
+        self.shell_id = shell_id
 
     def __del__(self):
         if __debug__:
@@ -71,8 +71,8 @@ def get_D_R(self):
     D_R = property(get_D_R)
 
     def initialize(self, t):
-	# re-initialize the time parameters of the Domain to reuse it.
-	# THIS IS PROBABLY USELESS
+        # re-initialize the time parameters of the Domain to reuse it.
+        # THIS IS PROBABLY USELESS
         self.last_time = t
         self.dt = 0
         self.event_type = None
@@ -83,7 +83,7 @@ def draw_com_escape_or_iv_event_time_tuple(self, r0):
         
         """
         dt_com = draw_time_wrapper(self.com_greens_function())
-        dt_iv = draw_time_wrapper(self.iv_greens_function(r0))	# uses the full solution to draw IV first event time
+        dt_iv = draw_time_wrapper(self.iv_greens_function(r0))  # uses the full solution to draw IV first event time
         if dt_com < dt_iv:
             return dt_com, EventType.COM_ESCAPE, None
         else:
@@ -126,24 +126,24 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         inter-particle vector.
 
         """
-	# If the two particles have reacted this returns the
-	# new position twice
-	# The positions are relative to the center of the shell
-	# TODO move this to SimplePair, this is not applicable to a MixedPair
-	# or make scaling factor in last line a parameter of the class
+        # If the two particles have reacted this returns the
+        # new position twice
+        # The positions are relative to the center of the shell
+        # TODO move this to SimplePair, this is not applicable to a MixedPair
+        # or make scaling factor in last line a parameter of the class
         new_com = self.shell.shape.position + self.draw_new_com(dt, event_type)
 
-	if event_type == EventType.IV_REACTION:
-	    newpos1 = new_com
-	    newpos2 = new_com
-	else:
+        if event_type == EventType.IV_REACTION:
+            newpos1 = new_com
+            newpos2 = new_com
+        else:
             new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
-	    newpos1, newpos2 = self.do_back_transform(new_com, new_iv)
+            newpos1, newpos2 = self.do_back_transform(new_com, new_iv)
 
         return newpos1, newpos2
 
     def draw_new_com(self, dt, event_type):
-	# draws a new coordinate for the CoM in world coordinates
+        # draws a new coordinate for the CoM in world coordinates
         if event_type == EventType.COM_ESCAPE:
             r = self.a_R
         else:
@@ -162,7 +162,7 @@ def draw_new_iv(self, dt, r0, old_iv, event_type):
         if event_type == EventType.IV_ESCAPE:
             r = self.a_r
         elif event_type == EventType.IV_REACTION:
-            r = self.sigma	# maybe this should be zero (product particle is at CoM)
+            r = self.sigma      # maybe this should be zero (product particle is at CoM)
         else:
             r = draw_r_wrapper(gf, dt, self.a_r, self.sigma)
 
@@ -187,8 +187,8 @@ class SimplePair(Pair):
     @staticmethod
     def get_min_shell_size(single1, single2, geometrycontainer):
         # 1. Determine min shell size for a putative SimplePair.
-	# TODO Note that the calculation is dimension independent. Also
-	# 'size' is not the right term here
+        # TODO Note that the calculation is dimension independent. Also
+        # 'size' is not the right term here
 
         assert single1.structure == single2.structure
 
@@ -205,30 +205,30 @@ def get_min_shell_size(single1, single2, geometrycontainer):
             'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
             (single1, single2, FORMAT_DOUBLE % (r0 - sigma))
 
-	# calculate the minimum shell size for the interparticle domain
+        # calculate the minimum shell size for the interparticle domain
         D1 = single1.pid_particle_pair[1].D
         D2 = single2.pid_particle_pair[1].D
         D12 = D1 + D2
-        dist_from_com1 = r0 * D1 / D12			# particle distance from CoM
+        dist_from_com1 = r0 * D1 / D12                  # particle distance from CoM
         dist_from_com2 = r0 * D2 / D12
-        iv_shell_size1 = dist_from_com1 + radius1	# the shell should surround the particles
+        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
         iv_shell_size2 = dist_from_com2 + radius2
 
-	# also fix the minimum shellsize for the CoM domain
-	com_shell_size = max(radius1, radius2)
+        # also fix the minimum shellsize for the CoM domain
+        com_shell_size = max(radius1, radius2)
 
-	# calculate total radii including the margin for the burst volume for the particles
-	shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
-			 iv_shell_size2 + com_shell_size + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
+        # calculate total radii including the margin for the burst volume for the particles
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
+                         iv_shell_size2 + com_shell_size + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
 
-	return shell_size
+        return shell_size
 
 
     @staticmethod
     def get_max_shell_size(shell_center, single1, single2, geometrycontainer, domains):
-	# returns the maximum shell size based on geometric constraints
-	# It makes sure that surrounding NonInteractionSingles have at least the
-	# 'bursting volume' of space.
+        # returns the maximum shell size based on geometric constraints
+        # It makes sure that surrounding NonInteractionSingles have at least the
+        # 'bursting volume' of space.
 
 #        pos1 = single1.pid_particle_pair[1].position
 #        pos2 = single2.pid_particle_pair[1].position
@@ -236,12 +236,12 @@ def get_max_shell_size(shell_center, single1, single2, geometrycontainer, domain
 #        D2 = single2.pid_particle_pair[1].D
 #        D12 = D1 + D2
 
-	# TODO it makes no sence to calculate the CoM in the world object
+        # TODO it makes no sence to calculate the CoM in the world object
 #        com  = geometrycontainer.world.calculate_pair_CoM(pos1, pos2, D1, D2)
 #        shell_center = geometrycontainer.world.apply_boundary(com)
 
-	# TODO get_closest_obj searches the spherical surrounding although this doesn't make sence for
-	# a 2D or 1D pair
+        # TODO get_closest_obj searches the spherical surrounding although this doesn't make sence for
+        # a 2D or 1D pair
         closest, closest_distance = geometrycontainer.get_closest_obj(shell_center, domains, ignore=[single1.domain_id,
                                                                       single2.domain_id],
                                                                       ignores=[single1.structure.id])
@@ -283,27 +283,27 @@ def get_max_shell_size(shell_center, single1, single2, geometrycontainer, domain
             shell_size = min(closest_distance, closest_particle_distance - closest_min_shell)
             assert shell_size <= closest_distance
 
-	# TODO this is not correct. If the closest domain is not a NonInteractionSingle
-	# we still have to make sure that the (non closest) NonInteractionSingles have
-	# the required space
+        # TODO this is not correct. If the closest domain is not a NonInteractionSingle
+        # we still have to make sure that the (non closest) NonInteractionSingles have
+        # the required space
         else:
             assert isinstance(closest, (InteractionSingle, Pair, Multi, Surface, None.__class__))
             shell_size = closest_distance 
 
 
-	return min(geometrycontainer.get_max_shell_size(),
-		   shell_size)
+        return min(geometrycontainer.get_max_shell_size(),
+                   shell_size)
 
 
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure):
-	Pair.__init__(self, domain_id, single1, single2, shell_id,
+        Pair.__init__(self, domain_id, single1, single2, shell_id,
                       r0, rrs)
 
-        self.structure = structure		# structure on which both particles live
+        self.structure = structure              # structure on which both particles live
 
         self.a_R, self.a_r = self.determine_radii(r0, shell_size)
-	# set the radii of the inner domains as a function of the outer protective domain
+        # set the radii of the inner domains as a function of the outer protective domain
 
         self.shell = self.create_new_shell(shell_center, shell_size, domain_id)
 
@@ -320,18 +320,18 @@ def get_com(self):
     @staticmethod
     def do_transform(single1, single2, world):
 
-	pos1 = single1.pid_particle_pair[1].position
-	pos2 = single2.pid_particle_pair[1].position
-	D1 = single1.pid_particle_pair[1].D
-	D2 = single2.pid_particle_pair[1].D
+        pos1 = single1.pid_particle_pair[1].position
+        pos2 = single2.pid_particle_pair[1].position
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
 
-	com = world.calculate_pair_CoM(pos1, pos2, D1, D2)
-	com = world.apply_boundary(com)
+        com = world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = world.apply_boundary(com)
 
         pos2t = world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
 
-	return com, iv
+        return com, iv
 
     def do_back_transform(self, com, iv):
         D1 = self.pid_particle_pair1[1].D
@@ -340,7 +340,7 @@ def do_back_transform(self, com, iv):
         pos1 = com - iv * (D1 / self.D_tot)
         pos2 = com + iv * (D2 / self.D_tot)
 
-	return pos1, pos2
+        return pos1, pos2
 
     def get_shell_size(self):
         return self.shell.shape.radius
@@ -357,15 +357,15 @@ def determine_radii(self, r0, shell_size):
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
 
-	LD_MAX = 20 # temporary value
-	a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
-	# a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
+        LD_MAX = 20 # temporary value
+        a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
+        # a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
 
         # Make sure that D1 != 0 to avoid division by zero in the followings.
         if D1 == 0:
-            D1, D2 = D2, D1	# shouldn't we also here swap the particle radii if we're swapping diffusion contants?
+            D1, D2 = D2, D1     # shouldn't we also here swap the particle radii if we're swapping diffusion contants?
 
-        shell_size /= SAFETY	#??
+        shell_size /= SAFETY    #??
 
         D_tot = D1 + D2
         D_geom = math.sqrt(D1 * D2)
@@ -396,30 +396,30 @@ def determine_radii(self, r0, shell_size):
         a_r = (D_geom * r0 + D_tot * (shell_size - radiusa)) / (Da + D_geom)
 
 
-	# Now if the planned domainsize for r is too large for proper convergence of the Green's
-	# functions, make it the maximum allowed size
-	if (a_r > a_r_max):
-	    a_r = a_r_max
-	    a_R = shell_size - radiusa - a_r * Da / D_tot
-	    if __debug__:
-		log.info('domainsize changed for convergence.')
+        # Now if the planned domainsize for r is too large for proper convergence of the Green's
+        # functions, make it the maximum allowed size
+        if (a_r > a_r_max):
+            a_r = a_r_max
+            a_R = shell_size - radiusa - a_r * Da / D_tot
+            if __debug__:
+                log.info('domainsize changed for convergence.')
 
         assert a_R + a_r * Da / D_tot + radiusa >= \
                a_R + a_r * Db / D_tot + radiusb
 
         assert abs(a_R + a_r * Da / D_tot + radiusa - shell_size) \
-            < 1e-12 * shell_size			# here the shell_size is the relevant scale
+            < 1e-12 * shell_size                        # here the shell_size is the relevant scale
 
 
         if __debug__:
           log.debug('a %g, r %g, R %g r0 %g' % 
                  (shell_size, a_r, a_R, r0))
         if __debug__:
-            tr = ((a_r - r0)**2) / (6 * self.D_r)	# the expected escape time of the iv
+            tr = ((a_r - r0)**2) / (6 * self.D_r)       # the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
-                tR = (a_R**2) / (6 * self.D_R)		# the expected escape time of the CoM
+                tR = (a_R**2) / (6 * self.D_R)          # the expected escape time of the CoM
             log.debug('tr %g, tR %g' % (tr, tR))
 
 
@@ -496,7 +496,7 @@ def create_com_vector(self, r):
         return random_vector(r)
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
-	# FIXME code doesn't handle r=0 
+        # FIXME code doesn't handle r=0 
 
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
@@ -505,13 +505,13 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 #        new_inter_particle_s = numpy.array([r, theta, phi])
 #        new_iv = spherical_to_cartesian(new_inter_particle_s)
 
-	# calculate the old_iv theta (theta is the angle with the zenith (z-axis) of the system)
+        # calculate the old_iv theta (theta is the angle with the zenith (z-axis) of the system)
 #        old_iv_theta = vector_angle_against_z_axis(old_iv)
-	# the old_iv phi is taken to be zero. This means that the theta is in the plane of
-	# the z-axis and the old_iv
+        # the old_iv phi is taken to be zero. This means that the theta is in the plane of
+        # the z-axis and the old_iv
 
             # We now rotate the new interparticle vector in the plane of
-	    # the old_iv and the z axis. This menas along the
+            # the old_iv and the z axis. This menas along the
             # rotation axis that is perpendicular to both the
             # z-axis and the original interparticle vector. The rotation
             # angle is the angle between the old_iv and z axis.
@@ -525,24 +525,24 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 #            new_iv = rotate_vector(new_iv, rotation_axis, old_iv_theta)
 
         if theta == 0.0:
-	    # no rotation is necessary -> new_iv = new_iv
-	    new_iv = old_iv
+            # no rotation is necessary -> new_iv = new_iv
+            new_iv = old_iv
         elif theta % numpy.pi != 0.0:
-	    # alternative calculation
-	    # rotate the old_iv to the new theta
+            # alternative calculation
+            # rotate the old_iv to the new theta
             rotation_axis = crossproduct_against_z_axis(old_iv)
             rotation_axis = normalize(rotation_axis)
             new_iv = rotate_vector(old_iv, rotation_axis, theta)
 
-	    # rotate the new_iv around the old_iv with angle phi and adjust length
-	    phi = myrandom.uniform() * 2 * Pi
-	    old_iv = normalize(old_iv)
-	    new_iv = rotate_vector(new_iv, old_iv, phi)
+            # rotate the new_iv around the old_iv with angle phi and adjust length
+            phi = myrandom.uniform() * 2 * Pi
+            old_iv = normalize(old_iv)
+            new_iv = rotate_vector(new_iv, old_iv, phi)
         else:
-	    # angle == numpi.pi -> just mirror the old_iv 
+            # angle == numpi.pi -> just mirror the old_iv 
             new_iv = -old_iv
 
-	new_iv = (r/r0) * new_iv
+        new_iv = (r/r0) * new_iv
 
         return new_iv
 
@@ -564,7 +564,7 @@ def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greens_function(self, r0):
-	# TODO still doesn't work with 2D Green's functions
+        # TODO still doesn't work with 2D Green's functions
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
@@ -582,8 +582,8 @@ def create_new_shell(self, position, radius, domain_id):
                                                     orientation, half_length))
 
     def choose_pair_greens_function(self, r0, t):
-	# selects between the full solution or an approximation where one of
-	# the boundaries is ignored
+        # selects between the full solution or an approximation where one of
+        # the boundaries is ignored
         distance_from_sigma = r0 - self.sigma
         distance_from_shell = self.a_r - r0
 
@@ -603,7 +603,7 @@ def choose_pair_greens_function(self, r0, t):
                 if __debug__:
                     log.debug('GF2D: only sigma')
                 return self.iv_greens_function(r0)
-        	# Todo
+                # Todo
                 # return GreensFunction2DRadInf(self.D_r, self.interparticle_ktot, r0, self.sigma)
         else:
             if distance_from_shell < threshold_distance:
@@ -611,7 +611,7 @@ def choose_pair_greens_function(self, r0, t):
                 if __debug__:
                     log.debug('GF2D: only a')
                 return self.iv_greens_function(r0)
-	        # Todo
+                # Todo
                 # return GreensFunction2DAbs(self.D_r, r0, self.a_r)
                 
             else:
@@ -619,7 +619,7 @@ def choose_pair_greens_function(self, r0, t):
                 if __debug__:
                     log.debug('GF2D: free')
                 return self.iv_greens_function(r0)
-        	# Todo
+                # Todo
                 # return GreensFunction2D(self.D_r, r0)
 
     def create_com_vector(self, r):
@@ -627,7 +627,7 @@ def create_com_vector(self, r):
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
-	# note that r0 = length (old_iv)
+        # note that r0 = length (old_iv)
 
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
@@ -636,17 +636,17 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 #        unit_x = self.structure.shape.unit_x
 #        unit_y = self.structure.shape.unit_y
 #        angle = vector_angle(unit_x, old_iv)
-	# FIXME THIS IS WRONG: angle returns the angle between the vectors regardsless of order
-	#       now we do not see the different if the old_iv is mirrored in the unit_x
+        # FIXME THIS IS WRONG: angle returns the angle between the vectors regardsless of order
+        #       now we do not see the different if the old_iv is mirrored in the unit_x
         # Todo. Test if nothing changes when theta == 0.
 #        new_angle = angle + theta
 #
 #        new_iv = r * math.cos(new_angle) * unit_x + \
 #                 r * math.sin(new_angle) * unit_y
 
-	new_iv = (r/r0) * rotate_vector(old_iv, self.structure.shape.unit_z, theta)
-	# note that unit_z can point two ways rotating the vector clockwise or counterclockwise
-	# Since theta is symmetric this doesn't matter.
+        new_iv = (r/r0) * rotate_vector(old_iv, self.structure.shape.unit_z, theta)
+        # note that unit_z can point two ways rotating the vector clockwise or counterclockwise
+        # Since theta is symmetric this doesn't matter.
 
         return new_iv
 
@@ -683,7 +683,7 @@ def com_greens_function(self):
         return GreensFunction1DAbsAbs(self.D_R, self.v_R, 0.0, -self.a_R, self.a_R)
 
     def iv_greens_function(self, r0):
-	# TODO Fix ugly hack to avoid k=0 below
+        # TODO Fix ugly hack to avoid k=0 below
         #return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
         return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
@@ -706,12 +706,12 @@ def create_com_vector(self, r):
         return r * self.structure.shape.unit_z
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
-	# note that r0 = length (old_iv)
+        # note that r0 = length (old_iv)
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
         # Note: using self.structure.shape.unit_z here might accidently 
         # interchange the particles.
-	# That's why we would use self.shell.shape.unit_z right?!
+        # That's why we would use self.shell.shape.unit_z right?!
         return (r/r0) * old_iv
 
     def get_shell_size(self):
@@ -727,225 +727,225 @@ class MixedPair(Pair):
     @staticmethod
     def get_min_shell_dimensions(single1, single2, reference_point, geometrycontainer):
 
-	assert isinstance (single1.structure, PlanarSurface)
-	assert isinstance (single2.structure, CuboidalRegion)
-
-	pos1 = single1.pid_particle_pair[1].position
-	pos2 = single2.pid_particle_pair[1].position
-	radius1 = single1.pid_particle_pair[1].radius
-	radius2 = single2.pid_particle_pair[1].radius
-	D1 = single1.pid_particle_pair[1].D
-	D2 = single2.pid_particle_pair[1].D
-	D12 = D1 + D2
-
-	# calculate the interparticle vector and project it onto the coordinate system of the structure
-	# of particle1
-	pos2_t = geometrycontainer.world.cyclic_transpose(pos2, pos1)
-	iv = pos2_t - pos1
-	iv_x = numpy.dot(iv, single1.structure.shape.unit_x)
-	iv_y = numpy.dot(iv, single1.structure.shape.unit_y)
-	iv_z = numpy.dot(iv, single1.structure.shape.unit_z)
-
-	# calculate the minimal dimensions of the iv shell (it fits perfectly around the particles)
-	iv_shell_z = abs(iv_z) + radius2
-
-	len_iv_projected = math.sqrt(iv_x*iv_x + iv_y*iv_y)
-	dist_r_from_com1 = len_iv_projected * D1 / D12
-	dist_r_from_com2 = len_iv_projected * D2 / D12
-	iv_shell_radius1 = dist_r_from_com1 + radius1
-	iv_shell_radius2 = dist_r_from_com2 + radius2
-
-	# fix the minimum shell size for the CoM domain
-	com_shell_radius = max(radius1, radius2)
-
-	# calculate the minimal dimensions of the protective domain including space for the
-	# burst volumes of the particles
-	dz_left = radius1
-	dz_right = iv_shell_z + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR)
-	dr = max(iv_shell_radius1 + com_shell_radius + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
-		 iv_shell_radius2 + com_shell_radius + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
-
-	return dr, dz_left, dz_right
+        assert isinstance (single1.structure, PlanarSurface)
+        assert isinstance (single2.structure, CuboidalRegion)
+
+        pos1 = single1.pid_particle_pair[1].position
+        pos2 = single2.pid_particle_pair[1].position
+        radius1 = single1.pid_particle_pair[1].radius
+        radius2 = single2.pid_particle_pair[1].radius
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
+        D12 = D1 + D2
+
+        # calculate the interparticle vector and project it onto the coordinate system of the structure
+        # of particle1
+        pos2_t = geometrycontainer.world.cyclic_transpose(pos2, pos1)
+        iv = pos2_t - pos1
+        iv_x = numpy.dot(iv, single1.structure.shape.unit_x)
+        iv_y = numpy.dot(iv, single1.structure.shape.unit_y)
+        iv_z = numpy.dot(iv, single1.structure.shape.unit_z)
+
+        # calculate the minimal dimensions of the iv shell (it fits perfectly around the particles)
+        iv_shell_z = abs(iv_z) + radius2
+
+        len_iv_projected = math.sqrt(iv_x*iv_x + iv_y*iv_y)
+        dist_r_from_com1 = len_iv_projected * D1 / D12
+        dist_r_from_com2 = len_iv_projected * D2 / D12
+        iv_shell_radius1 = dist_r_from_com1 + radius1
+        iv_shell_radius2 = dist_r_from_com2 + radius2
+
+        # fix the minimum shell size for the CoM domain
+        com_shell_radius = max(radius1, radius2)
+
+        # calculate the minimal dimensions of the protective domain including space for the
+        # burst volumes of the particles
+        dz_left = radius1
+        dz_right = iv_shell_z + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR)
+        dr = max(iv_shell_radius1 + com_shell_radius + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
+                 iv_shell_radius2 + com_shell_radius + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
+
+        return dr, dz_left, dz_right
 
     @staticmethod
     def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer, domains):
-	pass
+        pass
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
-		 shell_half_length, shell_orientation_vector, 
-		 unit_r, r0, rrs):
-	Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
+                 shell_half_length, shell_orientation_vector, 
+                 unit_r, r0, rrs):
+        Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
-	self.surface = surface	# the surface on which particle1 lives
-	self.r0 = r0	# TODO this needs to be rescaled too
+        self.surface = surface  # the surface on which particle1 lives
+        self.r0 = r0    # TODO this needs to be rescaled too
 
     def determine_radii(self, half_length, radius):
-	# determines the dimensions of the domains used for the Green's functions from the dimensions
-	# of the cylindrical shell.
-	# Note that the function assumes that the cylinder is dimensioned properly
-	radius1 = self.pid_particle_pair1[1].radius
-	radius2 = self.pid_particle_pair2[1].radius
-	D1 = self.pid_particle_pair1[1].D
-	D2 = self.pid_particle_pair2[1].D
-	D12 = D1 + D2
+        # determines the dimensions of the domains used for the Green's functions from the dimensions
+        # of the cylindrical shell.
+        # Note that the function assumes that the cylinder is dimensioned properly
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
+        D12 = D1 + D2
 
-	a_r = ((half_length * 2) - radius1 - (2 * radius2)) * self.z_scaling_factor
+        a_r = ((half_length * 2) - radius1 - (2 * radius2)) * self.z_scaling_factor
 
-	# calculate the maximal displacement of a particle given an a_r. Also include its radius
-	space_for_iv = max( (D1/D12) * a_r + radius1,
-			    (D2/D12) * a_r + radius2)
-	a_R = radius - space_for_iv
+        # calculate the maximal displacement of a particle given an a_r. Also include its radius
+        space_for_iv = max( (D1/D12) * a_r + radius1,
+                            (D2/D12) * a_r + radius2)
+        a_R = radius - space_for_iv
 
 
         if __debug__:
-            tr = ((a_r - self.r0)**2) / (6 * self.D_r)	# the expected escape time of the iv
+            tr = ((a_r - self.r0)**2) / (6 * self.D_r)  # the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
-                tR = (a_R**2) / (4 * self.D_R)		# the expected escape time of the CoM
+                tR = (a_R**2) / (4 * self.D_R)          # the expected escape time of the CoM
             log.debug('tr %g, tR %g' % (tr, tR))
 
-	assert (self.sigma < a_r) and (a_r < half_length*2)
-	assert (0 < a_R) and (a_R < radius)
+        assert (self.sigma < a_r) and (a_r < half_length*2)
+        assert (0 < a_R) and (a_R < radius)
 
-	return a_R, a_r
+        return a_R, a_r
 
     def get_com(self):
-	# Note that it is implied that the center of the shell is chosen such that its projection on the
-	# membrane is the CoM of the particles.
-	dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair1[1].radius
-	return self.shell.shape.position - dist_to_surface * self.shell.shape.unit_z
+        # Note that it is implied that the center of the shell is chosen such that its projection on the
+        # membrane is the CoM of the particles.
+        dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair1[1].radius
+        return self.shell.shape.position - dist_to_surface * self.shell.shape.unit_z
     com = property(get_com)
 
     def get_scaling_factor(self):
-	D_2 = self.pid_particle_pair2[1].D	# particle 2 is in 3D and is the only contributor to diffusion
-						# normal to the plane
-	return math.sqrt(self.D_r/D_2)
+        D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
+                                                # normal to the plane
+        return math.sqrt(self.D_r/D_2)
     z_scaling_factor = property(get_scaling_factor)
 
     @staticmethod
     def do_transform(single1, single2, world):
 
-	pos1 = single1.pid_particle_pair[1].position
-	pos2 = single2.pid_particle_pair[1].position
-	D_1 = single1.pid_particle_pair[1].D
-	D_2 = single2.pid_particle_pair[1].D
+        pos1 = single1.pid_particle_pair[1].position
+        pos2 = single2.pid_particle_pair[1].position
+        D_1 = single1.pid_particle_pair[1].D
+        D_2 = single2.pid_particle_pair[1].D
 
-	surface = single1.structure
-	# we assume that the particle of single1 lives on the membrane
-	assert isinstance(surface, PlanarSurface)
+        surface = single1.structure
+        # we assume that the particle of single1 lives on the membrane
+        assert isinstance(surface, PlanarSurface)
 
 
-	# the CoM is calculated in a similar way to a normal 3D pair
-	com = (D_2 * pos1 + D_1 * pos) / (D_1 + D_2)
-	# and then projected onto the plane
-	com = world.cyclic_transpose(com, surface.shape.position)
-	com, _ = surface.projected_point (com)
-	com = world.apply_boundary(com)
+        # the CoM is calculated in a similar way to a normal 3D pair
+        com = (D_2 * pos1 + D_1 * pos) / (D_1 + D_2)
+        # and then projected onto the plane
+        com = world.cyclic_transpose(com, surface.shape.position)
+        com, _ = surface.projected_point (com)
+        com = world.apply_boundary(com)
 
-	# calculate the interparticle vector
-	pos2t = world.cyclic_transpose(pos2, pos1)
+        # calculate the interparticle vector
+        pos2t = world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
 
-	# calculate the scaling factor due to anisotropic diffusion of iv
-	z_scaling_factor = math.sqrt((D_1 + D_2)/D_2)
+        # calculate the scaling factor due to anisotropic diffusion of iv
+        z_scaling_factor = math.sqrt((D_1 + D_2)/D_2)
 
-	# move and recale the iv in the axis normal to the plane
-	iv_z = surface.shape.unit_z * numpy.dot (iv, surface.shape.unit_z)
-	iv_z_length = length(iv_z)
+        # move and recale the iv in the axis normal to the plane
+        iv_z = surface.shape.unit_z * numpy.dot (iv, surface.shape.unit_z)
+        iv_z_length = length(iv_z)
 
-	new_iv_z_length = (iv_z_length - single2.pid_particle_pair[1].radius) * z_scaling_factor
-	new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
+        new_iv_z_length = (iv_z_length - single2.pid_particle_pair[1].radius) * z_scaling_factor
+        new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
 
-	iv = iv - iv_z + new_iv_z
+        iv = iv - iv_z + new_iv_z
 
-	return com, iv
+        return com, iv
 
     def do_back_transform(self, com, iv):
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
 
-	weight1 = D1 / self.D_tot
-	weight2 = D2 / self.D_tot
+        weight1 = D1 / self.D_tot
+        weight2 = D2 / self.D_tot
 
-	# get the coordinates of the iv relative to the system of the surface (or actually the shell)
-	iv_x = self.surface.shape.unit_x * numpy.dot(iv, self.surface.shape.unit_x)
-	iv_y = self.surface.shape.unit_y * numpy.dot(iv, self.surface.shape.unit_y)
-	iv_z = self.shell.shape.unit_z * numpy.dot(iv, self.shell.shape.unit_z)
+        # get the coordinates of the iv relative to the system of the surface (or actually the shell)
+        iv_x = self.surface.shape.unit_x * numpy.dot(iv, self.surface.shape.unit_x)
+        iv_y = self.surface.shape.unit_y * numpy.dot(iv, self.surface.shape.unit_y)
+        iv_z = self.shell.shape.unit_z * numpy.dot(iv, self.shell.shape.unit_z)
 
-	# reflect the coordinates in the unit_z direction back to the side of the membrane
-	# where the domain is. Note that it's implied that the origin of the coordinate system lies in the
-	# plane of the membrane
-	iv_z = abs(iv_z)
+        # reflect the coordinates in the unit_z direction back to the side of the membrane
+        # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
+        # plane of the membrane
+        iv_z = abs(iv_z)
 
-	pos1 = com - weight1 * (iv_x + iv_y)
-	pos2 = com + weight2 * (iv_x + iv_y) + \
+        pos1 = com - weight1 * (iv_x + iv_y)
+        pos2 = com + weight2 * (iv_x + iv_y) + \
                iv_z/self.z_scaling_factor + \
                self.shell.shape.unit_z * self.pid_particle_pair2[1].radius
 
-	return pos1, pos2
+        return pos1, pos2
 
     def get_sigma(self):
-	# rescale sigma to correct for the rescaling of the coordinate system
-	# This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
-	# different than the sums of the radii of the particleso
-	xi = self.z_scaling_factor
-	xi_inv = 1.0/xi
-	alpha = math.acos(xi_inv)
-	sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
-	rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
-	return rho
+        # rescale sigma to correct for the rescaling of the coordinate system
+        # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
+        # different than the sums of the radii of the particleso
+        xi = self.z_scaling_factor
+        xi_inv = 1.0/xi
+        alpha = math.acos(xi_inv)
+        sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
+        rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
+        return rho
     sigma = property (get_sigma)
 
     def com_greensfunction(self):
-	# diffusion of the CoM of a mixed pair is only two dimensional
-	return GreensFunction2DAbsSym(self.D_R, self.a_R)
+        # diffusion of the CoM of a mixed pair is only two dimensional
+        return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greensfunction(self):
-	# diffusion of the interparticle vector is three dimensional
-	return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, self.r0,
-				      self.sigma, self.a_r)
+        # diffusion of the interparticle vector is three dimensional
+        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, self.r0,
+                                      self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, orientation_vector, half_length):
-	# It is assumed that the parameter are correct -> the 'bottom' of the cylinder
-	# sticks through the membrane enough to accomodate the particle in the membrane
-	# assert that orientation_vector is on same line as surface.shape.unit_z
-	return CylindricalShell(self.domain_id, Cylinder(position, radius, orientation_vector,
-							 half_length))
+        # It is assumed that the parameter are correct -> the 'bottom' of the cylinder
+        # sticks through the membrane enough to accomodate the particle in the membrane
+        # assert that orientation_vector is on same line as surface.shape.unit_z
+        return CylindricalShell(self.domain_id, Cylinder(position, radius, orientation_vector,
+                                                         half_length))
 
     def create_com_vector(self, r):
-	x, y = random_vector2D(r)
-	return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
+        x, y = random_vector2D(r)
+        return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
-	# Note: old_iv is actually the r0_vector
-	# FIXME This is actually the same method as for SphericalPair
+        # Note: old_iv is actually the r0_vector
+        # FIXME This is actually the same method as for SphericalPair
 
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
 
-        theta = draw_theta_wrapper(gf, r, dt)	# draw_theta return a value between -Pi and Pi
+        theta = draw_theta_wrapper(gf, r, dt)   # draw_theta return a value between -Pi and Pi
 
         if theta == 0.0:
             new_iv = old_iv
         elif theta % numpy.pi != 0.0:
-	    # rotate the old_iv to the new theta
+            # rotate the old_iv to the new theta
             rotation_axis = crossproduct_against_z_axis(old_iv)
             rotation_axis = normalize(rotation_axis)
             new_iv = rotate_vector(old_iv, rotation_axis, theta)
 
-	    # rotate the new_iv around the old_iv with angle phi
-	    phi = myrandom.uniform() * 2 * Pi
-	    old_iv = normalize(old_iv)
-	    new_iv = rotate_vector(new_iv, old_iv, phi)
+            # rotate the new_iv around the old_iv with angle phi
+            phi = myrandom.uniform() * 2 * Pi
+            old_iv = normalize(old_iv)
+            new_iv = rotate_vector(new_iv, old_iv, phi)
         else:
-	    # theta == Pi -> just mirror the old_iv
+            # theta == Pi -> just mirror the old_iv
             new_iv = -old_iv
 
-	#adjust length of the vector to new r
+        #adjust length of the vector to new r
         new_iv = (r/r0) * new_iv
 
-	return new_iv
+        return new_iv
 
     def __str__(self):
         return 'Mixed' + Pair.__str__(self)
diff --git a/shellcontainer.py b/shellcontainer.py
index 9932c36a..b4acb1ef 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -17,7 +17,7 @@ class ShellContainer(object):
 
     def __init__(self, world):
 
-	# the containers hold the spherical and cylindrical shells respectively 
+        # the containers hold the spherical and cylindrical shells respectively 
         # the containers is a cache for the shell objects in the domain and is mostly
         # read only. The only method that writes the containers is self.move_shell
         self.containers = [SphericalShellContainer(world.world_size,
@@ -25,11 +25,11 @@ def __init__(self, world):
                            CylindricalShellContainer(world.world_size,
                                                      world.matrix_size)]
 
-	self.world = world
-        self.user_max_shell_size = numpy.inf	# Note: shell_size is actually the RADIUS of the shell
+        self.world = world
+        self.user_max_shell_size = numpy.inf    # Note: shell_size is actually the RADIUS of the shell
 
     def get_matrix_cell_size(self):
-	return self.containers[0].cell_size     # cell_size is the width of the (cubic) cell
+        return self.containers[0].cell_size     # cell_size is the width of the (cubic) cell
 
     # Here shell_size is actually the shell radius (and not shell diameter)
     def set_user_max_shell_size(self, size):
@@ -57,14 +57,14 @@ def move_shell(self, shell_id_shell_pair):
         container.update(shell_id_shell_pair)
 
     def remove_shell(self, shell_id_shell_pair):
-	shell_id = shell_id_shell_pair[0]
-	shell = shell_id_shell_pair[1]
-	container = self.get_container(shell)
-	del container[shell_id]
+        shell_id = shell_id_shell_pair[0]
+        shell = shell_id_shell_pair[1]
+        container = self.get_container(shell)
+        del container[shell_id]
 
     def distance(self, pos1, pos2):
-	# Export the distance calculation
-	return self.world.distance(pos1, pos2)
+        # Export the distance calculation
+        return self.world.distance(pos1, pos2)
 
     def get_intruders(self, position, radius, ignore):
         # gets the intruders in a spherical volume of radius 'radius'?
@@ -105,8 +105,8 @@ def get_intruders(self, position, radius, ignore):
 
     def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
         # ignore: domain ids.
-	# TODO It's bad to pass the domains to this function, but is currently
-	# only way to be able to return a domain object (instead of domain_id)
+        # TODO It's bad to pass the domains to this function, but is currently
+        # only way to be able to return a domain object (instead of domain_id)
         closest_domain = None
         closest_distance = numpy.inf
 
@@ -117,7 +117,7 @@ def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
                 domain_id = shell_id_shell_pair[1].did
 
                 if domain_id not in ignore and distance < closest_distance:
-		    domain = domains[domain_id]
+                    domain = domains[domain_id]
                     closest_domain, closest_distance = domain, distance
                     # Found yet a closer domain. Break out of inner for 
                     # loop and check other containers.
@@ -132,7 +132,7 @@ def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
 
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # Get neighbor domains within given radius.
-	# Note that the function returns a generator
+        # Note that the function returns a generator
         #
         # ignore: domain ids.
         #
@@ -165,8 +165,8 @@ def get_dids_shells(self):
                 did_map.setdefault(shell.did, []).append(shell_id)
                 shell_map[shell_id] = shell
 
-	return did_map, shell_map
+        return did_map, shell_map
 
     def get_total_num_shells(self):
-	return sum(len(container) for container in self.containers)
+        return sum(len(container) for container in self.containers)
 
diff --git a/single.py b/single.py
index b92c721f..2ff82433 100644
--- a/single.py
+++ b/single.py
@@ -31,58 +31,58 @@ class Single(ProtectiveDomain):
 
     """
     def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
-	ProtectiveDomain.__init__(self, domain_id)
+        ProtectiveDomain.__init__(self, domain_id)
 
-        self.multiplicity = 1				# all singles have only one particle
+        self.multiplicity = 1                           # all singles have only one particle
 
-        self.pid_particle_pair = pid_particle_pair	# the particle in the single
-        self.structure = structure			# the structure in/on which the particle lives
+        self.pid_particle_pair = pid_particle_pair      # the particle in the single
+        self.structure = structure                      # the structure in/on which the particle lives
 
-        self.reactionrules = reactionrules		# the reaction rules for mono molecular reactions
-	self.rrule = None				# the reaction rule of the actual reaction (property reactionrule)
+        self.reactionrules = reactionrules              # the reaction rules for mono molecular reactions
+        self.rrule = None                               # the reaction rule of the actual reaction (property reactionrule)
         self.k_tot = self.calc_ktot(reactionrules)
-        #self.updatek_tot()				# RENAME to calc_ktot and MOVE to ProtectiveDomain
+        #self.updatek_tot()                             # RENAME to calc_ktot and MOVE to ProtectiveDomain
 
     def getD(self):
         return self.pid_particle_pair[1].D
     D = property(getD)
 
     def get_reaction_rule(self):
-	if self.rrule == None:
-	    self.rrule = self.draw_reaction_rule(self.reactionrules)
-	return self.rrule
+        if self.rrule == None:
+            self.rrule = self.draw_reaction_rule(self.reactionrules)
+        return self.rrule
     reactionrule = property(get_reaction_rule)
 
     def get_inner_a(self):
-	# inner_a is the outer radius of the 'inner shell', which demarkates
-	# the space where the CoM of the particle can go. The space can be
-	# one, two or three dimensional and can be linear, round, spherical or
-	# cylindric in form.
+        # inner_a is the outer radius of the 'inner shell', which demarkates
+        # the space where the CoM of the particle can go. The space can be
+        # one, two or three dimensional and can be linear, round, spherical or
+        # cylindric in form.
         return self.shell.shape.radius - self.pid_particle_pair[1].radius
 
     def draw_new_position(self, dt, event_type):
-	'''Draw a new position of the particle in the coordinate system given that an
-	event of event_type has occured. No periodic boundary conditions are applied yet
-	to the coordinates, as the Domains do not understand this.
-
-	Note also that it calculates the positional information PRIOR to any identity or
-	structure change.
-
-	When for example a particles dissociates from the membrane (a structure change),
-	it is placed next to the membrane. 'draw_new_position' will only determine the
-	location in the membrane where it dissociates, not the position where the particle
-	should be placed.
-	'''
-	pass
+        '''Draw a new position of the particle in the coordinate system given that an
+        event of event_type has occured. No periodic boundary conditions are applied yet
+        to the coordinates, as the Domains do not understand this.
+
+        Note also that it calculates the positional information PRIOR to any identity or
+        structure change.
+
+        When for example a particles dissociates from the membrane (a structure change),
+        it is placed next to the membrane. 'draw_new_position' will only determine the
+        location in the membrane where it dissociates, not the position where the particle
+        should be placed.
+        '''
+        pass
 
     def is_reset(self):
         return self.dt == 0.0 and self.event_type == EventType.SINGLE_ESCAPE
 
     def draw_reaction_time_tuple(self):
-	# MOVE to ProtectiveDomain class as this is actually a property of a single particle
-	# and not of a Single domain. It should be a method to a particle (or species)
-	# but that's too much hassle. Now make it a function (!) of Domain class for
-	# easy access. This mechanism is used everywhere a particle can decay.
+        # MOVE to ProtectiveDomain class as this is actually a property of a single particle
+        # and not of a Single domain. It should be a method to a particle (or species)
+        # but that's too much hassle. Now make it a function (!) of Domain class for
+        # easy access. This mechanism is used everywhere a particle can decay.
         """Return a (reaction time, event type)-tuple for a unimolecular reaction.
 
         """
@@ -102,7 +102,7 @@ def draw_escape_time_tuple(self):
         """Return an (escape time, event type)-tuple.
 
         In case of an interaction single, handles only the escape in the
-	non-interacting coordinate.
+        non-interacting coordinate.
         
         """
         if self.getD() == 0:
@@ -110,12 +110,12 @@ def draw_escape_time_tuple(self):
         else:
             dt = draw_time_wrapper(self.greens_function())
 
-        event_type = EventType.SINGLE_ESCAPE	# TODO Event is not an ESCAPE when in 1D there is drift
+        event_type = EventType.SINGLE_ESCAPE    # TODO Event is not an ESCAPE when in 1D there is drift
         return dt, event_type
 
 #    def updatek_tot(self):
-#	# MOVE to ProtectiveDomain class. See also reasoning above for
-#	# draw_reaction_time_tuple
+#       # MOVE to ProtectiveDomain class. See also reasoning above for
+#       # draw_reaction_time_tuple
 #        self.k_tot = 0
 #
 #        if not self.reactionrules:
@@ -125,7 +125,7 @@ def draw_escape_time_tuple(self):
 #            self.k_tot += rr.k
 #
 #    def draw_reaction_rule(self):
-#	# MOVE to ProtectiveDomain class
+#       # MOVE to ProtectiveDomain class
 #        k_array = [rr.k for rr in self.reactionrules]
 #        k_array = numpy.add.accumulate(k_array)
 #        k_max = k_array[-1]
@@ -157,8 +157,8 @@ class NonInteractionSingle(Single):
         * CylindricalSurfaceSingle: cylindrical shell, 1D movement.
 
     NonInteractionSingle hold two independent processes:
-	* Diffusion of the particle in n (1-3) dimensions
-	* Decay process of the particle
+        * Diffusion of the particle in n (1-3) dimensions
+        * Decay process of the particle
 
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
@@ -167,19 +167,19 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
                         structure)
 
         # Create shell.
-	self.shell_id = shell_id
+        self.shell_id = shell_id
         self.shell = self.create_new_shell(pid_particle_pair[1].position,
                                       pid_particle_pair[1].radius, domain_id)
 
     def get_shell_size(self):
-	# Note: this method only means something for Protective Domains that can
-	# only be sized in one direction
-	# This is predominantly used when making Interaction domains
+        # Note: this method only means something for Protective Domains that can
+        # only be sized in one direction
+        # This is predominantly used when making Interaction domains
         return self.shell.shape.radius
 
 
     def initialize(self, t):
-	# self.shell.shape.radius = self.pid_particle_pair[1].radius
+        # self.shell.shape.radius = self.pid_particle_pair[1].radius
         self.dt = 0.0
         self.last_time = t
         self.event_type = EventType.SINGLE_ESCAPE
@@ -193,31 +193,31 @@ def determine_next_event(self):
                    self.draw_reaction_time_tuple())
 
     def draw_new_position(self, dt, event_type):
-	oldpos = self.pid_particle_pair[1].position
+        oldpos = self.pid_particle_pair[1].position
 
-	if self.D == 0:
-	    newpos = oldpos
+        if self.D == 0:
+            newpos = oldpos
         elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
-	    newpos = oldpos
-	else:
-	    # calculate r
-	    if event_type == EventType.SINGLE_ESCAPE:
+            newpos = oldpos
+        else:
+            # calculate r
+            if event_type == EventType.SINGLE_ESCAPE:
             # Moving this checks to the Green's functions is not a good 
             # idea, because then you'd draw an unused random number.  
             # The same yields for the draw_new_com and draw_new_iv.  
 
-	    # TODO Either include check for non-zero drift here, or overload
-	    # this method in CylindricalSurfaceSingle to check exit interface
-        	r = self.get_inner_a()
+            # TODO Either include check for non-zero drift here, or overload
+            # this method in CylindricalSurfaceSingle to check exit interface
+                r = self.get_inner_a()
             else:
-        	gf = self.greens_function()
-        	r = draw_r_wrapper(gf, dt, self.get_inner_a())
-		# Note that in case of 1D diffusion r has a direction. It is
-		# the lateral displacement and can be positive or negative. 
-		# In other cases r is always positive and denotes
-		# radial displacement from the center.
-
-	    # calculate other coordinates
+                gf = self.greens_function()
+                r = draw_r_wrapper(gf, dt, self.get_inner_a())
+                # Note that in case of 1D diffusion r has a direction. It is
+                # the lateral displacement and can be positive or negative. 
+                # In other cases r is always positive and denotes
+                # radial displacement from the center.
+
+            # calculate other coordinates
             displacement = self.create_position_vector(r)
 
             # This should be checked in the unit test of random_vector.
@@ -232,7 +232,7 @@ def draw_new_position(self, dt, event_type):
             # asymmetric 1D domain (r0 != 0, or drift), since draw_r always 
             # returns a distance relative to the centre of the shell (r=0), 
             # not relative to r0.
-	    newpos = self.shell.shape.position + displacement
+            newpos = self.shell.shape.position + displacement
 
         return newpos
 
@@ -252,7 +252,7 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
         sqrtD1 = math.sqrt(D1)
 
 
-	singlepos = self.pid_particle_pair[1].position
+        singlepos = self.pid_particle_pair[1].position
         closestpos = closest.shell.shape.position
         distance = geometrycontainer.distance(singlepos, closestpos)
 
@@ -265,35 +265,35 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
         return shell_size
 
     def get_min_shell_size(self):
-	return self.pid_particle_pair[1].radius
+        return self.pid_particle_pair[1].radius
 
     def get_max_shell_size(self, geometrycontainer, domains):
-	# This calculates the maximum shell size that the single can have in the current
-	# situation.
-	# TODO This is now general for all NonInteractionSingles and should be different
-	# for the different dimensions since they have different domains (spheres vs cylinders)
-	# and scale the domains in different directions (r or z).
-
-	# 1. Calculate the maximal dimensions of the shell
-	# TODO We now just check in a sphere around the particle and size accordingly. For
-	# NonInteractionSingles on the dna and membrane this is quite inefficient-> want to
-	# size in the appropriate coordinate (r or z).
-	singlepos = self.pid_particle_pair[1].position
+        # This calculates the maximum shell size that the single can have in the current
+        # situation.
+        # TODO This is now general for all NonInteractionSingles and should be different
+        # for the different dimensions since they have different domains (spheres vs cylinders)
+        # and scale the domains in different directions (r or z).
+
+        # 1. Calculate the maximal dimensions of the shell
+        # TODO We now just check in a sphere around the particle and size accordingly. For
+        # NonInteractionSingles on the dna and membrane this is quite inefficient-> want to
+        # size in the appropriate coordinate (r or z).
+        singlepos = self.pid_particle_pair[1].position
         closest, distance_to_shell = \
             geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
                                               ignores=[self.structure.id])
 
-	# 2. In case the nearest neighbor was a NonInteractionSingle we need to tweak the size
-	# TODO shell size has no real meaning for cylinderical domains
+        # 2. In case the nearest neighbor was a NonInteractionSingle we need to tweak the size
+        # TODO shell size has no real meaning for cylinderical domains
         if isinstance(closest, NonInteractionSingle):
             new_shell_size = self.calculate_shell_size_to_single(closest, distance_to_shell,
-						                 geometrycontainer)
-	# TODO This is incorrect. The closest can be a Pair but still NonInteractionSingles may need
-	# more space
+                                                                 geometrycontainer)
+        # TODO This is incorrect. The closest can be a Pair but still NonInteractionSingles may need
+        # more space
         else:  # Pair or Multi or Surface
             new_shell_size = distance_to_shell / SAFETY
 
-	return min(new_shell_size, geometrycontainer.get_max_shell_size())
+        return min(new_shell_size, geometrycontainer.get_max_shell_size())
 
 
 class SphericalSingle(NonInteractionSingle):
@@ -390,14 +390,14 @@ def get_shell_size(self):
         return self.shell.shape.half_length
 
     def get_inner_a(self):
-	# Here the free coordinate is not the radius of the domain as in the
-	# PlanarSurfaceSingle and SphericalSingle, although it is treated as a
-	# radius in NonInteractionSingle.draw_new_position for simplicity
-	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+        # Here the free coordinate is not the radius of the domain as in the
+        # PlanarSurfaceSingle and SphericalSingle, although it is treated as a
+        # radius in NonInteractionSingle.draw_new_position for simplicity
+        return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def greens_function(self):
         # The domain is created around r0, so r0 corresponds to r=0 within the domain
-	inner_half_length = self.get_inner_a()
+        inner_half_length = self.get_inner_a()
         return GreensFunction1DAbsAbs(self.D, self.v, 0.0, -inner_half_length, inner_half_length)
 
     def create_new_shell(self, position, half_length, domain_id):
@@ -413,9 +413,9 @@ def create_new_shell(self, position, half_length, domain_id):
     def create_position_vector(self, z):
         if utils.feq(z, self.get_inner_a()):
             # Escape, can be either to the left or to the right.
-	    # The side of escape should be decided on by the flux through
-	    # both boundaries at the escape time
-	    # TODO, include drift
+            # The side of escape should be decided on by the flux through
+            # both boundaries at the escape time
+            # TODO, include drift
             z = myrandom.choice(-1, 1) * z 
         return z * self.shell.shape.unit_z
 
@@ -432,9 +432,9 @@ class InteractionSingle(Single):
         * CylindricalSurfaceInteraction.
 
     The InteractionSingle holds three independent processes:
-	* Diffusion in the direction that allows the interaction (radial or z)
-	* Diffusion in the direction that is normal the the direction of interaction
-	* Decay of the particle into a different or no particle
+        * Diffusion in the direction that allows the interaction (radial or z)
+        * Diffusion in the direction that is normal the the direction of interaction
+        * Decay of the particle into a different or no particle
     """
     def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell_id,   
                  interactionrules, surface):
@@ -442,36 +442,36 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell
         Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
                         structure)
 
-	self.shell_id = shell_id
-        self.interactionrules = interactionrules	# the surface interaction 'reactions'
-	self.intrule = None
-	self.interaction_ktot = self.calc_ktot(interactionrules)
-	self.surface = surface				# The surface with which the particle is
-							# trying to interact
+        self.shell_id = shell_id
+        self.interactionrules = interactionrules        # the surface interaction 'reactions'
+        self.intrule = None
+        self.interaction_ktot = self.calc_ktot(interactionrules)
+        self.surface = surface                          # The surface with which the particle is
+                                                        # trying to interact
 
     def get_interaction_rule(self):
-	if self.intrule == None:
-	    self.intrule = self.draw_reaction_rule(self.interactionrules)
-	return self.intrule
+        if self.intrule == None:
+            self.intrule = self.draw_reaction_rule(self.interactionrules)
+        return self.intrule
     interactionrule = property(get_interaction_rule)
 
-	# There are defined here but are overloaded later
-	# These ProtectiveDomains have a Cylindrical shell that is scaled in r and z
-	# Below methods go together with this property
+        # There are defined here but are overloaded later
+        # These ProtectiveDomains have a Cylindrical shell that is scaled in r and z
+        # Below methods go together with this property
     def get_inner_dz_left(self):
-	pass
+        pass
 
     def get_inner_dz_right(self):
-	pass
+        pass
 
-    def initialize(self, t):	
-	# initialize the domain object with the appropriate time to allow reuse of
-	# the Domain at different times
-	self.dt = 0
-	self.last_time = t
-	self.event_type = None
+    def initialize(self, t):    
+        # initialize the domain object with the appropriate time to allow reuse of
+        # the Domain at different times
+        self.dt = 0
+        self.last_time = t
+        self.event_type = None
 
-	# This is defined here, but only used in the subclasses
+        # This is defined here, but only used in the subclasses
     def create_new_shell(self, position, radius, orientation_vector, half_length):
         return CylindricalShell(self.domain_id, Cylinder(position, radius,
                                                     orientation_vector, half_length))
@@ -482,12 +482,12 @@ def determine_next_event(self):
         """
         return min(self.draw_escape_time_tuple(),
                    self.draw_reaction_time_tuple(),
-                   self.draw_iv_event_time_tuple())	# above two events also occur in NonInteractingSingle
-							# IV event is added in InteractionSingle
+                   self.draw_iv_event_time_tuple())     # above two events also occur in NonInteractingSingle
+                                                        # IV event is added in InteractionSingle
 
     def draw_iv_event_time_tuple(self):
         """Return an (interaction/escape time, event type)-tuple.
-	Note that an interaction is modelled similarly to an escape.
+        Note that an interaction is modelled similarly to an escape.
  
         Note: we are not calling single.draw_iv_event_type() just yet, but 
         postpone it to the very last minute (when this event is executed 
@@ -502,7 +502,7 @@ def draw_iv_event_time_tuple(self):
     def draw_iv_event_type(self):
         gf = self.iv_greens_function()
         event_kind = draw_event_type_wrapper(gf, self.dt)
-        if event_kind == PairEventKind.IV_REACTION:	# Note REACTION -> INTERACTION
+        if event_kind == PairEventKind.IV_REACTION:     # Note REACTION -> INTERACTION
             return EventType.IV_INTERACTION
         elif event_kind == PairEventKind.IV_ESCAPE:
             return EventType.IV_ESCAPE
@@ -521,32 +521,32 @@ class PlanarSurfaceInteraction(InteractionSingle):
     """
     def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
                  shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
-		 interactionrules, surface):
-	# shell_orientation_vector and z0 are supplied by arguments because Domains can't do
-	# spatial calculations (they don't know about the world)
-	# NOTE shell_orientation_vector should be normalized and pointing from the surface to the particle!
+                 interactionrules, surface):
+        # shell_orientation_vector and z0 are supplied by arguments because Domains can't do
+        # spatial calculations (they don't know about the world)
+        # NOTE shell_orientation_vector should be normalized and pointing from the surface to the particle!
 
-	InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
-				   structure, shell_id, interactionrules, surface)
+        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
+                                   structure, shell_id, interactionrules, surface)
 
-	# z0 is the initial position of the particle relative to the center
-	# of the shell in the direction normal to the surface.
-	self.z0 = z0
-	self.shell = self.create_new_shell(shell_center, shell_radius, 
-					   shell_orientation_vector, shell_half_length)
+        # z0 is the initial position of the particle relative to the center
+        # of the shell in the direction normal to the surface.
+        self.z0 = z0
+        self.shell = self.create_new_shell(shell_center, shell_radius, 
+                                           shell_orientation_vector, shell_half_length)
 
     def get_inner_dz_right(self):
-	# This is the distance the particle can travel from its initial position
-	# to the flat boundary away from the surface
-	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+        # This is the distance the particle can travel from its initial position
+        # to the flat boundary away from the surface
+        return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_dz_left(self):
-	# This is the distance the particle can traval towards the surface
-	# Note that it is implied that the shell sticks out at the other end
-	# of the planar surface by the particle radius, and that the surface
-	# has no thickness.
-	dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair[1].radius
-	return dist_to_surface - self.pid_particle_pair[1].radius
+        # This is the distance the particle can traval towards the surface
+        # Note that it is implied that the shell sticks out at the other end
+        # of the planar surface by the particle radius, and that the surface
+        # has no thickness.
+        dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair[1].radius
+        return dist_to_surface - self.pid_particle_pair[1].radius
 
     def greens_function(self):
         # This is the Greens function that does not produce REACTION event
@@ -554,69 +554,69 @@ def greens_function(self):
         return GreensFunction2DAbsSym(self.D, self.get_inner_a())
 
     def iv_greens_function(self):
-	# The green's function that also modelles the association of the particle
-	# with the planar surface.
-	# TODO choose interactionrule
+        # The green's function that also modelles the association of the particle
+        # with the planar surface.
+        # TODO choose interactionrule
         return GreensFunction1DRadAbs(self.D, self.interaction_ktot, self.z0,
-				      -self.get_inner_dz_left(), self.get_inner_dz_right())
+                                      -self.get_inner_dz_left(), self.get_inner_dz_right())
 #        return GreensFunction1DRadAbs(self.D, 0, self.z0,
-#				      -self.get_inner_dz_left(), self.get_inner_dz_right())
+#                                     -self.get_inner_dz_left(), self.get_inner_dz_right())
 
     def draw_new_position(self, dt, event_type):
-	"""Draws a new position for the particle for a given event type at a given time
-	Note that it also 'moves the particle into the surface' when an interaction
-	takes place.
-	"""
-	oldpos = self.pid_particle_pair[1].position
-	if self.D == 0:
-	    newpos = oldpos
-	elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
-	    newpos = oldpos		# just return oldpos, particle will be removed anyway
-	else:
-	    # calculate r vector
+        """Draws a new position for the particle for a given event type at a given time
+        Note that it also 'moves the particle into the surface' when an interaction
+        takes place.
+        """
+        oldpos = self.pid_particle_pair[1].position
+        if self.D == 0:
+            newpos = oldpos
+        elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+            newpos = oldpos             # just return oldpos, particle will be removed anyway
+        else:
+            # calculate r vector
             a = self.get_inner_a()
-	    if event_type == EventType.SINGLE_ESCAPE:
-		r = a
-	    else:
-		gf = self.greens_function()
-        	r = draw_r_wrapper(gf, dt, a)
+            if event_type == EventType.SINGLE_ESCAPE:
+                r = a
+            else:
+                gf = self.greens_function()
+                r = draw_r_wrapper(gf, dt, a)
 
-	    x, y = random_vector2D(r)
-	    vector_r = x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
+            x, y = random_vector2D(r)
+            vector_r = x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
 
-	    # calculate z vector
+            # calculate z vector
             # Todo. Cartesian coordinate will return absolute position.
             # Heads up. size_of_domain is different from the half_length of 
             # the cylinder, because the domain ends where the surface 
             # starts, while the cylinder is continuing into the surface.
-            z_surface = -self.get_inner_dz_left()	# left side of the inner domain
-	    z_not_surface = self.get_inner_dz_right()	# right side of the inner domain (away from the surface)
+            z_surface = -self.get_inner_dz_left()       # left side of the inner domain
+            z_not_surface = self.get_inner_dz_right()   # right side of the inner domain (away from the surface)
 
-	    # If the event was not yet fully specified
-	    if event_type == EventType.IV_EVENT:	
-		self.event_type = self.draw_iv_event_type()
-		event_type = self.event_type
+            # If the event was not yet fully specified
+            if event_type == EventType.IV_EVENT:        
+                self.event_type = self.draw_iv_event_type()
+                event_type = self.event_type
 
 
-	    if event_type == EventType.IV_INTERACTION:
-		z = z_surface 
-	    elif event_type == EventType.IV_ESCAPE:
-		z = z_not_surface
-	    else:
-	        gf_iv = self.iv_greens_function()
-        	z = draw_r_wrapper(gf_iv, dt, z_not_surface, z_surface)	# last two args= a, sigma
+            if event_type == EventType.IV_INTERACTION:
+                z = z_surface 
+            elif event_type == EventType.IV_ESCAPE:
+                z = z_not_surface
+            else:
+                gf_iv = self.iv_greens_function()
+                z = draw_r_wrapper(gf_iv, dt, z_not_surface, z_surface) # last two args= a, sigma
 
-	    vector_z = z * self.shell.shape.unit_z
+            vector_z = z * self.shell.shape.unit_z
 
-	    # The new position is relative to the center of the shell
-	    newpos = self.shell.shape.position + vector_r + vector_z
+            # The new position is relative to the center of the shell
+            newpos = self.shell.shape.position + vector_r + vector_z
 
         return newpos
 
 
     def get_shell_size(self):
-	# REMOVE this method, it doesn't mean anything here.
-	# THis method is only used for making an Interaction
+        # REMOVE this method, it doesn't mean anything here.
+        # THis method is only used for making an Interaction
         # Heads up. The cylinder's *half_length*, not radius, 
         # determines the size in case of a cylindrical surface.
         return self.shell.shape.radius
@@ -636,62 +636,62 @@ class CylindricalSurfaceInteraction(InteractionSingle):
 
     """
     def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
-		 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
-		 unit_r, r0, interactionrules, surface):
+                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
+                 unit_r, r0, interactionrules, surface):
 
         InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
-				   structure, shell_id, interactionrules, surface)
+                                   structure, shell_id, interactionrules, surface)
 
-	# z0 is implied to be zero (the particle being in the center of the shell in the z direction)
-	self.z0 = z0
-	self.unit_r = unit_r	# This is the vector from the cylinder to the particle
-	self.r0 = r0		# r0 is the distance from the center of the cylinder to the
-				# center of the particle
+        # z0 is implied to be zero (the particle being in the center of the shell in the z direction)
+        self.z0 = z0
+        self.unit_r = unit_r    # This is the vector from the cylinder to the particle
+        self.r0 = r0            # r0 is the distance from the center of the cylinder to the
+                                # center of the particle
         self.shell = self.create_new_shell(shell_center, shell_radius,
                                            shell_orientation_vector, shell_half_length)
 
 
     def get_inner_dz_left(self):
-	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+        return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_dz_right(self):
-	return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+        return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_sigma(self):
-	return self.surface.shape.radius + self.pid_particle_pair[1].radius
+        return self.surface.shape.radius + self.pid_particle_pair[1].radius
 
     def greens_function(self):
-	# The greens function not used for the interaction but for the other coordinate
+        # The greens function not used for the interaction but for the other coordinate
         # Free diffusion in z direction, drift is zero.
         return GreensFunction1DAbsAbs(self.D, 0.0, self.z0,
                                       -self.get_inner_dz_left(),
                                       self.get_inner_dz_right())
 
     def iv_greens_function(self):
-	# Green's function used for the interaction
+        # Green's function used for the interaction
         # Interaction possible in r direction.
         # TODO 2D.
         return GreensFunction3DRadAbs(self.D, self.interaction_ktot, self.r0, self.get_inner_sigma(),
-				      self.get_inner_a())
+                                      self.get_inner_a())
 
     def draw_new_position(self, dt, event_type):
-	oldpos = self.pid_particle_pair[1].position
+        oldpos = self.pid_particle_pair[1].position
 
-	if self.D == 0:
-	    newpos = oldpos
-	elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
-	    newpos = oldpos
-	else:
+        if self.D == 0:
+            newpos = oldpos
+        elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+            newpos = oldpos
+        else:
             # 1) Draw z.
             if event_type == EventType.SINGLE_ESCAPE:
                 # Moving this checks to the Green's functions is not a good 
-        	# idea, because then you'd draw an unused random number.  
-        	# The same yields for the draw_new_com and draw_new_iv.  
-		# Assume for now that z0 = 0 -> both boundaries are equally likely
-		z = myrandom.choice(-1, 1) * self.get_inner_dz_left()
+                # idea, because then you'd draw an unused random number.  
+                # The same yields for the draw_new_com and draw_new_iv.  
+                # Assume for now that z0 = 0 -> both boundaries are equally likely
+                z = myrandom.choice(-1, 1) * self.get_inner_dz_left()
             else:
-        	gf = self.greens_function()
-        	z = draw_r_wrapper(gf, dt, self.get_inner_dz_left())
+                gf = self.greens_function()
+                z = draw_r_wrapper(gf, dt, self.get_inner_dz_left())
 
             # Direction matters, so use shell.shape.unit_z instead of 
             # structure.shape.unit_z.
@@ -699,21 +699,21 @@ def draw_new_position(self, dt, event_type):
 
 
             # 2) Draw r and theta.
-	    # If the event was not yet fully specified
-	    if event_type == EventType.IV_EVENT:	
-		self.event_type = self.draw_iv_event_type()
-		event_type = self.event_type
+            # If the event was not yet fully specified
+            if event_type == EventType.IV_EVENT:        
+                self.event_type = self.draw_iv_event_type()
+                event_type = self.event_type
 
             sigma = self.get_inner_sigma()
             a_r = self.get_inner_a()
             gf_iv = self.iv_greens_function()
 
             if event_type == EventType.IV_ESCAPE:
-        	r = a_r
+                r = a_r
             elif event_type == EventType.IV_INTERACTION:
-        	r = sigma
+                r = sigma
             else:
-        	r = draw_r_wrapper(gf_iv, dt, a_r, sigma)
+                r = draw_r_wrapper(gf_iv, dt, a_r, sigma)
             theta = draw_theta_wrapper(gf_iv, r, dt)
 
             r_vector = r * rotate_vector(self.unit_r, self.shell.shape.unit_z,
@@ -722,11 +722,11 @@ def draw_new_position(self, dt, event_type):
             # Add displacement to shell.shape.position, not to particle.position.  
             newpos = self.shell.shape.position + z_vector + r_vector
 
-	return newpos
+        return newpos
 
     def get_shell_size(self):
-	# REMOVE this method, it doesn't mean anything here.
-	# THis method is only used for making an Interaction
+        # REMOVE this method, it doesn't mean anything here.
+        # THis method is only used for making an Interaction
         # Heads up. The cylinder's *half_length*, not radius, 
         # determines the size in case of a cylindrical surface.
         return self.shell.shape.half_length

From e1ce8df2f715d0c7afa5960d2733a7e9a6ded8d5 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 21 Oct 2011 15:48:30 +0200
Subject: [PATCH 0302/1541] Getting up-to-date for mayor merger.

---
 newBDPropagator.hpp | 184 ++++++++++++++++++++++++++------------------
 1 file changed, 108 insertions(+), 76 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 819f8f9f..91d603c7 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -89,8 +89,10 @@ class newBDPropagator
 
         LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
 
-        /* START SOME SAMPLES, after which we return. */
+        /* START SOME SAMPLES, after which we return. 
         position_pair_type pp01;
+        position_pair_type new_pp01;
+        
         species_type const sp(tx_.get_species(pp.second.sid()));
         boost::shared_ptr<structure_type> const pp_struct( tx_.get_structure( sp.structure_id() ) );
         
@@ -102,28 +104,41 @@ class newBDPropagator
         typename reaction_rule_type::species_id_range products(r.get_products());
         
         species_type s0(tx_.get_species(products[0])), s1(tx_.get_species(products[1]));
-        
-        std::cerr<< s0.structure_id() << " " << s1.structure_id() << std::endl;
-        
+              
+        length_type r01( s0.radius() + s1.radius() );
+              
         if(s0.structure_id() == "world")    
             std::swap(s0,s1);
-            
-        std::cerr<< s0.structure_id() << " " << s1.structure_id() << std::endl;
-        
+
         for(int i = 0; i < 2000; i++)
         {
             pp01 = pp_struct->
                 special_geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ ); 
+            
+            pp01.first = tx_.apply_boundary( pp01.first );
+            pp01.second = tx_.apply_boundary( pp01.second );
+            
+            if( tx_.distance(pp01.first, pp01.second) - r01 < 0 )
+                std::cerr << "Diss pp dist < 0 error" << std::endl;
                 
-            std::cout << pp01.first[0] << " " << pp01.first[1] << " " << pp01.first[2] << " " 
-                      << pp01.second[0] << " " << pp01.second[1] << " " << pp01.second[2] << std::endl;
+            if( tx_.distance( pp_struct->projected_point( pp01.second ).first, pp01.second) - s1.radius() < 0 )
+                std::cerr << "Diss sp dist < 0 error" << std::endl;
+                                
+            new_pp01 = make_pair_move(s0, s1, pp01, pp.first);           
+             
+            std::cout << new_pp01.first[0] << " " << new_pp01.first[1] << " " << new_pp01.first[2] << " " 
+                      << new_pp01.second[0] << " " << new_pp01.second[1] << " " << new_pp01.second[2] << std::endl;
                       
-            //std::cerr << "pp dist: " << tx_.distance(pp01.first, pp01.second) << std::endl;
-            //std::cerr << "ps dist: " << tx_.distance(pp_struct->projected_point( pp01.second ).first, pp01.second) << std::endl;
+            if(tx_.distance(new_pp01.first, new_pp01.second) - r01 < 0)
+                std::cerr << "Move pp dist < 0 error" << std::endl;
+                
+            if(tx_.distance(pp_struct->projected_point( new_pp01.second ).first, new_pp01.second) - s1.radius() < 0)
+                std::cerr << "Move sp dist < 0 error" << std::endl;
         }     
-                    
+                  
         return false;  
-
+        */
+        
         /* Consider decay reactions first. Particles can move after decay, but this is done
            inside the 'attempt_reaction' function; for this particle can only react once . */
         try
@@ -176,7 +191,7 @@ class newBDPropagator
         while(!bounced && j < particles_in_overlap)
             bounced = overlapped->at(j++).second < r0;
         
-        /* If the particle has not bounced with a particle and lives in the bulk: 
+        /* If the particle has not bounced with another particle and lives in the bulk: 
            check for core overlap with a surface. */
         if(!bounced && pp_structure->id() == "world")
         {
@@ -288,65 +303,6 @@ class newBDPropagator
 
 private:
 
-    /* Given a position pair and two species, the function generates two new 
-       positions based on two moves drawn from the free propegator. */
-    position_pair_type const make_pair_move(species_type const& s0, species_type const& s1, position_pair_type const& pp01, 
-                                                particle_id_type const& ignore)
-    {
-        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
-        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
-
-        length_type const r01( s0.radius() + s1.radius() );
-        
-        position_type temp_pos0, temp_pos1;
-        position_pair_type new_pp01( pp01 );
-        
-        //First step: random between s0 and s1.
-        if( rng_.uniform_int(0, 1) )
-        {
-            temp_pos0 = make_move(s0, pp01.first, ignore);
-            new_pp01.first = tx_.distance(temp_pos0, pp01.second) - r01 < 0 ? pp01.first : temp_pos0;
-        }                       
-        else
-        {
-            temp_pos1 = make_move(s1, pp01.second, ignore);
-            new_pp01.second = tx_.distance(temp_pos1, pp01.first) - r01 < 0 ? pp01.second : temp_pos1;
-        }
-        
-        /* Make a second step only with a certain probability in order for detailed balance to hold.
-           For Pacc << 1, two moves in 50% of the cases. */
-
-        //TODO check what is correct.
-            
-        return new_pp01;
-    }
-
-    position_type const make_move(species_type const& s0, position_type const& np, particle_id_type const& ignore)
-    {
-        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
-
-        position_type displacement( s0_struct->
-                                        bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
-
-        position_type new_pos(tx_.apply_boundary( add( np, displacement ) ));
-                        
-        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( 
-                                    tx_.check_overlap(
-                                    particle_shape_type(new_pos, s0.radius()),
-                                    ignore));
-                                                                
-        if ( (overlapped && overlapped->size() > 0) )
-            return np;
-        
-        structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
-        length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
-                                    
-        if( core_surface_distance < 0 )
-            return np;
-            
-        return new_pos;
-    }
-
     bool attempt_reaction(particle_id_pair const& pp)
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
@@ -377,11 +333,14 @@ class newBDPropagator
                     {
                         const species_type s0(tx_.get_species(products[0]));
                         boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species(pp.second.sid()).structure_id() ) );
-                        
                         position_type new_pos = pp.second.position();
-                        /* If the product particle does NOT live of the same structure => surface -> bulk dissociation. */
+                        
+                        /* If the product particle does NOT live of the same structure as pp => surface -> bulk dissociation. */
                         if( s0.structure_id() != pp_struct->id() )
                         {
+                            if( s0.structure_id() != "world" )
+                                throw not_implemented("No surface -> surface dissociation allowed");
+                        
                             position_type const displacement( pp_struct->surface_dissociation_vector(rng_, s0.radius(), reaction_length_ ) );
 
                             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
@@ -451,7 +410,10 @@ class newBDPropagator
                                
                                We set: species 0 lives on the surface; species 1 lives in the bulk. */
                             if( s0.structure_id() != s1.structure_id() )
-                            {                      
+                            {
+                                if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
+                                    throw not_implemented("No surface -> surface + surface - dissociation allowed");
+                                                 
                                 if(s0.structure_id() == "world")    
                                      std::swap(s0,s1);
 
@@ -549,6 +511,9 @@ class newBDPropagator
            and we let this be s1, the particle from the surface is named s0. */     
         if(s0.structure_id() != s1.structure_id())
         {
+            if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
+                throw not_implemented("No surface -> surface + surface - reactions allowed");
+                
             if(s0.structure_id() == "world")
                 std::swap(s0,s1);
         }
@@ -579,6 +544,7 @@ class newBDPropagator
             if (prob > rnd)
             {
                 LOG_DEBUG(("fire reaction"));
+                std::cerr << "Initiating unequall structure reaction! " << std::endl;
                 const typename reaction_rule_type::species_id_range products(
                     r.get_products());
 
@@ -756,6 +722,72 @@ class newBDPropagator
         return false;
     }
     
+    /* Given a position pair and two species, the function generates two new 
+       positions based on two moves drawn from the free propegator. */
+    position_pair_type const make_pair_move(species_type const& s0, species_type const& s1, position_pair_type const& pp01, 
+                                                particle_id_type const& ignore)
+    {
+        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
+
+        length_type const r01( s0.radius() + s1.radius() );
+        
+        position_type temp_pos0, temp_pos1;
+        position_pair_type new_pp01( pp01 );
+        
+        //Randomize which species moves first, and if there will be one or two moves. (50%)
+        bool move_prt0_first( rng_.uniform_int(0, 1) );
+        int move_count( 1 + rng_.uniform_int(0, 1) );
+        while( move_count-- )
+        {
+            if( move_prt0_first )
+            {
+                temp_pos0 = make_move(s0, pp01.first, ignore);
+                new_pp01.first = tx_.distance(temp_pos0, new_pp01.second) - r01 < 0 ? pp01.first : temp_pos0;
+            }                       
+            else
+            {
+                temp_pos1 = make_move(s1, pp01.second, ignore);
+                new_pp01.second = tx_.distance(temp_pos1, new_pp01.first) - r01 < 0 ? pp01.second : temp_pos1;
+            }
+            move_prt0_first = !move_prt0_first;
+        }  
+            
+        return new_pp01;
+    }
+
+    position_type const make_move(species_type const& s0, position_type const& np, particle_id_type const& ignore)
+    {
+        if(s0.D() == 0)
+            return np;
+    
+        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+
+        position_type displacement( s0_struct->
+                                        bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
+
+        position_type new_pos(tx_.apply_boundary( add( np, displacement ) ));
+                        
+        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( 
+                                    tx_.check_overlap(
+                                    particle_shape_type(new_pos, s0.radius()),
+                                    ignore));
+                                                                
+        if ( (overlapped && overlapped->size() > 0) )
+            return np;
+        
+        if(s0.structure_id() == "world")
+        {
+            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
+            length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
+                                    
+            if( core_surface_distance < 0 )
+                return np;        
+        }
+            
+        return new_pos;
+    }
+    
     void remove_particle(particle_id_type const& pid)
     {
         LOG_DEBUG(("remove particle %s", boost::lexical_cast<std::string>(pid).c_str()));

From b026267d114420d59219cc4ebac1c6acd629fcb7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 25 Oct 2011 17:21:43 +0200
Subject: [PATCH 0303/1541] implemented most of the methods required for
 MixedPair.determine_max_shell_size This includes methods to calculate the
 ratios between the length and radius of the cylinder.

---
 pair.py | 101 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 100 insertions(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index aa9918f4..35ba362e 100644
--- a/pair.py
+++ b/pair.py
@@ -769,7 +769,106 @@ def get_min_shell_dimensions(single1, single2, reference_point, geometrycontaine
 
     @staticmethod
     def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer, domains):
-        pass
+        # Properties of the MixedPair system
+        phi = MixedPair.calc_shell_scalingangle(D1, D2)
+        tan_phi = math.tan(phi)
+        cos_phi = math.cos(phi)
+        shell_scalecenter_z = MixedPair.z_right(single1, single2, r0, 0.0)
+
+
+        theta = 
+        psi = theta - phi
+        sin_psi = math.sin(psi)
+        cos_psi = math.cos(psi)
+
+        if psi <= 0:
+            a_crit = shell_scalecenter_z - shell_scalecenter_xy * tan_phi
+        else
+            a_crit = shell_scalecenter_xy - shell_scalecenter_z/tan_phi
+
+        if a_shell <= a_crit and psi <= 0:
+            dr = shell_scalecenter_xy - a_shell
+            dz_right = MixedPair.z_right(dr)
+
+        elif a_shell <= a_crit and psi > 0:
+            dz_right = shell_scalecenter_z + h0 - a_shell
+            dr = MixedPair.r(dz_right)
+
+        else:
+            assert a_shell > a_crit
+            a_sq = a_shell*a_shell
+            ss_sq = shell_scalecenter*shell_scalecenter
+            dr = cos_phi * (shell_scalecenter * cos_phi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
+            dz_right = MixedPair.z_right(dr)
+
+
+        dz_left = single1.pid_particle_pair[1].radius
+        return dr, dz_left, dz_right
+
+    @staticmetod
+    def z_right(single1, single2, r0, r):
+        # if the radius is known and we want to determine the height z_right
+        radius1 = single1.pid_particle_pair[1].radius
+        radius2 = single2.pid_particle_pair[1].radius
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
+        D_r = D1 + D2
+        D_R = (D1*D2)/(D1 + D2)
+
+        # calculate a_r such that the expected first-passage for the CoM and IV are equal
+        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
+        a_r1 = (r - radius1 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D1/D_r) )
+        a_r2 = (r - radius2 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D2/D_r) )
+        # take the smallest that, if entered in the function for r below, would lead to this z_right
+        a_r = min (a_r1, a_r2)
+
+        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+        z_right = (a_r/z_scaling_factor) + (2*radius2)
+
+        return z_right
+
+    @staticmethod
+    def r(single1, single2, r0, z_right):
+        # if the z_right is known and we want to know the radius r
+        radius1 = single1.pid_particle_pair[1].radius
+        radius2 = single2.pid_particle_pair[1].radius
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
+        D_r = D1 + D2
+        D_R = (D1*D2)/(D1 + D2)
+
+        # we first calculate the a_r, since it is the only radius that depends on z_right only.
+        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+        a_r = (z_right - (2*radius2)) * z_scaling_factor
+
+        # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
+        # Note that for the IV we only take the distance to the outer boundary into account.
+        a_R = (a_r - r0)*math.sqrt((2*D_R)/(3*D_r))
+
+        # We calculate the maximum space needed for particles A and B based on maximum IV displacement
+        iv_max = max( (D1/D_r * a_r + radius1),
+                      (D2/D_r * a_r + radius2))
+
+        r = a_R + iv_max
+        return r
+
+    @staticmethod
+    def calc_shell_scalingangle(D1, D2):
+        D_r = D1 + D2
+        D_R = (D1*D2)/(D1 + D2)
+
+        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+
+        angle = math.atan( 1 / ( z_scaling_factor * ( math.sqrt( (2*D_R)/(3*D_r) ) + \
+                                                      max( D1/D_r, D2/D_r )
+                                                    )))
+        return angle
+
+    @staticmethod
+    def calc_z_scaling_factor(D2d, D3d):
+        # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
+        return math.sqrt( (D2d + D3d) / D3d)
+
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
                  shell_half_length, shell_orientation_vector, 

From efe93cdf0c0e789fae7383bd66f78d360af16d62 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 26 Oct 2011 15:10:15 +0200
Subject: [PATCH 0304/1541] get_closest_surface did not do cyclic boundaries.
 It does so now. Included factor 2 into acceptence probability.

---
 BDSimulator.hpp     | 19 ++++++++++++++-----
 Plane.hpp           |  2 +-
 Region.hpp          |  5 +++++
 Structure.hpp       |  2 ++
 Surface.hpp         |  5 +++++
 World.hpp           | 25 +++++++++++++++++--------
 newBDPropagator.hpp | 19 +++++++++++--------
 7 files changed, 55 insertions(+), 22 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 59554843..717fe7e5 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -51,6 +51,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     {
         calculate_dt();
         reaction_length_ = determine_reaction_length( *world, base_type::dt_, reaction_length_factor_ );
+        bound_time = 0;
     }
 
     virtual void calculate_dt()
@@ -78,6 +79,10 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
             _step(lt);
             base_type::t_ = upto;
         }
+        
+        if(base_type::world_->num_particles() == 1)
+            bound_time += base_type::dt_;
+        
         return true;
     }
 
@@ -97,7 +102,6 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     
     static length_type determine_reaction_length(world_type const& world, time_type dt, length_type const& reaction_length_factor)
     {
-        //TODO
         return reaction_length_factor * sqrt( 2 * 1E-12 * dt );
     }
     
@@ -106,10 +110,14 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return reaction_length_;    
     }
     
-    void set_reaction_length_factor(length_type new_reaction_length_factor)
+    double set_reaction_length_factor(length_type new_reaction_length_factor)
     {
+        double old_bound_time = bound_time;
+        bound_time = 0;
+        
         reaction_length_factor_ = new_reaction_length_factor;
-        reaction_length_ = determine_reaction_length( *base_type::world_, base_type::dt_, reaction_length_factor_ );        
+        reaction_length_ = determine_reaction_length( *base_type::world_, base_type::dt_, reaction_length_factor_ );
+        return old_bound_time;        
     }
 
 protected:
@@ -125,8 +133,8 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
                 make_select_first_range(base_type::world_->
                                         get_particles_range()));
             while (propagator());
-            LOG_DEBUG(("%d: t=%lg, dt=%lg", base_type::num_steps_, 
-                       base_type::t_, dt));
+            //LOG_DEBUG(("%d: t=%lg, dt=%lg", base_type::num_steps_, 
+            //           base_type::t_, dt));
         }
         ++base_type::num_steps_;
         base_type::t_ += dt;
@@ -138,6 +146,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     length_type reaction_length_factor_;
     length_type reaction_length_;
     static Logger& log_;
+    Real bound_time;
 };
 
 template<typename Ttraits_>
diff --git a/Plane.hpp b/Plane.hpp
index c9d4957c..bbcf1c7b 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -217,7 +217,7 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 
     if (dx < 0 && dy < 0) {
         // pos is positioned over the plane (projected point is in the plane and
-	// not next to it).
+	    // not next to it).
         return abs(x_y_z[2]);
     }
 
diff --git a/Region.hpp b/Region.hpp
index d34a595f..451d9167 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -84,6 +84,11 @@ class BasicRegionImpl: public Region<Ttraits_>
     {
         return ::distance(shape(), pos);
     }
+    
+    virtual position_type const& structure_position() const
+    {
+        return shape_.position();
+    }
 
     BasicRegionImpl(identifier_type const& id, shape_type const& shape)
         : base_type(id), shape_(shape) {}
diff --git a/Structure.hpp b/Structure.hpp
index 75ee7d15..3e9a0e08 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -86,6 +86,8 @@ class Structure
     virtual projected_type projected_point(position_type const& pos) const = 0;
     
     virtual length_type distance(position_type const& pos) const = 0;
+    
+    virtual position_type const& structure_position() const = 0;
 
     virtual std::size_t hash() const
     {
diff --git a/Surface.hpp b/Surface.hpp
index 8615d1cc..522d33af 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -90,6 +90,11 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     {
         return ::distance(shape(), pos);
     }
+    
+    virtual position_type const& structure_position() const
+    {
+        return shape_.position();
+    }
 
     BasicSurfaceImpl(identifier_type const& id, shape_type const& shape)
         : base_type(id), shape_(shape) {}
diff --git a/World.hpp b/World.hpp
index f22a3400..f5af29d8 100644
--- a/World.hpp
+++ b/World.hpp
@@ -293,33 +293,42 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         structures_range structures = get_structures();
         
         size_type size ( structures.size() );
-                
+        
+        length_type const world_size( base_type::world_size() );
+        
         switch(size)
         {
         case 0:
             throw not_found(std::string("No structures found."));
                  
-        case 1:
-            return structure_id_and_distance_pair( (*structures.begin())->id() , 2*base_type::world_size() );
+        case 1:   
+            return structure_id_and_distance_pair( (*structures.begin())->id() , 2*world_size );
         
         case 2:
         {
             surface_iterator structure = structures.begin();
-            return structure_id_and_distance_pair( (*structure)->id() , (*structure)->distance( pos ) );
+            position_type pos_transposed = 
+                cyclic_transpose( pos, (*structure)->structure_position(), world_size );
+            return structure_id_and_distance_pair( (*structure)->id() , 
+                (*structure)->distance( pos_transposed ) );
         }
         
         default:
         {   
             surface_iterator structure = structures.begin();               
             surface_iterator ret_structure( structure );
-                
-            length_type distance;            
-            length_type ret_distance( (*structure)->distance( pos ) );              
+            
+            position_type pos_transposed = cyclic_transpose( pos, 
+                (*structure)->structure_position(), world_size );
+            
+            length_type distance;
+            length_type ret_distance( (*structure)->distance( pos_transposed ) );              
                    
             structure++;
             for(size_type i = 2; i < size; i++)
             {
-                distance = (*structure)->distance( pos );
+                pos_transposed = cyclic_transpose( pos, (*structure)->structure_position(), world_size );
+                distance = (*structure)->distance( pos_transposed );
                 
                 if( distance < ret_distance )
                 {
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 91d603c7..f8f5edd5 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -87,7 +87,9 @@ class newBDPropagator
         queue_.pop_back();
         particle_id_pair pp(tx_.get_particle(pid));
 
-        LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
+        //LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
+
+
 
         /* START SOME SAMPLES, after which we return. 
         position_pair_type pp01;
@@ -168,7 +170,7 @@ class newBDPropagator
         {
 
             // Make a step, dependent on the surface the particle lives on.
-            position_type const displacement( tx_.get_structure(species.structure_id())->
+            position_type const displacement( pp_structure->
                                             bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
 
             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
@@ -225,12 +227,12 @@ class newBDPropagator
         {
             try
             {
-                if( false /*attempt_interaction(pp, pp_surface)*/ )
+                if( attempt_interaction(pp, tx_.get_structure(struct_id_distance_pair.first) ) )
                     return true;
                 else                
                 {
-                    LOG_DEBUG(("Particle attempted an interaction with the nonreactive surface %s.", 
-                        boost::lexical_cast<std::string>(pp_structure->id()).c_str()));
+                    LOG_DEBUG(("Particle attempted an interaction with the noninteractive surface %s.", 
+                        boost::lexical_cast<std::string>(struct_id_distance_pair.first).c_str()));
                     ++rejected_move_count_;
                 }
             }
@@ -529,7 +531,9 @@ class newBDPropagator
             reaction_rule_type const& r(*i);  
 
             //TODO Do I need special reaction volumes for surface-bulk interaction? Or allways the 3D case?
-            Real p( r.k() * dt_ / ( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ) );
+            /* NOTE: multiplying reaction volume with 2 because a reaction between a pair of particles is
+               attempted twice (at max). This only holds for small Pacc. */
+            Real p( r.k() * dt_ / ( 2 * s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ) );
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
@@ -544,7 +548,6 @@ class newBDPropagator
             if (prob > rnd)
             {
                 LOG_DEBUG(("fire reaction"));
-                std::cerr << "Initiating unequall structure reaction! " << std::endl;
                 const typename reaction_rule_type::species_id_range products(
                     r.get_products());
 
@@ -676,7 +679,7 @@ class newBDPropagator
                         const species_id_type product(products[0]);
                         const species_type sp(tx_.get_species(product));
 
-                        const position_type new_pos( tx_.apply_boundary( structure->projected_point( pp.second.position() ) ) );
+                        const position_type new_pos( tx_.apply_boundary( structure->projected_point( pp.second.position() ).first ) );
                             
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                             tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),

From a1d33a790e5de948659cba1f65c0e35bdbe67ed6 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 26 Oct 2011 17:38:20 +0200
Subject: [PATCH 0305/1541] Enabled reactions with multiple objects per step.
 Needs checking though.

---
 World.hpp           |  2 +-
 newBDPropagator.hpp | 76 +++++++++++++++++++++++++--------------------
 2 files changed, 44 insertions(+), 34 deletions(-)

diff --git a/World.hpp b/World.hpp
index f5af29d8..1521038c 100644
--- a/World.hpp
+++ b/World.hpp
@@ -288,6 +288,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             structure_map_.size());
     }
     
+    //TODO remove call to cyclic_transpose, sice world could be non cyclic.
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
     {        
         structures_range structures = get_structures();
@@ -335,7 +336,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
                     ret_distance = distance;
                     ret_structure = structure;
                 }
-                //std::cerr << "id = " << (*structure)->id() << ", dist = " << distance << std::endl;
                 structure++;
             }
         
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index f8f5edd5..22ff5e81 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -222,17 +222,27 @@ class newBDPropagator
             core_surface_distance = struct_id_distance_pair.second - r0;  
         }
         
-        /* If their is only a surface in the reaction volume, attempt interaction. */
-        if(particles_in_overlap == 0 && core_surface_distance < reaction_length_ && pp_structure->id() == "world")
+        /* Attempt a reaction or interaction with all the particles (and/or a surface) that 
+           are inside the reaction volume */
+        Real accumulated_prob = 0;
+        
+        /* First, if a surface is near, attempt an interaction.  */
+        if(core_surface_distance < reaction_length_ && pp_structure->id() == "world")
         {
             try
             {
-                if( attempt_interaction(pp, tx_.get_structure(struct_id_distance_pair.first) ) )
-                    return true;
+                const Real prob( attempt_interaction(pp, tx_.get_structure(struct_id_distance_pair.first) ) );
+                
+                if(prob < 0)
+                {
+                    //An interaction occured.
+                    return true;                                 
+                }
                 else                
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the noninteractive surface %s.", 
                         boost::lexical_cast<std::string>(struct_id_distance_pair.first).c_str()));
+                    accumulated_prob += prob;
                     ++rejected_move_count_;
                 }
             }
@@ -242,24 +252,25 @@ class newBDPropagator
                 ++rejected_move_count_;
             }
         }
-         
-        switch (particles_in_overlap)
-        {
-        case 0:
-            break;
-
-        case 1:
+        
+        /* Now attempt reaction with all particles inside the reaction volume. */
+        j = 0;
+        while(j < particles_in_overlap)
         {
-            particle_id_pair_and_distance const& closest(overlapped->at(0));
+            particle_id_pair_and_distance const& closest( overlapped->at(j) );
  		        
     		try
             {
-                if( attempt_reaction(pp, closest.first) )
+                const Real prob( attempt_reaction(pp, closest.first) );
+            
+                if( prob < 0 )
+                    //A reaction occured.
                     return true;
                 else                
                 {
                     LOG_DEBUG(("Particle attempted a reaction with a nonreactive particle %s.", 
                         boost::lexical_cast<std::string>(closest.first.first).c_str()));
+                    accumulated_prob += prob;
                     ++rejected_move_count_;
                 }
             }
@@ -268,16 +279,11 @@ class newBDPropagator
                 log_.info("second-order reaction rejected (reason: %s)", reason.what());
                 ++rejected_move_count_;
             }
-            /* If no reaction has occurred */    
-            break;
-        }
-        default:
-            log_.info("Multiple objects (surface and/or particle) in reaction volume; moved but no reaction initiated.");
-            ++rejected_move_count_;
-            break;
+            
+            j++;
         }
                        
-        /* If the particle did not bounce, update to new position. */
+        /* If the particle did neither react, interact or bounce, update it to it's new position. */
         if(!bounced)
         {   
             particle_id_pair particle_to_update( pp.first, 
@@ -498,12 +504,14 @@ class newBDPropagator
         return false;
     }
 
-    bool attempt_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1)
+    /* Function returns the accumulated acceptance probability of the reacting particles if no
+       reaction occured. If a reaction has happened, it returns -1 and if no rules exist it returns 0. */
+    Real attempt_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1)
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
         if (::size(rules) == 0)
         {
-            return false;
+            return 0;
         }
 
         species_type s0(tx_.get_species(pp0.second.sid())),
@@ -524,7 +532,8 @@ class newBDPropagator
         Real prob = 0;
 
         boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
-
+        const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
+        
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
@@ -533,7 +542,7 @@ class newBDPropagator
             //TODO Do I need special reaction volumes for surface-bulk interaction? Or allways the 3D case?
             /* NOTE: multiplying reaction volume with 2 because a reaction between a pair of particles is
                attempted twice (at max). This only holds for small Pacc. */
-            Real p( r.k() * dt_ / ( 2 * s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ) );
+            const Real p( r.k() * dt_ / ( 2 * reaction_volume ) );
             BOOST_ASSERT(p >= 0.);
             prob += p;
             if (prob >= 1.)
@@ -623,20 +632,21 @@ class newBDPropagator
                 default:
                     throw not_implemented("bimolecular reactions that produce more than one product are not supported");
                 }
-
-                return true;
+                
+                return -1;
             }
         }
-        return false;
+        return prob;
     }
     
-    
-    bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
+    /* Function returns the accumulated acceptance probability of the reacting particles if no
+       reaction occured. If a reaction has happened, it returns -1 and if no rules exist it returns 0. */
+    Real attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), structure->sid() ));
         if (::size(rules) == 0)
         {
-            return false;
+            return 0;
         }
         
         const species_type s0(tx_.get_species(pp.second.sid()));
@@ -719,10 +729,10 @@ class newBDPropagator
                     throw not_implemented("surface interactions that produce more than one product are not supported");
                 }
 
-                return true;
+                return -1;
             }
         }
-        return false;
+        return prob;
     }
     
     /* Given a position pair and two species, the function generates two new 

From 8b885a8b7c94f85b7c932ae0d2e218feb445d75f Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 26 Oct 2011 18:26:26 +0200
Subject: [PATCH 0306/1541] Removed mayot error in multiple overlaps reaction.

---
 newBDPropagator.hpp | 148 +++++++++++++++++++++++++++++++-------------
 1 file changed, 105 insertions(+), 43 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 22ff5e81..316c99ef 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -222,35 +222,42 @@ class newBDPropagator
             core_surface_distance = struct_id_distance_pair.second - r0;  
         }
         
-        /* Attempt a reaction or interaction with all the particles (and/or a surface) that 
-           are inside the reaction volume */
+        /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
+           are inside the reaction volume. */
         Real accumulated_prob = 0;
+        Real const rnd( rng_() );
         
         /* First, if a surface is near, attempt an interaction.  */
         if(core_surface_distance < reaction_length_ && pp_structure->id() == "world")
         {
-            try
+            boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure(struct_id_distance_pair.first) );
+            accumulated_prob += accumulated_reaction_probability( pp.second.sid(), closest_surf->sid() );
+        
+            if( accumulated_prob > rnd )
             {
-                const Real prob( attempt_interaction(pp, tx_.get_structure(struct_id_distance_pair.first) ) );
-                
-                if(prob < 0)
+                try
                 {
-                    //An interaction occured.
-                    return true;                                 
-                }
-                else                
+                    const Real prob( attempt_interaction(pp, closest_surf ) );
+                
+                    if(prob < 0)
+                    {
+                        //An interaction occured.
+                        return true;                                 
+                    }
+                    else                
+                    {
+                        LOG_DEBUG(("Particle attempted an interaction with the noninteractive surface %s.", 
+                            boost::lexical_cast<std::string>(struct_id_distance_pair.first).c_str()));
+                        accumulated_prob += prob;
+                        ++rejected_move_count_;
+                    }
+                }   
+                catch (propagation_error const& reason)
                 {
-                    LOG_DEBUG(("Particle attempted an interaction with the noninteractive surface %s.", 
-                        boost::lexical_cast<std::string>(struct_id_distance_pair.first).c_str()));
-                    accumulated_prob += prob;
+                    log_.info("surface interaction rejected (reason: %s)", reason.what());
                     ++rejected_move_count_;
                 }
             }
-            catch (propagation_error const& reason)
-            {
-                log_.info("surface interaction rejected (reason: %s)", reason.what());
-                ++rejected_move_count_;
-            }
         }
         
         /* Now attempt reaction with all particles inside the reaction volume. */
@@ -258,27 +265,42 @@ class newBDPropagator
         while(j < particles_in_overlap)
         {
             particle_id_pair_and_distance const& closest( overlapped->at(j) );
- 		        
-    		try
+            
+            accumulated_prob += accumulated_reaction_probability( pp.second.sid(), closest.first.second.sid() );
+            
+            if (accumulated_prob >= 1.)
             {
-                const Real prob( attempt_reaction(pp, closest.first) );
+                throw propagation_error(
+                    "the accumulated acceptance probability for a reaction volume with multiple overlaps exeeded one; "
+                    + boost::lexical_cast<std::string>(accumulated_prob)
+                    + ".");
+            }   
             
-                if( prob < 0 )
-                    //A reaction occured.
-                    return true;
-                else                
+            if(accumulated_prob > rnd)
+            {
+    		    try
+                {
+                    const Real prob( attempt_reaction(pp, closest.first) );
+            
+                    if( prob < 0 )
+                    {
+                        //A reaction occured.
+                        return true;
+                    }
+                    else                
+                    {
+                        LOG_DEBUG(("Particle attempted a reaction with a nonreactive particle %s.", 
+                            boost::lexical_cast<std::string>(closest.first.first).c_str()));
+                        accumulated_prob += prob;
+                        ++rejected_move_count_;
+                    }
+                }
+                catch (propagation_error const& reason)
                 {
-                    LOG_DEBUG(("Particle attempted a reaction with a nonreactive particle %s.", 
-                        boost::lexical_cast<std::string>(closest.first.first).c_str()));
-                    accumulated_prob += prob;
+                    log_.info("second-order reaction rejected (reason: %s)", reason.what());
                     ++rejected_move_count_;
                 }
             }
-            catch (propagation_error const& reason)
-            {
-                log_.info("second-order reaction rejected (reason: %s)", reason.what());
-                ++rejected_move_count_;
-            }
             
             j++;
         }
@@ -543,17 +565,7 @@ class newBDPropagator
             /* NOTE: multiplying reaction volume with 2 because a reaction between a pair of particles is
                attempted twice (at max). This only holds for small Pacc. */
             const Real p( r.k() * dt_ / ( 2 * reaction_volume ) );
-            BOOST_ASSERT(p >= 0.);
             prob += p;
-            if (prob >= 1.)
-            {
-                throw propagation_error(
-                    "invalid acceptance ratio ("
-                    + boost::lexical_cast<std::string>(p)
-                    + ") for reaction rate "
-                    + boost::lexical_cast<std::string>(r.k())
-                    + ".");
-            }
             if (prob > rnd)
             {
                 LOG_DEBUG(("fire reaction"));
@@ -639,6 +651,56 @@ class newBDPropagator
         return prob;
     }
     
+     /* Function returns the accumulated acceptance probability of the two reacting particles. */
+    Real accumulated_reaction_probability(species_id_type const& sid0, species_id_type const& sid1)
+    {
+        reaction_rules const& rules(rules_.query_reaction_rule(sid0, sid1));
+        if (::size(rules) == 0)
+        {
+            return 0;
+        }
+
+        species_type s0(tx_.get_species(sid0)),
+                s1(tx_.get_species(sid1));
+        
+        /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
+           and we let this be s1, the particle from the surface is named s0. */     
+        if(s0.structure_id() != s1.structure_id())
+        {
+            if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
+                throw not_implemented("No surface -> surface + surface - reactions allowed");
+                
+            if(s0.structure_id() == "world")
+                std::swap(s0,s1);
+        }
+
+        Real k_tot = 0;
+
+        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
+        const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
+        
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            reaction_rule_type const& r(*i);  
+            k_tot += r.k();
+        }
+        
+        Real const accumulated_prob( k_tot * dt_ / (2 * reaction_volume) );
+        
+        if (accumulated_prob >= 1.)
+        {
+            throw propagation_error(
+               "invalid accumulated probability calculated ("
+               + boost::lexical_cast<std::string>(accumulated_prob)
+               + ") for the accumulated reaction rate "
+               + boost::lexical_cast<std::string>(k_tot)
+               + ".");
+        }        
+        
+        return accumulated_prob;
+    }
+    
     /* Function returns the accumulated acceptance probability of the reacting particles if no
        reaction occured. If a reaction has happened, it returns -1 and if no rules exist it returns 0. */
     Real attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)

From 356d7ab77dc555554414e9ca9afb7c8bceb2ed29 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 26 Oct 2011 19:05:20 +0200
Subject: [PATCH 0307/1541] comments are supposed to be in English not Dutch :)

---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index 6eec6edc..d9d7f7af 100644
--- a/utils.py
+++ b/utils.py
@@ -198,7 +198,7 @@ def normalize(a, l=1):
     return _gfrd.normalize(a, l)
 
 def vector_angle(a, b):
-    # returns the angle tussen vector a en b
+    # returns the angle between vector a en b
     # the range of the angle is (0 - Pi)
     cosangle = numpy.dot(a, b) / (length(a) * length(b))
     return math.acos(cosangle)

From b51080f1b330016c3459387d75696210861eaed4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 26 Oct 2011 19:06:06 +0200
Subject: [PATCH 0308/1541] continued work on shell dimensioning algorithm for
 MixedPair

---
 pair.py | 55 ++++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 44 insertions(+), 11 deletions(-)

diff --git a/pair.py b/pair.py
index 35ba362e..418dfc61 100644
--- a/pair.py
+++ b/pair.py
@@ -770,20 +770,48 @@ def get_min_shell_dimensions(single1, single2, reference_point, geometrycontaine
     @staticmethod
     def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer, domains):
         # Properties of the MixedPair system
-        phi = MixedPair.calc_shell_scalingangle(D1, D2)
-        tan_phi = math.tan(phi)
-        cos_phi = math.cos(phi)
-        shell_scalecenter_z = MixedPair.z_right(single1, single2, r0, 0.0)
 
 
-        theta = 
+
+
+        return dr, dz_left, dz_right
+
+    @staticmethod
+    def laurens_algorithm(shell_position, shell_size, reference_point,
+                          orientation_vector, dr, dz_left, dz_right, surface)
+
+        # determine on what side the midpoint of the shell is relative to the reference_point
+        # Maybe do cyclic_transpose here
+        direction = math.dot(shell_position-reference_point, orientation_vector)
+
+        # if the shell is on the side of orientation_vector -> use z_right
+        # also use this one if the shell is in plane with the reference_point
+        if direction >= 0:
+            phi = MixedPair.calc_right_scalingangle(D1, D2)
+            h0 = MixedPair.z_right(single1, single2, r0, 0.0)
+        # else -> use z_left
+        else:
+            phi = MixedPair.calc_left_scaling(D1, D2)
+            h0 = MixedPair.z_left(single1, single2, r0, 0.0)
+
+        # calculate the center from which linear scaling will take place
+        scale_center = h0 * (direction/abs(direction)) * orientation_vector
+
+        # calculate the vector from the scale center to the center of the shell
+        shell_scale_center = shell_position_scale_center
+        # calculate the angle theta of the vector from the scale center to the shell with the vector
+        # to the scale center
+        theta = vector_angle (shell_scale_center, scale_center)
+
         psi = theta - phi
         sin_psi = math.sin(psi)
         cos_psi = math.cos(psi)
 
+
+        # TODO TODO TODO
         if psi <= 0:
             a_crit = shell_scalecenter_z - shell_scalecenter_xy * tan_phi
-        else
+        else:
             a_crit = shell_scalecenter_xy - shell_scalecenter_z/tan_phi
 
         if a_shell <= a_crit and psi <= 0:
@@ -802,10 +830,11 @@ def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer,
             dz_right = MixedPair.z_right(dr)
 
 
-        dz_left = single1.pid_particle_pair[1].radius
-        return dr, dz_left, dz_right
+        tan_phi = math.tan(phi)
+        cos_phi = math.cos(phi)
+
 
-    @staticmetod
+    @staticmethod
     def z_right(single1, single2, r0, r):
         # if the radius is known and we want to determine the height z_right
         radius1 = single1.pid_particle_pair[1].radius
@@ -827,6 +856,10 @@ def z_right(single1, single2, r0, r):
 
         return z_right
 
+    @staticmethod
+    def z_left(single1, single2, r0, r):
+        return single1.pid_particle_pair[1].radius
+
     @staticmethod
     def r(single1, single2, r0, z_right):
         # if the z_right is known and we want to know the radius r
@@ -853,13 +886,13 @@ def r(single1, single2, r0, z_right):
         return r
 
     @staticmethod
-    def calc_shell_scalingangle(D1, D2):
+    def calc_right_scalingangle(D1, D2):
         D_r = D1 + D2
         D_R = (D1*D2)/(D1 + D2)
 
         z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
 
-        angle = math.atan( 1 / ( z_scaling_factor * ( math.sqrt( (2*D_R)/(3*D_r) ) + \
+        angle = math.atan( ( z_scaling_factor * ( math.sqrt( (2*D_R)/(3*D_r) ) + \
                                                       max( D1/D_r, D2/D_r )
                                                     )))
         return angle

From c9e018a9ad05e6bc690d7d78eb135f1394906f4b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 27 Oct 2011 11:42:37 +0200
Subject: [PATCH 0309/1541] Continuing to blunder about with multi reactions.

---
 newBDPropagator.hpp | 230 +++++++++++++++++++++-----------------------
 1 file changed, 107 insertions(+), 123 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 316c99ef..d96b9c7b 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -237,20 +237,9 @@ class newBDPropagator
             {
                 try
                 {
-                    const Real prob( attempt_interaction(pp, closest_surf ) );
-                
-                    if(prob < 0)
-                    {
-                        //An interaction occured.
+                    LOG_DEBUG(("fire interaction"));
+                    if(fire_interaction(pp, closest_surf ))
                         return true;                                 
-                    }
-                    else                
-                    {
-                        LOG_DEBUG(("Particle attempted an interaction with the noninteractive surface %s.", 
-                            boost::lexical_cast<std::string>(struct_id_distance_pair.first).c_str()));
-                        accumulated_prob += prob;
-                        ++rejected_move_count_;
-                    }
                 }   
                 catch (propagation_error const& reason)
                 {
@@ -258,6 +247,12 @@ class newBDPropagator
                     ++rejected_move_count_;
                 }
             }
+            else                
+            {
+                LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
+                    boost::lexical_cast<std::string>(closest_surf->id()).c_str()));
+                ++rejected_move_count_;
+            }
         }
         
         /* Now attempt reaction with all particles inside the reaction volume. */
@@ -271,29 +266,18 @@ class newBDPropagator
             if (accumulated_prob >= 1.)
             {
                 throw propagation_error(
-                    "the accumulated acceptance probability for a reaction volume with multiple overlaps exeeded one; "
+                    "the accumulated acceptance probability for a reaction volume exeeded one; "
                     + boost::lexical_cast<std::string>(accumulated_prob)
                     + ".");
             }   
             
             if(accumulated_prob > rnd)
             {
+                LOG_DEBUG(("fire reaction"));
     		    try
                 {
-                    const Real prob( attempt_reaction(pp, closest.first) );
-            
-                    if( prob < 0 )
-                    {
-                        //A reaction occured.
+                    if( fire_reaction(pp, closest.first) )
                         return true;
-                    }
-                    else                
-                    {
-                        LOG_DEBUG(("Particle attempted a reaction with a nonreactive particle %s.", 
-                            boost::lexical_cast<std::string>(closest.first.first).c_str()));
-                        accumulated_prob += prob;
-                        ++rejected_move_count_;
-                    }
                 }
                 catch (propagation_error const& reason)
                 {
@@ -301,6 +285,12 @@ class newBDPropagator
                     ++rejected_move_count_;
                 }
             }
+            else                
+            {
+                LOG_DEBUG(("Particle attempted a reaction with a non-reactive particle %s.", 
+                    boost::lexical_cast<std::string>(closest.first.first).c_str()));
+                ++rejected_move_count_;
+            }
             
             j++;
         }
@@ -365,7 +355,7 @@ class newBDPropagator
                         boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species(pp.second.sid()).structure_id() ) );
                         position_type new_pos = pp.second.position();
                         
-                        /* If the product particle does NOT live of the same structure as pp => surface -> bulk dissociation. */
+                        /* If the product particle does NOT live of the same structure as the reactant => surface -> bulk dissociation. */
                         if( s0.structure_id() != pp_struct->id() )
                         {
                             if( s0.structure_id() != "world" )
@@ -374,6 +364,9 @@ class newBDPropagator
                             position_type const displacement( pp_struct->surface_dissociation_vector(rng_, s0.radius(), reaction_length_ ) );
 
                             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
+                            
+                            //Particle is allowed to move after dissociation from surface.
+                            new_pos = make_move(s0, new_pos, pp.first);
                         }
                       
                         const particle_id_pair new_p(
@@ -385,14 +378,14 @@ class newBDPropagator
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_p.second.shape(), new_p.first));
                         if (overlapped && overlapped->size() > 0)
                         {
-                            throw propagation_error("no space due to particle");
+                            throw propagation_error("no space due to other particle");
                         }
 
                         if (vc_)
                         {
                             if (!(*vc_)(new_p.second.shape(), pp.first))
                             {
-                                throw propagation_error("no space due to particle");
+                                throw propagation_error("no space due to other particle");
                             }
                         }
 
@@ -402,7 +395,7 @@ class newBDPropagator
                             length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
                                     
                             if( core_surface_distance < 0 )
-                                throw propagation_error("no space due to surface");
+                                throw propagation_error("no space due to near surface");
                         }
 
                         tx_.update_particle(new_p);
@@ -525,19 +518,19 @@ class newBDPropagator
         }
         return false;
     }
-
-    /* Function returns the accumulated acceptance probability of the reacting particles if no
-       reaction occured. If a reaction has happened, it returns -1 and if no rules exist it returns 0. */
-    Real attempt_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1)
+    
+    
+     /* Function returns the accumulated acceptance probability of the two reacting particles. */
+    Real accumulated_reaction_probability(species_id_type const& sid0, species_id_type const& sid1)
     {
-        reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
+        reaction_rules const& rules(rules_.query_reaction_rule(sid0, sid1));
         if (::size(rules) == 0)
         {
             return 0;
         }
 
-        species_type s0(tx_.get_species(pp0.second.sid())),
-                s1(tx_.get_species(pp1.second.sid()));
+        species_type s0(tx_.get_species(sid0)),
+                s1(tx_.get_species(sid1));
         
         /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
            and we let this be s1, the particle from the surface is named s0. */     
@@ -550,8 +543,7 @@ class newBDPropagator
                 std::swap(s0,s1);
         }
 
-        const Real rnd(rng_());
-        Real prob = 0;
+        Real k_tot = 0;
 
         boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
         const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
@@ -559,16 +551,64 @@ class newBDPropagator
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
-            reaction_rule_type const& r(*i);  
+            k_tot += (*i).k();
+        }
+        
+        Real const accumulated_prob( k_tot * dt_ / (2 * reaction_volume) );
+        
+        if (accumulated_prob >= 1.)
+        {
+            throw propagation_error(
+               "invalid accumulated probability calculated ("
+               + boost::lexical_cast<std::string>(accumulated_prob)
+               + ") for the total reaction rate is "
+               + boost::lexical_cast<std::string>(k_tot)
+               + ".");
+        }        
+        
+        return accumulated_prob;
+    }
+    
+    
+    bool fire_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1)
+    {
+        reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
+        if(::size(rules) == 0)
+            throw propagation_error("trying to fire a reaction between non-reactive particles");
 
-            //TODO Do I need special reaction volumes for surface-bulk interaction? Or allways the 3D case?
-            /* NOTE: multiplying reaction volume with 2 because a reaction between a pair of particles is
-               attempted twice (at max). This only holds for small Pacc. */
-            const Real p( r.k() * dt_ / ( 2 * reaction_volume ) );
-            prob += p;
+        species_type s0(tx_.get_species(pp0.second.sid())),
+                s1(tx_.get_species(pp1.second.sid()));
+        
+        /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
+           and we let this be s1, the particle from the surface is named s0. */     
+        if(s0.structure_id() != s1.structure_id())
+        {
+            if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
+                throw not_implemented("No surface -> surface + surface - reactions allowed");
+                
+            if(s0.structure_id() == "world")
+                std::swap(s0,s1);
+        }
+
+        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
+        
+        Real k_tot = 0;
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            k_tot += (*i).k();            
+        }
+
+        const Real rnd( k_tot * rng_() );
+        Real prob = 0;    
+        
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            reaction_rule_type const& r(*i);  
+            prob += r.k();
             if (prob > rnd)
             {
-                LOG_DEBUG(("fire reaction"));
                 const typename reaction_rule_type::species_id_range products(
                     r.get_products());
 
@@ -620,7 +660,7 @@ class newBDPropagator
                             length_type const core_surface_distance( struct_id_distance_pair.second - sp.radius() );
                                     
                             if( core_surface_distance < 0 )
-                                throw propagation_error("no space due to surface");     
+                                throw propagation_error("no space due to near surface");     
                         }
 
                         remove_particle(pp0.first);
@@ -645,71 +685,19 @@ class newBDPropagator
                     throw not_implemented("bimolecular reactions that produce more than one product are not supported");
                 }
                 
-                return -1;
+                return true;
             }
         }
-        return prob;
+        //Should not reach here.
+        return false;
     }
-    
-     /* Function returns the accumulated acceptance probability of the two reacting particles. */
-    Real accumulated_reaction_probability(species_id_type const& sid0, species_id_type const& sid1)
-    {
-        reaction_rules const& rules(rules_.query_reaction_rule(sid0, sid1));
-        if (::size(rules) == 0)
-        {
-            return 0;
-        }
-
-        species_type s0(tx_.get_species(sid0)),
-                s1(tx_.get_species(sid1));
-        
-        /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
-           and we let this be s1, the particle from the surface is named s0. */     
-        if(s0.structure_id() != s1.structure_id())
-        {
-            if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
-                throw not_implemented("No surface -> surface + surface - reactions allowed");
-                
-            if(s0.structure_id() == "world")
-                std::swap(s0,s1);
-        }
 
-        Real k_tot = 0;
-
-        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
-        const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
         
-        for (typename boost::range_const_iterator<reaction_rules>::type
-                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
-        {
-            reaction_rule_type const& r(*i);  
-            k_tot += r.k();
-        }
-        
-        Real const accumulated_prob( k_tot * dt_ / (2 * reaction_volume) );
-        
-        if (accumulated_prob >= 1.)
-        {
-            throw propagation_error(
-               "invalid accumulated probability calculated ("
-               + boost::lexical_cast<std::string>(accumulated_prob)
-               + ") for the accumulated reaction rate "
-               + boost::lexical_cast<std::string>(k_tot)
-               + ".");
-        }        
-        
-        return accumulated_prob;
-    }
-    
-    /* Function returns the accumulated acceptance probability of the reacting particles if no
-       reaction occured. If a reaction has happened, it returns -1 and if no rules exist it returns 0. */
-    Real attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
+    bool fire_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), structure->sid() ));
         if (::size(rules) == 0)
-        {
-            return 0;
-        }
+            throw propagation_error("trying to fire an interaction with a non-interactive surface");
         
         const species_type s0(tx_.get_species(pp.second.sid()));
         
@@ -718,29 +706,24 @@ class newBDPropagator
         if(pp_structure->id() != "world")
             throw not_implemented("only particles living in the bulk are allowed to interact with surfaces");
         
-        const Real rnd(rng_());
-        Real prob = 0;
+        Real k_tot = 0;
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            k_tot += (*i).k();            
+        }
+
+        const Real rnd( k_tot * rng_() );
+        Real prob = 0;  
 
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
             reaction_rule_type const& r(*i); 
+            prob += r.k();
 
-            const Real p( r.k() * dt_ / structure->surface_reaction_volume( s0.radius(), reaction_length_ ) );
-            BOOST_ASSERT(p >= 0.);
-            prob += p;
-            if (prob >= 1.)
-            {
-                throw propagation_error(
-                    "invalid acceptance ratio ("
-                    + boost::lexical_cast<std::string>(p)
-                    + ") for reaction rate "
-                    + boost::lexical_cast<std::string>(r.k())
-                    + ".");
-            }
             if (prob > rnd)
             {
-                LOG_DEBUG(("fire surface interaction"));
                 const typename reaction_rule_type::species_id_range products(
                     r.get_products());
 
@@ -791,10 +774,11 @@ class newBDPropagator
                     throw not_implemented("surface interactions that produce more than one product are not supported");
                 }
 
-                return -1;
+                return true;
             }
         }
-        return prob;
+        //should not reach here.
+        return false;
     }
     
     /* Given a position pair and two species, the function generates two new 
@@ -810,7 +794,7 @@ class newBDPropagator
         position_type temp_pos0, temp_pos1;
         position_pair_type new_pp01( pp01 );
         
-        //Randomize which species moves first, and if there will be one or two moves. (50%)
+        //Randomize which species moves first, and if there will be one or two moves. (50% of the cases)
         bool move_prt0_first( rng_.uniform_int(0, 1) );
         int move_count( 1 + rng_.uniform_int(0, 1) );
         while( move_count-- )

From ad540cf37be75fa29a6ac6f76890acd1c1ee94ca Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Thu, 27 Oct 2011 15:24:52 +0200
Subject: [PATCH 0310/1541] Added more reactions to the template file.

---
 samples/template/template.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/samples/template/template.py b/samples/template/template.py
index 3b77d901..b2984ce7 100755
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -39,8 +39,21 @@
 X = model.Species('X', D, sigma/2)                                   
 m.add_species_type(X) 
 # Reaction rules
+### Binding: A + B -> C
 r1 = model.create_binding_reaction_rule(A, B, X, k)
 m.network_rules.add_reaction_rule(r1)
+### Unbinding: C -> A + B
+r2 = model.create_unbinding_reaction_rule(A, B, X, k)
+m.network_rules.add_reaction_rule(r2)
+# Unimolecular: A - > B
+r3 = model.create_unimolecular_reaction_rule(A, X, k)
+m.network_rules.add_reaction_rule(r3)
+### Decay: A - > 0
+r4 = model.create_decay_reaction_rule(A, k)
+m.network_rules.add_reaction_rule(r4)
+### Annihilation: A + B - > 0
+r5 = model.create_annihilation_reaction_rule(A, B, k)
+m.network_rules.add_reaction_rule(r5)
 
 # World
 w = gfrdbase.create_world(m, 3)

From 45a1c610ab6c6c0a113f9f48158bad2ef94a9b2d Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Thu, 27 Oct 2011 15:26:34 +0200
Subject: [PATCH 0311/1541] Other update template.py.

---
 samples/template/template.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/samples/template/template.py b/samples/template/template.py
index b2984ce7..509796cd 100755
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -40,13 +40,13 @@
 m.add_species_type(X) 
 # Reaction rules
 ### Binding: A + B -> C
-r1 = model.create_binding_reaction_rule(A, B, X, k)
+r1 = model.create_binding_reaction_rule(A, B, C, k)
 m.network_rules.add_reaction_rule(r1)
 ### Unbinding: C -> A + B
-r2 = model.create_unbinding_reaction_rule(A, B, X, k)
+r2 = model.create_unbinding_reaction_rule(C, A, B, k)
 m.network_rules.add_reaction_rule(r2)
 # Unimolecular: A - > B
-r3 = model.create_unimolecular_reaction_rule(A, X, k)
+r3 = model.create_unimolecular_reaction_rule(A, B, k)
 m.network_rules.add_reaction_rule(r3)
 ### Decay: A - > 0
 r4 = model.create_decay_reaction_rule(A, k)

From 2088f795facb72509b27661c52b8158921872138 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 27 Oct 2011 18:15:15 +0200
Subject: [PATCH 0312/1541] continued work on general cylinder scaling (laurens
 algorithm as opposed to miedemas algorithm)

---
 pair.py | 93 +++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 67 insertions(+), 26 deletions(-)

diff --git a/pair.py b/pair.py
index 418dfc61..cdbdaf35 100644
--- a/pair.py
+++ b/pair.py
@@ -781,57 +781,98 @@ def laurens_algorithm(shell_position, shell_size, reference_point,
                           orientation_vector, dr, dz_left, dz_right, surface)
 
         # determine on what side the midpoint of the shell is relative to the reference_point
-        # Maybe do cyclic_transpose here
+        # TODO do cyclic_transpose of shell_position
         direction = math.dot(shell_position-reference_point, orientation_vector)
 
         # if the shell is on the side of orientation_vector -> use z_right
         # also use this one if the shell is in plane with the reference_point
         if direction >= 0:
             phi = MixedPair.calc_right_scalingangle(D1, D2)
-            h0 = MixedPair.z_right(single1, single2, r0, 0.0)
+            h0 = MixedPair.z_right(single1, single2, r0, 0.0)   # r = 0.0
         # else -> use z_left
         else:
-            phi = MixedPair.calc_left_scaling(D1, D2)
-            h0 = MixedPair.z_left(single1, single2, r0, 0.0)
+            phi = MixedPair.calc_left_scalingangle(D1, D2)
+            h0 = MixedPair.z_left(single1, single2, r0, 0.0)    # r = 0.0
 
         # calculate the center from which linear scaling will take place
+        # TODO this should be generalized to accomodate scaling in just z
         scale_center = h0 * (direction/abs(direction)) * orientation_vector
 
         # calculate the vector from the scale center to the center of the shell
-        shell_scale_center = shell_position_scale_center
+        # TODO cyclic transpose of shell_position
+        shell_scale_center = shell_position-scale_center
+        shell_scalecenter_z = 
+        shell_scalecenter_r =
         # calculate the angle theta of the vector from the scale center to the shell with the vector
-        # to the scale center
+        # to the scale center (which is +- the orientation_vector)
         theta = vector_angle (shell_scale_center, scale_center)
 
         psi = theta - phi
-        sin_psi = math.sin(psi)
-        cos_psi = math.cos(psi)
 
 
-        # TODO TODO TODO
-        if psi <= 0:
-            a_crit = shell_scalecenter_z - shell_scalecenter_xy * tan_phi
-        else:
-            a_crit = shell_scalecenter_xy - shell_scalecenter_z/tan_phi
+        ### check what situation arrises
+        # The shell can hit the cylinder on the flat side (situation 1),
+        #                                on the edge (situation 2),
+        #                                or on the round side (situation 3).
+        # I think this works for phi == 0 and phi == Pi/2
+        if psi <= -phi:
+        # The midpoint of the shell lies on the axis of the cylinder
+            situation = 1
 
-        if a_shell <= a_crit and psi <= 0:
-            dr = shell_scalecenter_xy - a_shell
-            dz_right = MixedPair.z_right(dr)
+        elif -phi < psi and psi < 0:
+        # The (spherical) shell can touch the cylinder on its flat side or its edge
+            if phi == Pi/2:
+                r_tan_phi = 0
+            else:
+                r_tan_phi = shell_scalecenter_r/math.tan(phi)   # phi == 0 should not get here
 
-        elif a_shell <= a_crit and psi > 0:
-            dz_right = shell_scalecenter_z + h0 - a_shell
-            dr = MixedPair.r(dz_right)
+            a_thres = shell_scalecenter_z - r_tan_phi
+            if shell_size < a_thres:
+                situation = 1
+            else:
+                situation = 2
+
+        elif 0 <= psi and psi < (Pi/2 - phi):
+        # The (spherical) shell can touch the cylinder on its edge or its radial side
+            tan_phi = math.tan(phi)                             # phi == Pi/2 should not get here
+            a_thres = shell_scalecenter_r - shell_scalecenter_z * tan_phi
+            if shell_size > a_thres:
+                situation = 2
+            else:
+                situation = 3
 
+        elif (Pi/2 - phi) <= psi:
+        # The shell is always only on the radial side of the cylinder
+                situation = 3
+
+        else:
+        # Don't know how we would get here, but it shouldn't happen
+            raise RuntimeError('psi was not in valid range')
+
+        # TODO fix the situation where r and z are actually independent
+        ### Get the right values for z and r for the given situation
+        if situation == 1:      # shell hits on the flat side
+            z = shell_scalecenter_z + h0 - a_shell
+            r = MixedPair.r(z)
+        elif situation == 2:    # shell hits on the edge
+            a_sq = shell_size*shell_size
+            shell_scalecenter_len = length(shell_scalecenter)
+            ss_sq = shell_scalecenter_len*shell_scalecenter_len
+            sin_phi = math.sin(phi)
+            sin_psi = math.sin(psi)
+            cos_psi = math.cos(psi)
+
+            r = sin_phi * (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
+            z = MixedPair.z_right(r)
+        elif situation == 3:    # shell hits on the round side
+            r = shell_scalecenter_r - a_shell
+            z = MixedPair.z_right(r)
         else:
-            assert a_shell > a_crit
-            a_sq = a_shell*a_shell
-            ss_sq = shell_scalecenter*shell_scalecenter
-            dr = cos_phi * (shell_scalecenter * cos_phi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
-            dz_right = MixedPair.z_right(dr)
+            raise RuntimeError('Bad situation for MixedPair shell making')
 
+        
 
-        tan_phi = math.tan(phi)
-        cos_phi = math.cos(phi)
+        return r, z_right, z_left
 
 
     @staticmethod

From 7e1644e85b57ab6e7d710285e95b635fa24fcda8 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 28 Oct 2011 16:19:20 +0200
Subject: [PATCH 0313/1541] Completed surface distance function with cyclic BC.

---
 Cylinder.hpp        |  18 ++++
 Plane.hpp           |  10 +++
 Region.hpp          |   5 ++
 Sphere.hpp          |  12 +++
 Structure.hpp       |   2 +
 Surface.hpp         |   5 ++
 World.hpp           |  37 ++++----
 newBDPropagator.hpp | 207 ++++++++++++++------------------------------
 8 files changed, 134 insertions(+), 162 deletions(-)

diff --git a/Cylinder.hpp b/Cylinder.hpp
index 860c2566..434ed4fc 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -130,6 +130,24 @@ projected_point(Cylinder<T_> const& obj,
         r_z.first);
 }
 
+//Allmost equal to projected point method, but for the substraction of the cylinder radius from the radial distance r.
+//And projected point now lies on the surface, not on the central axis.
+template<typename T_>
+inline std::pair<typename Cylinder<T_>::position_type,
+                 typename Cylinder<T_>::length_type>
+projected_point_on_surface(Cylinder<T_> const& obj,
+                typename Cylinder<T_>::position_type const& pos)
+{
+    typedef typename Cylinder<T_>::length_type length_type;
+    typedef typename Cylinder<T_>::position_type position_type;
+
+    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    position_type within_surface( add(obj.position(), multiply(obj.unit_z(), r_z.second)) );
+
+    return std::make_pair( add(within_surface, multiply( normalize( subtract( pos, within_surface ) ), obj.radius() )),
+        r_z.first - obj.radius() );
+}
+
 template<typename T_>
 inline typename Cylinder<T_>::length_type
 distance(Cylinder<T_> const& obj,
diff --git a/Plane.hpp b/Plane.hpp
index bbcf1c7b..a9b7a900 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -203,6 +203,16 @@ projected_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& p
         x_y_z[2]);
 }
 
+template<typename T_>
+inline std::pair<typename Plane<T_>::position_type,
+                 typename Plane<T_>::length_type>
+projected_point_on_surface(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Since the projected point on the plane, is already on the surface of the plane,
+// this function is just a wrapper of projected point.
+{
+    return projected_point(obj, pos);
+}
+
 template<typename T_>
 inline typename Plane<T_>::length_type
 distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
diff --git a/Region.hpp b/Region.hpp
index 451d9167..3c8acdde 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -80,6 +80,11 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::projected_point(shape(), pos);
     }
     
+    virtual std::pair<position_type, length_type> projected_point_on_surface(position_type const& pos) const
+    {
+        return ::projected_point(shape(), pos);
+    }
+    
     virtual length_type distance(position_type const& pos) const
     {
         return ::distance(shape(), pos);
diff --git a/Sphere.hpp b/Sphere.hpp
index 565f45db..157c49f9 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -83,6 +83,18 @@ projected_point(Sphere<T_> const& obj,
                           typename Sphere<T_>::length_type());
 }
 
+template<typename T_>
+inline std::pair<typename Sphere<T_>::position_type,
+                 typename Sphere<T_>::length_type>
+projected_point_on_surface(Sphere<T_> const& obj,
+                typename Sphere<T_>::position_type const& pos)
+{
+    // Todo. If we ever need it.
+    // The projection of a point on a sphere.
+    return std::make_pair(typename Sphere<T_>::position_type(),
+                          typename Sphere<T_>::length_type());
+}
+
 template<typename T_>
 inline typename Sphere<T_>::length_type
 distance(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
diff --git a/Structure.hpp b/Structure.hpp
index 3e9a0e08..1157374e 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -85,6 +85,8 @@ class Structure
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
     
+    virtual projected_type projected_point_on_surface(position_type const& pos) const = 0;
+    
     virtual length_type distance(position_type const& pos) const = 0;
     
     virtual position_type const& structure_position() const = 0;
diff --git a/Surface.hpp b/Surface.hpp
index 522d33af..786629d5 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -86,6 +86,11 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::projected_point(shape(), pos);
     }
     
+    virtual projected_type projected_point_on_surface(position_type const& pos) const
+    {
+        return ::projected_point_on_surface(shape(), pos);
+    }
+    
     virtual length_type distance(position_type const& pos) const
     {
         return ::distance(shape(), pos);
diff --git a/World.hpp b/World.hpp
index 1521038c..64b2ff23 100644
--- a/World.hpp
+++ b/World.hpp
@@ -175,6 +175,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
+    typedef std::pair<position_type, length_type> projected_type;
     typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
 
 protected:
@@ -288,13 +289,11 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             structure_map_.size());
     }
     
-    //TODO remove call to cyclic_transpose, sice world could be non cyclic.
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
     {        
         structures_range structures = get_structures();
-        
-        size_type size ( structures.size() );
-        
+        size_type const size ( structures.size() );
+               
         length_type const world_size( base_type::world_size() );
         
         switch(size)
@@ -303,15 +302,18 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             throw not_found(std::string("No structures found."));
                  
         case 1:   
-            return structure_id_and_distance_pair( (*structures.begin())->id() , 2*world_size );
+            return structure_id_and_distance_pair( (*structures.begin())->id() , std::numeric_limits<length_type>::max() );
         
         case 2:
         {
             surface_iterator structure = structures.begin();
-            position_type pos_transposed = 
-                cyclic_transpose( pos, (*structure)->structure_position(), world_size );
-            return structure_id_and_distance_pair( (*structure)->id() , 
-                (*structure)->distance( pos_transposed ) );
+                                              
+            position_type const cyc_pos( cyclic_transpose(pos, (*structure)->structure_position(), world_size) );
+                                              
+            position_type nearest_point_on_surface( (*structure)->projected_point( cyc_pos ).first );
+
+            return structure_id_and_distance_pair( (*structure)->id(), 
+                 traits_type::distance( nearest_point_on_surface, pos, world_size ) );
         }
         
         default:
@@ -319,27 +321,26 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             surface_iterator structure = structures.begin();               
             surface_iterator ret_structure( structure );
             
-            position_type pos_transposed = cyclic_transpose( pos, 
-                (*structure)->structure_position(), world_size );
+            position_type cyc_pos( cyclic_transpose(pos, (*structure)->structure_position(), world_size) );
             
-            length_type distance;
-            length_type ret_distance( (*structure)->distance( pos_transposed ) );              
+            length_type ret_dist( (*structure)->projected_point_on_surface( cyc_pos ).second );
+            length_type dist;
                    
             structure++;
             for(size_type i = 2; i < size; i++)
             {
-                pos_transposed = cyclic_transpose( pos, (*structure)->structure_position(), world_size );
-                distance = (*structure)->distance( pos_transposed );
+                cyc_pos = cyclic_transpose(pos, (*structure)->structure_position(), world_size);                
+                dist = (*structure)->projected_point_on_surface( cyc_pos ).second;
                 
-                if( distance < ret_distance )
+                if( dist < ret_dist )
                 {
-                    ret_distance = distance;
+                    ret_dist = dist;
                     ret_structure = structure;
                 }
                 structure++;
             }
         
-            return structure_id_and_distance_pair( (*ret_structure)->id() , ret_distance );
+            return structure_id_and_distance_pair( (*ret_structure)->id() , ret_dist );
         }
         
         }
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index d96b9c7b..5d9bc927 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -87,62 +87,10 @@ class newBDPropagator
         queue_.pop_back();
         particle_id_pair pp(tx_.get_particle(pid));
 
-        //LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
-
-
-
-        /* START SOME SAMPLES, after which we return. 
-        position_pair_type pp01;
-        position_pair_type new_pp01;
-        
-        species_type const sp(tx_.get_species(pp.second.sid()));
-        boost::shared_ptr<structure_type> const pp_struct( tx_.get_structure( sp.structure_id() ) );
-        
-        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
-
-        typename boost::range_const_iterator<reaction_rules>::type i(boost::begin(rules));
-        reaction_rule_type const& r(*i);
-        
-        typename reaction_rule_type::species_id_range products(r.get_products());
-        
-        species_type s0(tx_.get_species(products[0])), s1(tx_.get_species(products[1]));
-              
-        length_type r01( s0.radius() + s1.radius() );
-              
-        if(s0.structure_id() == "world")    
-            std::swap(s0,s1);
-
-        for(int i = 0; i < 2000; i++)
-        {
-            pp01 = pp_struct->
-                special_geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ ); 
-            
-            pp01.first = tx_.apply_boundary( pp01.first );
-            pp01.second = tx_.apply_boundary( pp01.second );
-            
-            if( tx_.distance(pp01.first, pp01.second) - r01 < 0 )
-                std::cerr << "Diss pp dist < 0 error" << std::endl;
-                
-            if( tx_.distance( pp_struct->projected_point( pp01.second ).first, pp01.second) - s1.radius() < 0 )
-                std::cerr << "Diss sp dist < 0 error" << std::endl;
-                                
-            new_pp01 = make_pair_move(s0, s1, pp01, pp.first);           
-             
-            std::cout << new_pp01.first[0] << " " << new_pp01.first[1] << " " << new_pp01.first[2] << " " 
-                      << new_pp01.second[0] << " " << new_pp01.second[1] << " " << new_pp01.second[2] << std::endl;
-                      
-            if(tx_.distance(new_pp01.first, new_pp01.second) - r01 < 0)
-                std::cerr << "Move pp dist < 0 error" << std::endl;
-                
-            if(tx_.distance(pp_struct->projected_point( new_pp01.second ).first, new_pp01.second) - s1.radius() < 0)
-                std::cerr << "Move sp dist < 0 error" << std::endl;
-        }     
-                  
-        return false;  
-        */
+        LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
         
         /* Consider decay reactions first. Particles can move after decay, but this is done
-           inside the 'attempt_reaction' function; for this particle can only react once . */
+           inside the 'attempt_reaction' function. */
         try
         {
             if (attempt_reaction(pp))
@@ -155,9 +103,9 @@ class newBDPropagator
             return true;
         }
         
-        species_type const species(tx_.get_species(pp.second.sid()));
-        length_type const r0( species.radius() );
-        boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( species.structure_id() ) );
+        species_type const pp_species(tx_.get_species(pp.second.sid()));
+        length_type const r0( pp_species.radius() );
+        boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( pp_species.structure_id() ) );
         
         structure_id_and_distance_pair struct_id_distance_pair;
         length_type core_surface_distance = 0;
@@ -166,15 +114,13 @@ class newBDPropagator
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particlem bounces, and is returned
            to it's original position. For a particle with D = 0, new_pos = old_pos */        
-        if (species.D() != 0.)
+        if (pp_species.D() != 0.)
         {
-
             // Make a step, dependent on the surface the particle lives on.
             position_type const displacement( pp_structure->
-                                            bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
+                                            bd_displacement(pp_species.v() * dt_, std::sqrt(2.0 * pp_species.D() * dt_), rng_) );
 
             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
-            
         }
         else
         {
@@ -217,9 +163,12 @@ class newBDPropagator
             overlapped.swap( overlapped_after_bounce );
                                             
             particles_in_overlap = overlapped ? overlapped->size(): 0; 
-                
-            struct_id_distance_pair = tx_.get_closest_surface( new_pos );
-            core_surface_distance = struct_id_distance_pair.second - r0;  
+            
+            if(pp_structure->id() == "world")
+            {
+                struct_id_distance_pair = tx_.get_closest_surface( new_pos );
+                core_surface_distance = struct_id_distance_pair.second - r0;  
+            }
         }
         
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
@@ -227,19 +176,30 @@ class newBDPropagator
         Real accumulated_prob = 0;
         Real const rnd( rng_() );
         
-        /* First, if a surface is near, attempt an interaction.  */
+        /* First, if a surface is near, attempt an interaction. */
         if(core_surface_distance < reaction_length_ && pp_structure->id() == "world")
-        {
+        {        
             boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure(struct_id_distance_pair.first) );
-            accumulated_prob += accumulated_reaction_probability( pp.second.sid(), closest_surf->sid() );
+            
+            accumulated_prob += k_tot( pp.second.sid(), closest_surf->sid() ) * dt_ / 
+                closest_surf->surface_reaction_volume( r0, reaction_length_ );
         
-            if( accumulated_prob > rnd )
+            if(accumulated_prob >= 1.)
             {
+                LOG_WARNING((
+                    "The accumulated acceptance probability for a reaction volume exeeded one; %f.",
+                    accumulated_prob));
+            } 
+        
+            if( accumulated_prob > rnd )
+            {            
                 try
                 {
-                    LOG_DEBUG(("fire interaction"));
+                    LOG_DEBUG(("fire surface interaction"));
                     if(fire_interaction(pp, closest_surf ))
-                        return true;                                 
+                        return true;
+                    else
+                        std::cerr << "zou niet moeten gebeuren (surf)" << std::endl;
                 }   
                 catch (propagation_error const& reason)
                 {
@@ -255,21 +215,35 @@ class newBDPropagator
             }
         }
         
-        /* Now attempt reaction with all particles inside the reaction volume. */
+        /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
         while(j < particles_in_overlap)
         {
             particle_id_pair_and_distance const& closest( overlapped->at(j) );
+
+            species_type s0(pp_species),s1(tx_.get_species(closest.first.second.sid()));
+                
+            /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
+               and we let this be s1, the particle from the surface is named s0. */
+            if(s0.structure_id() != s1.structure_id())
+            {
+                if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
+                    throw not_implemented("No surface -> surface + surface - reactions allowed");
+                
+                if(s0.structure_id() == "world")
+                    std::swap(s0,s1);
+            }
             
-            accumulated_prob += accumulated_reaction_probability( pp.second.sid(), closest.first.second.sid() );
+            boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
+            const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
+            accumulated_prob += k_tot(s0.id(), s1.id() ) * dt_ / ( 2 * reaction_volume ); 
             
             if (accumulated_prob >= 1.)
             {
-                throw propagation_error(
-                    "the accumulated acceptance probability for a reaction volume exeeded one; "
-                    + boost::lexical_cast<std::string>(accumulated_prob)
-                    + ".");
-            }   
+                LOG_WARNING((
+                    "the accumulated acceptance probability for a reaction volume exeeded one; %f.",
+                    accumulated_prob));
+            } 
             
             if(accumulated_prob > rnd)
             {
@@ -278,6 +252,8 @@ class newBDPropagator
                 {
                     if( fire_reaction(pp, closest.first) )
                         return true;
+                    else
+                        std::cerr << "zou niet moeten gebeuren (pp)" << std::endl;
                 }
                 catch (propagation_error const& reason)
                 {
@@ -299,7 +275,7 @@ class newBDPropagator
         if(!bounced)
         {   
             particle_id_pair particle_to_update( pp.first, 
-                        particle_type(species.id(), particle_shape_type(new_pos, r0), species.D()) );
+                        particle_type(pp_species.id(), particle_shape_type(new_pos, r0), pp_species.D()) );
                 
             if (vc_)
             {
@@ -518,55 +494,24 @@ class newBDPropagator
         }
         return false;
     }
-    
-    
-     /* Function returns the accumulated acceptance probability of the two reacting particles. */
-    Real accumulated_reaction_probability(species_id_type const& sid0, species_id_type const& sid1)
-    {
-        reaction_rules const& rules(rules_.query_reaction_rule(sid0, sid1));
+        
+    /* Function returns the accumulated intrinsic reaction rate. */
+    Real k_tot(species_id_type const& s0_id, species_id_type const& s1_id)
+    {   
+        reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
         if (::size(rules) == 0)
         {
             return 0;
         }
 
-        species_type s0(tx_.get_species(sid0)),
-                s1(tx_.get_species(sid1));
-        
-        /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
-           and we let this be s1, the particle from the surface is named s0. */     
-        if(s0.structure_id() != s1.structure_id())
-        {
-            if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
-                throw not_implemented("No surface -> surface + surface - reactions allowed");
-                
-            if(s0.structure_id() == "world")
-                std::swap(s0,s1);
-        }
-
         Real k_tot = 0;
-
-        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
-        const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
-        
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
             k_tot += (*i).k();
         }
         
-        Real const accumulated_prob( k_tot * dt_ / (2 * reaction_volume) );
-        
-        if (accumulated_prob >= 1.)
-        {
-            throw propagation_error(
-               "invalid accumulated probability calculated ("
-               + boost::lexical_cast<std::string>(accumulated_prob)
-               + ") for the total reaction rate is "
-               + boost::lexical_cast<std::string>(k_tot)
-               + ".");
-        }        
-        
-        return accumulated_prob;
+        return k_tot;
     }
     
     
@@ -579,26 +524,9 @@ class newBDPropagator
         species_type s0(tx_.get_species(pp0.second.sid())),
                 s1(tx_.get_species(pp1.second.sid()));
         
-        /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
-           and we let this be s1, the particle from the surface is named s0. */     
-        if(s0.structure_id() != s1.structure_id())
-        {
-            if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
-                throw not_implemented("No surface -> surface + surface - reactions allowed");
-                
-            if(s0.structure_id() == "world")
-                std::swap(s0,s1);
-        }
-
-        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
+        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
         
-        Real k_tot = 0;
-        for (typename boost::range_const_iterator<reaction_rules>::type
-                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
-        {
-            k_tot += (*i).k();            
-        }
-
+        const Real k_tot( k_tot(s0.sid(), s1.sid()) );
         const Real rnd( k_tot * rng_() );
         Real prob = 0;    
         
@@ -702,17 +630,8 @@ class newBDPropagator
         const species_type s0(tx_.get_species(pp.second.sid()));
         
         boost::shared_ptr<structure_type> pp_structure( tx_.get_structure( s0.structure_id() ) ); 
-
-        if(pp_structure->id() != "world")
-            throw not_implemented("only particles living in the bulk are allowed to interact with surfaces");
         
-        Real k_tot = 0;
-        for (typename boost::range_const_iterator<reaction_rules>::type
-                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
-        {
-            k_tot += (*i).k();            
-        }
-
+        const Real k_tot( k_tot(s0.sid(), s1.sid()) );
         const Real rnd( k_tot * rng_() );
         Real prob = 0;  
 

From ef756ecbb5aa8520466db77ff00843b51b4121f9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 31 Oct 2011 14:40:34 +0100
Subject: [PATCH 0314/1541] finished first version of laurens' algorithm

---
 pair.py | 85 +++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 62 insertions(+), 23 deletions(-)

diff --git a/pair.py b/pair.py
index cdbdaf35..1566f47d 100644
--- a/pair.py
+++ b/pair.py
@@ -771,38 +771,54 @@ def get_min_shell_dimensions(single1, single2, reference_point, geometrycontaine
     def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer, domains):
         # Properties of the MixedPair system
 
+        world = geometrycontainer.world
+        r, z_left, z_right = MixedPair.laurens_algorithm(single1, single2, r0, shell_position, shell_size, reference_point,
+                                                         orientation_vector, r, z_left, z_right, surface, world)
 
 
-
-        return dr, dz_left, dz_right
+        return r, z_left, z_right
 
     @staticmethod
-    def laurens_algorithm(shell_position, shell_size, reference_point,
-                          orientation_vector, dr, dz_left, dz_right, surface)
+    def laurens_algorithm(single1, single2, r0, shell_position, shell_size, reference_point,
+                          orientation_vector, r, z_left, z_right, surface, world)
 
         # determine on what side the midpoint of the shell is relative to the reference_point
-        # TODO do cyclic_transpose of shell_position
-        direction = math.dot(shell_position-reference_point, orientation_vector)
+        shell_position_t = world.cyclic_transpose (shell_position, reference_point)
+        direction = math.dot(shell_position_t - reference_point, orientation_vector)
 
         # if the shell is on the side of orientation_vector -> use z_right
         # also use this one if the shell is in plane with the reference_point
         if direction >= 0:
             phi = MixedPair.calc_right_scalingangle(D1, D2)
-            h0 = MixedPair.z_right(single1, single2, r0, 0.0)   # r = 0.0
+            scalecenter_h0 = MixedPair.z_right(single1, single2, r0, 0.0)   # r = 0.0
+            r1_function =  MixedPair.r_right
+            z1_function = MixedPair.z_right
+            z2_function = MixedPair.z_left
+            z1 = z_right
+            z2 = z_left
         # else -> use z_left
         else:
             phi = MixedPair.calc_left_scalingangle(D1, D2)
-            h0 = MixedPair.z_left(single1, single2, r0, 0.0)    # r = 0.0
+            scalecenter_h0 = MixedPair.z_left(single1, single2, r0, 0.0)    # r = 0.0
+            r1_function =  MixedPair.r_left
+            z1_function = MixedPair.z_left
+            z2_function = MixedPair.z_right
+            z1 = z_left
+            z2 = z_right
 
         # calculate the center from which linear scaling will take place
         # TODO this should be generalized to accomodate scaling in just z
-        scale_center = h0 * (direction/abs(direction)) * orientation_vector
+        if phi == 0.0:
+            scalecenter_r0 = r
+        else:
+            scalecenter_r0 = 0
+        scale_center = scale_center_h0 * (direction/abs(direction)) * orientation_vector
 
         # calculate the vector from the scale center to the center of the shell
-        # TODO cyclic transpose of shell_position
-        shell_scale_center = shell_position-scale_center
-        shell_scalecenter_z = 
-        shell_scalecenter_r =
+        shell_position_t = world.cyclic_transpose (shell_position, scale_center)
+        shell_scale_center = shell_position_t - scale_center
+        shell_scalecenter_z = math.dot( shell_scale_center, orientation_vector * (direction/abs(direction)) )
+        shell_scalecenter_r = shell_scale_center - shell_scalecenter_z
         # calculate the angle theta of the vector from the scale center to the shell with the vector
         # to the scale center (which is +- the orientation_vector)
         theta = vector_angle (shell_scale_center, scale_center)
@@ -814,7 +830,7 @@ def laurens_algorithm(shell_position, shell_size, reference_point,
         # The shell can hit the cylinder on the flat side (situation 1),
         #                                on the edge (situation 2),
         #                                or on the round side (situation 3).
-        # I think this works for phi == 0 and phi == Pi/2
+        # I think this also works for phi == 0 and phi == Pi/2
         if psi <= -phi:
         # The midpoint of the shell lies on the axis of the cylinder
             situation = 1
@@ -849,11 +865,13 @@ def laurens_algorithm(shell_position, shell_size, reference_point,
         # Don't know how we would get here, but it shouldn't happen
             raise RuntimeError('psi was not in valid range')
 
-        # TODO fix the situation where r and z are actually independent
+
         ### Get the right values for z and r for the given situation
         if situation == 1:      # shell hits on the flat side
-            z = shell_scalecenter_z + h0 - a_shell
-            r = MixedPair.r(z)
+            z1_new = min(z1, shell_scalecenter_z + scalecenter_h0 - a_shell)
+            r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
+            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+
         elif situation == 2:    # shell hits on the edge
             a_sq = shell_size*shell_size
             shell_scalecenter_len = length(shell_scalecenter)
@@ -861,16 +879,32 @@ def laurens_algorithm(shell_position, shell_size, reference_point,
             sin_phi = math.sin(phi)
             sin_psi = math.sin(psi)
             cos_psi = math.cos(psi)
+            scalecenter_shell_dist = (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
+
+            if phi <= Pi/4:
+                z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
+                r_new  = min(r, r1_function(single1, single2, r0, z1_new))
+                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+            else:
+                r_new = min(r, scalecenter_r0 + sin_phi * scalecenter_shell_dist)
+                z1_new = min(z1, z1_function(single1, single2, r0, r_new))
+                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
-            r = sin_phi * (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
-            z = MixedPair.z_right(r)
         elif situation == 3:    # shell hits on the round side
-            r = shell_scalecenter_r - a_shell
-            z = MixedPair.z_right(r)
+            r_new = min(r, shell_scalecenter_r - a_shell)
+            z1_new = min(z1, z1_function(single1, single2, r0, r_new))
+            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
         else:
             raise RuntimeError('Bad situation for MixedPair shell making')
 
-        
+        # switch the z values in case it's necessary. r doesn't have to be switched.
+        r = r_new
+        if direction >= 0.0:
+            z_right = z1_new
+            z_left  = z2_new
+        else:
+            z_right = z2_new
+            z_left  = z1_new
 
         return r, z_right, z_left
 
@@ -902,7 +936,7 @@ def z_left(single1, single2, r0, r):
         return single1.pid_particle_pair[1].radius
 
     @staticmethod
-    def r(single1, single2, r0, z_right):
+    def r_right(single1, single2, r0, z_right):
         # if the z_right is known and we want to know the radius r
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
@@ -926,6 +960,11 @@ def r(single1, single2, r0, z_right):
         r = a_R + iv_max
         return r
 
+    @staticmethod
+    def r_left(single1, single2, r0, z_left):
+        # FIXME this should return the maximum of the shell container
+        return numpy.inf
+
     @staticmethod
     def calc_right_scalingangle(D1, D2):
         D_r = D1 + D2

From c35c534d9be9ec47779cf5e2d1027669f680514f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 31 Oct 2011 16:57:30 +0100
Subject: [PATCH 0315/1541] implemented the MixedPair.get_max_shell_dimensions
 method

---
 pair.py | 96 ++++++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 75 insertions(+), 21 deletions(-)

diff --git a/pair.py b/pair.py
index 1566f47d..f2fad94f 100644
--- a/pair.py
+++ b/pair.py
@@ -771,16 +771,60 @@ def get_min_shell_dimensions(single1, single2, reference_point, geometrycontaine
     def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer, domains):
         # Properties of the MixedPair system
 
+        com, iv = MixedPair.do_transform(single1, single2, geometrycontainer.world)
+        reference_point = com
+        orientation_vector = normalize(single1.structure.shape.unit_z * numpy.dot (iv, single1.structure.shape.unit_z))
+        r0 = length(iv)
+
+        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
+        # doesn't allow to check for shells outside the maximal sphere.
+        max_cylinder_radius      = geometrycontainer.get_max_shell_size()/math.sqrt(2)
+        max_cylinder_half_length = max_cylinder_radius
+
+        # set initial values of shell dimensions
+        z_left = single1.pid_particle_pair[1].radius
+        z_right = max_cylinder_half_length * 2 - z_left
+        r = max_cylinder_radius
+        
+        # get all the domains in the neighborhood
+        search_point = reference_point + ((z_right - z_left)/2.0) * orientation_vector
+        all_neighbor_ids = \
+            geometrycontainer.get_neighbors_within_radius_no_sort(search_point,
+                                                     geometrycontainer.get_max_shell_size(),
+                                                     ignore=[single1.domain_id, single2.domain_id])
+        all_neighbors = [domains[domain_id] for domain_id in all_neighbor_ids]
+
         world = geometrycontainer.world
-        r, z_left, z_right = MixedPair.laurens_algorithm(single1, single2, r0, shell_position, shell_size, reference_point,
-                                                         orientation_vector, r, z_left, z_right, surface, world)
+
+        # adjust the maximal shell dimensions for every shell in the neighborhood
+        for domain in all_neighbors:
+            if isinstance(domain, Multi):
+                for _, shell in domain.shell_list:
+                    shell_position = shell.shape.position
+                    shell_size = shell.shape.radius
+                    r, z_left, z_right = MixedPair.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
+                                                                     reference_point, orientation_vector, r, z_left,
+                                                                     z_right, world)
+            else:
+                shell_position = domain.shell.shape.position
+                shell_size = domain.get_shell_size()
+
+                if domain.dt == 0.0 and domain.getD() > 0:
+                    # This is one of the bursted singles.
+                    # Or a particle that just escaped it's multi.
+                    shell_size *= Domain.SINGLE_SHELL_FACTOR
+
+                r, z_left, z_right = MixedPair.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
+                                                                 reference_point, orientation_vector, r, z_left,
+                                                                 z_right, world)
+
 
 
         return r, z_left, z_right
 
     @staticmethod
     def laurens_algorithm(single1, single2, r0, shell_position, shell_size, reference_point,
-                          orientation_vector, r, z_left, z_right, surface, world)
+                          orientation_vector, r, z_left, z_right, world):
 
         # determine on what side the midpoint of the shell is relative to the reference_point
         shell_position_t = world.cyclic_transpose (shell_position, reference_point)
@@ -808,10 +852,12 @@ def laurens_algorithm(single1, single2, r0, shell_position, shell_size, referenc
 
         # calculate the center from which linear scaling will take place
         # TODO this should be generalized to accomodate scaling in just z
+        # TODO Also the scale center is still strangly defined.
         if phi == 0.0:
-            scalecenter_r0 = r
-        else:
+            scalecenter_r0 = r  # This is an approximation, since the h0 is infinitely far away of phi == 0,
+        else:                   # we introduce an r0
             scalecenter_r0 = 0
+        # TODO check this
         scale_center = scale_center_h0 * (direction/abs(direction)) * orientation_vector
 
         # calculate the vector from the scale center to the center of the shell
@@ -908,6 +954,18 @@ def laurens_algorithm(single1, single2, r0, shell_position, shell_size, referenc
 
         return r, z_right, z_left
 
+    ### class methods that are for the right side of the cylindrical shell
+    @staticmethod
+    def calc_right_scalingangle(D1, D2):
+        D_r = D1 + D2
+        D_R = (D1*D2)/(D1 + D2)
+
+        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+
+        angle = math.atan( ( z_scaling_factor * ( math.sqrt( (2*D_R)/(3*D_r) ) + \
+                                                      max( D1/D_r, D2/D_r )
+                                                    )))
+        return angle
 
     @staticmethod
     def z_right(single1, single2, r0, r):
@@ -931,10 +989,6 @@ def z_right(single1, single2, r0, r):
 
         return z_right
 
-    @staticmethod
-    def z_left(single1, single2, r0, r):
-        return single1.pid_particle_pair[1].radius
-
     @staticmethod
     def r_right(single1, single2, r0, z_right):
         # if the z_right is known and we want to know the radius r
@@ -960,28 +1014,28 @@ def r_right(single1, single2, r0, z_right):
         r = a_R + iv_max
         return r
 
+    ### class methods for the left side of the cylindrical shell
     @staticmethod
-    def r_left(single1, single2, r0, z_left):
-        # FIXME this should return the maximum of the shell container
-        return numpy.inf
+    def calc_left_scalingangle(D1, D2):
+        return Pi/2
 
     @staticmethod
-    def calc_right_scalingangle(D1, D2):
-        D_r = D1 + D2
-        D_R = (D1*D2)/(D1 + D2)
+    def z_left(single1, single2, r0, r):
+        return single1.pid_particle_pair[1].radius
 
-        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+    @staticmethod
+    def r_left(single1, single2, r0, z_left):
+        # FIXME this should return the maximum of the shell container
+        return numpy.inf
 
-        angle = math.atan( ( z_scaling_factor * ( math.sqrt( (2*D_R)/(3*D_r) ) + \
-                                                      max( D1/D_r, D2/D_r )
-                                                    )))
-        return angle
 
+    ### class methods that are general
     @staticmethod
     def calc_z_scaling_factor(D2d, D3d):
         # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
         return math.sqrt( (D2d + D3d) / D3d)
 
+    ################
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
                  shell_half_length, shell_orientation_vector, 
@@ -1049,7 +1103,7 @@ def do_transform(single1, single2, world):
 
 
         # the CoM is calculated in a similar way to a normal 3D pair
-        com = (D_2 * pos1 + D_1 * pos) / (D_1 + D_2)
+        com = (D_2 * pos1 + D_1 * pos2) / (D_1 + D_2)
         # and then projected onto the plane
         com = world.cyclic_transpose(com, surface.shape.position)
         com, _ = surface.projected_point (com)

From 396f414f9fa3e9d5fa3ab0ee0387f1d0f039cb71 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 31 Oct 2011 17:46:35 +0100
Subject: [PATCH 0316/1541] changed staticmethods to classmethods in MixedPair

---
 pair.py | 88 ++++++++++++++++++++++++++++-----------------------------
 1 file changed, 44 insertions(+), 44 deletions(-)

diff --git a/pair.py b/pair.py
index f2fad94f..2de58d87 100644
--- a/pair.py
+++ b/pair.py
@@ -184,8 +184,8 @@ def __str__(self):
 
 class SimplePair(Pair):
 
-    @staticmethod
-    def get_min_shell_size(single1, single2, geometrycontainer):
+    @classmethod
+    def get_min_shell_size(cls, single1, single2, geometrycontainer):
         # 1. Determine min shell size for a putative SimplePair.
         # TODO Note that the calculation is dimension independent. Also
         # 'size' is not the right term here
@@ -224,8 +224,8 @@ def get_min_shell_size(single1, single2, geometrycontainer):
         return shell_size
 
 
-    @staticmethod
-    def get_max_shell_size(shell_center, single1, single2, geometrycontainer, domains):
+    @classmethod
+    def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, domains):
         # returns the maximum shell size based on geometric constraints
         # It makes sure that surrounding NonInteractionSingles have at least the
         # 'bursting volume' of space.
@@ -317,8 +317,8 @@ def get_com(self):
         return self.shell.shape.position
     com = property(get_com)
 
-    @staticmethod
-    def do_transform(single1, single2, world):
+    @classmethod
+    def do_transform(cls, single1, single2, world):
 
         pos1 = single1.pid_particle_pair[1].position
         pos2 = single2.pid_particle_pair[1].position
@@ -724,8 +724,8 @@ def __str__(self):
 
 class MixedPair(Pair):
 
-    @staticmethod
-    def get_min_shell_dimensions(single1, single2, reference_point, geometrycontainer):
+    @classmethod
+    def get_min_shell_dimensions(cls, single1, single2, reference_point, geometrycontainer):
 
         assert isinstance (single1.structure, PlanarSurface)
         assert isinstance (single2.structure, CuboidalRegion)
@@ -767,11 +767,11 @@ def get_min_shell_dimensions(single1, single2, reference_point, geometrycontaine
 
         return dr, dz_left, dz_right
 
-    @staticmethod
-    def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer, domains):
+    @classmethod
+    def get_max_shell_dimensions(cls, shell_center, single1, single2, geometrycontainer, domains):
         # Properties of the MixedPair system
 
-        com, iv = MixedPair.do_transform(single1, single2, geometrycontainer.world)
+        com, iv = cls.do_transform(single1, single2, geometrycontainer.world)
         reference_point = com
         orientation_vector = normalize(single1.structure.shape.unit_z * numpy.dot (iv, single1.structure.shape.unit_z))
         r0 = length(iv)
@@ -802,7 +802,7 @@ def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer,
                 for _, shell in domain.shell_list:
                     shell_position = shell.shape.position
                     shell_size = shell.shape.radius
-                    r, z_left, z_right = MixedPair.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
+                    r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
                                                                      reference_point, orientation_vector, r, z_left,
                                                                      z_right, world)
             else:
@@ -814,7 +814,7 @@ def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer,
                     # Or a particle that just escaped it's multi.
                     shell_size *= Domain.SINGLE_SHELL_FACTOR
 
-                r, z_left, z_right = MixedPair.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
+                r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
                                                                  reference_point, orientation_vector, r, z_left,
                                                                  z_right, world)
 
@@ -822,8 +822,8 @@ def get_max_shell_dimensions(shell_center, single1, single2, geometrycontainer,
 
         return r, z_left, z_right
 
-    @staticmethod
-    def laurens_algorithm(single1, single2, r0, shell_position, shell_size, reference_point,
+    @classmethod
+    def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, reference_point,
                           orientation_vector, r, z_left, z_right, world):
 
         # determine on what side the midpoint of the shell is relative to the reference_point
@@ -833,20 +833,20 @@ def laurens_algorithm(single1, single2, r0, shell_position, shell_size, referenc
         # if the shell is on the side of orientation_vector -> use z_right
         # also use this one if the shell is in plane with the reference_point
         if direction >= 0:
-            phi = MixedPair.calc_right_scalingangle(D1, D2)
-            scalecenter_h0 = MixedPair.z_right(single1, single2, r0, 0.0)   # r = 0.0
-            r1_function =  MixedPair.r_right
-            z1_function = MixedPair.z_right
-            z2_function = MixedPair.z_left
+            phi = cls.calc_right_scalingangle(D1, D2)
+            scalecenter_h0 = cls.z_right(single1, single2, r0, 0.0)   # r = 0.0
+            r1_function =  cls.r_right
+            z1_function = cls.z_right
+            z2_function = cls.z_left
             z1 = z_right
             z2 = z_left
         # else -> use z_left
         else:
-            phi = MixedPair.calc_left_scalingangle(D1, D2)
-            scalecenter_h0 = MixedPair.z_left(single1, single2, r0, 0.0)    # r = 0.0
-            r1_function =  MixedPair.r_left
-            z1_function = MixedPair.z_left
-            z2_function = MixedPair.z_right
+            phi = cls.calc_left_scalingangle(D1, D2)
+            scalecenter_h0 = cls.z_left(single1, single2, r0, 0.0)    # r = 0.0
+            r1_function =  cls.r_left
+            z1_function = cls.z_left
+            z2_function = cls.z_right
             z1 = z_left
             z2 = z_right
 
@@ -955,20 +955,20 @@ def laurens_algorithm(single1, single2, r0, shell_position, shell_size, referenc
         return r, z_right, z_left
 
     ### class methods that are for the right side of the cylindrical shell
-    @staticmethod
-    def calc_right_scalingangle(D1, D2):
+    @classmethod
+    def calc_right_scalingangle(cls, D1, D2):
         D_r = D1 + D2
         D_R = (D1*D2)/(D1 + D2)
 
-        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
 
         angle = math.atan( ( z_scaling_factor * ( math.sqrt( (2*D_R)/(3*D_r) ) + \
                                                       max( D1/D_r, D2/D_r )
                                                     )))
         return angle
 
-    @staticmethod
-    def z_right(single1, single2, r0, r):
+    @classmethod
+    def z_right(cls, single1, single2, r0, r):
         # if the radius is known and we want to determine the height z_right
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
@@ -984,13 +984,13 @@ def z_right(single1, single2, r0, r):
         # take the smallest that, if entered in the function for r below, would lead to this z_right
         a_r = min (a_r1, a_r2)
 
-        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
         z_right = (a_r/z_scaling_factor) + (2*radius2)
 
         return z_right
 
-    @staticmethod
-    def r_right(single1, single2, r0, z_right):
+    @classmethod
+    def r_right(cls, single1, single2, r0, z_right):
         # if the z_right is known and we want to know the radius r
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
@@ -1000,7 +1000,7 @@ def r_right(single1, single2, r0, z_right):
         D_R = (D1*D2)/(D1 + D2)
 
         # we first calculate the a_r, since it is the only radius that depends on z_right only.
-        z_scaling_factor = MixedPair.calc_z_scaling_factor(D1, D2)
+        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
         a_r = (z_right - (2*radius2)) * z_scaling_factor
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
@@ -1015,23 +1015,23 @@ def r_right(single1, single2, r0, z_right):
         return r
 
     ### class methods for the left side of the cylindrical shell
-    @staticmethod
-    def calc_left_scalingangle(D1, D2):
+    @classmethod
+    def calc_left_scalingangle(cls, D1, D2):
         return Pi/2
 
-    @staticmethod
-    def z_left(single1, single2, r0, r):
+    @classmethod
+    def z_left(cls, single1, single2, r0, r):
         return single1.pid_particle_pair[1].radius
 
-    @staticmethod
-    def r_left(single1, single2, r0, z_left):
+    @classmethod
+    def r_left(cls, single1, single2, r0, z_left):
         # FIXME this should return the maximum of the shell container
         return numpy.inf
 
 
     ### class methods that are general
-    @staticmethod
-    def calc_z_scaling_factor(D2d, D3d):
+    @classmethod
+    def calc_z_scaling_factor(cls, D2d, D3d):
         # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
         return math.sqrt( (D2d + D3d) / D3d)
 
@@ -1089,8 +1089,8 @@ def get_scaling_factor(self):
         return math.sqrt(self.D_r/D_2)
     z_scaling_factor = property(get_scaling_factor)
 
-    @staticmethod
-    def do_transform(single1, single2, world):
+    @classmethod
+    def do_transform(cls, single1, single2, world):
 
         pos1 = single1.pid_particle_pair[1].position
         pos2 = single2.pid_particle_pair[1].position

From d2a6e61834de00f84c41df6d926db4d935c14bc0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 12:20:04 +0100
Subject: [PATCH 0317/1541] started changing create_pair to facilitate
 MixedPair creation

---
 egfrd.py | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c968e85f..09055549 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -56,8 +56,8 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure)
                                    shell_id, rt, structure)
 
 
-def create_default_pair(domain_id, com, single1, single2, shell_id, 
-                        r0, shell_size, rrs, structure):
+def create_default_pair(domain_id, single1, single2, shell_id, com,
+                        shell_size, r0, rrs, structure):
     if isinstance(structure, CuboidalRegion):
         return SphericalPair(domain_id, com, single1, single2,
                              shell_id, r0, shell_size, rrs, structure)
@@ -445,7 +445,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
         return interaction
 
-    def create_pair(self, single1, single2, com, r0, shell_size):
+    def create_pair(self, single1, single2, shell_center, shell_radius, r0):
         assert single1.dt == 0.0
         assert single2.dt == 0.0
 
@@ -463,15 +463,22 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         # Get structure (region or surface) where particle1 lives (assuming particle2
         # also lives here -> TODO).
         species1 = self.world.get_species(pid_particle_pair1[1].sid)
-        structure = self.world.get_structure(species1.structure_id)
-
+        species2 = self.world.get_species(pid_particle_pair2[1].sid)
+        structure1 = self.world.get_structure(species1.structure_id)
+        structure2 = self.world.get_structure(species2.structure_id)
 
         # 2. Create pair. The type of the pair that will be created depends
         # on the structure (region or surface) the particles are in/on.  
-        # Either SphericalPair, PlanarSurfacePair, or 
-        # CylindricalSurfacePair.
-        pair = create_default_pair(domain_id, com, single1, single2, shell_id, 
-                                   r0, shell_size, rrs, structure)
+        if structure1 == structure2:
+            # Either SphericalPair, PlanarSurfacePair, or 
+            # CylindricalSurfacePair.
+            pair = create_default_pair(domain_id, single1, single2, shell_id, shell_center,
+                                       shell_radius, r0, rrs, structure)
+        else:
+            # MixedPair (3D/2D)
+            pair = MixedPair(domain_id, single1, single2, shell_id, shell_center, shell_radius,
+                             shell_half_length, shell_orientation_vector, r0, rrs)
+
 
         assert isinstance(pair, Pair)
         pair.initialize(self.t)
@@ -1961,7 +1968,7 @@ def try_pair(self, single1, single2):
 
         if shell_size:
             # A shell could be made and makes sense. Create a Pair
-            pair = self.create_pair(single1, single2, center, r0, shell_size)
+            pair = self.create_pair(single1, single2, center, shell_size, r0)
 
             pair.dt, pair.event_type, pair.reactingsingle = \
             pair.determine_next_event(r0)

From 5c257ce7da1f973f29da57226c30ce30fcb19955 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 12:21:10 +0100
Subject: [PATCH 0318/1541] MixedPair shell is now also created on MixedPair
 instantiation

---
 pair.py | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/pair.py b/pair.py
index 2de58d87..5570e3c6 100644
--- a/pair.py
+++ b/pair.py
@@ -450,7 +450,7 @@ def iv_greens_function(self, r0):
                                               self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):
-        return SphericalShell(self.domain_id, Sphere(position, radius))
+        return SphericalShell(domain_id, Sphere(position, radius))
 
     # selects between the full solution or an approximation where one of
     # the boundaries is ignored
@@ -1042,13 +1042,17 @@ def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_ra
                  unit_r, r0, rrs):
         Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
-        self.surface = surface  # the surface on which particle1 lives
-        self.r0 = r0    # TODO this needs to be rescaled too
+        self.surface = single1.structure    # the surface on which particle1 lives
+        self.r0 = r0                        # TODO this needs to be rescaled too
+
+        self.shell = self.create_new_shell (shell_center, shell_radius, shell_half_length, shell_orientation_vector,
+                                            domain_id)
 
     def determine_radii(self, half_length, radius):
         # determines the dimensions of the domains used for the Green's functions from the dimensions
         # of the cylindrical shell.
         # Note that the function assumes that the cylinder is dimensioned properly
+        # TODO use class methods to check dimensions of the cylinder
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
         D1 = self.pid_particle_pair1[1].D
@@ -1172,12 +1176,12 @@ def iv_greensfunction(self):
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, self.r0,
                                       self.sigma, self.a_r)
 
-    def create_new_shell(self, position, radius, orientation_vector, half_length):
+    def create_new_shell(self, position, radius, half_length, orientation_vector, domain_id):
         # It is assumed that the parameter are correct -> the 'bottom' of the cylinder
         # sticks through the membrane enough to accomodate the particle in the membrane
         # assert that orientation_vector is on same line as surface.shape.unit_z
-        return CylindricalShell(self.domain_id, Cylinder(position, radius, orientation_vector,
-                                                         half_length))
+        return CylindricalShell(domain_id, Cylinder(position, radius, orientation_vector,
+                                                    half_length))
 
     def create_com_vector(self, r):
         x, y = random_vector2D(r)

From b2d1c1083b08ca154870cfb20a40792fee399529 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 14:22:11 +0100
Subject: [PATCH 0319/1541] changed signature to create_pair + small typofix

---
 egfrd.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 09055549..f35bea04 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -445,7 +445,9 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
         return interaction
 
-    def create_pair(self, single1, single2, shell_center, shell_radius, r0):
+    def create_pair(self, single1, single2, shell_center, shell_radius, r0, shell_half_length=0,
+                    shell_orientation_vector=None):
+
         assert single1.dt == 0.0
         assert single2.dt == 0.0
 
@@ -473,9 +475,11 @@ def create_pair(self, single1, single2, shell_center, shell_radius, r0):
             # Either SphericalPair, PlanarSurfacePair, or 
             # CylindricalSurfacePair.
             pair = create_default_pair(domain_id, single1, single2, shell_id, shell_center,
-                                       shell_radius, r0, rrs, structure)
+                                       shell_radius, r0, rrs, structure1)
         else:
             # MixedPair (3D/2D)
+            assert shell_orientation_vector != None
+            assert shell_half_length != 0
             pair = MixedPair(domain_id, single1, single2, shell_id, shell_center, shell_radius,
                              shell_half_length, shell_orientation_vector, r0, rrs)
 

From 6b11b16352d476f8a0926ef3f10a3faeb1b54de7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 14:22:58 +0100
Subject: [PATCH 0320/1541] small changes to method signatures, removed unused
 parameters

---
 pair.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pair.py b/pair.py
index 5570e3c6..179adacd 100644
--- a/pair.py
+++ b/pair.py
@@ -725,7 +725,7 @@ def __str__(self):
 class MixedPair(Pair):
 
     @classmethod
-    def get_min_shell_dimensions(cls, single1, single2, reference_point, geometrycontainer):
+    def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
 
         assert isinstance (single1.structure, PlanarSurface)
         assert isinstance (single2.structure, CuboidalRegion)
@@ -768,7 +768,7 @@ def get_min_shell_dimensions(cls, single1, single2, reference_point, geometrycon
         return dr, dz_left, dz_right
 
     @classmethod
-    def get_max_shell_dimensions(cls, shell_center, single1, single2, geometrycontainer, domains):
+    def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
         # Properties of the MixedPair system
 
         com, iv = cls.do_transform(single1, single2, geometrycontainer.world)
@@ -1039,7 +1039,7 @@ def calc_z_scaling_factor(cls, D2d, D3d):
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
                  shell_half_length, shell_orientation_vector, 
-                 unit_r, r0, rrs):
+                 r0, rrs):
         Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
         self.surface = single1.structure    # the surface on which particle1 lives

From 116b2aa3df187ab4e84ff0879a87d0d96a6b0ab3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 14:44:47 +0100
Subject: [PATCH 0321/1541] cleaning up calculate_simple_pair_shell_size

---
 egfrd.py | 31 +++++++++++++------------------
 1 file changed, 13 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f35bea04..d4c17a7d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1238,24 +1238,8 @@ def calculate_simplepair_shell_size(self, single1, single2):
         assert single1.structure == single2.structure
 
         # 0. Get some necessary information
-        pos1 = single1.pid_particle_pair[1].position
-        pos2 = single2.pid_particle_pair[1].position
-
-        radius1 = single1.pid_particle_pair[1].radius
-        radius2 = single2.pid_particle_pair[1].radius
-        sigma = radius1 + radius2
-
-#        r0 = self.world.distance(pos1, pos2)
-
-#        D1 = single1.pid_particle_pair[1].D
-#        D2 = single2.pid_particle_pair[1].D
-#        D12 = D1 + D2
-
-#        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-#        com = self.world.apply_boundary(com)
         com, iv = SimplePair.do_transform(single1, single2, self.world)
         r0 = length (iv)
-        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
 
         # 1. Get the minimal possible shell size (including margin?)
         min_shell_size = SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
@@ -1265,6 +1249,10 @@ def calculate_simplepair_shell_size(self, single1, single2):
                                                        self.geometrycontainer, self.domains)
 
         # 3. Calculate the maximum based on some other criterium (convergence?)
+        radius1 = single1.pid_particle_pair[1].radius
+        radius2 = single2.pid_particle_pair[1].radius
+        sigma = radius1 + radius2
+        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
 #        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin                # FIXME
 #       max_shell_size = min(max_shell_size, convergence_max)
 
@@ -1281,7 +1269,12 @@ def calculate_simplepair_shell_size(self, single1, single2):
                            FORMAT_DOUBLE % max_shell_size))
             return None, None, None
 
-        # 5. Calculate the 'ideal' shell size
+        # 5. Calculate the 'ideal' shell size, it matches the expected first-passage time of the closest particle
+        # with the expected time of the particles in the pair.
+#        D1 = single1.pid_particle_pair[1].D
+#        D2 = single2.pid_particle_pair[1].D
+#        D12 = D1 + D2
+#
 #        D_closest = closest.pid_particle_pair[1].D
 #        D_tot = D_closest + D12
 #        ideal_shell_size = min((D12 / D_tot) *
@@ -1293,6 +1286,8 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
         # 6. Check if singles would not be better.
         # TODO clear this up -> strange rule
+        pos1 = single1.pid_particle_pair[1].position
+        pos2 = single2.pid_particle_pair[1].position
         d1 = self.world.distance(com, pos1)
         d2 = self.world.distance(com, pos2)
 
@@ -1312,7 +1307,7 @@ def calculate_simplepair_shell_size(self, single1, single2):
         assert shell_size <= max_shell_size
 
         if __debug__:
-            log.info('SimplePair shell made. shell_size=%s, '
+            log.info('SimplePair shell can be made. shell_size=%s, '
                      'closest_shell_distance=%s,\nclosest = %s' %
                      (FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % 0, None))
 

From 833d6d1077dc199604f52444d87f7be879726222 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 17:18:19 +0100
Subject: [PATCH 0322/1541] implemented MixedPair formation in egfrd algorithm
 implemented chosing between normal and mixedpair implemented getting the
 proper shell dimensions from the class methods

---
 egfrd.py | 99 ++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 85 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d4c17a7d..11149f94 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1314,6 +1314,45 @@ def calculate_simplepair_shell_size(self, single1, single2):
         return com, r0, shell_size
 
 
+
+    def calculate_mixedpair_shell_dimensions (self, single2D, single3D):
+
+
+        # 1. Get the minimal possible shell size (including margin?)
+        r_min, z_left_min, z_right_min = SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
+
+        # 2. Get the maximum possible shell size
+        r, z_left, z_right = SimplePair.get_max_shell_size(single1, single2, self.geometrycontainer, self.domains)
+
+        # Decide if MixedPair domain is possible.
+        if r < r_min or z_left < z_left_min or z_right < z_right_min:
+            if __debug__:
+                log.debug('        *MixedPair not possible:\n'
+                          '            %s +\n'
+                          '            %s.\n'
+                          '            r = %.3g. r_min = %.3g.\n'
+                          '            z_left = %.3g. z_left_min = %.3g.\n'
+                          '            z_right = %.3g. z_right_min = %.3g.' %
+                          (single2D, single3D, r, r_min, z_left, z_left_min, 
+                           z_right, z_right_min))
+            return None, None, None, None, None
+        else:
+
+            # Compute origin, radius and half_length of cylinder.
+            com, iv = MixedPair.do_transform(single2D, single3D, self.geometrycontainer.world)
+            reference_point = com
+            orientation_vector = normalize(single2D.structure.shape.unit_z * numpy.dot (iv, single2D.structure.shape.unit_z))
+            r0 = length(iv)
+
+            center = reference_point + ((z_right - z_left)/2.0) * orientation_vector
+            center = self.world.apply_boundary(center)
+            shell_half_length = (z_left + z_right) / 2.0
+            shell_radius = r
+
+            return center, shell_radius, shell_half_length, r0, orientation_vector
+
+
+
     def update_single(self, single): 
         assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
@@ -1774,6 +1813,7 @@ def try_interaction(self, single, surface):
         ### 2. The shell can be made. Now do what's necessary to make it
         # Compute origin, radius and half_length of cylinder.
         origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
+        origin = self.world.apply_boundary(origin)
         half_length = (dz_left + dz_right) / 2.0
         radius = dr
 
@@ -1943,31 +1983,62 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
 
     def try_pair(self, single1, single2):
         if __debug__:
-           log.debug('trying to form Pair(%s, %s)' %
-                     (single1.pid_particle_pair, single2.pid_particle_pair))
+            log.debug('trying to form Pair(%s, %s)' %
+                (single1.pid_particle_pair, single2.pid_particle_pair))
 
         assert single1.is_reset()
         assert single2.is_reset()
 
+
         # Try forming a Pair only if singles are on same structure.
-        if single1.structure != single2.structure:
-            # TODO implement shell making method for MixedPair
+        if single1.structure == single2.structure:
+            # particles are on the same structure
 
             if __debug__:
-                log.debug('Pair(%s, %s) not formed: not on same structure.' %
-                          (single1.pid_particle_pair[0],
-                           single2.pid_particle_pair[0]))
+                log.debug('Simple pair')
 
-            center, r0, shell_size = None, None, None
-#           shell = self.make_mixedpair_shell (single1, single2)
-        else:
-            # particles are on the same structure
             center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
+            if shell_size:
+                # A shell could be made and makes sense. Create a Pair
+                pair = self.create_pair(single1, single2, center, shell_size, r0)
+            else:
+                pair = None
+
+        elif isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion) ^ \
+             isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion):
+            # one particle in 2D, the other in 3D
+
+            if __debug__:
+                log.debug('Mixed pair')
+
+            # make sure that we know which single is on what structure
+            if isinstance (structure1, PlanarSurface):
+                single2D = single1
+                single3D = single2
+            else:
+                single2D = single2
+                single3D = single1
+
+            center, shell_radius, shell_half_length, r0, shell_orientation_vector = \
+            self.calculate_mixedpair_shell_dimensions (single2D, single3D)
+
+            if shell_radius:
+                pair = self.create_pair(single2D, single3D, center, shell_radius, r0,
+                                        shell_half_length, shell_orientation_vector)
+            else:
+                pair = None
+
+        else:
+            # a 1D/3D pair was supposed to be formed -> unsupported
+            if __debug__:
+                log.debug('Pair(%s, %s) not formed: combination of structures not supported.' %
+                          (single1.pid_particle_pair[0],
+                           single2.pid_particle_pair[0]))
+            pair = None
 
 
-        if shell_size:
-            # A shell could be made and makes sense. Create a Pair
-            pair = self.create_pair(single1, single2, center, shell_size, r0)
+        # if a pair has been formed
+        if pair:
 
             pair.dt, pair.event_type, pair.reactingsingle = \
             pair.determine_next_event(r0)

From 23c705819307e4a829903ee0cc83da28c2289367 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 18:28:49 +0100
Subject: [PATCH 0323/1541] fixed typos and added logging to MixedPair domain
 creation

---
 egfrd.py | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 11149f94..f8934314 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1319,10 +1319,10 @@ def calculate_mixedpair_shell_dimensions (self, single2D, single3D):
 
 
         # 1. Get the minimal possible shell size (including margin?)
-        r_min, z_left_min, z_right_min = SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
+        r_min, z_left_min, z_right_min = MixedPair.get_min_shell_dimensions(single2D, single3D, self.geometrycontainer)
 
         # 2. Get the maximum possible shell size
-        r, z_left, z_right = SimplePair.get_max_shell_size(single1, single2, self.geometrycontainer, self.domains)
+        r, z_left, z_right = MixedPair.get_max_shell_dimensions(single2D, single3D, self.geometrycontainer, self.domains)
 
         # Decide if MixedPair domain is possible.
         if r < r_min or z_left < z_left_min or z_right < z_right_min:
@@ -1994,25 +1994,26 @@ def try_pair(self, single1, single2):
         if single1.structure == single2.structure:
             # particles are on the same structure
 
-            if __debug__:
-                log.debug('Simple pair')
-
             center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
             if shell_size:
                 # A shell could be made and makes sense. Create a Pair
                 pair = self.create_pair(single1, single2, center, shell_size, r0)
+                if __debug__:
+                    log.debug('Simple pair: %s, shell_size = %.3g, r0 = %.3g' %
+                              (pair, shell_size, r0))
+
             else:
                 pair = None
 
-        elif isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion) ^ \
-             isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion):
+        elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)) ^ \
+             (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
             # one particle in 2D, the other in 3D
 
             if __debug__:
                 log.debug('Mixed pair')
 
             # make sure that we know which single is on what structure
-            if isinstance (structure1, PlanarSurface):
+            if isinstance (single1.structure, PlanarSurface):
                 single2D = single1
                 single3D = single2
             else:
@@ -2025,6 +2026,10 @@ def try_pair(self, single1, single2):
             if shell_radius:
                 pair = self.create_pair(single2D, single3D, center, shell_radius, r0,
                                         shell_half_length, shell_orientation_vector)
+                if __debug__:
+                    log.debug('Mixed pair: %s, shell_radius = %.3g, shell_half_length = %.3g, r0 = %.3g' %
+                              (pair, shell_radius, shell_half_length, r0))
+
             else:
                 pair = None
 
@@ -2057,9 +2062,7 @@ def try_pair(self, single1, single2):
             self.add_domain_event(pair)
 
             if __debug__:
-                log.info('%s,\ndt=%s, r0=%s, shell_size=%s, ' %
-                         (pair, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % r0, 
-                          FORMAT_DOUBLE % shell_size)) 
+                log.info('dt=%s' % (FORMAT_DOUBLE % pair.dt)) 
 
             return pair
         else:

From 281a0f2e250477ee47faf9a0bff1639814103e69 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 1 Nov 2011 18:29:45 +0100
Subject: [PATCH 0324/1541] Added dimensions check+adjustment of the shell for
 iv and com domains (determine_radii) Also fixed typos and added missing
 information to MixedPair.

---
 pair.py | 43 ++++++++++++++++++++++++++++++++++++-------
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/pair.py b/pair.py
index 179adacd..c2e0b6a3 100644
--- a/pair.py
+++ b/pair.py
@@ -129,8 +129,6 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         # If the two particles have reacted this returns the
         # new position twice
         # The positions are relative to the center of the shell
-        # TODO move this to SimplePair, this is not applicable to a MixedPair
-        # or make scaling factor in last line a parameter of the class
         new_com = self.shell.shape.position + self.draw_new_com(dt, event_type)
 
         if event_type == EventType.IV_REACTION:
@@ -771,6 +769,9 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
     def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
         # Properties of the MixedPair system
 
+        assert isinstance (single1.structure, PlanarSurface)
+        assert isinstance (single2.structure, CuboidalRegion)
+
         com, iv = cls.do_transform(single1, single2, geometrycontainer.world)
         reference_point = com
         orientation_vector = normalize(single1.structure.shape.unit_z * numpy.dot (iv, single1.structure.shape.unit_z))
@@ -1043,7 +1044,10 @@ def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_ra
         Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
         self.surface = single1.structure    # the surface on which particle1 lives
-        self.r0 = r0                        # TODO this needs to be rescaled too
+        self.structure = single1.structure    # the surface on which particle1 lives
+        self.r0 = r0
+
+        self.a_R, self.a_r = self.determine_radii(shell_half_length, shell_radius)
 
         self.shell = self.create_new_shell (shell_center, shell_radius, shell_half_length, shell_orientation_vector,
                                             domain_id)
@@ -1052,9 +1056,34 @@ def determine_radii(self, half_length, radius):
         # determines the dimensions of the domains used for the Green's functions from the dimensions
         # of the cylindrical shell.
         # Note that the function assumes that the cylinder is dimensioned properly
-        # TODO use class methods to check dimensions of the cylinder
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
+
+        # use class methods to check dimensions of the cylinder
+        # note that we assume that only the z_right is scalable
+        r_check = self.r_right (self.single1, self.single2, self.r0, half_length*2 - radius1)
+        hl2_check = self.z_right (self.single1, self.single2, self.r0, radius) + \
+                    self.z_left  (self.single1, self.single2, self.r0, radius)
+        if r_check > radius:
+            # radius should have been larger, adjust z_right instead
+            if __debug__:
+                log.debug('MixedPair: half_length was too high for radius:'
+                          'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
+                          (radius, r_check, half_length*2, hl2_check))
+
+            half_length = hl2_check/2
+
+        elif hl2_check > (half_length*2):
+            # half_length should have been larger, adjust radius instead
+            if __debug__:
+                log.debug('MixedPair: radius was too high for half_length:'
+                          'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
+                          (radius, r_check, half_length*2, hl2_check))
+            radius = r_check
+        else:
+            # dimensions were ok
+            pass
+
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
         D12 = D1 + D2
@@ -1167,13 +1196,13 @@ def get_sigma(self):
         return rho
     sigma = property (get_sigma)
 
-    def com_greensfunction(self):
+    def com_greens_function(self):
         # diffusion of the CoM of a mixed pair is only two dimensional
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
-    def iv_greensfunction(self):
+    def iv_greens_function(self, r0):
         # diffusion of the interparticle vector is three dimensional
-        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, self.r0,
+        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                       self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, half_length, orientation_vector, domain_id):

From cafce0a53dc5ec1add7b48a561bf7f595817ad7b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 2 Nov 2011 17:05:18 +0100
Subject: [PATCH 0325/1541] changed logging message when created a pair

---
 egfrd.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f8934314..2038f3b6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1999,7 +1999,7 @@ def try_pair(self, single1, single2):
                 # A shell could be made and makes sense. Create a Pair
                 pair = self.create_pair(single1, single2, center, shell_size, r0)
                 if __debug__:
-                    log.debug('Simple pair: %s, shell_size = %.3g, r0 = %.3g' %
+                    log.debug('Created: %s, shell_size = %.3g, r0 = %.3g' %
                               (pair, shell_size, r0))
 
             else:
@@ -2027,7 +2027,7 @@ def try_pair(self, single1, single2):
                 pair = self.create_pair(single2D, single3D, center, shell_radius, r0,
                                         shell_half_length, shell_orientation_vector)
                 if __debug__:
-                    log.debug('Mixed pair: %s, shell_radius = %.3g, shell_half_length = %.3g, r0 = %.3g' %
+                    log.debug('Created: %s, shell_radius = %.3g, shell_half_length = %.3g, r0 = %.3g' %
                               (pair, shell_radius, shell_half_length, r0))
 
             else:

From de15d162c963e8807c43017d945823352793b6c4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 2 Nov 2011 17:06:15 +0100
Subject: [PATCH 0326/1541] bugfixes for laurens' algorithm for shell making in
 MixedPair

---
 pair.py | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/pair.py b/pair.py
index c2e0b6a3..7585512b 100644
--- a/pair.py
+++ b/pair.py
@@ -827,9 +827,13 @@ def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
     def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, reference_point,
                           orientation_vector, r, z_left, z_right, world):
 
+        D1 = single1.pid_particle_pair[1].D
+        D2 = single2.pid_particle_pair[1].D
+
+
         # determine on what side the midpoint of the shell is relative to the reference_point
         shell_position_t = world.cyclic_transpose (shell_position, reference_point)
-        direction = math.dot(shell_position_t - reference_point, orientation_vector)
+        direction = numpy.dot(shell_position_t - reference_point, orientation_vector)
 
         # if the shell is on the side of orientation_vector -> use z_right
         # also use this one if the shell is in plane with the reference_point
@@ -841,6 +845,8 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             z2_function = cls.z_left
             z1 = z_right
             z2 = z_left
+            direction = 1           # improve direction specification such that following calculations still work
+                                    # Otherwise problems when direction = 0
         # else -> use z_left
         else:
             phi = cls.calc_left_scalingangle(D1, D2)
@@ -850,6 +856,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             z2_function = cls.z_right
             z1 = z_left
             z2 = z_right
+            direction = -1
 
         # calculate the center from which linear scaling will take place
         # TODO this should be generalized to accomodate scaling in just z
@@ -859,20 +866,19 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
         else:                   # we introduce an r0
             scalecenter_r0 = 0
         # TODO check this
-        scale_center = scale_center_h0 * (direction/abs(direction)) * orientation_vector
+        scale_center = scalecenter_h0 * direction * orientation_vector
 
         # calculate the vector from the scale center to the center of the shell
         shell_position_t = world.cyclic_transpose (shell_position, scale_center)
         shell_scale_center = shell_position_t - scale_center
-        shell_scalecenter_z = math.dot( shell_scale_center, orientation_vector * (direction/abs(direction)) )
-        shell_scalecenter_r = shell_scale_center - shell_scalecenter_z
+        shell_scalecenter_z = numpy.dot( shell_scale_center, orientation_vector * direction )
+        shell_scalecenter_r = length(shell_scale_center - shell_scalecenter_z)
         # calculate the angle theta of the vector from the scale center to the shell with the vector
         # to the scale center (which is +- the orientation_vector)
         theta = vector_angle (shell_scale_center, scale_center)
 
         psi = theta - phi
 
-
         ### check what situation arrises
         # The shell can hit the cylinder on the flat side (situation 1),
         #                                on the edge (situation 2),
@@ -910,12 +916,13 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
 
         else:
         # Don't know how we would get here, but it shouldn't happen
-            raise RuntimeError('psi was not in valid range')
+            raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
+                               (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
 
 
         ### Get the right values for z and r for the given situation
         if situation == 1:      # shell hits on the flat side
-            z1_new = min(z1, shell_scalecenter_z + scalecenter_h0 - a_shell)
+            z1_new = min(z1, shell_scalecenter_z + scalecenter_h0 - shell_size)
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
@@ -938,7 +945,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 3:    # shell hits on the round side
-            r_new = min(r, shell_scalecenter_r - a_shell)
+            r_new = min(r, shell_scalecenter_r - shell_size)
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
         else:

From 0c18637265bc5cb1244aa54a23b8fc631cc3bc46 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 3 Nov 2011 11:49:22 +0100
Subject: [PATCH 0327/1541] Starting with integrating newBD into multi domain.
 Changed 1D reaction volume 2S -> S (assumed particles does't 'see' cyclic
 boundary.

---
 BDSimulator.hpp        | 34 ++++++++++++++++++++++++++++++----
 CylindricalSurface.hpp |  4 ++--
 Multi.hpp              | 21 +++++++++++++++++++++
 Transaction.hpp        |  2 +-
 newBDPropagator.hpp    | 24 ++++++++++--------------
 5 files changed, 64 insertions(+), 21 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 717fe7e5..185026a7 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -29,6 +29,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     typedef typename traits_type::time_type time_type;  
     typedef typename traits_type::network_rules_type network_rules_type;
     typedef typename traits_type::reaction_rule_type reaction_rule_type;
+    typedef typename network_rules_type::reaction_rules reaction_rules;
     typedef typename traits_type::rate_type rate_type;
     typedef typename traits_type::reaction_record_type reaction_record_type;
     typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
@@ -50,7 +51,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
           reaction_length_factor_(reaction_length_factor)
     {
         calculate_dt();
-        reaction_length_ = determine_reaction_length( *world, base_type::dt_, reaction_length_factor_ );
+        reaction_length_ = determine_reaction_length( *world, base_type::dt_, reaction_length_factor_, *base_type::network_rules_);
         bound_time = 0;
     }
 
@@ -100,8 +101,30 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return gsl_pow_2(radius_min * 2) / (D_max * 2);
     }
     
-    static length_type determine_reaction_length(world_type const& world, time_type dt, length_type const& reaction_length_factor)
+    static length_type determine_reaction_length(world_type const& world, time_type dt, length_type const& reaction_length_factor,
+        network_rules_type const& rules)
     {
+        Real k_max(0.);
+
+        BOOST_FOREACH(species_type s0, world.get_species())
+        {
+            BOOST_FOREACH(species_type s1, world.get_species())
+            {
+                reaction_rules const& rrules(rules.query_reaction_rule( s0.id(), s1.id() ));
+                if (::size(rrules) == 0)
+                {
+                    break;
+                }
+                
+                for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rrules)), e(boost::end(rrules)); i != e; ++i)
+                {
+                    if ( k_max < (*i).k() )
+                        k_max = (*i).k();
+                }          
+            }
+        }
+    
         return reaction_length_factor * sqrt( 2 * 1E-12 * dt );
     }
     
@@ -110,13 +133,16 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return reaction_length_;    
     }
     
-    double set_reaction_length_factor(length_type new_reaction_length_factor)
+    double set_reaction_length_factor(length_type new_reaction_length_factor, time_type dt)
     {
         double old_bound_time = bound_time;
         bound_time = 0;
         
+        base_type::dt_ = dt;
+        
         reaction_length_factor_ = new_reaction_length_factor;
-        reaction_length_ = determine_reaction_length( *base_type::world_, base_type::dt_, reaction_length_factor_ );
+        reaction_length_ = determine_reaction_length( *base_type::world_, base_type::dt_, reaction_length_factor_, 
+            *base_type::network_rules_ );
         return old_bound_time;        
     }
 
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 0b18ef6e..017a28b7 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -77,7 +77,7 @@ class CylindricalSurface
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
-        return 2*rl;
+        return rl;
     }
 
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
@@ -144,7 +144,7 @@ class CylindricalSurface
         length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb) + r01_cb ) );
         
         position_type v;
-        v[0] = 1; v[1] = 1; v[2] = 1;
+        v[0] = 1.; v[1] = 1.; v[2] = 1.;
         
         position_type const unit_z( base_type::shape().unit_z() );      
         position_type const unit_x( normalize( subtract( v, 
diff --git a/Multi.hpp b/Multi.hpp
index 3f925981..1947f84a 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -244,6 +244,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
     typedef std::map<shell_id_type, spherical_shell_type> spherical_shell_map;
     typedef sized_iterator_range<typename spherical_shell_map::const_iterator> spherical_shell_id_pair_range;
     typedef MultiParticleContainer<traits_type> multi_particle_container_type;
+    typedef typename traits_type::world_type world_type;
 
     enum event_kind
     {
@@ -325,6 +326,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
           shells_(), last_event_(NONE)
     {
         BOOST_ASSERT(dt_factor > 0.);
+        //TODO: dt calc. should only depend on particles in the multi. 
         base_type::dt_ = dt_factor_ * BDSimulator<traits_type>::determine_dt(*main_.world());
     }
 
@@ -426,6 +428,25 @@ class Multi: public Domain<typename Tsim_::traits_type>
     {
         return pc_.get_particles_range();
     }
+    
+    static Real determine_dt(world_type const& world)
+    {
+        Real D_max(0.), radius_min(std::numeric_limits<Real>::max());
+
+        BOOST_FOREACH(particle_id_pair pp, get_particles_range() )
+        {       
+            
+        }
+        
+        BOOST_FOREACH(species_type s, world.get_species())
+        {
+            if (D_max < s.D())
+                D_max = s.D();
+            if (radius_min > s.radius())
+                radius_min = s.radius();
+        }
+        return gsl_pow_2(radius_min * 2) / (D_max * 2);
+    }
 
     void step()
     {
diff --git a/Transaction.hpp b/Transaction.hpp
index d538365d..97d490aa 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -170,7 +170,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
     {
-        return structure_id_and_distance_pair();
+        return pc_.get_closest_surface( pos );
     }
 
     virtual species_type const& get_species(species_id_type const& id) const
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 5d9bc927..a2962268 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -181,7 +181,7 @@ class newBDPropagator
         {        
             boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure(struct_id_distance_pair.first) );
             
-            accumulated_prob += k_tot( pp.second.sid(), closest_surf->sid() ) * dt_ / 
+            accumulated_prob += k_total( pp.second.sid(), closest_surf->sid() ) * dt_ / 
                 closest_surf->surface_reaction_volume( r0, reaction_length_ );
         
             if(accumulated_prob >= 1.)
@@ -236,7 +236,7 @@ class newBDPropagator
             
             boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
             const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
-            accumulated_prob += k_tot(s0.id(), s1.id() ) * dt_ / ( 2 * reaction_volume ); 
+            accumulated_prob += k_total(s0.id(), s1.id()) * dt_ / ( 2. * reaction_volume ); 
             
             if (accumulated_prob >= 1.)
             {
@@ -445,9 +445,7 @@ class newBDPropagator
                                 length_type core_surface_distance( struct_id_distance_pair.second - s0.radius() );
                                     
                                 if( core_surface_distance < 0 )
-                                {
                                     surface_overlap = true;
-                                }
                                     
                                 struct_id_distance_pair = tx_.get_closest_surface( pp01.second );
                                 core_surface_distance = struct_id_distance_pair.second - s1.radius();
@@ -495,8 +493,8 @@ class newBDPropagator
         return false;
     }
         
-    /* Function returns the accumulated intrinsic reaction rate. */
-    Real k_tot(species_id_type const& s0_id, species_id_type const& s1_id)
+    /* Function returns the accumulated intrinsic reaction rate between to species. */
+    Real k_total(species_id_type const& s0_id, species_id_type const& s1_id)
     {   
         reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
         if (::size(rules) == 0)
@@ -526,7 +524,7 @@ class newBDPropagator
         
         boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
         
-        const Real k_tot( k_tot(s0.sid(), s1.sid()) );
+        const Real k_tot( k_total(pp0.second.sid(), pp1.second.sid()) );
         const Real rnd( k_tot * rng_() );
         Real prob = 0;    
         
@@ -621,17 +619,15 @@ class newBDPropagator
     }
 
         
-    bool fire_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
+    bool fire_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& surface)
     {
-        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), structure->sid() ));
+        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), surface->sid() ));
         if (::size(rules) == 0)
             throw propagation_error("trying to fire an interaction with a non-interactive surface");
         
         const species_type s0(tx_.get_species(pp.second.sid()));
-        
-        boost::shared_ptr<structure_type> pp_structure( tx_.get_structure( s0.structure_id() ) ); 
-        
-        const Real k_tot( k_tot(s0.sid(), s1.sid()) );
+                
+        const Real k_tot( k_total(pp.second.sid(), surface->sid()) );
         const Real rnd( k_tot * rng_() );
         Real prob = 0;  
 
@@ -653,7 +649,7 @@ class newBDPropagator
                         const species_id_type product(products[0]);
                         const species_type sp(tx_.get_species(product));
 
-                        const position_type new_pos( tx_.apply_boundary( structure->projected_point( pp.second.position() ).first ) );
+                        const position_type new_pos( tx_.apply_boundary( surface->projected_point( pp.second.position() ).first ) );
                             
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                             tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),

From 3999bc456d87bb458dab722b95c183da9bbf99d2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 Nov 2011 12:19:32 +0100
Subject: [PATCH 0328/1541] added missing methods for proper functioning:
 choose_pair_greens_function and get_shell_size Also cleanedup small typos

---
 pair.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/pair.py b/pair.py
index 7585512b..2e124325 100644
--- a/pair.py
+++ b/pair.py
@@ -1046,8 +1046,8 @@ def calc_z_scaling_factor(cls, D2d, D3d):
     ################
 
     def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
-                 shell_half_length, shell_orientation_vector, 
-                 r0, rrs):
+                 shell_half_length, shell_orientation_vector, r0, rrs):
+
         Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
         self.surface = single1.structure    # the surface on which particle1 lives
@@ -1177,12 +1177,12 @@ def do_back_transform(self, com, iv):
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
         iv_x = self.surface.shape.unit_x * numpy.dot(iv, self.surface.shape.unit_x)
         iv_y = self.surface.shape.unit_y * numpy.dot(iv, self.surface.shape.unit_y)
-        iv_z = self.shell.shape.unit_z * numpy.dot(iv, self.shell.shape.unit_z)
+        iv_z = self.shell.shape.unit_z * abs(numpy.dot(iv, self.shell.shape.unit_z))
 
         # reflect the coordinates in the unit_z direction back to the side of the membrane
         # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
         # plane of the membrane
-        iv_z = abs(iv_z)
+#        iv_z = abs(iv_z)
 
         pos1 = com - weight1 * (iv_x + iv_y)
         pos2 = com + weight2 * (iv_x + iv_y) + \
@@ -1203,6 +1203,9 @@ def get_sigma(self):
         return rho
     sigma = property (get_sigma)
 
+    def choose_pair_greens_function(self, r0, t):
+        return self.iv_greens_function(r0)
+
     def com_greens_function(self):
         # diffusion of the CoM of a mixed pair is only two dimensional
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
@@ -1219,6 +1222,9 @@ def create_new_shell(self, position, radius, half_length, orientation_vector, do
         return CylindricalShell(domain_id, Cylinder(position, radius, orientation_vector,
                                                     half_length))
 
+    def get_shell_size(self):
+        return self.shell.shape.radius
+
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
         return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y

From ae064d87e8bcab8be08b38019a6eb261ad6ebf81 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 Nov 2011 14:51:18 +0100
Subject: [PATCH 0329/1541] new com should be relative to old com, not center
 of shell

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 2e124325..2e207f33 100644
--- a/pair.py
+++ b/pair.py
@@ -129,7 +129,7 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         # If the two particles have reacted this returns the
         # new position twice
         # The positions are relative to the center of the shell
-        new_com = self.shell.shape.position + self.draw_new_com(dt, event_type)
+        new_com = self.com + self.draw_new_com(dt, event_type)
 
         if event_type == EventType.IV_REACTION:
             newpos1 = new_com

From dde2a6f04fca34f6d16cad08a49b22f66848fdcd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 Nov 2011 14:51:53 +0100
Subject: [PATCH 0330/1541] changed calculation of com/iv from egfrd code to
 do_transform in pair.py

---
 egfrd.py | 61 ++++++++++++++++++++++++++++++++------------------------
 1 file changed, 35 insertions(+), 26 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2038f3b6..3cce7ff8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1047,6 +1047,7 @@ def process_single_event(self, single):
                 newpos = single.draw_new_position(single.dt, single.event_type)
                 newpos = self.world.apply_boundary(newpos)
             else:
+                # no change in position has taken place
                 newpos = pid_particle_pair[1].position
 
             # newpos now hold the new position of the particle (not yet committed to the world)
@@ -1382,12 +1383,17 @@ def process_pair_event(self, pair):
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
 
-        pos1 = pid_particle_pair1[1].position
-        pos2 = pid_particle_pair2[1].position
-        pos2t = self.world.cyclic_transpose(pos2, pos1)
-        old_iv = pos2t - pos1
-        r0 = length (old_iv)
-        
+#        pos1 = pid_particle_pair1[1].position
+#        pos2 = pid_particle_pair2[1].position
+#        pos2t = self.world.cyclic_transpose(pos2, pos1)
+#        old_iv = pos2t - pos1
+#        r0 = length (old_iv)
+#        
+#        old_com = pair.com
+
+        old_com, old_iv = pair.do_transform(single1, single2, self.world)
+        r0 = length(old_iv)
+
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
             pair.event_type = pair.draw_iv_event_type(r0)
@@ -1399,9 +1405,6 @@ def process_pair_event(self, pair):
             log.info('single1 = %s' % pair.single1)
             log.info('single2 = %s' % pair.single2)
 
-
-        old_com = pair.com
-
         # Four cases:
         #  1. Single reaction
         #  2. Pair reaction
@@ -1482,6 +1485,7 @@ def process_pair_event(self, pair):
                     if self.world.check_overlap((new_com, product_species.radius),
                                                 pid_particle_pair1[0],
                                                 pid_particle_pair2[0]):
+                        # TODO NoSpace no longer exists, make sure that reactant particles are properly placed
                         if __debug__:
                             log.info('no space for product particle.')
                         raise NoSpace()
@@ -1640,15 +1644,18 @@ def propagate_pair(self, pair):
 #            D1 = pid_particle_pair1[1].D
 #            D2 = pid_particle_pair2[1].D
 
-            # store for later check
-            old_com = pair.com
+            old_com, old_inter_particle = pair.do_transform (pair.single1, pair.single2, self.world)
+            r0 = length(old_inter_particle)
 
 
-            # TODO this should be done when the pair is made -> passed to the constructor
-            pos2t = self.world.cyclic_transpose(pos2, pos1)
-            old_inter_particle = pos2t - pos1
-            r0 = self.world.distance(pos1, pos2)
-            assert feq(r0, length(old_inter_particle))
+#            # store for later check
+#            old_com = pair.com
+#
+#            # TODO this should be done when the pair is made -> passed to the constructor
+#            pos2t = self.world.cyclic_transpose(pos2, pos1)
+#            old_inter_particle = pos2t - pos1
+#            r0 = self.world.distance(pos1, pos2)
+#            assert feq(r0, length(old_inter_particle))
 
             # draw the new positions of the particles
             newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
@@ -1663,8 +1670,8 @@ def propagate_pair(self, pair):
                                                 pid_particle_pair1[0], pid_particle_pair2[0])
 
             # some more consistency checking of the positions
-            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
-                                       pair.get_shell_size())
+#            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
+#                                       pair.get_shell_size())
 
         else:
         # no time has passed
@@ -1701,18 +1708,20 @@ def propagate_pair(self, pair):
         self.domains[single1.domain_id] = single1
         self.domains[single2.domain_id] = single2
 
-        # Thoroughly check the sizes of the shells of the singles
+        # Check the dimensions of the shells of the singles with the shell in the container
         if __debug__:
-            container = self.geometrycontainer.get_container(single1.shell)
-            assert container[single1.shell_id].shape.radius == \
+            container1 = self.geometrycontainer.get_container(single1.shell)
+            assert container1[single1.shell_id].shape.radius == \
                    single1.shell.shape.radius
-            assert container[single2.shell_id].shape.radius == \
-                   single2.shell.shape.radius
-
             if type(single1.shell) is CylindricalShell:
-                assert container[single1.shell_id].shape.half_length == \
+                assert container1[single1.shell_id].shape.half_length == \
                        single1.shell.shape.half_length
-                assert container[single2.shell_id].shape.half_length == \
+
+            container2 = self.geometrycontainer.get_container(single2.shell)
+            assert container2[single2.shell_id].shape.radius == \
+                   single2.shell.shape.radius
+            if type(single2.shell) is CylindricalShell:
+                assert container2[single2.shell_id].shape.half_length == \
                        single2.shell.shape.half_length
 
         assert single1.shell.shape.radius == pid_particle_pair1[1].radius

From 0bfb38efba3f4b789ab9b40af0d97902a5968d01 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 Nov 2011 17:19:42 +0100
Subject: [PATCH 0331/1541] now draw_new_com produces a full coordinate for the
 com -> can be used for product particle of Pair

---
 pair.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/pair.py b/pair.py
index 2e207f33..04aedeb6 100644
--- a/pair.py
+++ b/pair.py
@@ -126,17 +126,17 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         inter-particle vector.
 
         """
-        # If the two particles have reacted this returns the
-        # new position twice
-        # The positions are relative to the center of the shell
-        new_com = self.com + self.draw_new_com(dt, event_type)
-
-        if event_type == EventType.IV_REACTION:
-            newpos1 = new_com
-            newpos2 = new_com
-        else:
-            new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
-            newpos1, newpos2 = self.do_back_transform(new_com, new_iv)
+#        # If the two particles have reacted this returns the
+#        # new position twice
+#        # The positions are relative to the center of the shell
+        new_com = self.draw_new_com(dt, event_type)
+
+#        if event_type == EventType.IV_REACTION:
+#            newpos1 = new_com
+#            newpos2 = new_com
+#        else:
+        new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
+        newpos1, newpos2 = self.do_back_transform(new_com, new_iv)
 
         return newpos1, newpos2
 
@@ -148,7 +148,7 @@ def draw_new_com(self, dt, event_type):
             gf = self.com_greens_function()
             r = draw_r_wrapper(gf, dt, self.a_R)
 
-        return self.create_com_vector(r)
+        return self.com + self.create_com_vector(r)
 
         # Add displacement to old CoM. This assumes (correctly) that 
         # r0=0 for the CoM. Compare this to 1D singles, where r0 is not  

From 6d546fc9b65d9ff2d0d09f4c791e7c6f15bf9f9e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 Nov 2011 17:20:45 +0100
Subject: [PATCH 0332/1541] namechange new_com -> product_pos and introduced
 reactant positions This is needed to be able to revert a failed bi-molecular
 reaction

---
 egfrd.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3cce7ff8..da3d677e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1441,8 +1441,12 @@ def process_pair_event(self, pair):
         elif pair.event_type == EventType.IV_REACTION:
 
             # calculate new position
-            new_com, _ = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
-            new_com = self.world.apply_boundary(new_com)
+            reactant1_pos, reactant2_pos = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
+            reactant1_pos = self.world.apply_boundary(reactant1_pos)
+            reactant2_pos = self.world.apply_boundary(reactant2_pos)
+
+            product_pos = pair.draw_new_com (pair.dt, pair.event_type)
+            product_pos = self.world.apply_boundary(product_pos)
 
             # TODO make this a fire_pair_reaction method
 
@@ -1474,15 +1478,15 @@ def process_pair_event(self, pair):
                 product_species = self.world.get_species(rr.products[0])
 
                 # 1.5 no change in position due to reaction
-                # position = new_com
+                # position = product_pos
 
                 # 2.  make space for products
                 # 2.1 if the product particle sticks out of the shell
-                if self.world.distance(old_com, new_com) > (pair.get_shell_size() - product_species.radius):
-                    self.burst_volume(new_com, product_species.radius)
+                if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_species.radius):
+                    self.burst_volume(product_pos, product_species.radius)
 
                     # 3. check that there is space for the products ignoring the reactants
-                    if self.world.check_overlap((new_com, product_species.radius),
+                    if self.world.check_overlap((product_pos, product_species.radius),
                                                 pid_particle_pair1[0],
                                                 pid_particle_pair2[0]):
                         # TODO NoSpace no longer exists, make sure that reactant particles are properly placed
@@ -1493,7 +1497,7 @@ def process_pair_event(self, pair):
                 # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(pid_particle_pair1[0])
                 self.world.remove_particle(pid_particle_pair2[0])
-                particle = self.world.new_particle(product_species.id, new_com)
+                particle = self.world.new_particle(product_species.id, product_pos)
                 products = [particle, ]
 
                 # 5. make a new single and schedule

From f8e62d962a9c4408efcefc039673ffd9757b7972 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 Nov 2011 18:52:25 +0100
Subject: [PATCH 0333/1541] enable drift for singles on the cylindrical surface

---
 single.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/single.py b/single.py
index 2ff82433..5f0fde04 100644
--- a/single.py
+++ b/single.py
@@ -380,7 +380,6 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
                                       shell_id, reactionrules, structure)
 
     def getv(self):
-        return 0 # TODO, include drift.
         return self.pid_particle_pair[1].v
     v = property(getv)
 

From ec3dd44257a775e572b1e4d9e235dfa8b97c429a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 Nov 2011 18:56:04 +0100
Subject: [PATCH 0334/1541] removed comment

---
 pair.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/pair.py b/pair.py
index 04aedeb6..27b44414 100644
--- a/pair.py
+++ b/pair.py
@@ -681,8 +681,6 @@ def com_greens_function(self):
         return GreensFunction1DAbsAbs(self.D_R, self.v_R, 0.0, -self.a_R, self.a_R)
 
     def iv_greens_function(self, r0):
-        # TODO Fix ugly hack to avoid k=0 below
-        #return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
         return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
     def create_new_shell(self, position, half_length, domain_id):

From 54ca238ec7c3e15d0d16d1f4d125681a11b38cf9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 4 Nov 2011 12:10:07 +0100
Subject: [PATCH 0335/1541] changed transformation of the inter particle vector
 of MixedPair Previously the particle was reflected at its surface with the
 membrane, now the particle is reflected at its center of mass with the
 membrane. This prevents that the initial condition is at r0 < sigma

---
 pair.py | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/pair.py b/pair.py
index 27b44414..4f8c7010 100644
--- a/pair.py
+++ b/pair.py
@@ -991,7 +991,7 @@ def z_right(cls, single1, single2, r0, r):
         a_r = min (a_r1, a_r2)
 
         z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
-        z_right = (a_r/z_scaling_factor) + (2*radius2)
+        z_right = (a_r/z_scaling_factor) + (radius2)
 
         return z_right
 
@@ -1007,7 +1007,7 @@ def r_right(cls, single1, single2, r0, z_right):
 
         # we first calculate the a_r, since it is the only radius that depends on z_right only.
         z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
-        a_r = (z_right - (2*radius2)) * z_scaling_factor
+        a_r = (z_right - (radius2)) * z_scaling_factor
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
         # Note that for the IV we only take the distance to the outer boundary into account.
@@ -1093,7 +1093,7 @@ def determine_radii(self, half_length, radius):
         D2 = self.pid_particle_pair2[1].D
         D12 = D1 + D2
 
-        a_r = ((half_length * 2) - radius1 - (2 * radius2)) * self.z_scaling_factor
+        a_r = ((half_length * 2) - radius1 - (radius2)) * self.z_scaling_factor
 
         # calculate the maximal displacement of a particle given an a_r. Also include its radius
         space_for_iv = max( (D1/D12) * a_r + radius1,
@@ -1158,7 +1158,7 @@ def do_transform(cls, single1, single2, world):
         iv_z = surface.shape.unit_z * numpy.dot (iv, surface.shape.unit_z)
         iv_z_length = length(iv_z)
 
-        new_iv_z_length = (iv_z_length - single2.pid_particle_pair[1].radius) * z_scaling_factor
+        new_iv_z_length = (iv_z_length) * z_scaling_factor
         new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
 
         iv = iv - iv_z + new_iv_z
@@ -1175,17 +1175,24 @@ def do_back_transform(self, com, iv):
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
         iv_x = self.surface.shape.unit_x * numpy.dot(iv, self.surface.shape.unit_x)
         iv_y = self.surface.shape.unit_y * numpy.dot(iv, self.surface.shape.unit_y)
-        iv_z = self.shell.shape.unit_z * abs(numpy.dot(iv, self.shell.shape.unit_z))
 
         # reflect the coordinates in the unit_z direction back to the side of the membrane
         # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
         # plane of the membrane
-#        iv_z = abs(iv_z)
+        iv_z_length = abs(numpy.dot(iv, self.shell.shape.unit_z))
+        # do the reverse scaling
+        iv_z_length = iv_z_length / self.z_scaling_factor
+
+        # if the particle is overlapping with the membrane, make sure it doesn't
+        if iv_z_length < self.pid_particle_pair2[1].radius:
+            iv_z_length = self.pid_particle_pair2[1].radius * MINIMAL_SEPARATION_FACTOR
+
+        iv_z = self.shell.shape.unit_z * iv_z_length
 
         pos1 = com - weight1 * (iv_x + iv_y)
         pos2 = com + weight2 * (iv_x + iv_y) + \
-               iv_z/self.z_scaling_factor + \
-               self.shell.shape.unit_z * self.pid_particle_pair2[1].radius
+               iv_z #/self.z_scaling_factor + \
+#               self.shell.shape.unit_z * self.pid_particle_pair2[1].radius
 
         return pos1, pos2
 

From abffcc3dcfc5a317c33f9a6d7a600b46ec36c589 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 4 Nov 2011 14:30:45 +0100
Subject: [PATCH 0336/1541] Included get_max_rate and determine dt in Multi.
 Multi timestep is now based on the particles in the multi allone, not based
 on all the particles in the whole world.

---
 CuboidalRegion.hpp     |   5 ++
 CylindricalSurface.hpp |   5 ++
 EGFRDSimulator.hpp     |   1 +
 Multi.hpp              | 137 +++++++++++++++++++++++++++++++++++++----
 PlanarSurface.hpp      |   6 ++
 SphericalSurface.hpp   |   5 ++
 Structure.hpp          |   2 +
 newBDPropagator.hpp    |  10 ++-
 8 files changed, 154 insertions(+), 17 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 9ae2b0a0..3efb7f46 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -66,6 +66,11 @@ class CuboidalRegion
     {
         return random_vector( drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v ), rng );
     }
+    
+    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    {
+        return k / (4 * M_PI * r01 * r01 );    
+    }
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 017a28b7..12330546 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -74,6 +74,11 @@ class CylindricalSurface
     {
         return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
     }
+    
+    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    {
+        return k;
+    }
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index a40fcecc..8e6d5127 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -62,6 +62,7 @@ struct EGFRDSimulatorTraitsBase: public ParticleSimulatorTraitsBase<Tworld_>
 
     static const Real SAFETY = 1. + 1e-5;
     static const Real SINGLE_SHELL_FACTOR = .1;
+    static const Real MULTI_SHELL_FACTOR = .05;
     static const Real DEFAULT_DT_FACTOR = 1e-5;
     static const Real CUTOFF_FACTOR = 5.6;
 };
diff --git a/Multi.hpp b/Multi.hpp
index 1947f84a..7ad30cbc 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -49,11 +49,16 @@ class MultiParticleContainer
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
     typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+    typedef std::map<species_id_type, species_type> species_map;
+    typedef select_second<typename species_map::value_type> species_second_selector_type;
 
 public:    
     typedef boost::transform_iterator<surface_second_selector_type,
             typename structure_map::const_iterator> surface_iterator;
     typedef sized_iterator_range<surface_iterator> structures_range;
+    typedef boost::transform_iterator<species_second_selector_type,
+        typename species_map::const_iterator> species_iterator;
+    typedef sized_iterator_range<species_iterator> species_range;
 
 
     virtual ~MultiParticleContainer() {}
@@ -67,7 +72,7 @@ class MultiParticleContainer
     {
         return world_.world_size();
     }
-
+    
     virtual species_type const& get_species(species_id_type const& id) const
     {
         return world_.get_species(id);
@@ -208,11 +213,31 @@ class MultiParticleContainer
                                       particles_.size());
     }
 
+    species_range get_species_in_multi() const
+    {   
+        species_map_.clear();
+     
+        BOOST_FOREACH(particle_id_pair pp, get_particles_range() )
+        {
+            typename species_map::const_iterator i(species_map_.find( pp.second.sid() ));
+            if (species_map_.end() == i)
+            {
+                species_map_[pp.second.sid()] = world_.get_species( pp.second.sid() );
+            }
+        }
+    
+        return species_range(
+            species_iterator(species_map_.begin(), species_second_selector_type()),
+            species_iterator(species_map_.end(), species_second_selector_type()),
+            species_map_.size());
+    }
+
     MultiParticleContainer(world_type& world): world_(world) {}
 
 private:
     world_type& world_;
     particle_map particles_;
+    species_map species_map_;
 };
 
 template<typename Tsim_>
@@ -232,6 +257,9 @@ class Multi: public Domain<typename Tsim_::traits_type>
     typedef typename traits_type::world_type::size_type size_type;
     typedef typename traits_type::world_type::structure_type structure_type;
     typedef typename traits_type::world_type::particle_id_pair particle_id_pair;
+    typedef typename traits_type::network_rules_type network_rules_type;
+    typedef typename traits_type::reaction_rule_type reaction_rule_type;
+    typedef typename network_rules_type::reaction_rules reaction_rules;   
     typedef typename traits_type::shell_id_type shell_id_type;
     typedef typename traits_type::domain_id_type identifier_type;
     typedef typename traits_type::template shell_generator<
@@ -241,11 +269,19 @@ class Multi: public Domain<typename Tsim_::traits_type>
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
     typedef typename traits_type::reaction_record_type reaction_record_type;
 
+private:
+    typedef std::map<species_id_type, species_type> species_map;
+    typedef select_second<typename species_map::value_type> species_second_selector_type;
+            
+public:
     typedef std::map<shell_id_type, spherical_shell_type> spherical_shell_map;
     typedef sized_iterator_range<typename spherical_shell_map::const_iterator> spherical_shell_id_pair_range;
     typedef MultiParticleContainer<traits_type> multi_particle_container_type;
     typedef typename traits_type::world_type world_type;
-
+    typedef boost::transform_iterator<species_second_selector_type,
+        typename species_map::const_iterator> species_iterator;
+    typedef sized_iterator_range<species_iterator> species_range;
+    
     enum event_kind
     {
         NONE,
@@ -326,7 +362,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
           shells_(), last_event_(NONE)
     {
         BOOST_ASSERT(dt_factor > 0.);
-        //TODO: dt calc. should only depend on particles in the multi. 
+        //TODO: dt calc. should only depend on particles in the multi. -This is a hack
         base_type::dt_ = dt_factor_ * BDSimulator<traits_type>::determine_dt(*main_.world());
     }
 
@@ -429,23 +465,102 @@ class Multi: public Domain<typename Tsim_::traits_type>
         return pc_.get_particles_range();
     }
     
-    static Real determine_dt(world_type const& world)
+    /* Returns largest diffusion constant en smallest particle radius in the multi. */
+    std::pair<const Real, const Real> maxD_minsigma()
     {
         Real D_max(0.), radius_min(std::numeric_limits<Real>::max());
 
-        BOOST_FOREACH(particle_id_pair pp, get_particles_range() )
-        {       
-            
-        }
-        
-        BOOST_FOREACH(species_type s, world.get_species())
+        BOOST_FOREACH(species_type s, pc_.get_species_in_multi())
         {
             if (D_max < s.D())
                 D_max = s.D();
             if (radius_min > s.radius())
                 radius_min = s.radius();
         }
-        return gsl_pow_2(radius_min * 2) / (D_max * 2);
+        std::pair<const Real, const Real> retval(D_max, radius_min);
+        
+        return retval;
+    }
+    
+    /* Functions returns largest _1D_ intrinsic reaction rate in the multi.
+       TODO: include structures in kmax finder. */
+    Real kmax()
+    {
+        Real k_max(0.);
+        int i = 0, j= 0;
+
+        BOOST_FOREACH(species_type s0, pc_.get_species_in_multi())
+        {
+            j = 0;
+            BOOST_FOREACH(species_type s1, pc_.get_species_in_multi())
+            {
+                if( j++ < i )
+                    continue;
+                
+                reaction_rules const& rrules(main_.network_rules().query_reaction_rule( s0.id(), s1.id() ));
+                if (::size(rrules) == 0)
+                {
+                    continue;
+                }
+                                
+                for (typename boost::range_const_iterator<reaction_rules>::type
+                it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
+                {
+                    const length_type r01( s0.radius() + s1.radius() );
+                    Real k;
+                    
+                    if(s0.structure_id() != s1.structure_id())
+                    {
+                        if(s0.structure_id() == "world")
+                            k = pc_.get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                        else
+                            k = pc_.get_structure( s1.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                    }
+                    else
+                    {
+                        k = pc_.get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 ); 
+                    }
+                
+                    if ( k_max < k )
+                        k_max = k;
+                }          
+            }
+            i++;
+        }
+        
+        return k_max;
+    }
+    
+    /* Function returns dt for BD propegator. dt is calulated with the constraints:
+       (1) The reaction length is equal to (MULTI_SHELL_FACTOR - 1) * r_min,
+       where r_min is the radius of the smallest particle in the multi.
+       (2) The largest acceptance probability in the multi is smaller than 0.02.
+       
+       If the timestep as defined above is larger than a user defined maximum, use this maximum.
+       
+       PROBLEM: for certain parameters (large k) dt can be very small and the simulation will slow down.
+    */    
+    Real determine_dt(Real const& reaction_length_factor)
+    {
+        std::pair<const Real, const Real> maxD_minr( maxD_minsigma() );
+        const Real k_max( kmax() );
+        const Real D_max( maxD_minr.first );
+        const Real r_min( maxD_minr.second );
+        const Real Pacc_max( 0.02 ); //Reciproke of maximum value of the acceptance probability.
+        const Real tau_D( 2 * r_min * r_min / D_max );
+        Real dt;
+        
+        if( k_max > 0)
+        {
+            Real dt_temp( Pacc_max * traits_type::MULTI_SHELL_FACTOR * r_min / k_max );
+            dt = std::min( dt_temp, dt_factor_ * tau_D ); // dt_factor * tau_D is lower limit of dt.
+        }
+        else
+            dt = dt_factor_ * tau_D;
+
+        log_.info( "timestep set to %f", dt );
+
+        return dt;    
     }
 
     void step()
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 899c34e0..01ed0d33 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -64,6 +64,11 @@ class PlanarSurface
         return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng ); 
     }
 
+    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    {
+        return k / (2 * M_PI * r01);    
+    }
+
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
         length_type r01l( r01 + rl );
@@ -75,6 +80,7 @@ class PlanarSurface
     
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
+        //factor 2 because surface has two possible reaction sides due to cyclic BCn.
         return 2*rl;
     }
     
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 4ec6f2a5..88c86a2e 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -52,6 +52,11 @@ class SphericalSurface
         return position_type(); //TODO
     }
 
+    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    {
+        return Real(); //TODO
+    }
+
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
         return Real(); //TODO
diff --git a/Structure.hpp b/Structure.hpp
index 1157374e..2f6b5f93 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -72,6 +72,8 @@ class Structure
     virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, Real const& D0, Real const& D1, Real const& v0, Real const& v1) const = 0;
 
     virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
+    
+    virtual Real get_1D_rate( Real const& k, length_type const& r01) const = 0;
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const = 0;
     
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index a2962268..bc4c502c 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -198,8 +198,6 @@ class newBDPropagator
                     LOG_DEBUG(("fire surface interaction"));
                     if(fire_interaction(pp, closest_surf ))
                         return true;
-                    else
-                        std::cerr << "zou niet moeten gebeuren (surf)" << std::endl;
                 }   
                 catch (propagation_error const& reason)
                 {
@@ -228,8 +226,10 @@ class newBDPropagator
             if(s0.structure_id() != s1.structure_id())
             {
                 if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
-                    throw not_implemented("No surface -> surface + surface - reactions allowed");
-                
+                {
+                    log_.warn("A surface particle overlapped with a particle living on a different surface. No reaction implemented.");
+                    continue;
+                }
                 if(s0.structure_id() == "world")
                     std::swap(s0,s1);
             }
@@ -252,8 +252,6 @@ class newBDPropagator
                 {
                     if( fire_reaction(pp, closest.first) )
                         return true;
-                    else
-                        std::cerr << "zou niet moeten gebeuren (pp)" << std::endl;
                 }
                 catch (propagation_error const& reason)
                 {

From 4769722cd6d832c31e7bab82d6170be7b1c67f8a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 4 Nov 2011 16:23:58 +0100
Subject: [PATCH 0337/1541] implemented decay reaction of 2D particle into 2D
 and 3D particle as back reaction of MixedPair

---
 egfrd.py | 62 +++++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 48 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index da3d677e..e6579b07 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -794,12 +794,16 @@ def fire_single_reaction(self, single, reactant_pos):
                     productA_displacement = product1_displacement
                     productB_displacement = product2_displacement
                     productB_radius = product2_radius
+                    DA = D1
+                    DB = D2
                     default = True      # we like to think of this as the default
                 else:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
                     productA_displacement = product2_displacement
                     productB_displacement = product1_displacement
                     productB_radius = product1_radius
+                    DA = D2
+                    DB = D1
                     default = False
                 # Note that A is a particle in the surface and B is in the 3D
 
@@ -807,30 +811,60 @@ def fire_single_reaction(self, single, reactant_pos):
 
                     # draw a number of new positions for the two product particles
                     # TODO make this into a generator
-                    phi_min = math.asin (productB_radius / particle_radius12)   # we assume the membrane to have zero thickness
-                    phi_min *= MINIMAL_SEPARATION_FACTOR        # make sure that there's some distance from the membrane
+#                    phi_min = math.asin (productB_radius / particle_radius12)   # we assume the membrane to have zero thickness
+#                    phi_min *= MINIMAL_SEPARATION_FACTOR        # make sure that there's some distance from the membrane
 
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
                         # draw the random angle for the 3D particle relative to the particle left in the membrane
                         # not all angles are available because particle cannot intersect with the membrane
-                        phi = myrandom.uniform(phi_min, Pi - phi_min)
 
-                        cos_phi = math.cos(phi) 
-                        sin_phi = math.sin(phi)
+                        weightA = DA/(DA + DB)
+                        weightB = DB/(DA + DB)
 
-                        productA_displacement_xy = productA_displacement * cos_phi
-                        productB_displacement_xy = productB_displacement * cos_phi
-                        productB_displacement_z  = particle_radius12 * sin_phi
+                        # Basically do the backtransform with a random iv with length such that the particles are at contact
+                        # Note we make the iv slightly longer because otherwise the anisotropic transform will produce illegal
+                        # positions
+                        z_scaling_factor = MixedPair.calc_z_scaling_factor(DA, DB)
 
-                        # pick a random orientation
-                        orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
-                        # pick a random side of the membrane
+                        iv = random_vector(particle_radius12 * z_scaling_factor)
+                        iv *= MINIMAL_SEPARATION_FACTOR
+
+                        # backtransform. TODO use backtransform from MixedPair class
+                        iv_x = reactant_structure.shape.unit_x * numpy.dot(iv, reactant_structure.shape.unit_x)
+                        iv_y = reactant_structure.shape.unit_y * numpy.dot(iv, reactant_structure.shape.unit_y)
                         orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+                        iv_z_length = abs(numpy.dot(iv, orientation_vector_z))
+                        # do the reverse scaling
+                        iv_z_length /= z_scaling_factor
+
+                        # if the particle is overlapping with the membrane, make sure it doesn't
+                        if iv_z_length < productB_radius:
+                            iv_z_length = productB_radius * MINIMAL_SEPARATION_FACTOR
+
+                        iv_z = iv_z_length * orientation_vector_z
+
+                        newposA = reactant_pos - weightA * (iv_x + iv_y)
+                        newposB = reactant_pos + weightB * (iv_x + iv_y) + iv_z
+
 
-                        newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
-                        newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
-                                                 productB_displacement_z  * orientation_vector_z
+#                        phi = myrandom.uniform(phi_min, Pi - phi_min)
+#
+#                        cos_phi = math.cos(phi) 
+#                        sin_phi = math.sin(phi)
+#
+#                        productA_displacement_xy = productA_displacement * cos_phi
+#                        productB_displacement_xy = productB_displacement * cos_phi
+#                        productB_displacement_z  = particle_radius12 * sin_phi
+#
+#                        # pick a random orientation
+#                        orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
+#                        # pick a random side of the membrane
+#                        orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+#
+#                        newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
+#                        newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
+#                                                 productB_displacement_z  * orientation_vector_z
                         newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
 

From 0125c6f6349881b7edd2453dd5f0a89ce93cded8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 4 Nov 2011 17:52:13 +0100
Subject: [PATCH 0338/1541] fixed stupid typo

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 4f8c7010..38bd80ed 100644
--- a/pair.py
+++ b/pair.py
@@ -958,7 +958,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             z_right = z2_new
             z_left  = z1_new
 
-        return r, z_right, z_left
+        return r, z_left, z_right
 
     ### class methods that are for the right side of the cylindrical shell
     @classmethod

From dba411093703a8cd0ec4daf4cd69c4932652e00d Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Fri, 4 Nov 2011 18:18:34 +0100
Subject: [PATCH 0339/1541] Update to alpha-function root finding algorithm.
 Doesn't function properly yet.

Algorithm is implemented, but idea behind it not good enough. (Implemented
check for margin where convergence is assumed. But after values being
inside the margin, divergence may still occur.)
---
 GreensFunction2DRadAbs.cpp |  700 ++++++++++++++++---
 GreensFunction2DRadAbs.hpp |  140 +++-
 egfrd.py                   | 1293 ++++++++++++++++++------------------
 findRoot.cpp               |   33 +-
 greens_functions.cpp       |    4 +-
 pair.py                    |    4 +-
 samples/2d/2dtest.py       |   13 +-
 7 files changed, 1404 insertions(+), 783 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 8c0efb19..425f2467 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -1,3 +1,12 @@
+// Greens function class for 2d Green's Function for 2d annulus with radial and
+// axial dependence. Inner boundary is radiative (rad) (reaction event), outer 
+// boundary is absorbing (abs) (escape event). Different "draw" functions 
+// provide a way to draw certain values from the Green's Function, e.g. an
+// escape angle theta ("drawTheta" function).
+// 
+// Based upon code from Riken Institute. 
+// Written by Laurens Bossen, Adapted by Martijn Wehrens. FOM Institute AMOLF.
+
 //#define NDEBUG
 //#define BOOST_DISABLE_ASSERTS
 
@@ -37,23 +46,30 @@ GreensFunction2DRadAbs( const Real D,
 				    const Real kf,
 				    const Real r0, 
 				    const Real Sigma,
-                    		    const Real a )
+                    const Real a )
     :
-    PairGreensFunction(D, kf, r0, Sigma),
-    h( kf / (D * 2.0 * M_PI * Sigma) ),
-    a( a )
+    PairGreensFunction(D, kf, r0, Sigma),   
+    h( kf / (D * 2.0 * M_PI * Sigma) ),       
+    a( a ),                                    
+    estimated_alpha_root_distance_(M_PI/(a-Sigma))                                                                                      
+    // ^ Noobnote: here parent "constructors" are specified that are executed, 
+    // also a constructor initialization list can be (and is) specified. 
+    // These variables will be set before the contents of the constructor are 
+    // called.
 {
-    // print alphaTable value at construction
     const Real sigma(this->getSigma());
 
+    // Check wether input makes sense, outer boundary a should be > inner 
+    // boundary sigma.    
     if (a < sigma)
     {
         throw std::invalid_argument((boost::format("a >= sigma : a=%.16g, sigma=%.16g") % a % sigma).str());
     }
+    
+    // Clear AlphaTables (if this is not done, things will go wrong!)
     GreensFunction2DRadAbs::clearAlphaTable();
+    
 
-    // std::clog << "[alphaoffsettable[0]=" << this->alphaOffsetTable[0] << "]"; //DEBUG *REMOVEME*
-    ; // do nothing
 }
 
 GreensFunction2DRadAbs::~GreensFunction2DRadAbs()
@@ -65,15 +81,28 @@ GreensFunction2DRadAbs::~GreensFunction2DRadAbs()
 // Alpha-related methods
 //
 
+// Resets the alpha-tables
 void GreensFunction2DRadAbs::clearAlphaTable() const
 {
-    // std::clog << "[clearing.."; // DEBUG *REMOVEME*
+    // Clears all vectors in the alphaTable
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
 		   boost::mem_fn( &RealVector::clear ) );
+		   
+    // Sets the values in the alphaoffsetTable to {0, -1, .., -1}
     this->alphaOffsetTable[0] = 0;
     std::fill( this->alphaOffsetTable.begin()+1, this->alphaOffsetTable.end(),
 	       -1 );
-    // std::clog << " done]"; // DEBUG *REMOVEME*
+	       
+	// Sets all values of the alpha_x_scan_table_ to zero.
+    std::fill( this->alpha_x_scan_table_.begin(), 
+               this->alpha_x_scan_table_.end(),
+	           EPSILON/L_TYPICAL );
+	           
+	// Sets all values of the alpha_dx_entry_in_margin_ table to zero.
+    std::fill( this->alpha_dx_entry_in_margin_.begin(), 
+               this->alpha_dx_entry_in_margin_.end(),
+	           0 );	           
+	           
 }
 
 // The method evaluates the equation for finding the alphas for given alpha. This
@@ -101,15 +130,26 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 }
 
 
-// completely unclear why this is a separate function
+// Wraps function of which we need to find roots alpha.
+//
+// Params contains pointer to gf object (params.gf), where f_alpha is the member
+// function of which we have to find the roots. This function is thus a mere
+// wrapper of f_alpha.  
 const Real 
 GreensFunction2DRadAbs::f_alpha0_aux_F( const Real alpha,
 						const f_alpha0_aux_params* const params )
 {
-    const GreensFunction2DRadAbs* const gf( params->gf ); 	// get the gf from the params?
+    // create pointer to Green's Function object
+    const GreensFunction2DRadAbs* const gf( params->gf ); 	
+    
     return gf->f_alpha0( alpha );
 }
 
+
+// ======================================
+// LEGACY; TODO REMOVE
+// ======================================
+/*
 // finding the ith root for the order of Bessel functions zero. Only needed for the survival probability
 // and the flux
 const Real 
@@ -130,7 +170,6 @@ GreensFunction2DRadAbs::alpha0_i( const Real previous ) const
     {	low = EPSILON/L_TYPICAL;	// NEW to avoid the zero and negative values for the interval
     }
 
-
     // setting up the function
     f_alpha0_aux_params params = { this, target };	// struct with the gf object and the target
     gsl_function F = 
@@ -157,6 +196,11 @@ GreensFunction2DRadAbs::alpha0_i( const Real previous ) const
   
     return alpha;
 }
+*/
+
+// ======================================
+// END LEGACY;
+// ======================================
 
 // calculates the value of the expression for which the roots have to be found for given order n
 // The expression is evaluated for given alpha, to check if it zero or to get the value of the expression
@@ -185,40 +229,64 @@ const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 }
 
 
-// Finding the roots alpha
+// Wraps function of which we need to find roots alpha.
+//
+// Params contains pointer to gf object (params.gf), where f_alpha is the member
+// function of which we have to find the roots. This function is thus a mere
+// wrapper of f_alpha.  	  
 const Real 
 GreensFunction2DRadAbs::f_alpha_aux_F( const Real alpha,
-	       					const f_alpha_aux_params* const params )
+	       					const f_alpha_aux_params* const params )     					
 {
     const GreensFunction2DRadAbs* const gf( params->gf ); 
     const Integer n( params->n );
 
-    return gf->f_alpha( alpha, n );	// f_alpha is the function of which we have to find the roots
+    return gf->f_alpha( alpha, n );	// f_alpha is the function of which we have 
+                                    // to find the roots
 }
 
+// ======================================
+// LEGACY; TODO REMOVE
+// ======================================
 
+/*
 // This calculates a root based on the previous one (offset) with Bessel functions of order n
 // The roots are calculated based on the previous root which is given as an argument (offset)
 const Real 
 GreensFunction2DRadAbs::alpha_i( const Real offset, const Integer n ) const
 {
+    // # Get boundaries
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
-    const Real interval( M_PI / ( a - sigma ) );// interval is the estimated distance to the next
-						// root
-
-    const Real target( offset + interval );	// the target root is the previous one plus the interval
+    
+    // # Calculate estimated interval and next search area
+    // .. not exactly necessary for each alpha -> move to overhead
+    const Real interval( M_PI / ( a - sigma ) );
 
-    Real low ( target - (0.4 * interval ) );	// the range is calculated very easily
-    Real high( target + (0.4 * interval ) );	// We are sure that there is only one root in the interval
-						// THE 0.4 IS VERY TRICKY!! NOT SURE IF THIS WORKS FOR ALL
-						// PARAMETER SETS!!
+    Real target( offset + interval );	// the target root is the previous one plus the interval    
+        // CHANGED FROM 0.1 TO 0.4
+    Real low ( target - (0.4 * interval ) );	
+    Real high( target + (0.4 * interval ) );	    
+       
+        // To avoid the zero and negative values for the interval
     if (low <= 0)
-    {	low = EPSILON/L_TYPICAL;	// NEW to avoid the zero and negative values for the interval
-    }
-
-    f_alpha_aux_params params = { this, n, 0 };	// n is the summation index (the order of the Bessel
-						// functions used
+    {	low = EPSILON/L_TYPICAL;	
+    }    
+
+    // DEBUG REMOVE
+    std::cout << "Interval: " << interval << "; Offset: " << offset << ";\n";
+
+    // # Solving the root using GSL Brent root finder.
+
+        // f_alpha_aux_params is a struct: {gf, n, value}
+        // n is the summation index (the order of the Bessel functions used
+    f_alpha_aux_params params = { this, n, 0 };	
+					
+					
+	    // Reinterpret_cast converts any pointer type to any other pointer type, 
+	    // even of unrelated classes. Hence below code converts pointer 
+	    // ::f_alpha_aux_F to function pointer, which then points to memory 
+	    // location of params (&params).
     gsl_function F = 
 	{
 	    reinterpret_cast<typeof(F.function)>
@@ -226,79 +294,116 @@ GreensFunction2DRadAbs::alpha_i( const Real offset, const Integer n ) const
 	    &params 
 	};
 
-    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  // initialize the solver
-    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+    // DEBUG REMOVE
+    std::cout << "Looking inbetween [" << low << "," << high << "];\n"; 
+
+    // Define solvertype.
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
+    // Initialize the solver.
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );   
 
+    // Call rootfinder, find root called "alpha" and return it.
     const Real alpha ( findRoot( F, solver, low, high,
 		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::alpha_i" ) );
     gsl_root_fsolver_free( solver );
 
     return alpha;
 }
+*/
 
+// ======================================
+// END LEGACY; 
+// ======================================
 
-// Calculates the first root (called the offset) for summation index n (so using Bessel functions of order n)
+// Calculates the first root (called the offset) for summation index n (so using
+// Bessel functions of order n)
+//
+// Here we first find the interval where the first positive root is in.
+// We keep shifting the search window with the size of 'interval'
+// 'interval' is half of Pi/(a - sigma) (the expected distance between 
+// the 'offsets'). We then look for a sign change on the border of the
+// interval, if the sign changes in the interval inspected, we know it contains
+// a root.*
+//      After the interval is found, the GSL root finder is called.
+//
+// *) Note: we should be absolutely sure that the first search window is smaller
+// than half the "period" of the function, otherwise we can overlook roots.
 const Real
 GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
 {
-    if( this->alphaOffsetTable[n] > 0 )		// if the offset has already been calculated
+    // # Some preliminary checks
+
+    // Don't do all the work again if the offset has already been calculated
+    if( this->alphaOffsetTable[n] > 0 )		 
     {
-    // std::clog << "[returning because already calculated;]" ;// DEBUG *REMOVEME*
-	return this->alphaOffsetTable[n];	// don't do all the work again   
+	return this->alphaOffsetTable[n];	   
     }
-    assert( this->alphaOffsetTable.size() >= n );	// assume the table is large enough to
-							// accomodate the requested index
+    
+    // Makes sure table is large enough to accomodate requested index
+    assert( this->alphaOffsetTable.size() >= n );	
 
+    // # Get/calculate boundaries and determine width of interval to check for
+    // sign change.
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
-    const Real interval( M_PI_2 / ( a - sigma ));	// the x-axis of the function scales with a-sigma
-
-    // std::clog << "[calculating offset; input={n=" << n << ",sigma="<< sigma <<" , a="<< a <<" , interval="<< interval <<"}]" ;// DEBUG *REMOVEME*
-
-	Real offset (0);	// by default the offset is zero
+    const Real interval( M_PI_2 / ( a - sigma ));	// The x-axis of the 
+                                                    // function scales with 
+                                                    // a-sigma.
+
+    // If order (n) is zero, the offset is zero, otherwhise take n-1 offset
+    // value as first estimate.
+    //      (This can be done because the offsets only get bigger, the roots 
+    // shift to the right with the order of the Bessel functions n.)
+	Real offset (0);		
 	if (n != 0)
 	{	offset = ( this->alphaOffsetTable[n-1] );
-	}						// The offsets only get bigger, the roots shift to
-							// the right with the order of the Bessel functions n
-
-    // Here we find the interval where the first positive root is in.
-    // We keep shifting the search window with the size of 'interval'
-    // 'interval' is half of Pi/(a - sigma) (the expected distance between the 'offsets'
-
-    Real low ( offset );		// the searching interval for the new offset is between the previous
-    Real high( offset + interval );	// one a interval further
-	if (low <= 0)			// NEW to make sure things don't get negative
-	{	low = EPSILON/L_TYPICAL;// we assume that the high value is never negative
+	}						
+
+    // Define new interval as between x1=offset ("low") and x2=(offset+interval)
+    // ("high"). Make sure "low" is > 0.
+    Real low ( offset );		
+    Real high( offset + interval );	
+	if (low <= 0)			
+	{	low = EPSILON/L_TYPICAL;
 	}
 
-    Real f_low ( f_alpha(low,n) );	// get the values of the expression for the roots for these
-    Real f_high( f_alpha(high,n) );	// values of alpha (at the ends of the search range)
+    // # Look for the sign change.
 
-    while( f_low * f_high > 0 )		// if the expression changes sign then there is a root in the range
-    {					// and we should exit the loop
-	low =  high;			// shift everything so we check out the next interval
-	f_low = f_high;			// just pass the value on
+    // Get the values of the function at x "low" and x "high".
+    Real f_low ( f_alpha(low,n) );	
+    Real f_high( f_alpha(high,n) );	
+
+    // Continue shifting the search interval until a sign change is detected.
+    while( f_low * f_high > 0 )		
+    {					
+	low =  high;			
+	f_low = f_high;			
 
 	high += interval;
 	f_high = f_alpha( high, n );
     }
 
-   // We now determined roughly the interval where the first root should be.
-   // Next we find the exact root in the interval.
+   // # Once the interval that contains the root has been determined, use the
+   //   root finder to pinpoint the exact location.
 
    f_alpha_aux_params params = { this, n, 0};
    gsl_function F = 	{reinterpret_cast<typeof(F.function)>
 			( &GreensFunction2DRadAbs::f_alpha_aux_F ),
 			&params
 			};
+			// reinterpret_cast converts any pointer type to any other pointer type.
+            // reinterpret_cast<new_type> variable
 
-    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  // initialize the solver
+    // Initialize the GSL solver
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
-    offset = findRoot( F, solver, low, high, EPSILON/L_TYPICAL,	// find the intersection between the random
-                            EPSILON, "alphaOffset" );		// number and the cumm probability
+    // findRoot call GSL solver; See findRoot from findRoot.hpp for more info.
+    offset = findRoot( F, solver, low, high, EPSILON/L_TYPICAL,	
+                            EPSILON, "alphaOffset" );		
     gsl_root_fsolver_free( solver );
 
+    // Record value for future usage and return it.
     this->alphaOffsetTable[n] = offset;	// The offset found is now the first root
     return offset;
 }
@@ -484,68 +589,454 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	return boost::make_tuple (Ai0_expT*Y0_aAn, Ai0_expT*J0_aAn, Ai0_expT*Y0J1_J0Y1);
 }
 
+/*
 const Real GreensFunction2DRadAbs::getAlpha( size_t n, RealVector::size_type i ) const 
 {
-RealVector& alphaTable( this->alphaTable[n] );		// get the ref to the roots of order n
+    RealVector& alphaTable( this->alphaTable[n] );		// get the ref to the roots of order n
     const RealVector::size_type oldSize( alphaTable.size() );	// get it's size
 
-if( i >= oldSize )
-{
-    alphaTable.resize( i+1, 0 );	// resize the vector and fill the empty slots with 0
+    if( i >= oldSize )
+    {
+        alphaTable.resize( i+1, 0 );	// resize the vector and fill the empty slots with 0
+    }
+
+    if (alphaTable[i] == 0)		// if the requested root was not calculated yet
+    {
+	    if (i==0)		// if the requested root is the first one
+	    {	const Real offset (alphaOffset(n));	// The offset is the first root
+            std::cout << "Looking root " << i << "th root of " << n << "th Bessels;\n";
+            // std::clog << "[offset=" << offset << "]"; // DEBUG *REMOVEME*
+		    alphaTable[i]= offset;
+	    }
+	    else			// the requested root is dependent on the previous one
+	    {
+            std::cout << "Looking root " << i << "th root of " << n << "th Bessels;\n";
+		    const Real previous (getAlpha(n, i-1));		// get the previous root
+		    alphaTable[i] = this->alpha_i( previous , n );	// find the requested root based on
+								    // the previous one
+	    }
+    }
+    
+    return alphaTable[i];
+
 }
+*/
 
-if (alphaTable[i] == 0)		// if the requested root was not calculated yet
+/*
+// TODO: REMOVE THIS FUNCTIONALITY AND REPLACE WITH getAlpha(0)
+const Real GreensFunction2DRadAbs::getAlpha0( const RealVector::size_type i ) const
 {
-	if (i==0)		// if the requested root is the first one
-	{	const Real offset (alphaOffset(n));	// The offset is the first root
-        // std::clog << "[offset=" << offset << "]"; // DEBUG *REMOVEME*
-		alphaTable[i]= offset;
-	}
-	else			// the requested root is dependent on the previous one
-	{
-		const Real previous (getAlpha(n, i-1));		// get the previous root
-		alphaTable[i] = this->alpha_i( previous , n );	// find the requested root based on
-								// the previous one
-	}
+    RealVector& alphaTable( this->alphaTable[0] );
+    const RealVector::size_type oldSize( alphaTable.size() );
+
+    if( i >= oldSize )
+    {
+        alphaTable.resize( i+1, 0 );// fill the empty spaces with zeros
+    }
+
+    if (alphaTable[i] == 0)         // if the requested root was not calculated yet
+    {
+                if (i==0)               // if the requested root is the first one
+                {       const Real offset (alphaOffset(0));     // The offset is the first root
+                        alphaTable[i]= offset;
+                }
+                else                    // the requested root is dependent on the previous one
+                {
+                        const Real previous (getAlpha0(i-1));		// get the previous root
+                        alphaTable[i] = this->alpha0_i( previous );	// find the requested root based on
+                                                                        // the previous one
+                }
+    }
+
+    return alphaTable[i];
 }
-return alphaTable[i];
+*/
+
+// =============================================================================
+// Root finding algorithm for alpha function. 
+// Roots (y=0) are necessary to calculate 
+// Modified by wehrens@amolf.nl. nov, 2011
+// =============================================================================
+
+// TODO: check comments for mistakes / completion
+// Scans for next interval where a sign change is observed, and thus where a 
+// root is expected. 
+const void GreensFunction2DRadAbs::GiveRootInterval(
+            Real& low,             // Variable to return left boundary interval
+            Real& high,            // Variable to return right boundary interval
+            const Integer n) const // Order of Bessel functions
+{
+    // Variables for function values @ resp. left and right boundary interval.
+    Real f_low , f_high;
+    
+    // # Get/calculate boundaries and determine width of interval to check for
+    // sign change.
+    const Real estimated_alpha_root_distance_( this->getestimated_alpha_root_distance_() );
+    const Real interval( FRACTION_SCAN_INTERVAL * estimated_alpha_root_distance_);
+                                                        
+    // If order (n) is zero, the offset is zero, otherwhise take n-1 offset
+    // value as first estimate.
+    //      (This can be done because the offsets only get bigger, the roots 
+    // shift to the right with the order of the Bessel functions n.)
+    
+    // Cases:
+    //      1. i = 0 and n = 0; Can't make estimate -> use x=0 to start.
+    //      2. i = 0 and n > 1; Use n-1, i=0 value as estimate.
+    //      3. i > 0; Use value in alpha_x_scan_table_ as estimate.
+    if (alpha_x_scan_table_[n] == 0) { // which implies i == 0   
+	    if (n > 0)
+	    {	
+	        alpha_x_scan_table_[n] = ( this->alphaTable[n-1][0] ); // TODO check if not necessary to use "alphaOffsetTable"
+	    }
+	}	    						
+
+    // Define new interval as between x1=offset ("low") and x2=(offset+interval)
+    // ("high"). Make sure "low" is > 0.
+    low = alpha_x_scan_table_[n];		
+    high = alpha_x_scan_table_[n] + interval;	
+	if (low <= 0)			        // TODO this check should be redundant
+	{	std::cerr << "Left alpha search interval boundary < 0.";//low = EPSILON/L_TYPICAL;
+    	throw std::exception();
+	}
+
+    // # Look for the sign change.
+
+    // Get the values of the function at x "low" and x "high".
+    // Different for n=0 because this results in a simpler function.
+    //      This could be optimized by duplicating all involved functions and 
+    // removing this if-statement. 
+    if (n == 0) {
+        f_low  = f_alpha0(low);	
+        f_high = f_alpha0(high);
+    } else {
+        f_low  = f_alpha(low,n);	
+        f_high = f_alpha(high,n);
+    }	
+
+    // Continue shifting the search interval until a sign change is detected.
+    while( f_low * f_high > 0 )		
+    {					
+        // DEBUG; TODO REMOVE
+        std::cout << "Scanning; no root at:[" << low << "," << high << "]\n";
+    
+        low =  high;			
+        f_low = f_high;			
 
+        high += interval;
+        f_high = f_alpha( high, n );
+    }
+    
+    // When above loop has finished, low and high have values inbetween which
+    // a root of the alpha function should lie have been found. Make sure that 
+    // scanning for the next root starts at the end of the domain [low, high] 
+    // found here.
+    alpha_x_scan_table_[n] = high;
+    
+    return;
 }
 
-const Real GreensFunction2DRadAbs::getAlpha0( const RealVector::size_type i ) const
+// TODO: check comments for mistakes / completion
+// Simply returns an interval based upon previous root, estimated interval 
+// inbetween roots and INTERVAL_MARGIN (see .hpp).
+const void GreensFunction2DRadAbs::GiveRootIntervalSimple(
+            Real& low,          // Variable to return left boundary interval
+            Real& high,         // Variable to return right boundary interval
+            const Integer n,    // Order of Bessel functions
+            const Real i) const // ith root 
 {
-RealVector& alphaTable( this->alphaTable[0] );
-    const RealVector::size_type oldSize( alphaTable.size() );
+    // Offset is simply based on previous root, the interval in which the first 
+    // root (i=0) lies is never calculated with this function.
+    const Real previous_root (getAlpha(n, i-1));
+
+    // get estimated interval
+    const Real estimated_alpha_root_distance_( this->getestimated_alpha_root_distance_() );
+ 
+    // Calculates interval [low, high] where root is expected based on the 
+    // assumption where in a converging regime, where the deviation from this
+    // estimate is not more than INTERVAL_MARGIN.     
+    low  = previous_root + 
+                estimated_alpha_root_distance_ * (1 - INTERVAL_MARGIN);
+    high = previous_root + 
+                estimated_alpha_root_distance_ * (1 + INTERVAL_MARGIN);
+    
+    return;
+}
+
+// ===========================
+const Real 
+GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
+                                      const Real high   // .. and high 
+                                    ) const
+{                                    
+        // Reinterpret_cast converts any pointer type to any other pointer type, 
+	    // even of unrelated classes. Hence below code converts pointer to 
+	    // function ::f_alpha_aux_F() to function pointer, which then points to 
+	    // memory location of params (&params).
+	
+	    // f_alpha0_aux_params is a struct: {gf, value}
+        // n is the summation index (the order of the Bessel functions used        
+    f_alpha0_aux_params params = { this, 0 }; // TODO: purpose of this zero is unclear!!!	
+
+    gsl_function F = 
+    {       	    
+        reinterpret_cast<typeof(F.function)>
+        ( &GreensFunction2DRadAbs::f_alpha0_aux_F ),
+        &params 
+    };				
+
+    // Define solvertype.
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
+    // Initialize the solver.
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );   
+
+    // Call rootfinder, find root called "alpha" and return it.
+    const Real alpha ( findRoot( F, solver, low, high,
+		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRoot0" ) );
+    gsl_root_fsolver_free( solver );
+    
+    return alpha;
+}    
+
+const Real 
+GreensFunction2DRadAbs::getAlphaRootN( const Real low,   // root lies between low
+                                      const Real high,  // .. and high 
+                                      const Integer n   // nth order Bessel
+                                    ) const
+{                                    
+
+    // f_alpha_aux_params is a struct: {gf, n, value}
+    // n is the summation index (the order of the Bessel functions used
+    f_alpha_aux_params params = { this, n, 0 };	// TODO: purpose of this zero is unclear!!!
+    
+    gsl_function F = 
+    {	    
+        reinterpret_cast<typeof(F.function)>
+        ( &GreensFunction2DRadAbs::f_alpha_aux_F ),
+        &params
+    };
 
-if( i >= oldSize )
+
+    // Define solvertype.
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
+    // Initialize the solver.
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );   
+
+    // Call rootfinder, find root called "alpha" and return it.
+    const Real alpha ( findRoot( F, solver, low, high,
+		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRootN" ) );
+    gsl_root_fsolver_free( solver );
+    
+    return alpha;
+}
+
+// ====================    
+
+// This calculates a root based on the previous one (offset) with Bessel functions of order n
+// The roots are calculated based on the previous root which is given as an argument (offset)
+const Real 
+GreensFunction2DRadAbs::getAlphaRoot( const Real low,   // root lies between low
+                                      const Real high,  // .. and high 
+                                      const Integer n   // nth order Bessel
+                                    ) const
 {
-    alphaTable.resize( i+1, 0 );// fill the empty spaces with zeros
+    Real alpha;
+
+    if (n == 0) {
+        alpha = getAlphaRoot0(low, high);
+    } else {
+        alpha = getAlphaRootN(low, high, n);
+    }
+
+    return alpha;
 }
 
-if (alphaTable[i] == 0)         // if the requested root was not calculated yet
+// TODO: check comments for mistakes / completion
+// Subfunction of getAlpha
+const void GreensFunction2DRadAbs::decideOnMethod2(size_t n, 
+                                                   RealVector::size_type i
+                                                  ) const
 {
-            if (i==0)               // if the requested root is the first one
-            {       const Real offset (alphaOffset(0));     // The offset is the first root
-                    alphaTable[i]= offset;
-            }
-            else                    // the requested root is dependent on the previous one
-            {
-                    const Real previous (getAlpha0(i-1));		// get the previous root
-                    alphaTable[i] = this->alpha0_i( previous );	// find the requested root based on
-                                                                    // the previous one
+
+// TODO we could also add to this that if we've been in the margin for a certain
+// amount of time already, we'll also switch. DELIBERATE WITH TOMEK? Well, 
+// actually the overhead is not too bad. If there is only 1 entry, but we expect
+// two, then it will, for each root, check once if there is a sign change in the
+// difference. (Three substractions and a multiplication.)
+
+    // Since the function can only decide with two alpha's already calculated, 
+    // it can't do anything if i = 0.
+    if (i > 0) { 
+
+        const Real dx(getAlpha(n, i)-getAlpha(n, i-1)); // note the recursiveness!
+        const Real estimated_alpha_root_distance_( this->getestimated_alpha_root_distance_() );
+
+        // If the absolute deviation from the expected difference is smaller 
+        // than the expected margin, it is assumed we can use method 2.
+        if (fabs(1-dx/estimated_alpha_root_distance_) < INTERVAL_MARGIN) {
+            ++alpha_dx_entry_in_margin_[n];
+            
+            // There is only a limited amount of times the distance will switch
+            // from expected to be in the margin to being expected not to be in
+            // the margin. Hence if the distance falls within the margin, while
+            // the previous distance didn't, if this happens for more than 
+            // DISTANCE_INOUT_MARGIN times, we permanently switch to method 2. 
+            // (I.e. we will assume the distance between the roots will now 
+            // always stay within the margin.)
+            if (alpha_dx_entry_in_margin_[n] >= DISTANCE_INOUT_MARGIN) {
+                alpha_x_scan_table_[n] = -2; // permanently switch
+            } else {
+                alpha_x_scan_table_[n] = -1; // temporarely switch
             }
+        }    
+    }
+    
+    return;
+}
+
+// TODO: check comments for mistakes / completion
+// Subfunction of getAlpha
+const void GreensFunction2DRadAbs::needToSwitchBackMethod1(
+                                                size_t n, 
+                                                RealVector::size_type i
+                                                ) const
+{
+
+    // We could only have switched when i = 1, hence check is only needed when
+    // i >= 2. Also, (alpha_x_scan_table_[n] == -1) means it is required to 
+    // check, if (alpha_x_scan_table_[n] == -2), a check is not required.
+    if ((i > 1) and (alpha_x_scan_table_[n] == -1)) { 
+        // if the distance has changed from being overestimated to 
+        // underestimated it might be that we're no longer converging, and we 
+        // need to switch back to method 1. 
+        
+        // Get distance between root i & i-1 and distance i-1 & i-2.
+        const Real dx(getAlpha(n, i)-getAlpha(n, i-1)); // note the recursiveness!        
+        const Real dx_previous(getAlpha(n, i-1)-getAlpha(n, i-2)); // note the recursiveness!
+        
+        // If there is a sign change observed
+        if ((dx*dx_previous) < 0) {
+        
+            // Make alpha_x_scan_table_[n]
+            alpha_x_scan_table_[n] = getAlpha(n,i) + EPSILON;
+        }
+    }
+            
+
+    return;
 }
 
-return alphaTable[i];
+// TODO ADD SOME COMMENTS HERE!
+const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
+                                             RealVector::size_type i // ith root
+                                           ) const 
+{
+    Real current_root_, low, high;   
+    
+    // # "Administration"
+
+    // Gets the line of table that corresponds to order (n),     
+    RealVector& alphaTable( this->alphaTable[n] );		        
+    
+    // Gets it's size 
+    const RealVector::size_type oldSize( alphaTable.size() );	
+    
+    // Resizes and fills with zeroes if the vector is too small
+    if( i >= oldSize )
+    {
+        alphaTable.resize( i+1, 0 );	
+    }
+
+    // # Calculating the root
+
+    // Only calculates the root is this has not been done already
+    if (alphaTable[i] == 0)		
+    {        
+    
+        // Method 1. SCANNING. If the roots are not expected to lie close enough 
+        // to the estimate, use the "scanning" procedure to find an interval 
+        // that contains a root. (More robust method.)
+        //      If it is established that we can use method 2, 
+        // alpha_x_scan_table_[n] will contain a value < 0.
+	    if (alpha_x_scan_table_[n] >= 0)
+	    {		        
+	        // ### Gets estimate of interval by sign-change-searching
+	        //      high and low are the return-values of GiveRootInterval.
+	        GiveRootInterval(low, high, n);	        
+	        
+	        // DEBUG; TODO REMOVE
+	        std::cout << "(n="<<n<<",i="<<i<<") Via scan: looking at:[" << low << "," << high << "]\n";
+	        
+	        // ### Finds the root using the GSL rootfinder
+            current_root_ = getAlphaRoot(low, high, n);
+            
+            // ### Puts the found root in the table.
+		    alphaTable[i]= current_root_;
+		    		    
+		    // Check if we can use method 2 temporarily or permanently
+		    decideOnMethod2(n, i);		    
+	    }
+	    // Method 2. ASSUMING CORRECT. If next root is expected to lie close 
+	    // enough to estimate the root can be calculated from a simple estimated 
+	    // interval.
+	    else 
+	    {
+            // ### Get interval by simple extrapolation
+	        GiveRootIntervalSimple(low, high, n, i);	        
+
+	        // DEBUG; TODO REMOVE
+	        std::cout << "(n="<<n<<",i="<<i<<") Via \"sure\" estimate: looking at:[" << low << "," << high << "]\n";
+	    
+	        // ### Finds the root using the GSL rootfinder
+            current_root_ = getAlphaRoot(low, high, n);
+
+            // ### Puts the found root in the table.
+		    alphaTable[i] = current_root_;		    
+
+    		// check if we need to switch back to method 1
+    		needToSwitchBackMethod1(n, i);    		    
+	    }
+	    
+	    // # Looks if we can switch from method 1 to method 2.
+	    
+            // TODO FOLLOWING COMMENT SHOULD BE PLACED SOMEWHERE:
+	        // If alpha_x_scan_table_[n] is:
+	            // >0:  We're using method 1 and want to know if we can use 
+	            //      method 2. So check if we can temporarely or permanently
+	            //      switch to method 2. (For this value of n.)
+	            // -1:  We're using method 2, but it might be that we need to
+	            //      switch back to method 1 again, so check if we need to 
+	            //      switch to method 1. (For this value of n.)
+	            // -2:  We can keep using method 2 forever. No checks are 
+	            //      needed.(For this value of n.)	    
+/*	    
+	    if (i > 0) { // otherwise calculating distance impossible
+
+	    
+	        // We can use method 2 temporarely, this check should be performed
+	        // again.
+	    
+	        // We can use method 2 permanently, this check becomes obsolete
+	    
+	        real distance (current_root_ - alphaTable[i-1]);
+	    }
+*/	    
+    }
+    
+    return alphaTable[i];
+
 }
 
+// =============================================================================
+// End modification
+// =============================================================================
+
 // calculates the ith term with exponent and time for the survival probability
 const Real 
 GreensFunction2DRadAbs::p_survival_i_exp_table( const unsigned int i,
 							const Real t,
 							const RealVector& table ) const
 {
-    const Real alpha( this->getAlpha0( i ) );
+    const Real alpha( this->getAlpha( 0, i ) );
     return std::exp( - getD() * t * alpha * alpha ) * table[i];
 }
 
@@ -555,7 +1046,7 @@ const Real
 GreensFunction2DRadAbs::leavea_i_exp( const unsigned int i,
 					      const Real t) const
 {
-    const Real alpha( this->getAlpha0( i ) );
+    const Real alpha( this->getAlpha( 0,i ) );
     return std::exp( - getD() * t * alpha * alpha ) * calc_A_i_0( alpha );
 }
 
@@ -564,7 +1055,7 @@ const Real
 GreensFunction2DRadAbs::leaves_i_exp( const unsigned int i,
 					      const Real t) const
 {
-    const Real alpha( this->getAlpha0( i ) );
+    const Real alpha( this->getAlpha( 0, i ) );
 
     return std::exp( - getD() * t * alpha * alpha ) * leaves_i( alpha );
 }
@@ -578,7 +1069,7 @@ GreensFunction2DRadAbs::p_int_r_i_exp_table( const unsigned int i,
                					     const RealVector& J0_aAnTable,
 							const RealVector& Y0J1J0Y1Table ) const
 {
-	const Real alpha( this->getAlpha0( i ) );	// get the root An
+	const Real alpha( this->getAlpha( 0, i ) );	// get the root An
 	const Real r_An( r*alpha);
 
 	const Real J1_rAn (gsl_sf_bessel_J1(r_An));
@@ -606,7 +1097,7 @@ GreensFunction2DRadAbs::guess_maxi( const Real t ) const
     const Real sigma( getSigma() );
     const Real a( geta() );
 
-    const Real alpha0( getAlpha0( 0 ) );
+    const Real alpha0( getAlpha( 0, 0 ) );
     const Real Dt( D * t );
     const Real thr( ( exp( - Dt * alpha0 * alpha0 ) / alpha0 ) * this->EPSILON * 1e-1 );
     const Real thrsq( thr * thr );
@@ -648,7 +1139,7 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
             
         if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
         {						// that the table is filled
-        	IGNORE_RETURN getAlpha0( maxi );	// this updates the table of roots
+        	IGNORE_RETURN getAlpha( 0, maxi );	// this updates the table of roots
 		// std::clog << "creating PsurvTable... ";	// DEBUG *REMOVEME*
                 this->createPsurvTable( psurvTable);	// then the table is filled with data
 		// std::clog << "done" << std::endl;	// DEBUG *REMOVEME*
@@ -1012,7 +1503,8 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	const Real h( this->geth() );
 	const Real a( this->geta() );
 	const Real D( this->getD() );
-	const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
+	const Real alpha( this->getAlpha( m, n ) ); // Gets the n-th root using the 
+	                                            // besselfunctions of order m.
 	const Real r0( this->getr0() );
 
     // std::clog << "[r0=" << r0 << "]"; // DEBUG *REMOVEME*
@@ -1072,7 +1564,7 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 
     // DEBUG *REMOVEME*
     if (result == 0.0) {
-        std::clog << "Ladies and gentlemen, we've got alpha=0.";
+        std::clog << "Ladies and gentlemen, we've got 0.";
     }
     // END DEBUG
 	return result;
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 218aa21b..ae461542 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -1,3 +1,12 @@
+// Greens function class for 2d Green's Function for 2d annulus with radial and
+// axial dependence. Inner boundary is radiative (rad) (reaction event), outer 
+// boundary is absorbing (abs) (escape event). Different "draw" functions 
+// provide a way to draw certain values from the Green's Function, e.g. an
+// escape angle theta ("drawTheta" function).
+// 
+// Written by Laurens Bossen. Adapted by Martijn Wehrens.
+// FOM Institute AMOLF.
+
 #if !defined( __FIRSTPASSAGEPAIRGREENSFUNCTION2D_HPP )
 #define __FIRSTPASSAGEPAIRGREENSFUNCTION2D_HPP 
 
@@ -30,12 +39,32 @@ class GreensFunction2DRadAbs
 
     static const Real MIN_T_FACTOR = 1e-8;
 
-    static const Real L_TYPICAL = 1E-7;
-    static const Real T_TYPICAL = 1E-5;
-    static const Real EPSILON = 1E-12;
+    static const Real L_TYPICAL = 1E-7; // typical length scale
+    static const Real T_TYPICAL = 1E-5; // typical time scale
+    static const Real EPSILON = 1E-12;  // relative numeric error
+
+    static const unsigned int MAX_ORDER = 30;		// The maximum number of m 
+                                                    // terms
+    static const unsigned int MAX_ALPHA_SEQ = 2000;	// The maximum number of n 
+                                                    // terms
+    
+    // Parameters for alpha-root finding
+    // ======
+    // Could be tweaked for better performance!
+    //
+    // If we've switched from over- to underestimating the root for 
+    // EXPECTED_OVER_UNDER_SWITCHING times, we'll assume we're in regime where the 
+    // period of the roots converges to the pi/(sigma-a) estimate.
+    //      Hence, if the value of the root lies within INTERVAL_MARGIN 
+    // times the estimated interval, we assume all next roots subsequently have 
+    // the same or less deviation from the estimated pi/(sigma-a) interval. The 
+    // maximum INTERVAL_MARGIN is 0.33, since underestimating >33% twice
+    // in a row will result in two roots in the same sign-change scanning 
+    // domain.
+    static const Real DISTANCE_INOUT_MARGIN = 2;
+    static const Real INTERVAL_MARGIN = .33; 
+    static const Real FRACTION_SCAN_INTERVAL = .5; // Distance between subsequent roots should always > this
 
-    static const unsigned int MAX_ORDER = 30;		// The maximum number of m terms
-    static const unsigned int MAX_ALPHA_SEQ = 2000;	// The maximum number of n terms
 
 public:
 
@@ -62,6 +91,11 @@ class GreensFunction2DRadAbs
 	return this->a;
     }
 
+    const Real getestimated_alpha_root_distance_() const
+    {
+    return this->estimated_alpha_root_distance_;
+    }
+
     virtual Real drawTime( const Real rnd) const;
 
     virtual EventKind drawEventType( const Real rnd, 
@@ -110,9 +144,40 @@ class GreensFunction2DRadAbs
 
     const Real alphaOffset( const unsigned int n ) const;
 
-    const Real alpha0_i( const Real previous ) const;
-
-    const Real alpha_i( const Real offset, const Integer n ) const;
+//    const Real alpha0_i( const Real previous ) const;
+
+//    const Real alpha_i( const Real offset, const Integer n ) const;
+
+                                                          
+    const void GiveRootInterval(  Real& low,          
+                                  Real& high,         
+                                  const Integer n
+                               ) const;
+                                                                    
+
+    const void GiveRootIntervalSimple(  Real& low, Real& high, 
+                                        const Integer n, const Real i
+                                     ) const;
+
+    const Real getAlphaRoot0( const Real low,
+                              const Real high
+                            ) const;
+                                    
+    const Real getAlphaRootN( const Real low,  
+                              const Real high,  
+                              const Integer n  
+                            ) const;                                 
+                                                            
+    const Real getAlphaRoot(  const Real high, const Real low, const Integer n
+                           ) const;
+                                                    
+    const void decideOnMethod2(size_t n, RealVector::size_type i) const;
+
+    const void 
+        needToSwitchBackMethod1( size_t n, RealVector::size_type i ) const;
+
+    const Real getAlpha( size_t n, RealVector::size_type i ) const; 
+    
 
     const Real p_survival_i( const Real alpha) const;
 
@@ -123,9 +188,9 @@ class GreensFunction2DRadAbs
     const boost::tuple<Real,Real,Real> Y0J0J1_constants ( const Real alpha,
                                                           const Real t) const;
 
-    const Real getAlpha( const size_t n, const RealVector::size_type i ) const;
+//    const Real getAlpha( const size_t n, const RealVector::size_type i ) const;
 
-    const Real getAlpha0( const RealVector::size_type i ) const;
+//    const Real getAlpha0( const RealVector::size_type i ) const;
 
 protected:
 
@@ -181,21 +246,21 @@ class GreensFunction2DRadAbs
     const unsigned int guess_maxi( const Real t ) const;
 
     struct f_alpha0_aux_params
-    { 
-	const GreensFunction2DRadAbs* const gf;
-	const Real value;
+    {
+        const GreensFunction2DRadAbs* const gf;
+        const Real value;
     };
 
-    static const Real 
-    f_alpha0_aux_F( const Real alpha,
-		    const f_alpha0_aux_params* const params );
+    static const Real
+        f_alpha0_aux_F( const Real alpha,
+                const f_alpha0_aux_params* const params );
 
 
     struct f_alpha_aux_params
-    { 
-	const GreensFunction2DRadAbs* const gf;
-	const Integer n;
-	Real value;
+    {
+        const GreensFunction2DRadAbs* const gf;
+        const Integer n;
+        Real value;
     };
 
     static const Real 
@@ -246,11 +311,40 @@ class GreensFunction2DRadAbs
 private:
     
     const Real h;
-
+    const Real a;
+
+    // Tables that hold calculated roots (y=0) of "alpha" function for each    
+    // order n.
+    //      The alphaOffsetTable will be filled with 1st roots for all n. The 
+    // alphaTable will also be filled with these 1st roots, but also the mth 
+    // roots for all n.
+    //      Note that number of elements is MAX_ORDER+1 as the order n can range
+    // from n=0 to n=MAX_ORDER.
+    //      Initial values are set by constructor.
     mutable boost::array<Real,MAX_ORDER+1> alphaOffsetTable;
     mutable boost::array<RealVector,MAX_ORDER+1> alphaTable;
-
-    Real a;
+    
+    const Real estimated_alpha_root_distance_;    
+    
+    // LEGACY
+    // Table which for each order n tells if we're in regime where next root
+    // will lie in [x_previous_root-INTERVAL_ALLOWED_ERROR, x_previous_root
+    // +INTERVAL_ALLOWED_ERROR]. In that case value n of table will be true, 
+    // if we still have to scan for a sign-change, than value n in table will
+    // be false.
+    // mutable boost::array<bool,MAX_ORDER+1> alphaRootsConverged;
+    
+    // Table which tells us at which x we're left with scanning the alpha 
+    // function for a sign change, for a given order n. (A sign change would 
+    // indicate a root (y=0) lies between the boundaries of the "scanned" 
+    // interval.) 
+    //      If x_scan[n] == -1, this indicates scanning is no longer required
+    // because the distance between the roots is converging and within 
+    // boundaries that allow the direct use of the estimate interval width 
+    // pi/(sigma-a).
+    //      Initial values are set by constructor.
+    mutable boost::array<Real,MAX_ORDER+1> alpha_x_scan_table_;     
+    mutable boost::array<int,MAX_ORDER+1> alpha_dx_entry_in_margin_;
 
 };
 
diff --git a/egfrd.py b/egfrd.py
index 987862f6..a9b20d48 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -73,8 +73,8 @@ class DomainEvent(Event):
     __slot__ = ['data']
     def __init__(self, time, domain):
         Event.__init__(self, time)
-        self.data = domain.domain_id		# Store the domain_id key refering to the domain
-						# in domains{} in the scheduler
+        self.data = domain.domain_id            # Store the domain_id key refering to the domain
+                                                # in domains{} in the scheduler
 
 class Delegate(object):
     def __init__(self, obj, method, arg):
@@ -115,31 +115,31 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.domain_id_generator = DomainIDGenerator(0)
         self.shell_id_generator = ShellIDGenerator(0)
 
-	# some constants
-        self.MULTI_SHELL_FACTOR = 1.05		# This is the threshold for when the algorithm switches from
-						# NonInteractionSingles to a Multi and also defines the Multi
-						# shell size.
-        self.SINGLE_SHELL_FACTOR = 2.0		# This is the threshold for when the algorithm switches from
-						# NonInteractionSingles to a Pair or Interaction. It also defines
-						# the radius in which the NonInteractionSingle will burst.
-	self.MAX_NUM_DT0_STEPS = 10000
+        # some constants
+        self.MULTI_SHELL_FACTOR = 1.05          # This is the threshold for when the algorithm switches from
+                                                # NonInteractionSingles to a Multi and also defines the Multi
+                                                # shell size.
+        self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
+                                                # NonInteractionSingles to a Pair or Interaction. It also defines
+                                                # the radius in which the NonInteractionSingle will burst.
+        self.MAX_NUM_DT0_STEPS = 10000
 
-	self.MAX_TIME_STEP = 10
+        self.MAX_TIME_STEP = 10
 
-	# used datastructrures
-        self.scheduler = EventScheduler()	# contains the events. Note that every domains has exactly one event
+        # used datastructrures
+        self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
 
-        self.domains = {}			# a dictionary containing references to the domains that are defined
-						# in the simulation system. The id of the domain (domain_id) is the key.
-						# The domains can be a single, pair or multi of any type.
+        self.domains = {}                       # a dictionary containing references to the domains that are defined
+                                                # in the simulation system. The id of the domain (domain_id) is the key.
+                                                # The domains can be a single, pair or multi of any type.
 
-	# other stuff
-        self.is_dirty = True			# The simulator is dirty if the state if the simulator is not
-						# consistent with the content of the world that it represents
-						# (or if we don't know for sure)
+        # other stuff
+        self.is_dirty = True                    # The simulator is dirty if the state if the simulator is not
+                                                # consistent with the content of the world that it represents
+                                                # (or if we don't know for sure)
 
-        self.reset()				# The Simulator is only initialized at the first step, allowing
-						# modifications to the world to be made before simulation starts
+        self.reset()                            # The Simulator is only initialized at the first step, allowing
+                                                # modifications to the world to be made before simulation starts
 
     def get_next_time(self):
         """ 
@@ -147,8 +147,8 @@ def get_next_time(self):
         is completed.        
         """ #~MW
         if self.scheduler.size == 0:
-            return self.t			# self.t is the current time of the simulator
-	else:
+            return self.t                       # self.t is the current time of the simulator
+        else:
             return self.scheduler.top[1].time
 
     ###
@@ -160,7 +160,7 @@ def reset(self):
         the simulator time is reset, the step counter is reset, events
         are reset, etc.
         Can be for example usefull when users want to first do an equilibration
-	run before starting the "real experiment".
+        run before starting the "real experiment".
         """ #~ MW
         self.t = 0.0
         self.dt = 0.0
@@ -182,27 +182,27 @@ def reset(self):
         self.last_event = None
         self.last_reaction = None
 
-        self.is_dirty = True		# simulator needs to be re-initialized
+        self.is_dirty = True            # simulator needs to be re-initialized
 
     def initialize(self):
-	"""Initialize the eGFRD simulator
-
-	This method (re-)initializes the simulator with the current state of the 'world'
-	that it represents.
-	Call this method if you change the 'world' using methods outside of the Simulator
-	thereby invalidating the state of the eGFRD simulator (the simulator is dirty), or
-	in an other case that the state of the simulator is inconsistent with the state of
-	the world.
-	"""
-	# 1. (re-)initialize previously set datastructures
+        """Initialize the eGFRD simulator
+
+        This method (re-)initializes the simulator with the current state of the 'world'
+        that it represents.
+        Call this method if you change the 'world' using methods outside of the Simulator
+        thereby invalidating the state of the eGFRD simulator (the simulator is dirty), or
+        in an other case that the state of the simulator is inconsistent with the state of
+        the world.
+        """
+        # 1. (re-)initialize previously set datastructures
         ParticleSimulatorBase.initialize(self)
         self.scheduler.clear()
         self.domains = {}
 
-	# create/clear other datastructures
-	self.geometrycontainer = ShellContainer(self.world)
+        # create/clear other datastructures
+        self.geometrycontainer = ShellContainer(self.world)
 
-	# 2. Couple all the particles in 'world' to a new 'single' in the eGFRD simulator
+        # 2. Couple all the particles in 'world' to a new 'single' in the eGFRD simulator
         # Fix order of adding particles (always, or at least in debug mode).
         singles = []
         pid_particle_pairs = list(self.world)
@@ -218,13 +218,13 @@ def initialize(self):
         for single in singles:
             self.add_domain_event(single)
 
-	# 3. The simulator is now consistent with 'world'
+        # 3. The simulator is now consistent with 'world'
         self.is_dirty = False
 
     def stop(self, t):
         """Bring the simulation to a full stop, which synchronizes all
-	particles at time t. The state is similar to the state after
-	initialization.
+        particles at time t. The state is similar to the state after
+        initialization.
 
         With eGFRD, particle positions are normally updated 
         asynchronously. This method bursts all protective domains so that 
@@ -246,10 +246,10 @@ def stop(self, t):
         if __debug__:
             log.info('stop at %s' % (FORMAT_DOUBLE % t))
 
-        if self.t == t:				# We actually already stopped?
-            return				# FIXME: is this accurate? Probably use feq from utils.py
+        if self.t == t:                         # We actually already stopped?
+            return                              # FIXME: is this accurate? Probably use feq from utils.py
 
-        if t >= self.scheduler.top[1].time:	# Can't schedule a stop later than the next event time
+        if t >= self.scheduler.top[1].time:     # Can't schedule a stop later than the next event time
             raise RuntimeError('Stop time >= next event time.')
 
         if t < self.t:
@@ -298,15 +298,15 @@ def step(self):
         if __debug__:
             if self.scheduler.size == 0:
                 raise RuntimeError('No Events in scheduler.')
-	
-	# 1. Get the next event from the scheduler
-	#
+        
+        # 1. Get the next event from the scheduler
+        #
         id, event = self.scheduler.pop()
-	domain = self.domains[event.data]
-	if event.time == numpy.inf:
-	    self.t, self.last_event = self.MAX_TIME_STEP, event
-	else:
-	    self.t, self.last_event = event.time, event
+        domain = self.domains[event.data]
+        if event.time == numpy.inf:
+            self.t, self.last_event = self.MAX_TIME_STEP, event
+        else:
+            self.t, self.last_event = event.time, event
 
         if __debug__:
             domain_counts = self.count_domains()
@@ -317,22 +317,22 @@ def step(self):
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
        
-	# 2. Use the correct method to process (fire) the shell that produced the event
-	#
+        # 2. Use the correct method to process (fire) the shell that produced the event
+        #
         # Dispatch is a dictionary (hash) of what function to use to fire
         # different classes of shells (see bottom egfrd.py) 
         # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
         # e.g. "if class is Single, then process_single_event" ~ MW
         for klass, f in self.dispatch:
             if isinstance(domain, klass):
-                f(self, domain)		# fire the correct method for the class (e.g. fire_singel(self, Single))
+                f(self, domain)         # fire the correct method for the class (e.g. fire_singel(self, Single))
 
         if __debug__:
             if self.scheduler.size == 0:
                 raise RuntimeError('Zero events left.')
 
-	# 3. Adjust the simulation time
-	#
+        # 3. Adjust the simulation time
+        #
         next_time = self.scheduler.top[1].time
         self.dt = next_time - self.t
 
@@ -353,8 +353,8 @@ def step(self):
 
 
     def create_single(self, pid_particle_pair):
-	# 1. generate identifiers for the domain and shell. The event_id is
-	# generated by the scheduler
+        # 1. generate identifiers for the domain and shell. The event_id is
+        # generated by the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
@@ -364,7 +364,7 @@ def create_single(self, pid_particle_pair):
         structure = self.world.get_structure(species.structure_id)
 
         # 2. Create and register the single domain.
-	# The type of the single that will be created 
+        # The type of the single that will be created 
         # depends on the structure (region or surface) this particle is 
         # in/on. Either SphericalSingle, PlanarSurfaceSingle, or 
         # CylindricalSurfaceSingle.
@@ -372,10 +372,10 @@ def create_single(self, pid_particle_pair):
                                        shell_id, rrs, structure)
 
         assert isinstance(single, NonInteractionSingle)
-        single.initialize(self.t)		# set the initial event and event time
+        single.initialize(self.t)               # set the initial event and event time
         self.domains[domain_id] = single
 
-	# 3. update the proper shell container
+        # 3. update the proper shell container
         self.geometrycontainer.move_shell(single.shell_id_shell_pair)
 
         if __debug__:
@@ -384,18 +384,18 @@ def create_single(self, pid_particle_pair):
         return single
 
     def create_interaction(self, pid_particle_pair, surface, shell_center,
-			   shell_radius, shell_half_length, shell_unit_z):
+                           shell_radius, shell_half_length, shell_unit_z):
 
 ##        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
-#	assert that the particle is not already associate with another domain
+#       assert that the particle is not already associate with another domain
 
-	# 1. generate identifiers for the domain and shell. event_id is generated by
-	# the scheduler
+        # 1. generate identifiers for the domain and shell. event_id is generated by
+        # the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
         species_id = pid_particle_pair[1].sid
-	species = self.world.get_species(species_id)
+        species = self.world.get_species(species_id)
 
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
         # TODO.
@@ -405,9 +405,9 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
         structure = self.world.get_structure(species.structure_id)
 
-	particle_pos = pid_particle_pair[1].position
+        particle_pos = pid_particle_pair[1].position
 
-    	if isinstance(surface, CylindricalSurface):
+        if isinstance(surface, CylindricalSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
             projected_point, r0 = surface.projected_point(particle_pos)
             shell_unit_r = normalize(particle_pos - projected_point)
@@ -419,7 +419,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
                                                         shell_id, shell_center, shell_radius,
                                                         shell_half_length, shell_unit_z, z0,
                                                         shell_unit_r, r0, interaction_rules, surface)
-	elif isinstance(surface, PlanarSurface):
+        elif isinstance(surface, PlanarSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
             z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
 
@@ -434,7 +434,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
         interaction.initialize(self.t)
         self.domains[domain_id] = interaction
 
-	# 3. update the shell containers 
+        # 3. update the shell containers 
         self.geometrycontainer.move_shell(interaction.shell_id_shell_pair)
 
         if __debug__:
@@ -447,19 +447,19 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         assert single1.dt == 0.0
         assert single2.dt == 0.0
 
-	pid_particle_pair1 = single1.pid_particle_pair
-	pid_particle_pair2 = single2.pid_particle_pair
+        pid_particle_pair1 = single1.pid_particle_pair
+        pid_particle_pair2 = single2.pid_particle_pair
 
-	# 1. generate needed identifiers
+        # 1. generate needed identifiers
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
         # Select 1 reaction type out of all possible reaction types between the two particles.
         rrs = self.network_rules.query_reaction_rule(pid_particle_pair1[1].sid,
-					             pid_particle_pair2[1].sid)
+                                                     pid_particle_pair2[1].sid)
 
         # Get structure (region or surface) where particle1 lives (assuming particle2
-	# also lives here -> TODO).
+        # also lives here -> TODO).
         species1 = self.world.get_species(pid_particle_pair1[1].sid)
         structure = self.world.get_structure(species1.structure_id)
 
@@ -471,11 +471,11 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         pair = create_default_pair(domain_id, com, single1, single2, shell_id, 
                                    r0, shell_size, rrs, structure)
 
-	assert isinstance(pair, Pair)
+        assert isinstance(pair, Pair)
         pair.initialize(self.t)
         self.domains[domain_id] = pair
 
-	# 3. update the shell containers with the new shell
+        # 3. update the shell containers with the new shell
         self.geometrycontainer.move_shell(pair.shell_id_shell_pair)
 
         if __debug__:
@@ -484,7 +484,7 @@ def create_pair(self, single1, single2, com, r0, shell_size):
         return pair
 
     def create_multi(self):
-	# 1. generate necessary id's
+        # 1. generate necessary id's
         domain_id = self.domain_id_generator()
 
         if __debug__:
@@ -496,12 +496,12 @@ def create_multi(self):
         else:
             dt_factor = DEFAULT_DT_FACTOR
 
-	# 2. Create and register domain object
+        # 2. Create and register domain object
         multi = Multi(domain_id, self, dt_factor)
         self.domains[domain_id] = multi
 
-	# 3. no shells are yet made, since these are added later
-	# -> a multi can have 0 shells
+        # 3. no shells are yet made, since these are added later
+        # -> a multi can have 0 shells
         return multi
 
 
@@ -526,42 +526,42 @@ def update_single_shell(self, single, position, radius=None):
         self.geometrycontainer.move_shell(shell_id_shell_pair)
 
     def move_particle(self, pid_particle_pair, position):
-	# moves a particle in world based on an existing particle
+        # moves a particle in world based on an existing particle
 
         new_pid_particle_pair = (pid_particle_pair[0],
-	                         Particle(position,
+                                 Particle(position,
                                           pid_particle_pair[1].radius,
-                                   	  pid_particle_pair[1].D,
-                                   	  pid_particle_pair[1].sid))
+                                          pid_particle_pair[1].D,
+                                          pid_particle_pair[1].sid))
 
         self.world.update_particle(new_pid_particle_pair)
 
-	return new_pid_particle_pair
+        return new_pid_particle_pair
 
     def remove_domain(self, obj):
-	# Removes all the ties to a domain (single, pair, multi) from the system.
-	# Note that the particles that it represented still exist
-	# in 'world' and that obj also still persits (?!)
+        # Removes all the ties to a domain (single, pair, multi) from the system.
+        # Note that the particles that it represented still exist
+        # in 'world' and that obj also still persits (?!)
         if __debug__:
             log.info("remove: %s" % obj)
-	# TODO assert that the domain is not still in the scheduler
+        # TODO assert that the domain is not still in the scheduler
         del self.domains[obj.domain_id]
         for shell_id_shell_pair in obj.shell_list:
-	    self.geometrycontainer.remove_shell(shell_id_shell_pair)
+            self.geometrycontainer.remove_shell(shell_id_shell_pair)
 
 ### TODO These methods can be made methods to the scheduler class
     def add_domain_event(self, domain):
     # This method makes an event for domain 'domain' in the scheduler.
     # The event will have the domain_id pointing to the appropriate domain in 'domains{}'.
     # The domain will have the event_id pointing to the appropriate event in the scheduler.
-	event_time = self.t + domain.dt
+        event_time = self.t + domain.dt
         event_id = self.scheduler.add(
             DomainEvent(event_time, domain))
         if __debug__:
             log.info('add_event: %s, event=#%d, t=%s' %
                      (domain.domain_id, event_id,
                       FORMAT_DOUBLE % (event_time)))
-        domain.event_id = event_id			# FIXME side effect programming -> unclear!!
+        domain.event_id = event_id                      # FIXME side effect programming -> unclear!!
 
     def remove_event(self, event):
         if __debug__:
@@ -588,9 +588,9 @@ def burst_domain(self, domain):
             bursted = [single1, single2]
         else:  # Multi
 #            bursted = self.burst_multi(domain)
-            bursted = self.break_up_multi(domain)	# Multi's can't really be 'bursted' since the
-							# positions of the particles are known. They
-							# are broken up to singles with a dt=0 shell instead.
+            bursted = self.break_up_multi(domain)       # Multi's can't really be 'bursted' since the
+                                                        # positions of the particles are known. They
+                                                        # are broken up to singles with a dt=0 shell instead.
             self.remove_event(domain)
 
         if __debug__:
@@ -620,13 +620,13 @@ def burst_volume(self, pos, radius, ignore=[]):
             - radius: radius of area to be "bursted"
             - ignore: domains that should be ignored, none by default.
         """ # ~ MW
-	# TODO burst_volume now always assumes a spherical volume to burst.
-	# It is inefficient to burst on the 'other' side of the membrane or to
-	# burst in a circle, when you want to make a new shell in the membrane.
-	# Then we may want to burst in a cylindrical volume, not a sphere
+        # TODO burst_volume now always assumes a spherical volume to burst.
+        # It is inefficient to burst on the 'other' side of the membrane or to
+        # burst in a circle, when you want to make a new shell in the membrane.
+        # Then we may want to burst in a cylindrical volume, not a sphere
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius,
                                                                                ignore)
-	neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
         return self.burst_objs(neighbors)
 
     def burst_non_multis(self, domains):
@@ -634,118 +634,118 @@ def burst_non_multis(self, domains):
 
         for domain in domains:
             if not isinstance(domain, Multi):
-		# domain is Single or Pair of some subclass
+                # domain is Single or Pair of some subclass
                 single_list = self.burst_domain(domain)
                 bursted.extend(single_list)
             else:
-		# domain is a Multi
+                # domain is a Multi
                 bursted.append(domain)
 
         return bursted
 
     def fire_single_reaction(self, single, reactant_pos):
-	# This takes care of the identity change when a single particle decays into
-	# one or a number of other particles
-	# It performs the reactions:
-	# A(any structure) -> 0
-	# A(any structure) -> B(same structure or 3D)
-	# A(any structure) -> B(same structure) + C(same structure or 3D)
-
-	# 0. get reactant info
-	reactant           = single.pid_particle_pair
+        # This takes care of the identity change when a single particle decays into
+        # one or a number of other particles
+        # It performs the reactions:
+        # A(any structure) -> 0
+        # A(any structure) -> B(same structure or 3D)
+        # A(any structure) -> B(same structure) + C(same structure or 3D)
+
+        # 0. get reactant info
+        reactant           = single.pid_particle_pair
         reactant_radius    = reactant[1].radius
         reactant_structure = single.structure
         rr = single.reactionrule
 
-	# 1. remove the particle
+        # 1. remove the particle
 
         if len(rr.products) == 0:
             
-	    # 1. No products, no info
-	    # 2. No space required
-	    # 3. No space required
-	    # 4. process the changes (remove particle, make new ones)
+            # 1. No products, no info
+            # 2. No space required
+            # 3. No space required
+            # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(reactant[0])
-	    products = []
+            products = []
 
-	    # 5. No new single to be made
-	    # 6. Log the change
+            # 5. No new single to be made
+            # 6. Log the change
 
             
         elif len(rr.products) == 1:
-	# TODO product particle can live on different structure
+        # TODO product particle can live on different structure
             
-	    # 1. get product info
+            # 1. get product info
             product_species = self.world.get_species(rr.products[0])
-	    product_radius  = product_species.radius
-	    product_structure = self.world.get_structure(product_species.structure_id) 
-
-	    # 1.5 produce a number of new possible positions for the product particle
-	    # TODO make these generators for efficiency
-	    if product_structure != reactant_structure:
-		assert isinstance(product_structure, CuboidalRegion)
-
-		if isinstance(reactant_structure, PlanarSurface):
-		    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR	# the thickness of the membrane is 0.0
-		    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
-					for direction in [-1,1]]	# FIXME the direction should be randomized
-
-		elif isinstance(reactant_structure, CylindricalSurface):
-		    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
-		    product_pos_list = []
-		    for _ in range(self.dissociation_retry_moves):
-			unit_vector3D = random_unit_vector()
-			unit_vector2D = normalize(unit_vector3D - numpy.dot(unit_vector3D, reactant_structure.shape.unit_z))
-			vector = reactant_pos + vector_length * unit_vector2D
-			product_pos_list.append(vector)
-		else:
-		    # cannot decay from 3D to other structure
-            	    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
-	    else:
-	        product_pos_list = [reactant_pos]		# no change of position is required if structure doesn't change
-
-
-	    # TODO try alternatives if surrounding is crowded
-	    product_pos = product_pos_list[0]
-	    product_pos = self.world.apply_boundary(product_pos)
+            product_radius  = product_species.radius
+            product_structure = self.world.get_structure(product_species.structure_id) 
+
+            # 1.5 produce a number of new possible positions for the product particle
+            # TODO make these generators for efficiency
+            if product_structure != reactant_structure:
+                assert isinstance(product_structure, CuboidalRegion)
+
+                if isinstance(reactant_structure, PlanarSurface):
+                    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # the thickness of the membrane is 0.0
+                    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
+                                        for direction in [-1,1]]        # FIXME the direction should be randomized
+
+                elif isinstance(reactant_structure, CylindricalSurface):
+                    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
+                    product_pos_list = []
+                    for _ in range(self.dissociation_retry_moves):
+                        unit_vector3D = random_unit_vector()
+                        unit_vector2D = normalize(unit_vector3D - numpy.dot(unit_vector3D, reactant_structure.shape.unit_z))
+                        vector = reactant_pos + vector_length * unit_vector2D
+                        product_pos_list.append(vector)
+                else:
+                    # cannot decay from 3D to other structure
+                    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+            else:
+                product_pos_list = [reactant_pos]               # no change of position is required if structure doesn't change
+
+
+            # TODO try alternatives if surrounding is crowded
+            product_pos = product_pos_list[0]
+            product_pos = self.world.apply_boundary(product_pos)
 
             # 2. make space for the products.
 #            if product_pos != reactant_pos or product_radius > reactant_radius:
             self.burst_volume(product_pos, product_radius)
 
-	    # 3. check that there is space for the products 
+            # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
-		# 4. Process (the lack of) change
-		moved_reactant = self.move_particle(reactant, reactant_pos)
-                products = [moved_reactant]	# no change
+                # 4. Process (the lack of) change
+                moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]     # no change
 
-		# 5. update counters
-        	self.rejected_moves += 1
+                # 5. update counters
+                self.rejected_moves += 1
 
-		# 6. Log the event
+                # 6. Log the event
                 if __debug__:
-            	    log.info('single reaction; placing product failed.')
-	    else:
-	        # 4. process the changes (remove particle, make new ones)
+                    log.info('single reaction; placing product failed.')
+            else:
+                # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(reactant[0])
                 newparticle = self.world.new_particle(product_species.id, product_pos)
-	        products = [newparticle]
+                products = [newparticle]
 
-		# 5. update counters
-        	self.reaction_events += 1
-        	self.last_reaction = (rr, (reactant[1], None), products)
+                # 5. update counters
+                self.reaction_events += 1
+                self.last_reaction = (rr, (reactant[1], None), products)
 
-	        # 6. Log the change
+                # 6. Log the change
                 if __debug__:
                      log.info('product (%s) = %s' % (len(products), products))
 
             
         elif len(rr.products) == 2:
-	    # 1. get product info
+            # 1. get product info
             product1_species = self.world.get_species(rr.products[0])
             product2_species = self.world.get_species(rr.products[1])
-	    product1_structure = self.world.get_structure(product1_species.structure_id) 
-	    product2_structure = self.world.get_structure(product2_species.structure_id) 
+            product1_structure = self.world.get_structure(product1_species.structure_id) 
+            product2_structure = self.world.get_structure(product2_species.structure_id) 
             
             D1 = product1_species.D
             D2 = product2_species.D
@@ -756,358 +756,361 @@ def fire_single_reaction(self, single, reactant_pos):
 
             # calculate the displace of the particles according to the ratio D1:D2
             # this way, species with small D only have small displacement from the reaction point.
-	    if D1 == D2:
-	    # special case (this should also catch D1==D2==0.0)
-		product1_displacement = particle_radius12 * 0.5
-		product2_displacement = particle_radius12 * 0.5
-	    else:
+            if D1 == D2:
+            # special case (this should also catch D1==D2==0.0)
+                product1_displacement = particle_radius12 * 0.5
+                product2_displacement = particle_radius12 * 0.5
+            else:
                 D12 = D1 + D2
-	        product1_displacement = particle_radius12 * (D1 / D12)
-	        product2_displacement = particle_radius12 * (D2 / D12)
-
-	    product1_displacement *= MINIMAL_SEPARATION_FACTOR
-	    product2_displacement *= MINIMAL_SEPARATION_FACTOR
-
-
-	    if product1_structure != product2_structure:
-		# make sure that the reactant was on a 2D or 1D surface
-		assert not isinstance(reactant_structure, CuboidalRegion)
-		# make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
-		assert (isinstance(product1_structure, CuboidalRegion) ^ isinstance(product2_structure, CuboidalRegion))
-
-		# figure out which product stays in the surface and which one goes to 3D
-		if isinstance(product2_structure, CuboidalRegion):
-		    # product2 goes to 3D and is now particleB (product1 is particleA)
-		    productA_displacement = product1_displacement
-		    productB_displacement = product2_displacement
-		    productB_radius = product2_radius
-		    default = True	# we like to think of this as the default
-		else:
-		    # product1 goes to 3D and is now particleB (product2 is particleA)
-		    productA_displacement = product2_displacement
-		    productB_displacement = product1_displacement
-		    productB_radius = product1_radius
-		    default = False
-		# Note that A is a particle in the surface and B is in the 3D
-
-		if isinstance(reactant_structure, PlanarSurface):
-
-		    # draw a number of new positions for the two product particles
-		    # TODO make this into a generator
-		    phi_min = math.asin (productB_radius / particle_radius12)	# we assume the membrane to have zero thickness
-		    phi_min *= MINIMAL_SEPARATION_FACTOR	# make sure that there's some distance from the membrane
-
-		    product_pos_list = []
-		    for _ in range(self.dissociation_retry_moves):
-			# draw the random angle for the 3D particle relative to the particle left in the membrane
-			# not all angles are available because particle cannot intersect with the membrane
-		        phi = myrandom.uniform(phi_min, Pi - phi_min)
-
-		        cos_phi = math.cos(phi) 
-			sin_phi = math.sin(phi)
-
-		        productA_displacement_xy = productA_displacement * cos_phi
-		        productB_displacement_xy = productB_displacement * cos_phi
-			productB_displacement_z  = particle_radius12 * sin_phi
-
-			# pick a random orientation
-			orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
-			# pick a random side of the membrane
-			orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-
-			newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
-			newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
-						 productB_displacement_z  * orientation_vector_z
+                product1_displacement = particle_radius12 * (D1 / D12)
+                product2_displacement = particle_radius12 * (D2 / D12)
+
+            product1_displacement *= MINIMAL_SEPARATION_FACTOR
+            product2_displacement *= MINIMAL_SEPARATION_FACTOR
+
+
+            if product1_structure != product2_structure:
+                # make sure that the reactant was on a 2D or 1D surface
+                assert not isinstance(reactant_structure, CuboidalRegion)
+                # make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
+                assert (isinstance(product1_structure, CuboidalRegion) ^ isinstance(product2_structure, CuboidalRegion))
+
+                # figure out which product stays in the surface and which one goes to 3D
+                if isinstance(product2_structure, CuboidalRegion):
+                    # product2 goes to 3D and is now particleB (product1 is particleA)
+                    productA_displacement = product1_displacement
+                    productB_displacement = product2_displacement
+                    productB_radius = product2_radius
+                    default = True      # we like to think of this as the default
+                else:
+                    # product1 goes to 3D and is now particleB (product2 is particleA)
+                    productA_displacement = product2_displacement
+                    productB_displacement = product1_displacement
+                    productB_radius = product1_radius
+                    default = False
+                # Note that A is a particle in the surface and B is in the 3D
+
+                if isinstance(reactant_structure, PlanarSurface):
+
+                    # draw a number of new positions for the two product particles
+                    # TODO make this into a generator
+                    phi_min = math.asin (productB_radius / particle_radius12)   # we assume the membrane to have zero thickness
+                    phi_min *= MINIMAL_SEPARATION_FACTOR        # make sure that there's some distance from the membrane
+
+                    product_pos_list = []
+                    for _ in range(self.dissociation_retry_moves):
+                        # draw the random angle for the 3D particle relative to the particle left in the membrane
+                        # not all angles are available because particle cannot intersect with the membrane
+                        phi = myrandom.uniform(phi_min, Pi - phi_min)
+
+                        cos_phi = math.cos(phi) 
+                        sin_phi = math.sin(phi)
+
+                        productA_displacement_xy = productA_displacement * cos_phi
+                        productB_displacement_xy = productB_displacement * cos_phi
+                        productB_displacement_z  = particle_radius12 * sin_phi
+
+                        # pick a random orientation
+                        orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
+                        # pick a random side of the membrane
+                        orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+
+                        newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
+                        newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
+                                                 productB_displacement_z  * orientation_vector_z
                         newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
 
                         assert (self.world.distance(newposA, newposB) >= particle_radius12)
-			assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
+                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
 
-			if default:
-			    newpos1, newpos2 = newposA, newposB
-			else:
-			    newpos1, newpos2 = newposB, newposA
+                        if default:
+                            newpos1, newpos2 = newposA, newposB
+                        else:
+                            newpos1, newpos2 = newposB, newposA
 
-			product_pos_list.append((newpos1, newpos2))
+                        product_pos_list.append((newpos1, newpos2))
 
-		elif isinstance(reactant_structure, CylindricalSurface):
+                elif isinstance(reactant_structure, CylindricalSurface):
 
-		    # TODO insert reverse transformation for 3D/1D here
-		    surface_displace = product3D_radius + reactant_structure.shape.radius
+                    # TODO insert reverse transformation for 3D/1D here
+                    surface_displace = product3D_radius + reactant_structure.shape.radius
 
-		else:
-		    # cannot decay from 3D to other structure
-            	    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+                else:
+                    # cannot decay from 3D to other structure
+                    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
-	    else:
-		# The two particles stay on the same structure.
+            else:
+                # The two particles stay on the same structure.
 
-		# generate new positions in the structure
-	        # TODO Make this into a generator
-		product_pos_list = []
+                # generate new positions in the structure
+                # TODO Make this into a generator
+                product_pos_list = []
                 for _ in range(self.dissociation_retry_moves):
-		    # calculate a random vector in the structure with unit length
-		    # FIXME for particles on the cylinder there are only two possibilities
+                    # calculate a random vector in the structure with unit length
+                    # FIXME for particles on the cylinder there are only two possibilities
                     orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
             
-		    newpos1 = reactant_pos + product1_displacement * orientation_vector
-		    newpos2 = reactant_pos - product2_displacement * orientation_vector
+                    newpos1 = reactant_pos + product1_displacement * orientation_vector
+                    newpos2 = reactant_pos - product2_displacement * orientation_vector
                     newpos1 = self.world.apply_boundary(newpos1)
                     newpos2 = self.world.apply_boundary(newpos2)
 
                     assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
-		    product_pos_list.append((newpos1, newpos2))
+                    product_pos_list.append((newpos1, newpos2))
 
             # 2. make space for the products. 
-	    # TODO
-	    #    calculate the sphere around the two product particles
+            # TODO
+            #    calculate the sphere around the two product particles
             rad = max(product1_displacement + product1_radius,
                       product2_displacement + product2_radius)
             self.burst_volume(reactant_pos, rad)
 
-	    # 3. check that there is space for the products (try different positions if possible)
+            # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
-	    for newpos1, newpos2 in product_pos_list:
+            for newpos1, newpos2 in product_pos_list:
                 if (not self.world.check_overlap((newpos1, product1_radius), reactant[0])
                    and
                    not self.world.check_overlap((newpos2, product2_radius), reactant[0])):
-		    
-	    	    # 4. process the changes (remove particle, make new ones)
+                    
+                    # 4. process the changes (remove particle, make new ones)
                     self.world.remove_particle(reactant[0])
                     product1_pair = self.world.new_particle(product1_species.id, newpos1)
                     product2_pair = self.world.new_particle(product2_species.id, newpos2)
-	            products = [product1_pair, product2_pair]
+                    products = [product1_pair, product2_pair]
 
-	            # 5. update counters
+                    # 5. update counters
                     self.reaction_events += 1
                     self.last_reaction = (rr, (reactant[1], None), products)
 
-	            # 6. Log the change
+                    # 6. Log the change
                     if __debug__:
                         log.info('products (%s) = %s' % (len(products), products))
 
-		    # exit the loop, we have found new positions
+                    # exit the loop, we have found new positions
                     break
             else:
                 if __debug__:
-            	    log.info('single reaction; placing products failed.')
-		moved_reactant = self.move_particle(reactant, reactant_pos)
-		products = [moved_reactant]
-        	self.rejected_moves += 1
+                    log.info('single reaction; placing products failed.')
+                moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]
+                self.rejected_moves += 1
 
         else:
             raise RuntimeError('num products >= 3 not supported.')
 
-	return products
+        return products
 
     def fire_interaction(self, single, reactant_pos):
-	# This takes care of the identity change when a particle associates with a surface
-	# It performs the reactions:
-	# A(3D) + surface -> 0
-	# A(3D) + surface -> B(surface)
+        # This takes care of the identity change when a particle associates with a surface
+        # It performs the reactions:
+        # A(3D) + surface -> 0
+        # A(3D) + surface -> B(surface)
 
-	# 0. get reactant info
-	reactant        = single.pid_particle_pair
+        # 0. get reactant info
+        reactant        = single.pid_particle_pair
         reactant_radius    = reactant[1].radius
         rr = single.interactionrule
 
-	# 1. remove the particle
+        # 1. remove the particle
 
         if len(rr.products) == 0:
             
-	    # 1. No products, no info
-	    # 2. No space required
-	    # 3. No space required
-	    # 4. process the changes (remove particle, make new ones)
+            # 1. No products, no info
+            # 2. No space required
+            # 3. No space required
+            # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(reactant[0])
-	    products = []
+            products = []
 
-	    # 5. No new single to be made
-	    # 6. Log the change
+            # 5. No new single to be made
+            # 6. Log the change
 
             
         elif len(rr.products) == 1:
             
-	    # 1. get product info
+            # 1. get product info
             product_species = self.world.get_species(rr.products[0])
-	    product_radius  = product_species.radius
+            product_radius  = product_species.radius
             product_surface = single.surface
 
-	    # 1.5 get new position of particle
-	    transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
+            # 1.5 get new position of particle
+            transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
             product_pos, _ = product_surface.projected_point(transposed_pos)
-	    product_pos = self.world.apply_boundary(product_pos)	# not sure this is still necessary
+            product_pos = self.world.apply_boundary(product_pos)        # not sure this is still necessary
 
             # 2. burst the volume that will contain the products.
-	    #    Note that an interaction domain is already sized such that it includes the
-	    #    reactant particle moving into the surface.
-	    if product_radius > reactant_radius:
+            #    Note that an interaction domain is already sized such that it includes the
+            #    reactant particle moving into the surface.
+            if product_radius > reactant_radius:
                 self.burst_volume(product_pos, product_radius)
 
-	    # 3. check that there is space for the products 
+            # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
                 if __debug__:
-            	    log.info('interaction; placing product failed.')
-		moved_reactant = self.move_particle(reactant, reactant_pos)
-                products = [moved_reactant]	# no change 
-        	self.rejected_moves += 1
+                    log.info('interaction; placing product failed.')
+                moved_reactant = self.move_particle(reactant, reactant_pos)
+                products = [moved_reactant]     # no change 
+                self.rejected_moves += 1
 
-	    else:
-	        # 4. process the changes (remove particle, make new ones)
+            else:
+                # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(reactant[0])
                 newparticle = self.world.new_particle(product_species.id, product_pos)
-	        products = [newparticle]
+                products = [newparticle]
 
-		# 5. update counters
-        	self.reaction_events += 1
-        	self.last_reaction = (rr, (reactant[1], None), products)
+                # 5. update counters
+                self.reaction_events += 1
+                self.last_reaction = (rr, (reactant[1], None), products)
 
-	        # 6. Log the change
+                # 6. Log the change
                 if __debug__:
                      log.info('product (%s) = %s' % (len(products), products))
 
         else:
             raise RuntimeError('fire_interaction: num products > 1 not supported.')
 
-	return products
+        return products
 
 
     def fire_pair_reaction(self, pair):
-	# This takes care of the identity change when two particles react with each other
-	# It performs the reactions:
-	# A(any structure) + B(same structure) -> 0
-	# A(any structure) + B(same structure or 3D) -> C(same structure)
-	pass
+        # This takes care of the identity change when two particles react with each other
+        # It performs the reactions:
+        # A(any structure) + B(same structure) -> 0
+        # A(any structure) + B(same structure or 3D) -> C(same structure)
+        pass
 
 
     def fire_move(self, single, reactant_pos):
-	# No reactions/Interactions have taken place -> no identity change of the particle
-	# Just only move the particles
+        # No reactions/Interactions have taken place -> no identity change of the particle
+        # Just only move the particles
 
-	reactant = single.pid_particle_pair
+        reactant = single.pid_particle_pair
 
         if self.world.check_overlap((reactant_pos, reactant[1].radius),
                                     reactant[0]):
             raise RuntimeError('fire_move: particle overlap failed.')
-	moved_reactant = self.move_particle(reactant, reactant_pos)
-	return [moved_reactant]
+        moved_reactant = self.move_particle(reactant, reactant_pos)
+        return [moved_reactant]
 
 
     def process_single_event(self, single):
 
-	### log Single event
+        ### log Single event
         if __debug__:
             log.info('%s' % single.event_type)
             log.info('single = %s' % single)
 
 
 
-	if single.is_reset():
-	### If no event event really happened and just need to make new domain
-	    domains = [self.make_new_domain(single)]
-	    # domain is already scheduled in make_new_domain
+        if single.is_reset():
+        ### If no event event really happened and just need to make new domain
+            domains = [self.make_new_domain(single)]
+            # domain is already scheduled in make_new_domain
 
-	### 1.1 Special cases (shortcuts)
+        ### 1.1 Special cases (shortcuts)
         # In case nothing is scheduled to happen: do nothing and just reschedule
         elif single.dt == numpy.inf:
             self.add_domain_event(single)
             domains = [single]
 
-	else:
-	### 1. Process 'normal' event produced by the single
+        else:
+        ### 1. Process 'normal' event produced by the single
 
             # check that the event time of the single (last_time + dt) is equal to the
-	    # simulator time
-            assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
+            # simulator time
+            if __debug__:
+                if not (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t): 
+                    log.info("{"+str(single.dt) + "," + str(single.last_time) + "," + str(self.t)+"}")
+                    raise AssertionError
 
 
-	    pid_particle_pair = single.pid_particle_pair
-	    # in case of an interaction domain: determine real event before doing anything
-	    if single.event_type == EventType.IV_EVENT:
-		single.event_type = single.draw_iv_event_type()
+            pid_particle_pair = single.pid_particle_pair
+            # in case of an interaction domain: determine real event before doing anything
+            if single.event_type == EventType.IV_EVENT:
+                single.event_type = single.draw_iv_event_type()
 
 
-	    # get the (new) position
+            # get the (new) position
             if single.getD() != 0 and single.dt > 0.0:
-		# If the particle had the possibility to diffuse
-		newpos = single.draw_new_position(single.dt, single.event_type)
-	        newpos = self.world.apply_boundary(newpos)
-	    else:
-		newpos = pid_particle_pair[1].position
+                # If the particle had the possibility to diffuse
+                newpos = single.draw_new_position(single.dt, single.event_type)
+                newpos = self.world.apply_boundary(newpos)
+            else:
+                newpos = pid_particle_pair[1].position
 
-	    # newpos now hold the new position of the particle (not yet committed to the world)
-	    # if we would here move the particles and make new shells, then it would be similar to a propagate
+            # newpos now hold the new position of the particle (not yet committed to the world)
+            # if we would here move the particles and make new shells, then it would be similar to a propagate
 
             self.remove_domain(single)
 
             # If the single had a decay reaction or interaction.
             if single.event_type == EventType.SINGLE_REACTION or \
-	       single.event_type == EventType.IV_INTERACTION:
+               single.event_type == EventType.IV_INTERACTION:
                 if __debug__:
                     log.info('%s' % single.event_type)
                     log.info('reactant = %s' % single)
 
-		if single.event_type == EventType.SINGLE_REACTION:
+                if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1
                     particles = self.fire_single_reaction(single, newpos)
 
-		else:
+                else:
                     self.interaction_steps[single.event_type] += 1
                     particles = self.fire_interaction(single, newpos)
 
-	    else:
-		particles = self.fire_move(single, newpos)
-
-	    # 5. Make a (new) domain (reuse) domain for each particle(s)
-	    #    (Re)schedule the (new) domain
-	    domains = []
-	    for pid_particle_pair in particles:
-#	        single.pid_particle_pair = pid_particle_pair	# reuse single
-		single = self.create_single(pid_particle_pair)
-		self.add_domain_event(single)
-		domains.append(single) 
+            else:
+                particles = self.fire_move(single, newpos)
+
+            # 5. Make a (new) domain (reuse) domain for each particle(s)
+            #    (Re)schedule the (new) domain
+            domains = []
+            for pid_particle_pair in particles:
+#               single.pid_particle_pair = pid_particle_pair    # reuse single
+                single = self.create_single(pid_particle_pair)
+                self.add_domain_event(single)
+                domains.append(single) 
 
-	    # 6. Log change?
-		
-	return domains
+            # 6. Log change?
+                
+        return domains
 
 
     def make_new_domain(self, single):
-	### Make a new domain out of a NonInteractionSingle that was
-	### just fired
-
-	# can only make new domain from NonInteractionSingle
-	assert isinstance(single, NonInteractionSingle)
-	
-	# Special case: When D=0, nothing needs to change and only new event
-	# time is drawn
-	# TODO find nicer constructrion than just this if statement
-	if single.getD() == 0:
+        ### Make a new domain out of a NonInteractionSingle that was
+        ### just fired
+
+        # can only make new domain from NonInteractionSingle
+        assert isinstance(single, NonInteractionSingle)
+        
+        # Special case: When D=0, nothing needs to change and only new event
+        # time is drawn
+        # TODO find nicer constructrion than just this if statement
+        if single.getD() == 0:
             single.dt, single.event_type = single.determine_next_event() 
             single.last_time = self.t
             self.add_domain_event(single)
             return
 
 
-	single_pos = single.pid_particle_pair[1].position
-	single_radius = single.pid_particle_pair[1].radius
+        single_pos = single.pid_particle_pair[1].position
+        single_radius = single.pid_particle_pair[1].radius
 
-	# 2.1
-	# We prefer to make NonInteractionSingles for efficiency.
-	# But if objects (Shells and surfaces) get close enough (closer than
-	# reaction_threshold) we want to try Interaction and/or Pairs
+        # 2.1
+        # We prefer to make NonInteractionSingles for efficiency.
+        # But if objects (Shells and surfaces) get close enough (closer than
+        # reaction_threshold) we want to try Interaction and/or Pairs
 
-	# Check if there are shells with the burst radius (reaction_threshold)
-	# of the particle (intruders). Note that we approximate the reaction_volume
-	# with a sphere (should be cylinder for 2D or 1D particle)
+        # Check if there are shells with the burst radius (reaction_threshold)
+        # of the particle (intruders). Note that we approximate the reaction_volume
+        # with a sphere (should be cylinder for 2D or 1D particle)
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
         intruder_ids, closest_id, closest_distance = \
             self.geometrycontainer.get_intruders(single_pos, reaction_threshold,
                                                  ignore=[single.domain_id, ])
-	intruders = [self.domains[domain_id] for domain_id in intruder_ids]
+        intruders = [self.domains[domain_id] for domain_id in intruder_ids]
 
         if __debug__:
             log.debug("intruders: %s" %
@@ -1115,116 +1118,116 @@ def make_new_domain(self, single):
 
 
         # 2.2 Burst the shells with the following conditions
-	# -shell is in the burst radius (intruder)
-	# -shell is burstable (not Multi)
-	# -shell is not newly made
-	# -shell is not already a zero shell (just bursted)
-	burst = []
+        # -shell is in the burst radius (intruder)
+        # -shell is burstable (not Multi)
+        # -shell is not newly made
+        # -shell is not already a zero shell (just bursted)
+        burst = []
         if intruders:
 #            burst = self.burst_non_multis(intruders)
-	    for domain in intruders:
-        	if not isinstance(domain, Multi) and \
+            for domain in intruders:
+                if not isinstance(domain, Multi) and \
                    not self.t == domain.last_time: # and \
-#		   not domain.dt == 0.0:
+#                  not domain.dt == 0.0:
                     # domain is Single or Pair of some subclass
-            	    single_list = self.burst_domain(domain)
+                    single_list = self.burst_domain(domain)
                     burst.extend(single_list)
                 elif isinstance(domain, Multi):
                     # domain is a Multi
                     burst.append(domain)
 
-	    # burst now contains all the Domains resulting from the burst.
-	    # These are NonInteractionSingles and Multis
+            # burst now contains all the Domains resulting from the burst.
+            # These are NonInteractionSingles and Multis
 
 
-	# 2.3 get the closest object (a Domain or surface) which can be a
-	# partner for a new domain. This can be:
-	# zero-shell NonInteractionSingle -> Pair or Multi
-	# Multi -> Multi
-	# Surface -> Interaction
-	closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
-									ignore=[single.domain_id],
-									ignores=[single.structure.id])
+        # 2.3 get the closest object (a Domain or surface) which can be a
+        # partner for a new domain. This can be:
+        # zero-shell NonInteractionSingle -> Pair or Multi
+        # Multi -> Multi
+        # Surface -> Interaction
+        closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
+                                                                        ignore=[single.domain_id],
+                                                                        ignores=[single.structure.id])
 
-	# TODO Potential partners are for now just the bursted domains
-	partners = burst
+        # TODO Potential partners are for now just the bursted domains
+        partners = burst
 
-	dists = []
-	if partners:
+        dists = []
+        if partners:
             # sort partners by distance
-	    dists = self.obj_distance_array(single_pos, partners)
+            dists = self.obj_distance_array(single_pos, partners)
             if len(dists) >= 2:
-        	n = dists.argsort()
-        	partners = numpy.take(partners, n)	# sort the potential partners using the index
-        	dists = dists.take(n)			# sort the distances using the index
-
-	    closest_domain = partners[0]
-	    domain_distance = dists[0]
-	    rest_domains = partners[1:]
-	    rest_dists = dists[1:]
-	else:
-	    closest_domain = None
-	    domain_distance = numpy.inf
-	    rest_domains = []
-	    rest_dists = []
-	
-	# Potential partners are also surfaces
+                n = dists.argsort()
+                partners = numpy.take(partners, n)      # sort the potential partners using the index
+                dists = dists.take(n)                   # sort the distances using the index
+
+            closest_domain = partners[0]
+            domain_distance = dists[0]
+            rest_domains = partners[1:]
+            rest_dists = dists[1:]
+        else:
+            closest_domain = None
+            domain_distance = numpy.inf
+            rest_domains = []
+            rest_dists = []
+        
+        # Potential partners are also surfaces
         closest_surface, surface_distance = \
-	get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
+        get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
 
 
 
-	# 2.4 calculate the thresholds (horizons) for trying to form the various domains.
-	# Note that we do not differentiate between directions. This means that we
-	# look around in a sphere, the horizons are spherical
-	surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
-	multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
+        # 2.4 calculate the thresholds (horizons) for trying to form the various domains.
+        # Note that we do not differentiate between directions. This means that we
+        # look around in a sphere, the horizons are spherical
+        surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+        multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
 
-	# 2.4 check that the object is a potential partner for an
-	# -Pair		(a zero dt NonInteractionSingle)
-	# -Interaction 	(a surface)
-	# -Multi	(a zero dt NonInteractionSingle or Multi)
-	if isinstance(closest_obj, NonInteractionSingle) and \
-	   closest_obj.is_reset():
-		pair_horizon = (single_radius + \
+        # 2.4 check that the object is a potential partner for an
+        # -Pair         (a zero dt NonInteractionSingle)
+        # -Interaction  (a surface)
+        # -Multi        (a zero dt NonInteractionSingle or Multi)
+        if isinstance(closest_obj, NonInteractionSingle) and \
+           closest_obj.is_reset():
+                pair_horizon = (single_radius + \
                        closest_obj.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
-		if closest_distance < pair_horizon:
-	            # try making a Pair (can still be Mixed Pair or Normal Pair)
-		    domain = self.try_pair (single, closest_obj)
-		else:
-		    domain = None
-
-	elif isinstance(single, SphericalSingle) and \
-	     (isinstance(closest_obj, CylindricalSurface) or isinstance(closest_obj, PlanarSurface)) and \
-	     closest_distance < surface_horizon:
-#	     surface_distance < domain_distance and \
-#	     surface_distance < surface_horizon:
-		# try making an Interaction
-	    domain = self.try_interaction (single, closest_obj)
-	else:
-	    domain = None
-
-
-	if not domain:
-	    # No Pair or Interaction could be formed
-	    # Now choose between NonInteractionSingle and Multi
-
-	    if closest_distance > multi_horizon: # and \
-#	       surface_distance > multi_horizon:
-	        # just make a normal NonInteractionSingle
-	        self.update_single(single)
-	        self.add_domain_event(single)
-	    else:
-		# The closest object was too close to make a NonInteractionSingle
-		domain = self.form_multi(single, partners, dists)
-
-	return domain
+                if closest_distance < pair_horizon:
+                    # try making a Pair (can still be Mixed Pair or Normal Pair)
+                    domain = self.try_pair (single, closest_obj)
+                else:
+                    domain = None
+
+        elif isinstance(single, SphericalSingle) and \
+             (isinstance(closest_obj, CylindricalSurface) or isinstance(closest_obj, PlanarSurface)) and \
+             closest_distance < surface_horizon:
+#            surface_distance < domain_distance and \
+#            surface_distance < surface_horizon:
+                # try making an Interaction
+            domain = self.try_interaction (single, closest_obj)
+        else:
+            domain = None
+
+
+        if not domain:
+            # No Pair or Interaction could be formed
+            # Now choose between NonInteractionSingle and Multi
+
+            if closest_distance > multi_horizon: # and \
+#              surface_distance > multi_horizon:
+                # just make a normal NonInteractionSingle
+                self.update_single(single)
+                self.add_domain_event(single)
+            else:
+                # The closest object was too close to make a NonInteractionSingle
+                domain = self.form_multi(single, partners, dists)
+
+        return domain
 
 
     def calculate_simplepair_shell_size(self, single1, single2):
-	assert single1.structure == single2.structure
+        assert single1.structure == single2.structure
 
-	# 0. Get some necessary information
+        # 0. Get some necessary information
         pos1 = single1.pid_particle_pair[1].position
         pos2 = single2.pid_particle_pair[1].position
 
@@ -1240,20 +1243,20 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
 #        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
 #        com = self.world.apply_boundary(com)
-	com, iv = SimplePair.do_transform(single1, single2, self.world)
-	r0 = length (iv)
-        distance_from_sigma = r0 - sigma	# the distance between the surfaces of the particles
+        com, iv = SimplePair.do_transform(single1, single2, self.world)
+        r0 = length (iv)
+        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
 
-	# 1. Get the minimal possible shell size (including margin?)
+        # 1. Get the minimal possible shell size (including margin?)
         min_shell_size = SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
 
-	# 2. Get the maximum possible shell size
-	max_shell_size = SimplePair.get_max_shell_size(com, single1, single2,
-						       self.geometrycontainer, self.domains)
+        # 2. Get the maximum possible shell size
+        max_shell_size = SimplePair.get_max_shell_size(com, single1, single2,
+                                                       self.geometrycontainer, self.domains)
 
-	# 3. Calculate the maximum based on some other criterium (convergence?)
-#        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin		# FIXME
-#	max_shell_size = min(max_shell_size, convergence_max)
+        # 3. Calculate the maximum based on some other criterium (convergence?)
+#        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin                # FIXME
+#       max_shell_size = min(max_shell_size, convergence_max)
 
 
         # 4. Check if min shell size for the Pair not larger than max shell size or 
@@ -1268,18 +1271,18 @@ def calculate_simplepair_shell_size(self, single1, single2):
                            FORMAT_DOUBLE % max_shell_size))
             return None, None, None
 
-	# 5. Calculate the 'ideal' shell size
+        # 5. Calculate the 'ideal' shell size
 #        D_closest = closest.pid_particle_pair[1].D
 #        D_tot = D_closest + D12
 #        ideal_shell_size = min((D12 / D_tot) *
 #                            (closest_particle_distance - min_shell_size - closest_min_radius) +
-#			     min_shell_size,
-	ideal_shell_size = numpy.inf
-	shell_size = min(max_shell_size, ideal_shell_size)
+#                            min_shell_size,
+        ideal_shell_size = numpy.inf
+        shell_size = min(max_shell_size, ideal_shell_size)
 
 
         # 6. Check if singles would not be better.
-	# TODO clear this up -> strange rule
+        # TODO clear this up -> strange rule
         d1 = self.world.distance(com, pos1)
         d2 = self.world.distance(com, pos2)
 
@@ -1298,26 +1301,26 @@ def calculate_simplepair_shell_size(self, single1, single2):
         assert shell_size >= min_shell_size
         assert shell_size <= max_shell_size
 
-	if __debug__:
-	    log.info('SimplePair shell made. shell_size=%s, '
+        if __debug__:
+            log.info('SimplePair shell made. shell_size=%s, '
                      'closest_shell_distance=%s,\nclosest = %s' %
                      (FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % 0, None))
 
-	return com, r0, shell_size
+        return com, r0, shell_size
 
 
     def update_single(self, single): 
-        assert isinstance(single, NonInteractionSingle)	# This only works for 'simple' Singles
+        assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
-	min_shell_size = single.get_min_shell_size()
-	max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
+        min_shell_size = single.get_min_shell_size()
+        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
 
-	# Make sure that the new shell size is not too small or big
+        # Make sure that the new shell size is not too small or big
         new_shell_size = max(max_shell_size, min_shell_size)
 
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.
-	singlepos = single.pid_particle_pair[1].position
+        singlepos = single.pid_particle_pair[1].position
         self.update_single_shell(single, singlepos, new_shell_size)        
 
         single.dt, single.event_type = single.determine_next_event()
@@ -1326,7 +1329,7 @@ def update_single(self, single):
     def process_pair_event(self, pair):
         assert self.check_obj(pair)
 
-	# check that the time is the currect simulator time 
+        # check that the time is the currect simulator time 
         assert self.t >= pair.last_time
         assert self.t == pair.last_time + pair.dt
 
@@ -1372,7 +1375,7 @@ def process_pair_event(self, pair):
             else:
                 theothersingle = single1
 
-	    # note method has side effect on single1 and single2
+            # note method has side effect on single1 and single2
             self.propagate_pair(pair)
 
             self.add_domain_event(theothersingle)
@@ -1381,9 +1384,9 @@ def process_pair_event(self, pair):
                 log.info('reactant = %s' % reactingsingle)
             self.remove_domain(reactingsingle)
             particles = self.fire_single_reaction(reactingsingle, reactingsingle.pid_particle_pair[1].position)
-	    for pid_particle_pair in particles:
-		single = self.create_single(pid_particle_pair)
-		self.add_domain_event(single)
+            for pid_particle_pair in particles:
+                single = self.create_single(pid_particle_pair)
+                self.add_domain_event(single)
 
         #
         # 2. Pair reaction
@@ -1394,70 +1397,70 @@ def process_pair_event(self, pair):
             new_com, _ = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
             new_com = self.world.apply_boundary(new_com)
 
-	    # TODO make this a fire_pair_reaction method
+            # TODO make this a fire_pair_reaction method
 
 
-	    # 0. get reactant info
-	    rr = pair.draw_reaction_rule(pair.interparticle_rrs)
-	    reactant1_species_id = pid_particle_pair1[1].sid
-	    reactant2_species_id = pid_particle_pair2[1].sid
+            # 0. get reactant info
+            rr = pair.draw_reaction_rule(pair.interparticle_rrs)
+            reactant1_species_id = pid_particle_pair1[1].sid
+            reactant2_species_id = pid_particle_pair2[1].sid
 
-	    # 1. remove the particles
+            # 1. remove the particles
 
             if len(rr.products) == 0:
 
-		# 1. no product particles, no info
-		# 2. No space required
-		# 3. No space required
-		# 4. process the change (remove particles, make new ones)
+                # 1. no product particles, no info
+                # 2. No space required
+                # 3. No space required
+                # 4. process the change (remove particles, make new ones)
                 self.world.remove_particle(pid_particle_pair1[0])
                 self.world.remove_particle(pid_particle_pair2[0])
-		products = []
+                products = []
 
-		# 5. No new single to be made
-		# 6. Log the change
+                # 5. No new single to be made
+                # 6. Log the change
                 self.last_reaction = (rr, (pid_particle_pair1[1], pid_particle_pair2[1]), products)
 
-	    elif len(rr.products) == 1:
+            elif len(rr.products) == 1:
 
-		# 1. get product info
+                # 1. get product info
                 product_species = self.world.get_species(rr.products[0])
 
-		# 1.5 no change in position due to reaction
-		# position = new_com
+                # 1.5 no change in position due to reaction
+                # position = new_com
 
-		# 2.  make space for products
-		# 2.1 if the product particle sticks out of the shell
-		if self.world.distance(old_com, new_com) > (pair.get_shell_size() - product_species.radius):
-		    self.burst_volume(new_com, product_species.radius)
+                # 2.  make space for products
+                # 2.1 if the product particle sticks out of the shell
+                if self.world.distance(old_com, new_com) > (pair.get_shell_size() - product_species.radius):
+                    self.burst_volume(new_com, product_species.radius)
 
-		    # 3. check that there is space for the products ignoring the reactants
-		    if self.world.check_overlap((new_com, product_species.radius),
-						pid_particle_pair1[0],
-						pid_particle_pair2[0]):
-			if __debug__:
-	                    log.info('no space for product particle.')
-        	        raise NoSpace()
+                    # 3. check that there is space for the products ignoring the reactants
+                    if self.world.check_overlap((new_com, product_species.radius),
+                                                pid_particle_pair1[0],
+                                                pid_particle_pair2[0]):
+                        if __debug__:
+                            log.info('no space for product particle.')
+                        raise NoSpace()
 
-		# 4. process the changes (remove particle, make new ones)
-	        self.world.remove_particle(pid_particle_pair1[0])
+                # 4. process the changes (remove particle, make new ones)
+                self.world.remove_particle(pid_particle_pair1[0])
                 self.world.remove_particle(pid_particle_pair2[0])
                 particle = self.world.new_particle(product_species.id, new_com)
-		products = [particle, ]
+                products = [particle, ]
 
-		# 5. make a new single and schedule
+                # 5. make a new single and schedule
                 single = self.create_single(particle)
                 self.add_domain_event(single)
 
-		# 6. Log the change
-            	if __debug__:
+                # 6. Log the change
+                if __debug__:
                     log.info('product = %s' % single)
                 self.last_reaction = (rr, (pid_particle_pair1, pid_particle_pair2),
                                       products)
             else:
                 raise NotImplementedError('num products >= 2 not supported.')
 
-	    # 7. update counter
+            # 7. update counter
             self.reaction_events += 1
             self.remove_domain(pair)
 
@@ -1468,10 +1471,10 @@ def process_pair_event(self, pair):
         elif(pair.event_type == EventType.IV_ESCAPE or
              pair.event_type == EventType.COM_ESCAPE):
 
-	    # get new positions for particles, move them and make singles
+            # get new positions for particles, move them and make singles
             single1, single2 = self.propagate_pair(pair)
 
-	    # reschedule single domains
+            # reschedule single domains
             self.add_domain_event(single1)
             self.add_domain_event(single2)
 
@@ -1492,7 +1495,7 @@ def process_multi_event(self, multi):
             self.reaction_events += 1
             self.last_reaction = multi.last_reaction
 
-        if multi.last_event is not None:		# if an event took place
+        if multi.last_event is not None:                # if an event took place
             self.break_up_multi(multi)
             self.multi_steps[multi.last_event] += 1
         else:
@@ -1519,10 +1522,10 @@ def break_up_multi(self, multi):
     def burst_single(self, single):
         # Sets next event time of 'single' to current time and event to burst event
         # returns a new single that is the result of firing the old single
-	# new single also has proper zero shell and is rescheduled
+        # new single also has proper zero shell and is rescheduled
 
-	if __debug__:
-	    log.debug('burst single: %s', single)
+        if __debug__:
+            log.debug('burst single: %s', single)
 
         # Check correct timeline ~ MW
         assert single.last_time <= self.t
@@ -1532,11 +1535,11 @@ def burst_single(self, single):
         # Override event_type. 
         single.dt = self.t - single.last_time
         single.event_type = EventType.BURST
-	self.remove_event(single)
+        self.remove_event(single)
 
-#        newsingle = self.propagate_single(single)	# TODO this can now also just be a process_single_event
-#	self.add_domain_event(newsingle)
-	newsingles = self.process_single_event(single)
+#        newsingle = self.propagate_single(single)      # TODO this can now also just be a process_single_event
+#       self.add_domain_event(newsingle)
+        newsingles = self.process_single_event(single)
 
 # NOTE Be inefficient for just now and don't reuse the event in the schedules
 #        newpos = newsingle.pid_particle_pair[1].position
@@ -1544,7 +1547,7 @@ def burst_single(self, single):
 #
 #        if isinstance(single, InteractionSingle):
 #            # When bursting an InteractionSingle, the domain changes from Interaction
-#	    # NonInteraction domain. This needs to be reflected in the event 
+#           # NonInteraction domain. This needs to be reflected in the event 
 #            self.remove_event(single)
 #            self.add_domain_event(newsingle)
 #        else:
@@ -1557,30 +1560,30 @@ def burst_single(self, single):
         return newsingles
 
     def burst_pair(self, pair):
-	# Sets next event time of 'pair' to current time and event to burst event
-	# returns two new singles that are the result of firing the pair
-	# new singles also have proper zero shell and are rescheduled
+        # Sets next event time of 'pair' to current time and event to burst event
+        # returns two new singles that are the result of firing the pair
+        # new singles also have proper zero shell and are rescheduled
 
         if __debug__:
             log.debug('burst_pair: %s', pair)
 
-	# make sure that the current time is between the last time and the event time
+        # make sure that the current time is between the last time and the event time
         assert pair.last_time <= self.t
         assert self.t <= pair.last_time + pair.dt
 
         # Override event time and event_type. 
         pair.dt = self.t - pair.last_time 
         pair.event_type = EventType.BURST
-        self.remove_event(pair)		# remove the event -> was still in the scheduler
+        self.remove_event(pair)         # remove the event -> was still in the scheduler
 
-        single1, single2 = self.propagate_pair(pair)	# TODO this can now also just be a process_pair_event
+        single1, single2 = self.propagate_pair(pair)    # TODO this can now also just be a process_pair_event
         self.add_domain_event(single1)
         self.add_domain_event(single2)
 
         return single1, single2
 
     def propagate_pair(self, pair):
-	# takes a pair and returns two singles after propagation
+        # takes a pair and returns two singles after propagation
 
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
@@ -1588,39 +1591,39 @@ def propagate_pair(self, pair):
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
 
-	# if time has passed (should be always)
+        # if time has passed (should be always)
         if pair.dt > 0.0:
 #            D1 = pid_particle_pair1[1].D
 #            D2 = pid_particle_pair2[1].D
 
-	    # store for later check
+            # store for later check
             old_com = pair.com
 
 
-	    # TODO this should be done when the pair is made -> passed to the constructor
+            # TODO this should be done when the pair is made -> passed to the constructor
             pos2t = self.world.cyclic_transpose(pos2, pos1)
             old_inter_particle = pos2t - pos1
             r0 = self.world.distance(pos1, pos2)
             assert feq(r0, length(old_inter_particle))
 
-	    # draw the new positions of the particles
+            # draw the new positions of the particles
             newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
                                                        pair.event_type)
             newpos1 = self.world.apply_boundary(newpos1)
             newpos2 = self.world.apply_boundary(newpos2)
 
-	    # check that the particles do not overlap with any other particles in the world
+            # check that the particles do not overlap with any other particles in the world
             assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
                                                 pid_particle_pair1[0], pid_particle_pair2[0])
             assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
                                                 pid_particle_pair1[0], pid_particle_pair2[0])
 
-	    # some more consistency checking of the positions
+            # some more consistency checking of the positions
             assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
                                        pair.get_shell_size())
 
         else:
-	# no time has passed
+        # no time has passed
             newpos1 = pid_particle_pair1[1].position
             newpos2 = pid_particle_pair2[1].position
 
@@ -1628,22 +1631,22 @@ def propagate_pair(self, pair):
         pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
 
 
-	# re-use single domains for particles
-	# normally we would take the particles + new positions from the old pair
-	# and use them to make new singles. Now we re-use the singles stored in the
-	# pair
+        # re-use single domains for particles
+        # normally we would take the particles + new positions from the old pair
+        # and use them to make new singles. Now we re-use the singles stored in the
+        # pair
         single1 = pair.single1
         single2 = pair.single2
         assert single1.domain_id not in self.domains
         assert single2.domain_id not in self.domains
-	single1.pid_particle_pair = pid_particle_pair1	# this is probably redundant
-	single2.pid_particle_pair = pid_particle_pair2
+        single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
+        single2.pid_particle_pair = pid_particle_pair2
 
 
-	# remove the old domain
+        # remove the old domain
         self.remove_domain(pair)
 
-	# 'make' the singles
+        # 'make' the singles
         single1.initialize(self.t)
         single2.initialize(self.t)
         
@@ -1654,7 +1657,7 @@ def propagate_pair(self, pair):
         self.domains[single1.domain_id] = single1
         self.domains[single2.domain_id] = single2
 
-	# Thoroughly check the sizes of the shells of the singles
+        # Thoroughly check the sizes of the shells of the singles
         if __debug__:
             container = self.geometrycontainer.get_container(single1.shell)
             assert container[single1.shell_id].shape.radius == \
@@ -1670,12 +1673,12 @@ def propagate_pair(self, pair):
 
         assert single1.shell.shape.radius == pid_particle_pair1[1].radius
         assert single2.shell.shape.radius == pid_particle_pair2[1].radius
-	# even more checking
+        # even more checking
         assert self.check_obj(single1)
         assert self.check_obj(single2)
-	# Now finally we are convinced that the singles were actually made correctly
+        # Now finally we are convinced that the singles were actually made correctly
 
-	# Log the event
+        # Log the event
         if __debug__:
             log.debug("process_pair_event: #1 { %s: %s => %s }" %
                       (single1, str(pos1), str(newpos1)))
@@ -1688,33 +1691,33 @@ def try_interaction(self, single, surface):
         # Try to form an interaction between the 'single' particle and the 'surface'.
 
         pid_particle_pair = single.pid_particle_pair
-	particle = pid_particle_pair[1]
+        particle = pid_particle_pair[1]
 
-	# calculate the Projected_point and distance to the surface
+        # calculate the Projected_point and distance to the surface
         # Cyclic transpose needed when calling surface.projected_point!
         pos_transposed = self.world.cyclic_transpose(particle.position, 
                                                      surface.shape.position) 
         projected_point, projection_distance = \
                 surface.projected_point(pos_transposed)
 
-	# projection_distance is relative to the unit_z of the surface -> can be negative
+        # projection_distance is relative to the unit_z of the surface -> can be negative
         particle_distance = abs(projection_distance)
 
         # For interaction with a planar surface, decide orientation. 
-	# Note that the orientation_vector is normalized
+        # Note that the orientation_vector is normalized
         orientation_vector = cmp(projection_distance, 0) * surface.shape.unit_z 
 
         if __debug__:
            log.debug('trying to form Interaction(%s, %s)' % (particle, surface))
 
 
-	### 1. See if there is enough space for the shell
+        ### 1. See if there is enough space for the shell
 
 
-	# Make sure the maximal cylinder fits in the maximal sphere. Matrix space
-	# doesn't allow to check for shells outside the maximal sphere.
-	max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
-	max_cylinder_half_length = max_cylinder_radius
+        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
+        # doesn't allow to check for shells outside the maximal sphere.
+        max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
+        max_cylinder_half_length = max_cylinder_radius
 
         # Initialize dr, dz_left, dz_right to maximum allowed values.
         # And decide minimal dr, dz_left, dz_right.
@@ -1747,7 +1750,7 @@ def try_interaction(self, single, surface):
 
         dr /= SAFETY
         dz_right /= SAFETY
-#	 This will break the conditions below for membrane interaction
+#        This will break the conditions below for membrane interaction
 #        dz_left /= SAFETY
 
         # Decide if interaction domain is possible.
@@ -1763,15 +1766,15 @@ def try_interaction(self, single, surface):
                            dz_right, min_dz_right))
             return None
 
-	### 2. The shell can be made. Now do what's necessary to make it
+        ### 2. The shell can be made. Now do what's necessary to make it
         # Compute origin, radius and half_length of cylinder.
         origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
         half_length = (dz_left + dz_right) / 2.0
         radius = dr
 
         interaction = self.create_interaction(pid_particle_pair, surface,
-					      origin, radius, half_length,
-					      orientation_vector)
+                                              origin, radius, half_length,
+                                              orientation_vector)
 
         interaction.dt, interaction.event_type, = \
             interaction.determine_next_event()
@@ -1799,30 +1802,30 @@ def calculate_max_cylinder(self, single, surface, projected_point,
                                    dr, dz_left, dz_right):
         # Find optimal cylinder around particle and surface, such that 
         # it is not interfering with other shells.
-	#
-	# To determine the maximal cylindrical shell a starting cylinder is defined
-	# * The projected_point is a reference point along the axis of the cylinder,
-	#   the position, z, can be chosen freely
-	# * orientation_vector is a vector along the z-axis providing orientation
-	#   It usually points in the general direction of the particle
-	#
+        #
+        # To determine the maximal cylindrical shell a starting cylinder is defined
+        # * The projected_point is a reference point along the axis of the cylinder,
+        #   the position, z, can be chosen freely
+        # * orientation_vector is a vector along the z-axis providing orientation
+        #   It usually points in the general direction of the particle
+        #
         # * dr is the radius of the cylinder.
         # * dz_right is the distance between the projected_point and the face of the
-	#   cylinder on the side of the orientation_vector 
+        #   cylinder on the side of the orientation_vector 
         # * dz_left is the distance from the projected_point to the face of the cylinder
-	#   on the side oposite of the orientation_vector
-	#
-	# * particle_distance is the distance from the center of the particle to the
-	#   projected_point
+        #   on the side oposite of the orientation_vector
+        #
+        # * particle_distance is the distance from the center of the particle to the
+        #   projected_point
 
-	# the search point is the center of the sphere that surrounds the
-	# maximal cylinder
+        # the search point is the center of the sphere that surrounds the
+        # maximal cylinder
         search_point = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
         all_neighbor_ids = \
             self.geometrycontainer.get_neighbors_within_radius_no_sort(search_point, 
                                                      self.geometrycontainer.get_max_shell_size(),
                                                      ignore=[single.domain_id])
-	all_neighbors = [self.domains[domain_id] for domain_id in all_neighbor_ids]
+        all_neighbors = [self.domains[domain_id] for domain_id in all_neighbor_ids]
 
         for domain in all_neighbors:
             if isinstance(domain, Multi):
@@ -1872,7 +1875,7 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         # shell_position and with size (radius or half_length) 
         # shell_size.
 
-	shell_position = self.world.cyclic_transpose(shell_position, projected_point)
+        shell_position = self.world.cyclic_transpose(shell_position, projected_point)
         shell_vector = shell_position - projected_point
 
         # Calculate zi and ri for this shell.
@@ -1884,16 +1887,16 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
         # Calculate dr_i for this shell.
         dr_i = ri - shell_size
 
-	if isinstance(surface, PlanarSurface):
-	    dz_right -= particle_distance
+        if isinstance(surface, PlanarSurface):
+            dz_right -= particle_distance
         elif isinstance(surface, CylindricalSurface):
             # Run Miedema's algorithm in the r direction 
             # relative to the particle's position, not to 
             # projected point (r=0).
             dr_i -= particle_distance
-	    dr -= particle_distance
-	else:
-	    raise SystemError('Error in Miedema\'s algorithm: surface is not a Surface')
+            dr -= particle_distance
+        else:
+            raise SystemError('Error in Miedema\'s algorithm: surface is not a Surface')
 
         # Calculate dz_left_i or dz_right_i (both will usually 
         # be positive values).
@@ -1925,10 +1928,10 @@ def miedema_algorithm(self, shell_position, shell_size, projected_point,
                 else:
                     dr = dr_i
 
-	if isinstance(surface, PlanarSurface):
-	    dz_right += particle_distance
-	elif isinstance(surface, CylindricalSurface):
-	    dr += particle_distance
+        if isinstance(surface, PlanarSurface):
+            dz_right += particle_distance
+        elif isinstance(surface, CylindricalSurface):
+            dr += particle_distance
 
         return dr, dz_left, dz_right
 
@@ -1943,7 +1946,7 @@ def try_pair(self, single1, single2):
 
         # Try forming a Pair only if singles are on same structure.
         if single1.structure != single2.structure:
-	    # TODO implement shell making method for MixedPair
+            # TODO implement shell making method for MixedPair
 
             if __debug__:
                 log.debug('Pair(%s, %s) not formed: not on same structure.' %
@@ -1951,13 +1954,13 @@ def try_pair(self, single1, single2):
                            single2.pid_particle_pair[0]))
 
             center, r0, shell_size = None, None, None
-#	    shell = self.make_mixedpair_shell (single1, single2)
-	else:
-	    # particles are on the same structure
-	    center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
+#           shell = self.make_mixedpair_shell (single1, single2)
+        else:
+            # particles are on the same structure
+            center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
 
 
-	if shell_size:
+        if shell_size:
             # A shell could be made and makes sense. Create a Pair
             pair = self.create_pair(single1, single2, center, r0, shell_size)
 
@@ -1983,50 +1986,50 @@ def try_pair(self, single1, single2):
                           FORMAT_DOUBLE % shell_size)) 
 
             return pair
-	else:
-	    return None
+        else:
+            return None
     
 
     def form_multi(self, single, neighbors, dists):
-	# form a Multi with the 'single'
-	# The 'neighbors' are neighboring NonInteractionSingles and Multi which
-	# can be added to the Multi (this can also be empty)
-	# 'dists' are the distances of the 'neighbors'
-
-	# Filter out relevant neighbors if present
-	# only consider neighboring bursted domains that are within the Multi horizon
-	min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
-	dists = numpy.array(dists)	# FIXME Not sure why this is necessary, dists should already be array
+        # form a Multi with the 'single'
+        # The 'neighbors' are neighboring NonInteractionSingles and Multi which
+        # can be added to the Multi (this can also be empty)
+        # 'dists' are the distances of the 'neighbors'
+
+        # Filter out relevant neighbors if present
+        # only consider neighboring bursted domains that are within the Multi horizon
+        min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+        dists = numpy.array(dists)      # FIXME Not sure why this is necessary, dists should already be array
         neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
-	if neighbors:
+        if neighbors:
             closest = neighbors[0]
-	else:
-	    closest = None
+        else:
+            closest = None
 
 
-	# 1. Make new Multi if Necessary
+        # 1. Make new Multi if Necessary
         if isinstance(closest, Multi):
         # if the closest to this Single is a Multi, reuse the Multi.
-	    multi = closest
-	    neighbors = neighbors[1:]	# the rest of the neighbors are added
+            multi = closest
+            neighbors = neighbors[1:]   # the rest of the neighbors are added
         else: 
         # the closest is not a Multi. Can be NonInteractionSingle, surface or
-	# nothing. Create new Multi
+        # nothing. Create new Multi
             multi = self.create_multi()
 
 
-	# 2. Add the single and neighbors to the Multi
+        # 2. Add the single and neighbors to the Multi
         self.add_to_multi(single, multi)
         self.remove_domain(single)
         for neighbor in neighbors:
             self.add_to_multi_recursive(neighbor, multi)
 
 
-	# 3. Initialize and (re-)schedule
+        # 3. Initialize and (re-)schedule
         multi.initialize(self.t)
         if isinstance(closest, Multi):
             self.update_domain_event(self.t + multi.dt, multi)
-	else:
+        else:
             self.add_domain_event(multi)
 
         return multi
@@ -2048,7 +2051,7 @@ def add_to_multi_recursive(self, domain, multi):
                 self.MULTI_SHELL_FACTOR
             neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(
                     objpos, radius, ignore=[domain.domain_id])
-	    neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+            neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
             burst = self.burst_non_multis(neighbors)
             neighbor_dists = self.obj_distance_array(objpos, burst)
@@ -2073,10 +2076,10 @@ def add_to_multi(self, single, multi):
         if __debug__:
             log.info('add to multi:\n  %s\n  %s' % (single, multi))
 
-	shell_id = self.shell_id_generator()
-	shell = multi.create_new_shell(single.pid_particle_pair[1].position,
+        shell_id = self.shell_id_generator()
+        shell = multi.create_new_shell(single.pid_particle_pair[1].position,
                 single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
-	shell_id_shell_pair = (shell_id, shell)
+        shell_id_shell_pair = (shell_id, shell)
         self.geometrycontainer.move_shell(shell_id_shell_pair)
         multi.add_shell(shell_id_shell_pair)
         multi.add_particle(single.pid_particle_pair)
@@ -2107,9 +2110,9 @@ def merge_multis(self, multi1, multi2):
         self.remove_event(multi1)
 
     def domain_distance(self, pos, domain):
-	# calculates the shortest distance from 'pos' to A shell (a Multi
-	# can have multiple) of 'domain'.
-	# Note: it returns the distance between pos and the CENTER of the shell
+        # calculates the shortest distance from 'pos' to A shell (a Multi
+        # can have multiple) of 'domain'.
+        # Note: it returns the distance between pos and the CENTER of the shell
         return min(self.world.distance(shell.shape, pos)
                    for i, (_, shell) in enumerate(domain.shell_list))
 
@@ -2172,18 +2175,18 @@ def check_obj(self, obj):
             # Ignore all surfaces, multi shells can overlap with 
             # surfaces.
             ignores = [s.id for s in self.world.structures]
-	elif isinstance(obj, InteractionSingle):
-	    # Ignore surface of the particle and interaction surface
-	    ignores = [obj.structure.id, obj.surface.id]
+        elif isinstance(obj, InteractionSingle):
+            # Ignore surface of the particle and interaction surface
+            ignores = [obj.structure.id, obj.surface.id]
         else:
             ignores = [obj.structure.id]
 
         for shell_id, shell in obj.shell_list:
             closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
-								       self.domains,
+                                                                       self.domains,
                                                                        ignore=[obj.domain_id],
                                                                        ignores=ignores)
-	#TODO
+        #TODO
             if(type(shell.shape) is Cylinder and
                closest and type(closest.shell.shape) is Sphere):
                 # Note: this case is special.
@@ -2230,16 +2233,16 @@ def check_obj(self, obj):
 
     def check_obj_for_all(self):
         for id, event in self.scheduler:
-	    domain = self.domains[event.data]
+            domain = self.domains[event.data]
             self.check_obj(domain)
 
     def check_event_stoichiometry(self):
     # checks if the number of particles in the world is equal to the number
     # of particles represented in the EGFRD simulator
-	world_population = self.world.num_particles
+        world_population = self.world.num_particles
         domain_population = 0
         for id, event in self.scheduler:
-	    domain = self.domains[event.data]
+            domain = self.domains[event.data]
             domain_population += domain.multiplicity
 
         if world_population != domain_population:
@@ -2247,11 +2250,11 @@ def check_event_stoichiometry(self):
                                (world_population, domain_population))
 
     def check_shell_matrix(self):
-	did_map, shell_map = self.geometrycontainer.get_dids_shells()
+        did_map, shell_map = self.geometrycontainer.get_dids_shells()
 
         shell_population = 0
         for id, event in self.scheduler:
-	    domain = self.domains[event.data]
+            domain = self.domains[event.data]
             shell_population += domain.num_shells
             shell_ids = did_map[domain.domain_id]
             if len(shell_ids) != domain.num_shells:
@@ -2271,15 +2274,15 @@ def check_shell_matrix(self):
                                (shell_population, matrix_population))
 
     def check_domains(self):
-	# make set of event_id that are stored in all the domains
+        # make set of event_id that are stored in all the domains
         event_ids = set(domain.event_id
                         for domain in self.domains.itervalues())
-	# check that all the event_id in the scheduler are also stored in a domain
+        # check that all the event_id in the scheduler are also stored in a domain
         for id, event in self.scheduler:
             if id not in event_ids:
                 raise RuntimeError('Event %s in EventScheduler has no domain in self.domains' %
                                    event)
-	    else:
+            else:
                 event_ids.remove(id)
 
         # self.domains always include a None  --> this can change in future
diff --git a/findRoot.cpp b/findRoot.cpp
index f46fdf43..b420680f 100644
--- a/findRoot.cpp
+++ b/findRoot.cpp
@@ -1,3 +1,10 @@
+// Function findRoot iterates the GSL root finder until a root has been found
+// with the requested precision.
+//
+// Author, amongst others: Laurens Bossen.
+// FOM Insitute AMOLF
+
+
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif /* HAVE_CONFIG_H */
@@ -5,12 +12,19 @@
 #include <stdexcept>
 #include <gsl/gsl_errno.h>
 
+#include <iostream> // ONLY FOR DEBUG PURPOSES TODO
+
 #include "Logger.hpp"
 #include "findRoot.hpp"
 
 Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
               Real high, Real tol_abs, Real tol_rel, char const* funcName)
 {
+
+    // TODO DEBUG REMOVE!!!    
+    std::cout << "Starting root finding. Initiated by: " << funcName << ";\n";
+    // END TODO DEBUG REMOVE
+
     Real l(low);
     Real h(high);
 
@@ -21,10 +35,18 @@ Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
     unsigned int i(0);
     for (;;)
     {
+    
+        
         gsl_root_fsolver_iterate(solver);
+               
         l = gsl_root_fsolver_x_lower(solver);
         h = gsl_root_fsolver_x_upper(solver);
 
+        // TODO DEBUG REMOVE!!!
+        std::cout << "Current search: [" << l << ", " << h << "];\n";
+        // END TODO DEBUG REMOVE
+        
+
         const int status(gsl_root_test_interval(l, h, tol_abs,
                                                   tol_rel));
 
@@ -47,5 +69,14 @@ Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
 
     const Real root(gsl_root_fsolver_root(solver));
 
-    return root;
+    // TODO DEBUG REMOVE!!!    
+    std::cout << "Final output: [" << root << "];\n";
+    // END TODO DEBUG REMOVE
+        
+    return root;    
 }
+
+
+
+
+
diff --git a/greens_functions.cpp b/greens_functions.cpp
index b065bdae..2586ba0d 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -111,10 +111,10 @@ BOOST_PYTHON_MODULE( _greens_functions )
 	.def( "drawR", &GreensFunction2DRadAbs::drawR )
 	.def( "drawTheta", &GreensFunction2DRadAbs::drawTheta )
 	.def( "getAlpha", &GreensFunction2DRadAbs::getAlpha )
-	.def( "getAlpha0", &GreensFunction2DRadAbs::getAlpha0 )
+//	.def( "getAlpha0", &GreensFunction2DRadAbs::getAlpha0 ) // LEGACY; TODO REMOVE
 	.def( "f_alpha", &GreensFunction2DRadAbs::f_alpha )
 	.def( "f_alpha0", &GreensFunction2DRadAbs::f_alpha0 )
-	.def( "alpha_i", &GreensFunction2DRadAbs::alpha_i )
+//	.def( "alpha_i", &GreensFunction2DRadAbs::alpha_i ) // LEGACY; TODO REMOVE
 	.def( "p_survival", &GreensFunction2DRadAbs::p_survival )
 	.def( "leaves", &GreensFunction2DRadAbs::leaves )
 	.def( "leavea", &GreensFunction2DRadAbs::leavea )
diff --git a/pair.py b/pair.py
index 6b23a03c..76bfe9fe 100644
--- a/pair.py
+++ b/pair.py
@@ -404,8 +404,8 @@ def determine_radii(self, r0, shell_size):
 	    if __debug__:
 		log.info('domainsize changed for convergence.')
 
-        assert a_R + a_r * Da / D_tot + radius1 >= \
-               a_R + a_r * Db / D_tot + radius2
+        assert a_R + a_r * Da / D_tot + radiusa >= \
+               a_R + a_r * Db / D_tot + radiusb
 
         assert abs(a_R + a_r * Da / D_tot + radiusa - shell_size) \
             < 1e-12 * shell_size			# here the shell_size is the relevant scale
diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
index d36d730d..59b77441 100755
--- a/samples/2d/2dtest.py
+++ b/samples/2d/2dtest.py
@@ -47,11 +47,11 @@
 # ===============================
 logging = False
 sigma = 1e-9        # Diameter particle
-D = 1e-12           # Diffusion constant
-N = 10000             # Number of steps simulation will last
+D = 1e-13           # Diffusion constant
+N = 10000000        # Number of steps simulation will last
 world_size = 1e-6   # Lengths of simulation box
 NParticles = 50     # Number of particles in the simulation
-k = -6e-13          # Reaction constant
+k = 2e-14          # Reaction constant
 
 # VTK Logger
 # ===============================
@@ -81,9 +81,10 @@
 C = model.Species('C', D, 3*sigma, 'the_plane')                                   
 m.add_species_type(C)
 # Reaction rules
-#r1 = model.create_binding_reaction_rule(A, B, C, k)
-#m.network_rules.add_reaction_rule(r1)
-
+r1 = model.create_binding_reaction_rule(A, B, C, k)
+m.network_rules.add_reaction_rule(r1)
+r1 = model.create_unbinding_reaction_rule(C, A, B, (1/10))
+m.network_rules.add_reaction_rule(r1)
 
 
 # World

From 63efd8681d52d70dc1e2ea5d43ccb8fa4e65f62d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 7 Nov 2011 15:31:14 +0100
Subject: [PATCH 0340/1541] bugfixes in laurens' algorithm

---
 pair.py | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/pair.py b/pair.py
index 38bd80ed..91cf7d40 100644
--- a/pair.py
+++ b/pair.py
@@ -864,16 +864,17 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
         else:                   # we introduce an r0
             scalecenter_r0 = 0
         # TODO check this
-        scale_center = scalecenter_h0 * direction * orientation_vector
+        scale_center = reference_point + scalecenter_h0 * direction * orientation_vector
+        scale_center = world.apply_boundary(scale_center)
 
         # calculate the vector from the scale center to the center of the shell
         shell_position_t = world.cyclic_transpose (shell_position, scale_center)
         shell_scale_center = shell_position_t - scale_center
-        shell_scalecenter_z = numpy.dot( shell_scale_center, orientation_vector * direction )
-        shell_scalecenter_r = length(shell_scale_center - shell_scalecenter_z)
+        shell_scalecenter_z = numpy.dot( shell_scale_center, direction * orientation_vector )
+        shell_scalecenter_r = length(shell_scale_center - (shell_scalecenter_z*direction*orientation_vector))
         # calculate the angle theta of the vector from the scale center to the shell with the vector
         # to the scale center (which is +- the orientation_vector)
-        theta = vector_angle (shell_scale_center, scale_center)
+        theta = vector_angle (shell_scale_center, direction * orientation_vector)
 
         psi = theta - phi
 
@@ -888,7 +889,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
 
         elif -phi < psi and psi < 0:
         # The (spherical) shell can touch the cylinder on its flat side or its edge
-            if phi == Pi/2:
+            if phi == Pi/2.0:
                 r_tan_phi = 0
             else:
                 r_tan_phi = shell_scalecenter_r/math.tan(phi)   # phi == 0 should not get here
@@ -899,7 +900,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             else:
                 situation = 2
 
-        elif 0 <= psi and psi < (Pi/2 - phi):
+        elif 0 <= psi and psi < (Pi/2.0 - phi):
         # The (spherical) shell can touch the cylinder on its edge or its radial side
             tan_phi = math.tan(phi)                             # phi == Pi/2 should not get here
             a_thres = shell_scalecenter_r - shell_scalecenter_z * tan_phi
@@ -908,9 +909,9 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             else:
                 situation = 3
 
-        elif (Pi/2 - phi) <= psi:
+        elif (Pi/2.0 - phi) <= psi:
         # The shell is always only on the radial side of the cylinder
-                situation = 3
+            situation = 3
 
         else:
         # Don't know how we would get here, but it shouldn't happen
@@ -918,20 +919,23 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
                                (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
 
 
+
         ### Get the right values for z and r for the given situation
         if situation == 1:      # shell hits on the flat side
-            z1_new = min(z1, shell_scalecenter_z + scalecenter_h0 - shell_size)
+            z1_new = min(z1, scalecenter_h0 + shell_scalecenter_z - shell_size)
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 2:    # shell hits on the edge
             a_sq = shell_size*shell_size
-            shell_scalecenter_len = length(shell_scalecenter)
+            shell_scalecenter_len = length(shell_scale_center)
             ss_sq = shell_scalecenter_len*shell_scalecenter_len
             sin_phi = math.sin(phi)
             sin_psi = math.sin(psi)
             cos_psi = math.cos(psi)
             scalecenter_shell_dist = (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
+            # FIXME UGLY FIX BELOW
+            scalecenter_shell_dist /= 1.1
 
             if phi <= Pi/4:
                 z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
@@ -943,12 +947,13 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 3:    # shell hits on the round side
-            r_new = min(r, shell_scalecenter_r - shell_size)
+            r_new = min(r, scalecenter_r0 + shell_scalecenter_r - shell_size)
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
         else:
             raise RuntimeError('Bad situation for MixedPair shell making')
 
+
         # switch the z values in case it's necessary. r doesn't have to be switched.
         r = r_new
         if direction >= 0.0:
@@ -1107,7 +1112,9 @@ def determine_radii(self, half_length, radius):
                 tR = numpy.inf 
             else:
                 tR = (a_R**2) / (4 * self.D_R)          # the expected escape time of the CoM
-            log.debug('tr %g, tR %g' % (tr, tR))
+            log.debug('a_r= %s, tr= %s, a_R= %s, tR= %s' % \
+                      (FORMAT_DOUBLE % a_r, FORMAT_DOUBLE % tr,
+                       FORMAT_DOUBLE % a_R, FORMAT_DOUBLE % tR))
 
         assert (self.sigma < a_r) and (a_r < half_length*2)
         assert (0 < a_R) and (a_R < radius)

From 16dc739ef50351f1dcde564b9dcf7a6690d5f82f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 7 Nov 2011 15:34:14 +0100
Subject: [PATCH 0341/1541] added some ugly debugging code for finding
 numerical bug in laurens' algorithm

---
 egfrd.py |  9 +++++++--
 pair.py  | 26 ++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index e6579b07..738f9f23 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2312,6 +2312,10 @@ def check_obj(self, obj):
                                                                        self.domains,
                                                                        ignore=[obj.domain_id],
                                                                        ignores=ignores)
+
+#            distance_midpoints = self.world.distance(obj.shell.shape.position, closest.shell.shape.position)
+            distance_midpoints = 0
+
         #TODO
             if(type(shell.shape) is Cylinder and
                closest and type(closest.shell.shape) is Sphere):
@@ -2350,10 +2354,11 @@ def check_obj(self, obj):
                 str(shell_id)
 
             assert diff >= 0.0, \
-                '%s overlaps with %s. (shell: %s, dist: %s, diff: %s.' % \
+                '%s overlaps with %s. (shell: %s, dist: %s, diff: %s, dist_midpoints: %s.' % \
                 (str(obj), str(closest), FORMAT_DOUBLE % shell_size,
                  FORMAT_DOUBLE % distance,
-                 FORMAT_DOUBLE % diff)
+                 FORMAT_DOUBLE % diff,
+                 FORMAT_DOUBLE % distance_midpoints)
 
         return True
 
diff --git a/pair.py b/pair.py
index 91cf7d40..698e8477 100644
--- a/pair.py
+++ b/pair.py
@@ -918,6 +918,17 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
                                (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
 
+        log.debug('situation = %s' % (situation))
+        print "h0", scalecenter_h0
+        print "scale_center" , scale_center
+        print "theta = " ,theta
+        print "phi= ", phi
+        print "psi= ", psi
+        print "shell_scale_center= ", shell_scale_center
+        print "shell_scalecenter_r= ", shell_scalecenter_r
+        print "shell_scalecenter_z= ", shell_scalecenter_z
+#        print "a_thres=", a_thres
+        print "shell_size=", shell_size
 
 
         ### Get the right values for z and r for the given situation
@@ -938,10 +949,12 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             scalecenter_shell_dist /= 1.1
 
             if phi <= Pi/4:
+                print "scale z first."
                 z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
                 r_new  = min(r, r1_function(single1, single2, r0, z1_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
             else:
+                print "scale r first."
                 r_new = min(r, scalecenter_r0 + sin_phi * scalecenter_shell_dist)
                 z1_new = min(z1, z1_function(single1, single2, r0, r_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
@@ -953,6 +966,14 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
         else:
             raise RuntimeError('Bad situation for MixedPair shell making')
 
+        ## DEBUGGING
+        h_l = (z1_new + z2_new)/2.0
+        print "h_l = ", h_l
+        g = z1_new - h_l - scalecenter_h0
+        print "g = ", g
+        x = length(shell_scale_center) 
+        print "distance = ", math.sqrt(g*g + x*x - 2.0*g*x*math.cos(theta))
+
 
         # switch the z values in case it's necessary. r doesn't have to be switched.
         r = r_new
@@ -963,6 +984,11 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             z_right = z2_new
             z_left  = z1_new
 
+        ## DEBUGGING
+        print "r = " , r
+        print "z_left = ", z_left
+        print "z_right = ", z_right
+
         return r, z_left, z_right
 
     ### class methods that are for the right side of the cylindrical shell

From 63eff9a93d9b7a60e93f7600acc42838d46c5b44 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 7 Nov 2011 16:58:34 +0100
Subject: [PATCH 0342/1541] minimal size of shell of MixedPair now also obeys
 scaling relation

---
 pair.py | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git a/pair.py b/pair.py
index 698e8477..05a8c17d 100644
--- a/pair.py
+++ b/pair.py
@@ -738,12 +738,17 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
         # of particle1
         pos2_t = geometrycontainer.world.cyclic_transpose(pos2, pos1)
         iv = pos2_t - pos1
-        iv_x = numpy.dot(iv, single1.structure.shape.unit_x)
-        iv_y = numpy.dot(iv, single1.structure.shape.unit_y)
-        iv_z = numpy.dot(iv, single1.structure.shape.unit_z)
+        iv_x =     numpy.dot(iv, single1.structure.shape.unit_x)
+        iv_y =     numpy.dot(iv, single1.structure.shape.unit_y)
+        iv_z = abs(numpy.dot(iv, single1.structure.shape.unit_z))
 
-        # calculate the minimal dimensions of the iv shell (it fits perfectly around the particles)
-        iv_shell_z = abs(iv_z) + radius2
+        z_scaling = cls.calc_z_scaling_factor (D1, D2)
+        r0 = math.sqrt( iv_x**2 + iv_y**2 + (iv_z*z_scaling)**2)
+
+        # calculate the minimal height z_right1 of the shell including burst radius
+        # with the accompanying radius r1
+        z_right1 = iv_z + radius2 * Domain.SINGLE_SHELL_FACTOR
+        r1       = cls.r_right(single1, single2, r0, z_right1)
 
         len_iv_projected = math.sqrt(iv_x*iv_x + iv_y*iv_y)
         dist_r_from_com1 = len_iv_projected * D1 / D12
@@ -756,12 +761,17 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
 
         # calculate the minimal dimensions of the protective domain including space for the
         # burst volumes of the particles
-        dz_left = radius1
-        dz_right = iv_shell_z + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR)
-        dr = max(iv_shell_radius1 + com_shell_radius + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
+        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
                  iv_shell_radius2 + com_shell_radius + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
+        z_right2 = cls.z_right(single1, single2, r0, r2)
+
+        # of both alternatives pick the largest one
+        z_right, r = max((z_right1, r1),(z_right2, r2))
 
-        return dr, dz_left, dz_right
+        # z_left is always the same
+        z_left = radius1
+
+        return r, z_left, z_right
 
     @classmethod
     def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):

From 204203dd2be9d95dc21c2dd48356335826802896 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 Nov 2011 15:31:42 +0100
Subject: [PATCH 0343/1541] introduced constant for tolerance in time scale

---
 egfrd.py | 2 +-
 utils.py | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 738f9f23..762b4b7d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1066,7 +1066,7 @@ def process_single_event(self, single):
 
             # check that the event time of the single (last_time + dt) is equal to the
             # simulator time
-            assert (abs(single.dt + single.last_time - self.t) <= 1e-18 * self.t)
+            assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t)
 
 
             pid_particle_pair = single.pid_particle_pair
diff --git a/utils.py b/utils.py
index d9d7f7af..d590f902 100644
--- a/utils.py
+++ b/utils.py
@@ -21,6 +21,7 @@
 # Tolerance used for float comparison functions. Oversimplifying: two floats a 
 # and b are considered to be equal if abs(a - b) < TOLERANCE * abs(a).
 TOLERANCE = 1e-7
+TIME_TOLERANCE = 1e-10
 
 # Multiplication factor used for seperating 2 particles or a particle and a 
 # surface after unbinding.

From f6041a9df1bcdf3028b0e982307de6c85fc33434 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 8 Nov 2011 15:41:06 +0100
Subject: [PATCH 0344/1541] Changed multi.py to work with newBD scheme.
 get_closest surface has now an ignore argument, and is much shorter.

---
 BDSimulator.hpp                    | 116 +++++++++++---
 Multi.hpp                          | 241 +++++++++++++++--------------
 ParticleContainer.hpp              |   2 +-
 Transaction.hpp                    |   4 +-
 World.hpp                          |  69 +++------
 binding/MultiParticleContainer.hpp |  12 +-
 binding/ParticleContainer.hpp      |   4 +-
 multi.py                           |  11 +-
 newBDPropagator.hpp                |  27 ++--
 9 files changed, 276 insertions(+), 210 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 185026a7..5d7328cb 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -33,6 +33,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     typedef typename traits_type::rate_type rate_type;
     typedef typename traits_type::reaction_record_type reaction_record_type;
     typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
+    typedef std::pair<const Real, const Real> real_pair;
 
 public:
     Real const& dt_factor()
@@ -44,21 +45,24 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
 
     BDSimulator(boost::shared_ptr<world_type> world, 
                 boost::shared_ptr<network_rules_type const> network_rules,
-                rng_type& rng, Real dt_factor = traits_type::DEFAULT_DT_FACTOR,
-                int dissociation_retry_moves = 1, length_type reaction_length_factor = 1)
+                rng_type& rng, Real dt_factor = .1,
+                int dissociation_retry_moves = 1, length_type reaction_length_factor = traits_type::MULTI_SHELL_FACTOR)
         : base_type(world, network_rules, rng),
           dt_factor_(dt_factor), num_retries_(dissociation_retry_moves), 
           reaction_length_factor_(reaction_length_factor)
     {
-        calculate_dt();
-        reaction_length_ = determine_reaction_length( *world, base_type::dt_, reaction_length_factor_, *base_type::network_rules_);
+        calculate_dt_and_reaction_length();
         bound_time = 0;
     }
 
-    virtual void calculate_dt()
+    void calculate_dt_and_reaction_length()
     {
-        base_type::dt_ = dt_factor_ * determine_dt(*base_type::world_);
-        LOG_DEBUG(("dt=%f", base_type::dt_));
+        //base_type::dt_ = dt_factor_ * determine_dt(*base_type::world_);
+        base_type::dt_ = determine_dt();
+        reaction_length_ = determine_reaction_length();
+        log_.info( "dt=%e, reaction length=%e", base_type::dt_, reaction_length_ );
+        
+        LOG_DEBUG(("dt=%e, reaction length=%e", base_type::dt_, reaction_length_));
     }
 
     virtual void step()
@@ -101,31 +105,96 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return gsl_pow_2(radius_min * 2) / (D_max * 2);
     }
     
-    static length_type determine_reaction_length(world_type const& world, time_type dt, length_type const& reaction_length_factor,
-        network_rules_type const& rules)
+    Real determine_dt()
+    {
+        std::pair<const Real, const Real> maxD_minr( maxD_minsigma() );
+        const Real k_max( get_max_rate() );
+        const Real D_max( maxD_minr.first );
+        const Real r_min( maxD_minr.second );
+        const Real Pacc_max( 0.02 ); //Reciproke of maximum value of the acceptance probability.
+        const Real tau_D( 2 * r_min * r_min / D_max ); //~multi escape time.
+        Real dt;
+        
+        if( k_max > 0)
+        {
+            Real dt_temp( Pacc_max * reaction_length_factor_ * r_min / k_max );
+            dt = std::min( dt_temp, dt_factor_ * tau_D ); // dt_factor * tau_D is upper limit of dt.
+        }
+        else
+            dt = dt_factor_ * tau_D;
+
+        return dt;    
+    }
+    
+    length_type determine_reaction_length()
+    {
+        real_pair maxD_minr( maxD_minsigma() );
+        return reaction_length_factor_ * maxD_minr.second;
+    }
+    
+    /* Returns largest diffusion constant en smallest particle radius in the multi. */
+    real_pair maxD_minsigma()
+    {
+        Real D_max(0.), radius_min(std::numeric_limits<Real>::max());
+
+        BOOST_FOREACH(species_type s, base_type::world_->get_species())
+        {
+            if (D_max < s.D())
+                D_max = s.D();
+            if (radius_min > s.radius())
+                radius_min = s.radius();
+        }
+        
+        return real_pair(D_max, radius_min);
+    }
+    
+    /* Functions returns largest _1D_ intrinsic reaction rate in the multi.
+       TODO: include structures in kmax finder. */
+    Real get_max_rate()
     {
         Real k_max(0.);
+        int i = 0, j= 0;
 
-        BOOST_FOREACH(species_type s0, world.get_species())
+        BOOST_FOREACH(species_type s0, base_type::world_->get_species())
         {
-            BOOST_FOREACH(species_type s1, world.get_species())
+            j = 0;
+            BOOST_FOREACH(species_type s1, base_type::world_->get_species())
             {
-                reaction_rules const& rrules(rules.query_reaction_rule( s0.id(), s1.id() ));
+                if( j++ < i )
+                    continue;
+                
+                reaction_rules const& rrules((*base_type::network_rules_).query_reaction_rule( s0.id(), s1.id() ));
                 if (::size(rrules) == 0)
                 {
-                    break;
+                    continue;
                 }
-                
+                                
                 for (typename boost::range_const_iterator<reaction_rules>::type
-                i(boost::begin(rrules)), e(boost::end(rrules)); i != e; ++i)
+                it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
-                    if ( k_max < (*i).k() )
-                        k_max = (*i).k();
+                    const length_type r01( s0.radius() + s1.radius() );
+                    Real k;
+                    
+                    if(s0.structure_id() != s1.structure_id())
+                    {
+                        if(s0.structure_id() == "world")
+                            k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                        else
+                            k = base_type::world_->get_structure( s1.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                    }
+                    else
+                    {
+                        k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 ); 
+                    }
+                
+                    if ( k_max < k )
+                        k_max = k;
                 }          
             }
+            i++;
         }
-    
-        return reaction_length_factor * sqrt( 2 * 1E-12 * dt );
+        
+        return k_max;
     }
     
     Real get_reaction_length() const
@@ -138,11 +207,10 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         double old_bound_time = bound_time;
         bound_time = 0;
         
-        base_type::dt_ = dt;
-        
+        //base_type::dt_ = dt;
         reaction_length_factor_ = new_reaction_length_factor;
-        reaction_length_ = determine_reaction_length( *base_type::world_, base_type::dt_, reaction_length_factor_, 
-            *base_type::network_rules_ );
+        calculate_dt_and_reaction_length();
+
         return old_bound_time;        
     }
 
@@ -167,7 +235,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     }
 
 private:
-    Real const dt_factor_;
+    Real dt_factor_;
     int const num_retries_;
     length_type reaction_length_factor_;
     length_type reaction_length_;
diff --git a/Multi.hpp b/Multi.hpp
index 7ad30cbc..403b35a1 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -3,6 +3,7 @@
 
 #include <boost/scoped_ptr.hpp>
 #include <boost/algorithm/string/join.hpp>
+#include <boost/foreach.hpp>
 
 #include "exceptions.hpp"
 #include "Domain.hpp"
@@ -37,6 +38,11 @@ class MultiParticleContainer
     typedef typename traits_type::size_type size_type;
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
+    
+    typedef typename Ttraits_::network_rules_type network_rules_type;
+    typedef typename Ttraits_::reaction_rule_type reaction_rule_type;
+    typedef typename network_rules_type::reaction_rules reaction_rules;   
+    
     typedef typename Ttraits_::world_type::particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
     typedef Transaction<traits_type> transaction_type;
@@ -45,6 +51,7 @@ class MultiParticleContainer
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
     typedef std::map<particle_id_type, particle_type> particle_map;
     typedef sized_iterator_range<typename particle_map::const_iterator> particle_id_pair_range;
+    typedef std::pair<const Real, const Real> real_pair;
 
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
@@ -88,9 +95,9 @@ class MultiParticleContainer
         return world_.get_structures();
     }
     
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {        
-        return world_.get_closest_surface( pos );
+        return world_.get_closest_surface( pos, ignore );
     }
         
     virtual particle_id_pair new_particle(species_id_type const& sid,
@@ -98,6 +105,7 @@ class MultiParticleContainer
     {
         particle_id_pair const retval(world_.new_particle(sid, pos));
         particles_.insert(retval);
+	    add_species_to_multi(sid);
         return retval;
     }
 
@@ -108,19 +116,22 @@ class MultiParticleContainer
         if (i != particles_.end())
         {
             (*i).second = pi_pair.second;
+	        add_species_to_multi(pi_pair.second.sid());
             return false;
         }
         else
         {
-            particles_.insert(i, pi_pair);
+	        particles_.insert(i, pi_pair);
+	        add_species_to_multi(pi_pair.second.sid());
             return true;
         }
     }
 
     virtual bool remove_particle(particle_id_type const& id)
     {
+        species_.erase( get_particle(id).second.sid() );
         world_.remove_particle(id);
-        return particles_.erase(id);
+	    return particles_.erase(id);
     }
 
     virtual particle_id_pair get_particle(particle_id_type const& id) const
@@ -213,23 +224,119 @@ class MultiParticleContainer
                                       particles_.size());
     }
 
-    species_range get_species_in_multi() const
+    void add_species_to_multi(species_id_type const& sid)
     {   
-        species_map_.clear();
-     
-        BOOST_FOREACH(particle_id_pair pp, get_particles_range() )
+        typename species_map::const_iterator i(species_.find( sid ));
+	    if (species_.end() == i)
+	    {
+	        species_[sid] = world_.get_species( sid );
+        }
+    }
+    
+    species_range get_species_in_multi() const
+    {     
+        return species_range(
+            species_iterator(species_.begin(), species_second_selector_type()),
+            species_iterator(species_.end(), species_second_selector_type()),
+            species_.size());
+    }
+    
+    /* Returns largest diffusion constant en smallest particle radius inside the mpc. */
+    real_pair maxD_minsigma() const
+    {
+        Real D_max(0.), radius_min(std::numeric_limits<Real>::max());
+
+        BOOST_FOREACH(species_type s, get_species_in_multi())
+        {
+            if (D_max < s.D())
+                D_max = s.D();
+            if (radius_min > s.radius())
+                radius_min = s.radius();
+        }
+        
+        return real_pair(D_max, radius_min);
+    }
+    
+    /* Functions returns largest _1D_ intrinsic reaction rate in the mpc.
+       TODO: include structures in kmax finder. */
+    Real get_max_rate(network_rules_type const& rules) const
+    {
+        Real k_max(0.);
+        int i = 0, j= 0;
+
+        BOOST_FOREACH(species_type s0, get_species_in_multi())
         {
-            typename species_map::const_iterator i(species_map_.find( pp.second.sid() ));
-            if (species_map_.end() == i)
+            j = 0;
+            BOOST_FOREACH(species_type s1, get_species_in_multi())
             {
-                species_map_[pp.second.sid()] = world_.get_species( pp.second.sid() );
+                if( j++ < i )
+                    continue;
+                
+                reaction_rules const& rrules(rules.query_reaction_rule( s0.id(), s1.id() ));
+                if (::size(rrules) == 0)
+                {
+                    continue;
+                }
+                                
+                for (typename boost::range_const_iterator<reaction_rules>::type
+                it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
+                {
+                    const length_type r01( s0.radius() + s1.radius() );
+                    Real k;
+                    
+                    if(s0.structure_id() != s1.structure_id())
+                    {
+                        if(s0.structure_id() == "world")
+                            k = get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                        else
+                            k = get_structure( s1.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                    }
+                    else
+                    {
+                        k = get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 ); 
+                    }
+                
+                    if ( k_max < k )
+                        k_max = k;
+                }          
             }
+            i++;
         }
+        
+        return k_max;
+    }
     
-        return species_range(
-            species_iterator(species_map_.begin(), species_second_selector_type()),
-            species_iterator(species_map_.end(), species_second_selector_type()),
-            species_map_.size());
+    /* Function returns the timestep and reaction length (rl) for BD propegator. 
+       
+       --dt is calulated with the constraints:
+       (1) The reaction length is equal to MULTI_SHELL_FACTOR * r_min,
+       where r_min is the radius of the smallest particle in the multi.
+       (2) The largest acceptance probability in the multi is smaller than 0.02.
+       (3) particles can't escape the multi with a large step. (Dmax * dt < 1/10 * MULTI_SHELL_FACTOR * r_min * r_min).
+       
+       TODO:This function should be a method of the Multi Class, but I put it in the mpc such that we can use it in python.
+       
+       PROBLEM: for certain parameters (large k) dt can be very small and the simulation will slow down.
+    */    
+    real_pair determine_dt_and_reaction_length(network_rules_type const& rules, Real const& dt_factor) const
+    {            
+        const real_pair maxD_minr( maxD_minsigma() );
+        const Real k_max( get_max_rate(rules) );
+        const Real D_max( maxD_minr.first );
+        const Real r_min( maxD_minr.second );
+        const Real Pacc_max( 0.02 ); //Maximum allowed value of the acceptance probability.
+        const Real tau_D( 2 * r_min * r_min / D_max );
+        Real dt;
+        
+        if( k_max > 0)
+        {
+            Real dt_temp( Pacc_max * Ttraits_::MULTI_SHELL_FACTOR * r_min / k_max );
+            dt = std::min( dt_temp, dt_factor * tau_D ); // dt_factor * tau_D is upper limit of dt.
+        }
+        else
+            dt = dt_factor * tau_D;
+
+        return real_pair(dt, Ttraits_::MULTI_SHELL_FACTOR * r_min);
     }
 
     MultiParticleContainer(world_type& world): world_(world) {}
@@ -237,7 +344,7 @@ class MultiParticleContainer
 private:
     world_type& world_;
     particle_map particles_;
-    species_map species_map_;
+    species_map species_;
 };
 
 template<typename Tsim_>
@@ -268,6 +375,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
     typedef typename traits_type::reaction_record_type reaction_record_type;
+    typedef std::pair<const Real, const Real> real_pair;
 
 private:
     typedef std::map<species_id_type, species_type> species_map;
@@ -361,8 +469,8 @@ class Multi: public Domain<typename Tsim_::traits_type>
         : base_type(id), main_(main), pc_(*main.world()), dt_factor_(dt_factor),
           shells_(), last_event_(NONE)
     {
+        //TODO Do not base dt and rl on all particles in the world but only those in the multi.
         BOOST_ASSERT(dt_factor > 0.);
-        //TODO: dt calc. should only depend on particles in the multi. -This is a hack
         base_type::dt_ = dt_factor_ * BDSimulator<traits_type>::determine_dt(*main_.world());
     }
 
@@ -464,105 +572,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
     {
         return pc_.get_particles_range();
     }
-    
-    /* Returns largest diffusion constant en smallest particle radius in the multi. */
-    std::pair<const Real, const Real> maxD_minsigma()
-    {
-        Real D_max(0.), radius_min(std::numeric_limits<Real>::max());
-
-        BOOST_FOREACH(species_type s, pc_.get_species_in_multi())
-        {
-            if (D_max < s.D())
-                D_max = s.D();
-            if (radius_min > s.radius())
-                radius_min = s.radius();
-        }
-        std::pair<const Real, const Real> retval(D_max, radius_min);
-        
-        return retval;
-    }
-    
-    /* Functions returns largest _1D_ intrinsic reaction rate in the multi.
-       TODO: include structures in kmax finder. */
-    Real kmax()
-    {
-        Real k_max(0.);
-        int i = 0, j= 0;
-
-        BOOST_FOREACH(species_type s0, pc_.get_species_in_multi())
-        {
-            j = 0;
-            BOOST_FOREACH(species_type s1, pc_.get_species_in_multi())
-            {
-                if( j++ < i )
-                    continue;
-                
-                reaction_rules const& rrules(main_.network_rules().query_reaction_rule( s0.id(), s1.id() ));
-                if (::size(rrules) == 0)
-                {
-                    continue;
-                }
-                                
-                for (typename boost::range_const_iterator<reaction_rules>::type
-                it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
-                {
-                    const length_type r01( s0.radius() + s1.radius() );
-                    Real k;
-                    
-                    if(s0.structure_id() != s1.structure_id())
-                    {
-                        if(s0.structure_id() == "world")
-                            k = pc_.get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 );
-                        else
-                            k = pc_.get_structure( s1.structure_id() )->get_1D_rate( (*it).k(), r01 );
-                    }
-                    else
-                    {
-                        k = pc_.get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 ); 
-                    }
-                
-                    if ( k_max < k )
-                        k_max = k;
-                }          
-            }
-            i++;
-        }
-        
-        return k_max;
-    }
-    
-    /* Function returns dt for BD propegator. dt is calulated with the constraints:
-       (1) The reaction length is equal to (MULTI_SHELL_FACTOR - 1) * r_min,
-       where r_min is the radius of the smallest particle in the multi.
-       (2) The largest acceptance probability in the multi is smaller than 0.02.
-       
-       If the timestep as defined above is larger than a user defined maximum, use this maximum.
        
-       PROBLEM: for certain parameters (large k) dt can be very small and the simulation will slow down.
-    */    
-    Real determine_dt(Real const& reaction_length_factor)
-    {
-        std::pair<const Real, const Real> maxD_minr( maxD_minsigma() );
-        const Real k_max( kmax() );
-        const Real D_max( maxD_minr.first );
-        const Real r_min( maxD_minr.second );
-        const Real Pacc_max( 0.02 ); //Reciproke of maximum value of the acceptance probability.
-        const Real tau_D( 2 * r_min * r_min / D_max );
-        Real dt;
-        
-        if( k_max > 0)
-        {
-            Real dt_temp( Pacc_max * traits_type::MULTI_SHELL_FACTOR * r_min / k_max );
-            dt = std::min( dt_temp, dt_factor_ * tau_D ); // dt_factor * tau_D is lower limit of dt.
-        }
-        else
-            dt = dt_factor_ * tau_D;
-
-        log_.info( "timestep set to %f", dt );
-
-        return dt;    
-    }
-
     void step()
     {
         boost::scoped_ptr<
@@ -572,6 +582,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
         typedef typename multi_particle_container_type::transaction_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
         last_reaction_setter rs(*this);
         volume_clearer vc(*this);
+        
         BDPropagator<traits_type> ppg(
             *tx, *main_.network_rules(), main_.rng(),
             base_type::dt_,
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 63584b0b..650d4fe7 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -53,7 +53,7 @@ class ParticleContainer
     
     virtual structures_range get_structures() const = 0;
     
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const = 0;
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos) = 0;
diff --git a/Transaction.hpp b/Transaction.hpp
index 97d490aa..614be9dc 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -168,9 +168,9 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.get_structures();
     }    
         
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {
-        return pc_.get_closest_surface( pos );
+        return pc_.get_closest_surface( pos, ignore );
     }
 
     virtual species_type const& get_species(species_id_type const& id) const
diff --git a/World.hpp b/World.hpp
index 64b2ff23..bd728dde 100644
--- a/World.hpp
+++ b/World.hpp
@@ -10,6 +10,8 @@
 #include <boost/array.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/foreach.hpp>
 #include "exceptions.hpp"
 #include "generator.hpp"
 #include "filters.hpp"
@@ -289,63 +291,30 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             structure_map_.size());
     }
     
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
-    {        
-        structures_range structures = get_structures();
-        size_type const size ( structures.size() );
-               
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
+    {       
         length_type const world_size( base_type::world_size() );
-        
-        switch(size)
-        {
-        case 0:
-            throw not_found(std::string("No structures found."));
-                 
-        case 1:   
-            return structure_id_and_distance_pair( (*structures.begin())->id() , std::numeric_limits<length_type>::max() );
-        
-        case 2:
+        length_type ret_dist( std::numeric_limits<length_type>::max() );
+        structure_id_type ret_id;
+
+        BOOST_FOREACH(boost::shared_ptr<structure_type> const structure, get_structures())
         {
-            surface_iterator structure = structures.begin();
-                                              
-            position_type const cyc_pos( cyclic_transpose(pos, (*structure)->structure_position(), world_size) );
-                                              
-            position_type nearest_point_on_surface( (*structure)->projected_point( cyc_pos ).first );
-
-            return structure_id_and_distance_pair( (*structure)->id(), 
-                 traits_type::distance( nearest_point_on_surface, pos, world_size ) );
-        }
-        
-        default:
-        {   
-            surface_iterator structure = structures.begin();               
-            surface_iterator ret_structure( structure );
-            
-            position_type cyc_pos( cyclic_transpose(pos, (*structure)->structure_position(), world_size) );
+            if( structure->id() == ignore )
+                continue;
             
-            length_type ret_dist( (*structure)->projected_point_on_surface( cyc_pos ).second );
-            length_type dist;
-                   
-            structure++;
-            for(size_type i = 2; i < size; i++)
-            {
-                cyc_pos = cyclic_transpose(pos, (*structure)->structure_position(), world_size);                
-                dist = (*structure)->projected_point_on_surface( cyc_pos ).second;
+            position_type const cyc_pos(cyclic_transpose(pos, structure->structure_position(), world_size));
+            length_type const dist( structure->projected_point_on_surface( cyc_pos ).second );
                 
-                if( dist < ret_dist )
-                {
-                    ret_dist = dist;
-                    ret_structure = structure;
-                }
-                structure++;
-            }
-        
-            return structure_id_and_distance_pair( (*ret_structure)->id() , ret_dist );
+            if( dist < ret_dist )
+            {
+                ret_dist = dist;
+                ret_id = structure->id();
+            }  
         }
         
-        }
+        return structure_id_and_distance_pair( ret_id , ret_dist );
     }
-
+   
     particle_id_set get_particle_ids(species_id_type const& sid) const
     {
         typename per_species_particle_id_set::const_iterator i(
diff --git a/binding/MultiParticleContainer.hpp b/binding/MultiParticleContainer.hpp
index d27c8da8..852a815b 100644
--- a/binding/MultiParticleContainer.hpp
+++ b/binding/MultiParticleContainer.hpp
@@ -2,6 +2,9 @@
 #define BINDING_MULTI_PARTICLE_CONTAINER_HPP
 
 #include <boost/python.hpp>
+#include <boost/python/tuple.hpp>
+
+#include "peer/converters/tuple.hpp"
 
 namespace binding {
 
@@ -9,9 +12,14 @@ template<typename Timpl, typename Tworld>
 boost::python::objects::class_base register_multi_particle_container_class(char const* name)
 {
     using namespace boost::python;
+    typedef Timpl impl_type;
+
+    peer::converters::register_tuple_converter<typename impl_type::real_pair>();
 
-    return class_<Timpl, bases<typename Tworld::particle_container_type>,
-           boost::noncopyable>(name, init<Tworld&>());
+    return class_<impl_type, bases<typename Tworld::particle_container_type>,
+           boost::noncopyable>(name, init<Tworld&>())
+        .def("determine_dt_and_reaction_length", pure_virtual(&impl_type::determine_dt_and_reaction_length))
+        ;
 }
 
 } // namespace binding
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index e1985cd7..e0169c40 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -240,9 +240,9 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_structures")();
     }
 
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos) const
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {
-        return py_wrapper_type::get_override("get_closest_surface")(pos);
+        return py_wrapper_type::get_override("get_closest_surface")(pos, ignore);
     }
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
diff --git a/multi.py b/multi.py
index 2ceef203..e2ac8c0a 100644
--- a/multi.py
+++ b/multi.py
@@ -24,12 +24,14 @@ def __init__(self, domain_id, main, dt_factor):
         self.escaped = False
         self.dt_factor = dt_factor
         self.last_reaction = None
+        self.reaction_length = 0
 
     def initialize(self, t):
         self.last_time = t
         self.start_time = t
         main = self.main()
-        self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
+        set_dt_and_reaction_length()
+        #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):
         D_list = []
@@ -64,6 +66,9 @@ def add_particle(self, pid_particle_pair):
             log.info("add particle to multi:\n  (%s,\n   %s)" % 
                      (pid_particle_pair[0], pid_particle_pair[1]))
         self.particle_container.update_particle(pid_particle_pair)
+        
+    def set_dt_and_reaction_length(self):
+        self.dt, self.reaction_length = self.particle_container.determine_dt_and_reaction_length(main.network_rules, self.dt_factor)
 
     def step(self):
         self.escaped = False
@@ -102,8 +107,8 @@ def __call__(self, shape, ignore0, ignore1=None):
         cr = check_reaction()
         vc = clear_volume(self)
 
-        ppg = _gfrd.BDPropagator(tx, main.network_rules,
-                     myrandom.rng, self.dt, main.dissociation_retry_moves,
+        ppg = _gfrd.newBDPropagator(tx, main.network_rules,
+                     myrandom.rng, self.dt, main.dissociation_retry_moves, self.reaction_length,
                      cr, vc, [pid for pid, _ in self.particle_container])
 
         self.last_event = None
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index bc4c502c..278d3593 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -144,7 +144,7 @@ class newBDPropagator
         if(!bounced && pp_structure->id() == "world")
         {
             /* Check for overlap with nearest surface. */
-            struct_id_distance_pair = tx_.get_closest_surface( new_pos );
+            struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
             core_surface_distance = struct_id_distance_pair.second - r0;
         
             if(core_surface_distance < 0)
@@ -166,7 +166,7 @@ class newBDPropagator
             
             if(pp_structure->id() == "world")
             {
-                struct_id_distance_pair = tx_.get_closest_surface( new_pos );
+                struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
                 core_surface_distance = struct_id_distance_pair.second - r0;  
             }
         }
@@ -176,7 +176,7 @@ class newBDPropagator
         Real accumulated_prob = 0;
         Real const rnd( rng_() );
         
-        /* First, if a surface is near, attempt an interaction. */
+        /* First, if a surface is inside the reaction volume, attempt an interaction. */
         if(core_surface_distance < reaction_length_ && pp_structure->id() == "world")
         {        
             boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure(struct_id_distance_pair.first) );
@@ -365,7 +365,7 @@ class newBDPropagator
 
                         if( s0.structure_id() == "world" )
                         {
-                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
+                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id()) );
                             length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
                                     
                             if( core_surface_distance < 0 )
@@ -439,13 +439,13 @@ class newBDPropagator
                             bool surface_overlap = false;
                             if( s0.structure_id() == "world" && s1.structure_id() == "world" )
                             {
-                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first ) );
+                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, s0.structure_id() ) );
                                 length_type core_surface_distance( struct_id_distance_pair.second - s0.radius() );
                                     
                                 if( core_surface_distance < 0 )
                                     surface_overlap = true;
                                     
-                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second );
+                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second, s1.structure_id() );
                                 core_surface_distance = struct_id_distance_pair.second - s1.radius();
 
                                 if( core_surface_distance < 0 )
@@ -580,7 +580,7 @@ class newBDPropagator
                         
                         if( sp.structure_id() == "world" )
                         {
-                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
+                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, sp.structure_id() ) );
                             length_type const core_surface_distance( struct_id_distance_pair.second - sp.radius() );
                                     
                             if( core_surface_distance < 0 )
@@ -667,13 +667,18 @@ class newBDPropagator
                             }
                         }
 
-                        remove_particle(pp.first);
-                        particle_id_pair npp(tx_.new_particle(product, new_pos));
+			            const particle_id_pair new_p(
+			              pp.first, particle_type(sp.id(),
+				            particle_shape_type(new_pos,
+					          sp.radius()),
+					            sp.D()));
+
+                        tx_.update_particle(new_p);
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(npp.first), pp.first));
+                                    r.id(), array_gen(new_p.first), pp.first));
                         }
                         break;
                     }
@@ -750,7 +755,7 @@ class newBDPropagator
         
         if(s0.structure_id() == "world")
         {
-            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos ) );
+            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id() ) );
             length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
                                     
             if( core_surface_distance < 0 )

From 4774b5dc140388015507437abe196d52ce43ad86 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Tue, 8 Nov 2011 16:58:47 +0100
Subject: [PATCH 0345/1541] "Couldn't straddle" error has been fixed. Alpha's
 can now all be calculated.

Still todo concerning alpha's:
- run some tests
- only simple solution has been implemented, might be cheaper way
- still have to remove and update comments ("clean-up")
---
 GreensFunction2DRadAbs.cpp | 149 +++++++++++++++++++++++++------------
 GreensFunction2DRadAbs.hpp |   8 +-
 findRoot.cpp               |   6 +-
 3 files changed, 110 insertions(+), 53 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 425f2467..fd2d4c33 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -84,6 +84,8 @@ GreensFunction2DRadAbs::~GreensFunction2DRadAbs()
 // Resets the alpha-tables
 void GreensFunction2DRadAbs::clearAlphaTable() const
 {
+    const Real estimated_alpha_root_distance(getestimated_alpha_root_distance_());
+
     // Clears all vectors in the alphaTable
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
 		   boost::mem_fn( &RealVector::clear ) );
@@ -96,11 +98,13 @@ void GreensFunction2DRadAbs::clearAlphaTable() const
 	// Sets all values of the alpha_x_scan_table_ to zero.
     std::fill( this->alpha_x_scan_table_.begin(), 
                this->alpha_x_scan_table_.end(),
-	           EPSILON/L_TYPICAL );
+	           SCAN_START*estimated_alpha_root_distance); // DEBUG TODO; actual number here might
+                     	            // be important for functioning of Bessel
+                     	            // functions.
 	           
-	// Sets all values of the alpha_dx_entry_in_margin_ table to zero.
-    std::fill( this->alpha_dx_entry_in_margin_.begin(), 
-               this->alpha_dx_entry_in_margin_.end(),
+	// Sets all values of the alpha_correctly_estimated_ table to zero.
+    std::fill( this->alpha_correctly_estimated_.begin(), 
+               this->alpha_correctly_estimated_.end(),
 	           0 );	           
 	           
 }
@@ -116,6 +120,8 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const Real s_An( sigma * alpha );
 	const Real a_An( a * alpha );
 
+//TODO REMOVE    std::cout << "Calling bessel from f_alpha0.\n"; 
+
 	const double J0_s_An (gsl_sf_bessel_J0(s_An));
 	const double J1_s_An (gsl_sf_bessel_J1(s_An));
 	const double J0_a_An (gsl_sf_bessel_J0(a_An));
@@ -123,6 +129,8 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const double Y0_s_An (gsl_sf_bessel_Y0(s_An));
 	const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
 	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));
+	
+// TODO DEBUG REMOVE std::cout << "Done.\n";
 
 	const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
 	const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
@@ -215,14 +223,25 @@ const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 	const Real a_An( a * alpha );
 	const Real realn( static_cast<Real>( n ) );
 
+    // TODO REMOVE std::cout << "Calling bessel from f_alpha.\n"; // TODO: DEBUG REMOVE
+    // TODO REMOVE std::cout << "(n="<<n<<", sigma="<<sigma<<", alpha="<<alpha<<", sigma*alpha="<<s_An<<");\n";
+
+    // TODO REMOVE std::cout << "1.\n"; // TODO: DEBUG REMOVE
 	const double Jn_s_An  (gsl_sf_bessel_Jn(n, s_An));
+    // TODO REMOVE std::cout << "2.\n"; // TODO: DEBUG REMOVE	
 	const double Jn1_s_An (gsl_sf_bessel_Jn(n+1, s_An));
+    // TODO REMOVE std::cout << "3.\n"; // TODO: DEBUG REMOVE	
 	const double Jn_a_An  (gsl_sf_bessel_Jn(n, a_An));
 
+    // TODO REMOVE std::cout << "4.\n"; // TODO: DEBUG REMOVE
 	const double Yn_s_An  (gsl_sf_bessel_Yn(n, s_An));
+    // TODO REMOVE std::cout << "5.\n"; // TODO: DEBUG REMOVE
 	const double Yn1_s_An (gsl_sf_bessel_Yn(n+1, s_An));
+    // TODO REMOVE std::cout << "6.\n"; // TODO: DEBUG REMOVE	
 	const double Yn_a_An  (gsl_sf_bessel_Yn(n, a_An));
 
+    // TODO REMOVE std::cout << "Done\n";
+
 	const double rho1 ( ( (h*sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
 	const double rho2 ( ( (h*sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
 	return (rho1 - rho2); 
@@ -241,6 +260,9 @@ GreensFunction2DRadAbs::f_alpha_aux_F( const Real alpha,
     const GreensFunction2DRadAbs* const gf( params->gf ); 
     const Integer n( params->n );
 
+    //DEBUG REMOVE TODO
+    // TODO REMOVE std::cout << "Calling f_alpha from f_alpha_aux_F.\n";
+
     return gf->f_alpha( alpha, n );	// f_alpha is the function of which we have 
                                     // to find the roots
 }
@@ -369,6 +391,9 @@ GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
 
     // # Look for the sign change.
 
+    // DEBUG REMOVE TODO
+    // TODO REMOVE std::cout << "calling f_alpha from alphaOffset.\n";
+
     // Get the values of the function at x "low" and x "high".
     Real f_low ( f_alpha(low,n) );	
     Real f_high( f_alpha(high,n) );	
@@ -420,12 +445,16 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 	const Real a_An (a*alpha);
         const Real alpha_sq (alpha*alpha);
 
+    // TODO REMOVE std::cout << "Calling bessel from p_survival_i\n";
+
 	// calculate all the required Bessel functions
         const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
         const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
         const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
 	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
+    // TODO REMOVE std::cout << "Done.\n";
+
 	// calculate C0,n
         const Real C_i_0 (calc_A_i_0(alpha)); 
 
@@ -442,24 +471,29 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 const Real 
 GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
 {
-        const Real a( geta() );    		        // get the needed parameters
-        const Real sigma( getSigma() );
-        const Real h (this->geth());
+    const Real a( geta() );    		        // get the needed parameters
+    const Real sigma( getSigma() );
+    const Real h (this->geth());
 
-        const Real s_An (sigma*alpha);
-        const Real a_An (a*alpha);
-        const Real r0An (r0*alpha);
+    const Real s_An (sigma*alpha);
+    const Real a_An (a*alpha);
+    const Real r0An (r0*alpha);
 
 //	const int n = 0;
 //	if ( n == 0)
 //	{
-		const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
-	        const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
-	        const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
 
-	        const Real J0_r0An (gsl_sf_bessel_J0(r0An));
-	        const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-	        const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+    // TODO REMOVE std::cout << "Calling bessel from calc_A_i_0.\n";
+
+	const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+    const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+    const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+
+    const Real J0_r0An (gsl_sf_bessel_J0(r0An));
+    const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
+    const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
+    
+        // TODO REMOVE std::cout << "Done.\n";
 //	}
 //	else
 //	{
@@ -488,12 +522,16 @@ GreensFunction2DRadAbs::leaves_i( const Real alpha) const
         const Real s_An (sigma*alpha);
         const Real a_An (a*alpha);
 
+    // TODO REMOVE std::cout << "Calling bessel from leaves_i.\n"; // TODO REMOVE DEBUG
+
 	// calculate all the required Bessel functions
         const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
         const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
         const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
         const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-
+        
+    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
+    
         // calculate An,0
         const Real A_i_0 (calc_A_i_0(alpha));		// calculate the coefficient A0,n
 
@@ -568,12 +606,15 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	const Real a_An (a*alpha);
 	const Real alpha_sq (alpha*alpha);
 
-	// calculate all the required Bessel functions
+    // TODO REMOVE std::cout << "Calling bessel from Y0J0J1_constants.\n"; // TODO REMOVE DEBUG
+
+	// calculate all the required Bessel functions	
 	const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
 	const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
 	const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
 	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
-
+	
+    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
 
         // calculate An,0
 	const Real A_i_0 (calc_A_i_0(alpha)); //_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
@@ -700,6 +741,9 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
 	}
 
     // # Look for the sign change.
+    
+    // TODO DEBUG REMOVE
+    // TODO REMOVE std::cout << "Calling f_alpha from GiveRootInterval.\n";
 
     // Get the values of the function at x "low" and x "high".
     // Different for n=0 because this results in a simpler function.
@@ -717,7 +761,7 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
     while( f_low * f_high > 0 )		
     {					
         // DEBUG; TODO REMOVE
-        std::cout << "Scanning; no root at:[" << low << "," << high << "]\n";
+        // TODO REMOVE std::cout << "Scanning; no root at:[" << low << "," << high << "]\n";
     
         low =  high;			
         f_low = f_high;			
@@ -852,16 +896,15 @@ GreensFunction2DRadAbs::getAlphaRoot( const Real low,   // root lies between low
 
 // TODO: check comments for mistakes / completion
 // Subfunction of getAlpha
+// 
+// For now just counts the number of times the root lies in the interval that
+// can be used to estimate the next root. If this happens enough, then switch
+// to just assuming that for all next roots the distance inbetween roots will
+// equal the interval +/- margin.
 const void GreensFunction2DRadAbs::decideOnMethod2(size_t n, 
                                                    RealVector::size_type i
                                                   ) const
-{
-
-// TODO we could also add to this that if we've been in the margin for a certain
-// amount of time already, we'll also switch. DELIBERATE WITH TOMEK? Well, 
-// actually the overhead is not too bad. If there is only 1 entry, but we expect
-// two, then it will, for each root, check once if there is a sign change in the
-// difference. (Three substractions and a multiplication.)
+{    
 
     // Since the function can only decide with two alpha's already calculated, 
     // it can't do anything if i = 0.
@@ -870,29 +913,26 @@ const void GreensFunction2DRadAbs::decideOnMethod2(size_t n,
         const Real dx(getAlpha(n, i)-getAlpha(n, i-1)); // note the recursiveness!
         const Real estimated_alpha_root_distance_( this->getestimated_alpha_root_distance_() );
 
-        // If the absolute deviation from the expected difference is smaller 
-        // than the expected margin, it is assumed we can use method 2.
+        // If the relative deviation from the expected difference is smaller 
+        // than the expected margin, increase number of would-be correct 
+        // guesses.
         if (fabs(1-dx/estimated_alpha_root_distance_) < INTERVAL_MARGIN) {
-            ++alpha_dx_entry_in_margin_[n];
-            
-            // There is only a limited amount of times the distance will switch
-            // from expected to be in the margin to being expected not to be in
-            // the margin. Hence if the distance falls within the margin, while
-            // the previous distance didn't, if this happens for more than 
-            // DISTANCE_INOUT_MARGIN times, we permanently switch to method 2. 
-            // (I.e. we will assume the distance between the roots will now 
-            // always stay within the margin.)
-            if (alpha_dx_entry_in_margin_[n] >= DISTANCE_INOUT_MARGIN) {
-                alpha_x_scan_table_[n] = -2; // permanently switch
-            } else {
-                alpha_x_scan_table_[n] = -1; // temporarely switch
-            }
-        }    
+            ++alpha_correctly_estimated_[n];            
+        } else {
+            alpha_correctly_estimated_[n] = 0;
+        }   
+        
+        // If guessing would have worked for last CONVERGENCE_ASSUMED roots, 
+        // assume it will for all following roots.
+        if (alpha_correctly_estimated_[n] > CONVERGENCE_ASSUMED) {
+            alpha_x_scan_table_[n] = -2; // permanently switch
+        }
     }
     
     return;
 }
 
+/* LEGACY
 // TODO: check comments for mistakes / completion
 // Subfunction of getAlpha
 const void GreensFunction2DRadAbs::needToSwitchBackMethod1(
@@ -924,6 +964,7 @@ const void GreensFunction2DRadAbs::needToSwitchBackMethod1(
 
     return;
 }
+*/
 
 // TODO ADD SOME COMMENTS HERE!
 const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
@@ -964,7 +1005,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
 	        GiveRootInterval(low, high, n);	        
 	        
 	        // DEBUG; TODO REMOVE
-	        std::cout << "(n="<<n<<",i="<<i<<") Via scan: looking at:[" << low << "," << high << "]\n";
+	        // TODO REMOVE std::cout << "(n="<<n<<",i="<<i<<") Via scan: looking at:[" << low << "," << high << "]\n";
 	        
 	        // ### Finds the root using the GSL rootfinder
             current_root_ = getAlphaRoot(low, high, n);
@@ -972,7 +1013,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
             // ### Puts the found root in the table.
 		    alphaTable[i]= current_root_;
 		    		    
-		    // Check if we can use method 2 temporarily or permanently
+		    // Check if we can use method 2 for next roots
 		    decideOnMethod2(n, i);		    
 	    }
 	    // Method 2. ASSUMING CORRECT. If next root is expected to lie close 
@@ -984,7 +1025,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
 	        GiveRootIntervalSimple(low, high, n, i);	        
 
 	        // DEBUG; TODO REMOVE
-	        std::cout << "(n="<<n<<",i="<<i<<") Via \"sure\" estimate: looking at:[" << low << "," << high << "]\n";
+	        // TODO REMOVE std::cout << "(n="<<n<<",i="<<i<<") Via \"sure\" estimate: looking at:[" << low << "," << high << "]\n";
 	    
 	        // ### Finds the root using the GSL rootfinder
             current_root_ = getAlphaRoot(low, high, n);
@@ -992,8 +1033,10 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
             // ### Puts the found root in the table.
 		    alphaTable[i] = current_root_;		    
 
+            /* LEGACY
     		// check if we need to switch back to method 1
     		needToSwitchBackMethod1(n, i);    		    
+    		*/
 	    }
 	    
 	    // # Looks if we can switch from method 1 to method 2.
@@ -1020,6 +1063,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
 	        real distance (current_root_ - alphaTable[i-1]);
 	    }
 */	    
+    // TODO REMOVE std::cout << "We've found your root for ya!\n";
     }
     
     return alphaTable[i];
@@ -1072,8 +1116,12 @@ GreensFunction2DRadAbs::p_int_r_i_exp_table( const unsigned int i,
 	const Real alpha( this->getAlpha( 0, i ) );	// get the root An
 	const Real r_An( r*alpha);
 
+    // TODO REMOVE std::cout << "Calling bessel p_int_r_i_esp_table.\n"; // TODO REMOVE DEBUG
+    
 	const Real J1_rAn (gsl_sf_bessel_J1(r_An));
 	const Real Y1_rAn (gsl_sf_bessel_Y1(r_An));
+	
+    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
 
 	const Real result (Y0_aAnTable[i]*r*J1_rAn - J0_aAnTable[i]*r*Y1_rAn - Y0J1J0Y1Table[i]);
 	return result;
@@ -1521,6 +1569,8 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 
 //	const CylindricalBesselGenerator& s(CylindricalBesselGenerator::instance());
 
+    // TODO REMOVE std::cout << "Calling bessel from p_m_alpha.\n"; // TODO REMOVE DEBUG
+
 	// calculate the needed bessel functions
 	const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
 	const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));	// prime
@@ -1544,6 +1594,7 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 //	const Real Jm_rAnm   (s.J(m, r_Anm));
 //	const Real Ym_rAnm   (s.Y(m, r_Anm));
 
+    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
 
 	// calculating An,m
 	const Real h_ma (h - realm/sigma);
@@ -1672,6 +1723,8 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real a_Anm (a*alpha);
         const Real r0Anm (r0*alpha);
 
+    // TODO REMOVE std::cout << "Calling bessel from dp_m_alpha_at_a.\n"; // TODO REMOVE DEBUG
+
 	// std::clog << "|";	// DEBUG *REMOVEME*
         // calculate the needed bessel functions
         	// std::clog << "1";	// DEBUG *REMOVEME*
@@ -1689,6 +1742,8 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm)); // !GIVES PROBLEMS
 	// std::clog << "_";	// DEBUG *REMOVEME*
 
+    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
+
         // calculating An,m
         const Real h_ma (h - realm/sigma);
 //        std::clog << "\n[$ h_ma = "<< h_ma <<"$]\n"; // DEBUG *REMOVEME*
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index ae461542..9f58485f 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -61,9 +61,11 @@ class GreensFunction2DRadAbs
     // maximum INTERVAL_MARGIN is 0.33, since underestimating >33% twice
     // in a row will result in two roots in the same sign-change scanning 
     // domain.
-    static const Real DISTANCE_INOUT_MARGIN = 2;
+    static const Real CONVERGENCE_ASSUMED = 25;
     static const Real INTERVAL_MARGIN = .33; 
-    static const Real FRACTION_SCAN_INTERVAL = .5; // Distance between subsequent roots should always > this
+    static const Real FRACTION_SCAN_INTERVAL = .5; // Distance between subsequent roots should always > this    
+    // Percentage of estimated interval where root finding should start:
+    static const Real SCAN_START = 0.001; 
 
 
 public:
@@ -344,7 +346,7 @@ class GreensFunction2DRadAbs
     // pi/(sigma-a).
     //      Initial values are set by constructor.
     mutable boost::array<Real,MAX_ORDER+1> alpha_x_scan_table_;     
-    mutable boost::array<int,MAX_ORDER+1> alpha_dx_entry_in_margin_;
+    mutable boost::array<int,MAX_ORDER+1> alpha_correctly_estimated_;
 
 };
 
diff --git a/findRoot.cpp b/findRoot.cpp
index b420680f..57a02969 100644
--- a/findRoot.cpp
+++ b/findRoot.cpp
@@ -22,7 +22,7 @@ Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
 {
 
     // TODO DEBUG REMOVE!!!    
-    std::cout << "Starting root finding. Initiated by: " << funcName << ";\n";
+    // std::cout << "Starting root finding. Initiated by: " << funcName << ";\n";
     // END TODO DEBUG REMOVE
 
     Real l(low);
@@ -43,7 +43,7 @@ Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
         h = gsl_root_fsolver_x_upper(solver);
 
         // TODO DEBUG REMOVE!!!
-        std::cout << "Current search: [" << l << ", " << h << "];\n";
+        // std::cout << "Current search: [" << l << ", " << h << "];\n";
         // END TODO DEBUG REMOVE
         
 
@@ -70,7 +70,7 @@ Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
     const Real root(gsl_root_fsolver_root(solver));
 
     // TODO DEBUG REMOVE!!!    
-    std::cout << "Final output: [" << root << "];\n";
+    // std::cout << "Final output: [" << root << "];\n";
     // END TODO DEBUG REMOVE
         
     return root;    

From 3e77a8b131a2e6cd05120c22d9f2f9febe3d902c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 Nov 2011 17:25:46 +0100
Subject: [PATCH 0346/1541] moved identity change code from process_pair_event
 to separate fire_pair_reaction method

---
 egfrd.py | 145 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 76 insertions(+), 69 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 762b4b7d..a876f7d8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1020,12 +1020,80 @@ def fire_interaction(self, single, reactant_pos):
         return products
 
 
-    def fire_pair_reaction(self, pair):
+    def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos):
         # This takes care of the identity change when two particles react with each other
         # It performs the reactions:
         # A(any structure) + B(same structure) -> 0
         # A(any structure) + B(same structure or 3D) -> C(same structure)
-        pass
+
+        # 0. get reactant info
+        pid_particle_pair1 = pair.pid_particle_pair1
+        pid_particle_pair2 = pair.pid_particle_pair2
+        reactant1_species_id = pid_particle_pair1[1].sid
+        reactant2_species_id = pid_particle_pair2[1].sid
+
+        rr = pair.draw_reaction_rule(pair.interparticle_rrs)
+        # 1. remove the particles
+
+        if len(rr.products) == 0:
+
+            # 1. no product particles, no info
+            # 2. No space required
+            # 3. No space required
+            # 4. process the change (remove particles, make new ones)
+            self.world.remove_particle(pid_particle_pair1[0])
+            self.world.remove_particle(pid_particle_pair2[0])
+            products = []
+
+            # 5. No new single to be made
+            # 6. Log the change
+            self.last_reaction = (rr, (pid_particle_pair1[1], pid_particle_pair2[1]), products)
+
+        elif len(rr.products) == 1:
+
+            # 1. get product info
+            product_species = self.world.get_species(rr.products[0])
+            product_radius  = product_species.radius
+
+            # 1.5 get new position for product particle
+            product_pos = pair.draw_new_com (pair.dt, pair.event_type)
+            product_pos = self.world.apply_boundary(product_pos)
+
+            # 2.  make space for products
+            # 2.1 if the product particle sticks out of the shell
+#            if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_radius):
+            self.burst_volume(product_pos, product_radius)
+
+            # 3. check that there is space for the products ignoring the reactants
+            if self.world.check_overlap((product_pos, product_radius), pid_particle_pair1[0],
+                                                                       pid_particle_pair2[0]):
+                if __debug__:
+                    log.info('fire_pair_reaction: no space for product particle.')
+                moved_reactant1 = self.move_particle(pid_particle_pair1, reactant1_pos)
+                moved_reactant2 = self.move_particle(pid_particle_pair2, reactant2_pos)
+                products = [moved_reactant1, moved_reactant2]     # no change 
+                self.rejected_moves += 1
+
+            else:
+                # 4. process the changes (remove particle, make new ones)
+                self.world.remove_particle(pid_particle_pair1[0])
+                self.world.remove_particle(pid_particle_pair2[0])
+                newparticle = self.world.new_particle(product_species.id, product_pos)
+                products = [newparticle]
+
+                # 5. update counters
+                self.reaction_events += 1
+                self.last_reaction = (rr, (pid_particle_pair1, pid_particle_pair2),
+                                      products)
+
+                # 6. Log the change
+                if __debug__:
+                    log.info('fire_pair_reaction: product (%s) = %s' % (len(products), products))
+
+        else:
+            raise NotImplementedError('num products >= 2 not supported.')
+
+        return products
 
 
     def fire_move(self, single, reactant_pos):
@@ -1479,76 +1547,15 @@ def process_pair_event(self, pair):
             reactant1_pos = self.world.apply_boundary(reactant1_pos)
             reactant2_pos = self.world.apply_boundary(reactant2_pos)
 
-            product_pos = pair.draw_new_com (pair.dt, pair.event_type)
-            product_pos = self.world.apply_boundary(product_pos)
-
-            # TODO make this a fire_pair_reaction method
-
-
-            # 0. get reactant info
-            rr = pair.draw_reaction_rule(pair.interparticle_rrs)
-            reactant1_species_id = pid_particle_pair1[1].sid
-            reactant2_species_id = pid_particle_pair2[1].sid
-
-            # 1. remove the particles
-
-            if len(rr.products) == 0:
-
-                # 1. no product particles, no info
-                # 2. No space required
-                # 3. No space required
-                # 4. process the change (remove particles, make new ones)
-                self.world.remove_particle(pid_particle_pair1[0])
-                self.world.remove_particle(pid_particle_pair2[0])
-                products = []
-
-                # 5. No new single to be made
-                # 6. Log the change
-                self.last_reaction = (rr, (pid_particle_pair1[1], pid_particle_pair2[1]), products)
-
-            elif len(rr.products) == 1:
-
-                # 1. get product info
-                product_species = self.world.get_species(rr.products[0])
-
-                # 1.5 no change in position due to reaction
-                # position = product_pos
-
-                # 2.  make space for products
-                # 2.1 if the product particle sticks out of the shell
-                if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_species.radius):
-                    self.burst_volume(product_pos, product_species.radius)
-
-                    # 3. check that there is space for the products ignoring the reactants
-                    if self.world.check_overlap((product_pos, product_species.radius),
-                                                pid_particle_pair1[0],
-                                                pid_particle_pair2[0]):
-                        # TODO NoSpace no longer exists, make sure that reactant particles are properly placed
-                        if __debug__:
-                            log.info('no space for product particle.')
-                        raise NoSpace()
-
-                # 4. process the changes (remove particle, make new ones)
-                self.world.remove_particle(pid_particle_pair1[0])
-                self.world.remove_particle(pid_particle_pair2[0])
-                particle = self.world.new_particle(product_species.id, product_pos)
-                products = [particle, ]
+            self.remove_domain(pair)
+            particles = self.fire_pair_reaction (pair, reactant1_pos, reactant2_pos)
 
+            domains = []
+            for pid_particle_pair in particles:
                 # 5. make a new single and schedule
-                single = self.create_single(particle)
+                single = self.create_single(pid_particle_pair)
                 self.add_domain_event(single)
-
-                # 6. Log the change
-                if __debug__:
-                    log.info('product = %s' % single)
-                self.last_reaction = (rr, (pid_particle_pair1, pid_particle_pair2),
-                                      products)
-            else:
-                raise NotImplementedError('num products >= 2 not supported.')
-
-            # 7. update counter
-            self.reaction_events += 1
-            self.remove_domain(pair)
+                domains.append(single)
 
         #
         # 3a. Escaping through a_r.

From d28cf2ed13ad984b98d0c8baca09b3fa7659c999 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 9 Nov 2011 11:54:33 +0100
Subject: [PATCH 0347/1541] Particle reacts with surface when midpoint is near
 Included fabs in get_closest_surface.

---
 BDSimulator.hpp        |  2 +-
 CylindricalSurface.hpp | 10 +++---
 Multi.hpp              | 23 +++++++------
 World.hpp              |  2 +-
 egfrd.py               | 11 +++---
 multi.py               |  7 ++--
 newBDPropagator.hpp    | 78 ++++++++++++++++++++++--------------------
 7 files changed, 71 insertions(+), 62 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 5d7328cb..9c7d9b1d 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -111,7 +111,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         const Real k_max( get_max_rate() );
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
-        const Real Pacc_max( 0.02 ); //Reciproke of maximum value of the acceptance probability.
+        const Real Pacc_max( 0.1 ); //Reciproke of maximum value of the acceptance probability.
         const Real tau_D( 2 * r_min * r_min / D_max ); //~multi escape time.
         Real dt;
         
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 12330546..75d9e399 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -87,12 +87,12 @@ class CylindricalSurface
 
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
-        length_type r01( r0 + base_type::shape().radius() );
-        length_type r01l( r01 + rl );
-        length_type r01l_sq( r01l * r01l );
-        length_type r01_sq( r01 * r01 );
+        length_type rc( base_type::shape().radius() ); 
+        length_type rcl( rc + rl );
+        length_type rcl_sq( rcl * rcl );
+        length_type rc_sq( rc * rc );
 
-        return M_PI * ( r01l_sq - r01_sq );
+        return M_PI * ( rcl_sq - rc_sq );
     }
     
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
diff --git a/Multi.hpp b/Multi.hpp
index 403b35a1..04eb51a5 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -309,34 +309,35 @@ class MultiParticleContainer
     /* Function returns the timestep and reaction length (rl) for BD propegator. 
        
        --dt is calulated with the constraints:
-       (1) The reaction length is equal to MULTI_SHELL_FACTOR * r_min,
+       (1) The reaction length is equal to 0.05 * r_min,
        where r_min is the radius of the smallest particle in the multi.
-       (2) The largest acceptance probability in the multi is smaller than 0.02.
-       (3) particles can't escape the multi with a large step. (Dmax * dt < 1/10 * MULTI_SHELL_FACTOR * r_min * r_min).
+       (2) The largest acceptance probability in the multi is smaller than 0.1.
+       (3) particles escape the multi with a maximum step size in the order of the 
+           reaction length. (Dmax * dt ~ (.05 * r_min)**2 ).
        
        TODO:This function should be a method of the Multi Class, but I put it in the mpc such that we can use it in python.
        
        PROBLEM: for certain parameters (large k) dt can be very small and the simulation will slow down.
     */    
-    real_pair determine_dt_and_reaction_length(network_rules_type const& rules, Real const& dt_factor) const
-    {            
+    real_pair determine_dt_and_reaction_length(network_rules_type const& rules, Real const& step_size_factor) const
+    {               
         const real_pair maxD_minr( maxD_minsigma() );
         const Real k_max( get_max_rate(rules) );
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
-        const Real Pacc_max( 0.02 ); //Maximum allowed value of the acceptance probability.
-        const Real tau_D( 2 * r_min * r_min / D_max );
+        const Real Pacc_max( 0.1 ); //Maximum allowed value of the acceptance probability.
+        const Real tau_D( 2 * gsl_pow_2(step_size_factor * r_min) / D_max );
         Real dt;
         
         if( k_max > 0)
         {
-            Real dt_temp( Pacc_max * Ttraits_::MULTI_SHELL_FACTOR * r_min / k_max );
-            dt = std::min( dt_temp, dt_factor * tau_D ); // dt_factor * tau_D is upper limit of dt.
+            Real dt_temp( 2 * Pacc_max * step_size_factor * r_min / k_max );
+            dt = std::min( dt_temp, tau_D ); // tau_D is upper limit of dt.
         }
         else
-            dt = dt_factor * tau_D;
+            dt = tau_D;
 
-        return real_pair(dt, Ttraits_::MULTI_SHELL_FACTOR * r_min);
+        return real_pair(dt, step_size_factor * r_min);
     }
 
     MultiParticleContainer(world_type& world): world_(world) {}
diff --git a/World.hpp b/World.hpp
index bd728dde..b95af7dd 100644
--- a/World.hpp
+++ b/World.hpp
@@ -303,7 +303,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
                 continue;
             
             position_type const cyc_pos(cyclic_transpose(pos, structure->structure_position(), world_size));
-            length_type const dist( structure->projected_point_on_surface( cyc_pos ).second );
+            length_type const dist( fabs( structure->projected_point_on_surface( cyc_pos ).second ) );
                 
             if( dist < ret_dist )
             {
diff --git a/egfrd.py b/egfrd.py
index c968e85f..cdd51a96 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -36,8 +36,6 @@
 import logging
 import os
 
-from bd import DEFAULT_DT_FACTOR
-
 log = logging.getLogger('ecell')
 
 if __debug__:
@@ -116,7 +114,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.shell_id_generator = ShellIDGenerator(0)
 
         # some constants
-        self.MULTI_SHELL_FACTOR = 1.05          # This is the threshold for when the algorithm switches from
+        self.MULTI_SHELL_FACTOR = 1.5           # This is the threshold for when the algorithm switches from
                                                 # NonInteractionSingles to a Multi and also defines the Multi
                                                 # shell size.
         self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
@@ -126,6 +124,10 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         self.MAX_TIME_STEP = 10
 
+        self.DEFAULT_DT_FACTOR = 1e-5           # Diffusion time prefactor in BD algortithm to determine time step.
+        
+        self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # prefactor to determine maximum step size in BD algorithm.
+
         # used datastructrures
         self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
 
@@ -497,9 +499,10 @@ def create_multi(self):
                 dt_factor = DEFAULT_DT_FACTOR 
         else:
             dt_factor = DEFAULT_DT_FACTOR
+            step_size_factor = DEFAULT_STEP_SIZE_FACTOR
 
         # 2. Create and register domain object
-        multi = Multi(domain_id, self, dt_factor)
+        multi = Multi(domain_id, self, step_size_factor)
         self.domains[domain_id] = multi
 
         # 3. no shells are yet made, since these are added later
diff --git a/multi.py b/multi.py
index e2ac8c0a..12609f01 100644
--- a/multi.py
+++ b/multi.py
@@ -12,7 +12,7 @@
 import os
 
 class Multi(Domain):
-    def __init__(self, domain_id, main, dt_factor):
+    def __init__(self, domain_id, main, step_size_factor):
         Domain.__init__(self, domain_id)
 
         self.main = ref(main)
@@ -22,7 +22,7 @@ def __init__(self, domain_id, main, dt_factor):
         self.sphere_container = _gfrd.SphericalShellContainer(main.world.world_size, 3)
         self.particle_container = _gfrd.MultiParticleContainer(main.world)
         self.escaped = False
-        self.dt_factor = dt_factor
+        self.step_size_factor = step_size_factor
         self.last_reaction = None
         self.reaction_length = 0
 
@@ -68,7 +68,8 @@ def add_particle(self, pid_particle_pair):
         self.particle_container.update_particle(pid_particle_pair)
         
     def set_dt_and_reaction_length(self):
-        self.dt, self.reaction_length = self.particle_container.determine_dt_and_reaction_length(main.network_rules, self.dt_factor)
+        self.dt, self.reaction_length = \
+            self.particle_container.determine_dt_and_reaction_length(main.network_rules, self.step_size_factor)
 
     def step(self):
         self.escaped = False
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 278d3593..34795f47 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -108,7 +108,7 @@ class newBDPropagator
         boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( pp_species.structure_id() ) );
         
         structure_id_and_distance_pair struct_id_distance_pair;
-        length_type core_surface_distance = 0;
+        length_type particle_surface_distance = 0;
         position_type new_pos;
         
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
@@ -145,10 +145,9 @@ class newBDPropagator
         {
             /* Check for overlap with nearest surface. */
             struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
-            core_surface_distance = struct_id_distance_pair.second - r0;
+            particle_surface_distance = struct_id_distance_pair.second;
         
-            if(core_surface_distance < 0)
-                bounced = true;
+            bounced = determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair.first);
         }         
          
         /* If particle is bounced, check reaction_volume for reaction partners at old_pos. */     
@@ -167,17 +166,17 @@ class newBDPropagator
             if(pp_structure->id() == "world")
             {
                 struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
-                core_surface_distance = struct_id_distance_pair.second - r0;  
+                particle_surface_distance = struct_id_distance_pair.second;  
             }
         }
         
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
-           are inside the reaction volume. */
+           are/is inside the reaction volume. */
         Real accumulated_prob = 0;
         Real const rnd( rng_() );
         
         /* First, if a surface is inside the reaction volume, attempt an interaction. */
-        if(core_surface_distance < reaction_length_ && pp_structure->id() == "world")
+        if( particle_surface_distance < reaction_length_ && pp_structure->id() == "world")
         {        
             boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure(struct_id_distance_pair.first) );
             
@@ -241,7 +240,7 @@ class newBDPropagator
             if (accumulated_prob >= 1.)
             {
                 LOG_WARNING((
-                    "the accumulated acceptance probability for a reaction volume exeeded one; %f.",
+                    "the accumulated acceptance probability of a reaction volume exeeded one; %f.",
                     accumulated_prob));
             } 
             
@@ -320,7 +319,7 @@ class newBDPropagator
                 switch (::size(products))
                 {
                 case 0:
-                    remove_particle(pp.first);
+                    tx_.remove_particle(pp.first);
                     break;
 
                 case 1:
@@ -359,16 +358,15 @@ class newBDPropagator
                         {
                             if (!(*vc_)(new_p.second.shape(), pp.first))
                             {
-                                throw propagation_error("no space due to other particle");
+                                throw propagation_error("no space due to other particle (vc)");
                             }
                         }
 
                         if( s0.structure_id() == "world" )
                         {
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id()) );
-                            length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
-                                    
-                            if( core_surface_distance < 0 )
+                             
+                            if( determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair.first) )
                                 throw propagation_error("no space due to near surface");
                         }
 
@@ -398,7 +396,7 @@ class newBDPropagator
                         {
                             if (--i < 0)
                             {
-                                throw propagation_error("no space");
+                                throw propagation_error("no space due to particle or surface");
                             }
                             
                             /* If the product particles do NOT live on the same structure => surface -> surface + bulk dissociation.
@@ -435,21 +433,15 @@ class newBDPropagator
                                     particle_shape_type(pp01.second, s1.radius()),
                                     pp.first));
                                     
-                            //Only when both products live in the bulk, check for possible overlap with a surface.
+                            /* Only when both products live in the bulk, check for possible overlap with a surface. */
                             bool surface_overlap = false;
                             if( s0.structure_id() == "world" && s1.structure_id() == "world" )
                             {
                                 structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, s0.structure_id() ) );
-                                length_type core_surface_distance( struct_id_distance_pair.second - s0.radius() );
-                                    
-                                if( core_surface_distance < 0 )
-                                    surface_overlap = true;
-                                    
-                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second, s1.structure_id() );
-                                core_surface_distance = struct_id_distance_pair.second - s1.radius();
+                                surface_overlap = determine_surface_passage(pp01.first, pp.second.position(), struct_id_distance_pair.first);
 
-                                if( core_surface_distance < 0 )
-                                    surface_overlap = true;                                
+                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second, s1.structure_id() );
+                                surface_overlap = determine_surface_passage(pp01.second, pp.second.position(), struct_id_distance_pair.first);                          
                             }
                                     
                             if (!(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0) && !surface_overlap)
@@ -463,7 +455,7 @@ class newBDPropagator
                         {
                             if (!(*vc_)(particle_shape_type(pp01.first, s0.radius()), pp.first) || !(*vc_)(particle_shape_type(pp01.second, s1.radius()), pp.first))
                             {
-                                throw propagation_error("no space");
+                                throw propagation_error("no space due to near particle (vc)");
                             }
                         }
 
@@ -565,7 +557,7 @@ class newBDPropagator
                                               pp0.first, pp1.first));
                         if (overlapped && overlapped->size() > 0)
                         {
-                            throw propagation_error("no space");
+                            throw propagation_error("no space due to particle");
                         }
 
                         if (vc_)
@@ -574,16 +566,15 @@ class newBDPropagator
                                     particle_shape_type(new_pos, sp.radius()), 
                                     pp0.first, pp1.first))
                             {
-                                throw propagation_error("no space");
+                                throw propagation_error("no space due to particle (vc)");
                             }
                         }
                         
                         if( sp.structure_id() == "world" )
                         {
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, sp.structure_id() ) );
-                            length_type const core_surface_distance( struct_id_distance_pair.second - sp.radius() );
                                     
-                            if( core_surface_distance < 0 )
+                            if( determine_surface_passage(new_pos, pp0.second.position(), struct_id_distance_pair.first) )
                                 throw propagation_error("no space due to near surface");     
                         }
 
@@ -663,7 +654,7 @@ class newBDPropagator
                                     particle_shape_type(new_pos, sp.radius()), 
                                     pp.first))
                             {
-                                throw propagation_error("no space");
+                                throw propagation_error("no space (vc)");
                             }
                         }
 
@@ -699,6 +690,20 @@ class newBDPropagator
         return false;
     }
     
+    /* Function determines wether old_pos lies on the other side of the surface than new_pos. */
+    bool determine_surface_passage(position_type const& new_pos, position_type const& old_pos, structure_id_type const& struct_id)
+    {
+        boost::shared_ptr<structure_type> surface( tx_.get_structure( struct_id ) );
+        
+        projected_type const old_projection( surface->projected_point_on_surface( old_pos ) );
+        projected_type const new_projection( surface->projected_point_on_surface( new_pos ) );
+        
+        if( old_projection.second * new_projection.second <= 0 )
+            return true;
+        else
+            return false;
+    }
+    
     /* Given a position pair and two species, the function generates two new 
        positions based on two moves drawn from the free propegator. */
     position_pair_type const make_pair_move(species_type const& s0, species_type const& s1, position_pair_type const& pp01, 
@@ -733,17 +738,17 @@ class newBDPropagator
         return new_pp01;
     }
 
-    position_type const make_move(species_type const& s0, position_type const& np, particle_id_type const& ignore)
+    position_type const make_move(species_type const& s0, position_type const& old_pos, particle_id_type const& ignore)
     {
         if(s0.D() == 0)
-            return np;
+            return old_pos;
     
         boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
 
         position_type displacement( s0_struct->
                                         bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
 
-        position_type new_pos(tx_.apply_boundary( add( np, displacement ) ));
+        position_type new_pos(tx_.apply_boundary( add( old_pos, displacement ) ));
                         
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( 
                                     tx_.check_overlap(
@@ -751,15 +756,14 @@ class newBDPropagator
                                     ignore));
                                                                 
         if ( (overlapped && overlapped->size() > 0) )
-            return np;
+            return old_pos;
         
         if(s0.structure_id() == "world")
         {
             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id() ) );
-            length_type const core_surface_distance( struct_id_distance_pair.second - s0.radius() );
                                     
-            if( core_surface_distance < 0 )
-                return np;        
+            if( determine_surface_passage(new_pos, old_pos, struct_id_distance_pair.first) )
+                return old_pos;        
         }
             
         return new_pos;

From 3653fdc3a21e76266e51182ea03b761bb691faa4 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Wed, 9 Nov 2011 13:13:55 +0100
Subject: [PATCH 0348/1541] Start of some cosmetic changes..

---
 GreensFunction2DRadAbs.cpp | 15 ++++++++++-----
 GreensFunction2DRadAbs.hpp | 33 +++++++++++++++++----------------
 findRoot.cpp               | 26 ++++++++------------------
 3 files changed, 35 insertions(+), 39 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index fd2d4c33..759658c1 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -89,11 +89,13 @@ void GreensFunction2DRadAbs::clearAlphaTable() const
     // Clears all vectors in the alphaTable
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
 		   boost::mem_fn( &RealVector::clear ) );
-		   
+	
+	
+// LEGACY		   
     // Sets the values in the alphaoffsetTable to {0, -1, .., -1}
-    this->alphaOffsetTable[0] = 0;
-    std::fill( this->alphaOffsetTable.begin()+1, this->alphaOffsetTable.end(),
-	       -1 );
+//    this->alphaOffsetTable[0] = 0;
+//    std::fill( this->alphaOffsetTable.begin()+1, this->alphaOffsetTable.end(),
+//	       -1 );
 	       
 	// Sets all values of the alpha_x_scan_table_ to zero.
     std::fill( this->alpha_x_scan_table_.begin(), 
@@ -350,6 +352,9 @@ GreensFunction2DRadAbs::alpha_i( const Real offset, const Integer n ) const
 //
 // *) Note: we should be absolutely sure that the first search window is smaller
 // than half the "period" of the function, otherwise we can overlook roots.
+
+
+/* LEGACY 
 const Real
 GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
 {
@@ -432,7 +437,7 @@ GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
     this->alphaOffsetTable[n] = offset;	// The offset found is now the first root
     return offset;
 }
-
+*/
 
 // calculates the constant part of the i-th term for the survival probability
 const Real 
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 9f58485f..85a27a9f 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -26,7 +26,7 @@ class GreensFunction2DRadAbs
 {
 
 public:
-    // defines vector from template defined in standard template library,
+    // Defines vector from template defined in standard template library,
     // gives it's membervalues type Real. std:: clarifies the std namespace.
     typedef std::vector<Real> RealVector;
 
@@ -50,22 +50,23 @@ class GreensFunction2DRadAbs
     
     // Parameters for alpha-root finding
     // ======
-    // Could be tweaked for better performance!
+    // See getAlpha() in cpp file for more information. 
     //
-    // If we've switched from over- to underestimating the root for 
-    // EXPECTED_OVER_UNDER_SWITCHING times, we'll assume we're in regime where the 
-    // period of the roots converges to the pi/(sigma-a) estimate.
-    //      Hence, if the value of the root lies within INTERVAL_MARGIN 
-    // times the estimated interval, we assume all next roots subsequently have 
-    // the same or less deviation from the estimated pi/(sigma-a) interval. The 
-    // maximum INTERVAL_MARGIN is 0.33, since underestimating >33% twice
-    // in a row will result in two roots in the same sign-change scanning 
-    // domain.
+    // Parameters for scanning method
+    // Left boundary of 1st search interval 1st root
+    static const Real SCAN_START = 0.001;     
+    // Length of the scanning interval relative to estimated interval
+    static const Real FRACTION_SCAN_INTERVAL = .5;    
+    
+    // Other paramters
+    // After CONVERGENCE_ASSUMED subsequent roots that lay within +/- 
+    // INTERVAL_MARGIN from the distance to which the distance is known to 
+    // converge, it is assumed all following roots have a distances inbetween
+    // that don't deviate for more than INTERVAL_MARGIN from the distance to 
+    // which the roots are known to converge (Pi/(a-sigma)).
     static const Real CONVERGENCE_ASSUMED = 25;
     static const Real INTERVAL_MARGIN = .33; 
-    static const Real FRACTION_SCAN_INTERVAL = .5; // Distance between subsequent roots should always > this    
-    // Percentage of estimated interval where root finding should start:
-    static const Real SCAN_START = 0.001; 
+
 
 
 public:
@@ -144,7 +145,7 @@ class GreensFunction2DRadAbs
 
     std::string dump() const;
 
-    const Real alphaOffset( const unsigned int n ) const;
+//    const Real alphaOffset( const unsigned int n ) const; // TODO Really can be thrown away?
 
 //    const Real alpha0_i( const Real previous ) const;
 
@@ -323,7 +324,7 @@ class GreensFunction2DRadAbs
     //      Note that number of elements is MAX_ORDER+1 as the order n can range
     // from n=0 to n=MAX_ORDER.
     //      Initial values are set by constructor.
-    mutable boost::array<Real,MAX_ORDER+1> alphaOffsetTable;
+//    mutable boost::array<Real,MAX_ORDER+1> alphaOffsetTable;
     mutable boost::array<RealVector,MAX_ORDER+1> alphaTable;
     
     const Real estimated_alpha_root_distance_;    
diff --git a/findRoot.cpp b/findRoot.cpp
index 57a02969..b962313c 100644
--- a/findRoot.cpp
+++ b/findRoot.cpp
@@ -12,19 +12,15 @@
 #include <stdexcept>
 #include <gsl/gsl_errno.h>
 
-#include <iostream> // ONLY FOR DEBUG PURPOSES TODO
-
 #include "Logger.hpp"
 #include "findRoot.hpp"
 
+// Iterates the solver until desired precision has been reached or a maximum
+// number of iterations have been performed.
 Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
               Real high, Real tol_abs, Real tol_rel, char const* funcName)
 {
-
-    // TODO DEBUG REMOVE!!!    
-    // std::cout << "Starting root finding. Initiated by: " << funcName << ";\n";
-    // END TODO DEBUG REMOVE
-
+    // low and high should constitute an interval that straddles a root.
     Real l(low);
     Real h(high);
 
@@ -36,20 +32,18 @@ Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
     for (;;)
     {
     
-        
+        // iterate        
         gsl_root_fsolver_iterate(solver);
                
+        // get found bracketing interval
         l = gsl_root_fsolver_x_lower(solver);
-        h = gsl_root_fsolver_x_upper(solver);
-
-        // TODO DEBUG REMOVE!!!
-        // std::cout << "Current search: [" << l << ", " << h << "];\n";
-        // END TODO DEBUG REMOVE
-        
+        h = gsl_root_fsolver_x_upper(solver);     
 
+        // see if this is acceptable
         const int status(gsl_root_test_interval(l, h, tol_abs,
                                                   tol_rel));
 
+        // stop finder if convergence or too much iterations
         if (status == GSL_CONTINUE)
         {
             if (i >= maxIter)
@@ -68,10 +62,6 @@ Real findRoot(gsl_function const& F, gsl_root_fsolver* solver, Real low,
   
 
     const Real root(gsl_root_fsolver_root(solver));
-
-    // TODO DEBUG REMOVE!!!    
-    // std::cout << "Final output: [" << root << "];\n";
-    // END TODO DEBUG REMOVE
         
     return root;    
 }

From 66559502f4f3564810809081e66f52eef9e42383 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Thu, 10 Nov 2011 14:33:29 +0100
Subject: [PATCH 0349/1541] Edited comments and removed functionalities that
 were commented out.

(Cosmetics..)
---
 GreensFunction2DRadAbs.cpp | 651 +++++++------------------------------
 GreensFunction2DRadAbs.hpp |  32 +-
 2 files changed, 132 insertions(+), 551 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 759658c1..9ee9fa7a 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -51,8 +51,9 @@ GreensFunction2DRadAbs( const Real D,
     PairGreensFunction(D, kf, r0, Sigma),   
     h( kf / (D * 2.0 * M_PI * Sigma) ),       
     a( a ),                                    
-    estimated_alpha_root_distance_(M_PI/(a-Sigma))                                                                                      
-    // ^ Noobnote: here parent "constructors" are specified that are executed, 
+    estimated_alpha_root_distance_(M_PI/(a-Sigma)) // observed convergence of
+                                                   // distance roots f_alpha().                                                                                     
+    // ^: Here parent "constructors" are specified that are executed, 
     // also a constructor initialization list can be (and is) specified. 
     // These variables will be set before the contents of the constructor are 
     // called.
@@ -66,7 +67,7 @@ GreensFunction2DRadAbs( const Real D,
         throw std::invalid_argument((boost::format("a >= sigma : a=%.16g, sigma=%.16g") % a % sigma).str());
     }
     
-    // Clear AlphaTables (if this is not done, things will go wrong!)
+    // Clear AlphaTables
     GreensFunction2DRadAbs::clearAlphaTable();
     
 
@@ -89,14 +90,7 @@ void GreensFunction2DRadAbs::clearAlphaTable() const
     // Clears all vectors in the alphaTable
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
 		   boost::mem_fn( &RealVector::clear ) );
-	
-	
-// LEGACY		   
-    // Sets the values in the alphaoffsetTable to {0, -1, .., -1}
-//    this->alphaOffsetTable[0] = 0;
-//    std::fill( this->alphaOffsetTable.begin()+1, this->alphaOffsetTable.end(),
-//	       -1 );
-	       
+		   
 	// Sets all values of the alpha_x_scan_table_ to zero.
     std::fill( this->alpha_x_scan_table_.begin(), 
                this->alpha_x_scan_table_.end(),
@@ -156,65 +150,8 @@ GreensFunction2DRadAbs::f_alpha0_aux_F( const Real alpha,
 }
 
 
-// ======================================
-// LEGACY; TODO REMOVE
-// ======================================
-/*
-// finding the ith root for the order of Bessel functions zero. Only needed for the survival probability
-// and the flux
-const Real 
-GreensFunction2DRadAbs::alpha0_i( const Real previous ) const
-{
-    THROW_UNLESS( std::out_of_range, previous >= 0.0 );
-
-    const Real a( this->geta() );			// get the a (the outer boundary
-    const Real sigma( this->getSigma() );		// and sigma
-    const Real interval( M_PI / ( a - sigma ) );
-
-    const Real target( previous + interval );	// The next root is approximately pi/(a-sigma) further
-    Real low ( target - (0.4 * interval ) );	// the range is calculated very easily
-    Real high( target + (0.4 * interval ) );	// We are sure that there is only one root in the interval
-						// THE 0.4 IS VERY TRICKY!! NOT SURE IF THIS WORKS FOR ALL
-						// PARAMETER SETS!!
-    if (low <= 0)
-    {	low = EPSILON/L_TYPICAL;	// NEW to avoid the zero and negative values for the interval
-    }
-
-    // setting up the function
-    f_alpha0_aux_params params = { this, target };	// struct with the gf object and the target
-    gsl_function F = 
-	{
-	    reinterpret_cast<typeof(F.function)>( &GreensFunction2DRadAbs::f_alpha0_aux_F ),
-	    &params 
-	};
-
-
-    // setting the search interval
-//    Real low( i * interval + std::numeric_limits<Real>::epsilon() );
-//    Real high( (i+1) * interval );
-
-    //assert( GSL_FN_EVAL( &F, low ) * GSL_FN_EVAL( &F, high ) < 0.0 );
-
-    // finding the root
-    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
-    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-
-    const Real alpha ( findRoot( F, solver, low, high,
-		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::alpha0_i" ) );
-
-    gsl_root_fsolver_free( solver );
-  
-    return alpha;
-}
-*/
-
-// ======================================
-// END LEGACY;
-// ======================================
-
-// calculates the value of the expression for which the roots have to be found for given order n
-// The expression is evaluated for given alpha, to check if it zero or to get the value of the expression
-// n is the summation index used in the solution
+// f_alpha() Calculates the value of the mathematical function f_alpha(). The
+// roots (y=0) of this function are constants in the Green's Functions.
 const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 						    const Integer n ) const
 {
@@ -225,219 +162,32 @@ const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 	const Real a_An( a * alpha );
 	const Real realn( static_cast<Real>( n ) );
 
-    // TODO REMOVE std::cout << "Calling bessel from f_alpha.\n"; // TODO: DEBUG REMOVE
-    // TODO REMOVE std::cout << "(n="<<n<<", sigma="<<sigma<<", alpha="<<alpha<<", sigma*alpha="<<s_An<<");\n";
-
-    // TODO REMOVE std::cout << "1.\n"; // TODO: DEBUG REMOVE
 	const double Jn_s_An  (gsl_sf_bessel_Jn(n, s_An));
-    // TODO REMOVE std::cout << "2.\n"; // TODO: DEBUG REMOVE	
 	const double Jn1_s_An (gsl_sf_bessel_Jn(n+1, s_An));
-    // TODO REMOVE std::cout << "3.\n"; // TODO: DEBUG REMOVE	
 	const double Jn_a_An  (gsl_sf_bessel_Jn(n, a_An));
 
-    // TODO REMOVE std::cout << "4.\n"; // TODO: DEBUG REMOVE
 	const double Yn_s_An  (gsl_sf_bessel_Yn(n, s_An));
-    // TODO REMOVE std::cout << "5.\n"; // TODO: DEBUG REMOVE
 	const double Yn1_s_An (gsl_sf_bessel_Yn(n+1, s_An));
-    // TODO REMOVE std::cout << "6.\n"; // TODO: DEBUG REMOVE	
 	const double Yn_a_An  (gsl_sf_bessel_Yn(n, a_An));
 
-    // TODO REMOVE std::cout << "Done\n";
-
 	const double rho1 ( ( (h*sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
 	const double rho2 ( ( (h*sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
 	return (rho1 - rho2); 
 }
 
-
-// Wraps function of which we need to find roots alpha.
-//
-// Params contains pointer to gf object (params.gf), where f_alpha is the member
-// function of which we have to find the roots. This function is thus a mere
-// wrapper of f_alpha.  	  
+// Simply a wrapper for f_alpha().
 const Real 
 GreensFunction2DRadAbs::f_alpha_aux_F( const Real alpha,
 	       					const f_alpha_aux_params* const params )     					
 {
+    // Params contains pointer to gf object (params.gf), which has f_alpha() as 
+    // a member.
     const GreensFunction2DRadAbs* const gf( params->gf ); 
     const Integer n( params->n );
 
-    //DEBUG REMOVE TODO
-    // TODO REMOVE std::cout << "Calling f_alpha from f_alpha_aux_F.\n";
-
-    return gf->f_alpha( alpha, n );	// f_alpha is the function of which we have 
-                                    // to find the roots
-}
-
-// ======================================
-// LEGACY; TODO REMOVE
-// ======================================
-
-/*
-// This calculates a root based on the previous one (offset) with Bessel functions of order n
-// The roots are calculated based on the previous root which is given as an argument (offset)
-const Real 
-GreensFunction2DRadAbs::alpha_i( const Real offset, const Integer n ) const
-{
-    // # Get boundaries
-    const Real sigma( this->getSigma() );
-    const Real a( this->geta() );
-    
-    // # Calculate estimated interval and next search area
-    // .. not exactly necessary for each alpha -> move to overhead
-    const Real interval( M_PI / ( a - sigma ) );
-
-    Real target( offset + interval );	// the target root is the previous one plus the interval    
-        // CHANGED FROM 0.1 TO 0.4
-    Real low ( target - (0.4 * interval ) );	
-    Real high( target + (0.4 * interval ) );	    
-       
-        // To avoid the zero and negative values for the interval
-    if (low <= 0)
-    {	low = EPSILON/L_TYPICAL;	
-    }    
-
-    // DEBUG REMOVE
-    std::cout << "Interval: " << interval << "; Offset: " << offset << ";\n";
-
-    // # Solving the root using GSL Brent root finder.
-
-        // f_alpha_aux_params is a struct: {gf, n, value}
-        // n is the summation index (the order of the Bessel functions used
-    f_alpha_aux_params params = { this, n, 0 };	
-					
-					
-	    // Reinterpret_cast converts any pointer type to any other pointer type, 
-	    // even of unrelated classes. Hence below code converts pointer 
-	    // ::f_alpha_aux_F to function pointer, which then points to memory 
-	    // location of params (&params).
-    gsl_function F = 
-	{
-	    reinterpret_cast<typeof(F.function)>
-	    ( &GreensFunction2DRadAbs::f_alpha_aux_F ),
-	    &params 
-	};
-
-    // DEBUG REMOVE
-    std::cout << "Looking inbetween [" << low << "," << high << "];\n"; 
-
-    // Define solvertype.
-    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
-    // Initialize the solver.
-    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );   
-
-    // Call rootfinder, find root called "alpha" and return it.
-    const Real alpha ( findRoot( F, solver, low, high,
-		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::alpha_i" ) );
-    gsl_root_fsolver_free( solver );
-
-    return alpha;
+    return gf->f_alpha( alpha, n );	
 }
-*/
-
-// ======================================
-// END LEGACY; 
-// ======================================
-
-// Calculates the first root (called the offset) for summation index n (so using
-// Bessel functions of order n)
-//
-// Here we first find the interval where the first positive root is in.
-// We keep shifting the search window with the size of 'interval'
-// 'interval' is half of Pi/(a - sigma) (the expected distance between 
-// the 'offsets'). We then look for a sign change on the border of the
-// interval, if the sign changes in the interval inspected, we know it contains
-// a root.*
-//      After the interval is found, the GSL root finder is called.
-//
-// *) Note: we should be absolutely sure that the first search window is smaller
-// than half the "period" of the function, otherwise we can overlook roots.
-
-
-/* LEGACY 
-const Real
-GreensFunction2DRadAbs::alphaOffset( const unsigned int n ) const
-{
-    // # Some preliminary checks
 
-    // Don't do all the work again if the offset has already been calculated
-    if( this->alphaOffsetTable[n] > 0 )		 
-    {
-	return this->alphaOffsetTable[n];	   
-    }
-    
-    // Makes sure table is large enough to accomodate requested index
-    assert( this->alphaOffsetTable.size() >= n );	
-
-    // # Get/calculate boundaries and determine width of interval to check for
-    // sign change.
-    const Real sigma( this->getSigma() );
-    const Real a( this->geta() );
-    const Real interval( M_PI_2 / ( a - sigma ));	// The x-axis of the 
-                                                    // function scales with 
-                                                    // a-sigma.
-
-    // If order (n) is zero, the offset is zero, otherwhise take n-1 offset
-    // value as first estimate.
-    //      (This can be done because the offsets only get bigger, the roots 
-    // shift to the right with the order of the Bessel functions n.)
-	Real offset (0);		
-	if (n != 0)
-	{	offset = ( this->alphaOffsetTable[n-1] );
-	}						
-
-    // Define new interval as between x1=offset ("low") and x2=(offset+interval)
-    // ("high"). Make sure "low" is > 0.
-    Real low ( offset );		
-    Real high( offset + interval );	
-	if (low <= 0)			
-	{	low = EPSILON/L_TYPICAL;
-	}
-
-    // # Look for the sign change.
-
-    // DEBUG REMOVE TODO
-    // TODO REMOVE std::cout << "calling f_alpha from alphaOffset.\n";
-
-    // Get the values of the function at x "low" and x "high".
-    Real f_low ( f_alpha(low,n) );	
-    Real f_high( f_alpha(high,n) );	
-
-    // Continue shifting the search interval until a sign change is detected.
-    while( f_low * f_high > 0 )		
-    {					
-	low =  high;			
-	f_low = f_high;			
-
-	high += interval;
-	f_high = f_alpha( high, n );
-    }
-
-   // # Once the interval that contains the root has been determined, use the
-   //   root finder to pinpoint the exact location.
-
-   f_alpha_aux_params params = { this, n, 0};
-   gsl_function F = 	{reinterpret_cast<typeof(F.function)>
-			( &GreensFunction2DRadAbs::f_alpha_aux_F ),
-			&params
-			};
-			// reinterpret_cast converts any pointer type to any other pointer type.
-            // reinterpret_cast<new_type> variable
-
-    // Initialize the GSL solver
-    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
-    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-
-    // findRoot call GSL solver; See findRoot from findRoot.hpp for more info.
-    offset = findRoot( F, solver, low, high, EPSILON/L_TYPICAL,	
-                            EPSILON, "alphaOffset" );		
-    gsl_root_fsolver_free( solver );
-
-    // Record value for future usage and return it.
-    this->alphaOffsetTable[n] = offset;	// The offset found is now the first root
-    return offset;
-}
-*/
 
 // calculates the constant part of the i-th term for the survival probability
 const Real 
@@ -448,23 +198,20 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 
 	const Real s_An (sigma*alpha);
 	const Real a_An (a*alpha);
-        const Real alpha_sq (alpha*alpha);
-
-    // TODO REMOVE std::cout << "Calling bessel from p_survival_i\n";
+    const Real alpha_sq (alpha*alpha);
 
 	// calculate all the required Bessel functions
-        const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
-        const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
-        const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
+    const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+    const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+    const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
 	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
-    // TODO REMOVE std::cout << "Done.\n";
-
 	// calculate C0,n
         const Real C_i_0 (calc_A_i_0(alpha)); 
 
 	// calculate the integral over Bn,0
-	const Real dB_n_0dr (J1_sAn*Y0_aAn - Y1_sAn*J0_aAn);	// this is only the part without alpha of dB0,n(sigma)/dr
+	const Real dB_n_0dr (J1_sAn*Y0_aAn - Y1_sAn*J0_aAn);	// this is only the 
+	                                   // part without alpha of dB0,n(sigma)/dr
 	const Real B_n_0_int (Real(2.0)/(M_PI*alpha_sq) - (sigma/alpha)*dB_n_0dr);
 
 	// return the total result
@@ -472,11 +219,13 @@ GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 	return result;
 }
 
-// calculates the factor An,0 for (for example) determination of the flux through the outer interface
+// Calculates the factor An,0 for (for example) determination of the flux 
+// through the outer interface
 const Real 
 GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
 {
-    const Real a( geta() );    		        // get the needed parameters
+    // Get the required parameters
+    const Real a( geta() );    		        
     const Real sigma( getSigma() );
     const Real h (this->geth());
 
@@ -484,13 +233,8 @@ GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
     const Real a_An (a*alpha);
     const Real r0An (r0*alpha);
 
-//	const int n = 0;
-//	if ( n == 0)
-//	{
-
-    // TODO REMOVE std::cout << "Calling bessel from calc_A_i_0.\n";
-
-	const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    // calculate all the required Bessel functions
+    // Calculate all the required Bessel functions
+	const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    
     const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
     const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
 
@@ -498,47 +242,39 @@ GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
     const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
     const Real Y0_r0An (gsl_sf_bessel_Y0(r0An));
     
-        // TODO REMOVE std::cout << "Done.\n";
-//	}
-//	else
-//	{
-//	}
+    // Calculate return value
+    const Real alpha_sq (alpha*alpha);
 
-        // calculate An,0
-        const Real alpha_sq (alpha*alpha);
+    const Real rho (h*J0_sAn + alpha*J1_sAn);
+    const Real rho_sq (rho*rho);
 
-        const Real rho (h*J0_sAn + alpha*J1_sAn);
-        const Real rho_sq (rho*rho);
-
-        const Real B_n_0 (J0_r0An*Y0_aAn - Y0_r0An*J0_aAn);
+    const Real B_n_0 (J0_r0An*Y0_aAn - Y0_r0An*J0_aAn);
 
-        const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
+    const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
 
 	return A_i_0;
 }
 
-// Calculates the n-th term of the summation for calculating the flux through the inner interface (reaction)
+// Calculates the n-th term of the summation for calculating the flux through 
+// the inner interface (reaction)
 const Real 
 GreensFunction2DRadAbs::leaves_i( const Real alpha) const
 {
-        const Real a( geta() );         // get the needed parameters
-        const Real sigma( getSigma() );
-
-        const Real s_An (sigma*alpha);
-        const Real a_An (a*alpha);
+    const Real a( geta() );         // get the needed parameters
+    const Real sigma( getSigma() );
 
-    // TODO REMOVE std::cout << "Calling bessel from leaves_i.\n"; // TODO REMOVE DEBUG
+    const Real s_An (sigma*alpha);
+    const Real a_An (a*alpha);
 
-	// calculate all the required Bessel functions
-        const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
-        const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
-        const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
-        const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
+    // calculate all the required Bessel functions
+    const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+    const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
+    const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+    const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
         
-    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
-    
-        // calculate An,0
-        const Real A_i_0 (calc_A_i_0(alpha));		// calculate the coefficient A0,n
+
+    // calculate An,0
+    const Real A_i_0 (calc_A_i_0(alpha));		// calculate the coefficient A0,n
 
 	// calculate dBn,0(sigma)/dr
 	const Real dB_n_0dr (-alpha*(J1_sAn*Y0_aAn - Y1_sAn*J0_aAn));
@@ -611,17 +347,14 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	const Real a_An (a*alpha);
 	const Real alpha_sq (alpha*alpha);
 
-    // TODO REMOVE std::cout << "Calling bessel from Y0J0J1_constants.\n"; // TODO REMOVE DEBUG
-
 	// calculate all the required Bessel functions	
 	const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
 	const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
 	const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
 	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 	
-    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
 
-        // calculate An,0
+    // calculate An,0
 	const Real A_i_0 (calc_A_i_0(alpha)); //_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
 
 	// calculate the exponent with the time
@@ -635,68 +368,6 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 	return boost::make_tuple (Ai0_expT*Y0_aAn, Ai0_expT*J0_aAn, Ai0_expT*Y0J1_J0Y1);
 }
 
-/*
-const Real GreensFunction2DRadAbs::getAlpha( size_t n, RealVector::size_type i ) const 
-{
-    RealVector& alphaTable( this->alphaTable[n] );		// get the ref to the roots of order n
-    const RealVector::size_type oldSize( alphaTable.size() );	// get it's size
-
-    if( i >= oldSize )
-    {
-        alphaTable.resize( i+1, 0 );	// resize the vector and fill the empty slots with 0
-    }
-
-    if (alphaTable[i] == 0)		// if the requested root was not calculated yet
-    {
-	    if (i==0)		// if the requested root is the first one
-	    {	const Real offset (alphaOffset(n));	// The offset is the first root
-            std::cout << "Looking root " << i << "th root of " << n << "th Bessels;\n";
-            // std::clog << "[offset=" << offset << "]"; // DEBUG *REMOVEME*
-		    alphaTable[i]= offset;
-	    }
-	    else			// the requested root is dependent on the previous one
-	    {
-            std::cout << "Looking root " << i << "th root of " << n << "th Bessels;\n";
-		    const Real previous (getAlpha(n, i-1));		// get the previous root
-		    alphaTable[i] = this->alpha_i( previous , n );	// find the requested root based on
-								    // the previous one
-	    }
-    }
-    
-    return alphaTable[i];
-
-}
-*/
-
-/*
-// TODO: REMOVE THIS FUNCTIONALITY AND REPLACE WITH getAlpha(0)
-const Real GreensFunction2DRadAbs::getAlpha0( const RealVector::size_type i ) const
-{
-    RealVector& alphaTable( this->alphaTable[0] );
-    const RealVector::size_type oldSize( alphaTable.size() );
-
-    if( i >= oldSize )
-    {
-        alphaTable.resize( i+1, 0 );// fill the empty spaces with zeros
-    }
-
-    if (alphaTable[i] == 0)         // if the requested root was not calculated yet
-    {
-                if (i==0)               // if the requested root is the first one
-                {       const Real offset (alphaOffset(0));     // The offset is the first root
-                        alphaTable[i]= offset;
-                }
-                else                    // the requested root is dependent on the previous one
-                {
-                        const Real previous (getAlpha0(i-1));		// get the previous root
-                        alphaTable[i] = this->alpha0_i( previous );	// find the requested root based on
-                                                                        // the previous one
-                }
-    }
-
-    return alphaTable[i];
-}
-*/
 
 // =============================================================================
 // Root finding algorithm for alpha function. 
@@ -704,7 +375,6 @@ const Real GreensFunction2DRadAbs::getAlpha0( const RealVector::size_type i ) co
 // Modified by wehrens@amolf.nl. nov, 2011
 // =============================================================================
 
-// TODO: check comments for mistakes / completion
 // Scans for next interval where a sign change is observed, and thus where a 
 // root is expected. 
 const void GreensFunction2DRadAbs::GiveRootInterval(
@@ -723,16 +393,11 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
     // If order (n) is zero, the offset is zero, otherwhise take n-1 offset
     // value as first estimate.
     //      (This can be done because the offsets only get bigger, the roots 
-    // shift to the right with the order of the Bessel functions n.)
-    
-    // Cases:
-    //      1. i = 0 and n = 0; Can't make estimate -> use x=0 to start.
-    //      2. i = 0 and n > 1; Use n-1, i=0 value as estimate.
-    //      3. i > 0; Use value in alpha_x_scan_table_ as estimate.
+    // shift to the right with the order of the Bessel functions n.)   
     if (alpha_x_scan_table_[n] == 0) { // which implies i == 0   
 	    if (n > 0)
 	    {	
-	        alpha_x_scan_table_[n] = ( this->alphaTable[n-1][0] ); // TODO check if not necessary to use "alphaOffsetTable"
+	        alpha_x_scan_table_[n] = ( this->alphaTable[n-1][0] ); 
 	    }
 	}	    						
 
@@ -745,15 +410,12 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
     	throw std::exception();
 	}
 
-    // # Look for the sign change.
+    // # Look for the sign change:
     
-    // TODO DEBUG REMOVE
-    // TODO REMOVE std::cout << "Calling f_alpha from GiveRootInterval.\n";
-
     // Get the values of the function at x "low" and x "high".
     // Different for n=0 because this results in a simpler function.
-    //      This could be optimized by duplicating all involved functions and 
-    // removing this if-statement. 
+    //      (Note: This code could be optimized by duplicating all involved  
+    // functions and removing this if-statement. 
     if (n == 0) {
         f_low  = f_alpha0(low);	
         f_high = f_alpha0(high);
@@ -764,10 +426,7 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
 
     // Continue shifting the search interval until a sign change is detected.
     while( f_low * f_high > 0 )		
-    {					
-        // DEBUG; TODO REMOVE
-        // TODO REMOVE std::cout << "Scanning; no root at:[" << low << "," << high << "]\n";
-    
+    {					  
         low =  high;			
         f_low = f_high;			
 
@@ -784,7 +443,6 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
     return;
 }
 
-// TODO: check comments for mistakes / completion
 // Simply returns an interval based upon previous root, estimated interval 
 // inbetween roots and INTERVAL_MARGIN (see .hpp).
 const void GreensFunction2DRadAbs::GiveRootIntervalSimple(
@@ -811,19 +469,19 @@ const void GreensFunction2DRadAbs::GiveRootIntervalSimple(
     return;
 }
 
-// ===========================
+// This function calls the GSL root finder, for roots for which n = 0. (This is
+// a special case for which the function simplifies.)
 const Real 
 GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
                                       const Real high   // .. and high 
                                     ) const
 {                                    
-        // Reinterpret_cast converts any pointer type to any other pointer type, 
-	    // even of unrelated classes. Hence below code converts pointer to 
-	    // function ::f_alpha_aux_F() to function pointer, which then points to 
-	    // memory location of params (&params).
-	
-	    // f_alpha0_aux_params is a struct: {gf, value}
-        // n is the summation index (the order of the Bessel functions used        
+    // Reinterpret_cast converts any pointer type to any other pointer type, 
+    // even of unrelated classes. Hence below code converts pointer to 
+    // function ::f_alpha_aux_F() to function pointer, which then points to 
+    // memory location of params (&params).
+
+    // f_alpha0_aux_params is a struct: {gf, value}
     f_alpha0_aux_params params = { this, 0 }; // TODO: purpose of this zero is unclear!!!	
 
     gsl_function F = 
@@ -846,8 +504,10 @@ GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
     return alpha;
 }    
 
+// This function calls the GSL root finder, for roots for which n > 0. (n = 0 is
+// a special case for which the function simplifies.)
 const Real 
-GreensFunction2DRadAbs::getAlphaRootN( const Real low,   // root lies between low
+GreensFunction2DRadAbs::getAlphaRootN( const Real low,  // root lies between low
                                       const Real high,  // .. and high 
                                       const Integer n   // nth order Bessel
                                     ) const
@@ -864,7 +524,6 @@ GreensFunction2DRadAbs::getAlphaRootN( const Real low,   // root lies between lo
         &params
     };
 
-
     // Define solvertype.
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
     // Initialize the solver.
@@ -878,10 +537,8 @@ GreensFunction2DRadAbs::getAlphaRootN( const Real low,   // root lies between lo
     return alpha;
 }
 
-// ====================    
-
-// This calculates a root based on the previous one (offset) with Bessel functions of order n
-// The roots are calculated based on the previous root which is given as an argument (offset)
+// Simply calls the correct function to call the rootfinder (either 
+// getAlphaRoot0 or getAlphaRootN).
 const Real 
 GreensFunction2DRadAbs::getAlphaRoot( const Real low,   // root lies between low
                                       const Real high,  // .. and high 
@@ -899,13 +556,14 @@ GreensFunction2DRadAbs::getAlphaRoot( const Real low,   // root lies between low
     return alpha;
 }
 
-// TODO: check comments for mistakes / completion
 // Subfunction of getAlpha
 // 
-// For now just counts the number of times the root lies in the interval that
-// can be used to estimate the next root. If this happens enough, then switch
-// to just assuming that for all next roots the distance inbetween roots will
+// The function just counts the number of times the root lies in the interval 
+// that can be used to estimate the next root. If this happens enough, then it
+// edits alpha_correctly_estimated_ to a negative value to signify that it can 
+// be assumed that for all next roots the distance inbetween roots will
 // equal the interval +/- margin.
+// TODO: This could be more sophisticated.
 const void GreensFunction2DRadAbs::decideOnMethod2(size_t n, 
                                                    RealVector::size_type i
                                                   ) const
@@ -937,41 +595,11 @@ const void GreensFunction2DRadAbs::decideOnMethod2(size_t n,
     return;
 }
 
-/* LEGACY
-// TODO: check comments for mistakes / completion
-// Subfunction of getAlpha
-const void GreensFunction2DRadAbs::needToSwitchBackMethod1(
-                                                size_t n, 
-                                                RealVector::size_type i
-                                                ) const
-{
-
-    // We could only have switched when i = 1, hence check is only needed when
-    // i >= 2. Also, (alpha_x_scan_table_[n] == -1) means it is required to 
-    // check, if (alpha_x_scan_table_[n] == -2), a check is not required.
-    if ((i > 1) and (alpha_x_scan_table_[n] == -1)) { 
-        // if the distance has changed from being overestimated to 
-        // underestimated it might be that we're no longer converging, and we 
-        // need to switch back to method 1. 
-        
-        // Get distance between root i & i-1 and distance i-1 & i-2.
-        const Real dx(getAlpha(n, i)-getAlpha(n, i-1)); // note the recursiveness!        
-        const Real dx_previous(getAlpha(n, i-1)-getAlpha(n, i-2)); // note the recursiveness!
-        
-        // If there is a sign change observed
-        if ((dx*dx_previous) < 0) {
-        
-            // Make alpha_x_scan_table_[n]
-            alpha_x_scan_table_[n] = getAlpha(n,i) + EPSILON;
-        }
-    }
-            
-
-    return;
-}
-*/
-
-// TODO ADD SOME COMMENTS HERE!
+// This function searches for roots (y=0) of the so-called alpha-function 
+// (::f_alpha()). It either moves a small search interval along the x-axis to
+// check for sign-change (which would indicate a root), and calls the GSL
+// root finder, or directly calls the root finder if the spacing between 
+// roots is found to be converged. 
 const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                                              RealVector::size_type i // ith root
                                            ) const 
@@ -1009,9 +637,6 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
 	        //      high and low are the return-values of GiveRootInterval.
 	        GiveRootInterval(low, high, n);	        
 	        
-	        // DEBUG; TODO REMOVE
-	        // TODO REMOVE std::cout << "(n="<<n<<",i="<<i<<") Via scan: looking at:[" << low << "," << high << "]\n";
-	        
 	        // ### Finds the root using the GSL rootfinder
             current_root_ = getAlphaRoot(low, high, n);
             
@@ -1021,54 +646,20 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
 		    // Check if we can use method 2 for next roots
 		    decideOnMethod2(n, i);		    
 	    }
-	    // Method 2. ASSUMING CORRECT. If next root is expected to lie close 
-	    // enough to estimate the root can be calculated from a simple estimated 
-	    // interval.
+	    // Method 2. ASSUMING ROOTS AT ~FIXED INTERVAL. If next root is expected 
+	    // to lie at distance close enough to estimated distance the root finder 
+	    // can be called using a simple estimated interval.
 	    else 
 	    {
             // ### Get interval by simple extrapolation
 	        GiveRootIntervalSimple(low, high, n, i);	        
-
-	        // DEBUG; TODO REMOVE
-	        // TODO REMOVE std::cout << "(n="<<n<<",i="<<i<<") Via \"sure\" estimate: looking at:[" << low << "," << high << "]\n";
 	    
 	        // ### Finds the root using the GSL rootfinder
             current_root_ = getAlphaRoot(low, high, n);
 
             // ### Puts the found root in the table.
 		    alphaTable[i] = current_root_;		    
-
-            /* LEGACY
-    		// check if we need to switch back to method 1
-    		needToSwitchBackMethod1(n, i);    		    
-    		*/
-	    }
-	    
-	    // # Looks if we can switch from method 1 to method 2.
-	    
-            // TODO FOLLOWING COMMENT SHOULD BE PLACED SOMEWHERE:
-	        // If alpha_x_scan_table_[n] is:
-	            // >0:  We're using method 1 and want to know if we can use 
-	            //      method 2. So check if we can temporarely or permanently
-	            //      switch to method 2. (For this value of n.)
-	            // -1:  We're using method 2, but it might be that we need to
-	            //      switch back to method 1 again, so check if we need to 
-	            //      switch to method 1. (For this value of n.)
-	            // -2:  We can keep using method 2 forever. No checks are 
-	            //      needed.(For this value of n.)	    
-/*	    
-	    if (i > 0) { // otherwise calculating distance impossible
-
-	    
-	        // We can use method 2 temporarely, this check should be performed
-	        // again.
-	    
-	        // We can use method 2 permanently, this check becomes obsolete
-	    
-	        real distance (current_root_ - alphaTable[i-1]);
 	    }
-*/	    
-    // TODO REMOVE std::cout << "We've found your root for ya!\n";
     }
     
     return alphaTable[i];
@@ -1574,8 +1165,6 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 
 //	const CylindricalBesselGenerator& s(CylindricalBesselGenerator::instance());
 
-    // TODO REMOVE std::cout << "Calling bessel from p_m_alpha.\n"; // TODO REMOVE DEBUG
-
 	// calculate the needed bessel functions
 	const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
 	const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));	// prime
@@ -1599,8 +1188,6 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 //	const Real Jm_rAnm   (s.J(m, r_Anm));
 //	const Real Ym_rAnm   (s.Y(m, r_Anm));
 
-    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
-
 	// calculating An,m
 	const Real h_ma (h - realm/sigma);
 	const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
@@ -1815,60 +1402,60 @@ void
 GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
 						    const Real t ) const
 {
-        p_mTable.clear();
+    p_mTable.clear();
 
-        const Real p_0 ( this->dp_m_at_a( 0, t ) );	// This is the p_m where m is 0, for the denominator
-        p_mTable.push_back( p_0 );                      // put it in the table
+    const Real p_0 ( this->dp_m_at_a( 0, t ) );	// This is the p_m where m is 0, for the denominator
+    p_mTable.push_back( p_0 );                      // put it in the table
 
-        const Real p_1 ( this->dp_m_at_a( 1, t ) / p_0 );
-        p_mTable.push_back( p_1 );                      // put the first result in the table
+    const Real p_1 ( this->dp_m_at_a( 1, t ) / p_0 );
+    p_mTable.push_back( p_1 );                      // put the first result in the table
 
 
-        if( p_1 == 0 )
-        {
-                return;                 // apparantly all the terms are zero? We are finished
-        }
+    if( p_1 == 0 )
+    {
+            return;                 // apparantly all the terms are zero? We are finished
+    }
 
-        const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error
+    const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error
 
-	Real p_m_abs (fabs (p_1));
-        Real p_m_prev_abs;      
-        unsigned int m( 1 );
-        do
-        {
-                m++;
-                if( m >= this->MAX_ORDER )				// If the number of terms is too large
-                {
-                        std::cerr << "dp_m didn't converge (m=" << m << "), continuing..." << std::endl;
-                        break;
-                }
+    Real p_m_abs (fabs (p_1));
+    Real p_m_prev_abs;      
+    unsigned int m( 1 );
+    do
+    {
+            m++;
+            if( m >= this->MAX_ORDER )				// If the number of terms is too large
+            {
+                    std::cerr << "dp_m didn't converge (m=" << m << "), continuing..." << std::endl;
+                    break;
+            }
 
 
-                p_m_prev_abs = p_m_abs;					// store the previous term
-                const Real p_m( this->dp_m_at_a( m, t ) / p_0 );	// get the next term
+            p_m_prev_abs = p_m_abs;					// store the previous term
+            const Real p_m( this->dp_m_at_a( m, t ) / p_0 );	// get the next term
 
-                // DEBUG 
-                if (p_m_abs == 0) {
-                    std::cerr << "Zero valued term found, but convergence is:" <<
-                        p_mTable[p_mTable.size()-1-1]/p_mTable[p_mTable.size()-2-1];
-                }
-                // END DEBUG
+            // DEBUG 
+            if (p_m_abs == 0) {
+                std::cerr << "Zero valued term found, but convergence is:" <<
+                    p_mTable[p_mTable.size()-1-1]/p_mTable[p_mTable.size()-2-1];
+            }
+            // END DEBUG
 
-                if( ! std::isfinite( p_m ) )			// if the calculated value is not valid->exit
-                {
-                        std::cerr << "makedp_m_at_aTable: invalid value; " <<
-                                p_m << "( m= " << m << ")." << "( t= " << t << ")."<< "( p_0= " << p_0 << ")." << std::endl;
-                        break;
-                }
+            if( ! std::isfinite( p_m ) )			// if the calculated value is not valid->exit
+            {
+                    std::cerr << "makedp_m_at_aTable: invalid value; " <<
+                            p_m << "( m= " << m << ")." << "( t= " << t << ")."<< "( p_0= " << p_0 << ")." << std::endl;
+                    break;
+            }
 
-                p_mTable.push_back( p_m );                              // put the result in the table
-                p_m_abs = fabs( p_m );                                  // take the absolute value
-        }
-        while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
-        // truncate when converged enough.
-        // if the current term is smaller than threshold
-        // AND the previous term is also smaller than threshold
-        // AND the current term is smaller than the previous
+            p_mTable.push_back( p_m );                              // put the result in the table
+            p_m_abs = fabs( p_m );                                  // take the absolute value
+    }
+    while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
+    // truncate when converged enough.
+    // if the current term is smaller than threshold
+    // AND the previous term is also smaller than threshold
+    // AND the current term is smaller than the previous
 
 }
 
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 85a27a9f..398c5154 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -318,35 +318,29 @@ class GreensFunction2DRadAbs
 
     // Tables that hold calculated roots (y=0) of "alpha" function for each    
     // order n.
-    //      The alphaOffsetTable will be filled with 1st roots for all n. The 
-    // alphaTable will also be filled with these 1st roots, but also the mth 
-    // roots for all n.
-    //      Note that number of elements is MAX_ORDER+1 as the order n can range
-    // from n=0 to n=MAX_ORDER.
-    //      Initial values are set by constructor.
-//    mutable boost::array<Real,MAX_ORDER+1> alphaOffsetTable;
     mutable boost::array<RealVector,MAX_ORDER+1> alphaTable;
-    
-    const Real estimated_alpha_root_distance_;    
-    
-    // LEGACY
-    // Table which for each order n tells if we're in regime where next root
-    // will lie in [x_previous_root-INTERVAL_ALLOWED_ERROR, x_previous_root
-    // +INTERVAL_ALLOWED_ERROR]. In that case value n of table will be true, 
-    // if we still have to scan for a sign-change, than value n in table will
-    // be false.
-    // mutable boost::array<bool,MAX_ORDER+1> alphaRootsConverged;
-    
+
+    // Constants used in the roots of f_alpha() finding algorithm.
+    // ====
+    //
+    // This constant will simply be M_PI/(a-Sigma), the value to which the 
+    // distance between roots of f_alpha() should converge.
+    const Real estimated_alpha_root_distance_;        
+    //
     // Table which tells us at which x we're left with scanning the alpha 
     // function for a sign change, for a given order n. (A sign change would 
     // indicate a root (y=0) lies between the boundaries of the "scanned" 
     // interval.) 
-    //      If x_scan[n] == -1, this indicates scanning is no longer required
+    //      If x_scan[n] < 0, this indicates scanning is no longer required
     // because the distance between the roots is converging and within 
     // boundaries that allow the direct use of the estimate interval width 
     // pi/(sigma-a).
     //      Initial values are set by constructor.
     mutable boost::array<Real,MAX_ORDER+1> alpha_x_scan_table_;     
+    //
+    // Table that keeps track of the number of previous subsequent roots that 
+    // we're within margin of the distance to which they're expected to 
+    // converge.
     mutable boost::array<int,MAX_ORDER+1> alpha_correctly_estimated_;
 
 };

From 6cc6da995e3fb876a4a71ed6440b20299191a8dd Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Thu, 10 Nov 2011 15:52:06 +0100
Subject: [PATCH 0350/1541] More cosmetic changes.

---
 GreensFunction2DRadAbs.cpp | 77 +++-----------------------------------
 funcSum.cpp                |  2 +-
 2 files changed, 7 insertions(+), 72 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 9ee9fa7a..85d333c9 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -116,17 +116,13 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const Real s_An( sigma * alpha );
 	const Real a_An( a * alpha );
 
-//TODO REMOVE    std::cout << "Calling bessel from f_alpha0.\n"; 
-
 	const double J0_s_An (gsl_sf_bessel_J0(s_An));
 	const double J1_s_An (gsl_sf_bessel_J1(s_An));
 	const double J0_a_An (gsl_sf_bessel_J0(a_An));
 
 	const double Y0_s_An (gsl_sf_bessel_Y0(s_An));
 	const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
-	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));
-	
-// TODO DEBUG REMOVE std::cout << "Done.\n";
+	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));	
 
 	const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
 	const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
@@ -320,8 +316,6 @@ GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 	Y0J1J0Y1_Table.reserve( alphaTable_0.size() );
 
 	boost::tuple<Real,Real,Real> result;
-
-	// std::clog << "building Y0J0Tables... ";	// DEBUG *REMOVEME*
 	
 	for (unsigned int count = 0; count < alphaTable_0.size(); count++)
 	{	result = Y0J0J1_constants(alphaTable_0[count], t);
@@ -331,7 +325,6 @@ GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
 		Y0J1J0Y1_Table.push_back (result.get<2>());
 	}
 
-	// std::clog << "done" << std::endl;	// DEBUG *REMOVEME*
 }
 
 
@@ -711,13 +704,9 @@ GreensFunction2DRadAbs::p_int_r_i_exp_table( const unsigned int i,
 {
 	const Real alpha( this->getAlpha( 0, i ) );	// get the root An
 	const Real r_An( r*alpha);
-
-    // TODO REMOVE std::cout << "Calling bessel p_int_r_i_esp_table.\n"; // TODO REMOVE DEBUG
-    
+   
 	const Real J1_rAn (gsl_sf_bessel_J1(r_An));
 	const Real Y1_rAn (gsl_sf_bessel_Y1(r_An));
-	
-    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
 
 	const Real result (Y0_aAnTable[i]*r*J1_rAn - J0_aAnTable[i]*r*Y1_rAn - Y0J1J0Y1Table[i]);
 	return result;
@@ -784,11 +773,8 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
         if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
         {						// that the table is filled
         	IGNORE_RETURN getAlpha( 0, maxi );	// this updates the table of roots
-		// std::clog << "creating PsurvTable... ";	// DEBUG *REMOVEME*
                 this->createPsurvTable( psurvTable);	// then the table is filled with data
-		// std::clog << "done" << std::endl;	// DEBUG *REMOVEME*
         }
-//std::cout << "p_survival_2DPair ";
         p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
                                           this,
                                           _1, t, psurvTable ),
@@ -1151,8 +1137,6 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	                                            // besselfunctions of order m.
 	const Real r0( this->getr0() );
 
-    // std::clog << "[r0=" << r0 << "]"; // DEBUG *REMOVEME*
-
 	const Real alpha_sq( alpha * alpha );
 	const Real realm( static_cast<Real>( m ) );
 	const Real msq( realm * realm);
@@ -1171,12 +1155,10 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 //	const Real Jm_sAnm   (s.J(m, s_Anm));
 //	const Real Jmp1_sAnm (s.J(m+1, s_Anm));	// prime
 
-	// std::clog << "|";	// DEBUG *REMOVEME*
 	const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
 	const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
 //	const Real Jm_aAnm   (s.J(m, a_Anm));
 //	const Real Ym_aAnm   (s.Y(m, a_Anm));
-	// std::clog << "_";	// DEBUG *REMOVEME*
 
 	const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
 	const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
@@ -1205,11 +1187,6 @@ const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
 	// calculating the result
 	const Real result( A_n_m * B_n_m_r * exp(-D*alpha_sq*t) );
 
-    // DEBUG *REMOVEME*
-    if (result == 0.0) {
-        std::clog << "Ladies and gentlemen, we've got 0.";
-    }
-    // END DEBUG
 	return result;
 }
 
@@ -1239,16 +1216,13 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 	const Real p_0 ( this->p_m( 0, r, t ) );	// This is the p_m where m is 0, for the denominator
 	p_mTable.push_back( p_0 );			// put it in the table
 
-	// std::clog << "m=0, ";	// DEBUG *REMOVEME*
-
 	const Real p_1 ( this->p_m( 1, r, t ) / p_0 );
 	p_mTable.push_back( p_1 );			// put the first result in the table
 
-	// std::clog << "m=1, ";	// DEBUG *REMOVEME*
-
 	if( p_1 == 0 )
 	{
 		return;					// apparantly all the terms are zero? We are finished
+		                        // TODO: is this assumption correct??
 	}
 
 	const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error, is this correct?
@@ -1265,13 +1239,9 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 			break;
 		}
 
-		// std::clog << "m=" << m ;	// DEBUG *REMOVEME*
-
 		p_m_prev_abs = p_m_abs;					// store the previous term
 		const Real p_m( this->p_m( m, r, t ) / p_0 );	// get the next term
 
-		// std::clog << ", ";		// DEBUG *REMOVEME*
-
 		if( ! std::isfinite( p_m ) )		// if the calculated value is not valid->exit
 		{
 			std::cerr << "makep_mTable: invalid value; " <<
@@ -1301,11 +1271,8 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real D( this->getD() );
         const Real r0( this->getr0() );
 
-        // std::clog << "[feed the alpha: (m=" << m << ", n= " << n << ")]"; // DEBUG *REMOVEME*
         const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
        
-        // std::clog << "{r0=" << r0 << ", alpha="<< alpha << ", r*alpha="<< r0*alpha << "}"; // DEBUG *REMOVEME*
-
         const Real alpha_sq( alpha * alpha );
         const Real realm( static_cast<Real>( m ) );
         const Real msq( realm * realm);
@@ -1315,51 +1282,27 @@ GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
         const Real a_Anm (a*alpha);
         const Real r0Anm (r0*alpha);
 
-    // TODO REMOVE std::cout << "Calling bessel from dp_m_alpha_at_a.\n"; // TODO REMOVE DEBUG
-
-	// std::clog << "|";	// DEBUG *REMOVEME*
-        // calculate the needed bessel functions
-        	// std::clog << "1";	// DEBUG *REMOVEME*
         const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
-        	// std::clog << "2";	// DEBUG *REMOVEME*
-        const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    // prime
-        	// std::clog << "3";	// DEBUG *REMOVEME*
+        const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    
         const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
-        	// std::clog << "4(" << m << ", " << r0Anm << ")";	// DEBUG *REMOVEME*
-        const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm)); // !GIVES PROBLEMS
+        const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm)); 
 
-        	// std::clog << "5";	// DEBUG *REMOVEME*
         const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
-        	// std::clog << "6(" << m << ", " << r0Anm << ")";	// DEBUG *REMOVEME*
-        const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm)); // !GIVES PROBLEMS
-	// std::clog << "_";	// DEBUG *REMOVEME*
-
-    // TODO REMOVE std::cout << "Done.\n"; // TODO REMOVE DEBUG
+        const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm)); 
 
         // calculating An,m
         const Real h_ma (h - realm/sigma);
-//        std::clog << "\n[$ h_ma = "<< h_ma <<"$]\n"; // DEBUG *REMOVEME*
         const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
-//        std::clog << "\n[$ rho = "<< rho <<"$]\n"; // DEBUG *REMOVEME*
         const Real rho_sq (rho*rho);
 
         // calculating Bn,m(r')
         const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
-//        std::clog << "\n[$ B_n_m_r0 = "<< B_n_m_r0 <<"$]\n"; // DEBUG *REMOVEME*
 
         const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
-//        std::clog << "\n[$ A_n_m = "<< A_n_m <<"$]\n"; // DEBUG *REMOVEME*
 
         // calculating the result
         const Real result( A_n_m * exp(-D*alpha_sq*t) );
 
-        // DEBUG *REMOVEME*
-        if (result == 0.0) {
-            std::clog << "\nLadies and gentlemen, we've got result=0.";
-            std::clog << "\nShowing add. information:\nInput parameters: {n=" << n << ",m=" << m << ",t=" << t << "}\n"
-                      << "\nObtained parameters {sigma=" << sigma << ", h=" << h << ", a=" << a << ", D=" << D << ", r0=" << r0 << ", alpha="<< alpha <<"}\n";
-        }
-        // END DEBUG
 	return result;
 }
 
@@ -1368,9 +1311,6 @@ const Real
 GreensFunction2DRadAbs::dp_m_at_a( const Integer m,
 					   const Real t ) const
 {
-    
-    // DEBUG *REMOVEME*; seems to be correct
-    // std::clog << "\n[$$$ We're giving funcsum: " << m << ", " << t  << ", " << MAX_ALPHA_SEQ << ","<< EPSILON <<",  $$$]";    
 
     const Real p( funcSum( 
                         boost::bind( 
@@ -1530,22 +1470,17 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 	}
 
 	// making the tables with constants
-	// std::clog << "Making table p_mTable... "; // DEBUG *REMOVEME*
 
 	RealVector p_mTable;			// a table with constants to make calculations much faster
 	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
 	{
-		// std::clog << "at a... "; // DEBUG *REMOVEME*
 		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
 	}
 	else
 	{
-		// std::clog << "NOT at a... "; // DEBUG *REMOVEME*
 		makep_mTable( p_mTable, r, t );	// making the table of constants for the regular case
 	}
 
-	// std::clog << "done" << std::endl; // DEBUG *REMOVEME*
-
 	// preparing the function
 	ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 };	// r, r0, t are not required
 	gsl_function F = 
diff --git a/funcSum.cpp b/funcSum.cpp
index 8e4b4ad1..f39595cc 100644
--- a/funcSum.cpp
+++ b/funcSum.cpp
@@ -138,7 +138,7 @@ funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
 
         if (fabs(sum) * tolerance >= fabs(p_i)) // '=' is important
         {
-            ++convergenceCounter;
+            ++convergenceCounter;          
         }
         /*
         // this screws it up; why?

From 7731194285eadd2db13ac10bed066d019c99d9c4 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Fri, 11 Nov 2011 12:08:05 +0100
Subject: [PATCH 0351/1541] Switched to 2D Green's Functions.

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 280f9f3a..a3cb6ecd 100644
--- a/pair.py
+++ b/pair.py
@@ -563,7 +563,7 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
 	    # TODO still doesn't work with 2D Green's functions
-        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
+        return GreensFunction2DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                       self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, domain_id):

From e1882c2cd9593ffbe43549a057d7a784952f9eba Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 11 Nov 2011 12:19:38 +0100
Subject: [PATCH 0352/1541] mistakenly committed multiple changes in one
 commit. Should be -> egfrd.py: some cleanup and changed comments pair.py:
 Corrected calculation minimal shell dimensions for MixedPair + minor
 clarifications single.py: changed CylindericalSurfaceInteraction to use 2D
 GF's instead of 3D utils.py: Just for testing purposes changed separation
 between particle(s) and surface after dissociation

---
 egfrd.py  | 24 +++++++++++-------------
 pair.py   | 40 +++++++++++++++++++---------------------
 single.py |  3 +--
 utils.py  |  2 +-
 4 files changed, 32 insertions(+), 37 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a493929a..1714a588 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -462,8 +462,7 @@ def create_pair(self, single1, single2, shell_center, shell_radius, r0, shell_ha
         rrs = self.network_rules.query_reaction_rule(pid_particle_pair1[1].sid,
                                                      pid_particle_pair2[1].sid)
 
-        # Get structure (region or surface) where particle1 lives (assuming particle2
-        # also lives here -> TODO).
+        # Get structure (region or surface) where particles live.
         species1 = self.world.get_species(pid_particle_pair1[1].sid)
         species2 = self.world.get_species(pid_particle_pair2[1].sid)
         structure1 = self.world.get_structure(species1.structure_id)
@@ -1477,23 +1476,17 @@ def update_single(self, single):
     def process_pair_event(self, pair):
         assert self.check_obj(pair)
 
-        # check that the time is the currect simulator time 
-        assert self.t >= pair.last_time
-        assert self.t == pair.last_time + pair.dt
+        # check that the event time of the single (last_time + dt) is equal to the
+        # simulator time
+        assert (abs(pair.last_time + pair.dt - self.t) <= TIME_TOLERANCE * self.t), \
+            'Timeline incorrect. pair.last_time = %s, pair.dt = %s, self.t = %s' % \
+            (FORMAT_DOUBLE % pair.last_time, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % self.t)
 
         single1 = pair.single1
         single2 = pair.single2
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
 
-#        pos1 = pid_particle_pair1[1].position
-#        pos2 = pid_particle_pair2[1].position
-#        pos2t = self.world.cyclic_transpose(pos2, pos1)
-#        old_iv = pos2t - pos1
-#        r0 = length (old_iv)
-#        
-#        old_com = pair.com
-
         old_com, old_iv = pair.do_transform(single1, single2, self.world)
         r0 = length(old_iv)
 
@@ -1532,11 +1525,16 @@ def process_pair_event(self, pair):
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
+
             self.remove_domain(reactingsingle)
             particles = self.fire_single_reaction(reactingsingle, reactingsingle.pid_particle_pair[1].position)
+
+            domains = []
             for pid_particle_pair in particles:
+                # 5. make a new single and schedule
                 single = self.create_single(pid_particle_pair)
                 self.add_domain_event(single)
+                domains.append(single)
 
         #
         # 2. Pair reaction
diff --git a/pair.py b/pair.py
index a3cb6ecd..d00d3cd9 100644
--- a/pair.py
+++ b/pair.py
@@ -562,7 +562,6 @@ def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greens_function(self, r0):
-	    # TODO still doesn't work with 2D Green's functions
         return GreensFunction2DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                       self.sigma, self.a_r)
 
@@ -750,19 +749,17 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
         z_right1 = iv_z + radius2 * Domain.SINGLE_SHELL_FACTOR
         r1       = cls.r_right(single1, single2, r0, z_right1)
 
-        len_iv_projected = math.sqrt(iv_x*iv_x + iv_y*iv_y)
-        dist_r_from_com1 = len_iv_projected * D1 / D12
-        dist_r_from_com2 = len_iv_projected * D2 / D12
-        iv_shell_radius1 = dist_r_from_com1 + radius1
-        iv_shell_radius2 = dist_r_from_com2 + radius2
+        len_iv = r0
+        iv_shell_radius1 = len_iv * D1 / D12 
+        iv_shell_radius2 = len_iv * D2 / D12 
 
         # fix the minimum shell size for the CoM domain
         com_shell_radius = max(radius1, radius2)
 
         # calculate the minimal dimensions of the protective domain including space for the
         # burst volumes of the particles
-        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
-                 iv_shell_radius2 + com_shell_radius + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
+        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * Domain.SINGLE_SHELL_FACTOR,
+                 iv_shell_radius2 + com_shell_radius + radius2 * Domain.SINGLE_SHELL_FACTOR)
         z_right2 = cls.z_right(single1, single2, r0, r2)
 
         # of both alternatives pick the largest one
@@ -929,16 +926,15 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
                                (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
 
         log.debug('situation = %s' % (situation))
-        print "h0", scalecenter_h0
-        print "scale_center" , scale_center
-        print "theta = " ,theta
-        print "phi= ", phi
-        print "psi= ", psi
-        print "shell_scale_center= ", shell_scale_center
-        print "shell_scalecenter_r= ", shell_scalecenter_r
-        print "shell_scalecenter_z= ", shell_scalecenter_z
-#        print "a_thres=", a_thres
-        print "shell_size=", shell_size
+#        print "h0", scalecenter_h0
+#        print "scale_center" , scale_center
+#        print "theta = " ,theta
+#        print "phi= ", phi
+#        print "psi= ", psi
+#        print "shell_scale_center= ", shell_scale_center
+#        print "shell_scalecenter_r= ", shell_scalecenter_r
+#        print "shell_scalecenter_z= ", shell_scalecenter_z
+#        print "shell_size=", shell_size
 
 
         ### Get the right values for z and r for the given situation
@@ -1113,7 +1109,7 @@ def determine_radii(self, half_length, radius):
         if r_check > radius:
             # radius should have been larger, adjust z_right instead
             if __debug__:
-                log.debug('MixedPair: half_length was too high for radius:'
+                log.debug('MixedPair: half_length was too high for radius. '
                           'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
                           (radius, r_check, half_length*2, hl2_check))
 
@@ -1122,7 +1118,7 @@ def determine_radii(self, half_length, radius):
         elif hl2_check > (half_length*2):
             # half_length should have been larger, adjust radius instead
             if __debug__:
-                log.debug('MixedPair: radius was too high for half_length:'
+                log.debug('MixedPair: radius was too high for half_length. '
                           'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
                           (radius, r_check, half_length*2, hl2_check))
             radius = r_check
@@ -1134,7 +1130,9 @@ def determine_radii(self, half_length, radius):
         D2 = self.pid_particle_pair2[1].D
         D12 = D1 + D2
 
-        a_r = ((half_length * 2) - radius1 - (radius2)) * self.z_scaling_factor
+        z_left  = radius1
+        z_right = half_length * 2 - z_left
+        a_r = (z_right - radius2) * self.z_scaling_factor
 
         # calculate the maximal displacement of a particle given an a_r. Also include its radius
         space_for_iv = max( (D1/D12) * a_r + radius1,
diff --git a/single.py b/single.py
index 5f0fde04..7bc15ab4 100644
--- a/single.py
+++ b/single.py
@@ -669,8 +669,7 @@ def greens_function(self):
     def iv_greens_function(self):
         # Green's function used for the interaction
         # Interaction possible in r direction.
-        # TODO 2D.
-        return GreensFunction3DRadAbs(self.D, self.interaction_ktot, self.r0, self.get_inner_sigma(),
+        return GreensFunction2DRadAbs(self.D, self.interaction_ktot, self.r0, self.get_inner_sigma(),
                                       self.get_inner_a())
 
     def draw_new_position(self, dt, event_type):
diff --git a/utils.py b/utils.py
index d590f902..36bb9b7b 100644
--- a/utils.py
+++ b/utils.py
@@ -25,7 +25,7 @@
 
 # Multiplication factor used for seperating 2 particles or a particle and a 
 # surface after unbinding.
-MINIMAL_SEPARATION_FACTOR = 1.0 + TOLERANCE
+MINIMAL_SEPARATION_FACTOR = 2.0 + TOLERANCE
   
 # Float comparison functions.
 def feq(a, b, typical=1, tolerance=TOLERANCE):

From 107fe3b5939d4da52c8512d82ee1f11a4cb474ca Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 11 Nov 2011 14:04:46 +0100
Subject: [PATCH 0353/1541] reset displacement factor to proper value

---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index 36bb9b7b..d590f902 100644
--- a/utils.py
+++ b/utils.py
@@ -25,7 +25,7 @@
 
 # Multiplication factor used for seperating 2 particles or a particle and a 
 # surface after unbinding.
-MINIMAL_SEPARATION_FACTOR = 2.0 + TOLERANCE
+MINIMAL_SEPARATION_FACTOR = 1.0 + TOLERANCE
   
 # Float comparison functions.
 def feq(a, b, typical=1, tolerance=TOLERANCE):

From 5a0b99c2e51bea03a3126e99362bfa08194b7767 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 11 Nov 2011 14:10:44 +0100
Subject: [PATCH 0354/1541] changed comments

---
 pair.py | 45 ++++++++++++++++++++++++---------------------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/pair.py b/pair.py
index d00d3cd9..35cfaa97 100644
--- a/pair.py
+++ b/pair.py
@@ -591,12 +591,12 @@ def choose_pair_greens_function(self, r0, t):
         
             if distance_from_shell < threshold_distance:
                 # near both a and sigma;
-                # use GreensFunction3DRadAbs
+                # use GreensFunction2DRadAbs
                 if __debug__:
                     log.debug('GF2D: normal')
                 return self.iv_greens_function(r0)
             else:
-                # near sigma; use GreensFunction3DRadInf
+                # near sigma; use GreensFunction2DRadInf
                 if __debug__:
                     log.debug('GF2D: only sigma')
                 return self.iv_greens_function(r0)
@@ -925,16 +925,17 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
                                (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
 
-        log.debug('situation = %s' % (situation))
-#        print "h0", scalecenter_h0
-#        print "scale_center" , scale_center
-#        print "theta = " ,theta
-#        print "phi= ", phi
-#        print "psi= ", psi
-#        print "shell_scale_center= ", shell_scale_center
-#        print "shell_scalecenter_r= ", shell_scalecenter_r
-#        print "shell_scalecenter_z= ", shell_scalecenter_z
-#        print "shell_size=", shell_size
+        if __debug__:
+            log.debug('situation = %s' % (situation))
+    #        print "h0", scalecenter_h0
+    #        print "scale_center" , scale_center
+    #        print "theta = " ,theta
+    #        print "phi= ", phi
+    #        print "psi= ", psi
+    #        print "shell_scale_center= ", shell_scale_center
+    #        print "shell_scalecenter_r= ", shell_scalecenter_r
+    #        print "shell_scalecenter_z= ", shell_scalecenter_z
+    #        print "shell_size=", shell_size
 
 
         ### Get the right values for z and r for the given situation
@@ -973,12 +974,13 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             raise RuntimeError('Bad situation for MixedPair shell making')
 
         ## DEBUGGING
-        h_l = (z1_new + z2_new)/2.0
-        print "h_l = ", h_l
-        g = z1_new - h_l - scalecenter_h0
-        print "g = ", g
-        x = length(shell_scale_center) 
-        print "distance = ", math.sqrt(g*g + x*x - 2.0*g*x*math.cos(theta))
+        if __debug__:
+#            h_l = (z1_new + z2_new)/2.0
+#            print "h_l = ", h_l
+#            g = z1_new - h_l - scalecenter_h0
+#            print "g = ", g
+#            x = length(shell_scale_center) 
+#            print "distance = ", math.sqrt(g*g + x*x - 2.0*g*x*math.cos(theta))
 
 
         # switch the z values in case it's necessary. r doesn't have to be switched.
@@ -991,9 +993,10 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             z_left  = z1_new
 
         ## DEBUGGING
-        print "r = " , r
-        print "z_left = ", z_left
-        print "z_right = ", z_right
+        if __debug__:
+#            print "r = " , r
+#            print "z_left = ", z_left
+#            print "z_right = ", z_right
 
         return r, z_left, z_right
 

From dec35559df8cca82a5bbdf2faba6fe6f31e92f4d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 11 Nov 2011 17:29:44 +0100
Subject: [PATCH 0355/1541] reworked process_pair_event to fit procedure of
 process_single_event Still needs additional work Also fixed problem with
 particle overlaps while moving particles in a pair

---
 egfrd.py | 95 ++++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 71 insertions(+), 24 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1714a588..2abd389b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1094,15 +1094,21 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos):
         return products
 
 
-    def fire_move(self, single, reactant_pos):
+    def fire_move(self, single, reactant_pos, ignore=None):
         # No reactions/Interactions have taken place -> no identity change of the particle
         # Just only move the particles
 
         reactant = single.pid_particle_pair
 
-        if self.world.check_overlap((reactant_pos, reactant[1].radius),
-                                    reactant[0]):
-            raise RuntimeError('fire_move: particle overlap failed.')
+        if ignore:
+            if self.world.check_overlap((reactant_pos, reactant[1].radius),
+                                        reactant[0], ignore[0]):
+                raise RuntimeError('fire_move: particle overlap failed.')
+        else:
+            if self.world.check_overlap((reactant_pos, reactant[1].radius),
+                                        reactant[0]):
+                raise RuntimeError('fire_move: particle overlap failed.')
+
         moved_reactant = self.move_particle(reactant, reactant_pos)
         return [moved_reactant]
 
@@ -1111,7 +1117,7 @@ def process_single_event(self, single):
 
         ### log Single event
         if __debug__:
-            log.info('%s' % single.event_type)
+            log.info('FIRE SINGLE: %s' % single.event_type)
             log.info('single = %s' % single)
 
 
@@ -1165,11 +1171,11 @@ def process_single_event(self, single):
                     log.info('reactant = %s' % single)
 
                 if single.event_type == EventType.SINGLE_REACTION:
-                    self.single_steps[single.event_type] += 1
+                    self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
                     particles = self.fire_single_reaction(single, newpos)
 
                 else:
-                    self.interaction_steps[single.event_type] += 1
+                    self.interaction_steps[single.event_type] += 1  # TODO similarly here
                     particles = self.fire_interaction(single, newpos)
 
             else:
@@ -1476,17 +1482,28 @@ def update_single(self, single):
     def process_pair_event(self, pair):
         assert self.check_obj(pair)
 
+        if __debug__:
+            log.info('FIRE PAIR: %s' % pair.event_type)
+            log.info('single1 = %s' % pair.single1)
+            log.info('single2 = %s' % pair.single2)
+
         # check that the event time of the single (last_time + dt) is equal to the
         # simulator time
         assert (abs(pair.last_time + pair.dt - self.t) <= TIME_TOLERANCE * self.t), \
             'Timeline incorrect. pair.last_time = %s, pair.dt = %s, self.t = %s' % \
             (FORMAT_DOUBLE % pair.last_time, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % self.t)
 
+
+
         single1 = pair.single1
         single2 = pair.single2
+        assert single1.domain_id not in self.domains
+        assert single2.domain_id not in self.domains
+
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
 
+        # TODO store old_iv, old_com, r0 in pair object -> useless to recalculate these things all the time
         old_com, old_iv = pair.do_transform(single1, single2, self.world)
         r0 = length(old_iv)
 
@@ -1496,16 +1513,28 @@ def process_pair_event(self, pair):
 
         self.pair_steps[pair.event_type] += 1
 
-        if __debug__:
-            log.info('FIRE PAIR: %s' % pair.event_type)
-            log.info('single1 = %s' % pair.single1)
-            log.info('single2 = %s' % pair.single2)
 
+        # Get new position of particles
+        if pair.dt > 0.0:
+            newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
+            newpos1 = self.world.apply_boundary(newpos1)
+            newpos2 = self.world.apply_boundary(newpos2)
+
+            # check that the particles do not overlap with any other particles in the world
+            assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
+                                                pid_particle_pair1[0], pid_particle_pair2[0])
+            assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
+                                                pid_particle_pair1[0], pid_particle_pair2[0])
+
+        else:
+            newpos1 = pid_particle_pair1[1].position
+            newpos2 = pid_particle_pair2[1].position
+
+        # If identity changing processes have taken place
         # Four cases:
         #  1. Single reaction
         #  2. Pair reaction
-        #  3a. IV escape
-        #  3b. com escape
+
 
         #
         # 1. Single reaction
@@ -1542,12 +1571,12 @@ def process_pair_event(self, pair):
         elif pair.event_type == EventType.IV_REACTION:
 
             # calculate new position
-            reactant1_pos, reactant2_pos = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
-            reactant1_pos = self.world.apply_boundary(reactant1_pos)
-            reactant2_pos = self.world.apply_boundary(reactant2_pos)
+#            reactant1_pos, reactant2_pos = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
+#            reactant1_pos = self.world.apply_boundary(reactant1_pos)
+#            reactant2_pos = self.world.apply_boundary(reactant2_pos)
 
             self.remove_domain(pair)
-            particles = self.fire_pair_reaction (pair, reactant1_pos, reactant2_pos)
+            particles = self.fire_pair_reaction (pair, newpos1, newpos2)
 
             domains = []
             for pid_particle_pair in particles:
@@ -1556,24 +1585,42 @@ def process_pair_event(self, pair):
                 self.add_domain_event(single)
                 domains.append(single)
 
+        # Just moving the particles
+        #  3a. IV escape
+        #  3b. com escape
+
         #
         # 3a. Escaping through a_r.
         # 3b. Escaping through a_R.
         #
         elif(pair.event_type == EventType.IV_ESCAPE or
-             pair.event_type == EventType.COM_ESCAPE):
+             pair.event_type == EventType.COM_ESCAPE or
+             pair.event_type == EventType.BURST):
+
+#            # get new positions for particles, move them and make singles
+#            single1, single2 = self.propagate_pair(pair)
+
+#            pid_particle_pair1 = self.move_particle(pid_particle_pair1, newpos1)
+#            pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
+            self.remove_domain(pair)
+            particles = self.fire_move (single1, newpos1, pid_particle_pair2)
+            particles.extend(self.fire_move (single2, newpos2, pid_particle_pair1))
 
-            # get new positions for particles, move them and make singles
-            single1, single2 = self.propagate_pair(pair)
 
             # reschedule single domains
-            self.add_domain_event(single1)
-            self.add_domain_event(single2)
+            domains = []
+            for pid_particle_pair in particles:
+                # 5. make a new single and schedule
+                single = self.create_single(pid_particle_pair)
+                self.add_domain_event(single)
+                domains.append(single)
+#            self.add_domain_event(single1)
+#            self.add_domain_event(single2)
 
         else:
-            raise SystemError('Bug: invalid event_type.')
+            raise SystemError('process_pair_event: invalid event_type.')
 
-        return
+        return domains
 
     def process_multi_event(self, multi):
         self.multi_steps[3] += 1  # multi_steps[3]: total multi steps

From 5e3a995d4544bbbf8976dcc75d368e254d538551 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 11 Nov 2011 17:55:22 +0100
Subject: [PATCH 0356/1541] commented out logging for laurens' algorithm

---
 pair.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 35cfaa97..4a4b5470 100644
--- a/pair.py
+++ b/pair.py
@@ -975,7 +975,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
 
         ## DEBUGGING
         if __debug__:
-#            h_l = (z1_new + z2_new)/2.0
+            h_l = (z1_new + z2_new)/2.0
 #            print "h_l = ", h_l
 #            g = z1_new - h_l - scalecenter_h0
 #            print "g = ", g
@@ -994,7 +994,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
 
         ## DEBUGGING
         if __debug__:
-#            print "r = " , r
+            print "r = " , r
 #            print "z_left = ", z_left
 #            print "z_right = ", z_right
 

From e4581e79c1cf6fd5f0f5c37a997a22a970d0a176 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 14 Nov 2011 17:46:08 +0100
Subject: [PATCH 0357/1541] applied fix to multi horizon, make sure other
 particles also don't see us as potential multi partners

---
 egfrd.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 2abd389b..6cdc0035 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1269,6 +1269,7 @@ def make_new_domain(self, single):
                                                                         ignores=[single.structure.id])
 
         # TODO Potential partners are for now just the bursted domains
+        # TODO FIX THIS!
         partners = burst
 
         dists = []
@@ -1300,12 +1301,12 @@ def make_new_domain(self, single):
         # Note that we do not differentiate between directions. This means that we
         # look around in a sphere, the horizons are spherical
         surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
-        multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
 
         # 2.4 check that the object is a potential partner for an
         # -Pair         (a zero dt NonInteractionSingle)
         # -Interaction  (a surface)
         # -Multi        (a zero dt NonInteractionSingle or Multi)
+        # TODO For a MixedPair, the surface can be closer than the particle, still a Pair should be attempted
         if isinstance(closest_obj, NonInteractionSingle) and \
            closest_obj.is_reset():
                 pair_horizon = (single_radius + \
@@ -1331,6 +1332,15 @@ def make_new_domain(self, single):
             # No Pair or Interaction could be formed
             # Now choose between NonInteractionSingle and Multi
 
+            # TODO cleanup
+            if isinstance (closest_obj, NonInteractionSingle) and \
+               closest_obj.is_reset():
+                multi_horizon = (single_radius + \
+                    closest_obj.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
+            else:
+                multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
+
+
             if closest_distance > multi_horizon: # and \
 #              surface_distance > multi_horizon:
                 # just make a normal NonInteractionSingle

From 9eb47e1ee96a01024498ec37cc15f89b7011b80e Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 14 Nov 2011 19:15:20 +0100
Subject: [PATCH 0358/1541] newBD now works within eGFRD through multi.py.
 Increased MULTI_SHELL_FACTOR to 1.2. Changed newBDPropegator to work with 'no
 sigma' interaction. eg: particles interact when their c.o.m. is close to the
 surface, not their shell.

---
 BDSimulator.hpp                    | 10 ++++-----
 CylindricalSurface.hpp             | 10 ++++-----
 Multi.hpp                          |  9 ++++----
 PlanarSurface.hpp                  | 16 ++++++-------
 World.hpp                          |  2 +-
 binding/MultiParticleContainer.hpp |  2 +-
 egfrd.py                           | 20 +++++------------
 multi.py                           | 11 ++++-----
 newBDPropagator.hpp                | 36 +++++++++++++++++-------------
 9 files changed, 57 insertions(+), 59 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 9c7d9b1d..22391890 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -111,13 +111,13 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         const Real k_max( get_max_rate() );
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
-        const Real Pacc_max( 0.1 ); //Reciproke of maximum value of the acceptance probability.
+        const Real Pacc_max( 0.01 ); //Maximum value of the acceptance probability.
         const Real tau_D( 2 * r_min * r_min / D_max ); //~multi escape time.
         Real dt;
         
         if( k_max > 0)
         {
-            Real dt_temp( Pacc_max * reaction_length_factor_ * r_min / k_max );
+            Real dt_temp( 1. ); //2 * Pacc_max * reaction_length_factor_ * r_min / k_max );
             dt = std::min( dt_temp, dt_factor_ * tau_D ); // dt_factor * tau_D is upper limit of dt.
         }
         else
@@ -132,7 +132,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return reaction_length_factor_ * maxD_minr.second;
     }
     
-    /* Returns largest diffusion constant en smallest particle radius in the multi. */
+    /* Returns largest diffusion constant and smallest particle radius in the multi. */
     real_pair maxD_minsigma()
     {
         Real D_max(0.), radius_min(std::numeric_limits<Real>::max());
@@ -202,12 +202,12 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return reaction_length_;    
     }
     
-    double set_reaction_length_factor(length_type new_reaction_length_factor, time_type dt)
+    double set_reaction_length_factor(length_type new_reaction_length_factor, time_type new_dt_factor)
     {
         double old_bound_time = bound_time;
         bound_time = 0;
         
-        //base_type::dt_ = dt;
+        dt_factor_ = new_dt_factor;
         reaction_length_factor_ = new_reaction_length_factor;
         calculate_dt_and_reaction_length();
 
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 75d9e399..262b3b53 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -101,11 +101,11 @@ class CylindricalSurface
         length_type const rod_radius = base_type::shape().radius();
         position_type const unit_z = base_type::shape().unit_z();
 
-        length_type const r0rrl( rod_radius + r0 + rl );
-        length_type const r0rrl_sq( r0rrl * r0rrl );
-        length_type const r0rr_sq( (r0 + rod_radius) * (r0 + rod_radius) );
+        length_type const rrl( rod_radius + rl );
+        length_type const rrl_sq( gsl_pow_2(rrl) );
+        length_type const rr_sq( gsl_pow_2(rod_radius) );
         
-        length_type const diss_vec_length( sqrt( X * (r0rrl_sq - r0rr_sq) + r0rr_sq ) );
+        length_type const diss_vec_length( sqrt( X * (rrl_sq - rr_sq) + rr_sq ) );
 
         position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);        
         v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
@@ -137,7 +137,7 @@ class CylindricalSurface
         Real const D_bulk_D01( s_bulk.D() / D01 );
         Real const D_surf_D01( s_surf.D() / D01 );
           
-        Real const theta_min( asin(s_bulk.radius() / ( r01 )) );       
+        Real const theta_min( asin(base_type::shape().radius() / r01) );       
         Real const theta( theta_min + rng.uniform(0.,1.) * (M_PI - 2 * theta_min) );        
         Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
         
diff --git a/Multi.hpp b/Multi.hpp
index 04eb51a5..31663b74 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -309,11 +309,11 @@ class MultiParticleContainer
     /* Function returns the timestep and reaction length (rl) for BD propegator. 
        
        --dt is calulated with the constraints:
-       (1) The reaction length is equal to 0.05 * r_min,
+       (1) The reaction length is equal to step_size_factor (ssf) * r_min,
        where r_min is the radius of the smallest particle in the multi.
-       (2) The largest acceptance probability in the multi is smaller than 0.1.
+       (2) The largest acceptance probability in the multi is smaller than Pacc_max (.01).
        (3) particles escape the multi with a maximum step size in the order of the 
-           reaction length. (Dmax * dt ~ (.05 * r_min)**2 ).
+           reaction length. (Dmax * dt ~ (ssf * r_min)**2 ).
        
        TODO:This function should be a method of the Multi Class, but I put it in the mpc such that we can use it in python.
        
@@ -325,7 +325,7 @@ class MultiParticleContainer
         const Real k_max( get_max_rate(rules) );
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
-        const Real Pacc_max( 0.1 ); //Maximum allowed value of the acceptance probability.
+        const Real Pacc_max( 0.01 ); //Maximum allowed value of the acceptance probability.
         const Real tau_D( 2 * gsl_pow_2(step_size_factor * r_min) / D_max );
         Real dt;
         
@@ -534,6 +534,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
         {
             spherical_shell_id_pair const& sp(*i);
             position_type ppos(main_.world()->cyclic_transpose(sphere.position(), (sp).second.position()));
+            //TODO for newBD scheme, add reaction length to sphere.radius().
             if (distance(ppos, (sp).second.shape().position()) < (sp).second.shape().radius() - sphere.radius())
             {
                 return true;
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 01ed0d33..3abe8e24 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -88,7 +88,7 @@ class PlanarSurface
     {
         Real X( rng.uniform(0.,1.) );
         
-        length_type diss_vec_length( X*rl + r0 );
+        length_type diss_vec_length( X*rl );
 
         position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
 
@@ -112,7 +112,7 @@ class PlanarSurface
         length_type const diss_vec_length( sqrt( X * (r01l_sq - r01_sq) + r01_sq ) );
 
         position_type const m( random_vector( diss_vec_length, rng ) );
-        
+
         return position_pair_type( op - m * s0.D() / D01,
                                     op + m * s1.D() / D01 );
     }
@@ -125,24 +125,23 @@ class PlanarSurface
         Real const D_bulk_D01( s_bulk.D() / D01 );
         Real const D_surf_D01( s_surf.D() / D01 );
         
-        Real theta_max( M_PI/2 - asin(s_bulk.radius() / ( r01 )) );
-        theta_max = theta_max < 0 ? 0 : theta_max;
+        //Real theta_max( M_PI/2 - asin(s_bulk.radius() / ( r01 )) );
+        //theta_max = theta_max < 0 ? 0 : theta_max;
         
-        Real const theta( rng.uniform(0.,1.) * theta_max );        
+        Real const theta( rng.uniform(0.,1.) * M_PI );        
         Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
         
         Real const X( rng.uniform(0.,1.) );
-
         length_type const r01l( r01 + rl );
         length_type const r01l_cb( r01l * r01l * r01l );
         length_type const r01_cb( r01 * r01 * r01 );
         
-        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );
+        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );   
         
         position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
         unit_z = normalize ( unit_z );
         
-        unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
+        //unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
         
         length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
         length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
@@ -160,6 +159,7 @@ class PlanarSurface
                                 unit_z * z ) ) );
 
         return pp01;
+        
     }
 
     virtual length_type minimal_distance(length_type const& radius) const
diff --git a/World.hpp b/World.hpp
index b95af7dd..23635422 100644
--- a/World.hpp
+++ b/World.hpp
@@ -295,7 +295,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {       
         length_type const world_size( base_type::world_size() );
         length_type ret_dist( std::numeric_limits<length_type>::max() );
-        structure_id_type ret_id;
+        structure_id_type ret_id( ignore );
 
         BOOST_FOREACH(boost::shared_ptr<structure_type> const structure, get_structures())
         {
diff --git a/binding/MultiParticleContainer.hpp b/binding/MultiParticleContainer.hpp
index 852a815b..bcf59647 100644
--- a/binding/MultiParticleContainer.hpp
+++ b/binding/MultiParticleContainer.hpp
@@ -18,7 +18,7 @@ boost::python::objects::class_base register_multi_particle_container_class(char
 
     return class_<impl_type, bases<typename Tworld::particle_container_type>,
            boost::noncopyable>(name, init<Tworld&>())
-        .def("determine_dt_and_reaction_length", pure_virtual(&impl_type::determine_dt_and_reaction_length))
+        .def("determine_dt_and_reaction_length",&impl_type::determine_dt_and_reaction_length)
         ;
 }
 
diff --git a/egfrd.py b/egfrd.py
index cdd51a96..c21b2584 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -114,7 +114,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.shell_id_generator = ShellIDGenerator(0)
 
         # some constants
-        self.MULTI_SHELL_FACTOR = 1.5           # This is the threshold for when the algorithm switches from
+        self.MULTI_SHELL_FACTOR = 1.2           # This is the threshold for when the algorithm switches from
                                                 # NonInteractionSingles to a Multi and also defines the Multi
                                                 # shell size.
         self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
@@ -124,9 +124,11 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         self.MAX_TIME_STEP = 10
 
-        self.DEFAULT_DT_FACTOR = 1e-5           # Diffusion time prefactor in BD algortithm to determine time step.
+        self.DEFAULT_DT_FACTOR = 1e-5           # Diffusion time prefactor in oldBD algortithm to determine time step.
         
-        self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # prefactor to determine maximum step size in BD algorithm.
+        self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # The maximum step size in the newBD algorithm is determined as DSSF * sigma_min.
+                                                # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
+                                                # reaction volume sticks out of the multi.
 
         # used datastructrures
         self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
@@ -491,18 +493,8 @@ def create_multi(self):
         # 1. generate necessary id's
         domain_id = self.domain_id_generator()
 
-        if __debug__:
-            try:
-                # Option to make multis run faster for nicer visualization.
-                dt_factor = DEFAULT_DT_FACTOR * self.bd_dt_factor
-            except AttributeError:
-                dt_factor = DEFAULT_DT_FACTOR 
-        else:
-            dt_factor = DEFAULT_DT_FACTOR
-            step_size_factor = DEFAULT_STEP_SIZE_FACTOR
-
         # 2. Create and register domain object
-        multi = Multi(domain_id, self, step_size_factor)
+        multi = Multi(domain_id, self, self.DEFAULT_STEP_SIZE_FACTOR)
         self.domains[domain_id] = multi
 
         # 3. no shells are yet made, since these are added later
diff --git a/multi.py b/multi.py
index 12609f01..6221b0ca 100644
--- a/multi.py
+++ b/multi.py
@@ -30,7 +30,7 @@ def initialize(self, t):
         self.last_time = t
         self.start_time = t
         main = self.main()
-        set_dt_and_reaction_length()
+        self.set_dt_and_reaction_length()
         #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):
@@ -53,7 +53,7 @@ def create_new_shell(self, position, radius):
         return SphericalShell(self.domain_id, Sphere(position, radius))
 
     def within_shell(self, pp):
-        return bool(self.sphere_container.get_neighbors_within_radius(pp[1].position, -pp[1].radius))
+        return bool(self.sphere_container.get_neighbors_within_radius(pp[1].position, -(pp[1].radius + self.reaction_length)))
 
     def add_shell(self, shell_id_shell_pair):
         if __debug__:
@@ -68,6 +68,7 @@ def add_particle(self, pid_particle_pair):
         self.particle_container.update_particle(pid_particle_pair)
         
     def set_dt_and_reaction_length(self):
+        main = self.main()
         self.dt, self.reaction_length = \
             self.particle_container.determine_dt_and_reaction_length(main.network_rules, self.step_size_factor)
 
@@ -90,7 +91,7 @@ def __init__(self, outer):
             def __call__(self, shape, ignore0, ignore1=None):
                 within_radius = bool(
                     self.outer_.sphere_container.get_neighbors_within_radius(
-                        shape.position, -shape.radius))
+                        shape.position, -(shape.radius + self.outer_.reaction_length) ))
                 if not within_radius:
                     main = self.outer_.main()
                     if self.outer_.last_event == None:
@@ -112,7 +113,7 @@ def __call__(self, shape, ignore0, ignore1=None):
                      myrandom.rng, self.dt, main.dissociation_retry_moves, self.reaction_length,
                      cr, vc, [pid for pid, _ in self.particle_container])
 
-        self.last_event = None
+        self.last_event = None        
         while ppg():
             if cr.reactions:
                 self.last_reaction = cr.reactions[-1]
@@ -121,7 +122,7 @@ def __call__(self, shape, ignore0, ignore1=None):
                 else:
                     self.last_event = EventType.MULTI_BIMOLECULAR_REACTION
                 break
-
+                
         # for pid_particle_pair in itertools.chain(
         #         tx.modified_particles, tx.added_particles):
         #     overlapped = main.world.check_overlap(pid_particle_pair[1].shape, pid_particle_pair[0])
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 34795f47..0aec0483 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -147,8 +147,8 @@ class newBDPropagator
             struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
             particle_surface_distance = struct_id_distance_pair.second;
         
-            bounced = determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair.first);
-        }         
+            bounced = determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair, r0);
+        }
          
         /* If particle is bounced, check reaction_volume for reaction partners at old_pos. */     
         if(bounced)
@@ -186,7 +186,7 @@ class newBDPropagator
             if(accumulated_prob >= 1.)
             {
                 LOG_WARNING((
-                    "The accumulated acceptance probability for a reaction volume exeeded one; %f.",
+                    "the acceptance probability of an interaction exeeded one; %f.",
                     accumulated_prob));
             } 
         
@@ -240,7 +240,7 @@ class newBDPropagator
             if (accumulated_prob >= 1.)
             {
                 LOG_WARNING((
-                    "the accumulated acceptance probability of a reaction volume exeeded one; %f.",
+                    "the accumulated acceptance probability inside a reaction volume exeeded one; %f.",
                     accumulated_prob));
             } 
             
@@ -362,11 +362,11 @@ class newBDPropagator
                             }
                         }
 
-                        if( s0.structure_id() == "world" )
+                        if( s0.structure_id() == "world" && pp_struct->id() == "world" )
                         {
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id()) );
-                             
-                            if( determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair.first) )
+                            
+                            if( determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair, s0.radius()) )
                                 throw propagation_error("no space due to near surface");
                         }
 
@@ -438,10 +438,10 @@ class newBDPropagator
                             if( s0.structure_id() == "world" && s1.structure_id() == "world" )
                             {
                                 structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, s0.structure_id() ) );
-                                surface_overlap = determine_surface_passage(pp01.first, pp.second.position(), struct_id_distance_pair.first);
+                                surface_overlap = determine_surface_passage(pp01.first, pp.second.position(), struct_id_distance_pair, s0.radius());
 
                                 struct_id_distance_pair = tx_.get_closest_surface( pp01.second, s1.structure_id() );
-                                surface_overlap = determine_surface_passage(pp01.second, pp.second.position(), struct_id_distance_pair.first);                          
+                                surface_overlap = determine_surface_passage(pp01.second, pp.second.position(), struct_id_distance_pair, s1.radius());                          
                             }
                                     
                             if (!(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0) && !surface_overlap)
@@ -573,9 +573,9 @@ class newBDPropagator
                         if( sp.structure_id() == "world" )
                         {
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, sp.structure_id() ) );
-                                    
-                            if( determine_surface_passage(new_pos, pp0.second.position(), struct_id_distance_pair.first) )
-                                throw propagation_error("no space due to near surface");     
+                            
+                            if( determine_surface_passage(new_pos, pp0.second.position(), struct_id_distance_pair, sp.radius()) )
+                                throw propagation_error("no space due to near surface");
                         }
 
                         remove_particle(pp0.first);
@@ -691,9 +691,13 @@ class newBDPropagator
     }
     
     /* Function determines wether old_pos lies on the other side of the surface than new_pos. */
-    bool determine_surface_passage(position_type const& new_pos, position_type const& old_pos, structure_id_type const& struct_id)
+    bool determine_surface_passage(position_type const& new_pos, position_type const& old_pos, 
+                                    structure_id_and_distance_pair const& struct_id_distance_pair, length_type const& radius)
     {
-        boost::shared_ptr<structure_type> surface( tx_.get_structure( struct_id ) );
+        if( struct_id_distance_pair.second > radius )
+            return false;
+    
+        boost::shared_ptr<structure_type> surface( tx_.get_structure( struct_id_distance_pair.first ) );
         
         projected_type const old_projection( surface->projected_point_on_surface( old_pos ) );
         projected_type const new_projection( surface->projected_point_on_surface( new_pos ) );
@@ -761,8 +765,8 @@ class newBDPropagator
         if(s0.structure_id() == "world")
         {
             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id() ) );
-                                    
-            if( determine_surface_passage(new_pos, old_pos, struct_id_distance_pair.first) )
+                             
+            if( determine_surface_passage(new_pos, old_pos, struct_id_distance_pair, s0.radius()) )
                 return old_pos;        
         }
             

From 2a1df6f551d7d8c483ced0669801a871b842f9a6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 12:19:32 +0100
Subject: [PATCH 0359/1541] modified process_pair_event such that it also
 handles BURST events propagate_pair is now really redundant -> deactivated

---
 egfrd.py | 274 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 148 insertions(+), 126 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6cdc0035..d06943e9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -166,13 +166,16 @@ def reset(self):
         self.dt = 0.0
         self.step_counter = 0
         self.single_steps = {EventType.SINGLE_ESCAPE:0,
-                             EventType.SINGLE_REACTION:0}
+                             EventType.SINGLE_REACTION:0,
+                             EventType.BURST:0}
         self.interaction_steps = {EventType.IV_INTERACTION:0,
-                                  EventType.IV_ESCAPE:0}
+                                  EventType.IV_ESCAPE:0,
+                                  EventType.BURST:0}
         self.pair_steps = {EventType.SINGLE_REACTION:0,
                            EventType.IV_REACTION:0,
                            EventType.IV_ESCAPE:0,
-                           EventType.COM_ESCAPE:0}
+                           EventType.COM_ESCAPE:0,
+                           EventType.BURST:0}
         self.multi_steps = {EventType.MULTI_ESCAPE:0,
                             EventType.MULTI_UNIMOLECULAR_REACTION:0,
                             EventType.MULTI_BIMOLECULAR_REACTION:0, 3:0}
@@ -587,6 +590,7 @@ def update_domain_event(self, t, domain):
 
     def burst_domain(self, domain):
     # Reduces and domain (Single, Pair or Multi) to Singles with the zero shell, and dt=0
+    # return a list of Singles that was the result of the bursting
         if __debug__:
             log.info('burst_domain: %s' % domain)
 
@@ -595,8 +599,9 @@ def burst_domain(self, domain):
             domains = self.burst_single(domain)
             bursted = domains
         elif isinstance(domain, Pair):  # Pair
-            single1, single2 = self.burst_pair(domain)
-            bursted = [single1, single2]
+#            single1, single2 = self.burst_pair(domain)
+#            bursted = [single1, single2]
+            bursted = self.burst_pair(domain)
         else:  # Multi
 #            bursted = self.burst_multi(domain)
             bursted = self.break_up_multi(domain)       # Multi's can't really be 'bursted' since the
@@ -1540,6 +1545,13 @@ def process_pair_event(self, pair):
             newpos1 = pid_particle_pair1[1].position
             newpos2 = pid_particle_pair2[1].position
 
+
+
+        # newpos1/2 now hold the new positions of the particles (not yet committed to the world)
+        # if we would here move the particles and make new shells, then it would be similar to a propagate
+
+        self.remove_domain(pair)
+
         # If identity changing processes have taken place
         # Four cases:
         #  1. Single reaction
@@ -1554,19 +1566,25 @@ def process_pair_event(self, pair):
 
             if reactingsingle == single1:
                 theothersingle = single2
+                # first move the non-reacting particle
+                particles = self.fire_move(single2, newpos2, pid_particle_pair1)
+                # don't ignore the (moved) non-reacting particle
+                particles.extend(self.fire_single_reaction(single1, newpos1))
             else:
                 theothersingle = single1
+                particles = self.fire_move(single1, newpos1, pid_particle_pair2)
+                particles.extend(self.fire_single_reaction(single2, newpos2))
 
             # note method has side effect on single1 and single2
-            self.propagate_pair(pair)
+#            self.propagate_pair(pair)
 
-            self.add_domain_event(theothersingle)
+#            self.add_domain_event(theothersingle)
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
 
-            self.remove_domain(reactingsingle)
-            particles = self.fire_single_reaction(reactingsingle, reactingsingle.pid_particle_pair[1].position)
+#            self.remove_domain(reactingsingle)
+#            particles = self.fire_single_reaction(reactingsingle, reactingsingle.pid_particle_pair[1].position)
 
             domains = []
             for pid_particle_pair in particles:
@@ -1585,7 +1603,6 @@ def process_pair_event(self, pair):
 #            reactant1_pos = self.world.apply_boundary(reactant1_pos)
 #            reactant2_pos = self.world.apply_boundary(reactant2_pos)
 
-            self.remove_domain(pair)
             particles = self.fire_pair_reaction (pair, newpos1, newpos2)
 
             domains = []
@@ -1612,7 +1629,7 @@ def process_pair_event(self, pair):
 
 #            pid_particle_pair1 = self.move_particle(pid_particle_pair1, newpos1)
 #            pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
-            self.remove_domain(pair)
+#            self.remove_domain(pair)
             particles = self.fire_move (single1, newpos1, pid_particle_pair2)
             particles.extend(self.fire_move (single2, newpos2, pid_particle_pair1))
 
@@ -1725,121 +1742,123 @@ def burst_pair(self, pair):
         pair.event_type = EventType.BURST
         self.remove_event(pair)         # remove the event -> was still in the scheduler
 
-        single1, single2 = self.propagate_pair(pair)    # TODO this can now also just be a process_pair_event
-        self.add_domain_event(single1)
-        self.add_domain_event(single2)
-
-        return single1, single2
-
-    def propagate_pair(self, pair):
-        # takes a pair and returns two singles after propagation
-
-        pid_particle_pair1 = pair.pid_particle_pair1
-        pid_particle_pair2 = pair.pid_particle_pair2
-
-        pos1 = pid_particle_pair1[1].position
-        pos2 = pid_particle_pair2[1].position
-
-        # if time has passed (should be always)
-        if pair.dt > 0.0:
-#            D1 = pid_particle_pair1[1].D
-#            D2 = pid_particle_pair2[1].D
-
-            old_com, old_inter_particle = pair.do_transform (pair.single1, pair.single2, self.world)
-            r0 = length(old_inter_particle)
+#        single1, single2 = self.propagate_pair(pair)    # TODO this can now also just be a process_pair_event
+#        self.add_domain_event(single1)
+#        self.add_domain_event(single2)
+        newsingles = self.process_pair_event(pair)
 
+#        return single1, single2
+        return newsingles
 
-#            # store for later check
-#            old_com = pair.com
+#    def propagate_pair(self, pair):
+#        # takes a pair and returns two singles after propagation
 #
-#            # TODO this should be done when the pair is made -> passed to the constructor
-#            pos2t = self.world.cyclic_transpose(pos2, pos1)
-#            old_inter_particle = pos2t - pos1
-#            r0 = self.world.distance(pos1, pos2)
-#            assert feq(r0, length(old_inter_particle))
-
-            # draw the new positions of the particles
-            newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
-                                                       pair.event_type)
-            newpos1 = self.world.apply_boundary(newpos1)
-            newpos2 = self.world.apply_boundary(newpos2)
-
-            # check that the particles do not overlap with any other particles in the world
-            assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
-                                                pid_particle_pair1[0], pid_particle_pair2[0])
-            assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
-                                                pid_particle_pair1[0], pid_particle_pair2[0])
-
-            # some more consistency checking of the positions
-#            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
-#                                       pair.get_shell_size())
-
-        else:
-        # no time has passed
-            newpos1 = pid_particle_pair1[1].position
-            newpos2 = pid_particle_pair2[1].position
-
-        pid_particle_pair1 = self.move_particle(pid_particle_pair1, newpos1)
-        pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
-
-
-        # re-use single domains for particles
-        # normally we would take the particles + new positions from the old pair
-        # and use them to make new singles. Now we re-use the singles stored in the
-        # pair
-        single1 = pair.single1
-        single2 = pair.single2
-        assert single1.domain_id not in self.domains
-        assert single2.domain_id not in self.domains
-        single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
-        single2.pid_particle_pair = pid_particle_pair2
-
-
-        # remove the old domain
-        self.remove_domain(pair)
-
-        # 'make' the singles
-        single1.initialize(self.t)
-        single2.initialize(self.t)
-        
-        self.update_single_shell(single1, newpos1, pid_particle_pair1[1].radius)
-        self.update_single_shell(single2, newpos2, pid_particle_pair2[1].radius)
-
-
-        self.domains[single1.domain_id] = single1
-        self.domains[single2.domain_id] = single2
-
-        # Check the dimensions of the shells of the singles with the shell in the container
-        if __debug__:
-            container1 = self.geometrycontainer.get_container(single1.shell)
-            assert container1[single1.shell_id].shape.radius == \
-                   single1.shell.shape.radius
-            if type(single1.shell) is CylindricalShell:
-                assert container1[single1.shell_id].shape.half_length == \
-                       single1.shell.shape.half_length
-
-            container2 = self.geometrycontainer.get_container(single2.shell)
-            assert container2[single2.shell_id].shape.radius == \
-                   single2.shell.shape.radius
-            if type(single2.shell) is CylindricalShell:
-                assert container2[single2.shell_id].shape.half_length == \
-                       single2.shell.shape.half_length
-
-        assert single1.shell.shape.radius == pid_particle_pair1[1].radius
-        assert single2.shell.shape.radius == pid_particle_pair2[1].radius
-        # even more checking
-        assert self.check_obj(single1)
-        assert self.check_obj(single2)
-        # Now finally we are convinced that the singles were actually made correctly
-
-        # Log the event
-        if __debug__:
-            log.debug("process_pair_event: #1 { %s: %s => %s }" %
-                      (single1, str(pos1), str(newpos1)))
-            log.debug("process_pair_event: #2 { %s: %s => %s }" %
-                      (single2, str(pos2), str(newpos2)))
-
-        return single1, single2
+#        pid_particle_pair1 = pair.pid_particle_pair1
+#        pid_particle_pair2 = pair.pid_particle_pair2
+#
+#        pos1 = pid_particle_pair1[1].position
+#        pos2 = pid_particle_pair2[1].position
+#
+#        # if time has passed (should be always)
+#        if pair.dt > 0.0:
+##            D1 = pid_particle_pair1[1].D
+##            D2 = pid_particle_pair2[1].D
+#
+#            old_com, old_inter_particle = pair.do_transform (pair.single1, pair.single2, self.world)
+#            r0 = length(old_inter_particle)
+#
+#
+##            # store for later check
+##            old_com = pair.com
+##
+##            # TODO this should be done when the pair is made -> passed to the constructor
+##            pos2t = self.world.cyclic_transpose(pos2, pos1)
+##            old_inter_particle = pos2t - pos1
+##            r0 = self.world.distance(pos1, pos2)
+##            assert feq(r0, length(old_inter_particle))
+#
+#            # draw the new positions of the particles
+#            newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
+#                                                       pair.event_type)
+#            newpos1 = self.world.apply_boundary(newpos1)
+#            newpos2 = self.world.apply_boundary(newpos2)
+#
+#            # check that the particles do not overlap with any other particles in the world
+#            assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
+#                                                pid_particle_pair1[0], pid_particle_pair2[0])
+#            assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
+#                                                pid_particle_pair1[0], pid_particle_pair2[0])
+#
+#            # some more consistency checking of the positions
+##            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
+##                                       pair.get_shell_size())
+#
+#        else:
+#        # no time has passed
+#            newpos1 = pid_particle_pair1[1].position
+#            newpos2 = pid_particle_pair2[1].position
+#
+#        pid_particle_pair1 = self.move_particle(pid_particle_pair1, newpos1)
+#        pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
+#
+#
+#        # re-use single domains for particles
+#        # normally we would take the particles + new positions from the old pair
+#        # and use them to make new singles. Now we re-use the singles stored in the
+#        # pair
+#        single1 = pair.single1
+#        single2 = pair.single2
+#        assert single1.domain_id not in self.domains
+#        assert single2.domain_id not in self.domains
+#        single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
+#        single2.pid_particle_pair = pid_particle_pair2
+#
+#
+#        # remove the old domain
+#        self.remove_domain(pair)
+#
+#        # 'make' the singles
+#        single1.initialize(self.t)
+#        single2.initialize(self.t)
+#        
+#        self.update_single_shell(single1, newpos1, pid_particle_pair1[1].radius)
+#        self.update_single_shell(single2, newpos2, pid_particle_pair2[1].radius)
+#
+#
+#        self.domains[single1.domain_id] = single1
+#        self.domains[single2.domain_id] = single2
+#
+#        # Check the dimensions of the shells of the singles with the shell in the container
+#        if __debug__:
+#            container1 = self.geometrycontainer.get_container(single1.shell)
+#            assert container1[single1.shell_id].shape.radius == \
+#                   single1.shell.shape.radius
+#            if type(single1.shell) is CylindricalShell:
+#                assert container1[single1.shell_id].shape.half_length == \
+#                       single1.shell.shape.half_length
+#
+#            container2 = self.geometrycontainer.get_container(single2.shell)
+#            assert container2[single2.shell_id].shape.radius == \
+#                   single2.shell.shape.radius
+#            if type(single2.shell) is CylindricalShell:
+#                assert container2[single2.shell_id].shape.half_length == \
+#                       single2.shell.shape.half_length
+#
+#        assert single1.shell.shape.radius == pid_particle_pair1[1].radius
+#        assert single2.shell.shape.radius == pid_particle_pair2[1].radius
+#        # even more checking
+#        assert self.check_obj(single1)
+#        assert self.check_obj(single2)
+#        # Now finally we are convinced that the singles were actually made correctly
+#
+#        # Log the event
+#        if __debug__:
+#            log.debug("process_pair_event: #1 { %s: %s => %s }" %
+#                      (single1, str(pos1), str(newpos1)))
+#            log.debug("process_pair_event: #2 { %s: %s => %s }" %
+#                      (single2, str(pos2), str(newpos2)))
+#
+#        return single1, single2
 
     def try_interaction(self, single, surface):
         # Try to form an interaction between the 'single' particle and the 'surface'.
@@ -2324,9 +2343,9 @@ def print_report(self, out=None):
         report = '''
 t = %g
 steps = %d 
-\tSingle:\t%d\t(escape: %d, reaction: %d)
-\tInteraction: %d\t(escape: %d, interaction: %d)
-\tPair:\t%d\t(escape r: %d, R: %d, reaction pair: %d, single: %d)
+\tSingle:\t%d\t(escape: %d, reaction: %d, bursted: %d)
+\tInteraction: %d\t(escape: %d, interaction: %d, bursted: %d)
+\tPair:\t%d\t(escape r: %d, R: %d, reaction pair: %d, single: %d, bursted: %d)
 \tMulti:\t%d\t(escape: %d, reaction pair: %d, single: %d)
 total reactions = %d
 rejected moves = %d
@@ -2335,14 +2354,17 @@ def print_report(self, out=None):
                numpy.array(self.single_steps.values()).sum(),
                self.single_steps[EventType.SINGLE_ESCAPE],
                self.single_steps[EventType.SINGLE_REACTION],
+               self.single_steps[EventType.BURST],
                numpy.array(self.interaction_steps.values()).sum(),
                self.interaction_steps[EventType.IV_ESCAPE],
                self.interaction_steps[EventType.IV_INTERACTION],
+               self.interaction_steps[EventType.BURST],
                numpy.array(self.pair_steps.values()).sum(),
                self.pair_steps[EventType.IV_ESCAPE],
                self.pair_steps[EventType.COM_ESCAPE],
                self.pair_steps[EventType.IV_REACTION],
                self.pair_steps[EventType.SINGLE_REACTION],
+               self.pair_steps[EventType.BURST],
                self.multi_steps[3], # total multi steps
                self.multi_steps[EventType.MULTI_ESCAPE],
                self.multi_steps[EventType.MULTI_BIMOLECULAR_REACTION],

From 7c89163b89301f9dfea14a0f18f96f8cce3ef62d Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 15 Nov 2011 14:09:12 +0100
Subject: [PATCH 0360/1541] Species_id of the world was not set in model.py, it
 is now.

---
 model.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/model.py b/model.py
index 21e984e2..ad7964c0 100644
--- a/model.py
+++ b/model.py
@@ -169,8 +169,14 @@ def __init__(self, world_size):
         # Particles of a Species whose Surface is not specified will be 
         # added to the "world". Dimensions don't matter, except for 
         # visualization.
+        structure_type = _gfrd.StructureType()
+        structure_type['name'] = 'world'
+        _gfrd.ParticleModel.add_structure_type(self, structure_type)
+        
         x = numpy.repeat(world_size / 2, 3)
         region = _gfrd.CuboidalRegion('world', _gfrd.Box(x, x))
+        region.sid = structure_type.id
+        
         self.add_structure(region)
 
     def add_structure(self, structure):

From 4430a9e6c11d011b797fb0d830870c44111bbedc Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 15 Nov 2011 14:14:56 +0100
Subject: [PATCH 0361/1541] get_max_k now also takes surfaces into account.

---
 BDSimulator.hpp        | 39 +++++++++++++++++++++++++++++++--------
 CuboidalRegion.hpp     |  9 +++++++--
 CylindricalSurface.hpp |  7 ++++++-
 Multi.hpp              | 42 +++++++++++++++++++++++++++++++-----------
 PlanarSurface.hpp      |  7 ++++++-
 SphericalSurface.hpp   |  7 ++++++-
 Structure.hpp          |  4 +++-
 newBDPropagator.hpp    |  2 +-
 8 files changed, 91 insertions(+), 26 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 22391890..b83949f5 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -26,6 +26,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     typedef typename world_type::species_id_type species_id_type;
     typedef typename world_type::species_type species_type;
     typedef typename world_type::length_type length_type;
+    typedef typename world_type::structure_type structure_type;
     typedef typename traits_type::time_type time_type;  
     typedef typename traits_type::network_rules_type network_rules_type;
     typedef typename traits_type::reaction_rule_type reaction_rule_type;
@@ -112,12 +113,12 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
         const Real Pacc_max( 0.01 ); //Maximum value of the acceptance probability.
-        const Real tau_D( 2 * r_min * r_min / D_max ); //~multi escape time.
+        const Real tau_D( 2 * r_min * r_min / D_max ); //~step over particle - time.
         Real dt;
         
         if( k_max > 0)
         {
-            Real dt_temp( 1. ); //2 * Pacc_max * reaction_length_factor_ * r_min / k_max );
+            Real dt_temp( 2 * Pacc_max * reaction_length_factor_ * r_min / k_max );
             dt = std::min( dt_temp, dt_factor_ * tau_D ); // dt_factor * tau_D is upper limit of dt.
         }
         else
@@ -148,13 +149,35 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return real_pair(D_max, radius_min);
     }
     
-    /* Functions returns largest _1D_ intrinsic reaction rate in the multi.
-       TODO: include structures in kmax finder. */
+    /* Functions returns largest _1D_ intrinsic reaction rate in the world. */
     Real get_max_rate()
-    {
+    {    
         Real k_max(0.);
         int i = 0, j= 0;
 
+        BOOST_FOREACH(species_type s, base_type::world_->get_species())
+        {
+            if( s.structure_id() != "world" )
+                continue;
+
+            BOOST_FOREACH(boost::shared_ptr<structure_type> structure, base_type::world_->get_structures())
+            {            
+                species_id_type const strc_sid( structure->sid() );
+                reaction_rules const& rrules((*base_type::network_rules_).query_reaction_rule( s.id(), strc_sid ));
+                if (::size(rrules) == 0)
+                   continue;
+
+                for (typename boost::range_const_iterator<reaction_rules>::type
+                    it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
+                {
+                    Real const k( structure->get_1D_rate_surface( (*it).k() ) ); 
+    
+                    if ( k_max < k )
+                        k_max = k;
+                }
+            }
+        }
+        
         BOOST_FOREACH(species_type s0, base_type::world_->get_species())
         {
             j = 0;
@@ -178,13 +201,13 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
                     if(s0.structure_id() != s1.structure_id())
                     {
                         if(s0.structure_id() == "world")
-                            k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                            k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                         else
-                            k = base_type::world_->get_structure( s1.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                            k = base_type::world_->get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                     }
                     else
                     {
-                        k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 ); 
+                        k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
                     }
                 
                     if ( k_max < k )
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 3efb7f46..24865258 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -67,9 +67,14 @@ class CuboidalRegion
         return random_vector( drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v ), rng );
     }
     
-    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01 ) const
     {
-        return k / (4 * M_PI * r01 * r01 );    
+        return k / ( 4 * M_PI * r01 * r01 );    
+    }
+    
+    virtual Real get_1D_rate_surface( Real const& k ) const
+    {
+        return Real(); //No reaction rates with bulk;    
     }
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 262b3b53..7cabcb35 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -75,10 +75,15 @@ class CylindricalSurface
         return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
     }
     
-    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
     {
         return k;
     }
+    
+    virtual Real get_1D_rate_surface( Real const& k ) const
+    {
+        return k / ( 2 * M_PI * base_type::shape().radius() );
+    }
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
diff --git a/Multi.hpp b/Multi.hpp
index 31663b74..18ee80b7 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -38,11 +38,9 @@ class MultiParticleContainer
     typedef typename traits_type::size_type size_type;
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type structure_type;
-    
     typedef typename Ttraits_::network_rules_type network_rules_type;
     typedef typename Ttraits_::reaction_rule_type reaction_rule_type;
-    typedef typename network_rules_type::reaction_rules reaction_rules;   
-    
+    typedef typename network_rules_type::reaction_rules reaction_rules;      
     typedef typename Ttraits_::world_type::particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
     typedef Transaction<traits_type> transaction_type;
@@ -257,13 +255,37 @@ class MultiParticleContainer
         return real_pair(D_max, radius_min);
     }
     
-    /* Functions returns largest _1D_ intrinsic reaction rate in the mpc.
-       TODO: include structures in kmax finder. */
+    /* Functions returns largest _1D_ intrinsic reaction rate in the multi. */
     Real get_max_rate(network_rules_type const& rules) const
     {
         Real k_max(0.);
         int i = 0, j= 0;
+        
+        BOOST_FOREACH(particle_id_pair pp, get_particles_range())
+        {
+            species_type const s( pp.second.sid() );
+            structure_id_and_distance_pair const strc_id_and_dist( 
+                get_closest_surface( pp.second.position(), s.structure_id() ) );
+                
+            if( strc_id_and_dist.second < s.radius() && s.structure_id() == "world" )
+            {
+                species_id_type const strc_sid( get_structure( strc_id_and_dist.first )->sid() );
+                reaction_rules const& rrules(rules.query_reaction_rule( s.id(), strc_sid ));
+                if (::size(rrules) == 0)
+                    continue;
 
+                for (typename boost::range_const_iterator<reaction_rules>::type
+                it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
+                {
+                    Real const k( get_structure( strc_id_and_dist.first )->get_1D_rate_surface( (*it).k() ) ); 
+
+                    if ( k_max < k )
+                        k_max = k;
+                }
+            }            
+            
+        }
+        
         BOOST_FOREACH(species_type s0, get_species_in_multi())
         {
             j = 0;
@@ -274,10 +296,8 @@ class MultiParticleContainer
                 
                 reaction_rules const& rrules(rules.query_reaction_rule( s0.id(), s1.id() ));
                 if (::size(rrules) == 0)
-                {
                     continue;
-                }
-                                
+                                            
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
@@ -287,13 +307,13 @@ class MultiParticleContainer
                     if(s0.structure_id() != s1.structure_id())
                     {
                         if(s0.structure_id() == "world")
-                            k = get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                            k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                         else
-                            k = get_structure( s1.structure_id() )->get_1D_rate( (*it).k(), r01 );
+                            k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                     }
                     else
                     {
-                        k = get_structure( s0.structure_id() )->get_1D_rate( (*it).k(), r01 ); 
+                        k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
                     }
                 
                     if ( k_max < k )
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 3abe8e24..83b558eb 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -64,10 +64,15 @@ class PlanarSurface
         return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng ); 
     }
 
-    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
     {
         return k / (2 * M_PI * r01);    
     }
+    
+    virtual Real get_1D_rate_surface( Real const& k ) const
+    {
+        return k;    
+    }
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 88c86a2e..a5244b5a 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -52,7 +52,12 @@ class SphericalSurface
         return position_type(); //TODO
     }
 
-    virtual Real get_1D_rate( Real const& k, length_type const& r01) const
+    virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
+    {
+        return Real(); //TODO
+    }
+    
+    virtual Real get_1D_rate_surface( Real const& k ) const
     {
         return Real(); //TODO
     }
diff --git a/Structure.hpp b/Structure.hpp
index 2f6b5f93..24d8566e 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -73,7 +73,9 @@ class Structure
 
     virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
     
-    virtual Real get_1D_rate( Real const& k, length_type const& r01) const = 0;
+    virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const = 0;
+    
+    virtual Real get_1D_rate_surface( Real const& k ) const = 0;
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const = 0;
     
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 0aec0483..d7331178 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -487,7 +487,7 @@ class newBDPropagator
     Real k_total(species_id_type const& s0_id, species_id_type const& s1_id)
     {   
         reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
-        if (::size(rules) == 0)
+        if(::size(rules) == 0)
         {
             return 0;
         }

From 38ffa23797b279b210b202c6b3dcfc045c3c89c4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 15:17:48 +0100
Subject: [PATCH 0362/1541] some cleanup of old code and comments

---
 egfrd.py | 416 ++++++++++++++++++++++---------------------------------
 1 file changed, 163 insertions(+), 253 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d06943e9..545e3298 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -596,11 +596,8 @@ def burst_domain(self, domain):
 
         if isinstance(domain, Single):
             # TODO. Compare with gfrd.
-            domains = self.burst_single(domain)
-            bursted = domains
+            bursted = self.burst_single(domain)
         elif isinstance(domain, Pair):  # Pair
-#            single1, single2 = self.burst_pair(domain)
-#            bursted = [single1, single2]
             bursted = self.burst_pair(domain)
         else:  # Multi
 #            bursted = self.burst_multi(domain)
@@ -1118,87 +1115,6 @@ def fire_move(self, single, reactant_pos, ignore=None):
         return [moved_reactant]
 
 
-    def process_single_event(self, single):
-
-        ### log Single event
-        if __debug__:
-            log.info('FIRE SINGLE: %s' % single.event_type)
-            log.info('single = %s' % single)
-
-
-
-        if single.is_reset():
-        ### If no event event really happened and just need to make new domain
-            domains = [self.make_new_domain(single)]
-            # domain is already scheduled in make_new_domain
-
-        ### 1.1 Special cases (shortcuts)
-        # In case nothing is scheduled to happen: do nothing and just reschedule
-        elif single.dt == numpy.inf:
-            self.add_domain_event(single)
-            domains = [single]
-
-        else:
-        ### 1. Process 'normal' event produced by the single
-
-            # check that the event time of the single (last_time + dt) is equal to the
-            # simulator time
-            assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t), \
-                'Timeline incorrect. single.last_time = %s, single.dt = %s, self.t = %s' % \
-                (FORMAT_DOUBLE % single.last_time, FORMAT_DOUBLE % single.dt, FORMAT_DOUBLE % self.t)
-
-
-            pid_particle_pair = single.pid_particle_pair
-            # in case of an interaction domain: determine real event before doing anything
-            if single.event_type == EventType.IV_EVENT:
-                single.event_type = single.draw_iv_event_type()
-
-
-            # get the (new) position
-            if single.getD() != 0 and single.dt > 0.0:
-                # If the particle had the possibility to diffuse
-                newpos = single.draw_new_position(single.dt, single.event_type)
-                newpos = self.world.apply_boundary(newpos)
-            else:
-                # no change in position has taken place
-                newpos = pid_particle_pair[1].position
-
-            # newpos now hold the new position of the particle (not yet committed to the world)
-            # if we would here move the particles and make new shells, then it would be similar to a propagate
-
-            self.remove_domain(single)
-
-            # If the single had a decay reaction or interaction.
-            if single.event_type == EventType.SINGLE_REACTION or \
-               single.event_type == EventType.IV_INTERACTION:
-                if __debug__:
-                    log.info('%s' % single.event_type)
-                    log.info('reactant = %s' % single)
-
-                if single.event_type == EventType.SINGLE_REACTION:
-                    self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
-                    particles = self.fire_single_reaction(single, newpos)
-
-                else:
-                    self.interaction_steps[single.event_type] += 1  # TODO similarly here
-                    particles = self.fire_interaction(single, newpos)
-
-            else:
-                particles = self.fire_move(single, newpos)
-
-            # 5. Make a (new) domain (reuse) domain for each particle(s)
-            #    (Re)schedule the (new) domain
-            domains = []
-            for pid_particle_pair in particles:
-#               single.pid_particle_pair = pid_particle_pair    # reuse single
-                single = self.create_single(pid_particle_pair)
-                self.add_domain_event(single)
-                domains.append(single) 
-
-            # 6. Log change?
-                
-        return domains
-
 
     def make_new_domain(self, single):
         ### Make a new domain out of a NonInteractionSingle that was
@@ -1494,6 +1410,104 @@ def update_single(self, single):
         single.dt, single.event_type = single.determine_next_event()
         single.last_time = self.t
 
+
+    def process_single_event(self, single):
+
+        ### log Single event
+        if __debug__:
+            log.info('FIRE SINGLE: %s' % single.event_type)
+            log.info('single = %s' % single)
+
+
+
+        if single.is_reset():
+        ### If no event event really happened and just need to make new domain
+            domains = [self.make_new_domain(single)]
+            # domain is already scheduled in make_new_domain
+
+        ### 1.1 Special cases (shortcuts)
+        # In case nothing is scheduled to happen: do nothing and just reschedule
+        elif single.dt == numpy.inf:
+            self.add_domain_event(single)
+            domains = [single]
+
+        else:
+        ### 1. Process 'normal' event produced by the single
+
+            # check that the event time of the single (last_time + dt) is equal to the
+            # simulator time
+            assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t), \
+                'Timeline incorrect. single.last_time = %s, single.dt = %s, self.t = %s' % \
+                (FORMAT_DOUBLE % single.last_time, FORMAT_DOUBLE % single.dt, FORMAT_DOUBLE % self.t)
+
+
+            pid_particle_pair = single.pid_particle_pair
+            # in case of an interaction domain: determine real event before doing anything
+            if single.event_type == EventType.IV_EVENT:
+                single.event_type = single.draw_iv_event_type()
+
+
+            # get the (new) position
+            if single.getD() != 0 and single.dt > 0.0:
+                # If the particle had the possibility to diffuse
+                newpos = single.draw_new_position(single.dt, single.event_type)
+                newpos = self.world.apply_boundary(newpos)
+            else:
+                # no change in position has taken place
+                newpos = pid_particle_pair[1].position
+            # TODO? Check if the new positions are within domain
+
+            # newpos now hold the new position of the particle (not yet committed to the world)
+            # if we would here move the particles and make new shells, then it would be similar to a propagate
+
+            self.remove_domain(single)
+
+            # If the single had a decay reaction or interaction.
+            if single.event_type == EventType.SINGLE_REACTION or \
+               single.event_type == EventType.IV_INTERACTION:
+                if __debug__:
+                    log.info('%s' % single.event_type)
+                    log.info('reactant = %s' % single)
+
+                if single.event_type == EventType.SINGLE_REACTION:
+                    self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
+                    particles = self.fire_single_reaction(single, newpos)
+
+                else:
+                    self.interaction_steps[single.event_type] += 1  # TODO similarly here
+                    particles = self.fire_interaction(single, newpos)
+
+            else:
+                particles = self.fire_move(single, newpos)
+
+            # 5. Make a (new) domain (reuse) domain for each particle(s)
+            #    (Re)schedule the (new) domain
+            domains = []
+            for pid_particle_pair in particles:
+#               single.pid_particle_pair = pid_particle_pair    # reuse single
+                single = self.create_single(pid_particle_pair)  # TODO re-use NonInteractionSingle domain if possible
+                self.add_domain_event(single)                   # TODO re-use event if possible
+                domains.append(single) 
+
+            # 6. Log change?
+                
+# NOTE Code snippets to re-use the domain/event
+#
+#        if isinstance(single, InteractionSingle):
+#            # When bursting an InteractionSingle, the domain changes from Interaction
+#           # NonInteraction domain. This needs to be reflected in the event 
+#            self.remove_event(single)
+#            self.add_domain_event(newsingle)
+#        else:
+#            assert single == newsingle
+#            self.update_domain_event(self.t, single)
+#
+#        particle_radius = single.pid_particle_pair[1].radius
+#        assert newsingle.shell.shape.radius == particle_radius
+
+        return domains
+
+
     def process_pair_event(self, pair):
         assert self.check_obj(pair)
 
@@ -1517,6 +1531,8 @@ def process_pair_event(self, pair):
 
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
+        pos1 = pid_particle_pair1[1].position
+        pos2 = pid_particle_pair2[1].position
 
         # TODO store old_iv, old_com, r0 in pair object -> useless to recalculate these things all the time
         old_com, old_iv = pair.do_transform(single1, single2, self.world)
@@ -1544,7 +1560,10 @@ def process_pair_event(self, pair):
         else:
             newpos1 = pid_particle_pair1[1].position
             newpos2 = pid_particle_pair2[1].position
-
+        # TODO? Check if the new positions are within domain
+        # TODO? some more consistency checking of the positions
+##            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
+##                                       pair.get_shell_size())
 
 
         # newpos1/2 now hold the new positions of the particles (not yet committed to the world)
@@ -1555,12 +1574,6 @@ def process_pair_event(self, pair):
         # If identity changing processes have taken place
         # Four cases:
         #  1. Single reaction
-        #  2. Pair reaction
-
-
-        #
-        # 1. Single reaction
-        #
         if pair.event_type == EventType.SINGLE_REACTION:
             reactingsingle = pair.reactingsingle
 
@@ -1575,21 +1588,14 @@ def process_pair_event(self, pair):
                 particles = self.fire_move(single1, newpos1, pid_particle_pair2)
                 particles.extend(self.fire_single_reaction(single2, newpos2))
 
-            # note method has side effect on single1 and single2
-#            self.propagate_pair(pair)
-
-#            self.add_domain_event(theothersingle)
-
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
 
-#            self.remove_domain(reactingsingle)
-#            particles = self.fire_single_reaction(reactingsingle, reactingsingle.pid_particle_pair[1].position)
-
+            
             domains = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
-                single = self.create_single(pid_particle_pair)
+                single = self.create_single(pid_particle_pair)  # TODO reuse the non-reacting single domain
                 self.add_domain_event(single)
                 domains.append(single)
 
@@ -1598,11 +1604,6 @@ def process_pair_event(self, pair):
         #
         elif pair.event_type == EventType.IV_REACTION:
 
-            # calculate new position
-#            reactant1_pos, reactant2_pos = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
-#            reactant1_pos = self.world.apply_boundary(reactant1_pos)
-#            reactant2_pos = self.world.apply_boundary(reactant2_pos)
-
             particles = self.fire_pair_reaction (pair, newpos1, newpos2)
 
             domains = []
@@ -1615,38 +1616,78 @@ def process_pair_event(self, pair):
         # Just moving the particles
         #  3a. IV escape
         #  3b. com escape
-
-        #
-        # 3a. Escaping through a_r.
-        # 3b. Escaping through a_R.
-        #
         elif(pair.event_type == EventType.IV_ESCAPE or
              pair.event_type == EventType.COM_ESCAPE or
              pair.event_type == EventType.BURST):
 
-#            # get new positions for particles, move them and make singles
-#            single1, single2 = self.propagate_pair(pair)
-
-#            pid_particle_pair1 = self.move_particle(pid_particle_pair1, newpos1)
-#            pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
-#            self.remove_domain(pair)
             particles = self.fire_move (single1, newpos1, pid_particle_pair2)
             particles.extend(self.fire_move (single2, newpos2, pid_particle_pair1))
 
-
-            # reschedule single domains
+            # make new NonInteractionSingeles and reschedule domains
             domains = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
-                single = self.create_single(pid_particle_pair)
+                single = self.create_single(pid_particle_pair)  # TODO reuse domains that were cached in the pair
                 self.add_domain_event(single)
                 domains.append(single)
-#            self.add_domain_event(single1)
-#            self.add_domain_event(single2)
 
         else:
             raise SystemError('process_pair_event: invalid event_type.')
 
+# NOTE code snippit to reuse domains that were cached in pair domain
+#        # re-use single domains for particles
+#        # normally we would take the particles + new positions from the old pair
+#        # and use them to make new singles. Now we re-use the singles stored in the
+#        # pair
+#        single1 = pair.single1
+#        single2 = pair.single2
+#        assert single1.domain_id not in self.domains
+#        assert single2.domain_id not in self.domains
+#        single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
+#        single2.pid_particle_pair = pid_particle_pair2
+#
+#        # 'make' the singles
+#        single1.initialize(self.t)
+#        single2.initialize(self.t)
+#        
+#        self.update_single_shell(single1, newpos1, pid_particle_pair1[1].radius)
+#        self.update_single_shell(single2, newpos2, pid_particle_pair2[1].radius)
+#
+#
+#        self.domains[single1.domain_id] = single1
+#        self.domains[single2.domain_id] = single2
+#
+#        # Check the dimensions of the shells of the singles with the shell in the container
+#        if __debug__:
+#            container1 = self.geometrycontainer.get_container(single1.shell)
+#            assert container1[single1.shell_id].shape.radius == \
+#                   single1.shell.shape.radius
+#            if type(single1.shell) is CylindricalShell:
+#                assert container1[single1.shell_id].shape.half_length == \
+#                       single1.shell.shape.half_length
+#
+#            container2 = self.geometrycontainer.get_container(single2.shell)
+#            assert container2[single2.shell_id].shape.radius == \
+#                   single2.shell.shape.radius
+#            if type(single2.shell) is CylindricalShell:
+#                assert container2[single2.shell_id].shape.half_length == \
+#                       single2.shell.shape.half_length
+#
+#        assert single1.shell.shape.radius == pid_particle_pair1[1].radius
+#        assert single2.shell.shape.radius == pid_particle_pair2[1].radius
+#        # even more checking
+#        assert self.check_obj(single1)
+#        assert self.check_obj(single2)
+#        # Now finally we are convinced that the singles were actually made correctly
+
+
+        # Log the event
+        if __debug__:
+            log.debug("process_pair_event: #1 { %s: %s => %s }" %
+                      (single1, str(pos1), str(newpos1)))
+            log.debug("process_pair_event: #2 { %s: %s => %s }" %
+                      (single2, str(pos2), str(newpos2)))
+
         return domains
 
     def process_multi_event(self, multi):
@@ -1703,26 +1744,8 @@ def burst_single(self, single):
         single.event_type = EventType.BURST
         self.remove_event(single)
 
-#        newsingle = self.propagate_single(single)      # TODO this can now also just be a process_single_event
-#       self.add_domain_event(newsingle)
         newsingles = self.process_single_event(single)
 
-# NOTE Be inefficient for just now and don't reuse the event in the schedules
-#        newpos = newsingle.pid_particle_pair[1].position
-#        # TODO? Check if stays within domain ~MW
-#
-#        if isinstance(single, InteractionSingle):
-#            # When bursting an InteractionSingle, the domain changes from Interaction
-#           # NonInteraction domain. This needs to be reflected in the event 
-#            self.remove_event(single)
-#            self.add_domain_event(newsingle)
-#        else:
-#            assert single == newsingle
-#            self.update_domain_event(self.t, single)
-#
-#        particle_radius = single.pid_particle_pair[1].radius
-#        assert newsingle.shell.shape.radius == particle_radius
-
         return newsingles
 
     def burst_pair(self, pair):
@@ -1742,123 +1765,10 @@ def burst_pair(self, pair):
         pair.event_type = EventType.BURST
         self.remove_event(pair)         # remove the event -> was still in the scheduler
 
-#        single1, single2 = self.propagate_pair(pair)    # TODO this can now also just be a process_pair_event
-#        self.add_domain_event(single1)
-#        self.add_domain_event(single2)
         newsingles = self.process_pair_event(pair)
 
-#        return single1, single2
         return newsingles
 
-#    def propagate_pair(self, pair):
-#        # takes a pair and returns two singles after propagation
-#
-#        pid_particle_pair1 = pair.pid_particle_pair1
-#        pid_particle_pair2 = pair.pid_particle_pair2
-#
-#        pos1 = pid_particle_pair1[1].position
-#        pos2 = pid_particle_pair2[1].position
-#
-#        # if time has passed (should be always)
-#        if pair.dt > 0.0:
-##            D1 = pid_particle_pair1[1].D
-##            D2 = pid_particle_pair2[1].D
-#
-#            old_com, old_inter_particle = pair.do_transform (pair.single1, pair.single2, self.world)
-#            r0 = length(old_inter_particle)
-#
-#
-##            # store for later check
-##            old_com = pair.com
-##
-##            # TODO this should be done when the pair is made -> passed to the constructor
-##            pos2t = self.world.cyclic_transpose(pos2, pos1)
-##            old_inter_particle = pos2t - pos1
-##            r0 = self.world.distance(pos1, pos2)
-##            assert feq(r0, length(old_inter_particle))
-#
-#            # draw the new positions of the particles
-#            newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_inter_particle, 
-#                                                       pair.event_type)
-#            newpos1 = self.world.apply_boundary(newpos1)
-#            newpos2 = self.world.apply_boundary(newpos2)
-#
-#            # check that the particles do not overlap with any other particles in the world
-#            assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
-#                                                pid_particle_pair1[0], pid_particle_pair2[0])
-#            assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
-#                                                pid_particle_pair1[0], pid_particle_pair2[0])
-#
-#            # some more consistency checking of the positions
-##            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
-##                                       pair.get_shell_size())
-#
-#        else:
-#        # no time has passed
-#            newpos1 = pid_particle_pair1[1].position
-#            newpos2 = pid_particle_pair2[1].position
-#
-#        pid_particle_pair1 = self.move_particle(pid_particle_pair1, newpos1)
-#        pid_particle_pair2 = self.move_particle(pid_particle_pair2, newpos2)
-#
-#
-#        # re-use single domains for particles
-#        # normally we would take the particles + new positions from the old pair
-#        # and use them to make new singles. Now we re-use the singles stored in the
-#        # pair
-#        single1 = pair.single1
-#        single2 = pair.single2
-#        assert single1.domain_id not in self.domains
-#        assert single2.domain_id not in self.domains
-#        single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
-#        single2.pid_particle_pair = pid_particle_pair2
-#
-#
-#        # remove the old domain
-#        self.remove_domain(pair)
-#
-#        # 'make' the singles
-#        single1.initialize(self.t)
-#        single2.initialize(self.t)
-#        
-#        self.update_single_shell(single1, newpos1, pid_particle_pair1[1].radius)
-#        self.update_single_shell(single2, newpos2, pid_particle_pair2[1].radius)
-#
-#
-#        self.domains[single1.domain_id] = single1
-#        self.domains[single2.domain_id] = single2
-#
-#        # Check the dimensions of the shells of the singles with the shell in the container
-#        if __debug__:
-#            container1 = self.geometrycontainer.get_container(single1.shell)
-#            assert container1[single1.shell_id].shape.radius == \
-#                   single1.shell.shape.radius
-#            if type(single1.shell) is CylindricalShell:
-#                assert container1[single1.shell_id].shape.half_length == \
-#                       single1.shell.shape.half_length
-#
-#            container2 = self.geometrycontainer.get_container(single2.shell)
-#            assert container2[single2.shell_id].shape.radius == \
-#                   single2.shell.shape.radius
-#            if type(single2.shell) is CylindricalShell:
-#                assert container2[single2.shell_id].shape.half_length == \
-#                       single2.shell.shape.half_length
-#
-#        assert single1.shell.shape.radius == pid_particle_pair1[1].radius
-#        assert single2.shell.shape.radius == pid_particle_pair2[1].radius
-#        # even more checking
-#        assert self.check_obj(single1)
-#        assert self.check_obj(single2)
-#        # Now finally we are convinced that the singles were actually made correctly
-#
-#        # Log the event
-#        if __debug__:
-#            log.debug("process_pair_event: #1 { %s: %s => %s }" %
-#                      (single1, str(pos1), str(newpos1)))
-#            log.debug("process_pair_event: #2 { %s: %s => %s }" %
-#                      (single2, str(pos2), str(newpos2)))
-#
-#        return single1, single2
 
     def try_interaction(self, single, surface):
         # Try to form an interaction between the 'single' particle and the 'surface'.

From 8e40f884576f565c8208961807e87fa27bdfa927 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 15:32:03 +0100
Subject: [PATCH 0363/1541] fixed randomizing the direction when falling off
 the membrane

---
 egfrd.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 545e3298..0bb828a8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -699,9 +699,11 @@ def fire_single_reaction(self, single, reactant_pos):
                 assert isinstance(product_structure, CuboidalRegion)
 
                 if isinstance(reactant_structure, PlanarSurface):
+                    a = myrandom.choice(-1, 1)
+                    directions = [-a,a]
                     vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # the thickness of the membrane is 0.0
                     product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
-                                        for direction in [-1,1]]        # FIXME the direction should be randomized
+                                        for direction in directions]
 
                 elif isinstance(reactant_structure, CylindricalSurface):
                     vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR

From a0d3712992b30789d28f16f9bb5ff748fd5029b7 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 15 Nov 2011 15:36:10 +0100
Subject: [PATCH 0364/1541] dt=zero steps warning -> debug

---
 BDSimulator.hpp | 4 ++--
 egfrd.py        | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index b83949f5..75090399 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -250,8 +250,8 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
                 make_select_first_range(base_type::world_->
                                         get_particles_range()));
             while (propagator());
-            //LOG_DEBUG(("%d: t=%lg, dt=%lg", base_type::num_steps_, 
-            //           base_type::t_, dt));
+            LOG_DEBUG(("%d: t=%lg, dt=%lg", base_type::num_steps_, 
+                       base_type::t_, dt));
         }
         ++base_type::num_steps_;
         base_type::t_ += dt;
diff --git a/egfrd.py b/egfrd.py
index 5363963b..9c495263 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -343,7 +343,7 @@ def step(self):
         # assert if not too many successive dt=0 steps occur.
         if __debug__:
             if self.dt == 0:
-                log.warning('dt=zero step, working in s.t >> dt~0 Python limit.')
+                log.debug('dt=zero step, working in s.t >> dt~0 Python limit.')
                 self.zero_steps += 1
                 # TODO Changed from 10 to 10000, because only a problem 
                 # when reaching certain magnitude.

From cad2dedf7c42a8cd9d20b184ed7f5ca887c04ed0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 16:05:36 +0100
Subject: [PATCH 0365/1541] some cleanup of fire_single_reaction

---
 egfrd.py | 79 ++++++++++++++++++++++----------------------------------
 1 file changed, 31 insertions(+), 48 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0bb828a8..c50da801 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -686,7 +686,6 @@ def fire_single_reaction(self, single, reactant_pos):
 
             
         elif len(rr.products) == 1:
-        # TODO product particle can live on different structure
             
             # 1. get product info
             product_species = self.world.get_species(rr.products[0])
@@ -720,39 +719,43 @@ def fire_single_reaction(self, single, reactant_pos):
                 product_pos_list = [reactant_pos]               # no change of position is required if structure doesn't change
 
 
-            # TODO try alternatives if surrounding is crowded
-            product_pos = product_pos_list[0]
-            product_pos = self.world.apply_boundary(product_pos)
+            for product_pos in product_pos_list:
+                product_pos = self.world.apply_boundary(product_pos)
 
-            # 2. make space for the products.
-#            if product_pos != reactant_pos or product_radius > reactant_radius:
-            self.burst_volume(product_pos, product_radius)
+                # 2. make space for the products.
+#                if product_pos != reactant_pos or product_radius > reactant_radius:
+                self.burst_volume(product_pos, product_radius)
 
-            # 3. check that there is space for the products 
-            if self.world.check_overlap((product_pos, product_radius), reactant[0]):
-                # 4. Process (the lack of) change
-                moved_reactant = self.move_particle(reactant, reactant_pos)
-                products = [moved_reactant]     # no change
+                # 3. check that there is space for the products 
+                if (not self.world.check_overlap((product_pos, product_radius), reactant[0])):
 
-                # 5. update counters
-                self.rejected_moves += 1
+                    # 4. process the changes (remove particle, make new ones)
+                    self.world.remove_particle(reactant[0])
+                    newparticle = self.world.new_particle(product_species.id, product_pos)
+                    products = [newparticle]
+
+                    # 5. update counters
+                    self.reaction_events += 1
+                    self.last_reaction = (rr, (reactant[1], None), products)
+
+                    # 6. Log the change
+                    if __debug__:
+                        log.info('product (%s) = %s' % (len(products), products))
+
+                    # exit the loop, we have found a new position
+                    break
 
-                # 6. Log the event
-                if __debug__:
-                    log.info('single reaction; placing product failed.')
             else:
-                # 4. process the changes (remove particle, make new ones)
-                self.world.remove_particle(reactant[0])
-                newparticle = self.world.new_particle(product_species.id, product_pos)
-                products = [newparticle]
+                    # 4. Process (the lack of) change
+                    moved_reactant = self.move_particle(reactant, reactant_pos)
+                    products = [moved_reactant]     # no change
 
-                # 5. update counters
-                self.reaction_events += 1
-                self.last_reaction = (rr, (reactant[1], None), products)
+                    # 5. update counters
+                    self.rejected_moves += 1
 
-                # 6. Log the change
-                if __debug__:
-                     log.info('product (%s) = %s' % (len(products), products))
+                    # 6. Log the event
+                    if __debug__:
+                        log.info('single reaction; placing product failed.')
 
             
         elif len(rr.products) == 2:
@@ -813,8 +816,6 @@ def fire_single_reaction(self, single, reactant_pos):
 
                     # draw a number of new positions for the two product particles
                     # TODO make this into a generator
-#                    phi_min = math.asin (productB_radius / particle_radius12)   # we assume the membrane to have zero thickness
-#                    phi_min *= MINIMAL_SEPARATION_FACTOR        # make sure that there's some distance from the membrane
 
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
@@ -848,25 +849,6 @@ def fire_single_reaction(self, single, reactant_pos):
 
                         newposA = reactant_pos - weightA * (iv_x + iv_y)
                         newposB = reactant_pos + weightB * (iv_x + iv_y) + iv_z
-
-
-#                        phi = myrandom.uniform(phi_min, Pi - phi_min)
-#
-#                        cos_phi = math.cos(phi) 
-#                        sin_phi = math.sin(phi)
-#
-#                        productA_displacement_xy = productA_displacement * cos_phi
-#                        productB_displacement_xy = productB_displacement * cos_phi
-#                        productB_displacement_z  = particle_radius12 * sin_phi
-#
-#                        # pick a random orientation
-#                        orientation_vector_xy = _random_vector(reactant_structure, 1.0, self.rng)
-#                        # pick a random side of the membrane
-#                        orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-#
-#                        newposA = reactant_pos + productA_displacement_xy * orientation_vector_xy
-#                        newposB = reactant_pos - productB_displacement_xy * orientation_vector_xy + \
-#                                                 productB_displacement_z  * orientation_vector_z
                         newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
 
@@ -918,6 +900,7 @@ def fire_single_reaction(self, single, reactant_pos):
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
             for newpos1, newpos2 in product_pos_list:
+
                 if (not self.world.check_overlap((newpos1, product1_radius), reactant[0])
                    and
                    not self.world.check_overlap((newpos2, product2_radius), reactant[0])):

From 8a4175fa308484d48ee717f8a426fc78947968b3 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 15 Nov 2011 17:46:17 +0100
Subject: [PATCH 0366/1541] Started branch for new 1D Greensfunction with Sink.

---
 GreensFunction1DAbsSinkAbs.cpp | 738 +++++++++++++++++++++++++++++++++
 GreensFunction1DAbsSinkAbs.hpp | 242 +++++++++++
 2 files changed, 980 insertions(+)
 create mode 100644 GreensFunction1DAbsSinkAbs.cpp
 create mode 100644 GreensFunction1DAbsSinkAbs.hpp

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
new file mode 100644
index 00000000..044dc6d7
--- /dev/null
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -0,0 +1,738 @@
+#include <sstream>
+#include <iostream>
+#include <cstdlib>
+#include <exception>
+#include <vector>
+
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_sf_trig.h>
+#include <gsl/gsl_sum.h>
+#include <gsl/gsl_errno.h>
+#include <gsl/gsl_interp.h>
+#include <gsl/gsl_sf_expint.h>
+#include <gsl/gsl_sf_elljac.h>
+#include <gsl/gsl_roots.h>
+
+#include <math.h>
+
+#include "findRoot.hpp"
+#include "GreensFunction1DRadAbs.hpp"
+
+// This is the appropriate definition of the function defining
+// the roots of our Green's functions in GSL.
+// Later needed by the rootfinder.
+//
+// It expects a reaction rate h=k/D already divided by D.
+double
+GreensFunction1DRadAbs::tan_f (double x, void *p)
+{
+    // casts the void to the struct pointer
+    struct tan_f_params *params = (struct tan_f_params *)p;
+    const Real a = (params->a);
+    const Real h = (params->h);
+    const Real h_a (h*a);
+
+    if ( h_a < 1 )
+    {
+	// h = k/D
+	return 1/tan(x) + (h_a)/x;
+    }
+    else
+    {
+	// h = k/D
+	return tan(x) + x/(h_a);
+    }
+    
+}
+
+// Calculates the roots of tan(x*a)=-x/h
+Real
+GreensFunction1DRadAbs::root_n(int n) const
+{
+    const Real L( this->geta()-this->getsigma() );
+    const Real h( (this->getk()+this->getv()/2.0) / this->getD() );
+    // the drift v also comes into this constant, h=(k+v/2)/D
+    Real upper, lower;
+
+    //No drift, and k = 0, use reflective solution.
+    if (h == 0.0)
+        return M_PI * ( n - 1./2 ) / L;
+    
+
+    if ( h*L < 1 )
+    {
+	// 1E-10 to make sure that he doesn't include the transition 
+	lower = (n-1)*M_PI + 1E-10;
+	// (asymptotic) from infinity to -infinity
+	upper =  n   *M_PI - 1E-10;
+    }
+    else
+    {
+	lower = (n-1)*M_PI + M_PI_2 + 1E-10;
+	upper = n    *M_PI + M_PI_2 - 1E-10;
+    }
+
+    gsl_function F;
+    struct tan_f_params params = { L, h };
+     
+    F.function = &GreensFunction1DRadAbs::tan_f;
+    F.params = &params;
+
+    // define a new solver type brent
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+
+    // make a new solver instance
+    // TODO: incl typecast?
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+    // get the root = run the rootsolver
+    const Real root( findRoot( F, solver, lower, upper, 1.0*EPSILON, EPSILON,
+                            "GreensFunction1DRadAbs::root_tan" ) );
+    gsl_root_fsolver_free( solver );
+    
+    return root/L;
+    // This rescaling is important, because the function tan_f is used to solve for
+    // tan(x)+x/h/L=0, whereas we actually need tan(x*L)+x/h=0, So if x solves the 
+    // subsidiary equation, x/L solves the original one.
+}
+
+// This is the non-exponential factor in the Green's function sum, not
+// including the factor containing the explicit r-dependency (The latter
+// is given by the Bn's, see below).
+//
+// r0 is here still in the interval from 0 to a (and supposed to be the
+// starting point of the particle at t0).
+//
+// The root a_n also must be the specific one for that interval, thus
+// the one rescaled by a (see comments in function a_n(n) ).
+//
+// The factor calculated here is identical for the cases w. or w/o drift,
+// only h changes.
+Real
+GreensFunction1DRadAbs::An (Real root_n) const
+{
+    const Real h((this->getk()+this->getv()/2.0)/this->getD());
+    const Real sigma(this->getsigma());
+    const Real L(this->geta()-this->getsigma());
+    const Real r0(this->getr0());
+    const Real rootn_r0_s = root_n*(r0-sigma);
+
+    return (root_n*cos(rootn_r0_s) + h*sin(rootn_r0_s)) / (h + (root_n*root_n + h*h)*L);
+}
+
+// This factor appears in the survival prob.
+Real
+GreensFunction1DRadAbs::Bn (Real root_n) const
+{
+    const Real h((this->getk()+this->getv()/2.0)/this->getD());
+    const Real k(this->getk());
+    const Real D(this->getD());
+    const Real v(this->getv());
+    const Real sigma(this->getsigma());
+    const Real a(this->geta());
+    const Real L(this->geta()-this->getsigma());
+    
+    const Real rootnL(root_n*L);
+    const Real rootn2(root_n*root_n);
+    const Real h2(h*h);
+    const Real v2D(v/2.0/D);
+
+    if(v==0.0) return (h2 - (rootn2 + h2)*cos(rootnL)) / (h*root_n);
+    else	return (exp(v2D*sigma)*h*k/D - exp(v2D*a)*(rootn2+h2)*cos(rootnL) ) / (h/root_n*(rootn2+v2D*v2D));
+}
+
+// This is the exponential factor in the Green's function sum, also
+// appearing in the survival prob. and prop. function.
+//
+// Also here the root is the one refering to the interval of length L.
+Real
+GreensFunction1DRadAbs::Cn (Real root_n, Real t)
+const
+{
+    const Real D(this->getD());
+
+    return std::exp(-D*root_n*root_n*t);
+}
+
+// Calculates the probability of finding the particle inside the domain
+// at time t, the survival probability.
+Real
+GreensFunction1DRadAbs::p_survival (Real t) const
+{
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+  
+    const Real D(this->getD());
+    const Real v(this->getv());
+    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+    const Real L(this->geta()-this->getsigma());
+    const Real r0_s(this->getr0() - this->getsigma());
+    const Real h((this->getk()+this->getv()/2.0)/this->getD());
+
+    if (t == 0.0 || (D == 0.0 && v == 0.0) )
+    {
+	// if there was no time or no movement the particle was always
+	// in the domain
+	return 1.0;
+    }
+
+
+    Real root_n;
+    Real sum = 0, term = 0, term_prev = 0;
+    int n = 1;
+
+    if(h != 0.0)
+    {
+
+        do
+        {
+	        root_n = this->root_n(n);
+	        term_prev = term;
+    	    term = this->Cn(root_n, t) * this->An(root_n) * this->Bn(root_n);
+	        sum += term;
+	        n++;
+        }
+        while ( fabs(term/sum) > EPSILON  ||
+	    fabs(term_prev/sum) > EPSILON ||
+	    n <= MIN_TERMS);
+
+    }
+    else
+    {
+
+        do
+        {
+	        root_n = this->root_n(n);
+	        term_prev = term;
+    	    
+            term = this->Cn(root_n, t) * cos( root_n * r0_s ) * sin( root_n * L ) / ( L * root_n );
+
+	        sum += term;
+	        n++;
+        }
+        while ( fabs(term/sum) > EPSILON  ||
+	    fabs(term_prev/sum) > EPSILON ||
+	    n <= MIN_TERMS);
+
+    }
+    return 2.0*exp(vexpo)*sum;
+}
+
+
+// Calculates the probability density of finding the particle at location r
+// at time t.
+Real
+GreensFunction1DRadAbs::prob_r (Real r, Real t)
+const
+{
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+    THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a && (r0 - sigma) >= 0.0 && r0<=a );
+    
+    const Real sigma(this->getsigma());
+    const Real a(this->geta());
+    const Real L(this->geta()-this->getsigma());
+    const Real r0(this->getr0());
+    const Real D(this->getD());
+    const Real v(this->getv());
+    const Real h((this->getk()+this->getv()/2.0)/this->getD());
+    
+    const Real vexpo(-v*v*t/D/4.0 + v*(r-r0)/D/2.0);
+
+    // if there was no time change or zero diffusivity => no movement
+    if (t == 0 || D == 0)
+    {
+	// the probability density function is a delta function
+	if (r == r0)
+	{
+	    return INFINITY;
+	}
+	else
+	{
+	    return 0.0;
+	}
+    }
+
+    // if r is at the absorbing boundary
+    if ( fabs(a-r) < EPSILON*L )
+    {
+	return 0.0;
+    }
+
+    Real root_n, root_n_r_s;
+    Real sum = 0, term = 0, prev_term = 0;
+    int n=1;
+
+    do
+    {
+	if ( n >= MAX_TERMS )
+	{
+	    std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
+	              << n << std::endl;
+	    break;
+	}
+
+	root_n = this->root_n(n);
+	root_n_r_s = root_n*(r-sigma);
+
+	prev_term = term;
+	term = Cn(root_n, t) * An(root_n) * (h*sin(root_n_r_s) + root_n*cos(root_n_r_s));
+	sum += term;
+
+	n++;
+    }
+    while (fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
+	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+	n <= MIN_TERMS );
+
+    return 2.0*exp(vexpo)*sum;
+}
+
+// Calculates the probability density of finding the particle at location z at
+// timepoint t, given that the particle is still in the domain.
+Real
+GreensFunction1DRadAbs::calcpcum (Real r, Real t) const
+{
+    return prob_r(r, t)/p_survival(t);
+}
+
+// Calculates the total probability flux leaving the domain at time t
+// This is simply the negative of the time derivative of the survival prob.
+// at time t [-dS(t')/dt' for t'=t].
+Real
+GreensFunction1DRadAbs::flux_tot (Real t) const
+{
+    Real root_n;
+    const Real D(this->getD());
+    const Real v(this->getv());
+    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+
+    const Real D2 = D*D;
+    const Real v2Dv2D = v*v/4.0/D2;
+    double sum = 0, term = 0, prev_term = 0;
+    int n=1;
+
+    do
+    {
+	if ( n >= MAX_TERMS )
+	{
+	    std::cerr << "Too many terms needed for GF1DRad::flux_tot. N: "
+	              << n << std::endl;
+	    break;
+	}
+
+	root_n = this->root_n(n);
+	prev_term = term;
+	term = (root_n * root_n + v2Dv2D) * Cn(root_n, t) * An(root_n) * Bn(root_n);
+	n++;
+	sum += term;
+    }
+    while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
+	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+	n <= MIN_TERMS );
+
+    return 2.0*D*exp(vexpo)*sum;
+}
+
+// Calculates the probability flux leaving the domain through the radiative
+// boundary at time t
+Real
+GreensFunction1DRadAbs::flux_rad (Real t) const
+{
+    return this->getk() * prob_r(this->getsigma(), t);
+}
+
+// Calculates the flux leaving the domain through the radiative boundary as a
+// fraction of the total flux. This is the probability that the particle left
+// the domain through the radiative boundary instead of the absorbing
+// boundary.
+Real
+GreensFunction1DRadAbs::fluxRatioRadTot (Real t) const
+{
+    return flux_rad(t)/flux_tot(t);
+}
+
+// Determine which event has occured, an escape or a reaction. Based on the
+// fluxes through the boundaries at the given time. Beware: if t is not a
+// first passage time you still get an answer!
+GreensFunction1DRadAbs::EventKind
+GreensFunction1DRadAbs::drawEventType( Real rnd, Real t )
+const
+{
+    THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
+    THROW_UNLESS( std::invalid_argument, t > 0.0 );
+    // if t=0 nothing has happened => no event
+
+    const Real a(this->geta());
+    const Real L(this->geta()-this->getsigma());
+    const Real r0(this->getr0());
+
+    // if the radiative boundary is impermeable (k==0) or
+    // the particle is at the absorbing boundary (at a) => IV_ESCAPE event
+    if ( k == 0 || fabs(a-r0) < EPSILON*L )
+    {
+	return IV_ESCAPE;
+    }
+
+    // Else the event is sampled from the flux ratio
+    const Real fluxratio (this->fluxRatioRadTot(t));
+
+    if (rnd > fluxratio )
+    {
+	return IV_ESCAPE;
+    }
+    else
+    {
+	return IV_REACTION;
+    }
+}
+
+// This function is needed to cast the math. form of the function
+// into the form needed by the GSL root solver.
+double
+GreensFunction1DRadAbs::drawT_f (double t, void *p)
+{
+    // casts p to type 'struct drawT_params *'
+    struct drawT_params *params = (struct drawT_params *)p;
+    Real Xn, exponent;
+    Real prefactor = params->prefactor;
+    int terms = params->terms;
+
+    Real sum = 0, term = 0, prev_term = 0;
+    int n=0;
+    do
+    {
+	if ( n >= terms )
+	{
+	    std::cerr << "Too many terms needed for GF1DRad::DrawTime. N: "
+	              << n << ", conv arg: " << exponent * t <<  std::endl;
+	    break;
+	}
+	prev_term = term;
+
+	Xn = params->Xn[n];
+	exponent = params->exponent[n];
+	term = Xn * exp(exponent * t);
+
+	sum += term;
+	n++;
+    }
+    while (fabs(term/sum) > EPSILON*1.0 ||
+	fabs(prev_term/sum) > EPSILON*1.0 ||
+	n <= MIN_TERMS );
+
+    // find the intersection with the random number
+    return 1.0 - prefactor*sum - params->rnd;
+}
+
+// Draws the first passage time from the survival probability,
+// using an assistance function drawT_f that casts the math. function
+// into the form needed by the GSL root solver.
+Real
+GreensFunction1DRadAbs::drawTime (Real rnd) const
+{
+    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
+  
+    const Real sigma(this->getsigma());
+    const Real a(this->geta());
+    const Real L(this->geta()-this->getsigma());
+    const Real r0(this->getr0());
+    const Real k(this->getk());
+    const Real D(this->getD());
+    const Real v(this->getv());
+    const Real h((this->getk()+this->getv()/2.0)/this->getD());
+    
+
+    if ( D == 0.0 || L == INFINITY )
+    {
+	return INFINITY;
+    }
+
+    if ( rnd <= EPSILON || L < 0.0 || fabs(a-r0) < EPSILON*L )
+    {
+	return 0.0;
+    }
+
+    const Real v2D(v/2.0/D);
+    const Real exp_av2D(exp(a*v2D));
+    const Real exp_sigmav2D(exp(sigma*v2D));
+    // exponent of the prefactor present in case of v<>0; has to be split because it has a t-dep. and t-indep. part
+    const Real vexpo_t(-v*v/4.0/D);
+    const Real vexpo_pref(-v*r0/2.0/D);
+
+    // the structure to store the numbers to calculate the numbers for 1-S
+    struct drawT_params parameters;
+    // some temporary variables
+    double root_n = 0;
+    double root_n2, root_n_r0_s, root_n_L, h_root_n;
+    double Xn, exponent, prefactor;
+
+
+    // produce the coefficients and the terms in the exponent and put them
+    // in the params structure. This is not very efficient at this point,
+    // coefficients should be calculated on demand->TODO
+ 
+    for (int n=0; n<MAX_TERMS; n++)
+    {
+	root_n = this->root_n(n+1);	// get the n-th root of tan(root*a)=root/-h (Note: root numbering starts at n=1)
+	
+	root_n2	    = root_n * root_n;
+	root_n_r0_s = root_n * (r0-sigma);
+	root_n_L    = root_n * L;
+	h_root_n    = h / root_n;
+	
+	if(v==0)	Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
+			      * ( h_root_n + sin(root_n_L) - h_root_n*cos(root_n_L) ); 
+	else		Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
+			      * (exp_sigmav2D*h*k/D - exp_av2D*(root_n2+h*h)*cos(root_n_L)) / (h_root_n * (root_n2 + v2D*v2D)); 
+		  
+	exponent = -D*root_n2 + vexpo_t;
+
+	// store the coefficients in the structure
+	parameters.Xn[n] = Xn;
+	// also store the values for the exponent
+	parameters.exponent[n] = exponent;
+    }
+    
+    // the prefactor of the sum is also different in case of drift<>0 :
+    if(v==0)	prefactor = 2.0;
+    else	prefactor = 2.0*exp(vexpo_pref);
+    parameters.prefactor  = prefactor;
+    
+    // store the random number for the probability
+    parameters.rnd = rnd;
+    // store the number of terms used
+    parameters.terms = MAX_TERMS;
+    parameters.tscale = this->t_scale;
+
+    // Define the function for the rootfinder
+    gsl_function F;
+    F.function = &GreensFunction1DRadAbs::drawT_f;
+    F.params = &parameters;
+
+    // Find a good interval to determine the first passage time in
+    // get the distance to absorbing boundary (disregard rad BC)
+    Real t_guess;
+    Real dist;
+
+    if (k != 0)
+    {
+        dist = std::min(a - r0, r0 - sigma);
+    }
+    else
+    {
+        dist = a - r0;
+    }
+    //const Real dist( std::min(r0, a-r0));	// for test purposes
+    // construct a guess: MSD = sqrt (2*d*D*t)
+    t_guess = dist * dist / ( 2.0 * D );
+    t_guess *= .1;
+    // A different guess has to be made in case of nonzero drift to account for the displacement due to it
+    // TODO: This does not work properly in this case yet, but we don't know why...
+    // When drifting towards the closest boundary
+    //if( (r0 >= a/2.0 && v > 0.0) || (r0 <= a/2.0 && v < 0.0) )	t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
+    // When drifting away from the closest boundary
+    //if( ( r0 < a/2.0 && v > 0.0) || ( r0 > a/2.0 && v < 0.0) )	t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));  
+
+    Real value( GSL_FN_EVAL( &F, t_guess ) );
+    Real low( t_guess );
+    Real high( t_guess );
+
+    // scale the interval around the guess such that the function straddles
+    if( value < 0.0 )
+    {
+	// if the guess was too low
+	do
+	{
+	    // keep increasing the upper boundary until the
+	    // function straddles
+	    high *= 10;
+	    value = GSL_FN_EVAL( &F, high );
+
+	    if( fabs( high ) >= t_guess * 1e6 )
+	    {
+		std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
+		          << high << ") = " << value << std::endl;
+		throw std::exception();
+	    }
+	}
+	while ( value <= 0.0 );
+    }
+    else
+    {
+	// if the guess was too high
+	// initialize with 2 so the test below survives the first
+	// iteration
+	Real value_prev( 2 );
+	do
+	{
+	    if( fabs( low ) <= t_guess * 1e-6 ||
+	        fabs(value-value_prev) < EPSILON*1.0 )
+	    {
+		std::cerr << "GF1DRad::drawTime Couldn't adjust low. F(" << low << ") = "
+		          << value << " t_guess: " << t_guess << " diff: "
+		          << (value - value_prev) << " value: " << value
+		          << " value_prev: " << value_prev << " rnd: "
+		          << rnd << std::endl;
+		return low;
+	    }
+	    value_prev = value;
+	    // keep decreasing the lower boundary until the function straddles
+	    low *= 0.1;
+	    // get the accompanying value
+	    value = GSL_FN_EVAL( &F, low );
+	}
+	while ( value >= 0.0 );
+    }
+
+    // find the intersection on the y-axis between the random number and
+    // the function
+    
+    // define a new solver type brent
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+    // make a new solver instance
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+    const Real t( findRoot( F, solver, low, high, t_scale*EPSILON, EPSILON,
+                            "GreensFunction1DRadAbs::drawTime" ) );
+
+    // return the drawn time
+    return t;
+}
+
+double
+GreensFunction1DRadAbs::drawR_f (double z, void *p)
+{
+    // casts p to type 'struct drawR_params *'
+    struct drawR_params *params = (struct drawR_params *)p;
+    Real v2D 		= params->H[0];	// = v2D = v/(2D)
+    Real costerm 	= params->H[1];	// = k/D
+    Real sinterm 	= params->H[2];	// = h*v2D
+    Real sigma 		= params->H[3];	// = sigma
+    int  terms = params->terms;
+
+    Real expsigma(exp(sigma*v2D));
+    Real zs(z-sigma);
+    
+    Real sum = 0, term = 0, prev_term = 0;
+    Real root_n, S_Cn_root_n;
+    
+    int n = 0;
+    do
+    {
+	if ( n >= terms )
+	{
+	    std::cerr << "GF1DRad: Too many terms needed for DrawR. N: "
+	              << n << std::endl;
+	    break;
+	}
+	prev_term = term;
+
+	S_Cn_root_n = params->S_Cn_root_n[n];
+	root_n  = params->root_n[n];
+	term = S_Cn_root_n * ( expsigma*costerm - exp(v2D*z)*( costerm*cos(root_n*zs) - (root_n+sinterm/root_n)*sin(root_n*zs) ));
+
+	sum += term;
+	n++;
+    }
+    while (fabs(term/sum) > EPSILON*1.0 ||
+	fabs(prev_term/sum) > EPSILON*1.0 ||
+	n <= MIN_TERMS );
+
+    // Find the intersection with the random number
+    return sum - params->rnd;
+}
+
+Real
+GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
+{
+    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+    
+    const Real sigma(this->getsigma());
+    const Real a(this->geta());
+    const Real L(this->geta()-this->getsigma());
+    const Real r0(this->getr0());
+    const Real D(this->getD());
+    const Real v(this->getv());
+    const Real k(this->getk());
+    const Real h((this->getk()+this->getv()/2.0)/this->getD());
+    
+
+    if (t==0.0 || (D==0.0 && v==0.0) )
+    {
+	// the trivial case
+	//return r0*this->l_scale;	// renormalized version, discontinued
+	return r0;
+    }
+    if ( a<0.0 )
+    {
+	// if the domain had zero size
+	return 0.0;
+    }
+
+    // the structure to store the numbers to calculate the numbers for 1-S
+    struct drawR_params parameters;
+    double root_n = 0;
+    double S_Cn_root_n;
+    double root_n2, root_n_r0_s;
+
+    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D); // exponent of the drift-prefactor, same as in survival prob.
+    const Real v2D(v/2.0/D);
+    const Real v2Dv2D(v2D*v2D);
+    const Real S = 2.0*exp(vexpo)/p_survival(t); 
+
+    assert(p_survival(t) >= 0.0);
+
+    // produce the coefficients and the terms in the exponent and put them
+    // in the params structure
+    for (int n=0; n<MAX_TERMS; n++)
+    {
+	    root_n = this->root_n(n+1);  // get the n-th root of tan(alfa*a)=alfa/-k
+       	root_n2 = root_n * root_n;
+       	root_n_r0_s = root_n * (r0-sigma);
+       	S_Cn_root_n =	S * exp(-D*root_n2*t)
+	         * (root_n*cos(root_n_r0_s) + h*sin(root_n_r0_s)) / (L*(root_n2 + h*h) + h)
+	         * root_n / (root_n2 + v2Dv2D);
+
+      	// store the coefficients in the structure
+	    parameters.root_n[n] = root_n;
+        // also store the values for the exponent
+        parameters.S_Cn_root_n[n] = S_Cn_root_n;
+    }
+    
+    // also store constant prefactors that appear in the calculation of the
+    // r-dependent terms
+    parameters.H[0] = v2D;		// appears together with z in one of the prefactors
+    parameters.H[1] = k/D;		// further constant terms of the cosine prefactor
+    parameters.H[2] = h*v2D;		// further constant terms of the sine prefactor
+    parameters.H[3] = sigma;
+
+    // define gsl function for rootfinder
+    gsl_function F;
+    F.function = &GreensFunction1DRadAbs::drawR_f;
+    F.params = &parameters;
+
+    // store the random number for the probability
+    parameters.rnd = rnd;
+    // store the number of terms used
+    parameters.terms = MAX_TERMS;
+
+    // define a new solver type brent
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+    // make a new solver instance
+    // TODO: incl typecast?
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+    Real r( findRoot( F, solver, sigma, a, EPSILON*L, EPSILON,
+                            "GreensFunction1DRadAbs::drawR" ) );
+
+    // return the drawn position
+    return r;
+}
+
+std::string GreensFunction1DRadAbs::dump() const
+{
+    std::ostringstream ss;
+    ss << "D = " << this->getD() << ", sigma = " << this->getsigma() <<
+        ", a = " << this->geta() <<
+        ", r0 = " << this->getr0() <<
+        ", k = " << this->getk() << std::endl;
+    return ss.str();
+}
+
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
new file mode 100644
index 00000000..94ef0865
--- /dev/null
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -0,0 +1,242 @@
+#if !defined( __GREENSFUNCTION1DRADABS_HPP )
+#define __GREENSFUNCTION1DRADABS_HPP
+
+#include <sstream>
+#include <iostream>
+#include <cstdlib>
+#include <exception>
+#include <vector>
+
+#include <gsl/gsl_math.h>
+#include <gsl/gsl_sf_trig.h>
+#include <gsl/gsl_sum.h>
+#include <gsl/gsl_errno.h>
+#include <gsl/gsl_interp.h>
+#include <gsl/gsl_sf_expint.h>
+#include <gsl/gsl_sf_elljac.h>
+#include <gsl/gsl_roots.h>
+
+#include <math.h>
+
+#include "findRoot.hpp"
+#include "Defs.hpp"
+#include "OldDefs.hpp"			// TODO: this must be removed at some point!
+#include "GreensFunction.hpp"
+
+class GreensFunction1DRadAbs: public GreensFunction
+{
+private:
+    // This is a typical length scale of the system, may not be true!
+    static const Real L_TYPICAL = 1E-8;
+    // The typical timescale of the system, may also not be true!!
+    static const Real T_TYPICAL = 1E-6;
+    // measure of 'sameness' when comparing floating points numbers
+    static const Real EPSILON = 1E-10;
+    // Is 1E3 a good measure for the probability density?!
+    static const Real PDENS_TYPICAL = 1;
+    // The maximum number of terms used in calculating the sum
+    static const int MAX_TERMS = 500;
+    // The minimum number of terms
+    static const int MIN_TERMS = 20;
+
+public:
+    GreensFunction1DRadAbs(Real D, Real k, Real r0, Real sigma, Real a)
+	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
+    {
+	// do nothing
+    }
+
+    // The constructor is overloaded and can be called with or without drift v
+    // copy constructor including drift variable v
+    GreensFunction1DRadAbs(Real D, Real v, Real k, Real r0, Real sigma, Real a)
+	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
+    {
+	// do nothing
+    }
+
+    ~GreensFunction1DRadAbs()
+    {
+	;   // empty
+    }
+
+    // This also sets the scale
+    void seta(Real a)
+    {
+	THROW_UNLESS( std::invalid_argument, (a-this->sigma) >= 0.0 && this->r0 <= a);
+
+	// Use a typical domain size to determine if we are here 
+	// defining a domain of size 0.
+	if ( (a-this->sigma) < EPSILON*this->l_scale )
+	{
+	    // just some random value to show that the domain is zero
+	    this->a = -1.0;
+	}
+	else
+	{
+	    // set the l_scale to the given one
+	    this->l_scale = a-sigma;
+	    // set the typical time scale (MSD = sqrt(2*d*D*t) )
+	    this->t_scale = (l_scale*l_scale)/this->getD();
+	    this->a = a;
+	}
+    }
+
+    Real geta() const
+    {
+	return this->a;
+    }
+    
+    Real getsigma() const
+    {
+	return this->sigma;
+    }
+
+    void setr0(Real r0)
+    {
+	if ( this->a - this->sigma < 0.0 )
+	{
+	    // if the domain had zero size
+	    THROW_UNLESS( std::invalid_argument,
+	                  0.0 <= (r0-sigma) && (r0-sigma) <= EPSILON * l_scale );
+	    this->r0 = 0.0;
+	}
+	else
+	{
+	    // The normal case
+	    THROW_UNLESS( std::invalid_argument,
+	                  0.0 <= (r0-sigma) && r0 <= this->a);
+	    this->r0 = r0;
+	}
+    }
+
+    Real getr0() const
+    {
+	return r0;
+    }
+
+    Real getk() const
+    {
+	return this->k;
+    }
+
+    Real getv() const
+    {
+	return this->v;
+    }
+
+    // Calculates the probability density of finding the particle at 
+    // location z at timepoint t, given that the particle is still in the 
+    // domain.
+    Real calcpcum (Real r, Real t) const;
+
+    // Determine which event has occured, an escape or a reaction. Based 
+    // on the fluxes through the boundaries at the given time. Beware: if 
+    // t is not a first passage time you still get an answer!
+    EventKind drawEventType( Real rnd, Real t ) const;
+
+    // Draws the first passage time from the propensity function
+    Real drawTime (Real rnd) const;
+
+    // Draws the position of the particle at a given time, assuming that 
+    // the particle is still in the domain
+    Real drawR (Real rnd, Real t) const;
+
+
+// These methods are both public and private, they are used by public methods 
+// but can also be called from the 'outside'. This is mainly because of 
+// debugging purposes.
+
+
+    // Calculates the probability of finding the particle inside the 
+    // domain at time t -> the survival probability
+    Real p_survival (Real t) const;
+
+    // Calculates the total probability flux leaving the domain at time t
+    Real flux_tot (Real t) const;
+
+    // Calculates the probability flux leaving the domain through the 
+    // radiative boundary at time t
+    Real flux_rad (Real t) const;
+
+    // Calculates the flux leaving the domain through the radiative 
+    // boundary as a fraction of the total flux. This is the probability 
+    // that the particle left the domain through the radiative
+    // boundary instead of the absorbing boundary.
+    Real fluxRatioRadTot (Real t) const;
+
+    // Calculates the probability density of finding the particle at 
+    // location r at time t.
+    Real prob_r (Real r, Real t) const;
+    
+// End of public/private mix methods
+
+//private:	// method made public for testing
+
+    std::string dump() const;
+
+    const char* getName() const
+    {
+        return "GreensFunction1DRadAbs";
+    }
+
+    // Calculates the roots of tan(a*x)=-xk/h
+    Real root_n(int n) const;
+    
+private:
+
+    Real An (Real a_n) const;
+
+    Real Bn (Real a_n) const;
+
+    Real Cn (Real a_n, Real t) const;
+
+    struct tan_f_params
+    {
+	Real a;
+	Real h;
+    };
+
+    static double tan_f (double x, void *p);
+    // this is the appropriate definition of the function in gsl
+
+    struct drawT_params
+    {
+	double exponent[MAX_TERMS];
+	double Xn[MAX_TERMS];
+	double prefactor;
+	int    terms;
+	// the timescale used for convergence
+	Real   tscale;
+	// the random number associated with the time
+	double rnd;
+    };
+
+    static double drawT_f (double t, void *p);
+
+    struct drawR_params
+    {
+	double root_n[MAX_TERMS];
+	double S_Cn_root_n[MAX_TERMS];
+	// variables H: for additional terms appearing as multiplicative factors etc.
+	double H[5];
+	int terms;
+	// the random number associated with the time
+	double rnd;
+    };
+
+    static double drawR_f (double z, void *p);
+
+    // The diffusion constant and drift velocity
+    Real v;
+    // The reaction constant
+    Real k;
+    Real r0;
+    // The left and right boundary of the domain (sets the l_scale, see below)
+    Real sigma;
+    Real a;
+    // This is the length scale of the system
+    Real l_scale;
+    // This is the time scale of the system.
+    Real t_scale;
+};
+#endif // __GREENSFUNCTION1DRADABS_HPP

From 72f101c05bd84f6bb6af8f2dc6486fb1e360508f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 18:25:22 +0100
Subject: [PATCH 0367/1541] implemented back transform for 3D-1D MixedPair to
 take care of decay reaction from cylinder

---
 egfrd.py |  3 +++
 pair.py  | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index c50da801..e2c2080f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -865,6 +865,9 @@ def fire_single_reaction(self, single, reactant_pos):
                 elif isinstance(reactant_structure, CylindricalSurface):
 
                     # TODO insert reverse transformation for 3D/1D here
+                    product_pos_list = []
+                    for _ in range(self.dissociation_retry_moves):
+
                     surface_displace = product3D_radius + reactant_structure.shape.radius
 
                 else:
diff --git a/pair.py b/pair.py
index 4a4b5470..ac13daba 100644
--- a/pair.py
+++ b/pair.py
@@ -1311,3 +1311,37 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
     def __str__(self):
         return 'Mixed' + Pair.__str__(self)
 
+class MixedPair3D1D(Pair):
+
+    @classmethod
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface):
+        D_tot = D1 + D2
+        weight1 = D1 / D_tot
+        weight2 = D2 / D_tot
+
+        # get the coordinates of the iv relative to the system of the surface (or actually the shell)
+        iv_z = surface.shape.unit_z * numpy.dot(iv, surface.shape.unit_z)
+        iv_r = iv - iv_z
+
+        # reflect the coordinates in the unit_z direction back to the side of the membrane
+        # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
+        # plane of the membrane
+        iv_r_length = length(iv_r)
+        # do the reverse scaling
+        iv_r_length_new = iv_r_length / cls.calc_r_scaling_factor(D1, D2)
+
+        # if the particle is overlapping with the cylinder, make sure it doesn't
+        if iv_r_length_new < radius1:
+            iv_r_length_new = radius1 * MINIMAL_SEPARATION_FACTOR
+
+        iv_r =  (iv_r_length_new/iv_r_length) * iv_r
+
+        pos1 = com - weight1 * iv_z
+        pos2 = com + weight2 * iv_z + iv_r
+
+        return pos1, pos2
+
+    @classmethod
+    def calc_r_scaling_factor(cls, D1, D2):
+        return math.sqrt((D1 + D2)/D2)
+

From 493ca4f89a06546649a52d1daf8be1b66f445d1a Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 15 Nov 2011 19:18:08 +0100
Subject: [PATCH 0368/1541] First changes in GF header file.

---
 GreensFunction1DAbsSinkAbs.cpp |   2 +-
 GreensFunction1DAbsSinkAbs.hpp | 124 ++++++++++++++++++---------------
 2 files changed, 68 insertions(+), 58 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 044dc6d7..7daea69d 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -40,7 +40,7 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
     else
     {
 	// h = k/D
-	return tan(x) + x/(h_a);
+    return tan(x) + x/(h_a);
     }
     
 }
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 94ef0865..f8427f4f 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -23,7 +23,7 @@
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "GreensFunction.hpp"
 
-class GreensFunction1DRadAbs: public GreensFunction
+class GreensFunction1DAbsSinkAbs: public GreensFunction
 {
 private:
     // This is a typical length scale of the system, may not be true!
@@ -40,88 +40,95 @@ class GreensFunction1DRadAbs: public GreensFunction
     static const int MIN_TERMS = 20;
 
 public:
-    GreensFunction1DRadAbs(Real D, Real k, Real r0, Real sigma, Real a)
-	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
+    GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
+	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
 	// do nothing
     }
 
     // The constructor is overloaded and can be called with or without drift v
     // copy constructor including drift variable v
-    GreensFunction1DRadAbs(Real D, Real v, Real k, Real r0, Real sigma, Real a)
-	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
+    GreensFunction1DAbsSinkAbs(Real D, Real v, Real k, Real r0, Real rsink, Real sigma, Real a)
+	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), L(a - sigma), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
 	// do nothing
     }
 
-    ~GreensFunction1DRadAbs()
+    ~GreensFunction1DAbsSinkAbs()
     {
 	;   // empty
     }
 
-    // This also sets the scale
-    void seta(Real a)
-    {
-	THROW_UNLESS( std::invalid_argument, (a-this->sigma) >= 0.0 && this->r0 <= a);
-
-	// Use a typical domain size to determine if we are here 
-	// defining a domain of size 0.
-	if ( (a-this->sigma) < EPSILON*this->l_scale )
-	{
-	    // just some random value to show that the domain is zero
-	    this->a = -1.0;
-	}
-	else
-	{
-	    // set the l_scale to the given one
-	    this->l_scale = a-sigma;
-	    // set the typical time scale (MSD = sqrt(2*d*D*t) )
-	    this->t_scale = (l_scale*l_scale)/this->getD();
-	    this->a = a;
-	}
-    }
-
     Real geta() const
     {
-	return this->a;
+	    return this->a;
     }
     
-    Real getsigma() const
+    Real getrsink() const
     {
-	return this->sigma;
+	    return rsink;
     }
-
-    void setr0(Real r0)
+    
+    Real getsigma() const
     {
-	if ( this->a - this->sigma < 0.0 )
-	{
-	    // if the domain had zero size
-	    THROW_UNLESS( std::invalid_argument,
-	                  0.0 <= (r0-sigma) && (r0-sigma) <= EPSILON * l_scale );
-	    this->r0 = 0.0;
-	}
-	else
-	{
-	    // The normal case
-	    THROW_UNLESS( std::invalid_argument,
-	                  0.0 <= (r0-sigma) && r0 <= this->a);
-	    this->r0 = r0;
-	}
+	    return this->sigma;
     }
 
     Real getr0() const
     {
-	return r0;
+	    return r0;
     }
 
     Real getk() const
     {
-	return this->k;
+	    return k;
     }
 
     Real getv() const
     {
-	return this->v;
+	    return v;
+    }
+    
+    // This also sets the scale
+    void seta(Real a)
+    {
+	    THROW_UNLESS( std::invalid_argument, (a-this->sigma) >= 0.0 && this->r0 <= a);
+
+	    // Use a typical domain size to determine if we are here 
+	    // defining a domain of size 0.
+	    if ( (a-this->sigma) < EPSILON*this->l_scale )
+	    {
+	        // just some random value to show that the domain is zero
+	        this->a = -1.0;
+  	        this->L = -1.0;
+	    }
+	    else
+	    {   
+	        // set the l_scale to the given one
+	        this->l_scale = a - sigma;
+	        this->L = a - sigma;
+	        // set the typical time scale (MSD = sqrt(2*d*D*t) )
+	        this->t_scale = ( l_scale * l_scale ) / this->getD();
+	        this->a = a;
+	    }
+    }
+
+    void setr0(Real r0)
+    {
+	    if ( this->a - this->sigma < 0.0 )
+	    {
+	     // if the domain had zero size
+	        THROW_UNLESS( std::invalid_argument,
+	                  0.0 <= (r0-sigma) && (r0-sigma) <= EPSILON * l_scale );
+	        this->r0 = 0.0;
+	    }
+	    else
+	    {
+	        // The normal case
+	        THROW_UNLESS( std::invalid_argument,
+	                  0.0 <= (r0-sigma) && r0 <= this->a);
+	        this->r0 = r0;
+	    }
     }
 
     // Calculates the probability density of finding the particle at 
@@ -176,10 +183,10 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     const char* getName() const
     {
-        return "GreensFunction1DRadAbs";
+        return "GreensFunction1DAbsSinkAbs";
     }
 
-    // Calculates the roots of tan(a*x)=-xk/h
+    // Calculates the roots of D/L x * sin(x) + k/2 * ( cos(x Lr - Ll/L) - cos(x) ) 
     Real root_n(int n) const;
     
 private:
@@ -227,13 +234,16 @@ class GreensFunction1DRadAbs: public GreensFunction
     static double drawR_f (double z, void *p);
 
     // The diffusion constant and drift velocity
-    Real v;
+    const Real v;
     // The reaction constant
-    Real k;
-    Real r0;
+    const Real k;
+    //starting position
+    const Real r0;
     // The left and right boundary of the domain (sets the l_scale, see below)
-    Real sigma;
-    Real a;
+    const Real sigma;
+    const Real a;
+    //Position of the sink in the domain.
+    const Real rsink;
     // This is the length scale of the system
     Real l_scale;
     // This is the time scale of the system.

From 26bfc02f23208f52b02e4e778c2536d8c22add55 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 19:21:54 +0100
Subject: [PATCH 0369/1541] fixed stupid latex error that prevents the system
 from compiling without problems

---
 doc/event_processing.tex | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/event_processing.tex b/doc/event_processing.tex
index 18b743d6..0063f690 100644
--- a/doc/event_processing.tex
+++ b/doc/event_processing.tex
@@ -73,13 +73,13 @@
 
 
 Processing the event means:
-if Single && zero-shell && D != 0 then
+%if Single && zero-shell && D != 0 then
   the single was a 'special' single (zero shell) -> make\_new\_domain
 else
   the single was a 'normal' domain and event should be processed
 
   (calculate new position(s))
-  if (D != 0) && dt>0 (time has passed)
+%  if (D != 0) && dt>0 (time has passed)
     (there was actual relevant diffusion)
     determine new position(s) of particle(s)
     apply boundary conditions

From ea951f3fad08fb3cf4487d58b2260b8c61c62ecc Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 19:25:27 +0100
Subject: [PATCH 0370/1541] implemented 1D particle dissociating into a 1D and
 3D particle

---
 egfrd.py | 22 ++++++++++++++++++++--
 1 file changed, 20 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 46ea8ef5..6c4195ca 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -793,6 +793,7 @@ def fire_single_reaction(self, single, reactant_pos):
                     # product2 goes to 3D and is now particleB (product1 is particleA)
                     productA_displacement = product1_displacement
                     productB_displacement = product2_displacement
+                    productA_radius = product1_radius
                     productB_radius = product2_radius
                     DA = D1
                     DB = D2
@@ -801,6 +802,7 @@ def fire_single_reaction(self, single, reactant_pos):
                     # product1 goes to 3D and is now particleB (product2 is particleA)
                     productA_displacement = product2_displacement
                     productB_displacement = product1_displacement
+                    productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2
                     DB = D1
@@ -859,11 +861,27 @@ def fire_single_reaction(self, single, reactant_pos):
 
                 elif isinstance(reactant_structure, CylindricalSurface):
 
-                    # TODO insert reverse transformation for 3D/1D here
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
 
-                    surface_displace = product3D_radius + reactant_structure.shape.radius
+                        iv = random_vector(particle_radius12 * MixedPair3D1D.calc_r_scaling_factor(DA, DB))
+                        iv *= MINIMAL_SEPARATION_FACTOR
+
+                        newposA, newposB = MixedPair3D1D.do_back_transform(reactant_pos, iv, DA, DB,
+                                                                           productA_radius, productB_radius, reactant_structure)
+
+                        newposA = self.world.apply_boundary(newposA)
+                        newposB = self.world.apply_boundary(newposB)
+
+                        assert (self.world.distance(newposA, newposB) >= particle_radius12)
+                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
+
+                        if default:
+                            newpos1, newpos2 = newposA, newposB
+                        else:
+                            newpos1, newpos2 = newposB, newposA
+
+                        product_pos_list.append((newpos1, newpos2))
 
                 else:
                     # cannot decay from 3D to other structure

From 2a1d847cceb71ea82754a332afef0e09331402aa Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 15 Nov 2011 19:42:26 +0100
Subject: [PATCH 0371/1541] Uselless

---
 geometry.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/geometry.hpp b/geometry.hpp
index 87cc0c09..7ef72246 100644
--- a/geometry.hpp
+++ b/geometry.hpp
@@ -5,7 +5,7 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/mpl/and.hpp>
 #include "linear_algebra.hpp"
-
+//He!
 template< typename T1_, typename T2_ >
 inline typename element_type_of< T1_ >::type distance(
         T1_ const& p1,

From 423fd3d11089f693ee1dfb6e233fc76fe62fa822 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 Nov 2011 20:06:46 +0100
Subject: [PATCH 0372/1541] fixed silly error for the minimal distance of the
 particle to the midline of the cylinder The cylinder has a radius too, you
 know

---
 pair.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index ac13daba..285b4e9d 100644
--- a/pair.py
+++ b/pair.py
@@ -19,6 +19,7 @@
     'Pair',
     'SimplePair',
     'MixedPair',
+    'MixedPair3D1D',
     ]
 
 if __debug__:
@@ -1319,6 +1320,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface):
         weight1 = D1 / D_tot
         weight2 = D2 / D_tot
 
+        min_iv_r_length = radius2 + surface.shape.radius
+
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
         iv_z = surface.shape.unit_z * numpy.dot(iv, surface.shape.unit_z)
         iv_r = iv - iv_z
@@ -1331,8 +1334,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface):
         iv_r_length_new = iv_r_length / cls.calc_r_scaling_factor(D1, D2)
 
         # if the particle is overlapping with the cylinder, make sure it doesn't
-        if iv_r_length_new < radius1:
-            iv_r_length_new = radius1 * MINIMAL_SEPARATION_FACTOR
+        if iv_r_length_new < min_iv_r_length:
+            iv_r_length_new = min_iv_r_length * MINIMAL_SEPARATION_FACTOR
 
         iv_r =  (iv_r_length_new/iv_r_length) * iv_r
 

From 1b08658269a7a82b85f0ada58e2de340b60ea079 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 15 Nov 2011 20:06:57 +0100
Subject: [PATCH 0373/1541] Undid earlier test

---
 geometry.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/geometry.hpp b/geometry.hpp
index 7ef72246..87cc0c09 100644
--- a/geometry.hpp
+++ b/geometry.hpp
@@ -5,7 +5,7 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/mpl/and.hpp>
 #include "linear_algebra.hpp"
-//He!
+
 template< typename T1_, typename T2_ >
 inline typename element_type_of< T1_ >::type distance(
         T1_ const& p1,

From 5bac6fcefddc154dfd76ad185351f321d0f6b01d Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 16 Nov 2011 12:04:37 +0100
Subject: [PATCH 0374/1541] Included proper function naes in cpp file.

---
 GreensFunction1DAbsSinkAbs.cpp | 148 ++++++++++++---------------------
 multi.py                       |   1 +
 2 files changed, 54 insertions(+), 95 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 7daea69d..59332e09 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -23,8 +23,7 @@
 // Later needed by the rootfinder.
 //
 // It expects a reaction rate h=k/D already divided by D.
-double
-GreensFunction1DRadAbs::tan_f (double x, void *p)
+Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
 {
     // casts the void to the struct pointer
     struct tan_f_params *params = (struct tan_f_params *)p;
@@ -46,8 +45,7 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
 }
 
 // Calculates the roots of tan(x*a)=-x/h
-Real
-GreensFunction1DRadAbs::root_n(int n) const
+Real GreensFunction1DAbsSinkAbs::root_n(int n) const
 {
     const Real L( this->geta()-this->getsigma() );
     const Real h( (this->getk()+this->getv()/2.0) / this->getD() );
@@ -90,73 +88,12 @@ GreensFunction1DRadAbs::root_n(int n) const
     gsl_root_fsolver_free( solver );
     
     return root/L;
-    // This rescaling is important, because the function tan_f is used to solve for
-    // tan(x)+x/h/L=0, whereas we actually need tan(x*L)+x/h=0, So if x solves the 
-    // subsidiary equation, x/L solves the original one.
 }
 
-// This is the non-exponential factor in the Green's function sum, not
-// including the factor containing the explicit r-dependency (The latter
-// is given by the Bn's, see below).
-//
-// r0 is here still in the interval from 0 to a (and supposed to be the
-// starting point of the particle at t0).
-//
-// The root a_n also must be the specific one for that interval, thus
-// the one rescaled by a (see comments in function a_n(n) ).
-//
-// The factor calculated here is identical for the cases w. or w/o drift,
-// only h changes.
-Real
-GreensFunction1DRadAbs::An (Real root_n) const
-{
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    const Real sigma(this->getsigma());
-    const Real L(this->geta()-this->getsigma());
-    const Real r0(this->getr0());
-    const Real rootn_r0_s = root_n*(r0-sigma);
-
-    return (root_n*cos(rootn_r0_s) + h*sin(rootn_r0_s)) / (h + (root_n*root_n + h*h)*L);
-}
-
-// This factor appears in the survival prob.
-Real
-GreensFunction1DRadAbs::Bn (Real root_n) const
-{
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    const Real k(this->getk());
-    const Real D(this->getD());
-    const Real v(this->getv());
-    const Real sigma(this->getsigma());
-    const Real a(this->geta());
-    const Real L(this->geta()-this->getsigma());
-    
-    const Real rootnL(root_n*L);
-    const Real rootn2(root_n*root_n);
-    const Real h2(h*h);
-    const Real v2D(v/2.0/D);
-
-    if(v==0.0) return (h2 - (rootn2 + h2)*cos(rootnL)) / (h*root_n);
-    else	return (exp(v2D*sigma)*h*k/D - exp(v2D*a)*(rootn2+h2)*cos(rootnL) ) / (h/root_n*(rootn2+v2D*v2D));
-}
-
-// This is the exponential factor in the Green's function sum, also
-// appearing in the survival prob. and prop. function.
-//
-// Also here the root is the one refering to the interval of length L.
-Real
-GreensFunction1DRadAbs::Cn (Real root_n, Real t)
-const
-{
-    const Real D(this->getD());
-
-    return std::exp(-D*root_n*root_n*t);
-}
 
 // Calculates the probability of finding the particle inside the domain
 // at time t, the survival probability.
-Real
-GreensFunction1DRadAbs::p_survival (Real t) const
+Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
   
@@ -219,8 +156,7 @@ GreensFunction1DRadAbs::p_survival (Real t) const
 
 // Calculates the probability density of finding the particle at location r
 // at time t.
-Real
-GreensFunction1DRadAbs::prob_r (Real r, Real t)
+Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
 const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
@@ -287,8 +223,7 @@ const
 
 // Calculates the probability density of finding the particle at location z at
 // timepoint t, given that the particle is still in the domain.
-Real
-GreensFunction1DRadAbs::calcpcum (Real r, Real t) const
+Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
 {
     return prob_r(r, t)/p_survival(t);
 }
@@ -296,8 +231,7 @@ GreensFunction1DRadAbs::calcpcum (Real r, Real t) const
 // Calculates the total probability flux leaving the domain at time t
 // This is simply the negative of the time derivative of the survival prob.
 // at time t [-dS(t')/dt' for t'=t].
-Real
-GreensFunction1DRadAbs::flux_tot (Real t) const
+Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 {
     Real root_n;
     const Real D(this->getD());
@@ -331,29 +265,56 @@ GreensFunction1DRadAbs::flux_tot (Real t) const
     return 2.0*D*exp(vexpo)*sum;
 }
 
-// Calculates the probability flux leaving the domain through the radiative
-// boundary at time t
-Real
-GreensFunction1DRadAbs::flux_rad (Real t) const
+// Calculates the probability flux leaving the domain through the absorbing
+// left boundary at time t
+Real GreensFunction1DAbsSinkAbs::flux_abs_left(Real t) const
+{
+    return Real();
+}
+
+// Calculates the probability flux leaving the domain through the absorbing
+// right boundary at time t
+Real GreensFunction1DAbsSinkAbs::flux_abs_right(Real t) const
+{
+    return Real();
+}
+
+// Calculates the probability flux leaving the domain through the sink
+// at time t
+Real GreensFunction1DAbsSinkAbs::flux_sink(Real t) const
+{
+    return Real();
+}
+
+// Calculates the flux leaving the domain through the left absorbing boundary as a
+// fraction of the total flux. This is the probability that the particle left
+// the domain through the this boundary.
+Real GGreensFunction1DAbsSinkAbs::fluxRatioAbsLeftTot(Real t) const
+{
+    return flux_abs_left(t)/flux_tot(t);
+}
+
+// Calculates the flux leaving the domain through the left absorbing boundary as a
+// fraction of the total flux. This is the probability that the particle left
+// the domain through the this boundary.
+Real GreensFunction1DAbsSinkAbs::fluxRatioAbsRightTot(Real t) const
 {
-    return this->getk() * prob_r(this->getsigma(), t);
+    return flux_abs_right(t)/flux_tot(t);
 }
 
-// Calculates the flux leaving the domain through the radiative boundary as a
+// Calculates the flux leaving the domain through the sink as a
 // fraction of the total flux. This is the probability that the particle left
-// the domain through the radiative boundary instead of the absorbing
-// boundary.
-Real
-GreensFunction1DRadAbs::fluxRatioRadTot (Real t) const
+// the domain through the sink.
+Real GreensFunction1DAbsSinkAbs::fluxRatioSinkTot(Real t) const
 {
-    return flux_rad(t)/flux_tot(t);
+    return flux_sink(t)/flux_tot(t);
 }
 
 // Determine which event has occured, an escape or a reaction. Based on the
-// fluxes through the boundaries at the given time. Beware: if t is not a
+// fluxes through the boundaries and the sink at the given time. Beware: if t is not a
 // first passage time you still get an answer!
-GreensFunction1DRadAbs::EventKind
-GreensFunction1DRadAbs::drawEventType( Real rnd, Real t )
+GreensFunction1DAbsSinkAbs::EventKind
+GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t )
 const
 {
     THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
@@ -386,8 +347,7 @@ const
 
 // This function is needed to cast the math. form of the function
 // into the form needed by the GSL root solver.
-double
-GreensFunction1DRadAbs::drawT_f (double t, void *p)
+Real GreensFunction1DRadAbs::drawT_f (Real t, void *p)
 {
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
@@ -425,8 +385,7 @@ GreensFunction1DRadAbs::drawT_f (double t, void *p)
 // Draws the first passage time from the survival probability,
 // using an assistance function drawT_f that casts the math. function
 // into the form needed by the GSL root solver.
-Real
-GreensFunction1DRadAbs::drawTime (Real rnd) const
+Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
   
@@ -596,8 +555,7 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     return t;
 }
 
-double
-GreensFunction1DRadAbs::drawR_f (double z, void *p)
+Real GreensFunction1DAbsSinkAbs::drawR_f(Real z, void *p)
 {
     // casts p to type 'struct drawR_params *'
     struct drawR_params *params = (struct drawR_params *)p;
@@ -639,8 +597,7 @@ GreensFunction1DRadAbs::drawR_f (double z, void *p)
     return sum - params->rnd;
 }
 
-Real
-GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
+Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
@@ -726,12 +683,13 @@ GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
     return r;
 }
 
-std::string GreensFunction1DRadAbs::dump() const
+std::string GreensFunction1DAbsSinkAbs::dump() const
 {
     std::ostringstream ss;
     ss << "D = " << this->getD() << ", sigma = " << this->getsigma() <<
         ", a = " << this->geta() <<
         ", r0 = " << this->getr0() <<
+        ", rsink = " << this->getrsink() <<
         ", k = " << this->getk() << std::endl;
     return ss.str();
 }
diff --git a/multi.py b/multi.py
index 6221b0ca..e00ddce6 100644
--- a/multi.py
+++ b/multi.py
@@ -31,6 +31,7 @@ def initialize(self, t):
         self.start_time = t
         main = self.main()
         self.set_dt_and_reaction_length()
+        print "BD intit, dt = %s, rl = %s", %(self.dt, self.reaction_length)
         #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):

From a8683263a3d3f85f34567205681a42d9b0c47ad2 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 16 Nov 2011 14:00:39 +0100
Subject: [PATCH 0375/1541] Debug info in multi.py

---
 multi.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/multi.py b/multi.py
index 6221b0ca..a8f46e5a 100644
--- a/multi.py
+++ b/multi.py
@@ -31,6 +31,7 @@ def initialize(self, t):
         self.start_time = t
         main = self.main()
         self.set_dt_and_reaction_length()
+        #print "Multi intit, dt = %s, rl = %s" %(self.dt,self.reaction_length)
         #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):

From 3fdb7e91d8639a30ada3e4e35bf80c2ba6c4ae6c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 16 Nov 2011 17:32:34 +0100
Subject: [PATCH 0376/1541] implemented new methods to get neighboring
 domains+distance making sorting and filtering easier

---
 shellcontainer.py | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/shellcontainer.py b/shellcontainer.py
index b4acb1ef..46683a9e 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -130,6 +130,44 @@ def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
         else:
             return closest_domain, closest_distance
 
+    def get_neighbor_domains(self, position, domains, ignore=[]):
+    # returns the neighboring domains and the distance to their nearest shell (Multi's can have multiple)
+
+        dists = {}
+
+        for container in self.containers:
+            neighbors = container.get_neighbors(position)
+
+            for shell_id_shell_pair, distance in neighbors:
+                domain_id = shell_id_shell_pair[1].did
+
+                if (domain_id not in ignore) and \
+                   ((domain_id not in dists) or (distance < dists[domain_id])):
+
+                    dists[domain_id] = distance
+
+        neighbor_domains = [(domains[domain_id], distance) for domain_id, distance in dists.iteritems()]
+        return neighbor_domains
+
+
+    def filter_distance(self, neighbor_domains, radius):
+        # returns all the domains that are less than 'radius' distance away
+        intruders = [(domain, distance) for (domain, distance) in neighbor_domains if distance < radius]
+        return intruders        
+
+    def filter_partners(self, neighbor_domains):
+
+        partners = []
+        for domain, distance in neighbor_domains:
+            if isinstance ((domain, NonInteractionSingle) and domain.isreset()) or \
+               isinstance (domain, Multi):
+                partners.append((domain, distance))
+
+        return partners
+
+    def sort_domain_distance(self, neighbor_domains):
+        return sorted(neighbor_domains, key=lambda domain_dist: domain_dist[1])
+
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # Get neighbor domains within given radius.
         # Note that the function returns a generator

From 51e9095c98639486c06308ba8f7dfbd2f69919a8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 17 Nov 2011 11:17:55 +0100
Subject: [PATCH 0377/1541] using new method for intruder searching in
 make_new_domain

---
 egfrd.py | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6c4195ca..0f26570d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1131,7 +1131,7 @@ def make_new_domain(self, single):
             single.dt, single.event_type = single.determine_next_event() 
             single.last_time = self.t
             self.add_domain_event(single)
-            return
+            return single
 
 
         single_pos = single.pid_particle_pair[1].position
@@ -1148,10 +1148,14 @@ def make_new_domain(self, single):
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
-        intruder_ids, closest_id, closest_distance = \
-            self.geometrycontainer.get_intruders(single_pos, reaction_threshold,
-                                                 ignore=[single.domain_id, ])
-        intruders = [self.domains[domain_id] for domain_id in intruder_ids]
+#        intruder_ids, _, _ = \
+#            self.geometrycontainer.get_intruders(single_pos, reaction_threshold,
+#                                                 ignore=[single.domain_id, ])
+#        intruders = [self.domains[domain_id] for domain_id in intruder_ids]
+
+        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+        intruders = self.geometrycontainer.filter_distance(neighbors, reaction_threshold)
+        intruders = [domain for domain, distance in intruders]
 
         if __debug__:
             log.debug("intruders: %s" %
@@ -1168,8 +1172,8 @@ def make_new_domain(self, single):
 #            burst = self.burst_non_multis(intruders)
             for domain in intruders:
                 if not isinstance(domain, Multi) and \
-                   not self.t == domain.last_time: # and \
-#                  not domain.dt == 0.0:
+                   not self.t == domain.last_time and \
+                   not domain.dt == 0.0:
                     # domain is Single or Pair of some subclass
                     single_list = self.burst_domain(domain)
                     burst.extend(single_list)

From 55d3810ab6e6280787a634b89421e57653f825e5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 17 Nov 2011 14:07:27 +0100
Subject: [PATCH 0378/1541] small changes (mostly name change obj->domain) and
 comments to checking code

---
 egfrd.py  | 47 +++++++++++++++++++++++++----------------------
 pair.py   |  1 +
 single.py |  1 +
 3 files changed, 27 insertions(+), 22 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0f26570d..59c129e6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1514,7 +1514,7 @@ def process_single_event(self, single):
 
 
     def process_pair_event(self, pair):
-        assert self.check_obj(pair)
+        assert self.check_domain(pair)
 
         if __debug__:
             log.info('FIRE PAIR: %s' % pair.event_type)
@@ -1681,8 +1681,8 @@ def process_pair_event(self, pair):
 #        assert single1.shell.shape.radius == pid_particle_pair1[1].radius
 #        assert single2.shell.shape.radius == pid_particle_pair2[1].radius
 #        # even more checking
-#        assert self.check_obj(single1)
-#        assert self.check_obj(single2)
+#        assert self.check_domain(single1)
+#        assert self.check_domain(single2)
 #        # Now finally we are convinced that the singles were actually made correctly
 
 
@@ -1874,7 +1874,7 @@ def try_interaction(self, single, surface):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
-        #assert self.check_obj(interaction)
+        #assert self.check_domain(interaction)
         self.add_domain_event(interaction)
 
         if __debug__:
@@ -2102,7 +2102,7 @@ def try_pair(self, single1, single2):
             # single1 will be removed by the scheduler.
             self.remove_event(single2)
 
-            assert self.check_obj(pair)
+#            assert self.check_domain(pair)
             self.add_domain_event(pair)
 
             if __debug__:
@@ -2294,29 +2294,30 @@ def print_report(self, out=None):
     # consistency checkers
     #
 
-    def check_obj(self, obj):
-        obj.check()
+    def check_domain(self, domain):
+        domain.check()
 
-        if isinstance(obj, Multi):
+        if isinstance(domain, Multi):
             # Ignore all surfaces, multi shells can overlap with 
             # surfaces.
             ignores = [s.id for s in self.world.structures]
-        elif isinstance(obj, InteractionSingle):
+        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair):
             # Ignore surface of the particle and interaction surface
-            ignores = [obj.structure.id, obj.surface.id]
+            ignores = [domain.structure.id, domain.surface.id]
         else:
-            ignores = [obj.structure.id]
+            ignores = [domain.structure.id]
 
-        for shell_id, shell in obj.shell_list:
+        for shell_id, shell in domain.shell_list:
             closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
                                                                        self.domains,
-                                                                       ignore=[obj.domain_id],
+                                                                       ignore=[domain.domain_id],
                                                                        ignores=ignores)
 
-#            distance_midpoints = self.world.distance(obj.shell.shape.position, closest.shell.shape.position)
+#            distance_midpoints = self.world.distance(domain.shell.shape.position, closest.shell.shape.position)
             distance_midpoints = 0
 
-        #TODO
+            # testing overlap criteria
+            # TODO This doesn't work if closest is a Multi -> redesign this test
             if(type(shell.shape) is Cylinder and
                closest and type(closest.shell.shape) is Sphere):
                 # Note: this case is special.
@@ -2333,9 +2334,9 @@ def check_obj(self, obj):
                 diff = self.world.distance(shell.shape, sphere.position) - \
                        sphere.radius
             else:
-                if(type(obj) is CylindricalSurfaceSingle or
-                   type(obj) is CylindricalSurfacePair or
-                   type(obj) is CylindricalSurfaceInteraction):
+                if(type(domain) is CylindricalSurfaceSingle or
+                   type(domain) is CylindricalSurfacePair or
+                   type(domain) is CylindricalSurfaceInteraction):
                     # On CylindricalSurface, use half_lenghts.
                     # (assume all nearby other cylinders are on the 
                     # same surface)
@@ -2355,17 +2356,17 @@ def check_obj(self, obj):
 
             assert diff >= 0.0, \
                 '%s overlaps with %s. (shell: %s, dist: %s, diff: %s, dist_midpoints: %s.' % \
-                (str(obj), str(closest), FORMAT_DOUBLE % shell_size,
+                (str(domain), str(closest), FORMAT_DOUBLE % shell_size,
                  FORMAT_DOUBLE % distance,
                  FORMAT_DOUBLE % diff,
                  FORMAT_DOUBLE % distance_midpoints)
 
         return True
 
-    def check_obj_for_all(self):
+    def check_domain_for_all(self):
         for id, event in self.scheduler:
             domain = self.domains[event.data]
-            self.check_obj(domain)
+            self.check_domain(domain)
 
     def check_event_stoichiometry(self):
     # checks if the number of particles in the world is equal to the number
@@ -2405,6 +2406,8 @@ def check_shell_matrix(self):
                                (shell_population, matrix_population))
 
     def check_domains(self):
+    # checks that the events in the scheduler are consistent with the domains
+
         # make set of event_id that are stored in all the domains
         event_ids = set(domain.event_id
                         for domain in self.domains.itervalues())
@@ -2469,7 +2472,7 @@ def check(self):
         self.check_domains()
         self.check_event_stoichiometry()
         
-        self.check_obj_for_all()
+        self.check_domain_for_all()
 
     #
     # methods for debugging.
diff --git a/pair.py b/pair.py
index 285b4e9d..b2ba4d67 100644
--- a/pair.py
+++ b/pair.py
@@ -168,6 +168,7 @@ def draw_new_iv(self, dt, r0, old_iv, event_type):
         return self.create_interparticle_vector(gf, r, dt, r0, old_iv)
 
     def check(self):
+    # perform internal consistency check 
         pass
 
     def __str__(self):
diff --git a/single.py b/single.py
index 7bc15ab4..3003346f 100644
--- a/single.py
+++ b/single.py
@@ -136,6 +136,7 @@ def draw_escape_time_tuple(self):
 #        return self.reactionrules[i]
 
     def check(self):
+    # performs an internal consistency check
         pass
 
     def __str__(self):

From 4a4ae6dddf4c554e9c3c64360544939824b542c3 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 18 Nov 2011 11:00:41 +0100
Subject: [PATCH 0379/1541] Continue to work on Sjnk GF.

---
 GreensFunction1DAbsSinkAbs.cpp | 661 +++++++++++++++++++--------------
 GreensFunction1DAbsSinkAbs.hpp |  46 +--
 greens_functions.cpp           |  24 ++
 multi.py                       |   2 +-
 4 files changed, 430 insertions(+), 303 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 59332e09..71f36f6d 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -16,64 +16,53 @@
 #include <math.h>
 
 #include "findRoot.hpp"
-#include "GreensFunction1DRadAbs.hpp"
+#include "GreensFunction1DAbsSinkAbs.hpp"
 
 // This is the appropriate definition of the function defining
 // the roots of our Green's functions in GSL.
 // Later needed by the rootfinder.
-//
-// It expects a reaction rate h=k/D already divided by D.
 Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
 {
     // casts the void to the struct pointer
-    struct tan_f_params *params = (struct tan_f_params *)p;
-    const Real a = (params->a);
+    struct root_f_params *params = (struct root_f_params *)p;
+    const Real Lm_L = (params->Lm_L);
     const Real h = (params->h);
-    const Real h_a (h*a);
 
-    if ( h_a < 1 )
-    {
-	// h = k/D
-	return 1/tan(x) + (h_a)/x;
-    }
-    else
-    {
-	// h = k/D
-    return tan(x) + x/(h_a);
-    }
-    
+    // L   = Lr + Ll
+    // h    = L * k / (2 * D)
+    // L_Lm = Lr + Ll / Lr - Ll
+    // x    = q * L
+
+    return x * sin(x) + h * ( cos(x * Lm_L) - cos(x) );
 }
 
 // Calculates the roots of tan(x*a)=-x/h
-Real GreensFunction1DAbsSinkAbs::root_n(int n) const
+Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
 {
-    const Real L( this->geta()-this->getsigma() );
-    const Real h( (this->getk()+this->getv()/2.0) / this->getD() );
-    // the drift v also comes into this constant, h=(k+v/2)/D
-    Real upper, lower;
-
-    //No drift, and k = 0, use reflective solution.
-    if (h == 0.0)
-        return M_PI * ( n - 1./2 ) / L;
+    const Real L( getLr() + getLl() );
+    const Real Lm( getLr() - getLl() );
+    const Real h( getk() * L / ( 2 * getD() ) );
     
+    Real upper, lower;  
 
-    if ( h*L < 1 )
+    //h sets how strong second term in root function is pronounced. 
+    if ( h < 1 )
     {
-	// 1E-10 to make sure that he doesn't include the transition 
-	lower = (n-1)*M_PI + 1E-10;
-	// (asymptotic) from infinity to -infinity
-	upper =  n   *M_PI - 1E-10;
+	    // 1E-10 to make sure that he doesn't include the transition 
+	    lower = (n-1)*M_PI + 1E-10;
+	    // (asymptotic) from infinity to -infinity
+	    upper =  n   *M_PI - 1E-10;
     }
     else
     {
-	lower = (n-1)*M_PI + M_PI_2 + 1E-10;
-	upper = n    *M_PI + M_PI_2 - 1E-10;
+        //TODO: more complicated scheme needed.
+        THROW( h > 1 )
     }
 
     gsl_function F;
-    struct tan_f_params params = { L, h };
+    struct root_f_params params = { Lm / L, h };
      
-    F.function = &GreensFunction1DRadAbs::tan_f;
+    F.function = &GreensFunction1DAbsSinkAbs::root_f;
     F.params = &params;
 
     // define a new solver type brent
@@ -84,141 +73,269 @@ Real GreensFunction1DAbsSinkAbs::root_n(int n) const
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     // get the root = run the rootsolver
     const Real root( findRoot( F, solver, lower, upper, 1.0*EPSILON, EPSILON,
-                            "GreensFunction1DRadAbs::root_tan" ) );
+                            "GreensFunction1DAbsSinkAbs::root_f" ) );
     gsl_root_fsolver_free( solver );
     
-    return root/L;
+    return root/Lp;
+}
+
+/* Denominator of the greensfunction. */
+Real GreensFunction1DAbsSinkAbs::p_denominator(Real const& root_n) const
+{
+    const Real D( getD() );
+    const Real k( getk() );    
+    const Real Lm( getLr() - getLl() );
+    const Real L( getLr() + getLl() );
+    
+    const Real term1( root_n * L * cos( root_n * L ) + sin( root_n * L );
+    const Real term2( L * sin( root_n * L ) + Lm * sin( root_n * L );
+    
+    return D * term1 + k / 2. * term2;
 }
 
 
 // Calculates the probability of finding the particle inside the domain
 // at time t, the survival probability.
-Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
+Real GreensFunction1DAbsSinkAbs::p_survival(Real const& t) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
   
-    const Real D(this->getD());
-    const Real v(this->getv());
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
-    const Real L(this->geta()-this->getsigma());
-    const Real r0_s(this->getr0() - this->getsigma());
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
+    const Real D ( getD() );
+    const Real k ( getk() ); 
+    const Real L ( getLr() + getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
-	// if there was no time or no movement the particle was always
-	// in the domain
-	return 1.0;
+	    //particle can't escape.
+	    return 1.0;
     }
 
-
     Real root_n;
-    Real sum = 0, term = 0, term_prev = 0;
+    Real sum = 0, num = 0, num_prev = 0;
     int n = 1;
-
-    if(h != 0.0)
+    do
     {
-
-        do
-        {
-	        root_n = this->root_n(n);
-	        term_prev = term;
-    	    term = this->Cn(root_n, t) * this->An(root_n) * this->Bn(root_n);
-	        sum += term;
-	        n++;
-        }
-        while ( fabs(term/sum) > EPSILON  ||
-	    fabs(term_prev/sum) > EPSILON ||
-	    n <= MIN_TERMS);
-
+        if ( n >= MAX_TERMS )
+	    {
+	        std::cerr << " Too many terms needed for GF1DSink::p_survival. N: "
+	              << n << std::endl;
+	        break;
+	    }
+	    num_prev = num;
+    
+        root_n = root_n(n);
+        const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
+        const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+        
+        num = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
+	    sum += exp( - D * gsl_pow_2( root_n ) * t ) * num / p_denominator( root_n );
+	    n++;
     }
-    else
-    {
-
-        do
-        {
-	        root_n = this->root_n(n);
-	        term_prev = term;
-    	    
-            term = this->Cn(root_n, t) * cos( root_n * r0_s ) * sin( root_n * L ) / ( L * root_n );
-
-	        sum += term;
-	        n++;
-        }
-        while ( fabs(term/sum) > EPSILON  ||
-	    fabs(term_prev/sum) > EPSILON ||
-	    n <= MIN_TERMS);
+    while ( fabs(term/sum) > EPSILON  ||
+	        fabs(term_prev/sum) > EPSILON ||
+	        n <= MIN_TERMS );
 
-    }
-    return 2.0*exp(vexpo)*sum;
+    return 2.0 * sum;
 }
 
 
 // Calculates the probability density of finding the particle at location r
 // at time t.
-Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
-const
+Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
     THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a && (r0 - sigma) >= 0.0 && r0<=a );
     
-    const Real sigma(this->getsigma());
-    const Real a(this->geta());
-    const Real L(this->geta()-this->getsigma());
-    const Real r0(this->getr0());
-    const Real D(this->getD());
-    const Real v(this->getv());
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    
-    const Real vexpo(-v*v*t/D/4.0 + v*(r-r0)/D/2.0);
+    const Real D( getD() );
+    const Real k( getk() ); 
+    const Real L( getLr() + getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    Real L0( getL0() );
+    Real rr( r - getrsink() ) ;
 
     // if there was no time change or zero diffusivity => no movement
     if (t == 0 || D == 0)
     {
-	// the probability density function is a delta function
-	if (r == r0)
-	{
-	    return INFINITY;
-	}
-	else
-	{
-	    return 0.0;
-	}
+	    // the probability density function is a delta function
+	    if (r == r0)
+	    {
+	        return INFINITY;
+	    }
+	    else
+	    {
+	        return 0.0;
+	    }
     }
 
-    // if r is at the absorbing boundary
-    if ( fabs(a-r) < EPSILON*L )
+    // if r is at one of the the absorbing boundaries
+    if ( fabs( a - r ) < EPSILON * L || fabs( r - sigma ) < EPSILON * L  )
     {
-	return 0.0;
+	    return 0.0;
     }
 
-    Real root_n, root_n_r_s;
-    Real sum = 0, term = 0, prev_term = 0;
-    int n=1;
-
-    do
+    Real root_n;
+    Real sum = 0, term_n = 0, prev_term = 0, numerator = 0;
+    int n = 1;
+           
+    /* If r is on the right side of the sink, use right the solution for the right domain.
+       Otherwise, use the solution for the left domain. */
+    if( rr >= 0 )
     {
-	if ( n >= MAX_TERMS )
-	{
-	    std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
+        /* Check if r is left or right of the starting position r0.
+           If so, interchange r with r0. */
+        if( rr < L0 )
+        {
+            const Real temp( L0 );
+            rr = L0;
+            L0 = temp;
+        }    
+
+        do
+        {   
+	        if ( n >= MAX_TERMS )
+	        {
+	            std::cerr << " Too many terms needed for GF1DSink::prob_r. N: "
 	              << n << std::endl;
-	    break;
+	            break;
+	        }
+	        term_prev = term_n;
+
+	        root_n = root_n(n);
+
+            numerator =  D * root_n * sin( root_n * (Ll + L0) ) + k * sin( root_n * Ll ) * sin( root_n * x0);
+            numerator *= sin( root_n * (Lr - rr) );       
+                
+            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
+                
+    	    sum += term_n;
+
+    	    n++;
+       }
+       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
+	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+	           n <= MIN_TERMS );
 	}
+    else
+    {
+        do
+        {   
+	        if ( n >= MAX_TERMS )
+	        {
+	            std::cerr << " Too many terms needed for GF1DSink::prob_r. N: "
+	              << n << std::endl;
+	            break;
+	        }
+	        term_prev = term_n;
+
+	        root_n = root_n(n);
+
+            numerator =  D * root_n * sin( root_n * (Ll + rr) ) * sin( root_n * (Lr - L0) ); 
+            
+            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
+               
+    	    sum += term_n;
+
+    	    n++;
+       }
+       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
+	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+	           n <= MIN_TERMS );
+    }
+    
+    return - 2.0 * sum;
+}
 
-	root_n = this->root_n(n);
-	root_n_r_s = root_n*(r-sigma);
-
-	prev_term = term;
-	term = Cn(root_n, t) * An(root_n) * (h*sin(root_n_r_s) + root_n*cos(root_n_r_s));
-	sum += term;
+/* Greensfunction differentiated w.r.t. the position r.
+   Used for calculating fluxes. */
+Real GreensFunction1DAbsSinkAbs::diff_prob_r(Real r, Real t) const
+{
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+    THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a && (r0 - sigma) >= 0.0 && r0<=a );
+    
+    const Real D( getD() );
+    const Real k( getk() ); 
+    const Real L( getLr() + getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+    const Real rr( r - getrsink() ) ;
+
+    // If there was no time change or zero diffusivity => no flux
+    if (t == 0 || D == 0)
+    {
+	    return 0.0;
+    }
+    
+    /* If r is on the right side of the sink, use right the solution for the right domain.
+       Otherwise, use the solution for the left domain. */
+    if( rr >= 0 )
+    {
+        /* Check if r is left or right of the starting position r0.
+           If so, interchange r with r0. */
+        if( rr < L0 )
+        {
+            const Real temp( L0 );
+            rr = L0;
+            L0 = temp;
+        }    
 
-	n++;
+        do
+        {   
+	        if ( n >= MAX_TERMS )
+	        {
+	            std::cerr << " Too many terms needed for GF1DSink::diff_prob_r. N: "
+	              << n << std::endl;
+	            break;
+	        }
+	        term_prev = term_n;
+
+	        root_n = root_n(n);
+
+            numerator =  k * sin( root_n * Ll ) * sin( root_n * L0 ) + root_n * D * sin( root_n * (Ll + L0) );
+            numerator *= root_n * cos( root_n * (Lr - rr) );       
+                
+            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
+                
+    	    sum += term_n;
+
+    	    n++;
+       }
+       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
+	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+	           n <= MIN_TERMS );
+	}
+    else
+    {
+        do
+        {   
+	        if ( n >= MAX_TERMS )
+	        {
+	            std::cerr << " Too many terms needed for GF1DSink::diff_prob_r. N: "
+	              << n << std::endl;
+	            break;
+	        }
+	        term_prev = term_n;
+
+	        root_n = root_n(n);
+
+            numerator =  - D * gsl_pow_2( root_n ) * cos( root_n * (Ll + rr) ) * sin( root_n * (Lr - L0) ); 
+            
+            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
+               
+    	    sum += term_n;
+
+    	    n++;
+       }
+       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
+	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+	           n <= MIN_TERMS );
     }
-    while (fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
-	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	n <= MIN_TERMS );
 
-    return 2.0*exp(vexpo)*sum;
+    return 2.0 * sum;
 }
 
 // Calculates the probability density of finding the particle at location z at
@@ -234,56 +351,60 @@ Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
 Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 {
     Real root_n;
-    const Real D(this->getD());
-    const Real v(this->getv());
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+    const Real D( getD() );
+    const Real k( getk() ); 
+    const Real L( getLr() + getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+    const Real rr( r - getrsink() ) ;
 
-    const Real D2 = D*D;
-    const Real v2Dv2D = v*v/4.0/D2;
     double sum = 0, term = 0, prev_term = 0;
     int n=1;
-
     do
     {
-	if ( n >= MAX_TERMS )
-	{
-	    std::cerr << "Too many terms needed for GF1DRad::flux_tot. N: "
+        if ( n >= MAX_TERMS )
+	    {
+	        std::cerr << " Too many terms needed for GF1DSink::flux_tot. N: "
 	              << n << std::endl;
-	    break;
-	}
-
-	root_n = this->root_n(n);
-	prev_term = term;
-	term = (root_n * root_n + v2Dv2D) * Cn(root_n, t) * An(root_n) * Bn(root_n);
-	n++;
-	sum += term;
+	        break;
+	    }
+	    num_prev = num;
+    
+        root_n = root_n(n);
+        const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
+        const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+        
+        num = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
+	    sum += gsl_pow_2( root_n ) * exp( - D * gsl_pow_2( root_n ) * t ) * num / p_denominator( root_n );
+	    n++;
     }
-    while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
-	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	n <= MIN_TERMS );
+    while ( fabs(term/sum) > EPSILON  ||
+	        fabs(term_prev/sum) > EPSILON ||
+	        n <= MIN_TERMS );
 
-    return 2.0*D*exp(vexpo)*sum;
+    return  2.0 * D * sum;
 }
 
 // Calculates the probability flux leaving the domain through the absorbing
 // left boundary at time t
 Real GreensFunction1DAbsSinkAbs::flux_abs_left(Real t) const
 {
-    return Real();
+    return - getD() * diff_prob_r(getsigma(), t);
 }
 
 // Calculates the probability flux leaving the domain through the absorbing
 // right boundary at time t
 Real GreensFunction1DAbsSinkAbs::flux_abs_right(Real t) const
 {
-    return Real();
+    return - getD() * diff_prob_r(geta(), t);
 }
 
 // Calculates the probability flux leaving the domain through the sink
 // at time t
 Real GreensFunction1DAbsSinkAbs::flux_sink(Real t) const
 {
-    return Real();
+    return getk() * prob_r(getrsink(), t);
 }
 
 // Calculates the flux leaving the domain through the left absorbing boundary as a
@@ -321,33 +442,46 @@ const
     THROW_UNLESS( std::invalid_argument, t > 0.0 );
     // if t=0 nothing has happened => no event
 
-    const Real a(this->geta());
-    const Real L(this->geta()-this->getsigma());
-    const Real r0(this->getr0());
+    const Real  a( geta() );
+    const Real  L( geta() - getsigma() );
+    const Real r0( getr0() );
 
     // if the radiative boundary is impermeable (k==0) or
-    // the particle is at the absorbing boundary (at a) => IV_ESCAPE event
-    if ( k == 0 || fabs(a-r0) < EPSILON*L )
+    // the particle is at one the absorbing boundary (sigma or a) => IV_ESCAPE event
+    if ( k == 0 || fabs(a - r0) < EPSILON * L || fabs(sigma - r0) < EPSILON * L)
     {
-	return IV_ESCAPE;
+	    return IV_ESCAPE;
     }
 
-    // Else the event is sampled from the flux ratio
-    const Real fluxratio (this->fluxRatioRadTot(t));
-
-    if (rnd > fluxratio )
+    /* The event is sampled from the flux ratios.
+       Three possiblities:
+       (1) Leave through left  boundary - IV_ESCAPE_L
+       (2) Leave through right boundary - IV_ESCAPE_R
+       (3) Leave through sink - IV_REACTION
+    */
+    rnd *= flux_tot( t );
+    Real p_accumulate( flux_sink( t ) );
+    if (rnd < p_accumulate)
     {
-	return IV_ESCAPE;
+	    return IV_REACTION;
     }
     else
     {
-	return IV_REACTION;
+        p_accumulate += flux_abs_right( t );
+        if( rnd < p_accumulate )
+        {
+	        return IV_ESCAPE_R;
+	    }
+	    else
+	    {
+	        return IV_ESCAPE_L;
+	    }
     }
 }
 
 // This function is needed to cast the math. form of the function
 // into the form needed by the GSL root solver.
-Real GreensFunction1DRadAbs::drawT_f (Real t, void *p)
+Real GreensFunction1DAbsSinkAbs::drawT_f (Real t, void *p)
 {
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
@@ -356,27 +490,27 @@ Real GreensFunction1DRadAbs::drawT_f (Real t, void *p)
     int terms = params->terms;
 
     Real sum = 0, term = 0, prev_term = 0;
-    int n=0;
+    int n = 0;
     do
     {
-	if ( n >= terms )
-	{
-	    std::cerr << "Too many terms needed for GF1DRad::DrawTime. N: "
-	              << n << ", conv arg: " << exponent * t <<  std::endl;
-	    break;
-	}
-	prev_term = term;
+	    if ( n >= terms )
+	    {
+	        std::cerr << "Too many terms needed for GF1DSink::DrawTime. N: "
+	                  << n << ", conv arg: " << exponent * t <<  std::endl;
+	        break;
+	    }
+	    prev_term = term;
 
-	Xn = params->Xn[n];
-	exponent = params->exponent[n];
-	term = Xn * exp(exponent * t);
+	    Xn = params->Xn[n];
+	    exponent = params->exponent[n];
+	    term = Xn * exp(exponent * t);
 
-	sum += term;
-	n++;
+	    sum += term;
+	    n++;
     }
     while (fabs(term/sum) > EPSILON*1.0 ||
-	fabs(prev_term/sum) > EPSILON*1.0 ||
-	n <= MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON*1.0 ||
+	       n <= MIN_TERMS );
 
     // find the intersection with the random number
     return 1.0 - prefactor*sum - params->rnd;
@@ -389,33 +523,29 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
   
-    const Real sigma(this->getsigma());
-    const Real a(this->geta());
-    const Real L(this->geta()-this->getsigma());
-    const Real r0(this->getr0());
-    const Real k(this->getk());
-    const Real D(this->getD());
-    const Real v(this->getv());
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    
+    const Real sigma( getsigma() );
+    const Real a( geta() );    
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real k( getk() ); 
+    const Real L( getLr() + getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+    const Real rr( r - getrsink() ) ;
+
+    Real root_n;    
 
     if ( D == 0.0 || L == INFINITY )
     {
-	return INFINITY;
+	    return INFINITY;
     }
 
-    if ( rnd <= EPSILON || L < 0.0 || fabs(a-r0) < EPSILON*L )
+    if ( rnd <= EPSILON || L < 0.0 || fabs( a - r0 ) < EPSILON * L )
     {
-	return 0.0;
+	    return 0.0;
     }
 
-    const Real v2D(v/2.0/D);
-    const Real exp_av2D(exp(a*v2D));
-    const Real exp_sigmav2D(exp(sigma*v2D));
-    // exponent of the prefactor present in case of v<>0; has to be split because it has a t-dep. and t-indep. part
-    const Real vexpo_t(-v*v/4.0/D);
-    const Real vexpo_pref(-v*r0/2.0/D);
-
     // the structure to store the numbers to calculate the numbers for 1-S
     struct drawT_params parameters;
     // some temporary variables
@@ -423,72 +553,52 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     double root_n2, root_n_r0_s, root_n_L, h_root_n;
     double Xn, exponent, prefactor;
 
-
     // produce the coefficients and the terms in the exponent and put them
     // in the params structure. This is not very efficient at this point,
-    // coefficients should be calculated on demand->TODO
- 
+    // coefficients should be calculated on demand->TODO or not TODO?
     for (int n=0; n<MAX_TERMS; n++)
     {
-	root_n = this->root_n(n+1);	// get the n-th root of tan(root*a)=root/-h (Note: root numbering starts at n=1)
+	    root_n = this->root_n(n+1);	// get the n-th root of tan(root*a)=root/-h (Note: root numbering starts at n=1)
 	
-	root_n2	    = root_n * root_n;
-	root_n_r0_s = root_n * (r0-sigma);
-	root_n_L    = root_n * L;
-	h_root_n    = h / root_n;
+	    root_n2	    = root_n * root_n;
+	    root_n_r0_s = root_n * (r0-sigma);
+	    root_n_L    = root_n * L;
+	    h_root_n    = h / root_n;
 	
-	if(v==0)	Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
-			      * ( h_root_n + sin(root_n_L) - h_root_n*cos(root_n_L) ); 
-	else		Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
-			      * (exp_sigmav2D*h*k/D - exp_av2D*(root_n2+h*h)*cos(root_n_L)) / (h_root_n * (root_n2 + v2D*v2D)); 
-		  
-	exponent = -D*root_n2 + vexpo_t;
-
-	// store the coefficients in the structure
-	parameters.Xn[n] = Xn;
-	// also store the values for the exponent
-	parameters.exponent[n] = exponent;
+	    if(v==0)	Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
+			          * ( h_root_n + sin(root_n_L) - h_root_n*cos(root_n_L) ); 
+	    else		Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
+			          * (exp_sigmav2D*h*k/D - exp_av2D*(root_n2+h*h)*cos(root_n_L)) / (h_root_n * (root_n2 + v2D*v2D)); 
+		      
+	    exponent = -D*root_n2 + vexpo_t;
+
+	    // store the coefficients in the structure
+	    parameters.Xn[n] = Xn;
+	    // also store the values for the exponent
+	    parameters.exponent[n] = exponent;
     }
     
     // the prefactor of the sum is also different in case of drift<>0 :
-    if(v==0)	prefactor = 2.0;
-    else	prefactor = 2.0*exp(vexpo_pref);
-    parameters.prefactor  = prefactor;
+    parameters.prefactor = 2;
     
     // store the random number for the probability
     parameters.rnd = rnd;
     // store the number of terms used
     parameters.terms = MAX_TERMS;
-    parameters.tscale = this->t_scale;
+    parameters.tscale = t_scale;
 
     // Define the function for the rootfinder
     gsl_function F;
-    F.function = &GreensFunction1DRadAbs::drawT_f;
+    F.function = &GreensFunction1DAbsSinkAbs::drawT_f;
     F.params = &parameters;
 
     // Find a good interval to determine the first passage time in
-    // get the distance to absorbing boundary (disregard rad BC)
+    // get the distance to absorbing boundary (disregard Sink)
     Real t_guess;
-    Real dist;
-
-    if (k != 0)
-    {
-        dist = std::min(a - r0, r0 - sigma);
-    }
-    else
-    {
-        dist = a - r0;
-    }
-    //const Real dist( std::min(r0, a-r0));	// for test purposes
-    // construct a guess: MSD = sqrt (2*d*D*t)
+    const Real dist( std::min(Lr, Ll) );
+    
     t_guess = dist * dist / ( 2.0 * D );
     t_guess *= .1;
-    // A different guess has to be made in case of nonzero drift to account for the displacement due to it
-    // TODO: This does not work properly in this case yet, but we don't know why...
-    // When drifting towards the closest boundary
-    //if( (r0 >= a/2.0 && v > 0.0) || (r0 <= a/2.0 && v < 0.0) )	t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
-    // When drifting away from the closest boundary
-    //if( ( r0 < a/2.0 && v > 0.0) || ( r0 > a/2.0 && v < 0.0) )	t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));  
 
     Real value( GSL_FN_EVAL( &F, t_guess ) );
     Real low( t_guess );
@@ -497,48 +607,48 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     // scale the interval around the guess such that the function straddles
     if( value < 0.0 )
     {
-	// if the guess was too low
-	do
-	{
-	    // keep increasing the upper boundary until the
-	    // function straddles
-	    high *= 10;
-	    value = GSL_FN_EVAL( &F, high );
-
-	    if( fabs( high ) >= t_guess * 1e6 )
+	    // if the guess was too low
+	    do
 	    {
-		std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
-		          << high << ") = " << value << std::endl;
-		throw std::exception();
+	        // keep increasing the upper boundary until the
+	        // function straddles
+	        high *= 10;
+	        value = GSL_FN_EVAL( &F, high );
+
+	        if( fabs( high ) >= t_guess * 1e6 )
+	        {
+		    std::cerr << "GF1DSink::drawTime Couldn't adjust high. F("
+		              << high << ") = " << value << std::endl;
+		    throw std::exception();
+	        }
 	    }
-	}
-	while ( value <= 0.0 );
+	    while ( value <= 0.0 );
     }
     else
     {
-	// if the guess was too high
-	// initialize with 2 so the test below survives the first
-	// iteration
-	Real value_prev( 2 );
-	do
-	{
-	    if( fabs( low ) <= t_guess * 1e-6 ||
-	        fabs(value-value_prev) < EPSILON*1.0 )
+	    // if the guess was too high
+	    // initialize with 2 so the test below survives the first
+	    // iteration
+	    Real value_prev( 2 );
+	    do
 	    {
-		std::cerr << "GF1DRad::drawTime Couldn't adjust low. F(" << low << ") = "
-		          << value << " t_guess: " << t_guess << " diff: "
-		          << (value - value_prev) << " value: " << value
-		          << " value_prev: " << value_prev << " rnd: "
-		          << rnd << std::endl;
-		return low;
+	        if( fabs( low ) <= t_guess * 1e-6 ||
+	            fabs(value-value_prev) < EPSILON*1.0 )
+	        {
+		    std::cerr << "GF1DSink::drawTime Couldn't adjust low. F(" << low << ") = "
+		              << value << " t_guess: " << t_guess << " diff: "
+		              << (value - value_prev) << " value: " << value
+		              << " value_prev: " << value_prev << " rnd: "
+		              << rnd << std::endl;
+		    return low;
+	        }
+	        value_prev = value;
+	        // keep decreasing the lower boundary until the function straddles
+	        low *= 0.1;
+	        // get the accompanying value
+	        value = GSL_FN_EVAL( &F, low );
 	    }
-	    value_prev = value;
-	    // keep decreasing the lower boundary until the function straddles
-	    low *= 0.1;
-	    // get the accompanying value
-	    value = GSL_FN_EVAL( &F, low );
-	}
-	while ( value >= 0.0 );
+	    while ( value >= 0.0 );
     }
 
     // find the intersection on the y-axis between the random number and
@@ -549,8 +659,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     // make a new solver instance
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     const Real t( findRoot( F, solver, low, high, t_scale*EPSILON, EPSILON,
-                            "GreensFunction1DRadAbs::drawTime" ) );
-
+                            "GreensFunction1DAnsSinkAbs::drawTime" ) );
     // return the drawn time
     return t;
 }
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index f8427f4f..75396e13 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -186,49 +186,43 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
         return "GreensFunction1DAbsSinkAbs";
     }
 
-    // Calculates the roots of D/L x * sin(x) + k/2 * ( cos(x Lr - Ll/L) - cos(x) ) 
+    // Calculates the roots of x * sin(x) + k * L / (2 * D) * ( cos(x * (Lr - Ll)/L) - cos(x) ) 
     Real root_n(int n) const;
     
 private:
 
-    Real An (Real a_n) const;
-
-    Real Bn (Real a_n) const;
-
-    Real Cn (Real a_n, Real t) const;
-
-    struct tan_f_params
+    struct root_f_params
     {
-	Real a;
-	Real h;
+	    Real Lm_L;
+	    Real h;
     };
 
-    static double tan_f (double x, void *p);
+    static double root_f (double x, void *p);
     // this is the appropriate definition of the function in gsl
 
     struct drawT_params
     {
-	double exponent[MAX_TERMS];
-	double Xn[MAX_TERMS];
-	double prefactor;
-	int    terms;
-	// the timescale used for convergence
-	Real   tscale;
-	// the random number associated with the time
-	double rnd;
+	    double exponent[MAX_TERMS];
+	    double Xn[MAX_TERMS];
+	    double prefactor;
+	    int    terms;
+	    // the timescale used for convergence
+	    Real   tscale;
+	    // the random number associated with the time
+	    double rnd;
     };
 
     static double drawT_f (double t, void *p);
 
     struct drawR_params
     {
-	double root_n[MAX_TERMS];
-	double S_Cn_root_n[MAX_TERMS];
-	// variables H: for additional terms appearing as multiplicative factors etc.
-	double H[5];
-	int terms;
-	// the random number associated with the time
-	double rnd;
+	    double root_n[MAX_TERMS];
+	    double S_Cn_root_n[MAX_TERMS];
+	    // variables H: for additional terms appearing as multiplicative factors etc.
+	    double H[5];
+	    int terms;
+	    // the random number associated with the time
+	    double rnd;
     };
 
     static double drawR_f (double z, void *p);
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 2586ba0d..5418605b 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -7,6 +7,7 @@
 #include "freeFunctions.hpp"
 #include "GreensFunction1DAbsAbs.hpp"
 #include "GreensFunction1DRadAbs.hpp"
+#include "GreensFunction1DAbsSinkAbs.hpp"
 #include "GreensFunction2DAbsSym.hpp"
 #include "GreensFunction2DRadAbs.hpp"
 #include "GreensFunction3DSym.hpp"
@@ -80,6 +81,29 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "calcpcum", &GreensFunction1DRadAbs::calcpcum )
         .def( "dump", &GreensFunction1DRadAbs::dump )
         ;
+        
+    class_<GreensFunction1DRadAbs>("GreensFunction1DRadAbs",
+                                   init<Real, Real, Real, Real, Real, Real>() )
+        .def( init<Real, Real, Real, Real, Real, Real, Real>())
+        .def( "getName", &GreensFunction1DRadAbs::getName )
+        .def( "getk", &GreensFunction1DRadAbs::getk )
+        .def( "getD", &GreensFunction1DRadAbs::getD )
+        .def( "getv", &GreensFunction1DRadAbs::getv )
+        .def( "getsigma", &GreensFunction1DRadAbs::getsigma )
+        .def( "seta", &GreensFunction1DRadAbs::seta )
+        .def( "geta", &GreensFunction1DRadAbs::geta )
+        .def( "setr0", &GreensFunction1DRadAbs::setr0 )
+        .def( "getr0", &GreensFunction1DRadAbs::getr0 )
+        .def( "drawTime", &GreensFunction1DRadAbs::drawTime )
+        .def( "drawR", &GreensFunction1DRadAbs::drawR )
+        .def( "drawEventType", &GreensFunction1DRadAbs::drawEventType )
+        .def( "flux_tot", &GreensFunction1DRadAbs::flux_tot )
+        .def( "flux_rad", &GreensFunction1DRadAbs::flux_rad )
+        .def( "fluxRatioRadTot", &GreensFunction1DRadAbs::fluxRatioRadTot )
+        .def( "p_survival", &GreensFunction1DRadAbs::p_survival )
+        .def( "calcpcum", &GreensFunction1DRadAbs::calcpcum )
+        .def( "dump", &GreensFunction1DRadAbs::dump )
+        ;
 
     class_<GreensFunction2DAbsSym>( "GreensFunction2DAbsSym",
 					init<const Real, const Real>() )
diff --git a/multi.py b/multi.py
index e00ddce6..ba0646b7 100644
--- a/multi.py
+++ b/multi.py
@@ -31,7 +31,7 @@ def initialize(self, t):
         self.start_time = t
         main = self.main()
         self.set_dt_and_reaction_length()
-        print "BD intit, dt = %s, rl = %s", %(self.dt, self.reaction_length)
+        print "BD intit, dt = %s, rl = %s" %(self.dt, self.reaction_length)
         #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):

From 5cf8ca1efb23fb3e1846286befc1913fc8ba271c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 18 Nov 2011 18:02:19 +0100
Subject: [PATCH 0380/1541] fixed silly typo

---
 shellcontainer.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/shellcontainer.py b/shellcontainer.py
index 46683a9e..4b638b7f 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -9,6 +9,8 @@
     CylindricalShellContainer
     )
 from utils import *
+from single import NonInteractionSingle
+from multi import Multi
 from gfrdbase import (
     get_closest_surface
     )
@@ -159,7 +161,7 @@ def filter_partners(self, neighbor_domains):
 
         partners = []
         for domain, distance in neighbor_domains:
-            if isinstance ((domain, NonInteractionSingle) and domain.isreset()) or \
+            if (isinstance (domain, NonInteractionSingle) and domain.is_reset()) or \
                isinstance (domain, Multi):
                 partners.append((domain, distance))
 

From 85ed544e753e754076d2c594a6a5d455e684bbfe Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 18 Nov 2011 18:11:41 +0100
Subject: [PATCH 0381/1541] implemented improved algorithm for deciding on the
 type of shell to make

---
 egfrd.py | 160 +++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 114 insertions(+), 46 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 59c129e6..117fb891 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1155,7 +1155,6 @@ def make_new_domain(self, single):
 
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         intruders = self.geometrycontainer.filter_distance(neighbors, reaction_threshold)
-        intruders = [domain for domain, distance in intruders]
 
         if __debug__:
             log.debug("intruders: %s" %
@@ -1169,8 +1168,8 @@ def make_new_domain(self, single):
         # -shell is not already a zero shell (just bursted)
         burst = []
         if intruders:
-#            burst = self.burst_non_multis(intruders)
-            for domain in intruders:
+
+            for domain, _ in intruders:
                 if not isinstance(domain, Multi) and \
                    not self.t == domain.last_time and \
                    not domain.dt == 0.0:
@@ -1196,10 +1195,27 @@ def make_new_domain(self, single):
 
         # TODO Potential partners are for now just the bursted domains
         # TODO FIX THIS!
+        # New situation -> re-get the neighbors
+        # TODO modify the existing neighbor list by removing burst domains, and adding the new ones + distance
+        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+
+        pair_partners = []
+        for domain, _ in neighbors:
+            if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
+                pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
+                # distance from the center of the particles/domains
+                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
+                pair_partners.append((domain, pair_distance - pair_horizon))
+
+#        partners = self.geometrycontainer.filter_partners(neighbors)
+#        partners = self.geometrycontainer.sort_domain_distance(partners)
+
         partners = burst
 
         dists = []
         if partners:
+#            for domain, _ in partners:
+#            if isinstance(domain, NonInteractionSingle):
             # sort partners by distance
             dists = self.obj_distance_array(single_pos, partners)
             if len(dists) >= 2:
@@ -1207,73 +1223,125 @@ def make_new_domain(self, single):
                 partners = numpy.take(partners, n)      # sort the potential partners using the index
                 dists = dists.take(n)                   # sort the distances using the index
 
-            closest_domain = partners[0]
-            domain_distance = dists[0]
-            rest_domains = partners[1:]
-            rest_dists = dists[1:]
-        else:
-            closest_domain = None
-            domain_distance = numpy.inf
-            rest_domains = []
-            rest_dists = []
-        
-        # Potential partners are also surfaces
-        closest_surface, surface_distance = \
-        get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
+#            closest_domain = partners[0][0]
+#            domain_distance = partners[0][1]
+#        else:
+#            closest_domain = None
+#            domain_distance = numpy.inf
 
 
+        
+        # Potential partners are also surfaces
+        interaction_partners = []
+        if isinstance(single, SphericalSingle):
+            # TODO get a list of the surfaces sorted by distance instead of just the closest
+            closest_surface, surface_distance = \
+             get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
+            if closest_surface:
+                surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+                interaction_partners = [(closest_surface, surface_distance - surface_horizon), ]
+            # else no interaction is possible
+
+        pair_interaction_partners = pair_partners + interaction_partners
+        pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
         # 2.4 calculate the thresholds (horizons) for trying to form the various domains.
         # Note that we do not differentiate between directions. This means that we
         # look around in a sphere, the horizons are spherical
-        surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
 
         # 2.4 check that the object is a potential partner for an
         # -Pair         (a zero dt NonInteractionSingle)
         # -Interaction  (a surface)
         # -Multi        (a zero dt NonInteractionSingle or Multi)
-        # TODO For a MixedPair, the surface can be closer than the particle, still a Pair should be attempted
-        if isinstance(closest_obj, NonInteractionSingle) and \
-           closest_obj.is_reset():
-                pair_horizon = (single_radius + \
-                       closest_obj.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
-                if closest_distance < pair_horizon:
-                    # try making a Pair (can still be Mixed Pair or Normal Pair)
-                    domain = self.try_pair (single, closest_obj)
-                else:
-                    domain = None
-
-        elif isinstance(single, SphericalSingle) and \
-             (isinstance(closest_obj, CylindricalSurface) or isinstance(closest_obj, PlanarSurface)) and \
-             closest_distance < surface_horizon:
-#            surface_distance < domain_distance and \
-#            surface_distance < surface_horizon:
-                # try making an Interaction
-            domain = self.try_interaction (single, closest_obj)
-        else:
-            domain = None
+        domain = None
+        for obj, hor_overlap in pair_interaction_partners:
+
+            if hor_overlap > 0.0:
+                break       # there are no more potential partners (everything is out of range)
+
+            if isinstance(obj, NonInteractionSingle):
+#                pair_horizon = (single_radius + \
+#                    closest_obj.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
+
+#                if closest_distance < pair_horizon:
+#                    # try making a Pair (can still be Mixed Pair or Normal Pair)
+                domain = self.try_pair (single, obj)
+
+            elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
+#                surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+
+#                if closest_distance < surface_horizon:
+#                surface_distance < domain_distance and \
+#                surface_distance < surface_horizon:
+                    # try making an Interaction
+                domain = self.try_interaction (single, obj)
 
 
         if not domain:
             # No Pair or Interaction could be formed
             # Now choose between NonInteractionSingle and Multi
 
+            multi_partners = []
+            for domain, dist_to_shell in neighbors:
+                if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
+                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
+                    # distance from the center of the particles/domains
+                    distance = self.world.distance(single_pos, domain.shell.shape.position)
+                    multi_partners.append((domain, distance - multi_horizon, multi_horizon))
+
+                elif isinstance(domain, Multi):
+#                    min(self.world.distance(shell.shape, pos)
+#                        for i, (_, shell) in enumerate(domain.shell_list))
+#
+                    multi_horizon = (single_radius * self.MULTI_SHELL_FACTOR)
+#                    distance = self.domain_distance(single_pos, domain) # distance from the center of the particles/domains
+                    multi_partners.append((domain, dist_to_shell - multi_horizon, multi_horizon))
+
+
+            # Potential partners are also surfaces
+            if isinstance(single, SphericalSingle):
+                # TODO get a list of the surfaces sorted by distance instead of just the closest
+                closest_surface, surface_distance = \
+                 get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
+                surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
+                if closest_surface:
+                    interaction_partners = [(closest_surface, surface_distance - surface_horizon, surface_horizon), ]
+                else:
+                    interaction_partners = []
+            else:
+                # no interaction is possible
+                interaction_partners = []
+
+            multi_partners = multi_partners + interaction_partners
+
+#            for obj, hor_overlap in multi_partners:
             # TODO cleanup
-            if isinstance (closest_obj, NonInteractionSingle) and \
-               closest_obj.is_reset():
-                multi_horizon = (single_radius + \
-                    closest_obj.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
+#                if isinstance (obj, NonInteractionSingle) and \
+#                   closest_obj.is_reset():
+#                    multi_horizon = (single_radius + \
+#                        closest_obj.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
+#                else:
+#                    multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
+
+
+            # In case there is really nothing
+            if multi_partners:
+                multi_partners = sorted(multi_partners, key=lambda domain_overlap: domain_overlap[1])
+#                log.debug('multi_partners: %s' % str(multi_partners))
+                closest_overlap = multi_partners[0][1]
             else:
-                multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
+                closest_overlap = numpy.inf
 
+            log.debug('closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
 
-            if closest_distance > multi_horizon: # and \
-#              surface_distance > multi_horizon:
+            if closest_overlap > 0.0: # and \
+#                surface_distance > multi_horizon:
                 # just make a normal NonInteractionSingle
                 self.update_single(single)
                 self.add_domain_event(single)
             else:
                 # The closest object was too close to make a NonInteractionSingle
+                # TODO an object was closer than the Multi horizon
                 domain = self.form_multi(single, partners, dists)
 
         return domain
@@ -1874,7 +1942,7 @@ def try_interaction(self, single, surface):
         self.remove_domain(single)
         # the event associated with the single will be removed by the scheduler.
 
-        #assert self.check_domain(interaction)
+        assert self.check_domain(interaction)
         self.add_domain_event(interaction)
 
         if __debug__:
@@ -2235,7 +2303,7 @@ def merge_multis(self, multi1, multi2):
     def domain_distance(self, pos, domain):
         # calculates the shortest distance from 'pos' to A shell (a Multi
         # can have multiple) of 'domain'.
-        # Note: it returns the distance between pos and the CENTER of the shell
+        # Note: it returns the distance between pos and the surface of the shell
         return min(self.world.distance(shell.shape, pos)
                    for i, (_, shell) in enumerate(domain.shell_list))
 

From 3ffa6bfe325f50fc59fd586e81133e0ff6a6c162 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 18 Nov 2011 18:12:38 +0100
Subject: [PATCH 0382/1541] introduced SAFETY for pair domain to prevent domain
 overlaps due to numerical errors

---
 pair.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index b2ba4d67..cb137cc2 100644
--- a/pair.py
+++ b/pair.py
@@ -291,8 +291,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
             shell_size = closest_distance 
 
 
-        return min(geometrycontainer.get_max_shell_size(),
-                   shell_size)
+        return min(geometrycontainer.get_max_shell_size(), shell_size)/SAFETY
 
 
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,

From 27922a848f13647f312758eda6e0f1ab3942a57b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 18 Nov 2011 18:13:59 +0100
Subject: [PATCH 0383/1541] Continued working on GFSink cpp file.

---
 GreensFunction1DAbsSinkAbs.cpp | 371 ++++++++++++++-------------------
 GreensFunction1DAbsSinkAbs.hpp |  24 ++-
 2 files changed, 168 insertions(+), 227 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 71f36f6d..6dbfce3f 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -249,95 +249,6 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     return - 2.0 * sum;
 }
 
-/* Greensfunction differentiated w.r.t. the position r.
-   Used for calculating fluxes. */
-Real GreensFunction1DAbsSinkAbs::diff_prob_r(Real r, Real t) const
-{
-    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-    THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a && (r0 - sigma) >= 0.0 && r0<=a );
-    
-    const Real D( getD() );
-    const Real k( getk() ); 
-    const Real L( getLr() + getLl() );
-    const Real Lr( getLr() );
-    const Real Ll( getLl() );
-    const Real L0( getL0() );
-    const Real rr( r - getrsink() ) ;
-
-    // If there was no time change or zero diffusivity => no flux
-    if (t == 0 || D == 0)
-    {
-	    return 0.0;
-    }
-    
-    /* If r is on the right side of the sink, use right the solution for the right domain.
-       Otherwise, use the solution for the left domain. */
-    if( rr >= 0 )
-    {
-        /* Check if r is left or right of the starting position r0.
-           If so, interchange r with r0. */
-        if( rr < L0 )
-        {
-            const Real temp( L0 );
-            rr = L0;
-            L0 = temp;
-        }    
-
-        do
-        {   
-	        if ( n >= MAX_TERMS )
-	        {
-	            std::cerr << " Too many terms needed for GF1DSink::diff_prob_r. N: "
-	              << n << std::endl;
-	            break;
-	        }
-	        term_prev = term_n;
-
-	        root_n = root_n(n);
-
-            numerator =  k * sin( root_n * Ll ) * sin( root_n * L0 ) + root_n * D * sin( root_n * (Ll + L0) );
-            numerator *= root_n * cos( root_n * (Lr - rr) );       
-                
-            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
-                
-    	    sum += term_n;
-
-    	    n++;
-       }
-       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
-	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	           n <= MIN_TERMS );
-	}
-    else
-    {
-        do
-        {   
-	        if ( n >= MAX_TERMS )
-	        {
-	            std::cerr << " Too many terms needed for GF1DSink::diff_prob_r. N: "
-	              << n << std::endl;
-	            break;
-	        }
-	        term_prev = term_n;
-
-	        root_n = root_n(n);
-
-            numerator =  - D * gsl_pow_2( root_n ) * cos( root_n * (Ll + rr) ) * sin( root_n * (Lr - L0) ); 
-            
-            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
-               
-    	    sum += term_n;
-
-    	    n++;
-       }
-       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
-	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	           n <= MIN_TERMS );
-    }
-
-    return 2.0 * sum;
-}
-
 // Calculates the probability density of finding the particle at location z at
 // timepoint t, given that the particle is still in the domain.
 Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
@@ -360,7 +271,7 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
     const Real rr( r - getrsink() ) ;
 
     double sum = 0, term = 0, prev_term = 0;
-    int n=1;
+    int n = 1;
     do
     {
         if ( n >= MAX_TERMS )
@@ -386,18 +297,48 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
     return  2.0 * D * sum;
 }
 
-// Calculates the probability flux leaving the domain through the absorbing
-// left boundary at time t
-Real GreensFunction1DAbsSinkAbs::flux_abs_left(Real t) const
+/* Calculates the probability flux leaving the domain through the absorbing
+   boundaries at the left and right side at time t. */
+real_pair GreensFunction1DAbsSinkAbs::flux_abs(Real t) const
 {
-    return - getD() * diff_prob_r(getsigma(), t);
-}
+    const Real D( getD() );
+    const Real k( getk() );    
+    const Real Lr_L0( getLr() - getL0() );
+    const Real LlpL0( getLr() + getL0() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+    Real root_n;
+    
+    Real sum = 0, term = 0, prev_term = 0, prefac = 0;
+    int n = 1;
+    do
+    {
+        if ( n >= MAX_TERMS )
+	    {
+	        std::cerr << " Too many terms needed for GF1DSink::flux_abs. N: "
+	              << n << std::endl;
+	        break;
+	    }
+	    num_prev = num_left;
+    
+        root_n = root_n(n);
+        root_n2 = gsl_pow_2( root_n );        
+        
+        num_left = root_n2 * sin( root_n * ( Lr_L0 ) );
 
-// Calculates the probability flux leaving the domain through the absorbing
-// right boundary at time t
-Real GreensFunction1DAbsSinkAbs::flux_abs_right(Real t) const
-{
-    return - getD() * diff_prob_r(geta(), t);
+        num_right = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
+        
+        prefac = exp( - D * root_n2 * t ) / p_denominator( root_n );
+        
+	    sum_left  += prefac * num_left;
+	    sum_right += prefac * num_right; 
+	    n++;
+    }
+    while ( fabs(term/sum_left) > EPSILON  ||
+	        fabs(term_prev/sum_left) > EPSILON ||
+	        n <= MIN_TERMS );
+
+    return real_pair( 2 * D * D * sum_left,  - D * 2 * root_n * sum_right);
 }
 
 // Calculates the probability flux leaving the domain through the sink
@@ -407,33 +348,9 @@ Real GreensFunction1DAbsSinkAbs::flux_sink(Real t) const
     return getk() * prob_r(getrsink(), t);
 }
 
-// Calculates the flux leaving the domain through the left absorbing boundary as a
-// fraction of the total flux. This is the probability that the particle left
-// the domain through the this boundary.
-Real GGreensFunction1DAbsSinkAbs::fluxRatioAbsLeftTot(Real t) const
-{
-    return flux_abs_left(t)/flux_tot(t);
-}
-
-// Calculates the flux leaving the domain through the left absorbing boundary as a
-// fraction of the total flux. This is the probability that the particle left
-// the domain through the this boundary.
-Real GreensFunction1DAbsSinkAbs::fluxRatioAbsRightTot(Real t) const
-{
-    return flux_abs_right(t)/flux_tot(t);
-}
-
-// Calculates the flux leaving the domain through the sink as a
-// fraction of the total flux. This is the probability that the particle left
-// the domain through the sink.
-Real GreensFunction1DAbsSinkAbs::fluxRatioSinkTot(Real t) const
-{
-    return flux_sink(t)/flux_tot(t);
-}
-
-// Determine which event has occured, an escape or a reaction. Based on the
-// fluxes through the boundaries and the sink at the given time. Beware: if t is not a
-// first passage time you still get an answer!
+/* Determine which event has occured, an escape or a reaction. Based on the
+   fluxes through the boundaries and the sink at the given time. Beware: if t is not a
+   first passage time you still get an answer! */
 GreensFunction1DAbsSinkAbs::EventKind
 GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t )
 const
@@ -460,21 +377,24 @@ const
        (3) Leave through sink - IV_REACTION
     */
     rnd *= flux_tot( t );
-    Real p_accumulate( flux_sink( t ) );
+    //Get fluxes through left and right boundaries.
+    const real_pair flux_abs_left_right( flux_abs( t ) );
+    
+    Real p_accumulate( flux_abs_left_right.first );
     if (rnd < p_accumulate)
     {
-	    return IV_REACTION;
+	    return IV_ESCAPE_L;
     }
     else
     {
-        p_accumulate += flux_abs_right( t );
+        p_accumulate += flux_abs_left_right.second;
         if( rnd < p_accumulate )
         {
 	        return IV_ESCAPE_R;
 	    }
 	    else
 	    {
-	        return IV_ESCAPE_L;
+	        return IV_REACTION;
 	    }
     }
 }
@@ -558,19 +478,15 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     // coefficients should be calculated on demand->TODO or not TODO?
     for (int n=0; n<MAX_TERMS; n++)
     {
-	    root_n = this->root_n(n+1);	// get the n-th root of tan(root*a)=root/-h (Note: root numbering starts at n=1)
-	
-	    root_n2	    = root_n * root_n;
-	    root_n_r0_s = root_n * (r0-sigma);
-	    root_n_L    = root_n * L;
-	    h_root_n    = h / root_n;
-	
-	    if(v==0)	Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
-			          * ( h_root_n + sin(root_n_L) - h_root_n*cos(root_n_L) ); 
-	    else		Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
-			          * (exp_sigmav2D*h*k/D - exp_av2D*(root_n2+h*h)*cos(root_n_L)) / (h_root_n * (root_n2 + v2D*v2D)); 
+	    root_n = root_n( n + 1 );	
+		
+        const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
+        const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+        
+        const Real numerator( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
+	    Xn = numerator / p_denominator( root_n );
 		      
-	    exponent = -D*root_n2 + vexpo_t;
+	    exponent = - D * gsl_pow_2( root_n );
 
 	    // store the coefficients in the structure
 	    parameters.Xn[n] = Xn;
@@ -579,7 +495,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     }
     
     // the prefactor of the sum is also different in case of drift<>0 :
-    parameters.prefactor = 2;
+    parameters.prefactor = 2.0;
     
     // store the random number for the probability
     parameters.rnd = rnd;
@@ -664,46 +580,89 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     return t;
 }
 
-Real GreensFunction1DAbsSinkAbs::drawR_f(Real z, void *p)
+Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
 {
     // casts p to type 'struct drawR_params *'
     struct drawR_params *params = (struct drawR_params *)p;
-    Real v2D 		= params->H[0];	// = v2D = v/(2D)
-    Real costerm 	= params->H[1];	// = k/D
-    Real sinterm 	= params->H[2];	// = h*v2D
-    Real sigma 		= params->H[3];	// = sigma
-    int  terms = params->terms;
-
-    Real expsigma(exp(sigma*v2D));
-    Real zs(z-sigma);
-    
+    int  max_terms = params->terms;
+.    
     Real sum = 0, term = 0, prev_term = 0;
-    Real root_n, S_Cn_root_n;
+    Real root_n, exp_and_denominator;
+    
+    /* Determine in which part of the domain rr lies, and
+       thus which domain function to use. */
+    Real (*numerator_int_f)(Real const&, Real const&, Real const&) = NULL;
+    if( rr <= 0 )
+        numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_leftdomain;
+    else if( rr < L0 )
+            numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA;
+        else
+            numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB;
     
     int n = 0;
     do
     {
-	if ( n >= terms )
-	{
-	    std::cerr << "GF1DRad: Too many terms needed for DrawR. N: "
-	              << n << std::endl;
-	    break;
-	}
-	prev_term = term;
+	    if ( n >= max_terms )
+	    {
+	        std::cerr << "GF1DSink: Too many terms needed for DrawR. N: "
+	                  << n << std::endl;
+	        break;
+	    }
+	    prev_term = term;
 
-	S_Cn_root_n = params->S_Cn_root_n[n];
-	root_n  = params->root_n[n];
-	term = S_Cn_root_n * ( expsigma*costerm - exp(v2D*z)*( costerm*cos(root_n*zs) - (root_n+sinterm/root_n)*sin(root_n*zs) ));
+	    exp_and_denominator = params->exp_and_denominator[n];	    
+	    term = exp_and_denominator * (*numerator_int_f)( rr, t, root_n[n] );
 
-	sum += term;
-	n++;
+	    sum += term;
+	    n++;
     }
     while (fabs(term/sum) > EPSILON*1.0 ||
-	fabs(prev_term/sum) > EPSILON*1.0 ||
-	n <= MIN_TERMS );
+	       fabs(prev_term/sum) > EPSILON*1.0 ||
+           n <= MIN_TERMS );
 
     // Find the intersection with the random number
-    return sum - params->rnd;
+    return params.prefactor * sum - params->rnd;
+}
+
+//Integrated Greens function for rr part of [-Ll, 0]
+inline Real GreensFunction1DAbsSinkAbs::num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const
+{
+    const Real Ll_L0( getLl() - getL0() );
+    const Real Ll_rr( getLl() + rr );
+    
+    return getD() * sin( root_n * Ll_L0 ) * ( cos( root_n * Ll_rr ) - 1 )
+}
+
+//Integrated Greens function for rr part of (0, L0]
+inline Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const
+{
+    const Real Lr_L0( getLr() - getL0() );
+    const Real Ll_rr( getLl() + rr );
+    const Real root_n_rr( root_n * rr );
+    
+    const Real temp( getD() * ( cos( root_n * Ll_rr ) - 1 ) + 
+            getk() / root_n * ( cos( root_n_rr ) - 1 ) * sin( root_n * Ll ) );
+    
+    return sin( root_n * Lr_L0 ) * temp;
+}
+
+//Integrated Greens function for rr part of (L0, Lr]
+inline Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const
+{
+    const Real L( getLr() + getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+    const Real Lr_L0( Lr - L0 );
+    const Real Lr_rr( Lr - rr );
+                   
+    const Real term1( sin( root_n * L ) - sin( root_n * Lr_L0 ) - 
+            sin( root_n * (Ll + L0) ) * cos( root_n * Lr_rr ) );
+            
+    const Real term2( sin( root_n * Lr ) - sin( root_n * Lr_L0 ) -
+            sin( root_n * L0 ) * cos( root_n * Lr_rr ));
+        
+    return getD() * term1 + getk() * sin( root_n * Ll ) * term2 / root_n;
 }
 
 Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
@@ -711,65 +670,44 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
     
-    const Real sigma(this->getsigma());
-    const Real a(this->geta());
-    const Real L(this->geta()-this->getsigma());
-    const Real r0(this->getr0());
-    const Real D(this->getD());
-    const Real v(this->getv());
-    const Real k(this->getk());
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    
+    const Real D( getD() );
+    const Real L( getLr() + getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
 
-    if (t==0.0 || (D==0.0 && v==0.0) )
+    if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
-	// the trivial case
-	//return r0*this->l_scale;	// renormalized version, discontinued
-	return r0;
+	    // the trivial case
+	    return r0;
     }
-    if ( a<0.0 )
+    if ( L < 0.0 )
     {
-	// if the domain had zero size
-	return 0.0;
+	    // if the domain had zero size
+	    return 0.0;
     }
 
-    // the structure to store the numbers to calculate the numbers for 1-S
+    // the structure to store the numbers to calculate r.
     struct drawR_params parameters;
-    double root_n = 0;
-    double S_Cn_root_n;
-    double root_n2, root_n_r0_s;
+    const Real S( p_survival(t) );
+    Real root_n = 0;
 
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D); // exponent of the drift-prefactor, same as in survival prob.
-    const Real v2D(v/2.0/D);
-    const Real v2Dv2D(v2D*v2D);
-    const Real S = 2.0*exp(vexpo)/p_survival(t); 
-
-    assert(p_survival(t) >= 0.0);
+    assert(S >= 0.0);
 
     // produce the coefficients and the terms in the exponent and put them
-    // in the params structure
-    for (int n=0; n<MAX_TERMS; n++)
+    // in the params structure //TODO: MAX_TERM -> CONVERGENCE_TERMS
+    for (int n = 0; n < MAX_TERMS; n++)
     {
-	    root_n = this->root_n(n+1);  // get the n-th root of tan(alfa*a)=alfa/-k
+	    root_n = root_n(n+1);
        	root_n2 = root_n * root_n;
-       	root_n_r0_s = root_n * (r0-sigma);
-       	S_Cn_root_n =	S * exp(-D*root_n2*t)
-	         * (root_n*cos(root_n_r0_s) + h*sin(root_n_r0_s)) / (L*(root_n2 + h*h) + h)
-	         * root_n / (root_n2 + v2Dv2D);
-
-      	// store the coefficients in the structure
+      	// store the roots in the structure
 	    parameters.root_n[n] = root_n;
-        // also store the values for the exponent
-        parameters.S_Cn_root_n[n] = S_Cn_root_n;
+        // also store the exponent and denominator.
+        parameters.exp_and_denominator[n] = exp( - D * root_n2 * t ) / p_denominator( root_n );
+        // and the normalization.
+        parameters.prefactor = 2.0 / S;
     }
     
-    // also store constant prefactors that appear in the calculation of the
-    // r-dependent terms
-    parameters.H[0] = v2D;		// appears together with z in one of the prefactors
-    parameters.H[1] = k/D;		// further constant terms of the cosine prefactor
-    parameters.H[2] = h*v2D;		// further constant terms of the sine prefactor
-    parameters.H[3] = sigma;
-
     // define gsl function for rootfinder
     gsl_function F;
     F.function = &GreensFunction1DRadAbs::drawR_f;
@@ -785,10 +723,11 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     // make a new solver instance
     // TODO: incl typecast?
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-    Real r( findRoot( F, solver, sigma, a, EPSILON*L, EPSILON,
+    Real r( findRoot( F, solver, -Ll, Lr, EPSILON*L, EPSILON,
                             "GreensFunction1DRadAbs::drawR" ) );
 
-    // return the drawn position
+    // Convert the position to 'world' coordinates and return it.
+    
     return r;
 }
 
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 75396e13..c2e2730c 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -40,6 +40,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     static const int MIN_TERMS = 20;
 
 public:
+    typedef std::pair(Real, Real) real_pair;
+
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
 	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
@@ -197,35 +199,35 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    Real h;
     };
 
-    static double root_f (double x, void *p);
+    static Real root_f (Real x, void *p);
     // this is the appropriate definition of the function in gsl
 
     struct drawT_params
     {
-	    double exponent[MAX_TERMS];
-	    double Xn[MAX_TERMS];
-	    double prefactor;
+	    Real exponent[MAX_TERMS];
+	    Real Xn[MAX_TERMS];
+	    Real prefactor;
 	    int    terms;
 	    // the timescale used for convergence
 	    Real   tscale;
 	    // the random number associated with the time
-	    double rnd;
+	    Real rnd;
     };
 
-    static double drawT_f (double t, void *p);
+    static Real drawT_f (Real t, void *p);
 
     struct drawR_params
     {
-	    double root_n[MAX_TERMS];
-	    double S_Cn_root_n[MAX_TERMS];
+	    Real root_n[MAX_TERMS];
+	    Real exp_and_denominator[MAX_TERMS];
 	    // variables H: for additional terms appearing as multiplicative factors etc.
-	    double H[5];
+	    Real prefactor;
 	    int terms;
 	    // the random number associated with the time
-	    double rnd;
+	    Real rnd;
     };
 
-    static double drawR_f (double z, void *p);
+    static Real drawR_f (Real z, void *p);
 
     // The diffusion constant and drift velocity
     const Real v;

From 6231886e39e5117f602234a500aed4230c1834b4 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 18 Nov 2011 19:01:52 +0100
Subject: [PATCH 0384/1541] Included GFAbsSinkAbs into Makefile. Updated GF hpp
 file.

---
 GreensFunction1DAbsSinkAbs.cpp |   2 +-
 GreensFunction1DAbsSinkAbs.hpp | 128 ++++++++++++++++++++++++---------
 Makefile.am                    |   2 +
 3 files changed, 96 insertions(+), 36 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 6dbfce3f..0526da1c 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -76,7 +76,7 @@ Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
                             "GreensFunction1DAbsSinkAbs::root_f" ) );
     gsl_root_fsolver_free( solver );
     
-    return root/Lp;
+    return root/L;
 }
 
 /* Denominator of the greensfunction. */
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index c2e2730c..ad3faa1b 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -45,15 +45,41 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
 	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
-	// do nothing
+	    /* Set variables which define a domain with the sink at the origin. 
+	       Futhermore r0 is assumed to be ringht from the sink. */
+	    ASSERT( a > sigma );
+	    
+	    L0 = fabs( r0 - rsink ); 
+	    if( r0 >= rsink )
+	    {
+	        Lr = a - rsink; 
+	        Ll = rsink - sigma;	        
+	    }
+	    else
+	    {
+	        Lr = rsink - sigma; 
+	        Ll = a - rsink;
+	    }
     }
 
-    // The constructor is overloaded and can be called with or without drift v
-    // copy constructor including drift variable v
+    /* The constructor is overloaded and can be called with or without drift v
+       copy constructor including drift variable v */
     GreensFunction1DAbsSinkAbs(Real D, Real v, Real k, Real r0, Real rsink, Real sigma, Real a)
-	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), L(a - sigma), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
+	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), rsink(a - sigma), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
-	// do nothing
+		ASSERT( a > sigma );
+	    
+	    L0 = fabs( r0 - rsink ); 
+	    if( r0 >= rsink )
+	    {
+	        Lr = a - rsink; 
+	        Ll = rsink - sigma;	        
+	    }
+	    else
+	    {
+	        Lr = rsink - sigma; 
+	        Ll = a - rsink;
+	    }
     }
 
     ~GreensFunction1DAbsSinkAbs()
@@ -63,9 +89,24 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 
     Real geta() const
     {
-	    return this->a;
+	    return a;
     }
     
+    Real getLr() const
+    {
+	    return Lr;
+    }
+    
+    Real getLl() const
+    {
+	    return Ll;
+    }
+    
+    Real getL0() const
+    {
+	    return L0;
+    }
+
     Real getrsink() const
     {
 	    return rsink;
@@ -73,7 +114,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     
     Real getsigma() const
     {
-	    return this->sigma;
+	    return sigma;
     }
 
     Real getr0() const
@@ -91,7 +132,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    return v;
     }
     
-    // This also sets the scale
+    // TODO: ask Tomek for their function.
     void seta(Real a)
     {
 	    THROW_UNLESS( std::invalid_argument, (a-this->sigma) >= 0.0 && this->r0 <= a);
@@ -133,28 +174,27 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    }
     }
 
-    // Calculates the probability density of finding the particle at 
-    // location z at timepoint t, given that the particle is still in the 
-    // domain.
+    /* Calculates the probability density of finding the particle at 
+       location z at timepoint t, given that the particle is still in the 
+       domain. */
     Real calcpcum (Real r, Real t) const;
 
-    // Determine which event has occured, an escape or a reaction. Based 
-    // on the fluxes through the boundaries at the given time. Beware: if 
-    // t is not a first passage time you still get an answer!
+    /* Determine which event has occured at time t. Either an escape 
+       (left or right boundary) or a reaction with the sink. 
+       Based on the fluxes through the boundaries at the given time. */
     EventKind drawEventType( Real rnd, Real t ) const;
 
-    // Draws the first passage time from the propensity function
+    /* Draws the first passage time from the propensity function */
     Real drawTime (Real rnd) const;
 
-    // Draws the position of the particle at a given time, assuming that 
-    // the particle is still in the domain
+    /* Draws the position of the particle at a given time, assuming that 
+       the particle is still in the domain. */
     Real drawR (Real rnd, Real t) const;
 
 
-// These methods are both public and private, they are used by public methods 
-// but can also be called from the 'outside'. This is mainly because of 
-// debugging purposes.
-
+    // These methods are both public and private, they are used by public methods 
+    // but can also be called from the 'outside'. This is mainly because of 
+    // debugging purposes.
 
     // Calculates the probability of finding the particle inside the 
     // domain at time t -> the survival probability
@@ -164,14 +204,12 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     Real flux_tot (Real t) const;
 
     // Calculates the probability flux leaving the domain through the 
-    // radiative boundary at time t
-    Real flux_rad (Real t) const;
-
-    // Calculates the flux leaving the domain through the radiative 
-    // boundary as a fraction of the total flux. This is the probability 
-    // that the particle left the domain through the radiative
-    // boundary instead of the absorbing boundary.
-    Real fluxRatioRadTot (Real t) const;
+    // absorbing boundaries at time t.
+    real_pair flux_abs (Real t) const;
+    
+    // Calculates the probability flux leaving the domain through the 
+    // sink at time t.
+    flux_sink(Real t) const
 
     // Calculates the probability density of finding the particle at 
     // location r at time t.
@@ -192,15 +230,25 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     Real root_n(int n) const;
     
 private:
+   
+    Real p_denominator( Real const& root_n );
+    
+    inline Real num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const;
 
+    inline Real num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const;
+
+    inline Real num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const;
+
+
+    static Real root_f (Real x, void *p);
+    
     struct root_f_params
     {
 	    Real Lm_L;
 	    Real h;
     };
 
-    static Real root_f (Real x, void *p);
-    // this is the appropriate definition of the function in gsl
+    static Real drawT_f (Real t, void *p);
 
     struct drawT_params
     {
@@ -214,8 +262,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    Real rnd;
     };
 
-    static Real drawT_f (Real t, void *p);
-
+    static Real drawR_f (Real z, void *p);
+    
     struct drawR_params
     {
 	    Real root_n[MAX_TERMS];
@@ -227,8 +275,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    Real rnd;
     };
 
-    static Real drawR_f (Real z, void *p);
-
+    /* Class variables */
     // The diffusion constant and drift velocity
     const Real v;
     // The reaction constant
@@ -244,5 +291,16 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     Real l_scale;
     // This is the time scale of the system.
     Real t_scale;
+    
+    /* Greensfunction assumes that the sink is at the origin, and
+       consists of two sub-domains: one between a boundary and the sink including
+       r0, and one between boundary and sink not inlcuding r0. */
+
+    // Length of sub-domain which does not include r0.
+    Real Lr;
+    // Length of sub-domain which does include r0.
+    Real Ll;
+    // Distance between the sink and r0.
+    Real L0;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP
diff --git a/Makefile.am b/Makefile.am
index cf32ab0e..55f84d22 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -66,6 +66,7 @@ noinst_HEADERS = \
 	findRoot.hpp\
 	GreensFunction1DRadAbs.hpp\
 	GreensFunction1DAbsAbs.hpp\
+	GreensFunction1DAbsSinkAbs.hpp\
 	GreensFunction2DAbsSym.hpp\
 	GreensFunction2DRadAbs.hpp\
 	GreensFunction3DAbsSym.hpp\
@@ -198,6 +199,7 @@ _greens_functions_la_SOURCES=\
 	freeFunctions.cpp\
 	GreensFunction1DAbsAbs.cpp\
 	GreensFunction1DRadAbs.cpp\
+	GreensFunction1DAbsSinkAbs.cpp \
 	GreensFunction2DAbsSym.cpp\
 	GreensFunction2DRadAbs.cpp\
 	GreensFunction3DSym.cpp\

From b7a003c14697d725ec92eabf116e92ff1b9c70e0 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 18 Nov 2011 19:42:39 +0100
Subject: [PATCH 0385/1541] Undoing compile errors.

---
 GreensFunction1DAbsSinkAbs.cpp |  3 +--
 GreensFunction1DAbsSinkAbs.hpp | 17 ++++++++--------
 greens_functions.cpp           | 37 +++++++++++++++++-----------------
 3 files changed, 29 insertions(+), 28 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 0526da1c..33a664f2 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -3,6 +3,7 @@
 #include <cstdlib>
 #include <exception>
 #include <vector>
+#include <math.h>
 
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_sf_trig.h>
@@ -13,8 +14,6 @@
 #include <gsl/gsl_sf_elljac.h>
 #include <gsl/gsl_roots.h>
 
-#include <math.h>
-
 #include "findRoot.hpp"
 #include "GreensFunction1DAbsSinkAbs.hpp"
 
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index ad3faa1b..65dd8b04 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -40,14 +40,14 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     static const int MIN_TERMS = 20;
 
 public:
-    typedef std::pair(Real, Real) real_pair;
+    typedef std::pair<Real, Real> real_pair;
 
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
 	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
 	    /* Set variables which define a domain with the sink at the origin. 
 	       Futhermore r0 is assumed to be ringht from the sink. */
-	    ASSERT( a > sigma );
+	    assert( a > sigma );
 	    
 	    L0 = fabs( r0 - rsink ); 
 	    if( r0 >= rsink )
@@ -67,7 +67,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     GreensFunction1DAbsSinkAbs(Real D, Real v, Real k, Real r0, Real rsink, Real sigma, Real a)
 	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), rsink(a - sigma), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
-		ASSERT( a > sigma );
+		assert( a > sigma );
 	    
 	    L0 = fabs( r0 - rsink ); 
 	    if( r0 >= rsink )
@@ -132,7 +132,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    return v;
     }
     
-    // TODO: ask Tomek for their function.
+    /* TODO: ask Tomek for their function.
     void seta(Real a)
     {
 	    THROW_UNLESS( std::invalid_argument, (a-this->sigma) >= 0.0 && this->r0 <= a);
@@ -173,7 +173,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	        this->r0 = r0;
 	    }
     }
-
+    */
+    
     /* Calculates the probability density of finding the particle at 
        location z at timepoint t, given that the particle is still in the 
        domain. */
@@ -203,17 +204,17 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     // Calculates the total probability flux leaving the domain at time t
     Real flux_tot (Real t) const;
 
-    // Calculates the probability flux leaving the domain through the 
+    // Calculates the probability flux leaving the domain through both 
     // absorbing boundaries at time t.
     real_pair flux_abs (Real t) const;
     
     // Calculates the probability flux leaving the domain through the 
     // sink at time t.
-    flux_sink(Real t) const
+    Real flux_sink(Real t) const;
 
     // Calculates the probability density of finding the particle at 
     // location r at time t.
-    Real prob_r (Real r, Real t) const;
+    Real prob_r(Real r, Real t) const;
     
 // End of public/private mix methods
 
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 5418605b..2726b92e 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -82,27 +82,28 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "dump", &GreensFunction1DRadAbs::dump )
         ;
         
-    class_<GreensFunction1DRadAbs>("GreensFunction1DRadAbs",
+    class_<GreensFunction1DAbsSinkAbs>("GreensFunction1DAbsSinkAbs",
                                    init<Real, Real, Real, Real, Real, Real>() )
         .def( init<Real, Real, Real, Real, Real, Real, Real>())
         .def( "getName", &GreensFunction1DRadAbs::getName )
-        .def( "getk", &GreensFunction1DRadAbs::getk )
-        .def( "getD", &GreensFunction1DRadAbs::getD )
-        .def( "getv", &GreensFunction1DRadAbs::getv )
-        .def( "getsigma", &GreensFunction1DRadAbs::getsigma )
-        .def( "seta", &GreensFunction1DRadAbs::seta )
-        .def( "geta", &GreensFunction1DRadAbs::geta )
-        .def( "setr0", &GreensFunction1DRadAbs::setr0 )
-        .def( "getr0", &GreensFunction1DRadAbs::getr0 )
-        .def( "drawTime", &GreensFunction1DRadAbs::drawTime )
-        .def( "drawR", &GreensFunction1DRadAbs::drawR )
-        .def( "drawEventType", &GreensFunction1DRadAbs::drawEventType )
-        .def( "flux_tot", &GreensFunction1DRadAbs::flux_tot )
-        .def( "flux_rad", &GreensFunction1DRadAbs::flux_rad )
-        .def( "fluxRatioRadTot", &GreensFunction1DRadAbs::fluxRatioRadTot )
-        .def( "p_survival", &GreensFunction1DRadAbs::p_survival )
-        .def( "calcpcum", &GreensFunction1DRadAbs::calcpcum )
-        .def( "dump", &GreensFunction1DRadAbs::dump )
+        .def( "getk", &GreensFunction1DAbsSinkAbs::getk )
+        .def( "getD", &GreensFunction1DAbsSinkAbs::getD )
+        .def( "getv", &GreensFunction1DAbsSinkAbs::getv )
+        .def( "getsigma", &GreensFunction1DAbsSinkAbs::getsigma )
+        .def( "seta", &GreensFunction1DAbsSinkAbs::seta )
+        .def( "geta", &GreensFunction1DAbsSinkAbs::geta )
+        .def( "setr0", &GreensFunction1DAbsSinkAbs::setr0 )
+        .def( "getr0", &GreensFunction1DAbsSinkAbs::getr0 )
+        .def( "getrsink", &GreensFunction1DAbsSinkAbs::getrsink )
+        .def( "drawTime", &GreensFunction1DAbsSinkAbs::drawTime )
+        .def( "drawR", &GreensFunction1DAbsSinkAbs::drawR )
+        .def( "drawEventType", &GreensFunction1DAbsSinkAbs::drawEventType )
+        .def( "flux_tot", &GreensFunction1DAbsSinkAbs::flux_tot )
+        .def( "flux_rad", &GreensFunction1DAbsSinkAbs::flux_rad )
+        .def( "flux_sink", &GreensFunction1DAbsSinkAbs::flux_sink )
+        .def( "p_survival", &GreensFunction1DAbsSinkAbs::p_survival )
+        .def( "calcpcum", &GreensFunction1DAbsSinkAbs::calcpcum )
+        .def( "dump", &GreensFunction1DAbsSinkAbs::dump )
         ;
 
     class_<GreensFunction2DAbsSym>( "GreensFunction2DAbsSym",

From b38960b27bccfecc82f7bc3810171ef94fc251b2 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Sun, 20 Nov 2011 18:54:12 +0100
Subject: [PATCH 0386/1541] Implemented new ESCAPE event sampler leavea/leaves.
 Continued debugging new Greensfunction...

---
 GreensFunction1DAbsSinkAbs.cpp | 421 ++++++++++++++++++---------------
 GreensFunction1DAbsSinkAbs.hpp |  95 +++-----
 greens_functions.cpp           |   7 +-
 3 files changed, 268 insertions(+), 255 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 33a664f2..1aa37f5b 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -55,7 +55,7 @@ Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
     else
     {
         //TODO: more complicated scheme needed.
-        THROW( h > 1 )
+        assert( h > 1 );
     }
 
     gsl_function F;
@@ -78,24 +78,27 @@ Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
     return root/L;
 }
 
+/* Standart form of the greensfunction */
+inline Real GreensFunction1DAbsSinkAbs::Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const
+{
+    return exp( - getD() * root_n2 * t ) / p_denominator( root_n );
+}
+
 /* Denominator of the greensfunction. */
-Real GreensFunction1DAbsSinkAbs::p_denominator(Real const& root_n) const
+inline Real GreensFunction1DAbsSinkAbs::p_denominator(Real const& root_n) const
 {
-    const Real D( getD() );
-    const Real k( getk() );    
     const Real Lm( getLr() - getLl() );
     const Real L( getLr() + getLl() );
     
-    const Real term1( root_n * L * cos( root_n * L ) + sin( root_n * L );
-    const Real term2( L * sin( root_n * L ) + Lm * sin( root_n * L );
-    
-    return D * term1 + k / 2. * term2;
+    const Real term1( root_n * L * cos( root_n * L ) + sin( root_n * L ) );
+    const Real term2( L * sin( root_n * L ) + Lm * sin( root_n * L ) );
+ 
+    return getD() * term1 + getk() / 2. * term2;
 }
 
-
-// Calculates the probability of finding the particle inside the domain
-// at time t, the survival probability.
-Real GreensFunction1DAbsSinkAbs::p_survival(Real const& t) const
+/* Calculates the probability of finding the particle inside the domain
+   at time t, the survival probability. */
+Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
   
@@ -112,8 +115,8 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real const& t) const
 	    return 1.0;
     }
 
-    Real root_n;
-    Real sum = 0, num = 0, num_prev = 0;
+    Real sum = 0, numerator = 0, num_prev = 0;
+    Real term1, term2, root_n;
     int n = 1;
     do
     {
@@ -123,18 +126,18 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real const& t) const
 	              << n << std::endl;
 	        break;
 	    }
-	    num_prev = num;
+	    num_prev = numerator;
     
         root_n = root_n(n);
-        const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
-        const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+        term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
+        term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
         
-        num = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
-	    sum += exp( - D * gsl_pow_2( root_n ) * t ) * num / p_denominator( root_n );
+        numerator = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
+	    sum += Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
 	    n++;
     }
-    while ( fabs(term/sum) > EPSILON  ||
-	        fabs(term_prev/sum) > EPSILON ||
+    while ( fabs(term_n/sum) > EPSILON  ||
+	        fabs(prev_term/sum) > EPSILON ||
 	        n <= MIN_TERMS );
 
     return 2.0 * sum;
@@ -150,12 +153,17 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     
     const Real D( getD() );
     const Real k( getk() ); 
-    const Real L( getLr() + getLl() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     Real L0( getL0() );
     Real rr( r - getrsink() ) ;
 
+    const Real L( getLr() + getLl() );
+    const Real LlpL0( Ll + L0 );
+    const Real LrmL0( Lr - L0 );
+    const Real Lrmrr( Lr - Lr );
+    const Real Llprr( Ll + rr );
+
     // if there was no time change or zero diffusivity => no movement
     if (t == 0 || D == 0)
     {
@@ -180,10 +188,13 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     Real sum = 0, term_n = 0, prev_term = 0, numerator = 0;
     int n = 1;
            
-    /* If r is on the right side of the sink, use right the solution for the right domain.
-       Otherwise, use the solution for the left domain. */
-    if( rr >= 0 )
+    /* Determine wether rr lies in the same sub-domain as r0.
+       A different function is caculated when this is the case. */
+    if( rr * ( getr0() - getrsink() ) >= 0 )
     {
+        if(rr < 0)
+            rr *= -1;
+
         /* Check if r is left or right of the starting position r0.
            If so, interchange r with r0. */
         if( rr < L0 )
@@ -198,49 +209,49 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 	        if ( n >= MAX_TERMS )
 	        {
 	            std::cerr << " Too many terms needed for GF1DSink::prob_r. N: "
-	              << n << std::endl;
+                          << n << std::endl;
 	            break;
 	        }
-	        term_prev = term_n;
+	        prev_term = term_n;
 
 	        root_n = root_n(n);
 
-            numerator =  D * root_n * sin( root_n * (Ll + L0) ) + k * sin( root_n * Ll ) * sin( root_n * x0);
-            numerator *= sin( root_n * (Lr - rr) );       
-                
-            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
-                
-    	    sum += term_n;
+            numerator =  D * root_n * sin( root_n * LlpL0 ) + k * sin( root_n * Ll ) * sin( root_n * L0);
+            numerator *= sin( root_n * Lrmrr );       
+            term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+            sum += term_n;
 
     	    n++;
        }
-       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
+       while ( fabs(term_n/sum) > EPSILON*PDENS_TYPICAL || 
 	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
 	           n <= MIN_TERMS );
 	}
     else
     {
+        if( rr > 0 )
+            rr *= -1;
+
         do
         {   
 	        if ( n >= MAX_TERMS )
 	        {
 	            std::cerr << " Too many terms needed for GF1DSink::prob_r. N: "
-	              << n << std::endl;
+                          << n << std::endl;
 	            break;
 	        }
-	        term_prev = term_n;
+	        prev_term = term_n;
 
 	        root_n = root_n(n);
 
-            numerator =  D * root_n * sin( root_n * (Ll + rr) ) * sin( root_n * (Lr - L0) ); 
-            
-            term_n = exp( - D * gsl_pow_2( root_n ) * t ) * numerator / p_denominator( root_n );
-               
-    	    sum += term_n;
+            numerator =  D * root_n * sin( root_n * (Llprr) ) * sin( root_n * (LrmL0) ); 
+            term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
 
+            sum += term_n;
+            
     	    n++;
        }
-       while ( fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
+       while ( fabs(term_n/sum) > EPSILON*PDENS_TYPICAL || 
 	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
 	           n <= MIN_TERMS );
     }
@@ -248,119 +259,173 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     return - 2.0 * sum;
 }
 
-// Calculates the probability density of finding the particle at location z at
-// timepoint t, given that the particle is still in the domain.
+/* Calculates the probability density of finding the particle at location z at
+   timepoint t, given that the particle is still in the domain. */
 Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
 {
     return prob_r(r, t)/p_survival(t);
 }
 
-// Calculates the total probability flux leaving the domain at time t
-// This is simply the negative of the time derivative of the survival prob.
-// at time t [-dS(t')/dt' for t'=t].
+/* Function returns flux at absorbing bounday sigma. */
+Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
+{
+    if( getr0() > getrsink() )
+        return flux_abs_Ll( t );
+    else
+        return flux_abs_Lr( t );
+}
+
+/* Function returns flux at absorbing bounday a. */
+Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
+{
+    if( getr0() < getrsink() )
+        return flux_abs_Ll( t );
+    else
+        return flux_abs_Lr( t );
+}
+
+/* Calculates the total probability flux leaving the domain at time t
+   This is simply the negative of the time derivative of the survival prob.
+   at time t [-dS(t')/dt' for t'=t]. */
 Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 {
-    Real root_n;
     const Real D( getD() );
     const Real k( getk() ); 
-    const Real L( getLr() + getLl() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
-    const Real rr( r - getrsink() ) ;
 
-    double sum = 0, term = 0, prev_term = 0;
+    const Real L( Lr + Ll );
+    const Real LlpL0( Ll + L0 );
+    const Real LrmL0( Lr - L0 );
+
+    Real sum = 0, term_n = 0, prev_term = 0;
+    Real root_n, root_n2, term1, term2, numerator;
     int n = 1;
     do
     {
         if ( n >= MAX_TERMS )
-	    {
-	        std::cerr << " Too many terms needed for GF1DSink::flux_tot. N: "
-	              << n << std::endl;
-	        break;
-	    }
-	    num_prev = num;
+        {
+            std::cerr << " Too many terms needed for GF1DSink::flux_tot. N: "
+                      << n << std::endl;
+            break;
+        }
+        prev_term = term_n;
     
         root_n = root_n(n);
-        const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
-        const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+        root_n2 = gsl_pow_2( root_n );
+
+        term1 = sin( root_n * L ) - sin( root_n * LrmL0 ) - sin( root_n * LlpL0 );
+        term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * LrmL0 );
         
-        num = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
-	    sum += gsl_pow_2( root_n ) * exp( - D * gsl_pow_2( root_n ) * t ) * num / p_denominator( root_n );
-	    n++;
+        numerator = D * term1 + k * sin( root_n * Ll ) * term2 / root_n;
+
+        term_n = root_n2 * Greens_fn(t, root_n, root_n2) * numerator;
+        sum += term_n;
+
+        n++;
     }
-    while ( fabs(term/sum) > EPSILON  ||
-	        fabs(term_prev/sum) > EPSILON ||
+    while ( fabs(term_n/sum) > EPSILON  ||
+	        fabs(prev_term/sum) > EPSILON ||
 	        n <= MIN_TERMS );
 
     return  2.0 * D * sum;
 }
 
-/* Calculates the probability flux leaving the domain through the absorbing
-   boundaries at the left and right side at time t. */
-real_pair GreensFunction1DAbsSinkAbs::flux_abs(Real t) const
+/* Flux leaving throught absorbing boundary from sub-domain containing r0. */
+Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
 {
     const Real D( getD() );
     const Real k( getk() );    
-    const Real Lr_L0( getLr() - getL0() );
     const Real LlpL0( getLr() + getL0() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
     Real root_n;
     
-    Real sum = 0, term = 0, prev_term = 0, prefac = 0;
+    Real sum = 0, numerator, term_n = 0, prev_term = 0;
     int n = 1;
     do
     {
         if ( n >= MAX_TERMS )
-	    {
-	        std::cerr << " Too many terms needed for GF1DSink::flux_abs. N: "
-	              << n << std::endl;
-	        break;
-	    }
-	    num_prev = num_left;
+        {
+            std::cerr << " Too many terms needed for GF1DSink::flux_abs. N: "
+                      << n << std::endl;
+            break;
+        }
+        prev_term = term_n;
     
         root_n = root_n(n);
-        root_n2 = gsl_pow_2( root_n );        
-        
-        num_left = root_n2 * sin( root_n * ( Lr_L0 ) );
-
-        num_right = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
         
-        prefac = exp( - D * root_n2 * t ) / p_denominator( root_n );
+        numerator = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
         
-	    sum_left  += prefac * num_left;
-	    sum_right += prefac * num_right; 
-	    n++;
+        term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;         
+        sum += term_n;
+
+        n++;
     }
-    while ( fabs(term/sum_left) > EPSILON  ||
-	        fabs(term_prev/sum_left) > EPSILON ||
-	        n <= MIN_TERMS );
+    while ( fabs(term_n/sum) > EPSILON  ||
+            fabs(prev_term/sum) > EPSILON ||
+            n <= MIN_TERMS );
 
-    return real_pair( 2 * D * D * sum_left,  - D * 2 * root_n * sum_right);
+    return - D * 2 * root_n * sum;
 }
 
-// Calculates the probability flux leaving the domain through the sink
-// at time t
+/* Flux leaving throught absorbing boundary from sub-domain not containing r0. */
+Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
+{
+    const Real D2( gsl_pow_2( getD() ) );
+    const Real LrmL0( getLr() - getL0() );
+
+    Real root_n, root_n2;
+    
+    Real sum = 0, numerator = 0, term_n = 0, prev_term = 0;
+    int n = 1;
+    do
+    {
+        if ( n >= MAX_TERMS )
+        {
+            std::cerr << " Too many terms needed for GF1DSink::flux_abs. N: "
+                      << n << std::endl;
+            break;
+        }
+        prev_term = numerator;
+    
+        root_n = root_n(n);
+        root_n2 = gsl_pow_2( root_n );        
+        
+        numerator = root_n2 * sin( root_n * ( LrmL0 ) );
+
+        term_n = Greens_fn(t, root_n, root_n2 ) * numerator;
+        sum += term_n;
+
+        n++;
+    }
+    while ( fabs(term/sum) > EPSILON  ||
+            fabs(prev_term/sum) > EPSILON ||
+            n <= MIN_TERMS );
+    
+    return 2 * D2 * sum;
+}
+
+/* Calculates the probability flux leaving the domain through the sink
+   at time t */
 Real GreensFunction1DAbsSinkAbs::flux_sink(Real t) const
 {
     return getk() * prob_r(getrsink(), t);
 }
 
 /* Determine which event has occured, an escape or a reaction. Based on the
-   fluxes through the boundaries and the sink at the given time. Beware: if t is not a
-   first passage time you still get an answer! */
-GreensFunction1DAbsSinkAbs::EventKind
-GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t )
-const
+   fluxes through the boundaries and the sink at the given time. */
+GreensFunction1DAbsSinkAbs::EventKind 
+GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
 {
     THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
     THROW_UNLESS( std::invalid_argument, t > 0.0 );
-    // if t=0 nothing has happened => no event
 
-    const Real  a( geta() );
-    const Real  L( geta() - getsigma() );
+    const Real a( geta() );
+    const Real sigma( getsigma() );
     const Real r0( getr0() );
+    const Real L( a - sigma );
 
     // if the radiative boundary is impermeable (k==0) or
     // the particle is at one the absorbing boundary (sigma or a) => IV_ESCAPE event
@@ -370,36 +435,24 @@ const
     }
 
     /* The event is sampled from the flux ratios.
-       Three possiblities:
-       (1) Leave through left  boundary - IV_ESCAPE_L
-       (2) Leave through right boundary - IV_ESCAPE_R
-       (3) Leave through sink - IV_REACTION
+       Two possiblities:
+       (1) Leave through left or right boundary - IV_ESCAPE
+       (2) Leave through sink - IV_REACTION
     */
     rnd *= flux_tot( t );
-    //Get fluxes through left and right boundaries.
-    const real_pair flux_abs_left_right( flux_abs( t ) );
-    
-    Real p_accumulate( flux_abs_left_right.first );
-    if (rnd < p_accumulate)
+    const Real p_sink( flux_sink( t ) );
+    if (rnd < p_sink)
     {
-	    return IV_ESCAPE_L;
+      return IV_REACTION;
     }
     else
     {
-        p_accumulate += flux_abs_left_right.second;
-        if( rnd < p_accumulate )
-        {
-	        return IV_ESCAPE_R;
-	    }
-	    else
-	    {
-	        return IV_REACTION;
-	    }
+      return IV_ESCAPE;
     }
 }
 
-// This function is needed to cast the math. form of the function
-// into the form needed by the GSL root solver.
+/* This function is needed to cast the math. form of the function
+   into the form needed by the GSL root solver. */
 Real GreensFunction1DAbsSinkAbs::drawT_f (Real t, void *p)
 {
     // casts p to type 'struct drawT_params *'
@@ -412,24 +465,24 @@ Real GreensFunction1DAbsSinkAbs::drawT_f (Real t, void *p)
     int n = 0;
     do
     {
-	    if ( n >= terms )
-	    {
-	        std::cerr << "Too many terms needed for GF1DSink::DrawTime. N: "
-	                  << n << ", conv arg: " << exponent * t <<  std::endl;
-	        break;
-	    }
-	    prev_term = term;
-
-	    Xn = params->Xn[n];
-	    exponent = params->exponent[n];
-	    term = Xn * exp(exponent * t);
-
-	    sum += term;
-	    n++;
+        if ( n >= terms )
+        {
+            std::cerr << "Too many terms needed for GF1DSink::DrawTime. N: "
+                      << n << ", conv arg: " << exponent * t <<  std::endl;
+            break;
+        }
+        prev_term = term;
+        
+        Xn = params->Xn[n];
+        exponent = params->exponent[n];
+        term = Xn * exp(exponent * t);
+	
+        sum += term;
+        n++;
     }
     while (fabs(term/sum) > EPSILON*1.0 ||
            fabs(prev_term/sum) > EPSILON*1.0 ||
-	       n <= MIN_TERMS );
+           n <= MIN_TERMS );
 
     // find the intersection with the random number
     return 1.0 - prefactor*sum - params->rnd;
@@ -442,18 +495,16 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
   
-    const Real sigma( getsigma() );
     const Real a( geta() );    
     const Real r0( getr0() );
     const Real D( getD() );
     const Real k( getk() ); 
-    const Real L( getLr() + getLl() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
-    const Real rr( r - getrsink() ) ;
+    const Real L( getLr() + getLl() );
 
-    Real root_n;    
+    Real root_n, Xn, exponent;
 
     if ( D == 0.0 || L == INFINITY )
     {
@@ -468,29 +519,26 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     // the structure to store the numbers to calculate the numbers for 1-S
     struct drawT_params parameters;
     // some temporary variables
-    double root_n = 0;
-    double root_n2, root_n_r0_s, root_n_L, h_root_n;
-    double Xn, exponent, prefactor;
 
     // produce the coefficients and the terms in the exponent and put them
     // in the params structure. This is not very efficient at this point,
     // coefficients should be calculated on demand->TODO or not TODO?
     for (int n=0; n<MAX_TERMS; n++)
     {
-	    root_n = root_n( n + 1 );	
-		
+        root_n = root_n( n + 1 );	
+	    
         const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
         const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
         
         const Real numerator( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
-	    Xn = numerator / p_denominator( root_n );
+        Xn = numerator / p_denominator( root_n );
 		      
-	    exponent = - D * gsl_pow_2( root_n );
+        exponent = - D * gsl_pow_2( root_n );
 
-	    // store the coefficients in the structure
-	    parameters.Xn[n] = Xn;
+        // store the coefficients in the structure
+        parameters.Xn[n] = Xn;
 	    // also store the values for the exponent
-	    parameters.exponent[n] = exponent;
+        parameters.exponent[n] = exponent;
     }
     
     // the prefactor of the sum is also different in case of drift<>0 :
@@ -522,26 +570,26 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     // scale the interval around the guess such that the function straddles
     if( value < 0.0 )
     {
-	    // if the guess was too low
-	    do
-	    {
-	        // keep increasing the upper boundary until the
-	        // function straddles
-	        high *= 10;
-	        value = GSL_FN_EVAL( &F, high );
-
-	        if( fabs( high ) >= t_guess * 1e6 )
-	        {
-		    std::cerr << "GF1DSink::drawTime Couldn't adjust high. F("
-		              << high << ") = " << value << std::endl;
-		    throw std::exception();
-	        }
-	    }
-	    while ( value <= 0.0 );
+        // if the guess was too low
+        do
+        {
+            // keep increasing the upper boundary until the
+            // function straddles
+            high *= 10;
+            value = GSL_FN_EVAL( &F, high );
+            
+            if( fabs( high ) >= t_guess * 1e6 )
+            {
+                std::cerr << "GF1DSink::drawTime Couldn't adjust high. F("
+                          << high << ") = " << value << std::endl;
+                throw std::exception();
+            }
+        }
+        while ( value <= 0.0 );
     }
     else
     {
-	    // if the guess was too high
+        // if the guess was too high
 	    // initialize with 2 so the test below survives the first
 	    // iteration
 	    Real value_prev( 2 );
@@ -584,13 +632,13 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
     // casts p to type 'struct drawR_params *'
     struct drawR_params *params = (struct drawR_params *)p;
     int  max_terms = params->terms;
-.    
-    Real sum = 0, term = 0, prev_term = 0;
+    
+    Real sum = 0, term_n = 0, prev_term = 0;
     Real root_n, exp_and_denominator;
     
     /* Determine in which part of the domain rr lies, and
        thus which domain function to use. */
-    Real (*numerator_int_f)(Real const&, Real const&, Real const&) = NULL;
+    Real (*numerator_int_f)(Real const&, Real const&, Real const&) const = NULL;
     if( rr <= 0 )
         numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_leftdomain;
     else if( rr < L0 )
@@ -610,9 +658,9 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
 	    prev_term = term;
 
 	    exp_and_denominator = params->exp_and_denominator[n];	    
-	    term = exp_and_denominator * (*numerator_int_f)( rr, t, root_n[n] );
+	    term_n = exp_and_denominator * (*numerator_int_f)( rr, t, root_n[n] );
 
-	    sum += term;
+	    sum += term_n;
 	    n++;
     }
     while (fabs(term/sum) > EPSILON*1.0 ||
@@ -624,7 +672,7 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
 }
 
 //Integrated Greens function for rr part of [-Ll, 0]
-inline Real GreensFunction1DAbsSinkAbs::num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const
+Real GreensFunction1DAbsSinkAbs::num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const
 {
     const Real Ll_L0( getLl() - getL0() );
     const Real Ll_rr( getLl() + rr );
@@ -633,7 +681,7 @@ inline Real GreensFunction1DAbsSinkAbs::num_int_r_leftdomain(Real const& rr, Rea
 }
 
 //Integrated Greens function for rr part of (0, L0]
-inline Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const
+Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const
 {
     const Real Lr_L0( getLr() - getL0() );
     const Real Ll_rr( getLl() + rr );
@@ -646,7 +694,7 @@ inline Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA(Real const& rr, R
 }
 
 //Integrated Greens function for rr part of (L0, Lr]
-inline Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const
+Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const
 {
     const Real L( getLr() + getLl() );
     const Real Lr( getLr() );
@@ -674,6 +722,7 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
+    const Real rsink( getrsink() );
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
@@ -698,18 +747,18 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     for (int n = 0; n < MAX_TERMS; n++)
     {
 	    root_n = root_n(n+1);
-       	root_n2 = root_n * root_n;
+       	root_n2 = gsl_pow_2( root_n );
       	// store the roots in the structure
 	    parameters.root_n[n] = root_n;
         // also store the exponent and denominator.
-        parameters.exp_and_denominator[n] = exp( - D * root_n2 * t ) / p_denominator( root_n );
+        parameters.exp_and_denominator[n] = Greens_fn( t, root_n, root_n2 );
         // and the normalization.
         parameters.prefactor = 2.0 / S;
     }
     
     // define gsl function for rootfinder
     gsl_function F;
-    F.function = &GreensFunction1DRadAbs::drawR_f;
+    F.function = &drawR_f;
     F.params = &parameters;
 
     // store the random number for the probability
@@ -722,22 +771,24 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     // make a new solver instance
     // TODO: incl typecast?
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-    Real r( findRoot( F, solver, -Ll, Lr, EPSILON*L, EPSILON,
+    Real rr( findRoot( F, solver, -Ll, Lr, EPSILON*L, EPSILON,
                             "GreensFunction1DRadAbs::drawR" ) );
 
-    // Convert the position to 'world' coordinates and return it.
-    
-    return r;
+    // Convert the position rr to 'world' coordinates and return it.
+    if( getr0() < rsink )
+        return rsink - rr;
+    else
+        return rsink + rr;
 }
 
 std::string GreensFunction1DAbsSinkAbs::dump() const
 {
     std::ostringstream ss;
-    ss << "D = " << this->getD() << ", sigma = " << this->getsigma() <<
-        ", a = " << this->geta() <<
-        ", r0 = " << this->getr0() <<
-        ", rsink = " << this->getrsink() <<
-        ", k = " << this->getk() << std::endl;
+    ss << "D = " << getD() << ", sigma = " << getsigma() <<
+        ", a = " << geta() <<
+        ", r0 = " << getr0() <<
+        ", rsink = " << getrsink() <<
+        ", k = " << getk() << std::endl;
     return ss.str();
 }
 
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 65dd8b04..aa67170a 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -1,5 +1,5 @@
-#if !defined( __GREENSFUNCTION1DRADABS_HPP )
-#define __GREENSFUNCTION1DRADABS_HPP
+#if !defined( __GREENSFUNCTION1DABSSINKABS_HPP )
+#define __GREENSFUNCTION1DABSSINKABS_HPP
 
 #include <sstream>
 #include <iostream>
@@ -40,8 +40,6 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     static const int MIN_TERMS = 20;
 
 public:
-    typedef std::pair<Real, Real> real_pair;
-
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
 	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
@@ -131,54 +129,12 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     {
 	    return v;
     }
-    
-    /* TODO: ask Tomek for their function.
-    void seta(Real a)
-    {
-	    THROW_UNLESS( std::invalid_argument, (a-this->sigma) >= 0.0 && this->r0 <= a);
-
-	    // Use a typical domain size to determine if we are here 
-	    // defining a domain of size 0.
-	    if ( (a-this->sigma) < EPSILON*this->l_scale )
-	    {
-	        // just some random value to show that the domain is zero
-	        this->a = -1.0;
-  	        this->L = -1.0;
-	    }
-	    else
-	    {   
-	        // set the l_scale to the given one
-	        this->l_scale = a - sigma;
-	        this->L = a - sigma;
-	        // set the typical time scale (MSD = sqrt(2*d*D*t) )
-	        this->t_scale = ( l_scale * l_scale ) / this->getD();
-	        this->a = a;
-	    }
-    }
 
-    void setr0(Real r0)
-    {
-	    if ( this->a - this->sigma < 0.0 )
-	    {
-	     // if the domain had zero size
-	        THROW_UNLESS( std::invalid_argument,
-	                  0.0 <= (r0-sigma) && (r0-sigma) <= EPSILON * l_scale );
-	        this->r0 = 0.0;
-	    }
-	    else
-	    {
-	        // The normal case
-	        THROW_UNLESS( std::invalid_argument,
-	                  0.0 <= (r0-sigma) && r0 <= this->a);
-	        this->r0 = r0;
-	    }
-    }
-    */
     
     /* Calculates the probability density of finding the particle at 
        location z at timepoint t, given that the particle is still in the 
        domain. */
-    Real calcpcum (Real r, Real t) const;
+    Real calcpcum(Real r, Real t) const;
 
     /* Determine which event has occured at time t. Either an escape 
        (left or right boundary) or a reaction with the sink. 
@@ -186,31 +142,36 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     EventKind drawEventType( Real rnd, Real t ) const;
 
     /* Draws the first passage time from the propensity function */
-    Real drawTime (Real rnd) const;
+    Real drawTime(Real rnd) const;
 
     /* Draws the position of the particle at a given time, assuming that 
        the particle is still in the domain. */
-    Real drawR (Real rnd, Real t) const;
+    Real drawR(Real rnd, Real t) const;
+
+    /* Calculates the probability flux leaving the domain through the right 
+       absorbing boundary at time t. */
+    Real flux_leavea(Real t) const;
+
+    /* Calculates the probability flux leaving the domain through the left 
+       absorbing boundary at time t. */
+    Real flux_leaves(Real t) const;
 
 
-    // These methods are both public and private, they are used by public methods 
-    // but can also be called from the 'outside'. This is mainly because of 
-    // debugging purposes.
+    /* TODO: Private methods which are public for now - debugging */
 
     // Calculates the probability of finding the particle inside the 
     // domain at time t -> the survival probability
-    Real p_survival (Real t) const;
+    Real p_survival(Real t) const;
 
     // Calculates the total probability flux leaving the domain at time t
-    Real flux_tot (Real t) const;
+    Real flux_tot(Real t) const;
 
-    // Calculates the probability flux leaving the domain through both 
-    // absorbing boundaries at time t.
-    real_pair flux_abs (Real t) const;
-    
-    // Calculates the probability flux leaving the domain through the 
-    // sink at time t.
+    /* Calculates the probability flux leaving the domain through the 
+       sink, sub-domain containing r0 via absorbing boundary and sub-domain
+       not containing r0 via sink, respectivily. */
     Real flux_sink(Real t) const;
+    Real flux_abs_Lr(Real t) const;
+    Real flux_abs_Ll(Real t) const;
 
     // Calculates the probability density of finding the particle at 
     // location r at time t.
@@ -228,17 +189,19 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     }
 
     // Calculates the roots of x * sin(x) + k * L / (2 * D) * ( cos(x * (Lr - Ll)/L) - cos(x) ) 
-    Real root_n(int n) const;
+    Real root_n(int const& n) const;
     
 private:
    
-    Real p_denominator( Real const& root_n );
+    inline Real p_denominator( Real const& root_n ) const;
     
-    inline Real num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const;
+    inline Real Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const;
+
+    Real num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const;
 
-    inline Real num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const;
+    Real num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const;
 
-    inline Real num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const;
+    Real num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const;
 
 
     static Real root_f (Real x, void *p);
@@ -256,7 +219,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    Real exponent[MAX_TERMS];
 	    Real Xn[MAX_TERMS];
 	    Real prefactor;
-	    int    terms;
+	    int  terms;
 	    // the timescale used for convergence
 	    Real   tscale;
 	    // the random number associated with the time
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 2726b92e..c1bbd443 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -85,21 +85,20 @@ BOOST_PYTHON_MODULE( _greens_functions )
     class_<GreensFunction1DAbsSinkAbs>("GreensFunction1DAbsSinkAbs",
                                    init<Real, Real, Real, Real, Real, Real>() )
         .def( init<Real, Real, Real, Real, Real, Real, Real>())
-        .def( "getName", &GreensFunction1DRadAbs::getName )
+        .def( "getName", &GreensFunction1DAbsSinkAbs::getName )
         .def( "getk", &GreensFunction1DAbsSinkAbs::getk )
         .def( "getD", &GreensFunction1DAbsSinkAbs::getD )
         .def( "getv", &GreensFunction1DAbsSinkAbs::getv )
         .def( "getsigma", &GreensFunction1DAbsSinkAbs::getsigma )
-        .def( "seta", &GreensFunction1DAbsSinkAbs::seta )
         .def( "geta", &GreensFunction1DAbsSinkAbs::geta )
-        .def( "setr0", &GreensFunction1DAbsSinkAbs::setr0 )
         .def( "getr0", &GreensFunction1DAbsSinkAbs::getr0 )
         .def( "getrsink", &GreensFunction1DAbsSinkAbs::getrsink )
         .def( "drawTime", &GreensFunction1DAbsSinkAbs::drawTime )
         .def( "drawR", &GreensFunction1DAbsSinkAbs::drawR )
         .def( "drawEventType", &GreensFunction1DAbsSinkAbs::drawEventType )
         .def( "flux_tot", &GreensFunction1DAbsSinkAbs::flux_tot )
-        .def( "flux_rad", &GreensFunction1DAbsSinkAbs::flux_rad )
+        .def( "flux_leaves", &GreensFunction1DAbsSinkAbs::flux_leaves )
+        .def( "flux_leavea", &GreensFunction1DAbsSinkAbs::flux_leavea )
         .def( "flux_sink", &GreensFunction1DAbsSinkAbs::flux_sink )
         .def( "p_survival", &GreensFunction1DAbsSinkAbs::p_survival )
         .def( "calcpcum", &GreensFunction1DAbsSinkAbs::calcpcum )

From a008898a07bd8fdca945ba1898d94b383024b73b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 21 Nov 2011 13:34:18 +0100
Subject: [PATCH 0387/1541] First compile possible.

---
 GreensFunction1DAbsSinkAbs.cpp | 97 ++++++++++++++++++++--------------
 GreensFunction1DAbsSinkAbs.hpp | 59 +++++++++++----------
 2 files changed, 86 insertions(+), 70 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 1aa37f5b..a3c8aec1 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -55,7 +55,9 @@ Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
     else
     {
         //TODO: more complicated scheme needed.
-        assert( h > 1 );
+        THROW_UNLESS( std::invalid_argument, h < 1 );
+        lower = (n-1)*M_PI + 1E-10;
+	    upper =  n   *M_PI - 1E-1;      
     }
 
     gsl_function F;
@@ -115,8 +117,8 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
 	    return 1.0;
     }
 
-    Real sum = 0, numerator = 0, num_prev = 0;
-    Real term1, term2, root_n;
+    Real sum = 0, numerator = 0, prev_term = 0;
+    Real term1, term2, term_n, root_n;
     int n = 1;
     do
     {
@@ -126,14 +128,15 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
 	              << n << std::endl;
 	        break;
 	    }
-	    num_prev = numerator;
+	    prev_term = numerator;
     
-        root_n = root_n(n);
+        root_n = this->root_n(n);
         term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
         term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
         
         numerator = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
-	    sum += Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+        term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+	    sum += term_n;
 	    n++;
     }
     while ( fabs(term_n/sum) > EPSILON  ||
@@ -214,7 +217,7 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 	        }
 	        prev_term = term_n;
 
-	        root_n = root_n(n);
+	        root_n = this->root_n(n);
 
             numerator =  D * root_n * sin( root_n * LlpL0 ) + k * sin( root_n * Ll ) * sin( root_n * L0);
             numerator *= sin( root_n * Lrmrr );       
@@ -242,7 +245,7 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 	        }
 	        prev_term = term_n;
 
-	        root_n = root_n(n);
+	        root_n = this->root_n(n);
 
             numerator =  D * root_n * sin( root_n * (Llprr) ) * sin( root_n * (LrmL0) ); 
             term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
@@ -312,7 +315,7 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
         }
         prev_term = term_n;
     
-        root_n = root_n(n);
+        root_n = this->root_n(n);
         root_n2 = gsl_pow_2( root_n );
 
         term1 = sin( root_n * L ) - sin( root_n * LrmL0 ) - sin( root_n * LlpL0 );
@@ -354,7 +357,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
         }
         prev_term = term_n;
     
-        root_n = root_n(n);
+        root_n = this->root_n(n);
         
         numerator = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
         
@@ -390,7 +393,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
         }
         prev_term = numerator;
     
-        root_n = root_n(n);
+        root_n = this->root_n(n);
         root_n2 = gsl_pow_2( root_n );        
         
         numerator = root_n2 * sin( root_n * ( LrmL0 ) );
@@ -400,7 +403,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
 
         n++;
     }
-    while ( fabs(term/sum) > EPSILON  ||
+    while ( fabs(term_n/sum) > EPSILON  ||
             fabs(prev_term/sum) > EPSILON ||
             n <= MIN_TERMS );
     
@@ -457,7 +460,7 @@ Real GreensFunction1DAbsSinkAbs::drawT_f (Real t, void *p)
 {
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
-    Real Xn, exponent;
+    Real Xn = 0, exponent = 0;
     Real prefactor = params->prefactor;
     int terms = params->terms;
 
@@ -525,7 +528,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     // coefficients should be calculated on demand->TODO or not TODO?
     for (int n=0; n<MAX_TERMS; n++)
     {
-        root_n = root_n( n + 1 );	
+        root_n = this->root_n( n + 1 );	
 	    
         const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
         const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
@@ -634,14 +637,15 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
     int  max_terms = params->terms;
     
     Real sum = 0, term_n = 0, prev_term = 0;
-    Real root_n, exp_and_denominator;
     
     /* Determine in which part of the domain rr lies, and
        thus which domain function to use. */
-    Real (*numerator_int_f)(Real const&, Real const&, Real const&) const = NULL;
+    static Real (*numerator_int_f)
+        (Real const&, Real const&, drawR_params const&) = NULL;
+
     if( rr <= 0 )
         numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_leftdomain;
-    else if( rr < L0 )
+    else if( rr < params->L0 )
             numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA;
         else
             numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB;
@@ -655,53 +659,59 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
 	                  << n << std::endl;
 	        break;
 	    }
-	    prev_term = term;
+	    prev_term = term_n;
 
-	    exp_and_denominator = params->exp_and_denominator[n];	    
-	    term_n = exp_and_denominator * (*numerator_int_f)( rr, t, root_n[n] );
+	    term_n = params->exp_and_denominator[n] * (*numerator_int_f)
+            ( rr, params->root_n[n], *params );
 
 	    sum += term_n;
 	    n++;
     }
-    while (fabs(term/sum) > EPSILON*1.0 ||
+    while (fabs(term_n/sum) > EPSILON*1.0 ||
 	       fabs(prev_term/sum) > EPSILON*1.0 ||
            n <= MIN_TERMS );
 
     // Find the intersection with the random number
-    return params.prefactor * sum - params->rnd;
+    return params->prefactor * sum - params->rnd;
 }
 
 //Integrated Greens function for rr part of [-Ll, 0]
-Real GreensFunction1DAbsSinkAbs::num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const
+Real GreensFunction1DAbsSinkAbs::num_int_r_leftdomain(Real const& rr, 
+                                                      Real const& root_n,
+                                                      drawR_params const& params)
 {
-    const Real Ll_L0( getLl() - getL0() );
-    const Real Ll_rr( getLl() + rr );
+    const Real Ll_L0( params.Ll - params.L0 );
+    const Real Ll_rr( params.Ll + rr );
     
-    return getD() * sin( root_n * Ll_L0 ) * ( cos( root_n * Ll_rr ) - 1 )
+    return params.D * sin( root_n * Ll_L0 ) * ( cos( root_n * Ll_rr ) - 1 );
 }
 
 //Integrated Greens function for rr part of (0, L0]
-Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const
+Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA(Real const& rr, 
+                                                        Real const& root_n, 
+                                                        drawR_params const& params)
 {
-    const Real Lr_L0( getLr() - getL0() );
-    const Real Ll_rr( getLl() + rr );
+    const Real Lr_L0( params.Lr - params.L0 );
+    const Real Ll_rr( params.Ll + rr );
     const Real root_n_rr( root_n * rr );
     
-    const Real temp( getD() * ( cos( root_n * Ll_rr ) - 1 ) + 
-            getk() / root_n * ( cos( root_n_rr ) - 1 ) * sin( root_n * Ll ) );
+    const Real temp( params.D * ( cos( root_n * Ll_rr ) - 1 ) + 
+            params.k / root_n * ( cos( root_n_rr ) - 1 ) * sin( root_n * params.Ll ) );
     
     return sin( root_n * Lr_L0 ) * temp;
 }
 
 //Integrated Greens function for rr part of (L0, Lr]
-Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const
+Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB(Real const& rr, 
+                                                        Real const& root_n, 
+                                                        drawR_params const& params)
 {
-    const Real L( getLr() + getLl() );
-    const Real Lr( getLr() );
-    const Real Ll( getLl() );
-    const Real L0( getL0() );
+    const Real Lr( params.Lr );
+    const Real Ll( params.Ll );
+    const Real L0( params.L0 );
     const Real Lr_L0( Lr - L0 );
     const Real Lr_rr( Lr - rr );
+    const Real L( Lr + Ll );
                    
     const Real term1( sin( root_n * L ) - sin( root_n * Lr_L0 ) - 
             sin( root_n * (Ll + L0) ) * cos( root_n * Lr_rr ) );
@@ -709,7 +719,7 @@ Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB(Real const& rr, Real con
     const Real term2( sin( root_n * Lr ) - sin( root_n * Lr_L0 ) -
             sin( root_n * L0 ) * cos( root_n * Lr_rr ));
         
-    return getD() * term1 + getk() * sin( root_n * Ll ) * term2 / root_n;
+    return params.D * term1 + params.k * sin( root_n * Ll ) * term2 / root_n;
 }
 
 Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
@@ -721,7 +731,6 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     const Real L( getLr() + getLl() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
-    const Real L0( getL0() );
     const Real rsink( getrsink() );
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
@@ -738,7 +747,7 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     // the structure to store the numbers to calculate r.
     struct drawR_params parameters;
     const Real S( p_survival(t) );
-    Real root_n = 0;
+    Real root_n, root_n2;
 
     assert(S >= 0.0);
 
@@ -746,7 +755,7 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     // in the params structure //TODO: MAX_TERM -> CONVERGENCE_TERMS
     for (int n = 0; n < MAX_TERMS; n++)
     {
-	    root_n = root_n(n+1);
+	    root_n = this->root_n(n+1);
        	root_n2 = gsl_pow_2( root_n );
       	// store the roots in the structure
 	    parameters.root_n[n] = root_n;
@@ -761,8 +770,14 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     F.function = &drawR_f;
     F.params = &parameters;
 
-    // store the random number for the probability
+    // store the random number and L0
     parameters.rnd = rnd;
+    parameters.L0 = getL0();
+    parameters.Lr = getLr();
+    parameters.Ll = getLl();
+    parameters.D = getD();
+    parameters.k = getk();
+
     // store the number of terms used
     parameters.terms = MAX_TERMS;
 
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index aa67170a..e7606b48 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -192,28 +192,21 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     Real root_n(int const& n) const;
     
 private:
-   
-    inline Real p_denominator( Real const& root_n ) const;
-    
-    inline Real Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const;
-
-    Real num_int_r_leftdomain(Real const& rr, Real const& t, Real const& root_n) const;
-
-    Real num_int_r_rightdomainA(Real const& rr, Real const& t, Real const& root_n) const;
-
-    Real num_int_r_rightdomainB(Real const& rr, Real const& t, Real const& root_n) const;
 
-
-    static Real root_f (Real x, void *p);
-    
-    struct root_f_params
+    struct drawR_params
     {
-	    Real Lm_L;
-	    Real h;
+	    Real root_n[MAX_TERMS];
+	    Real exp_and_denominator[MAX_TERMS];
+	    Real prefactor;
+        Real L0;
+        Real Lr;
+        Real Ll;
+	    Real rnd;
+        Real D;
+        Real k;
+	    int terms;
     };
 
-    static Real drawT_f (Real t, void *p);
-
     struct drawT_params
     {
 	    Real exponent[MAX_TERMS];
@@ -222,22 +215,30 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    int  terms;
 	    // the timescale used for convergence
 	    Real   tscale;
-	    // the random number associated with the time
 	    Real rnd;
     };
-
-    static Real drawR_f (Real z, void *p);
     
-    struct drawR_params
+    struct root_f_params
     {
-	    Real root_n[MAX_TERMS];
-	    Real exp_and_denominator[MAX_TERMS];
-	    // variables H: for additional terms appearing as multiplicative factors etc.
-	    Real prefactor;
-	    int terms;
-	    // the random number associated with the time
-	    Real rnd;
+	    Real Lm_L;
+	    Real h;
     };
+       
+    inline Real p_denominator( Real const& root_n ) const;
+    
+    inline Real Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const;
+
+    static Real num_int_r_leftdomain(Real const& rr, Real const& root_n, drawR_params const& params);
+
+    static Real num_int_r_rightdomainA(Real const& rr, Real const& root_n, drawR_params const& params);
+
+    static Real num_int_r_rightdomainB(Real const& rr, Real const& root_n, drawR_params const& params);
+
+    static Real root_f (Real x, void *p);
+
+    static Real drawT_f (Real t, void *p);
+
+    static Real drawR_f (Real t, void *p);
 
     /* Class variables */
     // The diffusion constant and drift velocity

From 7d9983214563f7291645ff78095befa1b39276d5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 14:22:40 +0100
Subject: [PATCH 0388/1541] cleanup/improve make_new_domain method

---
 egfrd.py | 120 +++++++++++++++++++++++++------------------------------
 1 file changed, 54 insertions(+), 66 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 117fb891..3293bf40 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1126,7 +1126,7 @@ def make_new_domain(self, single):
         
         # Special case: When D=0, nothing needs to change and only new event
         # time is drawn
-        # TODO find nicer constructrion than just this if statement
+        # TODO find nicer construction than just this if statement
         if single.getD() == 0:
             single.dt, single.event_type = single.determine_next_event() 
             single.last_time = self.t
@@ -1193,45 +1193,20 @@ def make_new_domain(self, single):
                                                                         ignore=[single.domain_id],
                                                                         ignores=[single.structure.id])
 
-        # TODO Potential partners are for now just the bursted domains
-        # TODO FIX THIS!
         # New situation -> re-get the neighbors
-        # TODO modify the existing neighbor list by removing burst domains, and adding the new ones + distance
+        # TODO: modify the existing neighbor list by removing burst domains, and adding the new ones + distance
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
 
         pair_partners = []
         for domain, _ in neighbors:
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
-                pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
                 # distance from the center of the particles/domains
+                pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
                 pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
                 pair_partners.append((domain, pair_distance - pair_horizon))
 
-#        partners = self.geometrycontainer.filter_partners(neighbors)
-#        partners = self.geometrycontainer.sort_domain_distance(partners)
-
-        partners = burst
-
-        dists = []
-        if partners:
-#            for domain, _ in partners:
-#            if isinstance(domain, NonInteractionSingle):
-            # sort partners by distance
-            dists = self.obj_distance_array(single_pos, partners)
-            if len(dists) >= 2:
-                n = dists.argsort()
-                partners = numpy.take(partners, n)      # sort the potential partners using the index
-                dists = dists.take(n)                   # sort the distances using the index
-
-#            closest_domain = partners[0][0]
-#            domain_distance = partners[0][1]
-#        else:
-#            closest_domain = None
-#            domain_distance = numpy.inf
-
-
         
-        # Potential partners are also surfaces
+        # Potential partners are also surfaces but only if the particle is in 3D
         interaction_partners = []
         if isinstance(single, SphericalSingle):
             # TODO get a list of the surfaces sorted by distance instead of just the closest
@@ -1245,6 +1220,22 @@ def make_new_domain(self, single):
         pair_interaction_partners = pair_partners + interaction_partners
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
+
+        ### START LEGACY
+        partners = burst
+        dists = []
+        if partners:
+#            for domain, _ in partners:
+#            if isinstance(domain, NonInteractionSingle):
+            # sort partners by distance
+            dists = self.obj_distance_array(single_pos, partners)
+            if len(dists) >= 2:
+                n = dists.argsort()
+                partners = numpy.take(partners, n)      # sort the potential partners using the index
+                dists = dists.take(n)                   # sort the distances using the index
+        ### END LEGACY
+
+
         # 2.4 calculate the thresholds (horizons) for trying to form the various domains.
         # Note that we do not differentiate between directions. This means that we
         # look around in a sphere, the horizons are spherical
@@ -1281,68 +1272,57 @@ def make_new_domain(self, single):
             # No Pair or Interaction could be formed
             # Now choose between NonInteractionSingle and Multi
 
+            # make a new list of potential partners
+            # Is now zero-dt NonInteractionSingles and Multi's
+            # TODO: combine with first selection such that we have to do this loop only once
             multi_partners = []
             for domain, dist_to_shell in neighbors:
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                     multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
                     # distance from the center of the particles/domains
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
-                    multi_partners.append((domain, distance - multi_horizon, multi_horizon))
+                    multi_partners.append((domain, distance - multi_horizon))
 
                 elif isinstance(domain, Multi):
-#                    min(self.world.distance(shell.shape, pos)
-#                        for i, (_, shell) in enumerate(domain.shell_list))
-#
+                    # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
+                    # So only the horizon and distance of the current single needs to be taken into account
+                    # Note: this is built on the assumption that the shell of a Multi has the size of the horizon.
                     multi_horizon = (single_radius * self.MULTI_SHELL_FACTOR)
-#                    distance = self.domain_distance(single_pos, domain) # distance from the center of the particles/domains
-                    multi_partners.append((domain, dist_to_shell - multi_horizon, multi_horizon))
+                    multi_partners.append((domain, dist_to_shell - multi_horizon))
 
 
             # Potential partners are also surfaces
+            interaction_partners = []
             if isinstance(single, SphericalSingle):
                 # TODO get a list of the surfaces sorted by distance instead of just the closest
                 closest_surface, surface_distance = \
-                 get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
+                    get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
                 surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
                 if closest_surface:
                     interaction_partners = [(closest_surface, surface_distance - surface_horizon, surface_horizon), ]
-                else:
-                    interaction_partners = []
-            else:
-                # no interaction is possible
-                interaction_partners = []
+                # else no interaction is possible
 
             multi_partners = multi_partners + interaction_partners
 
-#            for obj, hor_overlap in multi_partners:
-            # TODO cleanup
-#                if isinstance (obj, NonInteractionSingle) and \
-#                   closest_obj.is_reset():
-#                    multi_horizon = (single_radius + \
-#                        closest_obj.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
-#                else:
-#                    multi_horizon = single_radius * self.MULTI_SHELL_FACTOR
-
 
-            # In case there is really nothing
             if multi_partners:
                 multi_partners = sorted(multi_partners, key=lambda domain_overlap: domain_overlap[1])
 #                log.debug('multi_partners: %s' % str(multi_partners))
                 closest_overlap = multi_partners[0][1]
             else:
+                # In case there is really nothing
                 closest_overlap = numpy.inf
 
-            log.debug('closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
+            log.debug('Single or Multi: closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
 
-            if closest_overlap > 0.0: # and \
-#                surface_distance > multi_horizon:
+            if closest_overlap > 0.0: 
                 # just make a normal NonInteractionSingle
                 self.update_single(single)
                 self.add_domain_event(single)
             else:
-                # The closest object was too close to make a NonInteractionSingle
-                # TODO an object was closer than the Multi horizon
-                domain = self.form_multi(single, partners, dists)
+                # An object was closer than the Multi horizon
+#                domain = self.form_multi(single, partners, dists)
+                domain = self.form_multi(single, multi_partners)
 
         return domain
 
@@ -1584,6 +1564,7 @@ def process_single_event(self, single):
     def process_pair_event(self, pair):
         assert self.check_domain(pair)
 
+        print 'FIRE_PAIR'
         if __debug__:
             log.info('FIRE PAIR: %s' % pair.event_type)
             log.info('single1 = %s' % pair.single1)
@@ -2170,7 +2151,7 @@ def try_pair(self, single1, single2):
             # single1 will be removed by the scheduler.
             self.remove_event(single2)
 
-#            assert self.check_domain(pair)
+            assert self.check_domain(pair)
             self.add_domain_event(pair)
 
             if __debug__:
@@ -2181,7 +2162,8 @@ def try_pair(self, single1, single2):
             return None
     
 
-    def form_multi(self, single, neighbors, dists):
+#    def form_multi(self, single, neighbors, dists):
+    def form_multi(self, single, multi_partners):
         # form a Multi with the 'single'
         # The 'neighbors' are neighboring NonInteractionSingles and Multi which
         # can be added to the Multi (this can also be empty)
@@ -2189,9 +2171,10 @@ def form_multi(self, single, neighbors, dists):
 
         # Filter out relevant neighbors if present
         # only consider neighboring bursted domains that are within the Multi horizon
-        min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
-        dists = numpy.array(dists)      # FIXME Not sure why this is necessary, dists should already be array
-        neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
+#        min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+#        dists = numpy.array(dists)      # FIXME Not sure why this is necessary, dists should already be array
+#        neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
+        neighbors = [domain for domain, overlap in multi_partners if overlap < 0]
         if neighbors:
             closest = neighbors[0]
         else:
@@ -2232,20 +2215,21 @@ def add_to_multi_recursive(self, domain, multi):
                 # Already in the Multi.
                 return
             assert domain.is_reset()
-            objpos = domain.shell.shape.position
+            dompos = domain.shell.shape.position
             
             self.add_to_multi(domain, multi)
             self.remove_domain(domain)
             self.remove_event(domain)
 
+            # TODO this is expensive/stupid -> fix
             radius = domain.pid_particle_pair[1].radius * \
                 self.MULTI_SHELL_FACTOR
             neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(
-                    objpos, radius, ignore=[domain.domain_id])
+                    dompos, radius, ignore=[domain.domain_id])
             neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
             burst = self.burst_non_multis(neighbors)
-            neighbor_dists = self.obj_distance_array(objpos, burst)
+            neighbor_dists = self.obj_distance_array(dompos, burst)
             neighbors = [burst[i] for i
                                   in (neighbor_dists <= radius).nonzero()[0]]
 
@@ -2261,7 +2245,8 @@ def add_to_multi_recursive(self, domain, multi):
             else:
                 self.merge_multis(domain, multi)
         else:
-            assert False, 'do not reach here.'  # Pairs are burst
+            # only NonInteractionSingles and Multi should be selected
+            assert False, 'Trying to add non Single or Multi to Multi.'
 
     def add_to_multi(self, single, multi):
         if __debug__:
@@ -2375,6 +2360,8 @@ def check_domain(self, domain):
         else:
             ignores = [domain.structure.id]
 
+
+
         for shell_id, shell in domain.shell_list:
             closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
                                                                        self.domains,
@@ -2431,6 +2418,7 @@ def check_domain(self, domain):
 
         return True
 
+
     def check_domain_for_all(self):
         for id, event in self.scheduler:
             domain = self.domains[event.data]

From 9d42d24670d4392b4dfecfdbff0542f80e193f55 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 14:23:46 +0100
Subject: [PATCH 0389/1541] implemeted simplified shell overlap checker It
 assumes that all cylinders are parallel to eachother

---
 egfrd.py | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index 3293bf40..beaccf93 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2418,6 +2418,43 @@ def check_domain(self, domain):
 
         return True
 
+    def check_shell_overlap(self, shell1, shell2):
+    # Returns True if the shells DO NOT overlap
+    # Returns False if the shells DO overlap
+
+        # overlap criterium when both shells are spherical
+        if (type(shell1.shape) is Sphere) and (type(shell2.shape) is Sphere):
+            distance = self.world.distance(shell1.shape.position, shell2.shape.position)
+            return (shell1.shape.radius + shell2.shape.radius) < distance
+
+        # overlap criterium when both shells are cylindrical 
+        elif (type(shell1.shape) is Cylinder) and (type(shell2.shape) is Cylinder):
+            # assuming that the cylinders are always parallel
+            assert (shell1.shape.unit_z == shell2.shape.unit_z) or \
+                   (shell1.shape.unit_z == -shell2.shape.unit_z)
+            shell1_pos = shell1.shape.position
+            shell2_pos = shell2.shape.position
+            shell2_post = self.world.cyclic_transpose(shell1_pos, shell2_pos)
+            inter_pos = shell1_pos - shell2_pos
+            inter_pos_z = shell1.shape.unit_z * numpy.dot(inter_pos, shell1.shape.unit_z)
+            inter_pos_r = inter_pos - inter_pos_z
+            return not (((shell1.shape.half_length + shell2.shape.half_length) > length(inter_pos_z)) and \
+                       ((shell1.shape.radius + shell2.shape.radius) > length(inter_pos_r)))
+
+        # overlap criterium when one shell is spherical and the other is cylindrical
+        elif (type(shell1.shape) is Sphere) and (type(shell2.shape) is Cylinder):
+            distance = self.world.distance(shell2.shape, shell1.shape.position)
+            return (shell1.shape.radius) < distance
+
+        # the other way around
+        elif (type(shell1.shape) is Cylinder) and (type(shell2.shape) is Sphere):
+            distance = self.world.distance(shell1.shape, shell2.shape.position)
+            return (shell2.shape.radius) < distance
+
+        # something was wrong (wrong type of shell provided)
+        else:
+            raise RuntimeError('check_shell_overlap: wrong shell type(s) provided.')
+
 
     def check_domain_for_all(self):
         for id, event in self.scheduler:

From 5787d44525c2206807bc8903aff1bd48b18773b7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 15:29:32 +0100
Subject: [PATCH 0390/1541] reworked/updated domain checking. Checks between
 multi's and multi's should now also work better Also checks between sphere's
 and cylinders and shells and surfaces should be clearer

---
 egfrd.py | 139 ++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 92 insertions(+), 47 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index beaccf93..f5f5841c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -22,6 +22,7 @@
     _random_vector,
     Cylinder,
     Sphere,
+    Plane,
     NetworkRulesWrapper,
     )
 
@@ -2363,58 +2364,83 @@ def check_domain(self, domain):
 
 
         for shell_id, shell in domain.shell_list:
-            closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
-                                                                       self.domains,
-                                                                       ignore=[domain.domain_id],
-                                                                       ignores=ignores)
+
+#            closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
+#                                                                       self.domains,
+#                                                                       ignore=[domain.domain_id],
+#                                                                       ignores=ignores)
 
 #            distance_midpoints = self.world.distance(domain.shell.shape.position, closest.shell.shape.position)
-            distance_midpoints = 0
-
-            # testing overlap criteria
-            # TODO This doesn't work if closest is a Multi -> redesign this test
-            if(type(shell.shape) is Cylinder and
-               closest and type(closest.shell.shape) is Sphere):
-                # Note: this case is special.
-                # Note: only checking if cylinder doesn't overlap with 
-                # closest sphere, like we do here, is not really 
-                # sufficient (but checking all spheres is too much 
-                # work).
-                shell_size = shell.shape.half_length
-                # Reverse overlap calculation: from closest sphere to 
-                # cylinder is easier than the other way around, because 
-                # the distance calculation from a point to a cylinder 
-                # is already implemented.
-                sphere = closest.shell.shape
-                diff = self.world.distance(shell.shape, sphere.position) - \
-                       sphere.radius
-            else:
-                if(type(domain) is CylindricalSurfaceSingle or
-                   type(domain) is CylindricalSurfacePair or
-                   type(domain) is CylindricalSurfaceInteraction):
-                    # On CylindricalSurface, use half_lenghts.
-                    # (assume all nearby other cylinders are on the 
-                    # same surface)
-                    shell_size = shell.shape.half_length
-                else:
-                    # Normally compare radii.
-                    shell_size = shell.shape.radius
-                diff = distance - shell_size
+#            distance_midpoints = 0
+
+            # TODO should be replace by list of surface
+            surface, distance = get_closest_surface(self.world, shell.shape.position, ignores)
+            if surface:
+                surfaces = [(surface, distance), ]
+                for surface, distance in surfaces:
+                    assert self.check_surface_overlap(shell, surface), \
+                        '%s (%s) overlaps with %s.' % \
+                        (str(domain), str(shell), str(surface))
+
+
+            neighbors = self.geometrycontainer.get_neighbor_domains(shell.shape.position,
+                                                                    self.domains, ignore=[domain.domain_id])
+
+            for neighbor, _ in neighbors:
+                for _, neighbor_shell in neighbor.shell_list:
+                    assert self.check_shell_overlap(shell, neighbor_shell), \
+                        '%s (%s) overlaps with %s (%s).' % \
+                        (str(domain), str(shell), str(neighbor), str(neighbor_shell))
+
+#            # testing overlap criteria
+#            # TODO This doesn't work if closest is a Multi -> redesign this test
+#            if(type(shell.shape) is Cylinder and
+#               closest and type(closest.shell.shape) is Sphere):
+#                # Note: this case is special.
+#                # Note: only checking if cylinder doesn't overlap with 
+#                # closest sphere, like we do here, is not really 
+#                # sufficient (but checking all spheres is too much 
+#                # work).
+#                shell_size = shell.shape.half_length
+#                # Reverse overlap calculation: from closest sphere to 
+#                # cylinder is easier than the other way around, because 
+#                # the distance calculation from a point to a cylinder 
+#                # is already implemented.
+#                sphere = closest.shell.shape
+#                diff = self.world.distance(shell.shape, sphere.position) - \
+#                       sphere.radius
+#            else:
+#                if(type(domain) is CylindricalSurfaceSingle or
+#                   type(domain) is CylindricalSurfacePair or
+#                   type(domain) is CylindricalSurfaceInteraction):
+#                    # On CylindricalSurface, use half_lenghts.
+#                    # (assume all nearby other cylinders are on the 
+#                    # same surface)
+#                    shell_size = shell.shape.half_length
+#                else:
+#                    # Normally compare radii.
+#                    shell_size = shell.shape.radius
+#                diff = distance - shell_size
+
+            if (type(shell.shape) is Cylinder):
+                shell_size = math.sqrt(shell.shape.radius**2 + shell.shape.half_length**2)
+            elif (type(shell.shape) is Sphere):
+                shell_size = shell.shape.radius
 
             assert shell_size <= self.geometrycontainer.get_user_max_shell_size(), \
-                '%s shell size larger than user-set max shell size' % \
-                str(shell_id)
+                '%s shell size larger than user-set max shell size, shell_size = %s, max = %s.' % \
+                (str(shell_id), FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % self.geometrycontainer.get_user_max_shell_size())
 
             assert shell_size <= self.geometrycontainer.get_max_shell_size(), \
-                '%s shell size larger than simulator cell size / 2' % \
-                str(shell_id)
+                '%s shell size larger than simulator cell size / 2, shell_size = %s, max = %s.' % \
+                (str(shell_id), FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % self.geometrycontainer.get_max_shell_size())
 
-            assert diff >= 0.0, \
-                '%s overlaps with %s. (shell: %s, dist: %s, diff: %s, dist_midpoints: %s.' % \
-                (str(domain), str(closest), FORMAT_DOUBLE % shell_size,
-                 FORMAT_DOUBLE % distance,
-                 FORMAT_DOUBLE % diff,
-                 FORMAT_DOUBLE % distance_midpoints)
+#            assert diff >= 0.0, \
+#                '%s overlaps with %s. (shell: %s, dist: %s, diff: %s, dist_midpoints: %s.' % \
+#                (str(domain), str(closest), FORMAT_DOUBLE % shell_size,
+#                 FORMAT_DOUBLE % distance,
+#                 FORMAT_DOUBLE % diff,
+#                 FORMAT_DOUBLE % distance_midpoints)
 
         return True
 
@@ -2430,8 +2456,7 @@ def check_shell_overlap(self, shell1, shell2):
         # overlap criterium when both shells are cylindrical 
         elif (type(shell1.shape) is Cylinder) and (type(shell2.shape) is Cylinder):
             # assuming that the cylinders are always parallel
-            assert (shell1.shape.unit_z == shell2.shape.unit_z) or \
-                   (shell1.shape.unit_z == -shell2.shape.unit_z)
+            assert abs(numpy.dot (shell1.shape.unit_z, shell2.shape.unit_z)) == 1
             shell1_pos = shell1.shape.position
             shell2_pos = shell2.shape.position
             shell2_post = self.world.cyclic_transpose(shell1_pos, shell2_pos)
@@ -2455,6 +2480,26 @@ def check_shell_overlap(self, shell1, shell2):
         else:
             raise RuntimeError('check_shell_overlap: wrong shell type(s) provided.')
 
+    def check_surface_overlap(self, shell, surface):
+        if (type(shell.shape) is Sphere):
+            distance = self.world.distance(surface.shape, shell.shape.position)
+            return shell.shape.radius < distance
+
+        elif (type(shell.shape) is Cylinder):
+            distance = self.world.distance(surface.shape, shell.shape.position)
+
+            # Only take shells into account that have unit_z perpendicular to unit_z of surface
+            if (type(surface.shape) is Plane):
+                return shell.shape.radius < distance
+            elif (type(surface.shape) is Cylinder):
+                return shell.shape.half_length < distance
+            else:
+                raise RuntimeError('check_surface_overlap: Surface was not Plane of Cylinder.')
+
+        # something was wrong (wrong type of shell provided)
+        else:
+            raise RuntimeError('check_surface_overlap: wrong shell type provided.')
+
 
     def check_domain_for_all(self):
         for id, event in self.scheduler:

From 378412763474cd3e9107a762a4bf8ae48a06bab8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 16:04:44 +0100
Subject: [PATCH 0391/1541] Ugly fix for preventing the max_shell (in case of
 cylinder) to be bigger than the max_sphere

---
 pair.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index cb137cc2..9efc5a8f 100644
--- a/pair.py
+++ b/pair.py
@@ -249,7 +249,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
             log.debug('Pair closest neighbor: %s %s' % \
                       (closest, FORMAT_DOUBLE % closest_distance))
 
-        assert closest_distance > 0
+        assert (closest_distance > 0), 'closest_distance = %s' % (FORMAT_DOUBLE % closest_distance)
 
 
 
@@ -290,8 +290,12 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
             assert isinstance(closest, (InteractionSingle, Pair, Multi, Surface, None.__class__))
             shell_size = closest_distance 
 
+        # FIXME Bloody ugly tweak to make sure that in case of a cylinder the 'maximum size' (which is
+        # actually the radius) does not stick out of the maximum sphere (which is the real hard max).
+        sigma = max(single1.pid_particle_pair[1].radius, single2.pid_particle_pair[1].radius)
+        max_shell_size = math.sqrt(geometrycontainer.get_max_shell_size()**2 - sigma**2)
 
-        return min(geometrycontainer.get_max_shell_size(), shell_size)/SAFETY
+        return min(max_shell_size, shell_size)/SAFETY
 
 
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,

From 8ec276d204624f8e76fa437c18096a7ed091ae6e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 16:07:04 +0100
Subject: [PATCH 0392/1541] small comment and error check

---
 egfrd.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index f5f5841c..19cfb309 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2423,9 +2423,12 @@ def check_domain(self, domain):
 #                diff = distance - shell_size
 
             if (type(shell.shape) is Cylinder):
+                # the cylinder should at least fit in the maximal sphere
                 shell_size = math.sqrt(shell.shape.radius**2 + shell.shape.half_length**2)
             elif (type(shell.shape) is Sphere):
                 shell_size = shell.shape.radius
+            else:
+                raise RuntimeError('check_domain error: Shell shape was not Cylinder of Sphere')
 
             assert shell_size <= self.geometrycontainer.get_user_max_shell_size(), \
                 '%s shell size larger than user-set max shell size, shell_size = %s, max = %s.' % \

From fc19ed2262ef1ff3a4b87246308cb3f66d1a4404 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 17:52:35 +0100
Subject: [PATCH 0393/1541] fixed bug -> squeezing particles can actually be
 overlapping with the CoM

---
 pair.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/pair.py b/pair.py
index 9efc5a8f..09a004bb 100644
--- a/pair.py
+++ b/pair.py
@@ -246,11 +246,14 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
                                                                       single2.domain_id],
                                                                       ignores=[single1.structure.id])
         if __debug__:
-            log.debug('Pair closest neighbor: %s %s' % \
+            log.debug('Pair closest neighbor: %s, distance: %s' % \
                       (closest, FORMAT_DOUBLE % closest_distance))
 
-        assert (closest_distance > 0), 'closest_distance = %s' % (FORMAT_DOUBLE % closest_distance)
-
+        # shortcut
+        # if closest_distance <0 then neighbor particle overlaps with center of mass ->
+        # neighboring particle is actually closer to the CoM than any of the two member particles
+        if closest_distance <= 0:
+            return 0
 
 
         # 3. Check if bursted Singles can still make a minimal shell.

From cf9154e6db91466483200e4f8e1117de961f2306 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 17:53:30 +0100
Subject: [PATCH 0394/1541] insignificant changes

---
 egfrd.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 19cfb309..f77b0cbd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -40,7 +40,7 @@
 log = logging.getLogger('ecell')
 
 if __debug__:
-    PRECISION = 3
+    PRECISION = 7
     FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
 
 def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure):
@@ -1565,7 +1565,6 @@ def process_single_event(self, single):
     def process_pair_event(self, pair):
         assert self.check_domain(pair)
 
-        print 'FIRE_PAIR'
         if __debug__:
             log.info('FIRE PAIR: %s' % pair.event_type)
             log.info('single1 = %s' % pair.single1)

From c11ebe17e0c9f5445ba610ac0afbce45902f2fb3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 Nov 2011 17:54:04 +0100
Subject: [PATCH 0395/1541] bugfix, should check ALL shells in the container,
 not break after first match

---
 shellcontainer.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shellcontainer.py b/shellcontainer.py
index 4b638b7f..4074b22f 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -118,12 +118,12 @@ def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
             for shell_id_shell_pair, distance in result:
                 domain_id = shell_id_shell_pair[1].did
 
-                if domain_id not in ignore and distance < closest_distance:
+                if ((domain_id not in ignore) and (distance < closest_distance)):
                     domain = domains[domain_id]
                     closest_domain, closest_distance = domain, distance
                     # Found yet a closer domain. Break out of inner for 
                     # loop and check other containers.
-                    break
+#                    break
 
         surface, distance = get_closest_surface(self.world, pos, ignores)
 

From c9c7aacb3c396879663888bb3c358f46ac71bfb8 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 21 Nov 2011 18:37:57 +0100
Subject: [PATCH 0396/1541] Removed bugs, testing functions.

---
 GreensFunction1DAbsAbs.cpp     |  4 +--
 GreensFunction1DAbsSinkAbs.cpp | 62 +++++++++++++++++++++-------------
 GreensFunction1DAbsSinkAbs.hpp |  2 +-
 greens_functions.cpp           |  1 +
 4 files changed, 43 insertions(+), 26 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index e5adc568..7e36a733 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -331,11 +331,11 @@ GreensFunction1DAbsAbs::drawEventType( Real rnd, Real t ) const
 
     if (rnd > fluxratio )
     {
-	return IV_ESCAPE;
+    return IV_ESCAPE; //escape through a.
     }
     else
     {
-	return IV_REACTION;
+	return IV_REACTION; //escape through sigma.
     }
 }
 
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index a3c8aec1..f2c611f7 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -48,16 +48,16 @@ Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
     if ( h < 1 )
     {
 	    // 1E-10 to make sure that he doesn't include the transition 
-	    lower = (n-1)*M_PI + 1E-10;
+	    lower = (n-.5)*M_PI;
 	    // (asymptotic) from infinity to -infinity
-	    upper =  n   *M_PI - 1E-10;
+	    upper = (n+.5)*M_PI;
     }
     else
     {
         //TODO: more complicated scheme needed.
         THROW_UNLESS( std::invalid_argument, h < 1 );
-        lower = (n-1)*M_PI + 1E-10;
-	    upper =  n   *M_PI - 1E-1;      
+        lower = (n-.5)*M_PI;
+	    upper = (n+.5)*M_PI;      
     }
 
     gsl_function F;
@@ -93,8 +93,8 @@ inline Real GreensFunction1DAbsSinkAbs::p_denominator(Real const& root_n) const
     const Real L( getLr() + getLl() );
     
     const Real term1( root_n * L * cos( root_n * L ) + sin( root_n * L ) );
-    const Real term2( L * sin( root_n * L ) + Lm * sin( root_n * L ) );
- 
+    const Real term2( L * sin( root_n * L ) - Lm * sin( root_n * Lm ) );   
+
     return getD() * term1 + getk() / 2. * term2;
 }
 
@@ -106,10 +106,10 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
   
     const Real D ( getD() );
     const Real k ( getk() ); 
-    const Real L ( getLr() + getLl() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
+    const Real L ( Lr + Ll );
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
@@ -136,6 +136,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
         
         numerator = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
         term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+        //std::cerr << term_n << " " << root_n * L / M_PI << std::endl;
 	    sum += term_n;
 	    n++;
     }
@@ -161,11 +162,7 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     Real L0( getL0() );
     Real rr( r - getrsink() ) ;
 
-    const Real L( getLr() + getLl() );
-    const Real LlpL0( Ll + L0 );
-    const Real LrmL0( Lr - L0 );
-    const Real Lrmrr( Lr - Lr );
-    const Real Llprr( Ll + rr );
+    const Real L( Lr + Ll );
 
     // if there was no time change or zero diffusivity => no movement
     if (t == 0 || D == 0)
@@ -202,10 +199,13 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
            If so, interchange r with r0. */
         if( rr < L0 )
         {
-            const Real temp( L0 );
+            const Real temp( rr );
             rr = L0;
             L0 = temp;
-        }    
+        }
+
+        const Real LlpL0( Ll + L0 );
+        const Real Lrmrr( Lr - rr );
 
         do
         {   
@@ -219,8 +219,10 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 
 	        root_n = this->root_n(n);
 
-            numerator =  D * root_n * sin( root_n * LlpL0 ) + k * sin( root_n * Ll ) * sin( root_n * L0);
-            numerator *= sin( root_n * Lrmrr );       
+            numerator =  D * root_n * sin( root_n * LlpL0 ) + 
+                k * sin( root_n * Ll ) * sin( root_n * L0);
+            numerator *= sin( root_n * Lrmrr );
+
             term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
             sum += term_n;
 
@@ -235,6 +237,9 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
         if( rr > 0 )
             rr *= -1;
 
+        const Real LrmL0( Lr - L0 );
+        const Real Llprr( Ll + rr );
+
         do
         {   
 	        if ( n >= MAX_TERMS )
@@ -272,6 +277,11 @@ Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
 /* Function returns flux at absorbing bounday sigma. */
 Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
 {
+    if( t == 0 || D == 0 )
+    {
+        return 0.0;
+    }
+
     if( getr0() > getrsink() )
         return flux_abs_Ll( t );
     else
@@ -281,6 +291,11 @@ Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
 /* Function returns flux at absorbing bounday a. */
 Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
 {
+    if( t == 0 || D == 0 )
+    {
+        return 0.0;
+    }
+
     if( getr0() < getrsink() )
         return flux_abs_Ll( t );
     else
@@ -340,9 +355,9 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
 {
     const Real D( getD() );
     const Real k( getk() );    
-    const Real LlpL0( getLr() + getL0() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
+    const Real LlpL0( Ll + L0 );
     Real root_n;
     
     Real sum = 0, numerator, term_n = 0, prev_term = 0;
@@ -351,7 +366,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
     {
         if ( n >= MAX_TERMS )
         {
-            std::cerr << " Too many terms needed for GF1DSink::flux_abs. N: "
+            std::cerr << " Too many terms needed for GF1DSink::flux_abs_Lr. N: "
                       << n << std::endl;
             break;
         }
@@ -360,7 +375,8 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
         root_n = this->root_n(n);
         
         numerator = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
-        
+        numerator *= root_n;
+
         term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;         
         sum += term_n;
 
@@ -370,7 +386,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
             fabs(prev_term/sum) > EPSILON ||
             n <= MIN_TERMS );
 
-    return - D * 2 * root_n * sum;
+    return - D * 2 * sum;
 }
 
 /* Flux leaving throught absorbing boundary from sub-domain not containing r0. */
@@ -387,16 +403,16 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
     {
         if ( n >= MAX_TERMS )
         {
-            std::cerr << " Too many terms needed for GF1DSink::flux_abs. N: "
+            std::cerr << " Too many terms needed for GF1DSink::flux_abs_Ll. N: "
                       << n << std::endl;
             break;
         }
-        prev_term = numerator;
+        prev_term = term_n;
     
         root_n = this->root_n(n);
         root_n2 = gsl_pow_2( root_n );        
         
-        numerator = root_n2 * sin( root_n * ( LrmL0 ) );
+        numerator = root_n2 * sin( root_n * LrmL0 );
 
         term_n = Greens_fn(t, root_n, root_n2 ) * numerator;
         sum += term_n;
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index e7606b48..867272f3 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -63,7 +63,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     /* The constructor is overloaded and can be called with or without drift v
        copy constructor including drift variable v */
     GreensFunction1DAbsSinkAbs(Real D, Real v, Real k, Real r0, Real rsink, Real sigma, Real a)
-	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), rsink(a - sigma), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
+	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
 		assert( a > sigma );
 	    
diff --git a/greens_functions.cpp b/greens_functions.cpp
index c1bbd443..ead267c2 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -100,6 +100,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "flux_leaves", &GreensFunction1DAbsSinkAbs::flux_leaves )
         .def( "flux_leavea", &GreensFunction1DAbsSinkAbs::flux_leavea )
         .def( "flux_sink", &GreensFunction1DAbsSinkAbs::flux_sink )
+        .def( "prob_r", &GreensFunction1DAbsSinkAbs::prob_r )
         .def( "p_survival", &GreensFunction1DAbsSinkAbs::p_survival )
         .def( "calcpcum", &GreensFunction1DAbsSinkAbs::calcpcum )
         .def( "dump", &GreensFunction1DAbsSinkAbs::dump )

From 78297a6cfa5b4e4d54d50247f23a6b797ef06f9f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 Nov 2011 14:34:50 +0100
Subject: [PATCH 0397/1541] cleanup/clarification/fixes to add_to_multi and
 recursive Note that recursive is turned off, this means that the bursted
 domains will be handled by the scheduler. This may introduce more bursting
 but will reduce code duplication and increase reliability.

---
 egfrd.py | 58 +++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 38 insertions(+), 20 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f77b0cbd..323edc2e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1322,7 +1322,6 @@ def make_new_domain(self, single):
                 self.add_domain_event(single)
             else:
                 # An object was closer than the Multi horizon
-#                domain = self.form_multi(single, partners, dists)
                 domain = self.form_multi(single, multi_partners)
 
         return domain
@@ -2162,19 +2161,22 @@ def try_pair(self, single1, single2):
             return None
     
 
-#    def form_multi(self, single, neighbors, dists):
     def form_multi(self, single, multi_partners):
         # form a Multi with the 'single'
-        # The 'neighbors' are neighboring NonInteractionSingles and Multi which
+        # The 'multi_partners' are neighboring NonInteractionSingles, Multis and surfaces which
         # can be added to the Multi (this can also be empty)
-        # 'dists' are the distances of the 'neighbors'
+
 
         # Filter out relevant neighbors if present
-        # only consider neighboring bursted domains that are within the Multi horizon
-#        min_shell = single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
-#        dists = numpy.array(dists)      # FIXME Not sure why this is necessary, dists should already be array
-#        neighbors = [neighbors[i] for i in (dists <= min_shell).nonzero()[0]]
-        neighbors = [domain for domain, overlap in multi_partners if overlap < 0]
+        # only consider objects that are within the Multi horizon
+        neighbors = [obj for obj, overlap in multi_partners if overlap < 0]
+        for partner in neighbors:
+            assert (isinstance(partner, NonInteractionSingle) or \
+                    isinstance(partner, Multi) or \
+                    isinstance(partner, PlanarSurface) or \
+                    isinstance(partner, CylindricalSurface)), \
+                    'multi_partner %s was not of proper type' % (partner)
+
         if neighbors:
             closest = neighbors[0]
         else:
@@ -2195,8 +2197,10 @@ def form_multi(self, single, multi_partners):
         # 2. Add the single and neighbors to the Multi
         self.add_to_multi(single, multi)
         self.remove_domain(single)
-        for neighbor in neighbors:
-            self.add_to_multi_recursive(neighbor, multi)
+
+        # TODO add them here or let the scheduler handle this?
+#        for neighbor in neighbors:
+#            self.add_to_multi_recursive(neighbor, multi)
 
 
         # 3. Initialize and (re-)schedule
@@ -2210,29 +2214,40 @@ def form_multi(self, single, multi_partners):
 
 
     def add_to_multi_recursive(self, domain, multi):
+    # adds 'domain' (which can be zero-dt NonInteractionSingle or Multi) to 'multi'
+
         if isinstance(domain, NonInteractionSingle):
+            assert domain.is_reset()        # domain must be zero-dt NonInteractionSingle
+
             if multi.has_particle(domain.pid_particle_pair[0]):
                 # Already in the Multi.
+                if __debug__:
+                    log.debug('%s already in multi. skipping.' % domain)
                 return
-            assert domain.is_reset()
+
             dompos = domain.shell.shape.position
             
-            self.add_to_multi(domain, multi)
-            self.remove_domain(domain)
-            self.remove_event(domain)
-
+            # 1. burst to make space for the multi shell
             # TODO this is expensive/stupid -> fix
-            radius = domain.pid_particle_pair[1].radius * \
-                self.MULTI_SHELL_FACTOR
+            burstradius = domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
             neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(
-                    dompos, radius, ignore=[domain.domain_id])
+                    dompos, burstradius, ignore=[domain.domain_id, multi.domain_id])
             neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
             burst = self.burst_non_multis(neighbors)
+
+            # 2. add domain to the multi
+            self.add_to_multi(domain, multi)
+            self.remove_domain(domain)
+            self.remove_event(domain)
+
+            # get distances to closest shell of burst neighbors
             neighbor_dists = self.obj_distance_array(dompos, burst)
+            # 3. select neighbors in the 'multi_horizon' for adding to the multi
             neighbors = [burst[i] for i
-                                  in (neighbor_dists <= radius).nonzero()[0]]
+                                  in (neighbor_dists <= burstradius).nonzero()[0]]
 
+            # 4. not sure we really want to do this
             for domain in neighbors:
                 self.add_to_multi_recursive(domain, multi)
 
@@ -2249,6 +2264,9 @@ def add_to_multi_recursive(self, domain, multi):
             assert False, 'Trying to add non Single or Multi to Multi.'
 
     def add_to_multi(self, single, multi):
+    # This method is similar to the 'create_' methods for pair and interaction, except it's now for a multi
+    # adding a single to the multi instead of creating a pair or interaction out of single(s)
+
         if __debug__:
             log.info('add to multi:\n  %s\n  %s' % (single, multi))
 

From bd5e595d33b540a56b70d1506b6c2cd3d5439b90 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 22 Nov 2011 14:50:04 +0100
Subject: [PATCH 0398/1541] Weiter...

---
 GreensFunction1DAbsSinkAbs.cpp | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index f2c611f7..c0ed497c 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -17,12 +17,11 @@
 #include "findRoot.hpp"
 #include "GreensFunction1DAbsSinkAbs.hpp"
 
-// This is the appropriate definition of the function defining
-// the roots of our Green's functions in GSL.
-// Later needed by the rootfinder.
+/* This is the appropriate definition of the function defining
+   the roots of our Green's functions in GSL.
+   Later needed by the rootfinder. */
 Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
 {
-    // casts the void to the struct pointer
     struct root_f_params *params = (struct root_f_params *)p;
     const Real Lm_L = (params->Lm_L);
     const Real h = (params->h);
@@ -32,10 +31,13 @@ Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
     // L_Lm = Lr + Ll / Lr - Ll
     // x    = q * L
 
-    return x * sin(x) + h * ( cos(x * Lm_L) - cos(x) );
+    if( h <= 1 )
+        return x * sin(x) + h * ( cos(x * Lm_L) - cos(x) );
+    else
+        return Real();
 }
 
-// Calculates the roots of tan(x*a)=-x/h
+/* Calculates the roots of root_f */
 Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
 {
     const Real L( getLr() + getLl() );
@@ -44,8 +46,9 @@ Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
     
     Real upper, lower;  
 
-    //h sets how strong second term in root function is pronounced. 
-    if ( h < 1 )
+    /* h sets how strong second term in root function is pronounced. 
+       The second term makes the rootfinding more complex. */
+    if ( h <= 1 )
     {
 	    // 1E-10 to make sure that he doesn't include the transition 
 	    lower = (n-.5)*M_PI;

From e574f5f1ed4420bac29cd6b363c383e273bfb167 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 Nov 2011 15:58:46 +0100
Subject: [PATCH 0399/1541] changed overlap method to return distance between
 shells Not just True or False for overlap, but positive number for no overlap
 and negative number for overlap (now denotes the amount of overlap)

---
 egfrd.py | 31 +++++++++++++++++++++----------
 pair.py  |  1 +
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 323edc2e..b815a262 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2169,7 +2169,7 @@ def form_multi(self, single, multi_partners):
 
         # Filter out relevant neighbors if present
         # only consider objects that are within the Multi horizon
-        neighbors = [obj for obj, overlap in multi_partners if overlap < 0]
+        neighbors = [obj for (obj, overlap) in multi_partners if overlap < 0]
         for partner in neighbors:
             assert (isinstance(partner, NonInteractionSingle) or \
                     isinstance(partner, Multi) or \
@@ -2405,9 +2405,10 @@ def check_domain(self, domain):
 
             for neighbor, _ in neighbors:
                 for _, neighbor_shell in neighbor.shell_list:
-                    assert self.check_shell_overlap(shell, neighbor_shell), \
-                        '%s (%s) overlaps with %s (%s).' % \
-                        (str(domain), str(shell), str(neighbor), str(neighbor_shell))
+                    overlap = self.check_shell_overlap(shell, neighbor_shell)
+                    assert overlap >= 0.0, \
+                        '%s (%s) overlaps with %s (%s) by %s.' % \
+                        (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
 
 #            # testing overlap criteria
 #            # TODO This doesn't work if closest is a Multi -> redesign this test
@@ -2467,39 +2468,49 @@ def check_domain(self, domain):
     def check_shell_overlap(self, shell1, shell2):
     # Returns True if the shells DO NOT overlap
     # Returns False if the shells DO overlap
+    # Return the amount of overlap (positive number means no overlap, negative means overlap)
 
         # overlap criterium when both shells are spherical
         if (type(shell1.shape) is Sphere) and (type(shell2.shape) is Sphere):
             distance = self.world.distance(shell1.shape.position, shell2.shape.position)
-            return (shell1.shape.radius + shell2.shape.radius) < distance
+            return distance - (shell1.shape.radius + shell2.shape.radius)
 
         # overlap criterium when both shells are cylindrical 
         elif (type(shell1.shape) is Cylinder) and (type(shell2.shape) is Cylinder):
             # assuming that the cylinders are always parallel
-            assert abs(numpy.dot (shell1.shape.unit_z, shell2.shape.unit_z)) == 1
+            assert feq(abs(numpy.dot (shell1.shape.unit_z, shell2.shape.unit_z)), 1.0), \
+                'shells are not oriented parallel, dot(unit_z1, unit_z2) = %s' % \
+                (abs(numpy.dot (shell1.shape.unit_z, shell2.shape.unit_z)))
+
             shell1_pos = shell1.shape.position
             shell2_pos = shell2.shape.position
             shell2_post = self.world.cyclic_transpose(shell1_pos, shell2_pos)
             inter_pos = shell1_pos - shell2_pos
             inter_pos_z = shell1.shape.unit_z * numpy.dot(inter_pos, shell1.shape.unit_z)
             inter_pos_r = inter_pos - inter_pos_z
-            return not (((shell1.shape.half_length + shell2.shape.half_length) > length(inter_pos_z)) and \
-                       ((shell1.shape.radius + shell2.shape.radius) > length(inter_pos_r)))
+            overlap_r = length(inter_pos_r) - (shell1.shape.radius + shell2.shape.radius)
+            overlap_z = length(inter_pos_z) - (shell1.shape.half_length + shell2.shape.half_length)
+            if (overlap_r < 0.0) and (overlap_z < 0.0):
+                return -1           # TODO: find better number for overlap measure
+            else:
+                return 1
+
 
         # overlap criterium when one shell is spherical and the other is cylindrical
         elif (type(shell1.shape) is Sphere) and (type(shell2.shape) is Cylinder):
             distance = self.world.distance(shell2.shape, shell1.shape.position)
-            return (shell1.shape.radius) < distance
+            return distance - shell1.shape.radius
 
         # the other way around
         elif (type(shell1.shape) is Cylinder) and (type(shell2.shape) is Sphere):
             distance = self.world.distance(shell1.shape, shell2.shape.position)
-            return (shell2.shape.radius) < distance
+            return distance - shell2.shape.radius
 
         # something was wrong (wrong type of shell provided)
         else:
             raise RuntimeError('check_shell_overlap: wrong shell type(s) provided.')
 
+
     def check_surface_overlap(self, shell, surface):
         if (type(shell.shape) is Sphere):
             distance = self.world.distance(surface.shape, shell.shape.position)
diff --git a/pair.py b/pair.py
index 09a004bb..fa61c1b5 100644
--- a/pair.py
+++ b/pair.py
@@ -201,6 +201,7 @@ def get_min_shell_size(cls, single1, single2, geometrycontainer):
         sigma = radius1 + radius2
         r0 = geometrycontainer.world.distance(pos1, pos2)
 #        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
+
         assert r0 >= sigma, \
             'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
             (single1, single2, FORMAT_DOUBLE % (r0 - sigma))

From b576e0d5d6474fc3b0e76910d29b69906fe38e59 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 Nov 2011 16:05:17 +0100
Subject: [PATCH 0400/1541] fixed stupid typo

---
 egfrd.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b815a262..707a8608 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1298,9 +1298,9 @@ def make_new_domain(self, single):
                 # TODO get a list of the surfaces sorted by distance instead of just the closest
                 closest_surface, surface_distance = \
                     get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
-                surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
                 if closest_surface:
-                    interaction_partners = [(closest_surface, surface_distance - surface_horizon, surface_horizon), ]
+                    surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
+                    interaction_partners = [(closest_surface, surface_distance - surface_horizon), ]
                 # else no interaction is possible
 
             multi_partners = multi_partners + interaction_partners

From 4882d18543edd01a215854d3d2cb0c5aaddbf3f2 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 22 Nov 2011 17:23:24 +0100
Subject: [PATCH 0401/1541] Added Laurens code / debug info in newBD.

---
 newBDPropagator.hpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index d7331178..68fd2aa0 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -267,6 +267,26 @@ class newBDPropagator
             
             j++;
         }
+        
+        
+        /*Debug overlap failed error.
+        std::cerr << " &&&& : " << pp.first << std::endl;
+        
+        j = 0;
+        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_last( 
+                    tx_.check_overlap( particle_shape_type( new_pos, 10*r0 ), 
+                            pp.first) );
+                            
+        particles_in_overlap = overlapped_last ? overlapped_last->size(): 0;
+        while(j < particles_in_overlap)
+        {
+            particle_id_pair_and_distance const& closest( overlapped_last->at(j++) );
+            const Real dist( tx_.distance( closest.first.second.position(), pp.second.position() ) );
+            std::cerr << "### pp id: " << pp.first << " ppi id: " << closest.first.first << " ipv length @ old_pos = " << dist << 
+                " dist till shell @ new_pos: " << closest.second << std::endl;
+            std::cerr << "Bounced? " << bounced << ", d (after move) = " << tx_.distance( new_pos, closest.first.second.position() ) << std::endl;
+        }
+        */
                        
         /* If the particle did neither react, interact or bounce, update it to it's new position. */
         if(!bounced)

From aab9838bceaa5c12b88c579e92346cc9351553f2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 Nov 2011 17:47:11 +0100
Subject: [PATCH 0402/1541] small fixes and change of system parameters -If
 domain making was succesfull than no more trying is wanted -multi horizon
 should also include a factor correcting for the fact that one could be a
 cylinder -you can't print a 300 digit number!

---
 egfrd.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 707a8608..8e692f8f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -115,7 +115,8 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.shell_id_generator = ShellIDGenerator(0)
 
         # some constants
-        self.MULTI_SHELL_FACTOR = 1.2           # This is the threshold for when the algorithm switches from
+        self.MULTI_SHELL_FACTOR = math.sqrt(2)  # This stems from the fact that there vacant space in the cylinder
+#        self.MULTI_SHELL_FACTOR = 1.2           # This is the threshold for when the algorithm switches from
                                                 # NonInteractionSingles to a Multi and also defines the Multi
                                                 # shell size.
         self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
@@ -354,7 +355,7 @@ def step(self):
                 if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
                     raise RuntimeError('too many dt=zero steps. '
                                        'Simulator halted?'
-                                    'dt= %.300g-%.300g' % (self.scheduler.top[1].time, self.t))
+                                    'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
             else:
                 self.zero_steps = 0
 
@@ -1248,8 +1249,9 @@ def make_new_domain(self, single):
         domain = None
         for obj, hor_overlap in pair_interaction_partners:
 
-            if hor_overlap > 0.0:
+            if hor_overlap > 0.0 or domain:
                 break       # there are no more potential partners (everything is out of range)
+                            # or a domain was formed successfully previously
 
             if isinstance(obj, NonInteractionSingle):
 #                pair_horizon = (single_radius + \
@@ -1279,10 +1281,10 @@ def make_new_domain(self, single):
             multi_partners = []
             for domain, dist_to_shell in neighbors:
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
-                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
+                    multi_horizon = (single_radius ) * self.MULTI_SHELL_FACTOR
                     # distance from the center of the particles/domains
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
-                    multi_partners.append((domain, distance - multi_horizon))
+                    multi_partners.append((domain, dist_to_shell - multi_horizon))
 
                 elif isinstance(domain, Multi):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle

From d2863f6af0d1b86c1ba8ad6e060b9b26f444df9f Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 22 Nov 2011 21:15:48 +0100
Subject: [PATCH 0403/1541] Done debugging GFn. Als functions return sensible
 results.

---
 GreensFunction1DAbsSinkAbs.cpp | 114 ++++++++++++++++++---------------
 GreensFunction1DAbsSinkAbs.hpp |   6 +-
 2 files changed, 66 insertions(+), 54 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index c0ed497c..e72855b6 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -31,7 +31,7 @@ Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
     // L_Lm = Lr + Ll / Lr - Ll
     // x    = q * L
 
-    if( h <= 1 )
+    if( h <= 10.0 )
         return x * sin(x) + h * ( cos(x * Lm_L) - cos(x) );
     else
         return Real();
@@ -48,7 +48,7 @@ Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
 
     /* h sets how strong second term in root function is pronounced. 
        The second term makes the rootfinding more complex. */
-    if ( h <= 1 )
+    if ( h <= 10.0 )
     {
 	    // 1E-10 to make sure that he doesn't include the transition 
 	    lower = (n-.5)*M_PI;
@@ -507,7 +507,7 @@ Real GreensFunction1DAbsSinkAbs::drawT_f (Real t, void *p)
            n <= MIN_TERMS );
 
     // find the intersection with the random number
-    return 1.0 - prefactor*sum - params->rnd;
+    return params->rnd - prefactor*sum;
 }
 
 // Draws the first passage time from the survival probability,
@@ -526,7 +526,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     const Real L0( getL0() );
     const Real L( getLr() + getLl() );
 
-    Real root_n, Xn, exponent;
+    Real root_n, Xn, exponent, term1, term2, numerator;
 
     if ( D == 0.0 || L == INFINITY )
     {
@@ -540,19 +540,18 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 
     // the structure to store the numbers to calculate the numbers for 1-S
     struct drawT_params parameters;
-    // some temporary variables
 
-    // produce the coefficients and the terms in the exponent and put them
-    // in the params structure. This is not very efficient at this point,
-    // coefficients should be calculated on demand->TODO or not TODO?
-    for (int n=0; n<MAX_TERMS; n++)
+    /* produce the coefficients and the terms in the exponent and put them
+       in the params structure. This is not very efficient at this point,
+       coefficients should be calculated on demand->TODO or not TODO? */
+    for (int n = 0; n < MAX_TERMS; n++)
     {
         root_n = this->root_n( n + 1 );	
-	    
-        const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
-        const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+
+        term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
+        term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
         
-        const Real numerator( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
+        numerator = D * term1 + k * sin( root_n * Ll ) * term2 / root_n;
         Xn = numerator / p_denominator( root_n );
 		      
         exponent = - D * gsl_pow_2( root_n );
@@ -659,15 +658,15 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
     
     /* Determine in which part of the domain rr lies, and
        thus which domain function to use. */
-    static Real (*numerator_int_f)
+    static Real (*p_int_r)
         (Real const&, Real const&, drawR_params const&) = NULL;
 
     if( rr <= 0 )
-        numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_leftdomain;
+        p_int_r = &GreensFunction1DAbsSinkAbs::p_int_r_leftdomain;
     else if( rr < params->L0 )
-            numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA;
+            p_int_r = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA;
         else
-            numerator_int_f = &GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB;
+            p_int_r = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB;
     
     int n = 0;
     do
@@ -680,7 +679,7 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
 	    }
 	    prev_term = term_n;
 
-	    term_n = params->exp_and_denominator[n] * (*numerator_int_f)
+	    term_n = params->exp_and_denominator[n] * (*p_int_r)
             ( rr, params->root_n[n], *params );
 
 	    sum += term_n;
@@ -689,80 +688,92 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
     while (fabs(term_n/sum) > EPSILON*1.0 ||
 	       fabs(prev_term/sum) > EPSILON*1.0 ||
            n <= MIN_TERMS );
-
+    
     // Find the intersection with the random number
     return params->prefactor * sum - params->rnd;
 }
 
 //Integrated Greens function for rr part of [-Ll, 0]
-Real GreensFunction1DAbsSinkAbs::num_int_r_leftdomain(Real const& rr, 
-                                                      Real const& root_n,
-                                                      drawR_params const& params)
+Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(Real const& rr, 
+                                                    Real const& root_n,
+                                                    drawR_params const& params)
 {
-    const Real Ll_L0( params.Ll - params.L0 );
-    const Real Ll_rr( params.Ll + rr );
-    
-    return params.D * sin( root_n * Ll_L0 ) * ( cos( root_n * Ll_rr ) - 1 );
+    const Real LrmL0( params.Lr - params.L0 );
+    const Real Llprr( params.Ll + rr );
+   
+    return params.D * sin( root_n * LrmL0 ) * ( cos( root_n * Llprr ) - 1.0 );
 }
 
 //Integrated Greens function for rr part of (0, L0]
-Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainA(Real const& rr, 
-                                                        Real const& root_n, 
-                                                        drawR_params const& params)
+Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(Real const& rr, 
+                                                      Real const& root_n, 
+                                                      drawR_params const& params)
 {
-    const Real Lr_L0( params.Lr - params.L0 );
-    const Real Ll_rr( params.Ll + rr );
+    const Real LrmL0( params.Lr - params.L0 );
+    const Real Llprr( params.Ll + rr );
     const Real root_n_rr( root_n * rr );
     
-    const Real temp( params.D * ( cos( root_n * Ll_rr ) - 1 ) + 
+    const Real temp( params.D * ( cos( root_n * Llprr ) - 1.0 ) + 
             params.k / root_n * ( cos( root_n_rr ) - 1 ) * sin( root_n * params.Ll ) );
     
-    return sin( root_n * Lr_L0 ) * temp;
+    return sin( root_n * LrmL0 ) * temp;
 }
 
 //Integrated Greens function for rr part of (L0, Lr]
-Real GreensFunction1DAbsSinkAbs::num_int_r_rightdomainB(Real const& rr, 
-                                                        Real const& root_n, 
-                                                        drawR_params const& params)
+Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(Real const& rr, 
+                                                      Real const& root_n, 
+                                                      drawR_params const& params)
 {
     const Real Lr( params.Lr );
     const Real Ll( params.Ll );
     const Real L0( params.L0 );
-    const Real Lr_L0( Lr - L0 );
-    const Real Lr_rr( Lr - rr );
+    const Real LrmL0( Lr - L0 );
+    const Real Lrmrr( Lr - rr );
     const Real L( Lr + Ll );
+    const Real LlpL0( Ll + L0 );
                    
-    const Real term1( sin( root_n * L ) - sin( root_n * Lr_L0 ) - 
-            sin( root_n * (Ll + L0) ) * cos( root_n * Lr_rr ) );
+    const Real term1( sin( root_n * L ) - sin( root_n * LrmL0 ) - 
+            sin( root_n * LlpL0 ) * cos( root_n * Lrmrr ) );
             
-    const Real term2( sin( root_n * Lr ) - sin( root_n * Lr_L0 ) -
-            sin( root_n * L0 ) * cos( root_n * Lr_rr ));
+    const Real term2( sin( root_n * Lr ) - sin( root_n * LrmL0 ) -
+            sin( root_n * L0 ) * cos( root_n * Lrmrr ));
         
     return params.D * term1 + params.k * sin( root_n * Ll ) * term2 / root_n;
 }
 
 Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 {
-    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
+    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd <= 1.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
     
     const Real D( getD() );
-    const Real L( getLr() + getLl() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real rsink( getrsink() );
+    const Real L( Lr + Ll );
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
 	    // the trivial case
 	    return r0;
     }
+
     if ( L < 0.0 )
     {
 	    // if the domain had zero size
 	    return 0.0;
     }
 
+    if ( rnd <= EPSILON )
+    {
+        return -Ll;        
+    }
+
+    if( rnd >= ( 1 - EPSILON ) )
+    {
+        return Lr;
+    }
+
     // the structure to store the numbers to calculate r.
     struct drawR_params parameters;
     const Real S( p_survival(t) );
@@ -780,16 +791,12 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 	    parameters.root_n[n] = root_n;
         // also store the exponent and denominator.
         parameters.exp_and_denominator[n] = Greens_fn( t, root_n, root_n2 );
-        // and the normalization.
-        parameters.prefactor = 2.0 / S;
     }
     
-    // define gsl function for rootfinder
-    gsl_function F;
-    F.function = &drawR_f;
-    F.params = &parameters;
+    // The normalization.
+    parameters.prefactor = 2.0 / S;
 
-    // store the random number and L0
+    // and the rest of the parameters
     parameters.rnd = rnd;
     parameters.L0 = getL0();
     parameters.Lr = getLr();
@@ -800,6 +807,11 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     // store the number of terms used
     parameters.terms = MAX_TERMS;
 
+    // define gsl function for rootfinder
+    gsl_function F;
+    F.function = &drawR_f;
+    F.params = &parameters;
+
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     // make a new solver instance
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 867272f3..2e73963a 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -228,11 +228,11 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     
     inline Real Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const;
 
-    static Real num_int_r_leftdomain(Real const& rr, Real const& root_n, drawR_params const& params);
+    static Real p_int_r_leftdomain(Real const& rr, Real const& root_n, drawR_params const& params);
 
-    static Real num_int_r_rightdomainA(Real const& rr, Real const& root_n, drawR_params const& params);
+    static Real p_int_r_rightdomainA(Real const& rr, Real const& root_n, drawR_params const& params);
 
-    static Real num_int_r_rightdomainB(Real const& rr, Real const& root_n, drawR_params const& params);
+    static Real p_int_r_rightdomainB(Real const& rr, Real const& root_n, drawR_params const& params);
 
     static Real root_f (Real x, void *p);
 

From 0f2d9d647cf71fdd2112f4088f84a002f9c85355 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 24 Nov 2011 15:56:26 +0100
Subject: [PATCH 0404/1541] Inproved Rootfinder, introduced rootsList.

---
 GreensFunction1DAbsSinkAbs.cpp | 207 +++++++++++++++++++++++++--------
 GreensFunction1DAbsSinkAbs.hpp |  50 ++++++--
 GreensFunction1DRadAbs.cpp     |   2 +-
 3 files changed, 204 insertions(+), 55 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index e72855b6..3de6f8f6 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -31,60 +31,171 @@ Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
     // L_Lm = Lr + Ll / Lr - Ll
     // x    = q * L
 
-    if( h <= 10.0 )
-        return x * sin(x) + h * ( cos(x * Lm_L) - cos(x) );
-    else
-        return Real();
+    return x * sin(x) + h * ( cos(x * Lm_L) - cos(x) );
+
 }
 
-/* Calculates the roots of root_f */
-Real GreensFunction1DAbsSinkAbs::root_n(int const& n) const
+/* Calculates the first n roots of root_f */
+void GreensFunction1DAbsSinkAbs::calculate_n_roots(int const& n) const
 {
-    const Real L( getLr() + getLl() );
-    const Real Lm( getLr() - getLl() );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L( Lr + Lr );
+    const Real Lm( Lr - Ll );
+    const Real Lm_L( Lm / L );
     const Real h( getk() * L / ( 2 * getD() ) );
     
-    Real upper, lower;  
+    Real root_i;
+    unsigned int i = 0;
 
-    /* h sets how strong second term in root function is pronounced. 
-       The second term makes the rootfinding more complex. */
-    if ( h <= 10.0 )
-    {
-	    // 1E-10 to make sure that he doesn't include the transition 
-	    lower = (n-.5)*M_PI;
-	    // (asymptotic) from infinity to -infinity
-	    upper = (n+.5)*M_PI;
-    }
-    else
-    {
-        //TODO: more complicated scheme needed.
-        THROW_UNLESS( std::invalid_argument, h < 1 );
-        lower = (n-.5)*M_PI;
-	    upper = (n+.5)*M_PI;      
-    }
+    /* Stores the last roots found with a low and a high
+       frequency resp. */
+    real_pair last_roots, lower_upper_pair;
+
+    /* set params needed for get lower and upper function */
+    lower_upper_params lo_up_params;
+    lo_up_params.h = h;
+    lo_up_params.Lm_L = Lm_L;
+    lo_up_params.long_half_wave = max( L/Lr * M_PI, L/Ll * M_PI );
+    lo_up_params.short_half_wave = min( L/Lr * M_PI, L/Ll * M_PI );
 
+    /* Define the root function. */
     gsl_function F;
-    struct root_f_params params = { Lm / L, h };
+    struct root_f_params params = { Lm_L, h };
      
     F.function = &GreensFunction1DAbsSinkAbs::root_f;
     F.params = &params;
 
-    // define a new solver type brent
+    /* define and ad a new solver type brent */
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
-
-    // make a new solver instance
-    // TODO: incl typecast?
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-    // get the root = run the rootsolver
-    const Real root( findRoot( F, solver, lower, upper, 1.0*EPSILON, EPSILON,
-                            "GreensFunction1DAbsSinkAbs::root_f" ) );
+
+    /* Find the n roots */
+    while(i++ < n)
+    {
+        lower_upper_pair = get_lower_and_upper( last_roots, lower_upper_params );
+
+        root_i = findRoot( F, solver, lower_upper_pair.first, lower_upper_pair.second, 
+                           1.0*EPSILON, EPSILON, "GreensFunction1DAbsSinkAbs::root_f" );
+
+        assert( root_i > get_last_root() - EPSILON );
+
+        ad_to_rootList( root_i );       
+
+        if( root_i - last_roots.first < root_i - last_roots.second )
+            last_roots.first = root_i;
+        else
+            last_roots.second = root_i;
+    }
+
     gsl_root_fsolver_free( solver );
-    
-    return root/L;
+}
+
+/* Function returns two points on the x-axis which straddle the next root. */
+real_pair GreensFunction1DAbsSinkAbs::get_lower_and_upper( real_pair& last_roots, 
+                                                           lower_upper_params const& params )
+{
+    const Real root_n( get_last_root() );
+    const Real safety( .75 );
+
+    Real lower, upper, next_root_est, max_offset;
+
+    if( params.h / root_n < 1 )
+    {
+        max_offset = M_PI;
+        next_root_est = root_n + M_PI;
+    }
+    else
+    {
+        const Real next_root_long( last_roots.first + params.long_half_wave );
+        const Real next_root_short( last_roots.second + params.short_half_wave );
+
+        if( next_root_long < next_root_short )
+        {
+            next_root_est = next_root_long;
+
+            max_offset = min( next_root_short - next_root_est, 
+                              params.long_half_wave );
+        }
+        else
+        {
+            next_root_est = root_n + next_root_short;
+            
+            max_offset = min( next_root_long - next_root_est, 
+                              params.short_half_wave );
+        }
+    }
+       
+    lower = next_root_est - safety * max_offset;
+    upper = next_root_est + safety * max_offset;
+
+    struct root_f_params p = { params.Lm_L, params.h };
+
+    Real f_lower( root_f( lower, p ) );
+    Real f_upper( root_f( upper, p ) );
+    bool odd( (get_rootList.size() + 1)%2 );
+    /* if 'endpoints do not straddle' */
+    if( f_lower * f_higher > 0 )
+    {
+        std::cerr << "An endpoints do not straddle is imminent!" << std::endl;
+        std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
+                  << upper << ") = " << f_upper << std::endl;
+        /*
+        if( odd )
+        {
+            while( f_lower < 0 )
+            {
+                
+            }
+                
+
+        }
+        else
+        {
+
+        }
+        */
+    }    
+
+    return real_pair( lower, upper );
+}
+
+/* returns a guess for the number of terms needed for 
+   the greensfunction to converge at time t */
+unsigned int GreensFunction1DAbsSinkAbs::guess_maxi(Real t) const
+{
+    const unsigned int safety(2);
+
+    if (t >= INFINITY)
+    {
+        return safety;
+    }
+
+    const Real D( getD() );
+
+    const Real root0( get_root( 0 ) );
+    const Real Dt(D * t);
+
+    const Real thr(exp(- Dt * root0 * root0) * this->TOLERANCE * 1e-1);
+
+    if (thr <= 0.0)
+    {
+        return this->MAX_TERMS;
+    }
+
+    const Real max_root(sqrt(root0 * root0 - log(thr) / Dt));
+
+    const unsigned int 
+        maxi(safety + 
+             static_cast<unsigned int>(max_alpha * getL() / M_PI));
+
+    return std::min(maxi, MAX_TERMS);
 }
 
 /* Standart form of the greensfunction */
-inline Real GreensFunction1DAbsSinkAbs::Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const
+inline Real GreensFunction1DAbsSinkAbs::Greens_fn(Real const& t, 
+                                                  Real const& root_n, 
+                                                  Real const& root_n2) const
 {
     return exp( - getD() * root_n2 * t ) / p_denominator( root_n );
 }
@@ -133,7 +244,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
 	    }
 	    prev_term = numerator;
     
-        root_n = this->root_n(n);
+        root_n = get_root(n);
         term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
         term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
         
@@ -220,7 +331,7 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 	        }
 	        prev_term = term_n;
 
-	        root_n = this->root_n(n);
+	        root_n = get_root(n);
 
             numerator =  D * root_n * sin( root_n * LlpL0 ) + 
                 k * sin( root_n * Ll ) * sin( root_n * L0);
@@ -333,7 +444,7 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
         }
         prev_term = term_n;
     
-        root_n = this->root_n(n);
+        root_n = get_root(n);
         root_n2 = gsl_pow_2( root_n );
 
         term1 = sin( root_n * L ) - sin( root_n * LrmL0 ) - sin( root_n * LlpL0 );
@@ -375,7 +486,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
         }
         prev_term = term_n;
     
-        root_n = this->root_n(n);
+        root_n = get_root(n);
         
         numerator = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
         numerator *= root_n;
@@ -412,7 +523,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
         }
         prev_term = term_n;
     
-        root_n = this->root_n(n);
+        root_n = get_root(n);
         root_n2 = gsl_pow_2( root_n );        
         
         numerator = root_n2 * sin( root_n * LrmL0 );
@@ -546,7 +657,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
        coefficients should be calculated on demand->TODO or not TODO? */
     for (int n = 0; n < MAX_TERMS; n++)
     {
-        root_n = this->root_n( n + 1 );	
+        root_n = get_root( n + 1 );	
 
         term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
         term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
@@ -781,17 +892,19 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 
     assert(S >= 0.0);
 
-    // produce the coefficients and the terms in the exponent and put them
-    // in the params structure //TODO: MAX_TERM -> CONVERGENCE_TERMS
+    /* produce the coefficients and the terms in the exponent and put them
+       in the params structure //TODO: MAX_TERM -> CONVERGENCE_TERMS */
     for (int n = 0; n < MAX_TERMS; n++)
     {
-	    root_n = this->root_n(n+1);
+	    root_n = get_root(n+1);
        	root_n2 = gsl_pow_2( root_n );
-      	// store the roots in the structure
-	    parameters.root_n[n] = root_n;
+
         // also store the exponent and denominator.
         parameters.exp_and_denominator[n] = Greens_fn( t, root_n, root_n2 );
     }
+
+    //Store pointer to the rootList in params.
+    parameters.rootListPtr = get_rootListPtr();
     
     // The normalization.
     parameters.prefactor = 2.0 / S;
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 2e73963a..80bc9f48 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -40,6 +40,9 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     static const int MIN_TERMS = 20;
 
 public:
+    typedef std::pair<Real, Real> real_pair;
+    typedef vector<Real> RealVector;
+
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
 	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
@@ -187,15 +190,31 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     {
         return "GreensFunction1DAbsSinkAbs";
     }
-
-    // Calculates the roots of x * sin(x) + k * L / (2 * D) * ( cos(x * (Lr - Ll)/L) - cos(x) ) 
-    Real root_n(int const& n) const;
     
 private:
 
+    /* return a reference to the rootList */
+    RealVecor& get_rootList() const
+    {
+        return rootList;
+    }
+
+    /* returns last root. */
+    Real get_last_root() const
+    {
+        return rootList.back();
+    }
+
+    /* return the n'th root */
+    Real get_root( unsigned inst const n ) const
+    {
+        return rootList[ n ];
+    }
+
     struct drawR_params
     {
-	    Real root_n[MAX_TERMS];
+        //Real root_n[MAX_TERMS];
+        vector<Real> *rootListPtr;
 	    Real exp_and_denominator[MAX_TERMS];
 	    Real prefactor;
         Real L0;
@@ -223,21 +242,35 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    Real Lm_L;
 	    Real h;
     };
-       
+
+    /* Try to guess number of terms needed for convergence, given t. */
+    unsigned int guess_maxi( Real t ) const;
+
+    /* Function needed for rootfinding */
+    static Real root_f(Real x, void *p);
+
+    /* Function returns i'th element in rootList */
+    Real get_root(unsigned int i) const;
+    
+    /* Denominator of the Greens function */
     inline Real p_denominator( Real const& root_n ) const;
     
+    /* Standard form of Greens Function: exp( -Dt root_n ** 2 ) / denominator */
     inline Real Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const;
 
+    /* p_int_r(r') for r' in left domain */
     static Real p_int_r_leftdomain(Real const& rr, Real const& root_n, drawR_params const& params);
 
+    /* p_int_r(r') for r' in right domain, left of r0 */
     static Real p_int_r_rightdomainA(Real const& rr, Real const& root_n, drawR_params const& params);
 
+    /* p_int_r(r') for r' in right domain, right of r0 */
     static Real p_int_r_rightdomainB(Real const& rr, Real const& root_n, drawR_params const& params);
 
-    static Real root_f (Real x, void *p);
-
+    /* Function for drawR */
     static Real drawT_f (Real t, void *p);
 
+    /* Function for drawTime */
     static Real drawR_f (Real t, void *p);
 
     /* Class variables */
@@ -267,5 +300,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     Real Ll;
     // Distance between the sink and r0.
     Real L0;
+
+    // Stores all the roots.
+    RealVector rootList;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 044dc6d7..6fb0efba 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -32,7 +32,7 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
     const Real h = (params->h);
     const Real h_a (h*a);
 
-    if ( h_a < 1 )
+    if ( fabs( h_a ) < 1 )
     {
 	// h = k/D
 	return 1/tan(x) + (h_a)/x;

From 9214ff159735da13dc1d88e3592a620eba235bed Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 24 Nov 2011 18:11:53 +0100
Subject: [PATCH 0405/1541] changes to Laurens algorithm such that it also
 supports cylinders as neighboring shells

---
 pair.py | 152 +++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 96 insertions(+), 56 deletions(-)

diff --git a/pair.py b/pair.py
index fa61c1b5..7a99c996 100644
--- a/pair.py
+++ b/pair.py
@@ -803,6 +803,7 @@ def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
         
         # get all the domains in the neighborhood
         search_point = reference_point + ((z_right - z_left)/2.0) * orientation_vector
+        search_point = geometrycontainer.world.apply_boundary(search_point)
         all_neighbor_ids = \
             geometrycontainer.get_neighbors_within_radius_no_sort(search_point,
                                                      geometrycontainer.get_max_shell_size(),
@@ -817,7 +818,7 @@ def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
                 for _, shell in domain.shell_list:
                     shell_position = shell.shape.position
                     shell_size = shell.shape.radius
-                    r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
+                    r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, shell,
                                                                      reference_point, orientation_vector, r, z_left,
                                                                      z_right, world)
             else:
@@ -829,7 +830,7 @@ def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
                     # Or a particle that just escaped it's multi.
                     shell_size *= Domain.SINGLE_SHELL_FACTOR
 
-                r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size,
+                r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, domain.shell,
                                                                  reference_point, orientation_vector, r, z_left,
                                                                  z_right, world)
 
@@ -838,7 +839,7 @@ def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
         return r, z_left, z_right
 
     @classmethod
-    def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, reference_point,
+    def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, shell, reference_point,
                           orientation_vector, r, z_left, z_right, world):
 
         D1 = single1.pid_particle_pair[1].D
@@ -847,11 +848,14 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
 
         # determine on what side the midpoint of the shell is relative to the reference_point
         shell_position_t = world.cyclic_transpose (shell_position, reference_point)
-        direction = numpy.dot(shell_position_t - reference_point, orientation_vector)
+        ref_to_shell = shell_position_t - reference_point
+        ref_to_shell_z_len = numpy.dot(ref_to_shell, orientation_vector)
+        ref_to_shell_z = ref_to_shell_z_len * orientation_vector
+        ref_to_shell_r = ref_to_shell - ref_to_shell_z
 
         # if the shell is on the side of orientation_vector -> use z_right
         # also use this one if the shell is in plane with the reference_point
-        if direction >= 0:
+        if ref_to_shell_z_len >= 0:
             phi = cls.calc_right_scalingangle(D1, D2)
             scalecenter_h0 = cls.z_right(single1, single2, r0, 0.0)   # r = 0.0
             r1_function =  cls.r_right
@@ -872,67 +876,101 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
             z2 = z_right
             direction = -1
 
+
+        # calculate the orientation vectors
+        orientation_vector_z = orientation_vector * direction
+        if length(ref_to_shell_r) == 0:
+            # produce a random vector perpendicular to the 'orientation_vector_z'
+            unit_vector3D = random_unit_vector()
+            orientation_vector_r = normalize(unit_vector3D - numpy.dot(unit_vector3D, orientation_vector_z))
+        else:
+            orientation_vector_r = normalize(ref_to_shell_r)
+
+
         # calculate the center from which linear scaling will take place
-        # TODO this should be generalized to accomodate scaling in just z
-        # TODO Also the scale center is still strangly defined.
         if phi == 0.0:
             scalecenter_r0 = r  # This is an approximation, since the h0 is infinitely far away of phi == 0,
         else:                   # we introduce an r0
             scalecenter_r0 = 0
-        # TODO check this
-        scale_center = reference_point + scalecenter_h0 * direction * orientation_vector
+
+        scale_center = reference_point + scalecenter_h0 * orientation_vector_z \
+                                       + scalecenter_r0 * orientation_vector_r
         scale_center = world.apply_boundary(scale_center)
 
         # calculate the vector from the scale center to the center of the shell
         shell_position_t = world.cyclic_transpose (shell_position, scale_center)
         shell_scale_center = shell_position_t - scale_center
-        shell_scalecenter_z = numpy.dot( shell_scale_center, direction * orientation_vector )
-        shell_scalecenter_r = length(shell_scale_center - (shell_scalecenter_z*direction*orientation_vector))
-        # calculate the angle theta of the vector from the scale center to the shell with the vector
-        # to the scale center (which is +- the orientation_vector)
-        theta = vector_angle (shell_scale_center, direction * orientation_vector)
-
-        psi = theta - phi
-
-        ### check what situation arrises
-        # The shell can hit the cylinder on the flat side (situation 1),
-        #                                on the edge (situation 2),
-        #                                or on the round side (situation 3).
-        # I think this also works for phi == 0 and phi == Pi/2
-        if psi <= -phi:
-        # The midpoint of the shell lies on the axis of the cylinder
-            situation = 1
-
-        elif -phi < psi and psi < 0:
-        # The (spherical) shell can touch the cylinder on its flat side or its edge
-            if phi == Pi/2.0:
-                r_tan_phi = 0
-            else:
-                r_tan_phi = shell_scalecenter_r/math.tan(phi)   # phi == 0 should not get here
+        shell_scalecenter_z = numpy.dot(shell_scale_center, orientation_vector_z)
+        shell_scalecenter_r = numpy.dot(shell_scale_center, orientation_vector_r) 
+        #length(shell_scale_center - (shell_scalecenter_z * orientation_vector_z))
+
+
+        if (type(shell.shape) is Sphere):
+
+            log.debug('sphere')
+            # calculate the angle theta of the vector from the scale center to the shell with the vector
+            # to the scale center (which is +- the orientation_vector)
+            theta = vector_angle (shell_scale_center, orientation_vector_z)
+
+            psi = theta - phi
 
-            a_thres = shell_scalecenter_z - r_tan_phi
-            if shell_size < a_thres:
+            ### check what situation arrises
+            # The shell can hit the cylinder on the flat side (situation 1),
+            #                                on the edge (situation 2),
+            #                                or on the round side (situation 3).
+            # I think this also works for phi == 0 and phi == Pi/2
+            if psi <= -phi:
+            # The midpoint of the shell lies on the axis of the cylinder
                 situation = 1
-            else:
-                situation = 2
-
-        elif 0 <= psi and psi < (Pi/2.0 - phi):
-        # The (spherical) shell can touch the cylinder on its edge or its radial side
-            tan_phi = math.tan(phi)                             # phi == Pi/2 should not get here
-            a_thres = shell_scalecenter_r - shell_scalecenter_z * tan_phi
-            if shell_size > a_thres:
-                situation = 2
-            else:
+
+            elif -phi < psi and psi < 0:
+            # The (spherical) shell can touch the cylinder on its flat side or its edge
+                if phi == Pi/2.0:
+                    r_tan_phi = 0
+                else:
+                    r_tan_phi = abs(shell_scalecenter_r)/math.tan(phi)   # phi == 0 should not get here
+                                                                         # TODO the abs may be wrong/unnecessary
+
+                a_thres = shell_scalecenter_z - r_tan_phi
+                if shell_size < a_thres:
+                    situation = 1
+                else:
+                    situation = 2
+
+            elif 0 <= psi and psi < (Pi/2.0 - phi):
+            # The (spherical) shell can touch the cylinder on its edge or its radial side
+                tan_phi = math.tan(phi)                             # phi == Pi/2 should not get here
+                a_thres = abs(shell_scalecenter_r) - shell_scalecenter_z * tan_phi  # TODO same here
+                if shell_size > a_thres:
+                    situation = 2
+                else:
+                    situation = 3
+
+            elif (Pi/2.0 - phi) <= psi:
+            # The shell is always only on the radial side of the cylinder
                 situation = 3
 
-        elif (Pi/2.0 - phi) <= psi:
-        # The shell is always only on the radial side of the cylinder
-            situation = 3
+            else:
+            # Don't know how we would get here, but it shouldn't happen
+                raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
+                                   (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
+
+        elif (type(shell.shape) is Cylinder):
+            omega = math.atan( (shell_scalecenter_r - shell.shape.radius) / (shell_scalecenter_z - shell.shape.half_length) )
+            omega += Pi
+
+            log.debug('cylinder')
+            log.debug('omega = %s' % FORMAT_DOUBLE % omega)
+
+            if omega <= phi:
+                situation = 1
+            elif omega > phi:
+                situation = 3
+            # situation 2 does not occur since we assume that the cylinders are oriented in same direction
 
         else:
-        # Don't know how we would get here, but it shouldn't happen
-            raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
-                               (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
+            raise RuntimeError('Laurens algorithm: Shelltype was unsupported')
+
 
         if __debug__:
             log.debug('situation = %s' % (situation))
@@ -948,12 +986,13 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
 
 
         ### Get the right values for z and r for the given situation
-        if situation == 1:      # shell hits on the flat side
-            z1_new = min(z1, scalecenter_h0 + shell_scalecenter_z - shell_size)
+        if situation == 1:      # shell hits cylinder on the flat side
+            z1_new = min(z1, (scalecenter_h0 + shell_scalecenter_z - shell_size)/SAFETY)
+                                                        # note that shell_size may also mean half_length
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
-        elif situation == 2:    # shell hits on the edge
+        elif situation == 2:    # shell hits sphere on the edge
             a_sq = shell_size*shell_size
             shell_scalecenter_len = length(shell_scale_center)
             ss_sq = shell_scalecenter_len*shell_scalecenter_len
@@ -975,8 +1014,8 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
                 z1_new = min(z1, z1_function(single1, single2, r0, r_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
-        elif situation == 3:    # shell hits on the round side
-            r_new = min(r, scalecenter_r0 + shell_scalecenter_r - shell_size)
+        elif situation == 3:    # shell hits cylinder on the round side
+            r_new = min(r, (scalecenter_r0 + abs(shell_scalecenter_r) - shell_size)/SAFETY)   # note that shell_size here means radius
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
         else:
@@ -1003,7 +1042,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
 
         ## DEBUGGING
         if __debug__:
-            print "r = " , r
+            log.debug('r = %s' % (FORMAT_DOUBLE % r))
 #            print "z_left = ", z_left
 #            print "z_right = ", z_right
 
@@ -1012,6 +1051,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, ref
     ### class methods that are for the right side of the cylindrical shell
     @classmethod
     def calc_right_scalingangle(cls, D1, D2):
+        # TODO change this to scaling ratio (this saves us an unnecassary arctan)
         D_r = D1 + D2
         D_R = (D1*D2)/(D1 + D2)
 

From ecf155e98bd01b9de7ac4d51ab56214e25c916a7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 Nov 2011 15:33:50 +0100
Subject: [PATCH 0406/1541] position of particle should be expressed in unit
 vectors of the surface to prevent the particle leaving the surface due to
 numerical errors Also some cleanup of comments

---
 pair.py   | 125 ++++++++++++++++++++++++++----------------------------
 single.py |  41 ++++++++++++++----
 2 files changed, 92 insertions(+), 74 deletions(-)

diff --git a/pair.py b/pair.py
index 7a99c996..e88ad02c 100644
--- a/pair.py
+++ b/pair.py
@@ -127,16 +127,9 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         inter-particle vector.
 
         """
-#        # If the two particles have reacted this returns the
-#        # new position twice
-#        # The positions are relative to the center of the shell
         new_com = self.draw_new_com(dt, event_type)
-
-#        if event_type == EventType.IV_REACTION:
-#            newpos1 = new_com
-#            newpos2 = new_com
-#        else:
         new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
+
         newpos1, newpos2 = self.do_back_transform(new_com, new_iv)
 
         return newpos1, newpos2
@@ -149,12 +142,13 @@ def draw_new_com(self, dt, event_type):
             gf = self.com_greens_function()
             r = draw_r_wrapper(gf, dt, self.a_R)
 
-        return self.com + self.create_com_vector(r)
-
         # Add displacement to old CoM. This assumes (correctly) that 
         # r0=0 for the CoM. Compare this to 1D singles, where r0 is not  
         # necesseraly 0.
-#        return displacement
+
+        # note that we need to make sure that the com and com_vector are in the structure to prevent
+        # the particle leaving the structure due to numerical errors
+        return self.com + self.create_com_vector(r)
 
     def draw_new_iv(self, dt, r0, old_iv, event_type):
         gf = self.choose_pair_greens_function(r0, dt)
@@ -165,6 +159,8 @@ def draw_new_iv(self, dt, r0, old_iv, event_type):
         else:
             r = draw_r_wrapper(gf, dt, self.a_r, self.sigma)
 
+        # note that we need to make sure that the interparticle vector is in the structure to prevent
+        # the particle leaving the structure due to numerical errors
         return self.create_interparticle_vector(gf, r, dt, r0, old_iv)
 
     def check(self):
@@ -334,6 +330,8 @@ def do_transform(cls, single1, single2, world):
 
         com = world.calculate_pair_CoM(pos1, pos2, D1, D2)
         com = world.apply_boundary(com)
+        # make sure that the com is in the structure of the particle (assume that this is done correctly in
+        # calculate_pair_CoM)
 
         pos2t = world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
@@ -341,6 +339,9 @@ def do_transform(cls, single1, single2, world):
         return com, iv
 
     def do_back_transform(self, com, iv):
+    # here we assume that the com and iv are really in the structure and no adjustments have to be
+    # made
+
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
 
@@ -503,34 +504,11 @@ def create_com_vector(self, r):
         return random_vector(r)
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
-        # FIXME code doesn't handle r=0 
 
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
         theta = draw_theta_wrapper(gf, r, dt)
 
-#        new_inter_particle_s = numpy.array([r, theta, phi])
-#        new_iv = spherical_to_cartesian(new_inter_particle_s)
-
-        # calculate the old_iv theta (theta is the angle with the zenith (z-axis) of the system)
-#        old_iv_theta = vector_angle_against_z_axis(old_iv)
-        # the old_iv phi is taken to be zero. This means that the theta is in the plane of
-        # the z-axis and the old_iv
-
-            # We now rotate the new interparticle vector in the plane of
-            # the old_iv and the z axis. This menas along the
-            # rotation axis that is perpendicular to both the
-            # z-axis and the original interparticle vector. The rotation
-            # angle is the angle between the old_iv and z axis.
-        
-            # the rotation axis is a normalized cross product of
-            # the z-axis and the original vector.
-            # rotation_axis = crossproduct([0,0,1], inter_particle)
-
-#            rotation_axis = crossproduct_against_z_axis(old_iv)
-#            rotation_axis = normalize(rotation_axis)
-#            new_iv = rotate_vector(new_iv, rotation_axis, old_iv_theta)
-
         if theta == 0.0:
             # no rotation is necessary -> new_iv = new_iv
             new_iv = old_iv
@@ -541,14 +519,16 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
             rotation_axis = normalize(rotation_axis)
             new_iv = rotate_vector(old_iv, rotation_axis, theta)
 
-            # rotate the new_iv around the old_iv with angle phi and adjust length
+            # rotate the new_iv around the old_iv with angle phi
             phi = myrandom.uniform() * 2 * Pi
-            old_iv = normalize(old_iv)
-            new_iv = rotate_vector(new_iv, old_iv, phi)
+            rotation_axis = normalize(old_iv)
+            new_iv = rotate_vector(new_iv, rotation_axis, phi)
         else:
-            # angle == numpi.pi -> just mirror the old_iv 
+            # theta == numpi.pi -> just mirror the old_iv 
             new_iv = -old_iv
 
+        # adjust length of the vector
+        # note that r0 = length (old_iv)
         new_iv = (r/r0) * new_iv
 
         return new_iv
@@ -630,31 +610,29 @@ def choose_pair_greens_function(self, r0, t):
 
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
+        # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
-        # note that r0 = length (old_iv)
 
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
         theta = draw_theta_wrapper(gf, r, dt)
 
-#        unit_x = self.structure.shape.unit_x
-#        unit_y = self.structure.shape.unit_y
-#        angle = vector_angle(unit_x, old_iv)
-        # FIXME THIS IS WRONG: angle returns the angle between the vectors regardsless of order
-        #       now we do not see the different if the old_iv is mirrored in the unit_x
-        # Todo. Test if nothing changes when theta == 0.
-#        new_angle = angle + theta
-#
-#        new_iv = r * math.cos(new_angle) * unit_x + \
-#                 r * math.sin(new_angle) * unit_y
-
+        # note that r0 = length (old_iv)
         new_iv = (r/r0) * rotate_vector(old_iv, self.structure.shape.unit_z, theta)
         # note that unit_z can point two ways rotating the vector clockwise or counterclockwise
         # Since theta is symmetric this doesn't matter.
 
-        return new_iv
+        # project the new_iv down on the unit vectors of the surface to prevent the particle from
+        # leaving the surface due to numerical problem
+        unit_x = self.structure.shape.unit_x
+        unit_y = self.structure.shape.unit_y
+
+        new_iv_x = unit_x * numpy.dot(new_iv, unit_x)
+        new_iv_y = unit_y * numpy.dot(new_iv, unit_y)
+
+        return new_iv_x + new_iv_y
 
     def __str__(self):
         return 'PlanarSurface' + Pair.__str__(self)
@@ -707,16 +685,22 @@ def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
 
     def create_com_vector(self, r):
+        # project the com onto the surface unit vector to make sure that the coordinates are in the surface
         return r * self.structure.shape.unit_z
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
-        # note that r0 = length (old_iv)
         if __debug__:
             log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
-        # Note: using self.structure.shape.unit_z here might accidently 
-        # interchange the particles.
-        # That's why we would use self.shell.shape.unit_z right?!
-        return (r/r0) * old_iv
+
+        # note that r0 = length (old_iv)
+        new_iv = (r/r0) * old_iv
+
+        # project the new_iv down on the unit vectors of the surface to prevent the particle from
+        # leaving the surface due to numerical problem
+        unit_z = self.surface.shape.unit_z
+        new_iv_z = unit_z * numpy.dot(new_iv, unit_z)
+
+        return new_iv_z
 
     def get_shell_size(self):
         # Heads up.
@@ -1235,7 +1219,7 @@ def do_transform(cls, single1, single2, world):
 
         # the CoM is calculated in a similar way to a normal 3D pair
         com = (D_2 * pos1 + D_1 * pos2) / (D_1 + D_2)
-        # and then projected onto the plane
+        # and then projected onto the plane to make sure the CoM is in the surface
         com = world.cyclic_transpose(com, surface.shape.position)
         com, _ = surface.projected_point (com)
         com = world.apply_boundary(com)
@@ -1259,12 +1243,17 @@ def do_transform(cls, single1, single2, world):
         return com, iv
 
     def do_back_transform(self, com, iv):
+    # here we assume that the com and iv are really in the structure and no adjustments have to be
+    # made
+
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
 
         weight1 = D1 / self.D_tot
         weight2 = D2 / self.D_tot
 
+        min_iv_z_length = self.pid_particle_pair2[1].radius
+
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
         iv_x = self.surface.shape.unit_x * numpy.dot(iv, self.surface.shape.unit_x)
         iv_y = self.surface.shape.unit_y * numpy.dot(iv, self.surface.shape.unit_y)
@@ -1272,20 +1261,20 @@ def do_back_transform(self, com, iv):
         # reflect the coordinates in the unit_z direction back to the side of the membrane
         # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
         # plane of the membrane
-        iv_z_length = abs(numpy.dot(iv, self.shell.shape.unit_z))
+        iv_z_length = abs(numpy.dot(iv, self.shell.shape.unit_z))   # FIXME maybe first project the shell unit_z onto the 
+                                                                    # surface unit_z to prevent numerical problems?
         # do the reverse scaling
         iv_z_length = iv_z_length / self.z_scaling_factor
 
         # if the particle is overlapping with the membrane, make sure it doesn't
-        if iv_z_length < self.pid_particle_pair2[1].radius:
-            iv_z_length = self.pid_particle_pair2[1].radius * MINIMAL_SEPARATION_FACTOR
+        if iv_z_length < min_iv_z_length:
+            iv_z_length = min_iv_z_length * MINIMAL_SEPARATION_FACTOR
 
         iv_z = self.shell.shape.unit_z * iv_z_length
 
         pos1 = com - weight1 * (iv_x + iv_y)
         pos2 = com + weight2 * (iv_x + iv_y) + \
-               iv_z #/self.z_scaling_factor + \
-#               self.shell.shape.unit_z * self.pid_particle_pair2[1].radius
+               iv_z 
 
         return pos1, pos2
 
@@ -1325,10 +1314,10 @@ def get_shell_size(self):
 
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
+        # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
         return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
-        # Note: old_iv is actually the r0_vector
         # FIXME This is actually the same method as for SphericalPair
 
         if __debug__:
@@ -1346,13 +1335,14 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
             # rotate the new_iv around the old_iv with angle phi
             phi = myrandom.uniform() * 2 * Pi
-            old_iv = normalize(old_iv)
-            new_iv = rotate_vector(new_iv, old_iv, phi)
+            rotation_axis = normalize(old_iv)
+            new_iv = rotate_vector(new_iv, rotation_axis, phi)
         else:
             # theta == Pi -> just mirror the old_iv
             new_iv = -old_iv
 
-        #adjust length of the vector to new r
+        # adjust length of the vector to new r
+        # note that r0 = length (old_iv)
         new_iv = (r/r0) * new_iv
 
         return new_iv
@@ -1364,6 +1354,9 @@ class MixedPair3D1D(Pair):
 
     @classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface):
+    # here we assume that the com and iv are really in the structure and no adjustments have to be
+    # made
+
         D_tot = D1 + D2
         weight1 = D1 / D_tot
         weight2 = D2 / D_tot
diff --git a/single.py b/single.py
index 3003346f..325f8c71 100644
--- a/single.py
+++ b/single.py
@@ -233,6 +233,9 @@ def draw_new_position(self, dt, event_type):
             # asymmetric 1D domain (r0 != 0, or drift), since draw_r always 
             # returns a distance relative to the centre of the shell (r=0), 
             # not relative to r0.
+
+            # note that we need to make sure that the shell.shape.position and displacement vector
+            # are in the structure to prevent the particle leaving the structure due to numerical errors
             newpos = self.shell.shape.position + displacement
 
         return newpos
@@ -351,14 +354,21 @@ def create_new_shell(self, position, radius, domain_id):
         # particle undergoes an unbinding reaction we still have to 
         # clear the target volume and the move may be rejected (NoSpace 
         # error).
-        orientation = normalize(
-            utils.crossproduct(self.structure.shape.unit_x,
-                               self.structure.shape.unit_y))
+#        orientation = normalize(
+#            utils.crossproduct(self.structure.shape.unit_x,
+#                               self.structure.shape.unit_y))
+
+        # express the position into the surface unit vectors to make sure that the coordinates are in the surface
+        pos_x = self.structure.shape.unit_x * numpy.dot(position, self.structure.shape.unit_x)
+        pos_y = self.structure.shape.unit_y * numpy.dot(position, self.structure.shape.unit_y)
+        position = pos_x + pos_y
+        orientation = self.structure.shape.unit_z
         half_length = self.pid_particle_pair[1].radius
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
     def create_position_vector(self, r):
+        # project the vector onto the surface unit vectors to make sure that the coordinates are in the surface
         x, y = random_vector2D(r)
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
@@ -404,9 +414,14 @@ def create_new_shell(self, position, half_length, domain_id):
         # The radius of a rod is not more than it has to be (namely the 
         # radius of the particle), so if the particle undergoes an 
         # unbinding reaction we still have to clear the target volume 
-        # and the move may be rejected (NoSpace error).
+        # and the move may be rejected.
+
+        unit_z = self.structure.shape.unit_z
+
+        # express the position into the surface unit vectors to make sure that the coordinates are in the surface
+        position = unit_z * numpy.dot(position, unit_z)
         radius = self.pid_particle_pair[1].radius
-        orientation = self.structure.shape.unit_z
+        orientation = unit_z
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
@@ -417,6 +432,8 @@ def create_position_vector(self, z):
             # both boundaries at the escape time
             # TODO, include drift
             z = myrandom.choice(-1, 1) * z 
+
+        # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
         return z * self.shell.shape.unit_z
 
     def __str__(self):
@@ -582,6 +599,8 @@ def draw_new_position(self, dt, event_type):
                 r = draw_r_wrapper(gf, dt, a)
 
             x, y = random_vector2D(r)
+            # express the r vector in the unit vectors of the surface to make sure the particle is
+            # parallel to the surface (due to numerical problem)
             vector_r = x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
 
             # calculate z vector
@@ -606,9 +625,13 @@ def draw_new_position(self, dt, event_type):
                 gf_iv = self.iv_greens_function()
                 z = draw_r_wrapper(gf_iv, dt, z_not_surface, z_surface) # last two args= a, sigma
 
+            # express the vector_z in the unit vectors of the surface to prevent the particle from
+            # leaving the surface due to numerical problem
             vector_z = z * self.shell.shape.unit_z
 
             # The new position is relative to the center of the shell
+            # note that we need to make sure that the shell.shape.position and vector_r and vector_z
+            # are correct (in the structure) to prevent the particle leaving the structure due to numerical errors
             newpos = self.shell.shape.position + vector_r + vector_z
 
         return newpos
@@ -692,9 +715,11 @@ def draw_new_position(self, dt, event_type):
                 gf = self.greens_function()
                 z = draw_r_wrapper(gf, dt, self.get_inner_dz_left())
 
-            # Direction matters, so use shell.shape.unit_z instead of 
-            # structure.shape.unit_z.
-            z_vector = z * self.shell.shape.unit_z
+            # Direction matters, so determine the direction of the shell relative to the surface
+            # first
+            direction = cmp(numpy.dot(self.shell.shape.unit_z, self.structure.shape.unit_z), 0)
+            # express the z_vector into the surface unit vectors to make sure that the coordinates are in the surface
+            z_vector = z * direction * self.structure.shape.unit_z
 
 
             # 2) Draw r and theta.

From e2ac3fa2d70ac00a22408e38b5a369e9c5b358e9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 Nov 2011 15:56:46 +0100
Subject: [PATCH 0407/1541] revert stupid changes from previous commit

---
 single.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/single.py b/single.py
index 325f8c71..31b05fd5 100644
--- a/single.py
+++ b/single.py
@@ -358,10 +358,8 @@ def create_new_shell(self, position, radius, domain_id):
 #            utils.crossproduct(self.structure.shape.unit_x,
 #                               self.structure.shape.unit_y))
 
-        # express the position into the surface unit vectors to make sure that the coordinates are in the surface
-        pos_x = self.structure.shape.unit_x * numpy.dot(position, self.structure.shape.unit_x)
-        pos_y = self.structure.shape.unit_y * numpy.dot(position, self.structure.shape.unit_y)
-        position = pos_x + pos_y
+        # Note that the calculateion of the position of the shell needs to make sure that the
+        # coordinates are in the surface
         orientation = self.structure.shape.unit_z
         half_length = self.pid_particle_pair[1].radius
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 
@@ -418,8 +416,8 @@ def create_new_shell(self, position, half_length, domain_id):
 
         unit_z = self.structure.shape.unit_z
 
-        # express the position into the surface unit vectors to make sure that the coordinates are in the surface
-        position = unit_z * numpy.dot(position, unit_z)
+        # Note that the calculation of the position of the shell has to make sure that the
+        # coordinates are in the surface
         radius = self.pid_particle_pair[1].radius
         orientation = unit_z
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 

From f3713aa91fb8c898ad3cd47c2181c8146a140f1a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 Nov 2011 17:32:49 +0100
Subject: [PATCH 0408/1541] made the do_back_transform a class method for all
 Pair classes

---
 pair.py | 68 +++++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 47 insertions(+), 21 deletions(-)

diff --git a/pair.py b/pair.py
index e88ad02c..fb2f8b79 100644
--- a/pair.py
+++ b/pair.py
@@ -130,7 +130,14 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         new_com = self.draw_new_com(dt, event_type)
         new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
 
-        newpos1, newpos2 = self.do_back_transform(new_com, new_iv)
+        unit_z = self.get_shell_direction()
+        newpos1, newpos2 = self.do_back_transform(new_com, new_iv,
+                                                  self.pid_particle_pair1[1].D,
+                                                  self.pid_particle_pair2[1].D,
+                                                  self.pid_particle_pair1[1].radius,
+                                                  self.pid_particle_pair2[1].radius,
+                                                  self.structure,
+                                                  unit_z)
 
         return newpos1, newpos2
 
@@ -338,15 +345,17 @@ def do_transform(cls, single1, single2, world):
 
         return com, iv
 
-    def do_back_transform(self, com, iv):
+    @ classmethod
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
 
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
+#        D1 = self.pid_particle_pair1[1].D
+#        D2 = self.pid_particle_pair2[1].D
+        D_tot = D1 + D2
 
-        pos1 = com - iv * (D1 / self.D_tot)
-        pos2 = com + iv * (D2 / self.D_tot)
+        pos1 = com - iv * (D1 / D_tot)
+        pos2 = com + iv * (D2 / D_tot)
 
         return pos1, pos2
 
@@ -460,6 +469,9 @@ def iv_greens_function(self, r0):
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
 
+    def get_shell_direction(self):
+        return random_vector(1.0)
+
     # selects between the full solution or an approximation where one of
     # the boundaries is ignored
     def choose_pair_greens_function(self, r0, t):
@@ -567,6 +579,9 @@ def create_new_shell(self, position, radius, domain_id):
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
+    def get_shell_direction(self):
+        return self.shell.shape.unit_z
+
     def choose_pair_greens_function(self, r0, t):
         # selects between the full solution or an approximation where one of
         # the boundaries is ignored
@@ -680,6 +695,9 @@ def create_new_shell(self, position, half_length, domain_id):
         return CylindricalShell(domain_id, Cylinder(position, radius, 
                                                     orientation, half_length))
 
+    def get_shell_direction(self):
+        return self.shell.shape.unit_z
+
     def choose_pair_greens_function(self, r0, t):
         # Todo
         return self.iv_greens_function(r0)
@@ -1242,39 +1260,40 @@ def do_transform(cls, single1, single2, world):
 
         return com, iv
 
-    def do_back_transform(self, com, iv):
+    @ classmethod
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
 
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
+#        D1 = self.pid_particle_pair1[1].D
+#        D2 = self.pid_particle_pair2[1].D
 
-        weight1 = D1 / self.D_tot
-        weight2 = D2 / self.D_tot
+        D_tot = D1 + D2
+        weight1 = D1 / D_tot
+        weight2 = D2 / D_tot
 
-        min_iv_z_length = self.pid_particle_pair2[1].radius
+        min_iv_z_length = radius2
 
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
-        iv_x = self.surface.shape.unit_x * numpy.dot(iv, self.surface.shape.unit_x)
-        iv_y = self.surface.shape.unit_y * numpy.dot(iv, self.surface.shape.unit_y)
+        iv_x = surface.shape.unit_x * numpy.dot(iv, surface.shape.unit_x)
+        iv_y = surface.shape.unit_y * numpy.dot(iv, surface.shape.unit_y)
 
         # reflect the coordinates in the unit_z direction back to the side of the membrane
         # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
         # plane of the membrane
-        iv_z_length = abs(numpy.dot(iv, self.shell.shape.unit_z))   # FIXME maybe first project the shell unit_z onto the 
-                                                                    # surface unit_z to prevent numerical problems?
+        iv_z_length = abs(numpy.dot(iv, unit_z))   # FIXME maybe first project the shell unit_z onto the 
+                                                   # surface unit_z to prevent numerical problems?
         # do the reverse scaling
-        iv_z_length = iv_z_length / self.z_scaling_factor
+        iv_z_length = iv_z_length / cls.calc_z_scaling_factor(D1, D2)
 
         # if the particle is overlapping with the membrane, make sure it doesn't
         if iv_z_length < min_iv_z_length:
             iv_z_length = min_iv_z_length * MINIMAL_SEPARATION_FACTOR
 
-        iv_z = self.shell.shape.unit_z * iv_z_length
+        iv_z = unit_z * iv_z_length
 
         pos1 = com - weight1 * (iv_x + iv_y)
-        pos2 = com + weight2 * (iv_x + iv_y) + \
-               iv_z 
+        pos2 = com + weight2 * (iv_x + iv_y) + iv_z 
 
         return pos1, pos2
 
@@ -1312,6 +1331,9 @@ def create_new_shell(self, position, radius, half_length, orientation_vector, do
     def get_shell_size(self):
         return self.shell.shape.radius
 
+    def get_shell_direction(self):
+        return self.shell.shape.unit_z
+
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
         # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
@@ -1353,9 +1375,10 @@ def __str__(self):
 class MixedPair3D1D(Pair):
 
     @classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
+    # unit_z is a putatively different unit_z than that available in the surface object
 
         D_tot = D1 + D2
         weight1 = D1 / D_tot
@@ -1389,3 +1412,6 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface):
     def calc_r_scaling_factor(cls, D1, D2):
         return math.sqrt((D1 + D2)/D2)
 
+    def get_shell_direction(self):
+        return self.shell.shape.unit_z
+

From cea1fc6795dcb83a97a25eb4b1b90c1fbe76f997 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 Nov 2011 17:33:17 +0100
Subject: [PATCH 0409/1541] replaced the position calculation of C(2D) -> A(2D)
 + B(3D) by do_back_transform of MixedPair

---
 egfrd.py | 47 +++++++++++++++++++++++++----------------------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8e692f8f..0aa5bf95 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -116,13 +116,12 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         # some constants
         self.MULTI_SHELL_FACTOR = math.sqrt(2)  # This stems from the fact that there vacant space in the cylinder
-#        self.MULTI_SHELL_FACTOR = 1.2           # This is the threshold for when the algorithm switches from
                                                 # NonInteractionSingles to a Multi and also defines the Multi
                                                 # shell size.
         self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
                                                 # NonInteractionSingles to a Pair or Interaction. It also defines
                                                 # the radius in which the NonInteractionSingle will burst.
-        self.MAX_NUM_DT0_STEPS = 10000
+        self.MAX_NUM_DT0_STEPS = 1000
 
         self.MAX_TIME_STEP = 10
 
@@ -821,33 +820,37 @@ def fire_single_reaction(self, single, reactant_pos):
                         # draw the random angle for the 3D particle relative to the particle left in the membrane
                         # not all angles are available because particle cannot intersect with the membrane
 
-                        weightA = DA/(DA + DB)
-                        weightB = DB/(DA + DB)
+#                        weightA = DA/(DA + DB)
+#                        weightB = DB/(DA + DB)
 
                         # Basically do the backtransform with a random iv with length such that the particles are at contact
                         # Note we make the iv slightly longer because otherwise the anisotropic transform will produce illegal
                         # positions
-                        z_scaling_factor = MixedPair.calc_z_scaling_factor(DA, DB)
 
-                        iv = random_vector(particle_radius12 * z_scaling_factor)
+                        iv = random_vector(particle_radius12 * MixedPair.calc_z_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
-                        # backtransform. TODO use backtransform from MixedPair class
-                        iv_x = reactant_structure.shape.unit_x * numpy.dot(iv, reactant_structure.shape.unit_x)
-                        iv_y = reactant_structure.shape.unit_y * numpy.dot(iv, reactant_structure.shape.unit_y)
-                        orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-                        iv_z_length = abs(numpy.dot(iv, orientation_vector_z))
-                        # do the reverse scaling
-                        iv_z_length /= z_scaling_factor
-
-                        # if the particle is overlapping with the membrane, make sure it doesn't
-                        if iv_z_length < productB_radius:
-                            iv_z_length = productB_radius * MINIMAL_SEPARATION_FACTOR
-
-                        iv_z = iv_z_length * orientation_vector_z
-
-                        newposA = reactant_pos - weightA * (iv_x + iv_y)
-                        newposB = reactant_pos + weightB * (iv_x + iv_y) + iv_z
+                        unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+                        newposA, newposB = MixedPair.do_back_transform(reactant_pos, iv, DA, DB,
+                                                                       productA_radius, productB_radius,
+                                                                       reactant_structure, unit_z)
+
+#                        # backtransform. TODO use backtransform from MixedPair class
+#                        iv_x = reactant_structure.shape.unit_x * numpy.dot(iv, reactant_structure.shape.unit_x)
+#                        iv_y = reactant_structure.shape.unit_y * numpy.dot(iv, reactant_structure.shape.unit_y)
+#                        orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+#                        iv_z_length = abs(numpy.dot(iv, orientation_vector_z))
+#                        # do the reverse scaling
+#                        iv_z_length /= z_scaling_factor
+#
+#                        # if the particle is overlapping with the membrane, make sure it doesn't
+#                        if iv_z_length < productB_radius:
+#                            iv_z_length = productB_radius * MINIMAL_SEPARATION_FACTOR
+#
+#                        iv_z = iv_z_length * orientation_vector_z
+#
+#                        newposA = reactant_pos - weightA * (iv_x + iv_y)
+#                        newposB = reactant_pos + weightB * (iv_x + iv_y) + iv_z
                         newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
 

From b43b4945ec45411a8243f6e9408cb980765adfbb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 Nov 2011 17:39:35 +0100
Subject: [PATCH 0410/1541] removed ugly print statements

---
 pair.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index fb2f8b79..0de8bd9a 100644
--- a/pair.py
+++ b/pair.py
@@ -1006,12 +1006,12 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, she
             scalecenter_shell_dist /= 1.1
 
             if phi <= Pi/4:
-                print "scale z first."
+#                print "scale z first."
                 z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
                 r_new  = min(r, r1_function(single1, single2, r0, z1_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
             else:
-                print "scale r first."
+#                print "scale r first."
                 r_new = min(r, scalecenter_r0 + sin_phi * scalecenter_shell_dist)
                 z1_new = min(z1, z1_function(single1, single2, r0, r_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))

From 6700d718b8cf9dba8cee823dd63ca11bc253f354 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 Nov 2011 18:21:36 +0100
Subject: [PATCH 0411/1541] removed some comments

---
 egfrd.py | 28 ++--------------------------
 pair.py  |  6 ------
 2 files changed, 2 insertions(+), 32 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0aa5bf95..67c5c1fe 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -792,8 +792,6 @@ def fire_single_reaction(self, single, reactant_pos):
                 # figure out which product stays in the surface and which one goes to 3D
                 if isinstance(product2_structure, CuboidalRegion):
                     # product2 goes to 3D and is now particleB (product1 is particleA)
-                    productA_displacement = product1_displacement
-                    productB_displacement = product2_displacement
                     productA_radius = product1_radius
                     productB_radius = product2_radius
                     DA = D1
@@ -801,8 +799,6 @@ def fire_single_reaction(self, single, reactant_pos):
                     default = True      # we like to think of this as the default
                 else:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
-                    productA_displacement = product2_displacement
-                    productB_displacement = product1_displacement
                     productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2
@@ -820,13 +816,9 @@ def fire_single_reaction(self, single, reactant_pos):
                         # draw the random angle for the 3D particle relative to the particle left in the membrane
                         # not all angles are available because particle cannot intersect with the membrane
 
-#                        weightA = DA/(DA + DB)
-#                        weightB = DB/(DA + DB)
-
-                        # Basically do the backtransform with a random iv with length such that the particles are at contact
+                        # do the backtransform with a random iv with length such that the particles are at contact
                         # Note we make the iv slightly longer because otherwise the anisotropic transform will produce illegal
                         # positions
-
                         iv = random_vector(particle_radius12 * MixedPair.calc_z_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
@@ -835,22 +827,6 @@ def fire_single_reaction(self, single, reactant_pos):
                                                                        productA_radius, productB_radius,
                                                                        reactant_structure, unit_z)
 
-#                        # backtransform. TODO use backtransform from MixedPair class
-#                        iv_x = reactant_structure.shape.unit_x * numpy.dot(iv, reactant_structure.shape.unit_x)
-#                        iv_y = reactant_structure.shape.unit_y * numpy.dot(iv, reactant_structure.shape.unit_y)
-#                        orientation_vector_z  = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-#                        iv_z_length = abs(numpy.dot(iv, orientation_vector_z))
-#                        # do the reverse scaling
-#                        iv_z_length /= z_scaling_factor
-#
-#                        # if the particle is overlapping with the membrane, make sure it doesn't
-#                        if iv_z_length < productB_radius:
-#                            iv_z_length = productB_radius * MINIMAL_SEPARATION_FACTOR
-#
-#                        iv_z = iv_z_length * orientation_vector_z
-#
-#                        newposA = reactant_pos - weightA * (iv_x + iv_y)
-#                        newposB = reactant_pos + weightB * (iv_x + iv_y) + iv_z
                         newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
 
@@ -899,8 +875,8 @@ def fire_single_reaction(self, single, reactant_pos):
                 # TODO Make this into a generator
                 product_pos_list = []
                 for _ in range(self.dissociation_retry_moves):
-                    # calculate a random vector in the structure with unit length
                     # FIXME for particles on the cylinder there are only two possibilities
+                    # calculate a random vector in the structure with unit length
                     orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
             
                     newpos1 = reactant_pos + product1_displacement * orientation_vector
diff --git a/pair.py b/pair.py
index 0de8bd9a..9a50dc63 100644
--- a/pair.py
+++ b/pair.py
@@ -350,10 +350,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
 
-#        D1 = self.pid_particle_pair1[1].D
-#        D2 = self.pid_particle_pair2[1].D
         D_tot = D1 + D2
-
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
 
@@ -1265,9 +1262,6 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
 
-#        D1 = self.pid_particle_pair1[1].D
-#        D2 = self.pid_particle_pair2[1].D
-
         D_tot = D1 + D2
         weight1 = D1 / D_tot
         weight2 = D2 / D_tot

From 8de63cd9a6fa6a200d66a4952427d51fc1bc5a72 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 Nov 2011 19:00:03 +0100
Subject: [PATCH 0412/1541] removed/changed comments

---
 egfrd.py  | 55 ++++++-------------------------------------------------
 pair.py   | 28 +++++++---------------------
 single.py | 33 ---------------------------------
 3 files changed, 13 insertions(+), 103 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 67c5c1fe..2e5bf741 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1233,20 +1233,11 @@ def make_new_domain(self, single):
                             # or a domain was formed successfully previously
 
             if isinstance(obj, NonInteractionSingle):
-#                pair_horizon = (single_radius + \
-#                    closest_obj.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
-
-#                if closest_distance < pair_horizon:
-#                    # try making a Pair (can still be Mixed Pair or Normal Pair)
+                # try making a Pair (can still be Mixed Pair or Normal Pair)
                 domain = self.try_pair (single, obj)
 
             elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
-#                surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
-
-#                if closest_distance < surface_horizon:
-#                surface_distance < domain_distance and \
-#                surface_distance < surface_horizon:
-                    # try making an Interaction
+                # try making an Interaction
                 domain = self.try_interaction (single, obj)
 
 
@@ -1867,8 +1858,7 @@ def try_interaction(self, single, surface):
 
         dr /= SAFETY
         dz_right /= SAFETY
-#        This will break the conditions below for membrane interaction
-#        dz_left /= SAFETY
+        # Don't tweak dz_left, this will break the conditions below for membrane interaction
 
         # Decide if interaction domain is possible.
         if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
@@ -2361,6 +2351,7 @@ def check_domain(self, domain):
 
 
 
+        # TODO maybe don't check all the shells, this takes a lot of time
         for shell_id, shell in domain.shell_list:
 
 #            closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
@@ -2384,6 +2375,7 @@ def check_domain(self, domain):
             neighbors = self.geometrycontainer.get_neighbor_domains(shell.shape.position,
                                                                     self.domains, ignore=[domain.domain_id])
 
+            # testing overlap criteria
             for neighbor, _ in neighbors:
                 for _, neighbor_shell in neighbor.shell_list:
                     overlap = self.check_shell_overlap(shell, neighbor_shell)
@@ -2391,36 +2383,8 @@ def check_domain(self, domain):
                         '%s (%s) overlaps with %s (%s) by %s.' % \
                         (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
 
-#            # testing overlap criteria
-#            # TODO This doesn't work if closest is a Multi -> redesign this test
-#            if(type(shell.shape) is Cylinder and
-#               closest and type(closest.shell.shape) is Sphere):
-#                # Note: this case is special.
-#                # Note: only checking if cylinder doesn't overlap with 
-#                # closest sphere, like we do here, is not really 
-#                # sufficient (but checking all spheres is too much 
-#                # work).
-#                shell_size = shell.shape.half_length
-#                # Reverse overlap calculation: from closest sphere to 
-#                # cylinder is easier than the other way around, because 
-#                # the distance calculation from a point to a cylinder 
-#                # is already implemented.
-#                sphere = closest.shell.shape
-#                diff = self.world.distance(shell.shape, sphere.position) - \
-#                       sphere.radius
-#            else:
-#                if(type(domain) is CylindricalSurfaceSingle or
-#                   type(domain) is CylindricalSurfacePair or
-#                   type(domain) is CylindricalSurfaceInteraction):
-#                    # On CylindricalSurface, use half_lenghts.
-#                    # (assume all nearby other cylinders are on the 
-#                    # same surface)
-#                    shell_size = shell.shape.half_length
-#                else:
-#                    # Normally compare radii.
-#                    shell_size = shell.shape.radius
-#                diff = distance - shell_size
 
+            # checking wether the shell don't exceed the maximum size
             if (type(shell.shape) is Cylinder):
                 # the cylinder should at least fit in the maximal sphere
                 shell_size = math.sqrt(shell.shape.radius**2 + shell.shape.half_length**2)
@@ -2437,13 +2401,6 @@ def check_domain(self, domain):
                 '%s shell size larger than simulator cell size / 2, shell_size = %s, max = %s.' % \
                 (str(shell_id), FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % self.geometrycontainer.get_max_shell_size())
 
-#            assert diff >= 0.0, \
-#                '%s overlaps with %s. (shell: %s, dist: %s, diff: %s, dist_midpoints: %s.' % \
-#                (str(domain), str(closest), FORMAT_DOUBLE % shell_size,
-#                 FORMAT_DOUBLE % distance,
-#                 FORMAT_DOUBLE % diff,
-#                 FORMAT_DOUBLE % distance_midpoints)
-
         return True
 
     def check_shell_overlap(self, shell1, shell2):
diff --git a/pair.py b/pair.py
index 9a50dc63..068835c6 100644
--- a/pair.py
+++ b/pair.py
@@ -203,7 +203,6 @@ def get_min_shell_size(cls, single1, single2, geometrycontainer):
 #        assert (pos1 - single1.shell.shape.position).sum() == 0        # TODO Not sure why this is here
         sigma = radius1 + radius2
         r0 = geometrycontainer.world.distance(pos1, pos2)
-#        distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
 
         assert r0 >= sigma, \
             'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
@@ -256,27 +255,15 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
         # shortcut
         # if closest_distance <0 then neighbor particle overlaps with center of mass ->
         # neighboring particle is actually closer to the CoM than any of the two member particles
+        # this can happen because we also try to make pairs with the next nearest neighbor if the nearest
+        # neighbor fails
         if closest_distance <= 0:
             return 0
 
-
         # 3. Check if bursted Singles can still make a minimal shell.
-        # TODO This should be changed to a more general algorithm
-        # that checks if the closest nearest relevant shell is a
-        # NonInteractionSingle or smt else.
-        # Now it only processes the shells that were actually bursted before.
-
-#        closest, closest_shell_distance = None, numpy.inf
-#        for b in burst:
-#            if isinstance(b, NonInteractionSingle):
-#                bpos = b.shell.shape.position
-#                d = self.world.distance(shell_center, bpos) - \
-#                    b.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
-#                if d < closest_shell_distance:
-#                    closest, closest_shell_distance = b, d
-#
-
-
+        # TODO this is not correct. If the closest domain is not a NonInteractionSingle
+        # we still have to make sure that the (non closest) NonInteractionSingles have
+        # the required space
         if isinstance(closest, NonInteractionSingle):
             closest_particle_distance = geometrycontainer.world.distance(
                     shell_center, closest.pid_particle_pair[1].position)
@@ -290,15 +277,13 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
             shell_size = min(closest_distance, closest_particle_distance - closest_min_shell)
             assert shell_size <= closest_distance
 
-        # TODO this is not correct. If the closest domain is not a NonInteractionSingle
-        # we still have to make sure that the (non closest) NonInteractionSingles have
-        # the required space
         else:
             assert isinstance(closest, (InteractionSingle, Pair, Multi, Surface, None.__class__))
             shell_size = closest_distance 
 
         # FIXME Bloody ugly tweak to make sure that in case of a cylinder the 'maximum size' (which is
         # actually the radius) does not stick out of the maximum sphere (which is the real hard max).
+        # BLoody UGLY because it now applies to ALL SimplePairs.
         sigma = max(single1.pid_particle_pair[1].radius, single2.pid_particle_pair[1].radius)
         max_shell_size = math.sqrt(geometrycontainer.get_max_shell_size()**2 - sigma**2)
 
@@ -1001,6 +986,7 @@ def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, she
             scalecenter_shell_dist = (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
             # FIXME UGLY FIX BELOW
             scalecenter_shell_dist /= 1.1
+            scalecenter_shell_dist /= SAFETY
 
             if phi <= Pi/4:
 #                print "scale z first."
diff --git a/single.py b/single.py
index 31b05fd5..152d22a2 100644
--- a/single.py
+++ b/single.py
@@ -41,7 +41,6 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
         self.reactionrules = reactionrules              # the reaction rules for mono molecular reactions
         self.rrule = None                               # the reaction rule of the actual reaction (property reactionrule)
         self.k_tot = self.calc_ktot(reactionrules)
-        #self.updatek_tot()                             # RENAME to calc_ktot and MOVE to ProtectiveDomain
 
     def getD(self):
         return self.pid_particle_pair[1].D
@@ -113,28 +112,6 @@ def draw_escape_time_tuple(self):
         event_type = EventType.SINGLE_ESCAPE    # TODO Event is not an ESCAPE when in 1D there is drift
         return dt, event_type
 
-#    def updatek_tot(self):
-#       # MOVE to ProtectiveDomain class. See also reasoning above for
-#       # draw_reaction_time_tuple
-#        self.k_tot = 0
-#
-#        if not self.reactionrules:
-#            return
-#
-#        for rr in self.reactionrules:
-#            self.k_tot += rr.k
-#
-#    def draw_reaction_rule(self):
-#       # MOVE to ProtectiveDomain class
-#        k_array = [rr.k for rr in self.reactionrules]
-#        k_array = numpy.add.accumulate(k_array)
-#        k_max = k_array[-1]
-#
-#        rnd = myrandom.uniform()
-#        i = numpy.searchsorted(k_array, rnd * k_max)
-#
-#        return self.reactionrules[i]
-
     def check(self):
     # performs an internal consistency check
         pass
@@ -354,9 +331,6 @@ def create_new_shell(self, position, radius, domain_id):
         # particle undergoes an unbinding reaction we still have to 
         # clear the target volume and the move may be rejected (NoSpace 
         # error).
-#        orientation = normalize(
-#            utils.crossproduct(self.structure.shape.unit_x,
-#                               self.structure.shape.unit_y))
 
         # Note that the calculateion of the position of the shell needs to make sure that the
         # coordinates are in the surface
@@ -571,11 +545,8 @@ def greens_function(self):
     def iv_greens_function(self):
         # The green's function that also modelles the association of the particle
         # with the planar surface.
-        # TODO choose interactionrule
         return GreensFunction1DRadAbs(self.D, self.interaction_ktot, self.z0,
                                       -self.get_inner_dz_left(), self.get_inner_dz_right())
-#        return GreensFunction1DRadAbs(self.D, 0, self.z0,
-#                                     -self.get_inner_dz_left(), self.get_inner_dz_right())
 
     def draw_new_position(self, dt, event_type):
         """Draws a new position for the particle for a given event type at a given time
@@ -602,10 +573,6 @@ def draw_new_position(self, dt, event_type):
             vector_r = x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
 
             # calculate z vector
-            # Todo. Cartesian coordinate will return absolute position.
-            # Heads up. size_of_domain is different from the half_length of 
-            # the cylinder, because the domain ends where the surface 
-            # starts, while the cylinder is continuing into the surface.
             z_surface = -self.get_inner_dz_left()       # left side of the inner domain
             z_not_surface = self.get_inner_dz_right()   # right side of the inner domain (away from the surface)
 

From 4cb44b29922ed3b1cda21896b8e023dd08ee4cda Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Sun, 27 Nov 2011 18:38:44 +0100
Subject: [PATCH 0413/1541] Improved rootfinder (for large h) and changed drawT
 and drawR in 3DRadAbs format. Now using funcSum for less redundancy.

---
 GreensFunction1DAbsSinkAbs.cpp | 731 ++++++++++++++++++---------------
 GreensFunction1DAbsSinkAbs.hpp | 146 ++++---
 2 files changed, 494 insertions(+), 383 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 3de6f8f6..725cf1b3 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -15,6 +15,7 @@
 #include <gsl/gsl_roots.h>
 
 #include "findRoot.hpp"
+#include "funcSum.hpp"
 #include "GreensFunction1DAbsSinkAbs.hpp"
 
 /* This is the appropriate definition of the function defining
@@ -36,7 +37,7 @@ Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
 }
 
 /* Calculates the first n roots of root_f */
-void GreensFunction1DAbsSinkAbs::calculate_n_roots(int const& n) const
+void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n)
 {
     const Real Lr( getLr() );
     const Real Ll( getLl() );
@@ -46,18 +47,15 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(int const& n) const
     const Real h( getk() * L / ( 2 * getD() ) );
     
     Real root_i;
-    unsigned int i = 0;
+    uint i = 0;
 
-    /* Stores the last roots found with a low and a high
-       frequency resp. */
-    real_pair last_roots, lower_upper_pair;
+    real_pair lower_upper_pair;
 
     /* set params needed for get lower and upper function */
-    lower_upper_params lo_up_params;
     lo_up_params.h = h;
     lo_up_params.Lm_L = Lm_L;
-    lo_up_params.long_half_wave = max( L/Lr * M_PI, L/Ll * M_PI );
-    lo_up_params.short_half_wave = min( L/Lr * M_PI, L/Ll * M_PI );
+    lo_up_params.long_half_wave = std::max( L/Lr * M_PI, L/Ll * M_PI );
+    lo_up_params.short_half_wave = std::min( L/Lr * M_PI, L/Ll * M_PI );
 
     /* Define the root function. */
     gsl_function F;
@@ -70,101 +68,136 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(int const& n) const
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
-    /* Find the n roots */
-    while(i++ < n)
+    /* Find all the roots up to the nth*/
+    i = rootList_size();
+
+    /* If rootList is empty, add first root: 0. Will be removed later. */
+    uint n_adapt( n );
+    if(i == 0)
+    {
+        /* Stores pointers to last root with long/short wavelength. */
+        lo_up_params.last_long_root = 0;
+        lo_up_params.last_short_root = 0;
+        ad_to_rootList( 0.0 );
+        n_adapt++;
+    }
+
+    while(i++ < n_adapt)
     {
-        lower_upper_pair = get_lower_and_upper( last_roots, lower_upper_params );
+        lower_upper_pair = get_lower_and_upper( lo_up_params );
 
         root_i = findRoot( F, solver, lower_upper_pair.first, lower_upper_pair.second, 
                            1.0*EPSILON, EPSILON, "GreensFunction1DAbsSinkAbs::root_f" );
 
         assert( root_i > get_last_root() - EPSILON );
 
-        ad_to_rootList( root_i );       
+        ad_to_rootList( root_i );
+    }
 
-        if( root_i - last_roots.first < root_i - last_roots.second )
-            last_roots.first = root_i;
-        else
-            last_roots.second = root_i;
+    /* Remove first root */
+    if( get_root( 0 ) == 0.0 )
+    {
+        remove_from_rootList( 0 );
+        /* correct pointers for removal */
+        if( lo_up_params.last_long_root > 0 ) 
+            lo_up_params.last_long_root--;
+        if( lo_up_params.last_short_root > 0 ) 
+            lo_up_params.last_short_root--;
     }
 
     gsl_root_fsolver_free( solver );
 }
 
-/* Function returns two points on the x-axis which straddle the next root. */
-real_pair GreensFunction1DAbsSinkAbs::get_lower_and_upper( real_pair& last_roots, 
-                                                           lower_upper_params const& params )
+
+/* returns two points on the x-axis which straddle the next root. */
+std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( lower_upper_params& params )
 {
     const Real root_n( get_last_root() );
     const Real safety( .75 );
 
-    Real lower, upper, next_root_est, max_offset;
+    Real lower, upper, next_root_est, left_offset, right_offset;
 
     if( params.h / root_n < 1 )
     {
-        max_offset = M_PI;
+        right_offset = M_PI;
         next_root_est = root_n + M_PI;
     }
     else
     {
-        const Real next_root_long( last_roots.first + params.long_half_wave );
-        const Real next_root_short( last_roots.second + params.short_half_wave );
+        const Real next_root_long( get_root( params.last_long_root ) + params.long_half_wave );
+        const Real next_root_short( get_root( params.last_short_root ) + params.short_half_wave );
 
         if( next_root_long < next_root_short )
         {
             next_root_est = next_root_long;
 
-            max_offset = min( next_root_short - next_root_est, 
+            right_offset = std::min( next_root_short - next_root_est, 
                               params.long_half_wave );
+
+            params.last_long_root = rootList_size() + 1;
         }
         else
         {
-            next_root_est = root_n + next_root_short;
+            next_root_est = next_root_short;
             
-            max_offset = min( next_root_long - next_root_est, 
+            right_offset = std::min( next_root_long - next_root_est, 
                               params.short_half_wave );
+
+            params.last_short_root = rootList_size() + 1;                        
         }
     }
-       
-    lower = next_root_est - safety * max_offset;
-    upper = next_root_est + safety * max_offset;
+    
+    left_offset = next_root_est - root_n - EPSILON;      
+
+    lower = next_root_est - left_offset;
+    upper = next_root_est + safety * right_offset;
 
     struct root_f_params p = { params.Lm_L, params.h };
 
-    Real f_lower( root_f( lower, p ) );
-    Real f_upper( root_f( upper, p ) );
-    bool odd( (get_rootList.size() + 1)%2 );
-    /* if 'endpoints do not straddle' */
-    if( f_lower * f_higher > 0 )
+    Real f_lower( root_f( lower, &p ) );
+    Real f_upper( root_f( upper, &p ) );
+
+    /* set the parity operator for the next root: 
+       +1 for an even root.
+       -1 for an odd root. */
+    const bool parity_op( 2 * ( rootList_size()%2 ) - 1 );
+
+    /* f_lower must have correct sign. */
+    assert( f_lower * parity_op < 0 );
+
+    /* If the parity is incorrect -> correct it */
+    if( f_upper * parity_op < 0)
     {
-        std::cerr << "An endpoints do not straddle is imminent!" << std::endl;
-        std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
-                  << upper << ") = " << f_upper << std::endl;
-        /*
-        if( odd )
-        {
-            while( f_lower < 0 )
-            {
-                
-            }
-                
+        int cntr = 0;
 
-        }
-        else
+        const Real delta( .1 * std::min(left_offset, right_offset) );
+        
+        cntr = 0;
+        //TODO: find out is upper is left or right from next_root.
+        while(f_upper * parity < 0 && cntr++ < 10 )
         {
+            upper += delta;
+            f_upper = root_f( upper, &p );
+        }
 
+        if(cntr >= 10)
+        {
+            std::cerr << "Failed to straddle root # " << rootList_size() + 1 
+                      << " in GF::AbsSinkAbs " << std::endl;
+            std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
+                  << upper << ") = " << f_upper << std::endl;
         }
-        */
-    }    
+
+    }
 
     return real_pair( lower, upper );
 }
 
 /* returns a guess for the number of terms needed for 
    the greensfunction to converge at time t */
-unsigned int GreensFunction1DAbsSinkAbs::guess_maxi(Real t) const
+uint GreensFunction1DAbsSinkAbs::guess_maxi(Real const& t)
 {
-    const unsigned int safety(2);
+    const uint safety(2);
 
     if (t >= INFINITY)
     {
@@ -176,32 +209,33 @@ unsigned int GreensFunction1DAbsSinkAbs::guess_maxi(Real t) const
     const Real root0( get_root( 0 ) );
     const Real Dt(D * t);
 
-    const Real thr(exp(- Dt * root0 * root0) * this->TOLERANCE * 1e-1);
+    const Real thr(exp(- Dt * root0 * root0) * EPSILON * 1e-1);
 
     if (thr <= 0.0)
     {
-        return this->MAX_TERMS;
+        return MAX_TERMS;
     }
 
-    const Real max_root(sqrt(root0 * root0 - log(thr) / Dt));
+    const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
 
-    const unsigned int 
-        maxi(safety + 
-             static_cast<unsigned int>(max_alpha * getL() / M_PI));
+    const uint maxi(safety + 
+          static_cast<unsigned int>(max_root * ( getLr() + getLl() )  / M_PI));
 
     return std::min(maxi, MAX_TERMS);
 }
 
-/* Standart form of the greensfunction */
-inline Real GreensFunction1DAbsSinkAbs::Greens_fn(Real const& t, 
-                                                  Real const& root_n, 
-                                                  Real const& root_n2) const
+
+/* Standart form of the greensfunction without numerator */
+inline Real GreensFunction1DAbsSinkAbs::p_exp_den_i(Real const& t, 
+                                                  Real const& root_i, 
+                                                  Real const& root_i2) const
 {
-    return exp( - getD() * root_n2 * t ) / p_denominator( root_n );
+    return exp( - getD() * root_i2 * t ) / p_denominator_i( root_i );
 }
 
+
 /* Denominator of the greensfunction. */
-inline Real GreensFunction1DAbsSinkAbs::p_denominator(Real const& root_n) const
+inline Real GreensFunction1DAbsSinkAbs::p_denominator_i(Real const& root_n) const
 {
     const Real Lm( getLr() - getLl() );
     const Real L( getLr() + getLl() );
@@ -212,12 +246,11 @@ inline Real GreensFunction1DAbsSinkAbs::p_denominator(Real const& root_n) const
     return getD() * term1 + getk() / 2. * term2;
 }
 
+
 /* Calculates the probability of finding the particle inside the domain
    at time t, the survival probability. */
-Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
-{
-    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-  
+Real GreensFunction1DAbsSinkAbs::p_survival_old(Real t)
+{ 
     const Real D ( getD() );
     const Real k ( getk() ); 
     const Real Lr( getLr() );
@@ -225,6 +258,9 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
     const Real L0( getL0() );
     const Real L ( Lr + Ll );
 
+
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
 	    //particle can't escape.
@@ -233,10 +269,10 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
 
     Real sum = 0, numerator = 0, prev_term = 0;
     Real term1, term2, term_n, root_n;
-    int n = 1;
+    uint n = 0;
     do
     {
-        if ( n >= MAX_TERMS )
+        if ( n > MAX_TERMS )
 	    {
 	        std::cerr << " Too many terms needed for GF1DSink::p_survival. N: "
 	              << n << std::endl;
@@ -244,39 +280,192 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
 	    }
 	    prev_term = numerator;
     
-        root_n = get_root(n);
+        root_n = get_root( n );
         term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
         term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
         
-        numerator = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n );
+        numerator = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n ); 
         term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+
         //std::cerr << term_n << " " << root_n * L / M_PI << std::endl;
 	    sum += term_n;
 	    n++;
     }
     while ( fabs(term_n/sum) > EPSILON  ||
 	        fabs(prev_term/sum) > EPSILON ||
-	        n <= MIN_TERMS );
+	        n < MIN_TERMS );
 
     return 2.0 * sum;
 }
 
+/* Calculates survival probability. 
+   Switchbox for which greensfunction to use. */
+Real GreensFunction3DRadAbs::p_survival(Real t, RealVector& psurvTable) const
+{
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
+    Real p;
+
+    const Real D( getD() );
+    const Real sigma(getSigma());
+    const Real a( geta() );
+
+    const Real L0( getL0() );
+    const Real distToa(a - r0);
+    const Real distTos(r0 - sigma);
 
-// Calculates the probability density of finding the particle at location r
-// at time t.
-Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
+    const Real H(6.0); // a fairly strict criterion for safety.
+    const Real maxDist(H * sqrt(2.0 * D * t));
+
+    if (t == 0.0 || (D == 0.0 && v == 0.0) )
+    {
+	    //particle can't escape.
+	    return 1.0;
+    }
+
+    /*
+    if (distToa > maxDist)
+    {
+        if (distTos > maxDist) // far from anything; it'll survive.
+        {
+            if( L0 > maxDist )
+                p = 1.0;
+        }
+        else // close only to s, ignore a
+        {
+            const Real sigma(this->getSigma());
+            const Real kf(this->getkf());
+            p = p_survival_irr(t, r0, kf, D, sigma);
+        }
+    }
+    else
+    {
+        if (distTos > maxDist)  // close only to a.
+        {
+            p = p_survival_nocollision(t, r0, D, a);
+        }
+        else  // close to both boundaries.  do the normal calculation.
+        {
+            const unsigned int maxi(guess_maxi(t));
+            
+            if (psurvTable.size() < maxi + 1)
+            {
+                IGNORE_RETURN getAlpha0(maxi);  // this updates the table
+                this->createPsurvTable(psurvTable);
+            }
+
+            p = funcSum_all(boost::bind(&GreensFunction3DRadAbs::
+                                          p_survival_i_exp_table, 
+                                          this,
+                                          _1, t, psurvTable),
+                             maxi);
+        }
+    }
+    */
+
+    const uint maxi( guess_maxi(t) );
+            
+    if (psurvTable.size() < maxi + 1)
+    {
+        calculate_n_roots( maxi );  // this updates the table
+        createPsurvTable( psurvTable );
+    }
+    
+    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::
+                                p_survival_i, 
+                                this,
+                                _1, t, psurvTable),
+                    maxi);
+    
+    return p;
+}
+
+
+/* Calculates the i'th term of the p_survival sum. */
+Real p_survival_i( uint const& i, Real const& t, RealVector const& table) const
+{
+    const Real root_i( get_root( i ) );
+    exp( - getD() * t * gsl_pow_2( root_i ) ) * table[ i ];
+}
+
+
+/* Calculates the part of the i'th term of p_surv not dependent on t */
+Real p_survival_table_i( Real const& root_i )
+{ 
+    const Real D ( getD() );
+    const Real k ( getk() ); 
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+    const Real L ( Lr + Ll );
+
+    const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
+    const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+        
+    Real numerator( D * term1 + k * sin( root_n * Ll ) * term2 / root_n ); 
+    numerator *= 2;
+
+    return numerator / p_denominator_i( root_i );
+}
+
+
+/* Fills table with terms in the p_survival sum which don't depend on t. */
+void GreensFunction1DAbsSinkAbs::createPsurvTable(RealVector& table) const
+{
+    uint const root_nbr( rootList.size() );
+    uint i( table.size() );
+
+    while( i <= root_nbr )
+    {
+        table.push_back( p_survival_table_i( get_root( i++ ) ) );
+    }
+}
+
+
+/* Returns i'th term of prob_r (domain containing r0) function */
+Real GreensFunction1DAbsSinkAbs::prob_r_r0_i(uint const& i, Real const& rr, Real const&t)
+{
+    const Real root_i( get_root(i) );
+    const Real LlpL0( Ll + L0 );
+    const Real Lrmrr( Lr - rr );
+    
+    Real numerator( getD() * root_i * sin( root_i * LlpL0 ) + 
+                    getk() * sin( root_i * Ll ) * sin( root_i * L0) );
+
+    numerator *= sin( root_i * Lrmrr );
+    
+    return - 2.0 * p_exp_den_i(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+}
+
+
+/* Returns i'th term of prob_r (domain not containing r0) function */
+Real GreensFunction1DAbsSinkAbs::prob_r_nor0_i(uint const& i, Real const& rr, Real const&t)
+{
+    const Real root_i( get_root(i) );
+    const Real LrmL0( Lr - L0 );
+    const Real Llprr( Ll + rr );
+
+    const Real numerator( getD() * root_n * sin( root_n * Llprr ) * sin( root_n * LrmL0 ) );
+
+    return -2.0 * p_exp_den_i(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+}
+
+
+/* Calculates the probability density of finding the particle at location r
+   at time t. */
+Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
     THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a && (r0 - sigma) >= 0.0 && r0<=a );
     
     const Real D( getD() );
-    const Real k( getk() ); 
     const Real Lr( getLr() );
     const Real Ll( getLl() );
+    const Real L( Lr + Ll );    
+    
     Real L0( getL0() );
     Real rr( r - getrsink() ) ;
-
-    const Real L( Lr + Ll );
+    Real p;  
 
     // if there was no time change or zero diffusivity => no movement
     if (t == 0 || D == 0)
@@ -298,10 +487,6 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 	    return 0.0;
     }
 
-    Real root_n;
-    Real sum = 0, term_n = 0, prev_term = 0, numerator = 0;
-    int n = 1;
-           
     /* Determine wether rr lies in the same sub-domain as r0.
        A different function is caculated when this is the case. */
     if( rr * ( getr0() - getrsink() ) >= 0 )
@@ -317,79 +502,33 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
             rr = L0;
             L0 = temp;
         }
-
-        const Real LlpL0( Ll + L0 );
-        const Real Lrmrr( Lr - rr );
-
-        do
-        {   
-	        if ( n >= MAX_TERMS )
-	        {
-	            std::cerr << " Too many terms needed for GF1DSink::prob_r. N: "
-                          << n << std::endl;
-	            break;
-	        }
-	        prev_term = term_n;
-
-	        root_n = get_root(n);
-
-            numerator =  D * root_n * sin( root_n * LlpL0 ) + 
-                k * sin( root_n * Ll ) * sin( root_n * L0);
-            numerator *= sin( root_n * Lrmrr );
-
-            term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
-            sum += term_n;
-
-    	    n++;
-       }
-       while ( fabs(term_n/sum) > EPSILON*PDENS_TYPICAL || 
-	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	           n <= MIN_TERMS );
+    
+        p = funcSum_all(boost::bind(&prob_r_r0_i, this, _1, rr, t),
+                        maxi);
 	}
     else
     {
         if( rr > 0 )
             rr *= -1;
 
-        const Real LrmL0( Lr - L0 );
-        const Real Llprr( Ll + rr );
-
-        do
-        {   
-	        if ( n >= MAX_TERMS )
-	        {
-	            std::cerr << " Too many terms needed for GF1DSink::prob_r. N: "
-                          << n << std::endl;
-	            break;
-	        }
-	        prev_term = term_n;
-
-	        root_n = this->root_n(n);
-
-            numerator =  D * root_n * sin( root_n * (Llprr) ) * sin( root_n * (LrmL0) ); 
-            term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
-
-            sum += term_n;
-            
-    	    n++;
-       }
-       while ( fabs(term_n/sum) > EPSILON*PDENS_TYPICAL || 
-	           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	           n <= MIN_TERMS );
+        p = funcSum_all(boost::bind(&prob_r_nor0_i, this, _1, rr, t),
+                        maxi);
     }
     
-    return - 2.0 * sum;
+    return p;
 }
 
+
 /* Calculates the probability density of finding the particle at location z at
    timepoint t, given that the particle is still in the domain. */
-Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
+Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t)
 {
     return prob_r(r, t)/p_survival(t);
 }
 
+
 /* Function returns flux at absorbing bounday sigma. */
-Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
+Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t)
 {
     if( t == 0 || D == 0 )
     {
@@ -402,8 +541,9 @@ Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
         return flux_abs_Lr( t );
 }
 
+
 /* Function returns flux at absorbing bounday a. */
-Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
+Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t)
 {
     if( t == 0 || D == 0 )
     {
@@ -416,10 +556,11 @@ Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
         return flux_abs_Lr( t );
 }
 
+
 /* Calculates the total probability flux leaving the domain at time t
    This is simply the negative of the time derivative of the survival prob.
    at time t [-dS(t')/dt' for t'=t]. */
-Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
+Real GreensFunction1DAbsSinkAbs::flux_tot(Real t)
 {
     const Real D( getD() );
     const Real k( getk() ); 
@@ -433,10 +574,10 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 
     Real sum = 0, term_n = 0, prev_term = 0;
     Real root_n, root_n2, term1, term2, numerator;
-    int n = 1;
+    uint n = 0;
     do
     {
-        if ( n >= MAX_TERMS )
+        if ( n > MAX_TERMS )
         {
             std::cerr << " Too many terms needed for GF1DSink::flux_tot. N: "
                       << n << std::endl;
@@ -444,7 +585,7 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
         }
         prev_term = term_n;
     
-        root_n = get_root(n);
+        root_n = get_root( n );
         root_n2 = gsl_pow_2( root_n );
 
         term1 = sin( root_n * L ) - sin( root_n * LrmL0 ) - sin( root_n * LlpL0 );
@@ -459,13 +600,14 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
     }
     while ( fabs(term_n/sum) > EPSILON  ||
 	        fabs(prev_term/sum) > EPSILON ||
-	        n <= MIN_TERMS );
+	        n < MIN_TERMS );
 
     return  2.0 * D * sum;
 }
 
+
 /* Flux leaving throught absorbing boundary from sub-domain containing r0. */
-Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
+Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t)
 {
     const Real D( getD() );
     const Real k( getk() );    
@@ -475,10 +617,10 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
     Real root_n;
     
     Real sum = 0, numerator, term_n = 0, prev_term = 0;
-    int n = 1;
+    uint n = 0;
     do
     {
-        if ( n >= MAX_TERMS )
+        if ( n > MAX_TERMS )
         {
             std::cerr << " Too many terms needed for GF1DSink::flux_abs_Lr. N: "
                       << n << std::endl;
@@ -486,7 +628,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
         }
         prev_term = term_n;
     
-        root_n = get_root(n);
+        root_n = get_root( n );
         
         numerator = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
         numerator *= root_n;
@@ -498,13 +640,13 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t) const
     }
     while ( fabs(term_n/sum) > EPSILON  ||
             fabs(prev_term/sum) > EPSILON ||
-            n <= MIN_TERMS );
+            n < MIN_TERMS );
 
     return - D * 2 * sum;
 }
 
 /* Flux leaving throught absorbing boundary from sub-domain not containing r0. */
-Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
+Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t)
 {
     const Real D2( gsl_pow_2( getD() ) );
     const Real LrmL0( getLr() - getL0() );
@@ -512,10 +654,10 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
     Real root_n, root_n2;
     
     Real sum = 0, numerator = 0, term_n = 0, prev_term = 0;
-    int n = 1;
+    uint n = 0;
     do
     {
-        if ( n >= MAX_TERMS )
+        if ( n > MAX_TERMS )
         {
             std::cerr << " Too many terms needed for GF1DSink::flux_abs_Ll. N: "
                       << n << std::endl;
@@ -523,7 +665,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
         }
         prev_term = term_n;
     
-        root_n = get_root(n);
+        root_n = get_root( n );
         root_n2 = gsl_pow_2( root_n );        
         
         numerator = root_n2 * sin( root_n * LrmL0 );
@@ -535,22 +677,24 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t) const
     }
     while ( fabs(term_n/sum) > EPSILON  ||
             fabs(prev_term/sum) > EPSILON ||
-            n <= MIN_TERMS );
+            n < MIN_TERMS );
     
     return 2 * D2 * sum;
 }
 
+
 /* Calculates the probability flux leaving the domain through the sink
    at time t */
-Real GreensFunction1DAbsSinkAbs::flux_sink(Real t) const
+Real GreensFunction1DAbsSinkAbs::flux_sink(Real t)
 {
     return getk() * prob_r(getrsink(), t);
 }
 
+
 /* Determine which event has occured, an escape or a reaction. Based on the
    fluxes through the boundaries and the sink at the given time. */
 GreensFunction1DAbsSinkAbs::EventKind 
-GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
+GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t )
 {
     THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
     THROW_UNLESS( std::invalid_argument, t > 0.0 );
@@ -560,8 +704,8 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
     const Real r0( getr0() );
     const Real L( a - sigma );
 
-    // if the radiative boundary is impermeable (k==0) or
-    // the particle is at one the absorbing boundary (sigma or a) => IV_ESCAPE event
+    /* if the sink is impermeable (k==0) or
+       the particle is at one the absorbing boundary (sigma or a) => IV_ESCAPE event */
     if ( k == 0 || fabs(a - r0) < EPSILON * L || fabs(sigma - r0) < EPSILON * L)
     {
 	    return IV_ESCAPE;
@@ -584,61 +728,31 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
     }
 }
 
+
 /* This function is needed to cast the math. form of the function
    into the form needed by the GSL root solver. */
-Real GreensFunction1DAbsSinkAbs::drawT_f (Real t, void *p)
+Real GreensFunction1DAbsSinkAbs::drawT_f(Real t, void *p)
 {
-    // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
-    Real Xn = 0, exponent = 0;
-    Real prefactor = params->prefactor;
-    int terms = params->terms;
-
-    Real sum = 0, term = 0, prev_term = 0;
-    int n = 0;
-    do
-    {
-        if ( n >= terms )
-        {
-            std::cerr << "Too many terms needed for GF1DSink::DrawTime. N: "
-                      << n << ", conv arg: " << exponent * t <<  std::endl;
-            break;
-        }
-        prev_term = term;
-        
-        Xn = params->Xn[n];
-        exponent = params->exponent[n];
-        term = Xn * exp(exponent * t);
-	
-        sum += term;
-        n++;
-    }
-    while (fabs(term/sum) > EPSILON*1.0 ||
-           fabs(prev_term/sum) > EPSILON*1.0 ||
-           n <= MIN_TERMS );
-
-    // find the intersection with the random number
-    return params->rnd - prefactor*sum;
+    return params->rnd - params->gf->p_survival( t, params->table );
 }
 
-// Draws the first passage time from the survival probability,
-// using an assistance function drawT_f that casts the math. function
-// into the form needed by the GSL root solver.
-Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
+
+/* Draws the first passage time from the survival probability,
+   using an assistance function drawT_f that casts the math. function
+   into the form needed by the GSL root solver. */
+Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd)
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
   
     const Real a( geta() );    
     const Real r0( getr0() );
     const Real D( getD() );
-    const Real k( getk() ); 
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
     const Real L( getLr() + getLl() );
 
-    Real root_n, Xn, exponent, term1, term2, numerator;
-
     if ( D == 0.0 || L == INFINITY )
     {
 	    return INFINITY;
@@ -649,52 +763,27 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 	    return 0.0;
     }
 
-    // the structure to store the numbers to calculate the numbers for 1-S
-    struct drawT_params parameters;
+    /* the structure to store the numbers to calculate the numbers for 1-S */
+    RealVector psurvTable;
+    drawT_params params = { this, psurvTable, rnd };
 
-    /* produce the coefficients and the terms in the exponent and put them
-       in the params structure. This is not very efficient at this point,
-       coefficients should be calculated on demand->TODO or not TODO? */
-    for (int n = 0; n < MAX_TERMS; n++)
-    {
-        root_n = get_root( n + 1 );	
+    /* Find a good interval to determine the first passage time.
+       First we get the distance to one of the absorbing boundaries or the sink. */
+    Real t_guess;
+    Real dist( std::min(Lr - L0, Ll + L0) );
+    dist = std::min( dist, L0 );
 
-        term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
-        term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
-        
-        numerator = D * term1 + k * sin( root_n * Ll ) * term2 / root_n;
-        Xn = numerator / p_denominator( root_n );
-		      
-        exponent = - D * gsl_pow_2( root_n );
+    t_guess = dist * dist / ( 2.0 * D );
+    t_guess *= .1;
 
-        // store the coefficients in the structure
-        parameters.Xn[n] = Xn;
-	    // also store the values for the exponent
-        parameters.exponent[n] = exponent;
-    }
-    
-    // the prefactor of the sum is also different in case of drift<>0 :
-    parameters.prefactor = 2.0;
-    
-    // store the random number for the probability
-    parameters.rnd = rnd;
-    // store the number of terms used
-    parameters.terms = MAX_TERMS;
-    parameters.tscale = t_scale;
+    const uint n_max_guess( guess_maxi( t_guess ) );
+    calculate_n_roots( n_max_guess );
 
-    // Define the function for the rootfinder
+    /* Define the function for the rootfinder */
     gsl_function F;
     F.function = &GreensFunction1DAbsSinkAbs::drawT_f;
     F.params = &parameters;
 
-    // Find a good interval to determine the first passage time in
-    // get the distance to absorbing boundary (disregard Sink)
-    Real t_guess;
-    const Real dist( std::min(Lr, Ll) );
-    
-    t_guess = dist * dist / ( 2.0 * D );
-    t_guess *= .1;
-
     Real value( GSL_FN_EVAL( &F, t_guess ) );
     Real low( t_guess );
     Real high( t_guess );
@@ -746,8 +835,8 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 	    while ( value >= 0.0 );
     }
 
-    // find the intersection on the y-axis between the random number and
-    // the function
+    /* find the intersection on the y-axis between the random number and
+       the function */
     
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
@@ -759,88 +848,100 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     return t;
 }
 
-Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
+
+/* Retrurns the c.d.f. with respect to the position at time t. */
+Real p_int_r(Real const& rr, Real const& t, RealVector& table)
 {
-    // casts p to type 'struct drawR_params *'
-    struct drawR_params *params = (struct drawR_params *)p;
-    int  max_terms = params->terms;
-    
-    Real sum = 0, term_n = 0, prev_term = 0;
+    Real p;
+
+    const uint maxi( guess_maxi(t) );       
+    if (table.size() < maxi + 1)
+    {
+        calculate_n_roots( maxi );  // this updates the table
+        createP_int_r_Table( t, table );
+    }
     
     /* Determine in which part of the domain rr lies, and
-       thus which domain function to use. */
-    static Real (*p_int_r)
-        (Real const&, Real const&, drawR_params const&) = NULL;
+       thus which function to use. */
+    Real (*p_int_r_i)(uint const&, Real const&, RealVector const& table) = NULL;
 
     if( rr <= 0 )
-        p_int_r = &GreensFunction1DAbsSinkAbs::p_int_r_leftdomain;
-    else if( rr < params->L0 )
-            p_int_r = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA;
+        p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_leftdomain;
+    else if( rr < obj.getL0() )
+            p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA;
         else
-            p_int_r = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB;
-    
-    int n = 0;
-    do
-    {
-	    if ( n >= max_terms )
-	    {
-	        std::cerr << "GF1DSink: Too many terms needed for DrawR. N: "
-	                  << n << std::endl;
-	        break;
-	    }
-	    prev_term = term_n;
+            p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB;
 
-	    term_n = params->exp_and_denominator[n] * (*p_int_r)
-            ( rr, params->root_n[n], *params );
+    p = funcSum_all(boost::bind(&p_int_r_i, this, _1, rr, t, table),
+                    maxi);
 
-	    sum += term_n;
-	    n++;
+    return p
+}
+
+
+void createP_int_r_Table( Real const& t, RealVector& table )
+{
+    const uint root_nbr( rootList_size() );
+    uint i (table.size() );
+
+    while( i <= root_nbr )
+    {
+        table.push_back( p_exp_den_i(t, get_root( i++ ) ) );
     }
-    while (fabs(term_n/sum) > EPSILON*1.0 ||
-	       fabs(prev_term/sum) > EPSILON*1.0 ||
-           n <= MIN_TERMS );
-    
-    // Find the intersection with the random number
-    return params->prefactor * sum - params->rnd;
 }
 
+
+/* Function for GFL rootfinder of drawR. */
+Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
+{
+    struct drawR_params *params = (struct drawR_params *)p;
+    return params->gf->p_int_r(rr, params->t, params->table) - params->rnd;
+}
+
+
 //Integrated Greens function for rr part of [-Ll, 0]
-Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(Real const& rr, 
-                                                    Real const& root_n,
-                                                    drawR_params const& params)
+Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint const& i, 
+                                                    Real const& rr,
+                                                    RealVector const& table)
 {
-    const Real LrmL0( params.Lr - params.L0 );
-    const Real Llprr( params.Ll + rr );
+    const Real root_i( get_root( i ) );
+    const Real LrmL0( getLr() - getL0() );
+    const Real Llprr( getLl() + rr );
    
-    return params.D * sin( root_n * LrmL0 ) * ( cos( root_n * Llprr ) - 1.0 );
+    const Real temp(  2.0 * getD() * sin( root_n * LrmL0 ) * ( cos( root_n * Llprr ) - 1.0 ) );
+
+    return table[i] * temp;
 }
 
 //Integrated Greens function for rr part of (0, L0]
-Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(Real const& rr, 
-                                                      Real const& root_n, 
-                                                      drawR_params const& params)
+Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(uint const& i, 
+                                                      Real const& rr, 
+                                                      RealVector const& table)
 {
-    const Real LrmL0( params.Lr - params.L0 );
-    const Real Llprr( params.Ll + rr );
+    const Real root_i( get_root( i ) );
+    const Real LrmL0( getLr() - getL0() );
+    const Real Llprr( getLl() + rr );
     const Real root_n_rr( root_n * rr );
     
-    const Real temp( params.D * ( cos( root_n * Llprr ) - 1.0 ) + 
-            params.k / root_n * ( cos( root_n_rr ) - 1 ) * sin( root_n * params.Ll ) );
+    const Real temp( getD() * ( cos( root_n * Llprr ) - 1.0 ) + 
+                     getk() / root_n * ( cos( root_n_rr ) - 1.0 ) 
+                     * sin( root_n * getLl() ) );
     
-    return sin( root_n * LrmL0 ) * temp;
+    return 2.0 * table[i] * sin( root_n * LrmL0 ) * temp;
 }
 
 //Integrated Greens function for rr part of (L0, Lr]
-Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(Real const& rr, 
+Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint const& i, 
                                                       Real const& root_n, 
-                                                      drawR_params const& params)
+                                                      RealVector const& table)
 {
-    const Real Lr( params.Lr );
-    const Real Ll( params.Ll );
-    const Real L0( params.L0 );
+    const Real root_i( get_root( i ) );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+    const Real L( Lr + Ll );
     const Real LrmL0( Lr - L0 );
     const Real Lrmrr( Lr - rr );
-    const Real L( Lr + Ll );
     const Real LlpL0( Ll + L0 );
                    
     const Real term1( sin( root_n * L ) - sin( root_n * LrmL0 ) - 
@@ -849,10 +950,12 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(Real const& rr,
     const Real term2( sin( root_n * Lr ) - sin( root_n * LrmL0 ) -
             sin( root_n * L0 ) * cos( root_n * Lrmrr ));
         
-    return params.D * term1 + params.k * sin( root_n * Ll ) * term2 / root_n;
+    const Real temp( getD() * term1 + getk() * sin( root_n * Ll ) * term2 / root_n );
+
+    return 2.0 * table[i] * temp;
 }
 
-Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
+Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t)
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd <= 1.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
@@ -886,39 +989,12 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     }
 
     // the structure to store the numbers to calculate r.
-    struct drawR_params parameters;
     const Real S( p_survival(t) );
-    Real root_n, root_n2;
-
-    assert(S >= 0.0);
-
-    /* produce the coefficients and the terms in the exponent and put them
-       in the params structure //TODO: MAX_TERM -> CONVERGENCE_TERMS */
-    for (int n = 0; n < MAX_TERMS; n++)
-    {
-	    root_n = get_root(n+1);
-       	root_n2 = gsl_pow_2( root_n );
-
-        // also store the exponent and denominator.
-        parameters.exp_and_denominator[n] = Greens_fn( t, root_n, root_n2 );
-    }
-
-    //Store pointer to the rootList in params.
-    parameters.rootListPtr = get_rootListPtr();
-    
-    // The normalization.
-    parameters.prefactor = 2.0 / S;
 
-    // and the rest of the parameters
-    parameters.rnd = rnd;
-    parameters.L0 = getL0();
-    parameters.Lr = getLr();
-    parameters.Ll = getLl();
-    parameters.D = getD();
-    parameters.k = getk();
+    RealVector drawR_table;
+    drawR_params parameters = { this, drawR_table, rnd * S };
 
-    // store the number of terms used
-    parameters.terms = MAX_TERMS;
+    const uint n_max_guess( guess_maxi( t ) );
 
     // define gsl function for rootfinder
     gsl_function F;
@@ -927,8 +1003,7 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
-    // make a new solver instance
-    // TODO: incl typecast?
+
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     Real rr( findRoot( F, solver, -Ll, Lr, EPSILON*L, EPSILON,
                             "GreensFunction1DRadAbs::drawR" ) );
@@ -940,6 +1015,14 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
         return rsink + rr;
 }
 
+Real GreensFunction1DAbsSinkAbs::drawR_Xn( uint const& i, Real const& t )
+{
+    const Real root_n( get_root( i ) );
+    const Real root_n2( gsl_pow_2( root_n ) );
+
+    return Greens_fn( t, root_n, root_n2 );
+}
+
 std::string GreensFunction1DAbsSinkAbs::dump() const
 {
     std::ostringstream ss;
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 80bc9f48..58839754 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -25,6 +25,11 @@
 
 class GreensFunction1DAbsSinkAbs: public GreensFunction
 {
+public:
+    typedef std::pair<Real, Real> real_pair;
+    typedef std::vector<Real> RealVector;
+    typedef unsigned int uint;
+
 private:
     // This is a typical length scale of the system, may not be true!
     static const Real L_TYPICAL = 1E-8;
@@ -35,14 +40,11 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     // Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms used in calculating the sum
-    static const int MAX_TERMS = 500;
+    static const uint MAX_TERMS = 500;
     // The minimum number of terms
-    static const int MIN_TERMS = 20;
+    static const uint MIN_TERMS = 20;
 
 public:
-    typedef std::pair<Real, Real> real_pair;
-    typedef vector<Real> RealVector;
-
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
 	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
@@ -137,135 +139,158 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     /* Calculates the probability density of finding the particle at 
        location z at timepoint t, given that the particle is still in the 
        domain. */
-    Real calcpcum(Real r, Real t) const;
+    Real calcpcum(Real r, Real t);
 
     /* Determine which event has occured at time t. Either an escape 
        (left or right boundary) or a reaction with the sink. 
        Based on the fluxes through the boundaries at the given time. */
-    EventKind drawEventType( Real rnd, Real t ) const;
+    EventKind drawEventType( Real rnd, Real t );
 
     /* Draws the first passage time from the propensity function */
-    Real drawTime(Real rnd) const;
+    Real drawTime(Real rnd);
 
     /* Draws the position of the particle at a given time, assuming that 
        the particle is still in the domain. */
-    Real drawR(Real rnd, Real t) const;
+    Real drawR(Real rnd, Real t);
 
     /* Calculates the probability flux leaving the domain through the right 
        absorbing boundary at time t. */
-    Real flux_leavea(Real t) const;
+    Real flux_leavea(Real t);
 
     /* Calculates the probability flux leaving the domain through the left 
        absorbing boundary at time t. */
-    Real flux_leaves(Real t) const;
+    Real flux_leaves(Real t);
 
 
     /* TODO: Private methods which are public for now - debugging */
 
     // Calculates the probability of finding the particle inside the 
     // domain at time t -> the survival probability
-    Real p_survival(Real t) const;
+    Real p_survival(Real t);
 
     // Calculates the total probability flux leaving the domain at time t
-    Real flux_tot(Real t) const;
+    Real flux_tot(Real t);
 
     /* Calculates the probability flux leaving the domain through the 
        sink, sub-domain containing r0 via absorbing boundary and sub-domain
        not containing r0 via sink, respectivily. */
-    Real flux_sink(Real t) const;
-    Real flux_abs_Lr(Real t) const;
-    Real flux_abs_Ll(Real t) const;
+    Real flux_sink(Real t);
+    Real flux_abs_Lr(Real t);
+    Real flux_abs_Ll(Real t);
 
     // Calculates the probability density of finding the particle at 
     // location r at time t.
-    Real prob_r(Real r, Real t) const;
+    Real prob_r(Real r, Real t);
     
-// End of public/private mix methods
-
-//private:	// method made public for testing
-
     std::string dump() const;
 
     const char* getName() const
     {
         return "GreensFunction1DAbsSinkAbs";
     }
-    
-private:
 
-    /* return a reference to the rootList */
-    RealVecor& get_rootList() const
+private:
+    
+    /* return the rootList size */
+    uint rootList_size() const
     {
-        return rootList;
+        return rootList.size();
     }
 
-    /* returns last root. */
+    /* returns the last root. */
     Real get_last_root() const
     {
         return rootList.back();
     }
 
+    /* ads a root to rootList */
+    void ad_to_rootList( Real const& root_i )
+    {
+        rootList.push_back( root_i );
+    }
+
+    /* remove n'th root from rootList */
+    void remove_from_rootList(uint const& n)
+    {
+        rootList.erase( rootList.begin() + n );
+    }
+
+    /* Fills the rootList with the first n roots */
+    void calculate_n_roots( uint const& n );
+
     /* return the n'th root */
-    Real get_root( unsigned inst const n ) const
+    Real get_root( unsigned int const& n )
     {
-        return rootList[ n ];
+        if( n < rootList.size() )
+            return rootList[ n ];
+        else
+            calculate_n_roots( n );
     }
 
+    /* Guess the number of terms needed for convergence, given t. */
+    uint guess_maxi( Real const& t );
+
+    Real p_survival_i( uint const& i, Real const& t, RealVector& table ) const;
+
+    Real p_survival_table_i( Real const& root_i ) const;
+    
+    void createPsurvTable( Realvector& table );
+
+    Real prob_r_r0_i(uint const& i, Real const& rr, Real const& t);
+
+    Real prob_r_nor0_i( uint const& i, Real const& rr, Real const& t);
+
     struct drawR_params
     {
-        //Real root_n[MAX_TERMS];
-        vector<Real> *rootListPtr;
-	    Real exp_and_denominator[MAX_TERMS];
-	    Real prefactor;
-        Real L0;
-        Real Lr;
-        Real Ll;
-	    Real rnd;
-        Real D;
-        Real k;
-	    int terms;
+        GreensFunction1DAbsSinkAbs const* const gf;
+        const Real t;
+   	    RealVector& table;
+	    const Real rnd;
     };
 
     struct drawT_params
     {
-	    Real exponent[MAX_TERMS];
-	    Real Xn[MAX_TERMS];
-	    Real prefactor;
-	    int  terms;
-	    // the timescale used for convergence
-	    Real   tscale;
-	    Real rnd;
+	    GreensFunction1DAbsSinkAbs const* const gf;
+	    RealVector& table;
+	    const Real rnd;
     };
-    
+
     struct root_f_params
     {
 	    Real Lm_L;
 	    Real h;
     };
 
-    /* Try to guess number of terms needed for convergence, given t. */
-    unsigned int guess_maxi( Real t ) const;
+    struct lower_upper_params
+    {
+        Real h;
+        Real Lm_L;
+        Real long_half_wave;
+        Real short_half_wave;
+        uint last_long_root;
+        uint last_short_root;
+    };
+
+    /* Function returns two positions on the x-axis which straddle the next root. */
+    real_pair get_lower_and_upper( lower_upper_params& params );
 
     /* Function needed for rootfinding */
     static Real root_f(Real x, void *p);
 
-    /* Function returns i'th element in rootList */
-    Real get_root(unsigned int i) const;
-    
     /* Denominator of the Greens function */
-    inline Real p_denominator( Real const& root_n ) const;
+    inline Real p_denominator_i( Real const& root_n ) const;
     
     /* Standard form of Greens Function: exp( -Dt root_n ** 2 ) / denominator */
-    inline Real Greens_fn(Real const& t, Real const& root_n, Real const& root_n2) const;
+    inline Real p_exp_den_i(Real const& t, Real const& root_n, Real const& root_n2) const;
 
     /* p_int_r(r') for r' in left domain */
-    static Real p_int_r_leftdomain(Real const& rr, Real const& root_n, drawR_params const& params);
+    static Real p_int_r_leftdomain(Real const& rr, Real const& root_n, GreensFunction1DAbsSinkAbs const& obj);
 
     /* p_int_r(r') for r' in right domain, left of r0 */
-    static Real p_int_r_rightdomainA(Real const& rr, Real const& root_n, drawR_params const& params);
+    static Real p_int_r_rightdomainA(Real const& rr, Real const& root_n, GreensFunction1DAbsSinkAbs const& obj);
 
     /* p_int_r(r') for r' in right domain, right of r0 */
-    static Real p_int_r_rightdomainB(Real const& rr, Real const& root_n, drawR_params const& params);
+    static Real p_int_r_rightdomainB(Real const& rr, Real const& root_n, GreensFunction1DAbsSinkAbs const& obj);
 
     /* Function for drawR */
     static Real drawT_f (Real t, void *p);
@@ -274,7 +299,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     static Real drawR_f (Real t, void *p);
 
     /* Class variables */
-    // The diffusion constant and drift velocity
+    // The drift velocity
     const Real v;
     // The reaction constant
     const Real k;
@@ -303,5 +328,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 
     // Stores all the roots.
     RealVector rootList;
+
+    // Stores params for rootfiner.
+    struct lower_upper_params lo_up_params;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP

From 39ea1c185a74109f46ce34080c8c9327be7dfd40 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 28 Nov 2011 14:42:02 +0100
Subject: [PATCH 0414/1541] Removed redundancy in the code. It compiles.

---
 GreensFunction1DAbsSinkAbs.cpp | 409 ++++++++++++++-------------------
 GreensFunction1DAbsSinkAbs.hpp | 188 +++++++++------
 2 files changed, 288 insertions(+), 309 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 725cf1b3..f2c45f19 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -5,6 +5,8 @@
 #include <vector>
 #include <math.h>
 
+#include <boost/bind.hpp>
+#include <boost/format.hpp>
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_sf_trig.h>
 #include <gsl/gsl_sum.h>
@@ -37,7 +39,7 @@ Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
 }
 
 /* Calculates the first n roots of root_f */
-void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n)
+void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
 {
     const Real Lr( getLr() );
     const Real Ll( getLl() );
@@ -54,8 +56,8 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n)
     /* set params needed for get lower and upper function */
     lo_up_params.h = h;
     lo_up_params.Lm_L = Lm_L;
-    lo_up_params.long_half_wave = std::max( L/Lr * M_PI, L/Ll * M_PI );
-    lo_up_params.short_half_wave = std::min( L/Lr * M_PI, L/Ll * M_PI );
+    lo_up_params.long_period = std::max( L/Lr * M_PI, L/Ll * M_PI );
+    lo_up_params.short_period = std::min( L/Lr * M_PI, L/Ll * M_PI );
 
     /* Define the root function. */
     gsl_function F;
@@ -110,7 +112,8 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n)
 
 
 /* returns two points on the x-axis which straddle the next root. */
-std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( lower_upper_params& params )
+std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( 
+                          lower_upper_params& params ) const
 {
     const Real root_n( get_last_root() );
     const Real safety( .75 );
@@ -124,15 +127,17 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( lower_upp
     }
     else
     {
-        const Real next_root_long( get_root( params.last_long_root ) + params.long_half_wave );
-        const Real next_root_short( get_root( params.last_short_root ) + params.short_half_wave );
+        const Real next_root_long( get_root( params.last_long_root ) 
+                                   + params.long_period );
+        const Real next_root_short( get_root( params.last_short_root ) 
+                                    + params.short_period );
 
         if( next_root_long < next_root_short )
         {
             next_root_est = next_root_long;
 
             right_offset = std::min( next_root_short - next_root_est, 
-                              params.long_half_wave );
+                              params.long_period );
 
             params.last_long_root = rootList_size() + 1;
         }
@@ -141,7 +146,7 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( lower_upp
             next_root_est = next_root_short;
             
             right_offset = std::min( next_root_long - next_root_est, 
-                              params.short_half_wave );
+                              params.short_period );
 
             params.last_short_root = rootList_size() + 1;                        
         }
@@ -163,7 +168,13 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( lower_upp
     const bool parity_op( 2 * ( rootList_size()%2 ) - 1 );
 
     /* f_lower must have correct sign. */
-    assert( f_lower * parity_op < 0 );
+    if( f_lower * parity_op < 0 )
+    {
+        std::cerr << "{Parity error in lower of root# " << rootList_size() + 1 
+                      << " in GF::AbsSinkAbs " << std::endl;
+        std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
+                  << upper << ") = " << f_upper << std::endl;
+    }
 
     /* If the parity is incorrect -> correct it */
     if( f_upper * parity_op < 0)
@@ -174,9 +185,10 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( lower_upp
         
         cntr = 0;
         //TODO: find out is upper is left or right from next_root.
-        while(f_upper * parity < 0 && cntr++ < 10 )
+        while(f_upper * parity_op < 0 && cntr++ < 10 )
         {
-            upper += delta;
+            //Assume overshoot for now.
+            upper -= delta;
             f_upper = root_f( upper, &p );
         }
 
@@ -195,7 +207,7 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( lower_upp
 
 /* returns a guess for the number of terms needed for 
    the greensfunction to converge at time t */
-uint GreensFunction1DAbsSinkAbs::guess_maxi(Real const& t)
+uint GreensFunction1DAbsSinkAbs::guess_maxi(Real const& t) const
 {
     const uint safety(2);
 
@@ -247,75 +259,24 @@ inline Real GreensFunction1DAbsSinkAbs::p_denominator_i(Real const& root_n) cons
 }
 
 
-/* Calculates the probability of finding the particle inside the domain
-   at time t, the survival probability. */
-Real GreensFunction1DAbsSinkAbs::p_survival_old(Real t)
-{ 
-    const Real D ( getD() );
-    const Real k ( getk() ); 
-    const Real Lr( getLr() );
-    const Real Ll( getLl() );
-    const Real L0( getL0() );
-    const Real L ( Lr + Ll );
-
-
-    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-
-    if (t == 0.0 || (D == 0.0 && v == 0.0) )
-    {
-	    //particle can't escape.
-	    return 1.0;
-    }
-
-    Real sum = 0, numerator = 0, prev_term = 0;
-    Real term1, term2, term_n, root_n;
-    uint n = 0;
-    do
-    {
-        if ( n > MAX_TERMS )
-	    {
-	        std::cerr << " Too many terms needed for GF1DSink::p_survival. N: "
-	              << n << std::endl;
-	        break;
-	    }
-	    prev_term = numerator;
-    
-        root_n = get_root( n );
-        term1 = sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) );
-        term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) );
-        
-        numerator = ( D * term1 + k * sin( root_n * Ll ) * term2 / root_n ); 
-        term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;
-
-        //std::cerr << term_n << " " << root_n * L / M_PI << std::endl;
-	    sum += term_n;
-	    n++;
-    }
-    while ( fabs(term_n/sum) > EPSILON  ||
-	        fabs(prev_term/sum) > EPSILON ||
-	        n < MIN_TERMS );
-
-    return 2.0 * sum;
-}
-
 /* Calculates survival probability. 
    Switchbox for which greensfunction to use. */
-Real GreensFunction3DRadAbs::p_survival(Real t, RealVector& psurvTable) const
+Real GreensFunction1DAbsSinkAbs::p_survival(Real t, RealVector& psurvTable) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
 
     Real p;
 
     const Real D( getD() );
-    const Real sigma(getSigma());
-    const Real a( geta() );
+    //const Real sigma(getsigma());
+    //const Real a( geta() );
 
-    const Real L0( getL0() );
-    const Real distToa(a - r0);
-    const Real distTos(r0 - sigma);
+    //    const Real L0( getL0() );
+    //    const Real distToa(a - r0);
+    //    const Real distTos(r0 - sigma);
 
-    const Real H(6.0); // a fairly strict criterion for safety.
-    const Real maxDist(H * sqrt(2.0 * D * t));
+    //    const Real H(6.0); // a fairly strict criterion for safety.
+    //    const Real maxDist(H * sqrt(2.0 * D * t));
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
@@ -371,10 +332,8 @@ Real GreensFunction3DRadAbs::p_survival(Real t, RealVector& psurvTable) const
         createPsurvTable( psurvTable );
     }
     
-    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::
-                                p_survival_i, 
-                                this,
-                                _1, t, psurvTable),
+    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::p_survival_i, 
+                                this, _1, t, psurvTable),
                     maxi);
     
     return p;
@@ -382,15 +341,16 @@ Real GreensFunction3DRadAbs::p_survival(Real t, RealVector& psurvTable) const
 
 
 /* Calculates the i'th term of the p_survival sum. */
-Real p_survival_i( uint const& i, Real const& t, RealVector const& table) const
+Real GreensFunction1DAbsSinkAbs::p_survival_i( uint i, Real const& t, 
+                                               RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
-    exp( - getD() * t * gsl_pow_2( root_i ) ) * table[ i ];
+    return exp( - getD() * t * gsl_pow_2( root_i ) ) * table[ i ];
 }
 
 
 /* Calculates the part of the i'th term of p_surv not dependent on t */
-Real p_survival_table_i( Real const& root_i )
+Real GreensFunction1DAbsSinkAbs::p_survival_table_i( Real const& root_i ) const
 { 
     const Real D ( getD() );
     const Real k ( getk() ); 
@@ -398,11 +358,15 @@ Real p_survival_table_i( Real const& root_i )
     const Real Ll( getLl() );
     const Real L0( getL0() );
     const Real L ( Lr + Ll );
+    const Real LrmL0( Lr - L0 );
+
+    const Real term1( sin( root_i * L ) - 
+                      sin( root_i * LrmL0 ) - sin( root_i * (Ll + L0) ) );
 
-    const Real term1( sin( root_n * L ) - sin( root_n * (Lr - L0) ) - sin( root_n * (Ll + L0) ) );
-    const Real term2( sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * (Lr - L0) ) );
+    const Real term2( sin( root_i * Lr ) - sin( root_i * L0 ) 
+                      - sin( root_i * LrmL0 ) );
         
-    Real numerator( D * term1 + k * sin( root_n * Ll ) * term2 / root_n ); 
+    Real numerator( D * term1 + k * sin( root_i * Ll ) * term2 / root_i ); 
     numerator *= 2;
 
     return numerator / p_denominator_i( root_i );
@@ -412,7 +376,7 @@ Real p_survival_table_i( Real const& root_i )
 /* Fills table with terms in the p_survival sum which don't depend on t. */
 void GreensFunction1DAbsSinkAbs::createPsurvTable(RealVector& table) const
 {
-    uint const root_nbr( rootList.size() );
+    uint const root_nbr( rootList_size() );
     uint i( table.size() );
 
     while( i <= root_nbr )
@@ -423,7 +387,9 @@ void GreensFunction1DAbsSinkAbs::createPsurvTable(RealVector& table) const
 
 
 /* Returns i'th term of prob_r (domain containing r0) function */
-Real GreensFunction1DAbsSinkAbs::prob_r_r0_i(uint const& i, Real const& rr, Real const&t)
+Real GreensFunction1DAbsSinkAbs::prob_r_r0_i(uint i, 
+                                             Real const& rr, 
+                                             Real const& t) const
 {
     const Real root_i( get_root(i) );
     const Real LlpL0( Ll + L0 );
@@ -434,26 +400,28 @@ Real GreensFunction1DAbsSinkAbs::prob_r_r0_i(uint const& i, Real const& rr, Real
 
     numerator *= sin( root_i * Lrmrr );
     
-    return - 2.0 * p_exp_den_i(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+    return - 2.0 * p_exp_den_i(t, root_i, gsl_pow_2( root_i ) ) * numerator;
 }
 
 
 /* Returns i'th term of prob_r (domain not containing r0) function */
-Real GreensFunction1DAbsSinkAbs::prob_r_nor0_i(uint const& i, Real const& rr, Real const&t)
+Real GreensFunction1DAbsSinkAbs::prob_r_nor0_i(uint i, 
+                                               Real const& rr, 
+                                               Real const&t) const
 {
     const Real root_i( get_root(i) );
     const Real LrmL0( Lr - L0 );
     const Real Llprr( Ll + rr );
 
-    const Real numerator( getD() * root_n * sin( root_n * Llprr ) * sin( root_n * LrmL0 ) );
+    const Real numerator( getD() * root_i * sin( root_i * Llprr ) * sin( root_i * LrmL0 ) );
 
-    return -2.0 * p_exp_den_i(t, root_n, gsl_pow_2( root_n ) ) * numerator;
+    return -2.0 * p_exp_den_i(t, root_i, gsl_pow_2( root_i ) ) * numerator;
 }
 
 
 /* Calculates the probability density of finding the particle at location r
    at time t. */
-Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
+Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
     THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a && (r0 - sigma) >= 0.0 && r0<=a );
@@ -487,6 +455,8 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
 	    return 0.0;
     }
 
+    const uint maxi( guess_maxi( t ) );
+
     /* Determine wether rr lies in the same sub-domain as r0.
        A different function is caculated when this is the case. */
     if( rr * ( getr0() - getrsink() ) >= 0 )
@@ -503,7 +473,8 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
             L0 = temp;
         }
     
-        p = funcSum_all(boost::bind(&prob_r_r0_i, this, _1, rr, t),
+        p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_r0_i, 
+                                    this, _1, rr, t),
                         maxi);
 	}
     else
@@ -511,7 +482,8 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
         if( rr > 0 )
             rr *= -1;
 
-        p = funcSum_all(boost::bind(&prob_r_nor0_i, this, _1, rr, t),
+        p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_nor0_i, 
+                                    this, _1, rr, t),
                         maxi);
     }
     
@@ -521,171 +493,136 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t)
 
 /* Calculates the probability density of finding the particle at location z at
    timepoint t, given that the particle is still in the domain. */
-Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t)
+Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
 {
-    return prob_r(r, t)/p_survival(t);
+    RealVector table;
+    return prob_r(r, t)/p_survival(t, table);
 }
 
 
 /* Function returns flux at absorbing bounday sigma. */
-Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t)
+Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
 {
     if( t == 0 || D == 0 )
     {
         return 0.0;
     }
 
+    const Real maxi( guess_maxi( t ) );
+
     if( getr0() > getrsink() )
-        return flux_abs_Ll( t );
+        return flux_abs_Ll( t, maxi );
     else
-        return flux_abs_Lr( t );
+        return flux_abs_Lr( t, maxi );
 }
 
 
 /* Function returns flux at absorbing bounday a. */
-Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t)
+Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
 {
     if( t == 0 || D == 0 )
     {
         return 0.0;
     }
 
+    const Real maxi( guess_maxi( t ) );
+
     if( getr0() < getrsink() )
-        return flux_abs_Ll( t );
+        return flux_abs_Ll( t, maxi );
     else
-        return flux_abs_Lr( t );
+        return flux_abs_Lr( t, maxi );
 }
 
 
 /* Calculates the total probability flux leaving the domain at time t
    This is simply the negative of the time derivative of the survival prob.
    at time t [-dS(t')/dt' for t'=t]. */
-Real GreensFunction1DAbsSinkAbs::flux_tot(Real t)
+Real GreensFunction1DAbsSinkAbs::flux_tot(Real t, uint const& maxi) const
 {
     const Real D( getD() );
-    const Real k( getk() ); 
-    const Real Lr( getLr() );
-    const Real Ll( getLl() );
-    const Real L0( getL0() );
-
-    const Real L( Lr + Ll );
-    const Real LlpL0( Ll + L0 );
-    const Real LrmL0( Lr - L0 );
+    Real p;
 
-    Real sum = 0, term_n = 0, prev_term = 0;
-    Real root_n, root_n2, term1, term2, numerator;
-    uint n = 0;
-    do
-    {
-        if ( n > MAX_TERMS )
-        {
-            std::cerr << " Too many terms needed for GF1DSink::flux_tot. N: "
-                      << n << std::endl;
-            break;
-        }
-        prev_term = term_n;
-    
-        root_n = get_root( n );
-        root_n2 = gsl_pow_2( root_n );
+    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_tot_i, 
+                                this, _1, t),
+                        maxi);
 
-        term1 = sin( root_n * L ) - sin( root_n * LrmL0 ) - sin( root_n * LlpL0 );
-        term2 = sin( root_n * Lr ) - sin( root_n * L0 ) - sin( root_n * LrmL0 );
-        
-        numerator = D * term1 + k * sin( root_n * Ll ) * term2 / root_n;
+    return D * p;
+}
 
-        term_n = root_n2 * Greens_fn(t, root_n, root_n2) * numerator;
-        sum += term_n;
 
-        n++;
-    }
-    while ( fabs(term_n/sum) > EPSILON  ||
-	        fabs(prev_term/sum) > EPSILON ||
-	        n < MIN_TERMS );
+/* Calculates i'th term of total flux leaving at time t. */
+Real GreensFunction1DAbsSinkAbs::flux_tot_i(uint i, Real const& t) const
+{
+    const Real root_i( get_root( i ) );
+    const Real root_i2( gsl_pow_2( root_i ) );
 
-    return  2.0 * D * sum;
+    return root_i2 * p_survival_table_i( root_i );
 }
 
 
 /* Flux leaving throught absorbing boundary from sub-domain containing r0. */
-Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t)
+Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t, uint const& maxi) const
+{
+    const Real D( getD() );
+    Real p;
+   
+    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Lr_i, 
+                                this, _1, t),
+                        maxi);
+
+    return - D * 2 * p;
+}
+
+
+/* Calculates the i'th term of the flux at Lr. */
+Real GreensFunction1DAbsSinkAbs::flux_abs_Lr_i(uint i, Real const& t) const
 {
+    const Real root_i( get_root( i ) );
     const Real D( getD() );
     const Real k( getk() );    
     const Real Ll( getLl() );
     const Real L0( getL0() );
     const Real LlpL0( Ll + L0 );
-    Real root_n;
-    
-    Real sum = 0, numerator, term_n = 0, prev_term = 0;
-    uint n = 0;
-    do
-    {
-        if ( n > MAX_TERMS )
-        {
-            std::cerr << " Too many terms needed for GF1DSink::flux_abs_Lr. N: "
-                      << n << std::endl;
-            break;
-        }
-        prev_term = term_n;
-    
-        root_n = get_root( n );
         
-        numerator = k * sin( root_n * Ll ) * sin ( root_n * L0 ) + D * root_n * sin( root_n * LlpL0 );
-        numerator *= root_n;
+    Real numerator( k * sin( root_i * Ll ) * sin ( root_i * L0 ) + 
+                    D * root_i * sin( root_i * LlpL0 ) );
 
-        term_n = Greens_fn(t, root_n, gsl_pow_2( root_n ) ) * numerator;         
-        sum += term_n;
+    numerator *= root_i;
 
-        n++;
-    }
-    while ( fabs(term_n/sum) > EPSILON  ||
-            fabs(prev_term/sum) > EPSILON ||
-            n < MIN_TERMS );
-
-    return - D * 2 * sum;
+    return p_exp_den_i(t, root_i, gsl_pow_2( root_i ) ) * numerator; 
 }
 
+
 /* Flux leaving throught absorbing boundary from sub-domain not containing r0. */
-Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t)
+Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t, uint const& maxi) const
 {
     const Real D2( gsl_pow_2( getD() ) );
-    const Real LrmL0( getLr() - getL0() );
+    Real p;
 
-    Real root_n, root_n2;
-    
-    Real sum = 0, numerator = 0, term_n = 0, prev_term = 0;
-    uint n = 0;
-    do
-    {
-        if ( n > MAX_TERMS )
-        {
-            std::cerr << " Too many terms needed for GF1DSink::flux_abs_Ll. N: "
-                      << n << std::endl;
-            break;
-        }
-        prev_term = term_n;
+    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Lr_i, 
+                                this, _1, t),
+                        maxi);
     
-        root_n = get_root( n );
-        root_n2 = gsl_pow_2( root_n );        
-        
-        numerator = root_n2 * sin( root_n * LrmL0 );
+    return 2 * D2 * p;
+}
 
-        term_n = Greens_fn(t, root_n, root_n2 ) * numerator;
-        sum += term_n;
 
-        n++;
-    }
-    while ( fabs(term_n/sum) > EPSILON  ||
-            fabs(prev_term/sum) > EPSILON ||
-            n < MIN_TERMS );
-    
-    return 2 * D2 * sum;
+/* Calculates the i'th term of the flux at Ll. */
+Real GreensFunction1DAbsSinkAbs::flux_abs_Ll_i(uint i, Real const& t) const
+{
+    const Real root_i( get_root( i ) );
+    const Real root_i2( gsl_pow_2( root_i ) );
+    const Real LrmL0( getLr() - getL0() );
+        
+    Real numerator( root_i2 * sin( root_i * LrmL0 ) );
+
+    return p_exp_den_i(t, root_i, root_i2 ) * numerator;
 }
 
 
 /* Calculates the probability flux leaving the domain through the sink
    at time t */
-Real GreensFunction1DAbsSinkAbs::flux_sink(Real t)
+Real GreensFunction1DAbsSinkAbs::flux_sink(Real t) const
 {
     return getk() * prob_r(getrsink(), t);
 }
@@ -694,7 +631,7 @@ Real GreensFunction1DAbsSinkAbs::flux_sink(Real t)
 /* Determine which event has occured, an escape or a reaction. Based on the
    fluxes through the boundaries and the sink at the given time. */
 GreensFunction1DAbsSinkAbs::EventKind 
-GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t )
+GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
 {
     THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
     THROW_UNLESS( std::invalid_argument, t > 0.0 );
@@ -716,7 +653,9 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t )
        (1) Leave through left or right boundary - IV_ESCAPE
        (2) Leave through sink - IV_REACTION
     */
-    rnd *= flux_tot( t );
+    const Real maxi( guess_maxi( t ) );
+    rnd *= flux_tot( t, maxi );
+
     const Real p_sink( flux_sink( t ) );
     if (rnd < p_sink)
     {
@@ -741,7 +680,7 @@ Real GreensFunction1DAbsSinkAbs::drawT_f(Real t, void *p)
 /* Draws the first passage time from the survival probability,
    using an assistance function drawT_f that casts the math. function
    into the form needed by the GSL root solver. */
-Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd)
+Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
   
@@ -782,7 +721,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd)
     /* Define the function for the rootfinder */
     gsl_function F;
     F.function = &GreensFunction1DAbsSinkAbs::drawT_f;
-    F.params = &parameters;
+    F.params = &params;
 
     Real value( GSL_FN_EVAL( &F, t_guess ) );
     Real low( t_guess );
@@ -849,8 +788,11 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd)
 }
 
 
-/* Retrurns the c.d.f. with respect to the position at time t. */
-Real p_int_r(Real const& rr, Real const& t, RealVector& table)
+/* Retrurns the c.d.f. with respect to the position at time t. 
+   - Also a switchbox for which GF to choose. */
+Real GreensFunction1DAbsSinkAbs::p_int_r(Real const& rr, 
+                                         Real const& t, 
+                                         RealVector& table) const
 {
     Real p;
 
@@ -863,30 +805,34 @@ Real p_int_r(Real const& rr, Real const& t, RealVector& table)
     
     /* Determine in which part of the domain rr lies, and
        thus which function to use. */
-    Real (*p_int_r_i)(uint const&, Real const&, RealVector const& table) = NULL;
+    Real (GreensFunction1DAbsSinkAbs::*p_int_r_i)
+    (uint, Real const&, RealVector const& table) const = NULL;
 
     if( rr <= 0 )
         p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_leftdomain;
-    else if( rr < obj.getL0() )
+    else if( rr < getL0() )
             p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA;
         else
             p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB;
 
-    p = funcSum_all(boost::bind(&p_int_r_i, this, _1, rr, t, table),
+    p = funcSum_all(boost::bind(p_int_r_i, 
+                                this, _1, rr, table),
                     maxi);
 
-    return p
+    return 2.0 * p;
 }
 
 
-void createP_int_r_Table( Real const& t, RealVector& table )
+void GreensFunction1DAbsSinkAbs::createP_int_r_Table( Real const& t, 
+                                                      RealVector& table ) const
 {
     const uint root_nbr( rootList_size() );
     uint i (table.size() );
 
     while( i <= root_nbr )
     {
-        table.push_back( p_exp_den_i(t, get_root( i++ ) ) );
+        const Real root_i( get_root( i ) );
+        table.push_back( p_exp_den_i(t, root_i, gsl_pow_2( root_i ) ) );
     }
 }
 
@@ -900,40 +846,43 @@ Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
 
 
 //Integrated Greens function for rr part of [-Ll, 0]
-Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint const& i, 
+Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint i, 
                                                     Real const& rr,
-                                                    RealVector const& table)
+                                                    RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
     const Real LrmL0( getLr() - getL0() );
     const Real Llprr( getLl() + rr );
    
-    const Real temp(  2.0 * getD() * sin( root_n * LrmL0 ) * ( cos( root_n * Llprr ) - 1.0 ) );
+    const Real temp( getD() * sin( root_i * LrmL0 ) * 
+                     ( cos( root_i * Llprr ) - 1.0 ) );
 
     return table[i] * temp;
 }
 
+
 //Integrated Greens function for rr part of (0, L0]
-Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(uint const& i, 
+Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(uint i, 
                                                       Real const& rr, 
-                                                      RealVector const& table)
+                                                      RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
     const Real LrmL0( getLr() - getL0() );
     const Real Llprr( getLl() + rr );
-    const Real root_n_rr( root_n * rr );
+    const Real root_i_rr( root_i * rr );
     
-    const Real temp( getD() * ( cos( root_n * Llprr ) - 1.0 ) + 
-                     getk() / root_n * ( cos( root_n_rr ) - 1.0 ) 
-                     * sin( root_n * getLl() ) );
+    const Real temp( getD() * ( cos( root_i * Llprr ) - 1.0 ) + 
+                     getk() / root_i * ( cos( root_i_rr ) - 1.0 ) 
+                     * sin( root_i * getLl() ) );
     
-    return 2.0 * table[i] * sin( root_n * LrmL0 ) * temp;
+    return table[i] * sin( root_i * LrmL0 ) * temp;
 }
 
+
 //Integrated Greens function for rr part of (L0, Lr]
-Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint const& i, 
-                                                      Real const& root_n, 
-                                                      RealVector const& table)
+Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint i, 
+                                                      Real const& rr, 
+                                                      RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
     const Real Lr( getLr() );
@@ -944,18 +893,20 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint const& i,
     const Real Lrmrr( Lr - rr );
     const Real LlpL0( Ll + L0 );
                    
-    const Real term1( sin( root_n * L ) - sin( root_n * LrmL0 ) - 
-            sin( root_n * LlpL0 ) * cos( root_n * Lrmrr ) );
+    const Real term1( sin( root_i * L ) - sin( root_i * LrmL0 ) - 
+            sin( root_i * LlpL0 ) * cos( root_i * Lrmrr ) );
             
-    const Real term2( sin( root_n * Lr ) - sin( root_n * LrmL0 ) -
-            sin( root_n * L0 ) * cos( root_n * Lrmrr ));
+    const Real term2( sin( root_i * Lr ) - sin( root_i * LrmL0 ) -
+            sin( root_i * L0 ) * cos( root_i * Lrmrr ));
         
-    const Real temp( getD() * term1 + getk() * sin( root_n * Ll ) * term2 / root_n );
+    const Real temp( getD() * term1 + 
+                     getk() * sin( root_i * Ll ) * term2 / root_i );
 
-    return 2.0 * table[i] * temp;
+    return table[i] * temp;
 }
 
-Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t)
+
+Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd <= 1.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
@@ -989,12 +940,11 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t)
     }
 
     // the structure to store the numbers to calculate r.
-    const Real S( p_survival(t) );
+    RealVector table;
+    const Real S( p_survival(t, table) );
 
     RealVector drawR_table;
-    drawR_params parameters = { this, drawR_table, rnd * S };
-
-    const uint n_max_guess( guess_maxi( t ) );
+    drawR_params parameters = { this, t, drawR_table, rnd * S };
 
     // define gsl function for rootfinder
     gsl_function F;
@@ -1015,13 +965,6 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t)
         return rsink + rr;
 }
 
-Real GreensFunction1DAbsSinkAbs::drawR_Xn( uint const& i, Real const& t )
-{
-    const Real root_n( get_root( i ) );
-    const Real root_n2( gsl_pow_2( root_n ) );
-
-    return Greens_fn( t, root_n, root_n2 );
-}
 
 std::string GreensFunction1DAbsSinkAbs::dump() const
 {
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 58839754..3662edd4 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -135,52 +135,57 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    return v;
     }
 
-    
     /* Calculates the probability density of finding the particle at 
        location z at timepoint t, given that the particle is still in the 
        domain. */
-    Real calcpcum(Real r, Real t);
+    Real calcpcum(Real r, Real t) const;
 
     /* Determine which event has occured at time t. Either an escape 
        (left or right boundary) or a reaction with the sink. 
        Based on the fluxes through the boundaries at the given time. */
-    EventKind drawEventType( Real rnd, Real t );
+    EventKind drawEventType( Real rnd, Real t ) const;
 
     /* Draws the first passage time from the propensity function */
-    Real drawTime(Real rnd);
+    Real drawTime(Real rnd) const;
 
     /* Draws the position of the particle at a given time, assuming that 
        the particle is still in the domain. */
-    Real drawR(Real rnd, Real t);
+    Real drawR(Real rnd, Real t) const;
 
     /* Calculates the probability flux leaving the domain through the right 
        absorbing boundary at time t. */
-    Real flux_leavea(Real t);
+    Real flux_leavea(Real t) const;
 
     /* Calculates the probability flux leaving the domain through the left 
        absorbing boundary at time t. */
-    Real flux_leaves(Real t);
+    Real flux_leaves(Real t) const;
 
+    /* Calculates the probability flux leaving the domain through the sink 
+       at time t. */
+    Real flux_sink(Real t) const;
 
-    /* TODO: Private methods which are public for now - debugging */
+    /* Calculates the probability of finding the particle inside the 
+       domain at time t -> the survival probability */
+    Real p_survival(Real t, RealVector& psurvTable) const;
+
+    /* c.d.f. of the greensfunction with respect to position. */
+    Real p_int_r( Real const& rr, Real const& t, RealVector& table ) const;
 
-    // Calculates the probability of finding the particle inside the 
-    // domain at time t -> the survival probability
-    Real p_survival(Real t);
 
-    // Calculates the total probability flux leaving the domain at time t
-    Real flux_tot(Real t);
+    /* TODO: Private methods which are public for now - debugging */
+
+    /* Calculates the total probability flux leaving the domain at time t. */
+    Real flux_tot(Real t, uint const& maxi) const;
 
     /* Calculates the probability flux leaving the domain through the 
-       sink, sub-domain containing r0 via absorbing boundary and sub-domain
-       not containing r0 via sink, respectivily. */
-    Real flux_sink(Real t);
-    Real flux_abs_Lr(Real t);
-    Real flux_abs_Ll(Real t);
-
-    // Calculates the probability density of finding the particle at 
-    // location r at time t.
-    Real prob_r(Real r, Real t);
+       sub-domain containing r0 via the absorbing boundary and the flux 
+       leaving the sub-domain not containing r0 via the absorbing boundary. */
+    Real flux_abs_Lr(Real t, uint const& maxi) const;
+    Real flux_abs_Ll(Real t, uint const& maxi) const;
+
+    /* Calculates the probability density of finding the particle at 
+       location r at time t. */
+    Real prob_r(Real r, Real t) const;
     
     std::string dump() const;
 
@@ -190,6 +195,41 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     }
 
 private:
+    /* used structures */
+
+    struct drawR_params
+    {
+        GreensFunction1DAbsSinkAbs const* gf;
+        const Real t;
+   	    RealVector& table;
+	    const Real rnd;
+    };
+
+    struct drawT_params
+    {
+	    GreensFunction1DAbsSinkAbs const* gf;
+	    RealVector& table;
+	    const Real rnd;
+    };
+
+    struct root_f_params
+    {
+	    Real Lm_L;
+	    Real h;
+    };
+
+    struct lower_upper_params
+    {
+        Real h;
+        Real Lm_L;
+        Real long_period;
+        Real short_period;
+        uint last_long_root;
+        uint last_short_root;
+    };
+
+
+    /* Functions managing the rootList */
     
     /* return the rootList size */
     uint rootList_size() const
@@ -203,79 +243,82 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
         return rootList.back();
     }
 
-    /* ads a root to rootList */
-    void ad_to_rootList( Real const& root_i )
+    /* ad a root to the rootList */
+    void ad_to_rootList( Real const& root_i ) const
     {
         rootList.push_back( root_i );
     }
 
     /* remove n'th root from rootList */
-    void remove_from_rootList(uint const& n)
+    void remove_from_rootList(uint const& n) const
     {
         rootList.erase( rootList.begin() + n );
     }
 
-    /* Fills the rootList with the first n roots */
-    void calculate_n_roots( uint const& n );
-
     /* return the n'th root */
-    Real get_root( unsigned int const& n )
+    Real get_root( uint const& n ) const
     {
         if( n < rootList.size() )
             return rootList[ n ];
         else
+        {
             calculate_n_roots( n );
+            return rootList[ n ];
+        }
     }
 
+
+    /* Functions concerned with finding the roots. */
+
+    /* Fills the rootList with the first n roots */
+    void calculate_n_roots( uint const& n ) const;
+    
+    /* Function returns two positions on the x-axis which straddle the next root. */
+    real_pair get_lower_and_upper( lower_upper_params& params ) const;
+
+    /* Function of which we need the roots. */
+    static Real root_f(Real x, void *p);
+
     /* Guess the number of terms needed for convergence, given t. */
-    uint guess_maxi( Real const& t );
+    uint guess_maxi( Real const& t ) const;
+
 
-    Real p_survival_i( uint const& i, Real const& t, RealVector& table ) const;
+    /* Function for calculating the survival probability. */
+    Real p_survival_i( uint i, Real const& t, RealVector const& table ) const;
 
     Real p_survival_table_i( Real const& root_i ) const;
     
-    void createPsurvTable( Realvector& table );
+    void createPsurvTable( RealVector& table ) const;
 
-    Real prob_r_r0_i(uint const& i, Real const& rr, Real const& t);
 
-    Real prob_r_nor0_i( uint const& i, Real const& rr, Real const& t);
+    /* Functions for calculating thegreensfunction. */
+    Real prob_r_r0_i(uint i, Real const& rr, Real const& t) const;
 
-    struct drawR_params
-    {
-        GreensFunction1DAbsSinkAbs const* const gf;
-        const Real t;
-   	    RealVector& table;
-	    const Real rnd;
-    };
+    Real prob_r_nor0_i( uint i, Real const& rr, Real const& t) const;
 
-    struct drawT_params
-    {
-	    GreensFunction1DAbsSinkAbs const* const gf;
-	    RealVector& table;
-	    const Real rnd;
-    };
 
-    struct root_f_params
-    {
-	    Real Lm_L;
-	    Real h;
-    };
+    /* Functions for calculating the fluxes. */
+    Real flux_tot_i(uint i, Real const& t) const;
 
-    struct lower_upper_params
-    {
-        Real h;
-        Real Lm_L;
-        Real long_half_wave;
-        Real short_half_wave;
-        uint last_long_root;
-        uint last_short_root;
-    };
+    Real flux_abs_Lr_i(uint i, Real const& t) const;
 
-    /* Function returns two positions on the x-axis which straddle the next root. */
-    real_pair get_lower_and_upper( lower_upper_params& params );
+    Real flux_abs_Ll_i(uint i, Real const& t) const;
+
+
+
+    /* functions for calculating the c.d.f. */
+
+    /* i'th term of p_int_r(r') for r' in left domain */
+    Real p_int_r_leftdomain(uint i, Real const& rr, RealVector const& table) const;
+
+    /* i'th term of p_int_r(r') for r' in right domain, left of r0 */
+    Real p_int_r_rightdomainA(uint i, Real const& rr, RealVector const& table) const;
+
+    /* i'th term of p_int_r(r') for r' in right domain, right of r0 */
+    Real p_int_r_rightdomainB(uint i, Real const& rr, RealVector const& table) const;
+
+    void createP_int_r_Table( Real const& t, RealVector& table ) const;
 
-    /* Function needed for rootfinding */
-    static Real root_f(Real x, void *p);
 
     /* Denominator of the Greens function */
     inline Real p_denominator_i( Real const& root_n ) const;
@@ -283,22 +326,15 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     /* Standard form of Greens Function: exp( -Dt root_n ** 2 ) / denominator */
     inline Real p_exp_den_i(Real const& t, Real const& root_n, Real const& root_n2) const;
 
-    /* p_int_r(r') for r' in left domain */
-    static Real p_int_r_leftdomain(Real const& rr, Real const& root_n, GreensFunction1DAbsSinkAbs const& obj);
-
-    /* p_int_r(r') for r' in right domain, left of r0 */
-    static Real p_int_r_rightdomainA(Real const& rr, Real const& root_n, GreensFunction1DAbsSinkAbs const& obj);
-
-    /* p_int_r(r') for r' in right domain, right of r0 */
-    static Real p_int_r_rightdomainB(Real const& rr, Real const& root_n, GreensFunction1DAbsSinkAbs const& obj);
-
     /* Function for drawR */
     static Real drawT_f (Real t, void *p);
 
     /* Function for drawTime */
     static Real drawR_f (Real t, void *p);
 
+    
     /* Class variables */
+
     // The drift velocity
     const Real v;
     // The reaction constant
@@ -327,9 +363,9 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     Real L0;
 
     // Stores all the roots.
-    RealVector rootList;
+    mutable RealVector rootList;
 
     // Stores params for rootfiner.
-    struct lower_upper_params lo_up_params;
+    mutable struct lower_upper_params lo_up_params;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP

From 4b330162278b44bb0c5da24053516a21814722b0 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 29 Nov 2011 11:53:36 +0100
Subject: [PATCH 0415/1541] GFn in optima forma!

---
 GreensFunction1DAbsSinkAbs.cpp | 241 ++++++++++++++++++---------------
 GreensFunction1DAbsSinkAbs.hpp |  22 ++-
 greens_functions.cpp           |   1 +
 3 files changed, 147 insertions(+), 117 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index f2c45f19..76a8cda0 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -43,7 +43,7 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
 {
     const Real Lr( getLr() );
     const Real Ll( getLl() );
-    const Real L( Lr + Lr );
+    const Real L( Lr + Ll );
     const Real Lm( Lr - Ll );
     const Real Lm_L( Lm / L );
     const Real h( getk() * L / ( 2 * getD() ) );
@@ -53,7 +53,6 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
 
     real_pair lower_upper_pair;
 
-    /* set params needed for get lower and upper function */
     lo_up_params.h = h;
     lo_up_params.Lm_L = Lm_L;
     lo_up_params.long_period = std::max( L/Lr * M_PI, L/Ll * M_PI );
@@ -70,41 +69,35 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
-    /* Find all the roots up to the nth*/
     i = rootList_size();
 
-    /* If rootList is empty, add first root: 0. Will be removed later. */
-    uint n_adapt( n );
+    /* Stores the last root with long or short period. */
     if(i == 0)
     {
-        /* Stores pointers to last root with long/short wavelength. */
-        lo_up_params.last_long_root = 0;
-        lo_up_params.last_short_root = 0;
-        ad_to_rootList( 0.0 );
-        n_adapt++;
+        lo_up_params.last_long_root = 0.0;
+        lo_up_params.last_short_root = 0.0;
     }
 
-    while(i++ < n_adapt)
+    /* Find all the roots up to the nth */
+    while(i++ < n)
     {
-        lower_upper_pair = get_lower_and_upper( lo_up_params );
+        lower_upper_pair = get_lower_and_upper();
 
         root_i = findRoot( F, solver, lower_upper_pair.first, lower_upper_pair.second, 
                            1.0*EPSILON, EPSILON, "GreensFunction1DAbsSinkAbs::root_f" );
 
-        assert( root_i > get_last_root() - EPSILON );
+        assert( root_i > std::max(lo_up_params.last_long_root, 
+                                  lo_up_params.last_short_root) 
+                - EPSILON );
 
-        ad_to_rootList( root_i );
-    }
+        ad_to_rootList( root_i / L );
 
-    /* Remove first root */
-    if( get_root( 0 ) == 0.0 )
-    {
-        remove_from_rootList( 0 );
-        /* correct pointers for removal */
-        if( lo_up_params.last_long_root > 0 ) 
-            lo_up_params.last_long_root--;
-        if( lo_up_params.last_short_root > 0 ) 
-            lo_up_params.last_short_root--;
+        if(lo_up_params.last_was_long)
+            lo_up_params.last_long_root = root_i;
+        else
+            lo_up_params.last_short_root = root_i;
+
+        std::cerr << "root#: " << rootList_size() << " - " << get_last_root() << std::endl;
     }
 
     gsl_root_fsolver_free( solver );
@@ -112,52 +105,54 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
 
 
 /* returns two points on the x-axis which straddle the next root. */
-std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper( 
-                          lower_upper_params& params ) const
+std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
 {
-    const Real root_n( get_last_root() );
+    const Real root_n( std::max(lo_up_params.last_long_root, 
+                                lo_up_params.last_short_root) );
     const Real safety( .75 );
 
     Real lower, upper, next_root_est, left_offset, right_offset;
 
-    if( params.h / root_n < 1 )
+    const Real last_root( root_n ==  0.0 ? M_PI : root_n );
+
+    if( lo_up_params.h / last_root < 1 )
     {
         right_offset = M_PI;
         next_root_est = root_n + M_PI;
     }
     else
     {
-        const Real next_root_long( get_root( params.last_long_root ) 
-                                   + params.long_period );
-        const Real next_root_short( get_root( params.last_short_root ) 
-                                    + params.short_period );
+        const Real next_root_long( lo_up_params.last_long_root 
+                                   + lo_up_params.long_period );
+        const Real next_root_short( lo_up_params.last_short_root
+                                    + lo_up_params.short_period );
 
         if( next_root_long < next_root_short )
         {
             next_root_est = next_root_long;
 
             right_offset = std::min( next_root_short - next_root_est, 
-                              params.long_period );
+                              lo_up_params.long_period );
 
-            params.last_long_root = rootList_size() + 1;
+            lo_up_params.last_was_long = true;
         }
         else
         {
             next_root_est = next_root_short;
             
             right_offset = std::min( next_root_long - next_root_est, 
-                              params.short_period );
+                              lo_up_params.short_period );
 
-            params.last_short_root = rootList_size() + 1;                        
+            lo_up_params.last_was_long = false;                        
         }
     }
     
-    left_offset = next_root_est - root_n - EPSILON;      
+    left_offset = next_root_est - root_n - 1000 * EPSILON;      
 
     lower = next_root_est - left_offset;
     upper = next_root_est + safety * right_offset;
 
-    struct root_f_params p = { params.Lm_L, params.h };
+    struct root_f_params p = { lo_up_params.Lm_L, lo_up_params.h };
 
     Real f_lower( root_f( lower, &p ) );
     Real f_upper( root_f( upper, &p ) );
@@ -165,12 +160,12 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper(
     /* set the parity operator for the next root: 
        +1 for an even root.
        -1 for an odd root. */
-    const bool parity_op( 2 * ( rootList_size()%2 ) - 1 );
+    const int parity_op( 2 * ( rootList_size()%2 ) - 1 );
 
     /* f_lower must have correct sign. */
-    if( f_lower * parity_op < 0 )
+    if( f_lower * parity_op > 0 )
     {
-        std::cerr << "{Parity error in lower of root# " << rootList_size() + 1 
+        std::cerr << "Parity error in lower of root# " << rootList_size() + 1 
                       << " in GF::AbsSinkAbs " << std::endl;
         std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
                   << upper << ") = " << f_upper << std::endl;
@@ -259,9 +254,15 @@ inline Real GreensFunction1DAbsSinkAbs::p_denominator_i(Real const& root_n) cons
 }
 
 
-/* Calculates survival probability. 
+Real GreensFunction1DAbsSinkAbs::p_survival(Real t) const
+{
+    RealVector table;
+    return p_survival_table(t, table);
+}
+
+/* Calculates survival probability using a table. 
    Switchbox for which greensfunction to use. */
-Real GreensFunction1DAbsSinkAbs::p_survival(Real t, RealVector& psurvTable) const
+Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
 
@@ -341,7 +342,8 @@ Real GreensFunction1DAbsSinkAbs::p_survival(Real t, RealVector& psurvTable) cons
 
 
 /* Calculates the i'th term of the p_survival sum. */
-Real GreensFunction1DAbsSinkAbs::p_survival_i( uint i, Real const& t, 
+Real GreensFunction1DAbsSinkAbs::p_survival_i( uint i, 
+                                               Real const& t, 
                                                RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
@@ -367,7 +369,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table_i( Real const& root_i ) const
                       - sin( root_i * LrmL0 ) );
         
     Real numerator( D * term1 + k * sin( root_i * Ll ) * term2 / root_i ); 
-    numerator *= 2;
+    numerator *= 2.0;
 
     return numerator / p_denominator_i( root_i );
 }
@@ -392,8 +394,21 @@ Real GreensFunction1DAbsSinkAbs::prob_r_r0_i(uint i,
                                              Real const& t) const
 {
     const Real root_i( get_root(i) );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    Real L0( getL0() );
+    Real rr2( rr );
+    
+    /* Check if r is left or right of the starting position r0.
+       If so, interchange rr with L0. */
+    if( rr < L0 )
+    {
+        rr2 = L0;
+        L0 = rr;
+    }
+
     const Real LlpL0( Ll + L0 );
-    const Real Lrmrr( Lr - rr );
+    const Real Lrmrr( Lr - rr2 );
     
     Real numerator( getD() * root_i * sin( root_i * LlpL0 ) + 
                     getk() * sin( root_i * Ll ) * sin( root_i * L0) );
@@ -410,12 +425,16 @@ Real GreensFunction1DAbsSinkAbs::prob_r_nor0_i(uint i,
                                                Real const&t) const
 {
     const Real root_i( get_root(i) );
+    const Real Lr( getLr() );
+    const Real Ll( getLl() );
+    const Real L0( getL0() );
+
     const Real LrmL0( Lr - L0 );
     const Real Llprr( Ll + rr );
 
     const Real numerator( getD() * root_i * sin( root_i * Llprr ) * sin( root_i * LrmL0 ) );
 
-    return -2.0 * p_exp_den_i(t, root_i, gsl_pow_2( root_i ) ) * numerator;
+    return - 2.0 * p_exp_den_i(t, root_i, gsl_pow_2( root_i ) ) * numerator;
 }
 
 
@@ -430,10 +449,6 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L( Lr + Ll );    
-    
-    Real L0( getL0() );
-    Real rr( r - getrsink() ) ;
-    Real p;  
 
     // if there was no time change or zero diffusivity => no movement
     if (t == 0 || D == 0)
@@ -455,33 +470,23 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 	    return 0.0;
     }
 
+    const Real rr( getr0() - getrsink() >= 0 ? r - rsink : rsink - r  );
+
+    Real p;  
+
     const uint maxi( guess_maxi( t ) );
+    calculate_n_roots( maxi );
 
     /* Determine wether rr lies in the same sub-domain as r0.
        A different function is caculated when this is the case. */
-    if( rr * ( getr0() - getrsink() ) >= 0 )
-    {
-        if(rr < 0)
-            rr *= -1;
-
-        /* Check if r is left or right of the starting position r0.
-           If so, interchange r with r0. */
-        if( rr < L0 )
-        {
-            const Real temp( rr );
-            rr = L0;
-            L0 = temp;
-        }
-    
+    if( rr >= 0 )
+    {   
         p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_r0_i, 
                                     this, _1, rr, t),
                         maxi);
 	}
     else
     {
-        if( rr > 0 )
-            rr *= -1;
-
         p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_nor0_i, 
                                     this, _1, rr, t),
                         maxi);
@@ -491,12 +496,11 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 }
 
 
-/* Calculates the probability density of finding the particle at location z at
-   timepoint t, given that the particle is still in the domain. */
+/* Calculates the probability density of finding the particle at location r at
+   time t, given that the particle is still in the domain. */
 Real GreensFunction1DAbsSinkAbs::calcpcum(Real r, Real t) const
 {
-    RealVector table;
-    return prob_r(r, t)/p_survival(t, table);
+    return prob_r(r, t)/p_survival( t );
 }
 
 
@@ -510,10 +514,10 @@ Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
 
     const Real maxi( guess_maxi( t ) );
 
-    if( getr0() > getrsink() )
+    if( getr0() >= getrsink() )
         return flux_abs_Ll( t, maxi );
     else
-        return flux_abs_Lr( t, maxi );
+        return - flux_abs_Lr( t, maxi );
 }
 
 
@@ -528,7 +532,7 @@ Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
     const Real maxi( guess_maxi( t ) );
 
     if( getr0() < getrsink() )
-        return flux_abs_Ll( t, maxi );
+        return - flux_abs_Ll( t, maxi );
     else
         return flux_abs_Lr( t, maxi );
 }
@@ -537,11 +541,13 @@ Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
 /* Calculates the total probability flux leaving the domain at time t
    This is simply the negative of the time derivative of the survival prob.
    at time t [-dS(t')/dt' for t'=t]. */
-Real GreensFunction1DAbsSinkAbs::flux_tot(Real t, uint const& maxi) const
+Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 {
     const Real D( getD() );
     Real p;
 
+    const Real maxi( guess_maxi( t ) );
+
     p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_tot_i, 
                                 this, _1, t),
                         maxi);
@@ -556,7 +562,8 @@ Real GreensFunction1DAbsSinkAbs::flux_tot_i(uint i, Real const& t) const
     const Real root_i( get_root( i ) );
     const Real root_i2( gsl_pow_2( root_i ) );
 
-    return root_i2 * p_survival_table_i( root_i );
+    return root_i2 * exp( - getD() * t * root_i2 ) * 
+        p_survival_table_i( root_i );
 }
 
 
@@ -599,7 +606,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t, uint const& maxi) const
     const Real D2( gsl_pow_2( getD() ) );
     Real p;
 
-    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Lr_i, 
+    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Ll_i, 
                                 this, _1, t),
                         maxi);
     
@@ -653,8 +660,8 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
        (1) Leave through left or right boundary - IV_ESCAPE
        (2) Leave through sink - IV_REACTION
     */
-    const Real maxi( guess_maxi( t ) );
-    rnd *= flux_tot( t, maxi );
+
+    rnd *= flux_tot( t );
 
     const Real p_sink( flux_sink( t ) );
     if (rnd < p_sink)
@@ -673,7 +680,7 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
 Real GreensFunction1DAbsSinkAbs::drawT_f(Real t, void *p)
 {
     struct drawT_params *params = (struct drawT_params *)p;
-    return params->rnd - params->gf->p_survival( t, params->table );
+    return params->rnd - params->gf->p_survival_table( t, params->table );
 }
 
 
@@ -715,8 +722,8 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     t_guess = dist * dist / ( 2.0 * D );
     t_guess *= .1;
 
-    const uint n_max_guess( guess_maxi( t_guess ) );
-    calculate_n_roots( n_max_guess );
+    const uint maxi( guess_maxi( t_guess ) );
+    calculate_n_roots( maxi );
 
     /* Define the function for the rootfinder */
     gsl_function F;
@@ -782,7 +789,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     // make a new solver instance
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     const Real t( findRoot( F, solver, low, high, t_scale*EPSILON, EPSILON,
-                            "GreensFunction1DAnsSinkAbs::drawTime" ) );
+                            "GreensFunction1DAbsSinkAbs::drawTime" ) );
     // return the drawn time
     return t;
 }
@@ -790,19 +797,25 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 
 /* Retrurns the c.d.f. with respect to the position at time t. 
    - Also a switchbox for which GF to choose. */
-Real GreensFunction1DAbsSinkAbs::p_int_r(Real const& rr, 
-                                         Real const& t, 
-                                         RealVector& table) const
+Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r, 
+                                               Real const& t, 
+                                               RealVector& table) const
 {
     Real p;
+    const Real rsink( getrsink() );
 
-    const uint maxi( guess_maxi(t) );       
+    /* when r0 lies left of the sink, mirror the domain around rsink
+       : rr -> -rr. */
+    const Real rr( getr0() - rsink >= 0 ? r - rsink : rsink - r  );
+
+    const uint maxi( guess_maxi(t) );    
+   
     if (table.size() < maxi + 1)
     {
         calculate_n_roots( maxi );  // this updates the table
         createP_int_r_Table( t, table );
     }
-    
+
     /* Determine in which part of the domain rr lies, and
        thus which function to use. */
     Real (GreensFunction1DAbsSinkAbs::*p_int_r_i)
@@ -823,28 +836,32 @@ Real GreensFunction1DAbsSinkAbs::p_int_r(Real const& rr,
 }
 
 
+Real GreensFunction1DAbsSinkAbs::p_int_r(Real const& r, 
+                                         Real const& t) const
+{
+    THROW_UNLESS( std::invalid_argument, r >= getsigma() && r <= geta() );
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
+    RealVector table;
+    return p_int_r_table(r, t, table) / p_survival( t );
+}
+
+
 void GreensFunction1DAbsSinkAbs::createP_int_r_Table( Real const& t, 
                                                       RealVector& table ) const
 {
     const uint root_nbr( rootList_size() );
-    uint i (table.size() );
+    uint i( table.size() );
 
-    while( i <= root_nbr )
+    while( i < root_nbr )
     {
         const Real root_i( get_root( i ) );
         table.push_back( p_exp_den_i(t, root_i, gsl_pow_2( root_i ) ) );
+        i++;
     }
 }
 
 
-/* Function for GFL rootfinder of drawR. */
-Real GreensFunction1DAbsSinkAbs::drawR_f(Real rr, void *p)
-{
-    struct drawR_params *params = (struct drawR_params *)p;
-    return params->gf->p_int_r(rr, params->t, params->table) - params->rnd;
-}
-
-
 //Integrated Greens function for rr part of [-Ll, 0]
 Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint i, 
                                                     Real const& rr,
@@ -906,6 +923,14 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint i,
 }
 
 
+/* Function for GFL rootfinder of drawR. */
+Real GreensFunction1DAbsSinkAbs::drawR_f(Real r, void *p)
+{
+    struct drawR_params *params = (struct drawR_params *)p;
+    return params->gf->p_int_r_table(r, params->t, params->table) - params->rnd;
+}
+
+
 Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd <= 1.0 );
@@ -914,7 +939,7 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     const Real D( getD() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
-    const Real rsink( getrsink() );
+    const Real r0( getr0() );
     const Real L( Lr + Ll );
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
@@ -931,17 +956,16 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
 
     if ( rnd <= EPSILON )
     {
-        return -Ll;        
+        return getsigma();        
     }
 
     if( rnd >= ( 1 - EPSILON ) )
     {
-        return Lr;
+        return geta();
     }
 
     // the structure to store the numbers to calculate r.
-    RealVector table;
-    const Real S( p_survival(t, table) );
+    const Real S( p_survival( t ) );
 
     RealVector drawR_table;
     drawR_params parameters = { this, t, drawR_table, rnd * S };
@@ -955,14 +979,11 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
 
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-    Real rr( findRoot( F, solver, -Ll, Lr, EPSILON*L, EPSILON,
-                            "GreensFunction1DRadAbs::drawR" ) );
+    Real r( findRoot( F, solver, getsigma(), geta(), 
+                      EPSILON*L, EPSILON, "GreensFunction1AbsSinkAbs::drawR" ) );
 
     // Convert the position rr to 'world' coordinates and return it.
-    if( getr0() < rsink )
-        return rsink - rr;
-    else
-        return rsink + rr;
+    return r;
 }
 
 
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 3662edd4..742a69c9 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -63,6 +63,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	        Lr = rsink - sigma; 
 	        Ll = a - rsink;
 	    }
+
+        calculate_n_roots( 1 );
     }
 
     /* The constructor is overloaded and can be called with or without drift v
@@ -83,6 +85,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	        Lr = rsink - sigma; 
 	        Ll = a - rsink;
 	    }
+
+        calculate_n_roots( 1 );
     }
 
     ~GreensFunction1DAbsSinkAbs()
@@ -166,16 +170,17 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 
     /* Calculates the probability of finding the particle inside the 
        domain at time t -> the survival probability */
-    Real p_survival(Real t, RealVector& psurvTable) const;
+    Real p_survival(Real t) const;
 
     /* c.d.f. of the greensfunction with respect to position. */
-    Real p_int_r( Real const& rr, Real const& t, RealVector& table ) const;
+    Real p_int_r_table( Real const& r, Real const& t, RealVector& table ) const;
 
+    Real p_int_r(Real const& r, Real const& t) const;
 
     /* TODO: Private methods which are public for now - debugging */
 
     /* Calculates the total probability flux leaving the domain at time t. */
-    Real flux_tot(Real t, uint const& maxi) const;
+    Real flux_tot(Real t) const;
 
     /* Calculates the probability flux leaving the domain through the 
        sub-domain containing r0 via the absorbing boundary and the flux 
@@ -224,8 +229,9 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
         Real Lm_L;
         Real long_period;
         Real short_period;
-        uint last_long_root;
-        uint last_short_root;
+        Real last_long_root;
+        Real last_short_root;
+        bool last_was_long;
     };
 
 
@@ -274,7 +280,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     void calculate_n_roots( uint const& n ) const;
     
     /* Function returns two positions on the x-axis which straddle the next root. */
-    real_pair get_lower_and_upper( lower_upper_params& params ) const;
+    real_pair get_lower_and_upper() const;
 
     /* Function of which we need the roots. */
     static Real root_f(Real x, void *p);
@@ -284,6 +290,8 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 
 
     /* Function for calculating the survival probability. */
+    Real p_survival_table(Real t, RealVector& psurvTable) const;
+
     Real p_survival_i( uint i, Real const& t, RealVector const& table ) const;
 
     Real p_survival_table_i( Real const& root_i ) const;
@@ -330,7 +338,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     static Real drawT_f (Real t, void *p);
 
     /* Function for drawTime */
-    static Real drawR_f (Real t, void *p);
+    static Real drawR_f (Real r, void *p);
 
     
     /* Class variables */
diff --git a/greens_functions.cpp b/greens_functions.cpp
index ead267c2..c4d2c7ff 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -101,6 +101,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
         .def( "flux_leavea", &GreensFunction1DAbsSinkAbs::flux_leavea )
         .def( "flux_sink", &GreensFunction1DAbsSinkAbs::flux_sink )
         .def( "prob_r", &GreensFunction1DAbsSinkAbs::prob_r )
+        .def( "p_int_r", &GreensFunction1DAbsSinkAbs::p_int_r )
         .def( "p_survival", &GreensFunction1DAbsSinkAbs::p_survival )
         .def( "calcpcum", &GreensFunction1DAbsSinkAbs::calcpcum )
         .def( "dump", &GreensFunction1DAbsSinkAbs::dump )

From c268c4d44183faec57e5a99901e4f41ede4f889b Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Tue, 29 Nov 2011 13:53:14 +0100
Subject: [PATCH 0416/1541] Added comments & debugging functionalities.

---
 GreensFunction2DRadAbs.cpp | 131 +++++++++++++++++++++++++++++--------
 GreensFunction2DRadAbs.hpp |  18 +++--
 funcSum.cpp                |   8 +--
 greens_function_wrapper.py |   4 ++
 greens_functions.cpp       |   2 +
 samples/2d/2dtest.py       |   2 +-
 6 files changed, 122 insertions(+), 43 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 85d333c9..c6e9d8d1 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -115,6 +115,7 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const Real h( this->geth() );
 	const Real s_An( sigma * alpha );
 	const Real a_An( a * alpha );
+//	const Real h_s( h * sigma);
 
 	const double J0_s_An (gsl_sf_bessel_J0(s_An));
 	const double J1_s_An (gsl_sf_bessel_J1(s_An));
@@ -124,6 +125,12 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
 	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));	
 
+//  const double rho1 ( ( (h_s * J0_s_An) + (s_An * J1_s_An) ) * Y0_a_An );
+//	const double rho2 ( ( (h_s * Y0_s_An) + (s_An * Y1_s_An) ) * J0_a_An );
+//	return (rho1 - rho2); 
+//
+//  Sigma can be divided out, roots will remain same:
+
 	const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
 	const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
 	return rho1 - rho2;
@@ -155,21 +162,27 @@ const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 	const Real sigma( getSigma() );
 	const Real h( this->geth() );
 	const Real s_An( sigma * alpha );
-	const Real a_An( a * alpha );
-	const Real realn( static_cast<Real>( n ) );
+	const Real a_An( a * alpha );	
+    const Real realn( static_cast<Real>( n ) );
 
-	const double Jn_s_An  (gsl_sf_bessel_Jn(n, s_An));
-	const double Jn1_s_An (gsl_sf_bessel_Jn(n+1, s_An));
-	const double Jn_a_An  (gsl_sf_bessel_Jn(n, a_An));
+	const double Jn_s_An (gsl_sf_bessel_Jn(n,s_An));
+	const double Jn1_s_An (gsl_sf_bessel_Jn(n+1,s_An));
+	const double Jn_a_An (gsl_sf_bessel_Jn(n,a_An));
 
-	const double Yn_s_An  (gsl_sf_bessel_Yn(n, s_An));
-	const double Yn1_s_An (gsl_sf_bessel_Yn(n+1, s_An));
-	const double Yn_a_An  (gsl_sf_bessel_Yn(n, a_An));
+	const double Yn_s_An (gsl_sf_bessel_Yn(n,s_An));
+	const double Yn1_s_An (gsl_sf_bessel_Yn(n+1,s_An));
+	const double Yn_a_An (gsl_sf_bessel_Yn(n,a_An));
 
-	const double rho1 ( ( (h*sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
+    const double rho1 ( ( (h*sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
 	const double rho2 ( ( (h*sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
 	return (rho1 - rho2); 
-}
+
+//  Or..? -:	
+//  const double rho1 ( ( ((h*sigma-realn) * Jn_s_An) + (s_An * Jn1_s_An) ) * Yn_a_An );
+//	const double rho2 ( ( ((h*sigma-realn) * Yn_s_An) + (s_An * Yn1_s_An) ) * Jn_a_An );
+//	return (rho1 - rho2); 		
+       
+} 
 
 // Simply a wrapper for f_alpha().
 const Real 
@@ -409,6 +422,7 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
     // Different for n=0 because this results in a simpler function.
     //      (Note: This code could be optimized by duplicating all involved  
     // functions and removing this if-statement. 
+
     if (n == 0) {
         f_low  = f_alpha0(low);	
         f_high = f_alpha0(high);
@@ -419,7 +433,7 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
 
     // Continue shifting the search interval until a sign change is detected.
     while( f_low * f_high > 0 )		
-    {					  
+    {	      				  
         low =  high;			
         f_low = f_high;			
 
@@ -597,6 +611,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                                              RealVector::size_type i // ith root
                                            ) const 
 {
+    const Real sigma(getSigma());
     Real current_root_, low, high;   
     
     // # "Administration"
@@ -1253,10 +1268,12 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 		p_m_abs = fabs( p_m );					// take the absolute value
         }
 	while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
+
 	// truncate when converged enough.
 	// if the current term is smaller than threshold
 	// AND the previous term is also smaller than threshold
 	// AND the current term is smaller than the previous
+		
 }
 
 // This method calculates the constants for the drawTheta method when the particle is at the boundary
@@ -1374,11 +1391,11 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
             p_m_prev_abs = p_m_abs;					// store the previous term
             const Real p_m( this->dp_m_at_a( m, t ) / p_0 );	// get the next term
 
-            // DEBUG 
-            if (p_m_abs == 0) {
-                std::cerr << "Zero valued term found, but convergence is:" <<
-                    p_mTable[p_mTable.size()-1-1]/p_mTable[p_mTable.size()-2-1];
-            }
+            // DEBUG (something to check in the future?)
+            // if (p_m_abs == 0) {
+            //    std::cerr << "Zero valued term found, but convergence is:" <<
+            //        p_mTable[p_mTable.size()-1-1]/p_mTable[p_mTable.size()-2-1];
+            // }
             // END DEBUG
 
             if( ! std::isfinite( p_m ) )			// if the calculated value is not valid->exit
@@ -1390,13 +1407,12 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
 
             p_mTable.push_back( p_m );                              // put the result in the table
             p_m_abs = fabs( p_m );                                  // take the absolute value
-    }
+    }            
     while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
     // truncate when converged enough.
     // if the current term is smaller than threshold
     // AND the previous term is also smaller than threshold
     // AND the current term is smaller than the previous
-
 }
 
 // This calculates the m-th term of the summation for the drawTheta calculation
@@ -1448,10 +1464,10 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 					   const Real r, 
 					   const Real t ) const
 {
-	const Real sigma( this->getSigma() );
-	const Real a( this->geta() );
-	const Real D( this->getD() );
-    	const Real r0( this->getr0() );
+    const Real sigma( this->getSigma() );
+    const Real a( this->geta() );
+    const Real D( this->getD() );
+    const Real r0( this->getr0() );
 
 	// input parameter range checks.
 	THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
@@ -1482,15 +1498,21 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 	}
 
 	// preparing the function
-	ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 };	// r, r0, t are not required
+	
+	// ip_theta_params is a struct.
+	ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 };	// r, r0, t are not required	    
+	                                                        // 0.5 is not even used
+    // F is a struct of type "gsl_function" that contains a function pointer
+	// and the required parameters.
 	gsl_function F = 
 	{
-	    reinterpret_cast<typeof(F.function)>( &ip_theta_F ),     
+	    reinterpret_cast<typeof(F.function)>( &ip_theta_F ), // ip_theta_F is 
+	                                                    // theta pdf function.
 	    &params 
         // reinterpret_cast converts any pointer type to any other pointer type.
         // reinterpret_cast<new_type> variable
-	};
-
+	}; 
+	    
 	// finding the root
 	const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
 	gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
@@ -1506,6 +1528,7 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 // debug
 //
 
+// Debug functionality
 std::string GreensFunction2DRadAbs::dump() const
 {
     std::ostringstream ss;
@@ -1516,3 +1539,59 @@ std::string GreensFunction2DRadAbs::dump() const
 	", h = " << this->geth() << std::endl;
     return ss.str();
 }    
+
+// Debug functionality
+// Directly outputs probability distribution function value of leaving angle
+// for given theta, r and t.
+Real 
+GreensFunction2DRadAbs::givePDF( const Real theta,
+					   const Real r, 
+					   const Real t ) const
+{
+    const Real sigma( this->getSigma() );
+    const Real a( this->geta() );
+    const Real D( this->getD() );
+    const Real r0( this->getr0() );
+
+	// input parameter range checks.
+	THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
+	THROW_UNLESS( std::invalid_argument, sigma <= r && r <= a);
+	THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
+	// making the tables with constants
+	RealVector p_mTable;			// a table with constants to make calculations much faster
+	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
+	{
+		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
+	}
+	else
+	{
+		makep_mTable( p_mTable, r, t );	// making the table of constants for the regular case
+	}
+
+    // Return the pdf
+  	ip_theta_params params = { this, r, t, p_mTable, 0.0 };	// r, r0, t are not required	    
+    Real PDF (ip_theta_F( theta, &params ));
+    return PDF;
+	
+}
+
+// It is used by the drawTheta method
+// It uses the p_nTable for it to speed things up
+/*
+const Real 
+GreensFunction2DRadAbs::debug_ip_theta_table( const Real theta) const
+{
+    const RealVector& p_nTable( params->p_nTable );	// table with useful constants
+    
+    const unsigned int maxm( p_nTable.size()-1 );	// get the length of the sum
+							// it is shifted one because the first entry should
+							// be used (m=0)
+
+    const Real p( funcSum_all( boost::bind( &GreensFunction2DRadAbs::ip_theta_n,
+                                             this,
+                                             _1, theta, p_nTable ),
+                                maxm ) );
+    return p;
+}
+*/
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 398c5154..f2e7ea74 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -43,8 +43,9 @@ class GreensFunction2DRadAbs
     static const Real T_TYPICAL = 1E-5; // typical time scale
     static const Real EPSILON = 1E-12;  // relative numeric error
 
+    // DEFAULT = 30
     static const unsigned int MAX_ORDER = 30;		// The maximum number of m 
-                                                    // terms
+                                                    // terms 
     static const unsigned int MAX_ALPHA_SEQ = 2000;	// The maximum number of n 
                                                     // terms
     
@@ -56,7 +57,7 @@ class GreensFunction2DRadAbs
     // Left boundary of 1st search interval 1st root
     static const Real SCAN_START = 0.001;     
     // Length of the scanning interval relative to estimated interval
-    static const Real FRACTION_SCAN_INTERVAL = .5;    
+    static const Real FRACTION_SCAN_INTERVAL = .5;
     
     // Other paramters
     // After CONVERGENCE_ASSUMED subsequent roots that lay within +/- 
@@ -110,8 +111,7 @@ class GreensFunction2DRadAbs
     virtual Real drawTheta( const Real rnd,
 			  const Real r, 
 			  const Real t ) const;
-    
-    
+      
     const Real f_alpha0( const Real alpha ) const;
   
     const Real f_alpha( const Real alpha, const Integer n ) const;
@@ -145,12 +145,6 @@ class GreensFunction2DRadAbs
 
     std::string dump() const;
 
-//    const Real alphaOffset( const unsigned int n ) const; // TODO Really can be thrown away?
-
-//    const Real alpha0_i( const Real previous ) const;
-
-//    const Real alpha_i( const Real offset, const Integer n ) const;
-
                                                           
     const void GiveRootInterval(  Real& low,          
                                   Real& high,         
@@ -195,6 +189,10 @@ class GreensFunction2DRadAbs
 
 //    const Real getAlpha0( const RealVector::size_type i ) const;
 
+    virtual Real givePDF( const Real theta,
+					   const Real r, 
+					   const Real t ) const;    
+
 protected:
 
     void clearAlphaTable() const;
diff --git a/funcSum.cpp b/funcSum.cpp
index f39595cc..76981b10 100644
--- a/funcSum.cpp
+++ b/funcSum.cpp
@@ -10,10 +10,6 @@
 #include "Logger.hpp"
 #include "funcSum.hpp"
 
-#include <iostream> // debug REMOVEME
-#include <stdexcept> // debug REMOVEME
-#include <sstream> // debug REMOVEME
-
 typedef std::vector<Real> RealVector;
 
 static Logger& _log(Logger::get_logger("funcSum"));
@@ -108,7 +104,8 @@ funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
 // If that's impossible, it's a compile error.
 // (From: http://stackoverflow.com/questions/527413/how-boostfunction-and-boostbind-work)
 {
-    const unsigned int CONVERGENCE_CHECK(4);
+    // DEFAULT = 4
+    const unsigned int CONVERGENCE_CHECK(4);    
 
     Real sum(0.0);
     RealVector pTable;
@@ -116,7 +113,6 @@ funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
     const Real p_0(f(0));
     if (p_0 == 0.0)
     {
-//        std::clog << "[[p_0(f(0))=0]]"; // DEBUG *REMOVEME*
         return 0.0;
     }
 
diff --git a/greens_function_wrapper.py b/greens_function_wrapper.py
index b975170d..bc2ec2e9 100644
--- a/greens_function_wrapper.py
+++ b/greens_function_wrapper.py
@@ -57,6 +57,10 @@ def draw_theta_wrapper(gf, r, dt):
     """Draw theta for the inter-particle vector.
 
     """
+    # We're interested in value between [-pi,pi], but this problem is symmetric: 
+    # the cumulative pdf is odd. Thus drawTheta() returns a value between 
+    # [0,pi], which is then with a 50% probability made negative or kept 
+    # positive.
     rnd = myrandom.uniform()
 
     if __debug__:
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 2586ba0d..e9e8f0c7 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -119,6 +119,8 @@ BOOST_PYTHON_MODULE( _greens_functions )
 	.def( "leaves", &GreensFunction2DRadAbs::leaves )
 	.def( "leavea", &GreensFunction2DRadAbs::leavea )
     .def( "dump", &GreensFunction2DRadAbs::dump )
+    // DEBUG: TODO REMOVE?
+    .def( "givePDF", &GreensFunction2DRadAbs::givePDF )    
 	;
     
     class_<GreensFunction3DSym>("GreensFunction3DSym", init<Real>())
diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
index 59b77441..c4735a53 100755
--- a/samples/2d/2dtest.py
+++ b/samples/2d/2dtest.py
@@ -48,7 +48,7 @@
 logging = False
 sigma = 1e-9        # Diameter particle
 D = 1e-13           # Diffusion constant
-N = 10000000        # Number of steps simulation will last
+N = 200000            # Number of steps simulation will last
 world_size = 1e-6   # Lengths of simulation box
 NParticles = 50     # Number of particles in the simulation
 k = 2e-14          # Reaction constant

From a6a0043c0e4df686f07d04ba29c6a6a592812939 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 29 Nov 2011 16:40:31 +0100
Subject: [PATCH 0417/1541] Optimized drawTime and drawR with convergence
 guess. Added rootList and table functions for drawR and drawT. Fixed
 indentation. Compiles.

---
 GreensFunction1DAbsAbs.cpp | 570 +++++++++++++++++++--------------
 GreensFunction1DAbsAbs.hpp |  26 +-
 GreensFunction1DRadAbs.cpp | 626 +++++++++++++++++++++++--------------
 GreensFunction1DRadAbs.hpp | 103 ++++--
 4 files changed, 818 insertions(+), 507 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 7e36a733..0fa4bfe0 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -20,6 +20,41 @@
 #include "Defs.hpp"
 
 
+/* returns a guess for the number of terms needed for 
+   the greensfunction to converge at time t */
+uint GreensFunction1DAbsAbs::guess_maxi(Real const& t) const
+{
+    const uint safety(2);
+
+    if (t >= INFINITY)
+    {
+        return safety;
+    }
+
+    const Real D( getD() );
+    const Real L( fabs( geta() - getsigma() ) );
+
+    const Real root0( M_PI );
+    const Real Dt(D * t);
+
+    const Real thr(exp(- Dt * root0 * root0) * EPSILON * 1e-1);
+
+    if (thr <= 0.0)
+    {
+        return MAX_TERMS;
+    }
+
+    const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
+
+    const uint maxi(std::max( safety + 
+                              static_cast<uint>
+                              (max_root * L  / M_PI),
+                              MIN_TERMS )
+                    );
+
+    return std::min(maxi, MAX_TERMS);
+}
+
 // Calculates the probability of finding the particle inside the domain at 
 // time t
 Real
@@ -58,54 +93,53 @@ GreensFunction1DAbsAbs::p_survival (Real t) const
 
 
     // Sum
-    Real n=1;
+    Real n = 1;
     // different calculations depending on whether v=0 or not
     if(v==0.0)	// case without drift (v==0); in this case the summation is simpler, so do the complicated caluclation only if necessary
     {
       do
       {
-	  if (n >= MAX_TERMS )
-	  {
-	      std::cerr << "Too many terms for GF1DAbs::p_survival. N: " << n << std::endl;
-	      break;
-	  }
+          if (n >= MAX_TERMS )
+          {
+              std::cerr << "Too many terms for GF1DAbs::p_survival. N: " << n << std::endl;
+              break;
+          }
 	  
-	  prev_term = term;
-	  nPI = (Real)n*M_PI;
-	  term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * (1.0 - cos(nPI)) / nPI;
-	  sum += term;
-	  n++;
+          prev_term = term;
+          nPI = (Real)n*M_PI;
+          term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * (1.0 - cos(nPI)) / nPI;
+          sum += term;
+          n++;
       }
       // Is 1 a good measure or will this fail at some point?
       while (	fabs(term/sum) > EPSILON*1.0 ||
-		fabs(prev_term/sum) > EPSILON*1.0 ||
-		n < MIN_TERMS );
+                fabs(prev_term/sum) > EPSILON*1.0 ||
+                n < MIN_TERMS );
 
-      sum = 2.0*sum;	// This is a prefactor of every term, so do only one multiplication here
+      sum = 2.0 * sum;	// This is a prefactor of every term, so do only one multiplication here
     }
     else	// case with drift (v<>0)
     {
-      do
-      {
-	  if (n >= MAX_TERMS )
-	  {
-	      std::cerr << "Too many terms for p_survival. N: " << n << std::endl;
-	      break;
-	  }
+        do
+        {
+            if (n >= MAX_TERMS )
+            {
+                std::cerr << "Too many terms for p_survival. N: " << n << std::endl;
+                break;
+            }
 	  
-	  nPI = (Real)n*M_PI;
-	  prev_term = term;
-	  term = exp(nPI*nPI*expo) * (exp(sigmav2D) - cos(nPI)*exp(av2D)) * nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L);
-	  sum += term;
-	  n++;
-      }
-      // TODO: Is 1 a good measure or will this fail at some point?
-      while (	fabs(term/sum) > EPSILON*1.0 ||
-		fabs(prev_term/sum) > EPSILON*1.0 ||
-		n < MIN_TERMS );
+            nPI = (Real)n*M_PI;
+            prev_term = term;
+            term = exp(nPI*nPI*expo) * (exp(sigmav2D) - cos(nPI)*exp(av2D)) * nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L);
+            sum += term;
+            n++;
+        }
+        // TODO: Is 1 a good measure or will this fail at some point?
+        while (	fabs(term/sum) > EPSILON*1.0 ||
+                fabs(prev_term/sum) > EPSILON*1.0 ||
+                n < MIN_TERMS );
       
-      sum = 2.0*exp(vexpo) * sum;	// prefactor containing the drift
-
+        sum = 2.0 * exp(vexpo) * sum;	// prefactor containing the drift
     }
 
     return sum;
@@ -130,18 +164,18 @@ GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     if (t == 0 || D == 0)
     {
 	// the probability density function is a delta function
-	if (r == r0)
-	{
-	    return INFINITY;
-	}
-	else
-	{      
-	    return 0.0;
-	}
+        if (r == r0)
+        {
+            return INFINITY;
+        }
+        else
+        {      
+            return 0.0;
+        }
     }
     else if ( fabs(r-sigma) < L*EPSILON || fabs(a-r) < L*EPSILON || L < 0.0 )
     {
-	return 0.0;
+        return 0.0;
     }
 
     // Set values that are constant in this calculation
@@ -155,25 +189,25 @@ GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     Real sum = 0, term = 0, prev_term = 0;
 
     // Sum
-    int n=1;
+    uint n = 1;
     do
     {
-	if (n >= MAX_TERMS )
-	{
-	    std::cerr << "Too many terms for GF1DAbs::prob_r. N: " << n << std::endl;
-	    break;
-	}
+        if (n >= MAX_TERMS )
+        {
+            std::cerr << "Too many terms for GF1DAbs::prob_r. N: " << n << std::endl;
+            break;
+        }
 
-	prev_term = term;
+        prev_term = term;
 
-	nPI = n*M_PI;
-	term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * sin(nPI*rs_L);
-	sum += term;
-	n++;
+        nPI = n*M_PI;
+        term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * sin(nPI*rs_L);
+        sum += term;
+        n++;
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
-	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	n <= MIN_TERMS);
+           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+           n <= MIN_TERMS);
 
     return 2.0/L * exp(vexpo) * sum;
 }
@@ -201,14 +235,14 @@ GreensFunction1DAbsAbs::leaves(Real t) const
 
     if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
     {
-	// The flux of a zero domain is INFINITY. Also if the particle 
-	// started on the left boundary (leaking out immediately).
-	return INFINITY;
+        // The flux of a zero domain is INFINITY. Also if the particle 
+        // started on the left boundary (leaking out immediately).
+        return INFINITY;
     }
     else if ( t < EPSILON*this->t_scale )
     {
-	// if t=0.0 the flux must be zero
-	return 0.0;
+        // if t=0.0 the flux must be zero
+        return 0.0;
     }
 
 
@@ -219,24 +253,24 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     const Real r0s_L((r0-sigma)/L);
     const Real vexpo(-v*v*t/4.0/D - v*(r0-sigma)/2.0/D);
     
-    Real n=1;
+    Real n = 1;
     do
     {
-	if (n >= MAX_TERMS )
-	{
-	    std::cerr << "Too many terms for GF1DAbs::leaves. N: " << n << std::endl;
-	    break;
-	}
+        if (n >= MAX_TERMS )
+        {
+            std::cerr << "Too many terms for GF1DAbs::leaves. N: " << n << std::endl;
+            break;
+        }
 
-	nPI = n*M_PI;
-	prev_term = term;
-	term = nPI * exp(nPI*nPI*expo) * sin(nPI*r0s_L);
-	sum += term;
-	n++;
+        nPI = n*M_PI;
+        prev_term = term;
+        term = nPI * exp(nPI*nPI*expo) * sin(nPI*r0s_L);
+        sum += term;
+        n++;
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
-	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	n < MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+           n < MIN_TERMS );
 
     return 2.0*D_L_sq * exp(vexpo) * sum;
 }
@@ -256,14 +290,14 @@ GreensFunction1DAbsAbs::leavea(Real t) const
 
     if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
     {
-	// The flux of a zero domain is INFINITY. Also if the particle 
-	// started on the right boundary (leaking out immediately).
-	return INFINITY;
+        // The flux of a zero domain is INFINITY. Also if the particle 
+        // started on the right boundary (leaking out immediately).
+        return INFINITY;
     }
     else if ( t < EPSILON*this->t_scale )
     {
-	// if t=0.0 the flux must be zero
-	return 0.0;
+        // if t=0.0 the flux must be zero
+        return 0.0;
     }
 
 
@@ -277,23 +311,23 @@ GreensFunction1DAbsAbs::leavea(Real t) const
     Real n=1;
     do
      {
-       if (n >= MAX_TERMS )
-       {
-	 std::cerr << "Too many terms for GF1DAbs::leavea. N: " << n << std::endl;
-	 break;
-       }
+         if (n >= MAX_TERMS )
+         {
+             std::cerr << "Too many terms for GF1DAbs::leavea. N: " << n << std::endl;
+             break;
+         }
        
-       nPI = n*M_PI;
-       prev_term = term;
-       term = nPI * exp(nPI*nPI*expo) * cos(nPI) * sin(nPI*r0s_L);
-       sum += term;
-       n++;
+         nPI = n*M_PI;
+         prev_term = term;
+         term = nPI * exp(nPI*nPI*expo) * cos(nPI) * sin(nPI*r0s_L);
+         sum += term;
+         n++;
      }
      while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
-	    fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	    n < MIN_TERMS );
+            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+            n < MIN_TERMS );
      
-     return -2.0*D_L_sq * exp(vexpo) * sum;
+     return - 2.0 * D_L_sq * exp(vexpo) * sum;
 }
 
 // This draws an eventtype of time t based on the flux through the left (z=sigma) 
@@ -315,13 +349,13 @@ GreensFunction1DAbsAbs::drawEventType( Real rnd, Real t ) const
     // For particles at the boundaries
     if ( fabs(a-r0) < EPSILON*L )
     {
-	// if the particle started on the right boundary
-	return IV_ESCAPE;
+        // if the particle started on the right boundary
+        return IV_ESCAPE;
     }
     else if ( fabs(r0-sigma) < EPSILON*L )
     {
-	// if the particle started on the left boundary
-	return IV_REACTION;
+        // if the particle started on the left boundary
+        return IV_REACTION;
     }
 
     const Real leaves_s (this->leaves(t));
@@ -331,20 +365,109 @@ GreensFunction1DAbsAbs::drawEventType( Real rnd, Real t ) const
 
     if (rnd > fluxratio )
     {
-    return IV_ESCAPE; //escape through a.
+        return IV_ESCAPE; //escape through a.
     }
     else
     {
-	return IV_REACTION; //escape through sigma.
+        return IV_REACTION; //escape through sigma.
     }
 }
 
-// This is a help function that casts the drawT_params parameter structure into
-// the right form and calculates the survival probability from it (and returns it).
-// The routine drawTime uses this one to sample the next-event time from the
-// survival probability using a rootfinder from GSL.
-Real
-GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
+
+/* Returns i'th term of table or fills a table with 
+   i exp arguments for drawT. */
+Real GreensFunction1DAbsAbs::drawT_exponent_table( uint const& i, 
+                                                   RealVector& table) const
+{
+    uint n( table.size() );
+
+    if(i < n)
+        return table[i];
+    else
+    {
+        const Real L(this->geta() - this->getsigma());
+        const Real expo(-D/(L*L));
+        Real nPi;
+
+        if( v== 0)
+        {
+            while(n++ < i)
+            {
+                nPi = ((Real)(n+1)) * M_PI;
+                table.push_back( nPi * nPi * expo );
+            }
+        }
+        else
+        {
+            const Real vexpo_t(-v*v/4.0/D);
+
+            while(n++ < i)
+            {
+                nPi = ((Real)(n+1)) * M_PI;
+                table.push_back( nPi * nPi * expo + vexpo_t );
+            }
+        }
+
+        return table.back();
+    }
+}
+
+
+/* Returns i'th term of table or fills the table with 
+   i numerators for drawT. */
+Real GreensFunction1DAbsAbs::drawT_Xn_table( uint const& i, 
+                                             RealVector& table) const
+{
+    uint n( table.size() );
+
+    if(i < n)
+        return table[i];
+    else
+    {
+        Real nPI;
+
+        const Real a(this->geta());
+        const Real sigma(this->getsigma());
+        const Real L(this->geta() - this->getsigma());
+        const Real r0(this->getr0());
+        const Real D(this->getD());
+        const Real v(this->getv());
+    
+        const Real r0s_L((r0-sigma)/L);
+
+        if( v== 0)
+        {
+
+            while(n++ < i)
+            {
+                nPI = ((Real)(n+1))*M_PI;
+                table.push_back( sin( nPI * r0s_L ) 
+                                 * (1.0 - cos(nPI)) / nPI );
+            }
+        }
+        else
+        {
+            const Real sigmav2D(sigma*v/2.0/D);
+            const Real av2D(a*v/2.0/D);
+            const Real Lv2D(L*v/2.0/D);
+
+            while(n++ < i)
+            {
+                nPI = ((Real)(n+1))*M_PI;
+                table.push_back( (exp(sigmav2D) - cos(nPI)*exp(av2D)) * 
+                                 nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L) );
+            }
+        }
+        return table.back();
+    }
+}
+
+
+/* This is a help function that casts the drawT_params parameter structure into
+   the right form and calculates the survival probability from it (and returns it).
+   The routine drawTime uses this one to sample the next-event time from the
+   survival probability using a rootfinder from GSL.*/
+Real GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
 {   
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
@@ -352,30 +475,31 @@ GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
     Real sum = 0, term = 0, prev_term = 0;
     Real Xn, exponent, prefactor;
     // the maximum number of terms in the params table
-    int    terms = params->terms;
+    uint terms = params->terms;
     // the timescale used
-    Real   tscale = params->tscale;
+    Real tscale = params->tscale;
 
-    int n=0;
+    uint n = 0;
     do
     {
-	if ( n >= terms )
-	{
-	    std::cerr << "Too many terms needed for DrawTime. N: "
-	              << n << std::endl;
-	    break;
-	}
-	prev_term = term;
+        if ( n >= terms )
+        {
+            std::cerr << "Too many terms needed for DrawTime. N: "
+                      << n << std::endl;
+            break;
+        }
+        prev_term = term;
+
+        Xn = params->gf->drawT_Xn_table(n, params->Xn_table);
+        exponent = params->gf->drawT_exponent_table(n, params->exponent_table);
 
-	Xn = params->Xn[n];
-	exponent = params->exponent[n];
-	term = Xn * exp(exponent * t);
-	sum += term;
-	n++;
+        term = Xn * exp(exponent * t);
+        sum += term;
+        n++;
     }
     while (fabs(term/sum) > EPSILON*tscale ||
-	fabs(prev_term/sum) > EPSILON*tscale ||
-	n <= MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON*tscale ||
+           n < MIN_TERMS );
 
     prefactor = params->prefactor;
     
@@ -398,75 +522,58 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     const Real r0(this->getr0());
     const Real D(this->getD());
     const Real v(this->getv());
-    
+
     if (D == 0.0 )
     {
-	return INFINITY;
+        return INFINITY;
     }
     else if ( L < 0.0 || fabs(a-r0) < EPSILON*L || fabs(r0-sigma) > (1.0 - EPSILON)*L )
     {
-	// if the domain had zero size
-	return 0.0;
+        // if the domain had zero size
+        return 0.0;
     }
 
-    const Real expo(-D/(L*L));
-    const Real r0s_L((r0-sigma)/L);
-    // some abbreviations for terms appearing in the sums with drift<>0
-    const Real sigmav2D(sigma*v/2.0/D);
-    const Real av2D(a*v/2.0/D);
-    const Real Lv2D(L*v/2.0/D);
     // exponent of the prefactor present in case of v<>0; has to be split because it has a t-dep. and t-indep. part
-    const Real vexpo_t(-v*v/4.0/D);
     const Real vexpo_pref(-v*r0/2.0/D);
-
-    // the structure to store the numbers to calculate the numbers for 1-S
-    struct drawT_params parameters;
-    Real Xn, exponent, prefactor;
+    Real prefactor;
     
-    Real nPI;
+    // Find a good interval to determine the first passage time in
+    const Real dist( std::min(r0-sigma, a-r0) );
+
+    // construct a guess: MSD = sqrt (2*d*D*t)
+    Real t_guess( dist * dist / ( 2.0 * D ) );
+
+    // A different guess has to be made in case of nonzero drift to account for the displacement due to it
+    // When drifting towards the closest boundary...
+    if( ( r0-sigma >= L/2.0 && v > 0.0 ) || 
+        ( r0-sigma <= L/2.0 && v < 0.0 ) )	
+        t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
+
+    // When drifting away from the closest boundary...
+    if( ( r0-sigma  < L/2.0 && v > 0.0 ) || 
+        ( r0-sigma  > L/2.0 && v < 0.0 ) )	
+        t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));
+      
+    t_guess *= .1;
+
+    /* Guess number of terms needed for convergence */
+    const uint maxi( guess_maxi( t_guess ) );
     
-    // Construct the coefficients and the terms in the exponent and put them 
-    // into the params structure
-    int n = 0;
-    // a simpler sum has to be computed for the case w/o drift, so distinguish here
-    if(v==0)
-    {
-      do
-      {
-	  nPI = ((Real)(n+1))*M_PI;	// why n+1 : this loop starts at n=0 (1st index of the arrays), while the sum starts at n=1 !
-	  Xn = sin(nPI*r0s_L) * (1.0 - cos(nPI)) / nPI; 
-	  exponent = nPI*nPI*expo;
-	  
-	  // store the coefficients in the structure
-	  parameters.Xn[n] = Xn;	
-	  // also store the values for the exponent
-	  parameters.exponent[n]=exponent;
-	  n++;
-      }
-      // TODO: Modify this later to include a cutoff when changes are small
-      while (n<MAX_TERMS);
-    }
-    else	// case with drift<>0
-    {
-     do
-      {
-	  nPI = ((Real)(n+1))*M_PI;	// why n+1 : this loop starts at n=0 (1st index of the arrays), while the sum starts at n=1 !
-	  Xn = (exp(sigmav2D) - cos(nPI)*exp(av2D)) * nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L);
-	  exponent = nPI*nPI*expo + vexpo_t;
-	  
-	  // store the coefficients in the structure
-	  parameters.Xn[n] = Xn;	
-	  // also store the values for the exponent
-	  parameters.exponent[n]=exponent;
-	  n++;
-      }
-       // TODO: Modify this later to include a cutoff when changes are small
-      while (n<MAX_TERMS);
-    }
+    /* Build tables of factor not depending on t */
+    RealVector exponent_table;
+    RealVector Xn_table;
+    drawT_exponent_table( maxi, exponent_table );
+    drawT_Xn_table( maxi, Xn_table );
+
+    /* Set params structure. */
+    struct drawT_params parameters = {this, exponent_table, Xn_table};
 
     // the prefactor of the sum is also different in case of drift<>0 :
-    if(v == 0)	prefactor = 2.0;
-    else	prefactor = 2.0*exp(vexpo_pref);
+    if(v == 0)	
+        prefactor = 2.0;
+    else	
+        prefactor = 2.0*exp(vexpo_pref);
+
     parameters.prefactor = prefactor;
     
     parameters.rnd = rnd;
@@ -477,18 +584,6 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     F.function = &drawT_f;
     F.params = &parameters;
 
-    // Find a good interval to determine the first passage time in
-    const Real dist( std::min(r0-sigma, a-r0) );
-
-    // construct a guess: MSD = sqrt (2*d*D*t)
-    Real t_guess( dist * dist / ( 2.0 * D ) );
-    // A different guess has to be made in case of nonzero drift to account for the displacement due to it
-    // When drifting towards the closest boundary...
-    if( ( r0-sigma >= L/2.0 && v > 0.0 ) || ( r0-sigma <= L/2.0 && v < 0.0 ) )	t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
-    // When drifting away from the closest boundary...
-    if( ( r0-sigma  < L/2.0 && v > 0.0 ) || ( r0-sigma  > L/2.0 && v < 0.0 ) )	t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));
-    
-    
     Real value( GSL_FN_EVAL( &F, t_guess ) );
     Real low( t_guess );
     Real high( t_guess );
@@ -506,39 +601,39 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
 
 	    if( fabs( high ) >= t_guess * 1e6 )
 	    {
-		std::cerr << "Couldn't adjust high. F(" << high << ") = "
-		          << value << std::endl;
-		throw std::exception();
+            std::cerr << "Couldn't adjust high. F(" << high << ") = "
+                      << value << std::endl;
+            throw std::exception();
 	    }
 	}
 	while ( value <= 0.0 );
     }
     else
     {
-	// if the guess was too high initialize with 2 so the test 
-	// below survives the first iteration
-	Real value_prev( 2.0 );
-	do
-	{
-	    if( fabs( low ) <= t_guess * 1.0e-6 ||
-	        fabs(value-value_prev) < EPSILON*this->t_scale )
-	    {
-		std::cerr << "GF1DAbs::drawTime Couldn't adjust low. F(" << low << ") = "
-		          << value << " t_guess: " << t_guess << " diff: "
-		          << (value - value_prev) << " value: " << value
-		          << " value_prev: " << value_prev << std::endl;
-		return low;
-	    }
-
-	    value_prev = value;
-	    // keep decreasing the lower boundary until the 
-	    // function straddles
-	    low *= 0.1;
-	    // get the accompanying value
-	    value = GSL_FN_EVAL( &F, low );
-
-	}
-	while ( value >= 0.0 );
+        // if the guess was too high initialize with 2 so the test 
+        // below survives the first iteration
+        Real value_prev( 2.0 );
+        do
+        {
+            if( fabs( low ) <= t_guess * 1.0e-6 ||
+                fabs(value-value_prev) < EPSILON*this->t_scale )
+            {
+                std::cerr << "GF1DAbs::drawTime Couldn't adjust low. F(" << low << ") = "
+                          << value << " t_guess: " << t_guess << " diff: "
+                          << (value - value_prev) << " value: " << value
+                          << " value_prev: " << value_prev << std::endl;
+                return low;
+            }
+
+            value_prev = value;
+            // keep decreasing the lower boundary until the 
+            // function straddles
+            low *= 0.1;
+            // get the accompanying value
+            value = GSL_FN_EVAL( &F, low );
+            
+        }
+        while ( value >= 0.0 );
     }
 
     // find the intersection on the y-axis between the random number and 
@@ -573,36 +668,41 @@ GreensFunction1DAbsAbs::drawR_f (Real r, drawR_params const* params)
 {   
     Real sum = 0, term = 0, prev_term = 0;
     Real S_Cn_An, n_L;
-    int    terms = params->terms;
+    uint terms = params->terms;
     Real sigma = params->H[0];
     Real v2D = params->H[1];	// =v/(2D)
 
-    int n=0;
+    uint n = 0;
     do
     {
-	if (n >= terms )
-	{
-	    std::cerr << "Too many terms for DrawR. N: " << n << std::endl;
-	    break;
-	}
-	prev_term = term;
+        if (n >= terms )
+        {
+            std::cerr << "Too many terms for DrawR. N: " << n << std::endl;
+            break;
+        }
+        prev_term = term;
+        
+        S_Cn_An = params->S_Cn_An[n];
+        n_L = params->n_L[n];	// this is n*pi/L
+        if(v2D==0.0)	
+            term = S_Cn_An * ( 1.0 - cos(n_L*(r-sigma)) );
+        else		
+            term = S_Cn_An * ( exp(v2D*sigma) + exp(v2D*r)*
+                               ( v2D/n_L*sin(n_L*(r-sigma)) 
+                                 - cos(n_L*(r-sigma)) ));
 
-	S_Cn_An = params->S_Cn_An[n];
-	n_L = params->n_L[n];	// this is n*pi/L
-	if(v2D==0.0)	term = S_Cn_An * ( 1.0 - cos(n_L*(r-sigma)) );
-	else		term = S_Cn_An * ( exp(v2D*sigma) + exp(v2D*r)*( v2D/n_L*sin(n_L*(r-sigma)) - cos(n_L*(r-sigma)) ));
 	  // S_Cn_An contains all expon. prefactors, the 1/S(t) term and all parts
 	  // of the terms that do not depend on r.
 	  //
 	  // In case of zero drift the terms become S_An_Cn * ( 1 - cos(nPi/L*(r-sigma)) )
 	  // as it should be. The if-statement is only to avoid calculation costs.
 
-	sum += term;
-	n++;
+        sum += term;
+        n++;
     }
     while (fabs(term/sum) > EPSILON ||
-	fabs(prev_term/sum) > EPSILON ||
-	n <= MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON ||
+           n < MIN_TERMS );
 
     // find the intersection with the random number
     return sum - params->rnd;
@@ -647,6 +747,8 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     F.params = &parameters;
     Real psurv;
 
+    const uint maxi( guess_maxi( t ) );
+
     if ((r0 + vt - sigma) <= thresholdDistance || (a - r0 - vt) <= thresholdDistance)
     {
         psurv = p_survival(t);
@@ -670,7 +772,7 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
 
         // Construct the coefficients and the terms in the exponent and put them 
         // in the params structure
-        int n=0;
+        uint n = 0;
         do
         {
 	        nPI = ((Real)(n+1))*M_PI;	    // note: summation starting with n=1, indexing with n=0, therefore we need n+1 here
@@ -688,7 +790,7 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
 	        parameters.n_L[n]    = nPI/L;
 	        n++;
         }
-        while (n<MAX_TERMS);
+        while (n<maxi);
     
         F.function = reinterpret_cast<typeof(F.function)>(&drawR_f);
     }
@@ -711,7 +813,7 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     // store the random number for the probability
     parameters.rnd = rnd ;
     // store the number of terms used
-    parameters.terms = MAX_TERMS;
+    parameters.terms = maxi;
    
 
     // find the intersection on the y-axis between the random number and the function
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 652b162c..e1729029 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -21,6 +21,7 @@
 #include "findRoot.hpp"
 #include "Defs.hpp"
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
+#include "funcSum.hpp"
 
 #include "GreensFunction.hpp"
 #include "PairGreensFunction.hpp"	// needed to declare EventType
@@ -28,6 +29,10 @@
 
 class GreensFunction1DAbsAbs: public GreensFunction
 {
+public:
+    typedef std::vector<Real> RealVector;
+    typedef unsigned int uint;
+
 private:
     // This is a typical length scale of the system, may not be true!
     static const Real L_TYPICAL = 1E-8;
@@ -38,9 +43,9 @@ class GreensFunction1DAbsAbs: public GreensFunction
     //E3; Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms in the sum
-    static const int MAX_TERMS = 500;
+    static const uint MAX_TERMS = 500;
     // The minimum
-    static const int MIN_TERMS = 20;
+    static const uint MIN_TERMS = 20;
     // Cutoff distance: When H * sqrt(2Dt) < 1/2*L, use free greensfunction instead of absorbing.
     static const Real CUTOFF_H = 6.0;
 
@@ -167,29 +172,34 @@ class GreensFunction1DAbsAbs: public GreensFunction
 private:
     struct drawT_params
     {
-        // use 10 terms in the summation for now
-        Real exponent[MAX_TERMS];
-        Real Xn[MAX_TERMS];
+        GreensFunction1DAbsAbs const* gf;
+        RealVector& exponent_table;
+        RealVector& Xn_table;
         Real prefactor;
-        int    terms;
+        uint terms;
         Real tscale;
-        // random number
         Real rnd;
     };
 
     static double drawT_f (double t, void *p);
 
+    Real drawT_exponent_table( uint const& i, RealVector& table) const;
+
+    Real drawT_Xn_table( uint const& i, RealVector& table) const;
+
     struct drawR_params
     {
         Real S_Cn_An[MAX_TERMS];
         Real n_L[MAX_TERMS];
         // variables H: for additional terms appearing as multiplicative factors etc.
         Real H[5];
-        int terms;
+        uint terms;
         // random number
         Real rnd;
     };
 
+    uint guess_maxi(Real const& t ) const;
+
     static Real drawR_f (Real z, drawR_params const* params);
     static Real drawR_free_f (Real z, drawR_params const* params);
 
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 6fb0efba..66f17fe7 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -45,33 +45,24 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
     
 }
 
-// Calculates the roots of tan(x*a)=-x/h
-Real
-GreensFunction1DRadAbs::root_n(int n) const
+/* Fills the rootList with all the roots of tan(x*a)=-x/h up to n */
+void GreensFunction1DRadAbs::calculate_n_roots(uint const& n) const
 {
     const Real L( this->geta()-this->getsigma() );
     const Real h( (this->getk()+this->getv()/2.0) / this->getD() );
     // the drift v also comes into this constant, h=(k+v/2)/D
-    Real upper, lower;
+    Real upper, lower, root_i;
 
-    //No drift, and k = 0, use reflective solution.
-    if (h == 0.0)
-        return M_PI * ( n - 1./2 ) / L;
-    
+    uint i( rootList_size() );
 
-    if ( h*L < 1 )
-    {
-	// 1E-10 to make sure that he doesn't include the transition 
-	lower = (n-1)*M_PI + 1E-10;
-	// (asymptotic) from infinity to -infinity
-	upper =  n   *M_PI - 1E-10;
-    }
-    else
+    //No drift, and k = 0, use reflective solution.
+    if (h < EPSILON)
     {
-	lower = (n-1)*M_PI + M_PI_2 + 1E-10;
-	upper = n    *M_PI + M_PI_2 - 1E-10;
+        while(i++ < n)
+            ad_to_rootList( M_PI * ( n - 1./2 ) / L );
+        return;
     }
-
+    
     gsl_function F;
     struct tan_f_params params = { L, h };
      
@@ -80,21 +71,71 @@ GreensFunction1DRadAbs::root_n(int n) const
 
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
-
-    // make a new solver instance
-    // TODO: incl typecast?
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-    // get the root = run the rootsolver
-    const Real root( findRoot( F, solver, lower, upper, 1.0*EPSILON, EPSILON,
-                            "GreensFunction1DRadAbs::root_tan" ) );
+
+    /* Find all the roots up to the nth */
+    if ( h*L < 1 )
+    {
+        lower = i*M_PI + 1E-10;
+        upper = ( i + 1 ) * M_PI - 1E-10;
+    }
+    else
+    {
+        lower = i * M_PI + M_PI_2 + 1E-10;
+        upper = ( i + 1 ) * M_PI + M_PI_2 - 1E-10;
+    }
+
+    while(i++ < n)
+    {
+        root_i = findRoot( F, solver, lower, upper, 
+                           1.0*EPSILON, EPSILON, "GreensFunction1DRadAbs::root_tan" );
+
+        ad_to_rootList( root_i / L );
+
+        lower += M_PI;
+        upper += M_PI;
+    }
+
     gsl_root_fsolver_free( solver );
-    
-    return root/L;
-    // This rescaling is important, because the function tan_f is used to solve for
-    // tan(x)+x/h/L=0, whereas we actually need tan(x*L)+x/h=0, So if x solves the 
-    // subsidiary equation, x/L solves the original one.
 }
 
+
+/* returns a guess for the number of terms needed for 
+   the greensfunction to converge at time t */
+uint GreensFunction1DRadAbs::guess_maxi(Real const& t) const
+{
+    const uint safety(2);
+
+    if (t >= INFINITY)
+    {
+        return safety;
+    }
+
+    const Real D( getD() );
+    const Real L( fabs( geta() - getsigma() ) );
+
+    const Real root0( get_root( 0 ) );
+    const Real Dt(D * t);
+
+    const Real thr(exp(- Dt * root0 * root0) * EPSILON * 1e-1);
+
+    if (thr <= 0.0)
+    {
+        return MAX_TERMS;
+    }
+
+    const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
+
+    const uint maxi(std::max( safety + 
+                              static_cast<uint>
+                              (max_root * L  / M_PI),
+                              MIN_TERMS )
+                    );
+
+    return std::min(maxi, MAX_TERMS);
+}
+
+
 // This is the non-exponential factor in the Green's function sum, not
 // including the factor containing the explicit r-dependency (The latter
 // is given by the Bn's, see below).
@@ -169,30 +210,39 @@ GreensFunction1DRadAbs::p_survival (Real t) const
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
-	// if there was no time or no movement the particle was always
-	// in the domain
-	return 1.0;
+        // if there was no time or no movement the particle was always
+        // in the domain
+        return 1.0;
     }
 
 
     Real root_n;
     Real sum = 0, term = 0, term_prev = 0;
-    int n = 1;
+    uint n = 0;
+
+    const uint maxi( guess_maxi( t ) );
+    calculate_n_roots( maxi );
 
     if(h != 0.0)
     {
-
         do
         {
-	        root_n = this->root_n(n);
+            if ( n >= MAX_TERMS )
+            {
+                std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
+                          << n << std::endl;
+                break;
+            }
+
+	        root_n = this->get_root(n);
 	        term_prev = term;
     	    term = this->Cn(root_n, t) * this->An(root_n) * this->Bn(root_n);
 	        sum += term;
 	        n++;
         }
         while ( fabs(term/sum) > EPSILON  ||
-	    fabs(term_prev/sum) > EPSILON ||
-	    n <= MIN_TERMS);
+                fabs(term_prev/sum) > EPSILON ||
+                n < MIN_TERMS);
 
     }
     else
@@ -200,20 +250,28 @@ GreensFunction1DRadAbs::p_survival (Real t) const
 
         do
         {
-	        root_n = this->root_n(n);
+            if ( n >= MAX_TERMS )
+            {
+                std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
+                          << n << std::endl;
+                break;
+            }
+
+	        root_n = this->get_root(n);
 	        term_prev = term;
     	    
-            term = this->Cn(root_n, t) * cos( root_n * r0_s ) * sin( root_n * L ) / ( L * root_n );
+            term = this->Cn(root_n, t) * cos( root_n * r0_s ) * sin( root_n * L ) / 
+                ( L * root_n );
 
 	        sum += term;
 	        n++;
         }
         while ( fabs(term/sum) > EPSILON  ||
-	    fabs(term_prev/sum) > EPSILON ||
-	    n <= MIN_TERMS);
+                fabs(term_prev/sum) > EPSILON ||
+                n < MIN_TERMS);
 
     }
-    return 2.0*exp(vexpo)*sum;
+    return 2.0 * exp(vexpo) * sum;
 }
 
 
@@ -224,7 +282,8 @@ GreensFunction1DRadAbs::prob_r (Real r, Real t)
 const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-    THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a && (r0 - sigma) >= 0.0 && r0<=a );
+    THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a 
+                  && (r0 - sigma) >= 0.0 && r0<=a );
     
     const Real sigma(this->getsigma());
     const Real a(this->geta());
@@ -239,52 +298,56 @@ const
     // if there was no time change or zero diffusivity => no movement
     if (t == 0 || D == 0)
     {
-	// the probability density function is a delta function
-	if (r == r0)
-	{
-	    return INFINITY;
-	}
-	else
-	{
-	    return 0.0;
-	}
+        // the probability density function is a delta function
+        if (r == r0)
+        {
+            return INFINITY;
+        }
+        else
+        {
+            return 0.0;
+        }
     }
 
     // if r is at the absorbing boundary
     if ( fabs(a-r) < EPSILON*L )
     {
-	return 0.0;
+        return 0.0;
     }
 
     Real root_n, root_n_r_s;
     Real sum = 0, term = 0, prev_term = 0;
-    int n=1;
 
+    const uint maxi( guess_maxi( t ) );
+    calculate_n_roots( maxi );
+
+    uint n = 0;
     do
     {
-	if ( n >= MAX_TERMS )
-	{
-	    std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
-	              << n << std::endl;
-	    break;
-	}
+        if ( n >= MAX_TERMS )
+        {
+            std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
+                      << n << std::endl;
+            break;
+        }
 
-	root_n = this->root_n(n);
-	root_n_r_s = root_n*(r-sigma);
+        root_n = this->get_root(n);
+        root_n_r_s = root_n*(r-sigma);
 
-	prev_term = term;
-	term = Cn(root_n, t) * An(root_n) * (h*sin(root_n_r_s) + root_n*cos(root_n_r_s));
-	sum += term;
+        prev_term = term;
+        term = Cn(root_n, t) * An(root_n) * (h*sin(root_n_r_s) + root_n*cos(root_n_r_s));
+        sum += term;
 
-	n++;
+        n++;
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
-	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	n <= MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+           n < MIN_TERMS );
 
     return 2.0*exp(vexpo)*sum;
 }
 
+
 // Calculates the probability density of finding the particle at location z at
 // timepoint t, given that the particle is still in the domain.
 Real
@@ -293,6 +356,7 @@ GreensFunction1DRadAbs::calcpcum (Real r, Real t) const
     return prob_r(r, t)/p_survival(t);
 }
 
+
 // Calculates the total probability flux leaving the domain at time t
 // This is simply the negative of the time derivative of the survival prob.
 // at time t [-dS(t')/dt' for t'=t].
@@ -307,42 +371,47 @@ GreensFunction1DRadAbs::flux_tot (Real t) const
     const Real D2 = D*D;
     const Real v2Dv2D = v*v/4.0/D2;
     double sum = 0, term = 0, prev_term = 0;
-    int n=1;
 
+    const uint maxi( guess_maxi( t ) );
+    calculate_n_roots( maxi );
+
+    uint n = 0;
     do
     {
-	if ( n >= MAX_TERMS )
-	{
-	    std::cerr << "Too many terms needed for GF1DRad::flux_tot. N: "
-	              << n << std::endl;
-	    break;
-	}
-
-	root_n = this->root_n(n);
-	prev_term = term;
-	term = (root_n * root_n + v2Dv2D) * Cn(root_n, t) * An(root_n) * Bn(root_n);
-	n++;
-	sum += term;
+        if ( n >= MAX_TERMS )
+        {
+            std::cerr << "Too many terms needed for GF1DRad::flux_tot. N: "
+                      << n << std::endl;
+            break;
+        }
+
+        root_n = this->get_root(n);
+        prev_term = term;
+        term = (root_n * root_n + v2Dv2D) * Cn(root_n, t) * An(root_n) * Bn(root_n);
+        n++;
+        sum += term;
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
-	fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-	n <= MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
+           n < MIN_TERMS );
 
     return 2.0*D*exp(vexpo)*sum;
 }
 
-// Calculates the probability flux leaving the domain through the radiative
-// boundary at time t
+
+/* Calculates the probability flux leaving the domain through the radiative
+   boundary at time t */
 Real
 GreensFunction1DRadAbs::flux_rad (Real t) const
 {
     return this->getk() * prob_r(this->getsigma(), t);
 }
 
-// Calculates the flux leaving the domain through the radiative boundary as a
-// fraction of the total flux. This is the probability that the particle left
-// the domain through the radiative boundary instead of the absorbing
-// boundary.
+
+/* Calculates the flux leaving the domain through the radiative boundary as a
+   fraction of the total flux. This is the probability that the particle left
+   the domain through the radiative boundary instead of the absorbing
+   boundary. */
 Real
 GreensFunction1DRadAbs::fluxRatioRadTot (Real t) const
 {
@@ -368,7 +437,7 @@ const
     // the particle is at the absorbing boundary (at a) => IV_ESCAPE event
     if ( k == 0 || fabs(a-r0) < EPSILON*L )
     {
-	return IV_ESCAPE;
+        return IV_ESCAPE;
     }
 
     // Else the event is sampled from the flux ratio
@@ -376,50 +445,141 @@ const
 
     if (rnd > fluxratio )
     {
-	return IV_ESCAPE;
+        return IV_ESCAPE;
     }
     else
     {
-	return IV_REACTION;
+        return IV_REACTION;
     }
 }
 
+
+
+/* Returns i'th term of table or fills a table with 
+   i exp arguments for drawT. */
+Real GreensFunction1DRadAbs::drawT_exponent_table( uint const& i, 
+                                                   RealVector& table) const
+{
+    uint n( table.size() );
+
+    if(i < n)
+        return table[i];
+    else
+    {
+        const Real D( getD() );
+        const Real v2( gsl_pow_2( getv() ) );
+        const Real vexpo_t(-v2/4.0/D);
+        Real root_n2;
+
+        while(n++ < i)
+        {
+            root_n2 = gsl_pow_2( get_root( n ) );
+            table.push_back( -D * root_n2 + vexpo_t );
+        }
+        
+        return table.back();
+    }
+}
+
+
+/* Returns i'th term of table or fills the table with 
+   i numerators for drawT. */
+Real GreensFunction1DRadAbs::drawT_Xn_table( uint const& i, 
+                                             RealVector& table) const
+{
+    uint n( table.size() );
+
+    if(i < n)
+        return table[i];
+    else
+    {
+        const Real sigma(this->getsigma());
+        const Real L(this->geta() - this->getsigma());
+        const Real r0(this->getr0());
+        const Real D(this->getD());
+        const Real v(this->getv());
+        const Real h((getk()+getv()/2.0)/getD());
+
+        Real root_n, root_n2, root_n_r0_s, root_n_L, h_root_n;	  
+
+        if( v== 0)
+        {
+            while(n++ < i)
+            {
+                root_n      = get_root(n);	
+                root_n2	    = root_n * root_n;
+                root_n_r0_s = root_n * (r0-sigma);
+                root_n_L    = root_n * L;
+                h_root_n    = h / root_n;
+
+                table.push_back( (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) 
+                                 / (L*(root_n2+h*h)+h) * ( h_root_n + sin(root_n_L) 
+                                                           - h_root_n*cos(root_n_L) ) );
+            }
+        }
+        else
+        {
+            const Real v2D(v/2.0/D);
+            const Real exp_av2D(exp(a*v2D));
+            const Real exp_sigmav2D(exp(sigma*v2D));
+
+            while(n++ < i)
+            {
+                root_n      = get_root(n);	
+                root_n2	    = root_n * root_n;
+                root_n_r0_s = root_n * (r0-sigma);
+                root_n_L    = root_n * L;
+                h_root_n    = h / root_n;
+
+                table.push_back( (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / 
+                                 (L*(root_n2+h*h)+h) * (exp_sigmav2D*h*k/D - 
+                                                        exp_av2D*(root_n2+h*h)*
+                                                        cos(root_n_L)) / 
+                                 (h_root_n * (root_n2 + v2D*v2D))  
+                                 );
+            }
+        }
+        return table.back();
+    }
+}
+
+
 // This function is needed to cast the math. form of the function
 // into the form needed by the GSL root solver.
-double
-GreensFunction1DRadAbs::drawT_f (double t, void *p)
+double GreensFunction1DRadAbs::drawT_f (double t, void *p)
 {
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
-    Real Xn, exponent;
+    Real Xn = 0, exponent = 0;
     Real prefactor = params->prefactor;
-    int terms = params->terms;
+    uint terms = params->terms;
 
     Real sum = 0, term = 0, prev_term = 0;
-    int n=0;
+
+    uint n = 0;
     do
     {
-	if ( n >= terms )
-	{
-	    std::cerr << "Too many terms needed for GF1DRad::DrawTime. N: "
-	              << n << ", conv arg: " << exponent * t <<  std::endl;
-	    break;
-	}
-	prev_term = term;
-
-	Xn = params->Xn[n];
-	exponent = params->exponent[n];
-	term = Xn * exp(exponent * t);
-
-	sum += term;
-	n++;
+        if ( n >= terms )
+        {
+            std::cerr << "Too many terms needed for GF1DRad::DrawTime. N: "
+                      << n << ", conv arg: " << exponent * t <<  std::endl;
+            break;
+        }
+        prev_term = term;
+        
+        Xn = params->gf->drawT_Xn_table(n, params->Xn_table);
+        exponent = params->gf->drawT_exponent_table(n, params->exponent_table);
+        term = Xn * exp(exponent * t);
+
+        sum += term;
+        n++;
     }
     while (fabs(term/sum) > EPSILON*1.0 ||
-	fabs(prev_term/sum) > EPSILON*1.0 ||
-	n <= MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON*1.0 ||
+           n < MIN_TERMS );
 
     // find the intersection with the random number
-    return 1.0 - prefactor*sum - params->rnd;
+    return params->rnd - prefactor*sum;
 }
 
 // Draws the first passage time from the survival probability,
@@ -436,79 +596,23 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     const Real r0(this->getr0());
     const Real k(this->getk());
     const Real D(this->getD());
-    const Real v(this->getv());
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    
+    const Real v(this->getv());   
 
     if ( D == 0.0 || L == INFINITY )
     {
-	return INFINITY;
+        return INFINITY;
     }
 
     if ( rnd <= EPSILON || L < 0.0 || fabs(a-r0) < EPSILON*L )
     {
-	return 0.0;
+        return 0.0;
     }
 
-    const Real v2D(v/2.0/D);
-    const Real exp_av2D(exp(a*v2D));
-    const Real exp_sigmav2D(exp(sigma*v2D));
-    // exponent of the prefactor present in case of v<>0; has to be split because it has a t-dep. and t-indep. part
-    const Real vexpo_t(-v*v/4.0/D);
-    const Real vexpo_pref(-v*r0/2.0/D);
-
-    // the structure to store the numbers to calculate the numbers for 1-S
-    struct drawT_params parameters;
     // some temporary variables
-    double root_n = 0;
-    double root_n2, root_n_r0_s, root_n_L, h_root_n;
-    double Xn, exponent, prefactor;
-
-
-    // produce the coefficients and the terms in the exponent and put them
-    // in the params structure. This is not very efficient at this point,
-    // coefficients should be calculated on demand->TODO
- 
-    for (int n=0; n<MAX_TERMS; n++)
-    {
-	root_n = this->root_n(n+1);	// get the n-th root of tan(root*a)=root/-h (Note: root numbering starts at n=1)
-	
-	root_n2	    = root_n * root_n;
-	root_n_r0_s = root_n * (r0-sigma);
-	root_n_L    = root_n * L;
-	h_root_n    = h / root_n;
-	
-	if(v==0)	Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
-			      * ( h_root_n + sin(root_n_L) - h_root_n*cos(root_n_L) ); 
-	else		Xn = (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / (L*(root_n2+h*h)+h)
-			      * (exp_sigmav2D*h*k/D - exp_av2D*(root_n2+h*h)*cos(root_n_L)) / (h_root_n * (root_n2 + v2D*v2D)); 
-		  
-	exponent = -D*root_n2 + vexpo_t;
-
-	// store the coefficients in the structure
-	parameters.Xn[n] = Xn;
-	// also store the values for the exponent
-	parameters.exponent[n] = exponent;
-    }
-    
-    // the prefactor of the sum is also different in case of drift<>0 :
-    if(v==0)	prefactor = 2.0;
-    else	prefactor = 2.0*exp(vexpo_pref);
-    parameters.prefactor  = prefactor;
-    
-    // store the random number for the probability
-    parameters.rnd = rnd;
-    // store the number of terms used
-    parameters.terms = MAX_TERMS;
-    parameters.tscale = this->t_scale;
-
-    // Define the function for the rootfinder
-    gsl_function F;
-    F.function = &GreensFunction1DRadAbs::drawT_f;
-    F.params = &parameters;
+    const Real vexpo_pref(-v*r0/2.0/D);
+    Real prefactor;
 
-    // Find a good interval to determine the first passage time in
-    // get the distance to absorbing boundary (disregard rad BC)
+    /* Find a good interval to determine the first passage time. */
     Real t_guess;
     Real dist;
 
@@ -520,10 +624,10 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     {
         dist = a - r0;
     }
-    //const Real dist( std::min(r0, a-r0));	// for test purposes
-    // construct a guess: MSD = sqrt (2*d*D*t)
+
     t_guess = dist * dist / ( 2.0 * D );
     t_guess *= .1;
+
     // A different guess has to be made in case of nonzero drift to account for the displacement due to it
     // TODO: This does not work properly in this case yet, but we don't know why...
     // When drifting towards the closest boundary
@@ -531,6 +635,38 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     // When drifting away from the closest boundary
     //if( ( r0 < a/2.0 && v > 0.0) || ( r0 > a/2.0 && v < 0.0) )	t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));  
 
+    /* Guess nbr of terms needed for convergence. */
+    const uint maxi( guess_maxi( t_guess ) );
+    calculate_n_roots( maxi );
+
+    /* Build tables of factor not depending on t */
+    RealVector exponent_table;
+    RealVector Xn_table;
+    drawT_exponent_table( maxi, exponent_table );
+    drawT_Xn_table( maxi, Xn_table );
+
+    /* Set params structure. */
+    struct drawT_params parameters = {this, exponent_table, Xn_table};
+    
+    // the prefactor of the sum is also different in case of drift<>0 :
+    if(v == 0)
+        prefactor = 2.0;
+    else
+        prefactor = 2.0 * exp(vexpo_pref);
+
+    parameters.prefactor  = prefactor;
+    
+    // store the random number for the probability
+    parameters.rnd = rnd;
+    // store the number of terms used
+    parameters.terms = MAX_TERMS;
+    parameters.tscale = this->t_scale;
+
+    // Define the function for the rootfinder
+    gsl_function F;
+    F.function = &GreensFunction1DRadAbs::drawT_f;
+    F.params = &parameters;
+
     Real value( GSL_FN_EVAL( &F, t_guess ) );
     Real low( t_guess );
     Real high( t_guess );
@@ -538,48 +674,48 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     // scale the interval around the guess such that the function straddles
     if( value < 0.0 )
     {
-	// if the guess was too low
-	do
-	{
-	    // keep increasing the upper boundary until the
-	    // function straddles
-	    high *= 10;
-	    value = GSL_FN_EVAL( &F, high );
-
-	    if( fabs( high ) >= t_guess * 1e6 )
-	    {
-		std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
-		          << high << ") = " << value << std::endl;
-		throw std::exception();
-	    }
-	}
-	while ( value <= 0.0 );
+        // if the guess was too low
+        do
+        {
+            // keep increasing the upper boundary until the
+            // function straddles
+            high *= 10;
+            value = GSL_FN_EVAL( &F, high );
+
+            if( fabs( high ) >= t_guess * 1e6 )
+            {
+                std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
+                          << high << ") = " << value << std::endl;
+                throw std::exception();
+            }
+        }
+        while ( value <= 0.0 );
     }
     else
     {
 	// if the guess was too high
 	// initialize with 2 so the test below survives the first
 	// iteration
-	Real value_prev( 2 );
-	do
-	{
-	    if( fabs( low ) <= t_guess * 1e-6 ||
-	        fabs(value-value_prev) < EPSILON*1.0 )
-	    {
-		std::cerr << "GF1DRad::drawTime Couldn't adjust low. F(" << low << ") = "
-		          << value << " t_guess: " << t_guess << " diff: "
-		          << (value - value_prev) << " value: " << value
-		          << " value_prev: " << value_prev << " rnd: "
-		          << rnd << std::endl;
-		return low;
-	    }
-	    value_prev = value;
-	    // keep decreasing the lower boundary until the function straddles
-	    low *= 0.1;
-	    // get the accompanying value
-	    value = GSL_FN_EVAL( &F, low );
-	}
-	while ( value >= 0.0 );
+        Real value_prev( 2 );
+        do
+        {
+            if( fabs( low ) <= t_guess * 1e-6 ||
+                fabs(value-value_prev) < EPSILON*1.0 )
+            {
+                std::cerr << "GF1DRad::drawTime Couldn't adjust low. F(" << low << ") = "
+                          << value << " t_guess: " << t_guess << " diff: "
+                          << (value - value_prev) << " value: " << value
+                          << " value_prev: " << value_prev << " rnd: "
+                          << rnd << std::endl;
+                return low;
+            }
+            value_prev = value;
+            // keep decreasing the lower boundary until the function straddles
+            low *= 0.1;
+            // get the accompanying value
+            value = GSL_FN_EVAL( &F, low );
+        }
+        while ( value >= 0.0 );
     }
 
     // find the intersection on the y-axis between the random number and
@@ -605,7 +741,7 @@ GreensFunction1DRadAbs::drawR_f (double z, void *p)
     Real costerm 	= params->H[1];	// = k/D
     Real sinterm 	= params->H[2];	// = h*v2D
     Real sigma 		= params->H[3];	// = sigma
-    int  terms = params->terms;
+    uint  terms = params->terms;
 
     Real expsigma(exp(sigma*v2D));
     Real zs(z-sigma);
@@ -613,27 +749,29 @@ GreensFunction1DRadAbs::drawR_f (double z, void *p)
     Real sum = 0, term = 0, prev_term = 0;
     Real root_n, S_Cn_root_n;
     
-    int n = 0;
+    uint n = 0;
     do
     {
-	if ( n >= terms )
-	{
-	    std::cerr << "GF1DRad: Too many terms needed for DrawR. N: "
-	              << n << std::endl;
-	    break;
-	}
-	prev_term = term;
-
-	S_Cn_root_n = params->S_Cn_root_n[n];
-	root_n  = params->root_n[n];
-	term = S_Cn_root_n * ( expsigma*costerm - exp(v2D*z)*( costerm*cos(root_n*zs) - (root_n+sinterm/root_n)*sin(root_n*zs) ));
-
-	sum += term;
-	n++;
+        if ( n >= terms )
+        {
+            std::cerr << "GF1DRad: Too many terms needed for DrawR. N: "
+                      << n << std::endl;
+            break;
+        }
+        prev_term = term;
+        
+        S_Cn_root_n = params->S_Cn_root_n[n];
+        root_n  = params->root_n[n];
+        term = S_Cn_root_n * ( expsigma*costerm - exp(v2D*z)*
+                               ( costerm*cos(root_n*zs) - 
+                                 (root_n+sinterm/root_n)*sin(root_n*zs) ));
+
+        sum += term;
+        n++;
     }
     while (fabs(term/sum) > EPSILON*1.0 ||
-	fabs(prev_term/sum) > EPSILON*1.0 ||
-	n <= MIN_TERMS );
+           fabs(prev_term/sum) > EPSILON*1.0 ||
+           n < MIN_TERMS );
 
     // Find the intersection with the random number
     return sum - params->rnd;
@@ -657,14 +795,14 @@ GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
 
     if (t==0.0 || (D==0.0 && v==0.0) )
     {
-	// the trivial case
-	//return r0*this->l_scale;	// renormalized version, discontinued
-	return r0;
+        // the trivial case
+        //return r0*this->l_scale;	// renormalized version, discontinued
+        return r0;
     }
     if ( a<0.0 )
     {
-	// if the domain had zero size
-	return 0.0;
+        // if the domain had zero size
+        return 0.0;
     }
 
     // the structure to store the numbers to calculate the numbers for 1-S
@@ -680,11 +818,14 @@ GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
 
     assert(p_survival(t) >= 0.0);
 
+    const uint maxi( guess_maxi( t ) );
+    calculate_n_roots( maxi );
+
     // produce the coefficients and the terms in the exponent and put them
     // in the params structure
-    for (int n=0; n<MAX_TERMS; n++)
+    for (uint n = 0; n < maxi; n++)
     {
-	    root_n = this->root_n(n+1);  // get the n-th root of tan(alfa*a)=alfa/-k
+	    root_n = this->get_root(n);  // get the n-th root of tan(alfa*a)=alfa/-k
        	root_n2 = root_n * root_n;
        	root_n_r0_s = root_n * (r0-sigma);
        	S_Cn_root_n =	S * exp(-D*root_n2*t)
@@ -712,13 +853,12 @@ GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
     // store the random number for the probability
     parameters.rnd = rnd;
     // store the number of terms used
-    parameters.terms = MAX_TERMS;
+    parameters.terms = maxi;
 
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
-    // make a new solver instance
-    // TODO: incl typecast?
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+
     Real r( findRoot( F, solver, sigma, a, EPSILON*L, EPSILON,
                             "GreensFunction1DRadAbs::drawR" ) );
 
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 94ef0865..81c91450 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -19,12 +19,17 @@
 #include <math.h>
 
 #include "findRoot.hpp"
+#include "funcSum.hpp" 
 #include "Defs.hpp"
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "GreensFunction.hpp"
 
 class GreensFunction1DRadAbs: public GreensFunction
 {
+public:
+    typedef std::vector<Real> RealVector;
+    typedef unsigned int uint;
+
 private:
     // This is a typical length scale of the system, may not be true!
     static const Real L_TYPICAL = 1E-8;
@@ -35,15 +40,16 @@ class GreensFunction1DRadAbs: public GreensFunction
     // Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms used in calculating the sum
-    static const int MAX_TERMS = 500;
+    static const uint MAX_TERMS = 500;
     // The minimum number of terms
-    static const int MIN_TERMS = 20;
+    static const uint MIN_TERMS = 20;
 
 public:
     GreensFunction1DRadAbs(Real D, Real k, Real r0, Real sigma, Real a)
 	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
-	// do nothing
+        //set first root.
+        calculate_n_roots( 1 );
     }
 
     // The constructor is overloaded and can be called with or without drift v
@@ -51,7 +57,8 @@ class GreensFunction1DRadAbs: public GreensFunction
     GreensFunction1DRadAbs(Real D, Real v, Real k, Real r0, Real sigma, Real a)
 	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
-	// do nothing
+        //set first root;
+        calculate_n_roots( 1 );
     }
 
     ~GreensFunction1DRadAbs()
@@ -192,36 +199,86 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     struct tan_f_params
     {
-	Real a;
-	Real h;
+        Real a;
+        Real h;
     };
 
+
+    /* Functions managing the rootList */
+    
+    /* return the rootList size */
+    uint rootList_size() const
+    {
+        return rootList.size();
+    }
+
+    /* returns the last root. */
+    Real get_last_root() const
+    {
+        return rootList.back();
+    }
+
+    /* ad a root to the rootList */
+    void ad_to_rootList( Real const& root_i ) const
+    {
+        rootList.push_back( root_i );
+    }
+
+    /* remove n'th root from rootList */
+    void remove_from_rootList(uint const& n) const
+    {
+        rootList.erase( rootList.begin() + n );
+    }
+
+    /* return the n'th root */
+    Real get_root( uint const& n ) const
+    {
+        if( n < rootList.size() )
+            return rootList[ n ];
+        else
+        {
+            root_n( n );
+            return rootList[ n ];
+        }
+    }
+
+    /* Fills the rootList with the first n roots. */
+    void calculate_n_roots(uint const& n) const;
+
+    /* Guess the number of terms needed for convergence, given t. */
+    uint guess_maxi( Real const& t ) const;
+
+    /* this is the appropriate definition of the function in gsl. */
     static double tan_f (double x, void *p);
-    // this is the appropriate definition of the function in gsl
 
     struct drawT_params
     {
-	double exponent[MAX_TERMS];
-	double Xn[MAX_TERMS];
-	double prefactor;
-	int    terms;
-	// the timescale used for convergence
-	Real   tscale;
-	// the random number associated with the time
-	double rnd;
+        GreensFunction1DRadAbs const* gf;
+        RealVector& exponent_table;
+        RealVector& Xn_table;
+        double prefactor;
+        uint   terms;
+        // the timescale used for convergence
+        Real   tscale;
+        // the random number associated with the time
+        double rnd;
     };
 
     static double drawT_f (double t, void *p);
 
+    Real drawT_exponent_table( uint const& i, RealVector& table) const;
+
+    Real drawT_Xn_table( uint const& i, RealVector& table) const;
+
     struct drawR_params
     {
-	double root_n[MAX_TERMS];
-	double S_Cn_root_n[MAX_TERMS];
-	// variables H: for additional terms appearing as multiplicative factors etc.
-	double H[5];
-	int terms;
-	// the random number associated with the time
-	double rnd;
+        double root_n[MAX_TERMS];
+        double S_Cn_root_n[MAX_TERMS];
+        // variables H: for additional terms appearing as multiplicative factors etc.
+        double H[5];
+        uint terms;
+        // the random number associated with the time
+        double rnd;
     };
 
     static double drawR_f (double z, void *p);
@@ -238,5 +295,7 @@ class GreensFunction1DRadAbs: public GreensFunction
     Real l_scale;
     // This is the time scale of the system.
     Real t_scale;
+
+    mutable RealVector rootList;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP

From c3539f7d4430e564a7300339cb8bba6f31ff6191 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 30 Nov 2011 17:27:30 +0100
Subject: [PATCH 0418/1541] Added functions needed for approximations in 1D
 Green's functions. Changed the behaviour of drawT functions.

---
 GreensFunction1DAbsAbs.cpp     |  14 ++-
 GreensFunction1DAbsAbs.hpp     |   1 -
 GreensFunction1DAbsSinkAbs.cpp |  15 ++--
 GreensFunction1DRadAbs.cpp     |  25 +++---
 GreensFunction1DRadAbs.hpp     |   1 -
 freeFunctions.cpp              | 156 +++++++++++++++++++++++++++++++++
 freeFunctions.hpp              |  35 ++++++++
 7 files changed, 223 insertions(+), 24 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 0fa4bfe0..cfa00c79 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -474,15 +474,22 @@ Real GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
     
     Real sum = 0, term = 0, prev_term = 0;
     Real Xn, exponent, prefactor;
-    // the maximum number of terms in the params table
-    uint terms = params->terms;
     // the timescale used
     Real tscale = params->tscale;
 
+    const uint maxi( params->gf->guess_maxi( t ) );
+
+    if( params->exponent_table.size() < maxi + 1 &&
+        params->Xn_table.size() < maxi + 1 )
+    {
+        IGNORE_RETURN params->gf->drawT_exponent_table( maxi, params->exponent_table );
+        IGNORE_RETURN params->gf->drawT_Xn_table( maxi, params->Xn_table );
+    }
+
     uint n = 0;
     do
     {
-        if ( n >= terms )
+        if ( n >= maxi )
         {
             std::cerr << "Too many terms needed for DrawTime. N: "
                       << n << std::endl;
@@ -577,7 +584,6 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     parameters.prefactor = prefactor;
     
     parameters.rnd = rnd;
-    parameters.terms = MAX_TERMS;
     parameters.tscale = this->t_scale;
 
     gsl_function F;
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index e1729029..11ba98ee 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -176,7 +176,6 @@ class GreensFunction1DAbsAbs: public GreensFunction
         RealVector& exponent_table;
         RealVector& Xn_table;
         Real prefactor;
-        uint terms;
         Real tscale;
         Real rnd;
     };
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 76a8cda0..afc68aca 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -326,7 +326,11 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
     */
 
     const uint maxi( guess_maxi(t) );
-            
+    
+    if( maxi == MAX_TERMS )
+        std::cerr << "1DSink::drawT: maxi was cut to MAX_TERMS for t = " 
+                  << t << std::endl;
+        
     if (psurvTable.size() < maxi + 1)
     {
         calculate_n_roots( maxi );  // this updates the table
@@ -722,9 +726,6 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     t_guess = dist * dist / ( 2.0 * D );
     t_guess *= .1;
 
-    const uint maxi( guess_maxi( t_guess ) );
-    calculate_n_roots( maxi );
-
     /* Define the function for the rootfinder */
     gsl_function F;
     F.function = &GreensFunction1DAbsSinkAbs::drawT_f;
@@ -808,7 +809,11 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
        : rr -> -rr. */
     const Real rr( getr0() - rsink >= 0 ? r - rsink : rsink - r  );
 
-    const uint maxi( guess_maxi(t) );    
+    const uint maxi( guess_maxi(t) );
+
+    if( maxi == MAX_TERMS )
+        std::cerr << "1DSink::p_int_r_table: maxi was cut to MAX_TERMS for t = " 
+                  << t << std::endl;
    
     if (table.size() < maxi + 1)
     {
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 66f17fe7..509f2778 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -552,14 +552,22 @@ double GreensFunction1DRadAbs::drawT_f (double t, void *p)
     struct drawT_params *params = (struct drawT_params *)p;
     Real Xn = 0, exponent = 0;
     Real prefactor = params->prefactor;
-    uint terms = params->terms;
 
-    Real sum = 0, term = 0, prev_term = 0;
+    const uint maxi( params->gf->guess_maxi( t ) );
+    
+    if( params->exponent_table.size() < maxi + 1 &&
+        params->Xn_table.size() < maxi + 1 )
+    {
+        params->gf->calculate_n_roots( maxi );
+        IGNORE_RETURN params->gf->drawT_exponent_table( maxi, params->exponent_table );
+        IGNORE_RETURN params->gf->drawT_Xn_table( maxi, params->Xn_table );
+    }
 
+    Real sum = 0, term = 0, prev_term = 0;
     uint n = 0;
     do
     {
-        if ( n >= terms )
+        if ( n >= maxi )
         {
             std::cerr << "Too many terms needed for GF1DRad::DrawTime. N: "
                       << n << ", conv arg: " << exponent * t <<  std::endl;
@@ -635,17 +643,9 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     // When drifting away from the closest boundary
     //if( ( r0 < a/2.0 && v > 0.0) || ( r0 > a/2.0 && v < 0.0) )	t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));  
 
-    /* Guess nbr of terms needed for convergence. */
-    const uint maxi( guess_maxi( t_guess ) );
-    calculate_n_roots( maxi );
-
-    /* Build tables of factor not depending on t */
+    /* Set params structure. */
     RealVector exponent_table;
     RealVector Xn_table;
-    drawT_exponent_table( maxi, exponent_table );
-    drawT_Xn_table( maxi, Xn_table );
-
-    /* Set params structure. */
     struct drawT_params parameters = {this, exponent_table, Xn_table};
     
     // the prefactor of the sum is also different in case of drift<>0 :
@@ -659,7 +659,6 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     // store the random number for the probability
     parameters.rnd = rnd;
     // store the number of terms used
-    parameters.terms = MAX_TERMS;
     parameters.tscale = this->t_scale;
 
     // Define the function for the rootfinder
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 81c91450..d629ac9b 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -257,7 +257,6 @@ class GreensFunction1DRadAbs: public GreensFunction
         RealVector& exponent_table;
         RealVector& Xn_table;
         double prefactor;
-        uint   terms;
         // the timescale used for convergence
         Real   tscale;
         // the random number associated with the time
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index 70b9a269..09ef8085 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -62,6 +62,162 @@ Real W(Real a, Real b)
     return std::exp(- a * a) * expxsq_erfc(a + b);
 }
 
+
+/* List of 1D functions used as approximations for the greensfunctions
+   of the full domain. For small t, a particle only scans part of the domain
+   and thus not al the boundary conditions have to be included. Because the
+   greensfunctions converge bad for small t, we use these approximations.
+
+   note: drift not included yet!
+
+   *** Naming: 
+   All 1D function names start with an X, followed by:
+
+   P for position density function.
+   S for survival probability function.
+   I for culumative distribution function of position.
+
+   ** Last two numer give boundaries 
+   (By J.V. Beck - Heat Conduction in Green's Functions)
+
+   0 - No boundary.
+   1 - Absorbing boundary.
+   2 - Reflective boundary.
+   3 - Radiation boundary with rate ka.
+ */
+
+Real XP00( Real r, Real t, Real r0, Real D )
+{
+    const Real fourDt( 4 * D * t );
+    const Real rminr02( gsl_pow_2( r - r0 ) );
+
+    return 1. / sqrt( fourDt * M_PI ) * exp( - rminr02 / fourDt );
+}
+
+
+Real XI00( Real r, Real t, Real r0, Real D )
+{
+    const Real sqrt4Dt( sqrt( 4 * D * t ) );
+    const Real rminr0( r - r0 );
+
+    return 0.5 * ( 1.0 + erf( rminr0 / sqrt4Dt ) );
+}
+
+
+Real XS00( Real r, Real t, Real r0, Real D )
+{
+    return 1;
+}
+
+
+Real XP10( Real r, Real t, Real r0, Real D )
+{
+    const Real fourDt( 4 * D * t );
+    const Real rminr02( gsl_pow_2( r - r0 ) );
+    const Real rplusr02( gsl_pow_2( r + r0 ) );
+
+    return 1. / sqrt( fourDt * M_PI ) * 
+        ( exp( - rminr02 / fourDt ) - exp( - rplusr02 / fourDt ) );
+}
+
+
+Real XI10( Real r, Real t, Real r0, Real D )
+{
+    const Real sqrt4Dt( sqrt( 4 * D * t ) );
+    const Real rminr0( r - r0 );
+    const Real rplusr0( r + r0 );
+
+    const Real temp( 2.0 * erf( r0 / sqrt4Dt ) 
+                     + erf( rminr0/sqrt4Dt ) - erf( rplusr0/sqrt4Dt ) );
+
+    return 0.5 * temp;
+}
+
+
+Real XS10( Real r, Real t, Real r0, Real D )
+{
+    const Real sqrt4Dt( sqrt( 4 * D * t ) );
+
+    return erf( r0 / sqrt4Dt );
+}
+
+
+Real XP20( Real r, Real t, Real r0, Real D )
+{
+    const Real fourDt( 4 * D * t );
+    const Real rminr02( gsl_pow_2( r - r0 ) );
+    const Real rplusr02( gsl_pow_2( r + r0 ) );
+
+    return 1. / sqrt( fourDt * M_PI ) * 
+        ( exp( - rminr02 / fourDt ) + exp( - rplusr02 / fourDt ) );
+}
+
+
+Real XI20( Real r, Real t, Real r0, Real D )
+{
+    const Real sqrt4Dt( sqrt( 4 * D * t ) );
+
+    const Real temp( erf( (r - r0)/sqrt4Dt ) - erf( (r + r0)/sqrt4Dt ) );
+
+    return 0.5 * temp;
+}
+
+
+Real XS20( Real r, Real t, Real r0, Real D )
+{
+    return 1;
+}
+
+
+Real XP30term( Real r, Real t, Real r0, Real ka, Real D )
+{
+    const Real fourDt( 4 * D * t );
+    const Real k_D( ka / D );
+    const Real rplusr02( gsl_pow_2( r + r0 ) );
+    const Real arg( (r + r0)/sqrt(fourDt) + ka * sqrt( t / D ) );
+        
+    return -k_D * exp( - rplusr02 / fourDt ) * expxsq_erfc( arg );
+}
+
+
+Real XP30( Real r, Real t, Real r0, Real ka, Real D )
+{        
+    return XP20(r, t, r0, D) + XP30term(r, t, r0, ka, D);
+}
+
+
+Real XI30term( Real r, Real t, Real r0, Real ka, Real D )
+{
+    const Real sqrt4Dt( sqrt(4 * D * t) );
+    const Real k_D( ka / D );
+    const Real rplusr02( gsl_pow_2( r + r0 ) );
+        
+    const Real term1( erf( r0/sqrt4Dt ) - erf( (r+r0)/sqrt4Dt ) );
+
+    const Real term2( exp( k_D * (ka * t + r0) ) * erfc( (2 * ka * t + r0)/sqrt4Dt ) );
+
+    const Real term3( exp( k_D * (ka * t + r0 + r) ) * erfc( (2 * ka * t + r0 + r)/sqrt4Dt ) );
+
+    return term1 + term2 - term3;
+}
+
+
+Real XI30( Real r, Real t, Real r0, Real ka, Real D )
+{
+    return XI20(r, t, r0, D) + XI30term(r, t, r0, ka, D);
+}
+
+
+Real XS30( Real t, Real r0, Real ka, Real D )
+{
+    const Real sqrt4Dt( sqrt( 4 * D * t ) );
+    const Real k_D( ka / D );
+
+    return erf( r0 / sqrt4Dt ) + 
+        exp( k_D * ka * t + k_D * r0 ) * erfc( (2 * ka * t + r0) / sqrt4Dt );
+}
+
+
 Real __p_irr(Real r, Real t, Real r0, Real kf, Real D, Real sigma, Real alpha)
 {
     //  printf("irrp %.16g %.16g %.16g\n",r,r0,t);
diff --git a/freeFunctions.hpp b/freeFunctions.hpp
index 617001e5..6221ab57 100644
--- a/freeFunctions.hpp
+++ b/freeFunctions.hpp
@@ -7,6 +7,39 @@ Real expxsq_erfc(Real x);
 
 Real W(Real a, Real b);
 
+/* Functions needed in 1D Green's functions. For
+   explanation, see the cpp file. */
+
+Real XP00( Real r, Real t, Real r0, Real D );
+
+Real XI00( Real r, Real t, Real r0, Real D );
+
+Real XS00( Real r, Real t, Real r0, Real D );
+
+Real XP10( Real r, Real t, Real r0, Real D );
+
+Real XI10( Real r, Real t, Real r0, Real D );
+
+Real XS10( Real r, Real t, Real r0, Real D );
+
+Real XP20( Real r, Real t, Real r0, Real D );
+
+Real XI20( Real r, Real t, Real r0, Real D );
+
+Real XS20( Real r, Real t, Real r0, Real D );
+
+Real XP30term( Real r, Real t, Real r0, Real ka, Real D );
+
+Real XP30( Real r, Real t, Real r0, Real ka, Real D );
+
+Real XI30term( Real r, Real t, Real r0, Real ka, Real D );
+
+Real XI30( Real r, Real t, Real r0, Real ka, Real D );
+
+Real XS30( Real t, Real r0, Real ka, Real D );
+
+/* 3D functions below. */
+
 Real p_irr(Real r, Real t, Real r0, Real kf, Real D, Real sigma);
 
 Real __p_irr(Real r, Real t, Real r0, Real kf, Real D, Real sigma, Real alpha);
@@ -27,6 +60,8 @@ Real p_theta_free(Real theta, Real r, Real r0, Real t, Real D);
 
 Real ip_theta_free(Real theta, Real r, Real r0, Real t, Real D);
 
+/* Functions used in old Brownian Dynamic scheme. */
+
 Real g_bd_3D(Real r0, Real sigma, Real t, Real D);
 
 Real I_bd_3D(Real sigma, Real t, Real D);

From 033cc8ab6e0d762ab16d1aa54f3b4098efee630a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 30 Nov 2011 19:15:59 +0100
Subject: [PATCH 0419/1541] fixed design error in multi formation. Still has
 problems though

---
 egfrd.py | 96 +++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 67 insertions(+), 29 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2e5bf741..ac0e4275 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1170,9 +1170,9 @@ def make_new_domain(self, single):
         # zero-shell NonInteractionSingle -> Pair or Multi
         # Multi -> Multi
         # Surface -> Interaction
-        closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
-                                                                        ignore=[single.domain_id],
-                                                                        ignores=[single.structure.id])
+#        closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
+#                                                                        ignore=[single.domain_id],
+#                                                                        ignores=[single.structure.id])
 
         # New situation -> re-get the neighbors
         # TODO: modify the existing neighbor list by removing burst domains, and adding the new ones + distance
@@ -1202,19 +1202,19 @@ def make_new_domain(self, single):
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
 
-        ### START LEGACY
-        partners = burst
-        dists = []
-        if partners:
-#            for domain, _ in partners:
-#            if isinstance(domain, NonInteractionSingle):
-            # sort partners by distance
-            dists = self.obj_distance_array(single_pos, partners)
-            if len(dists) >= 2:
-                n = dists.argsort()
-                partners = numpy.take(partners, n)      # sort the potential partners using the index
-                dists = dists.take(n)                   # sort the distances using the index
-        ### END LEGACY
+#        ### START LEGACY
+#        partners = burst
+#        dists = []
+#        if partners:
+##            for domain, _ in partners:
+##            if isinstance(domain, NonInteractionSingle):
+#            # sort partners by distance
+#            dists = self.obj_distance_array(single_pos, partners)
+#            if len(dists) >= 2:
+#                n = dists.argsort()
+#                partners = numpy.take(partners, n)      # sort the potential partners using the index
+#                dists = dists.take(n)                   # sort the distances using the index
+#        ### END LEGACY
 
 
         # 2.4 calculate the thresholds (horizons) for trying to form the various domains.
@@ -1251,10 +1251,10 @@ def make_new_domain(self, single):
             multi_partners = []
             for domain, dist_to_shell in neighbors:
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
-                    multi_horizon = (single_radius ) * self.MULTI_SHELL_FACTOR
+                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
                     # distance from the center of the particles/domains
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
-                    multi_partners.append((domain, dist_to_shell - multi_horizon))
+                    multi_partners.append((domain, distance - multi_horizon))
 
                 elif isinstance(domain, Multi):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
@@ -1294,6 +1294,7 @@ def make_new_domain(self, single):
                 self.add_domain_event(single)
             else:
                 # An object was closer than the Multi horizon
+                # Form a multi with everything that is in the multi_horizon
                 domain = self.form_multi(single, multi_partners)
 
         return domain
@@ -2141,8 +2142,9 @@ def form_multi(self, single, multi_partners):
         # Filter out relevant neighbors if present
         # only consider objects that are within the Multi horizon
         neighbors = [obj for (obj, overlap) in multi_partners if overlap < 0]
+
         for partner in neighbors:
-            assert (isinstance(partner, NonInteractionSingle) or \
+            assert ((isinstance(partner, NonInteractionSingle) and partner.is_reset()) or \
                     isinstance(partner, Multi) or \
                     isinstance(partner, PlanarSurface) or \
                     isinstance(partner, CylindricalSurface)), \
@@ -2158,7 +2160,7 @@ def form_multi(self, single, multi_partners):
         if isinstance(closest, Multi):
         # if the closest to this Single is a Multi, reuse the Multi.
             multi = closest
-            neighbors = neighbors[1:]   # the rest of the neighbors are added
+            neighbors = neighbors[1:]   # don't add the closest multi with add_to_multi_recursive below
         else: 
         # the closest is not a Multi. Can be NonInteractionSingle, surface or
         # nothing. Create new Multi
@@ -2169,16 +2171,23 @@ def form_multi(self, single, multi_partners):
         self.add_to_multi(single, multi)
         self.remove_domain(single)
 
-        # TODO add them here or let the scheduler handle this?
-#        for neighbor in neighbors:
-#            self.add_to_multi_recursive(neighbor, multi)
+        # add everything in the horizon to the multi
+        for neighbor in neighbors:
+            if (isinstance(neighbor, NonInteractionSingle) and neighbor.is_reset()) or \
+               isinstance(neighbor, Multi):
+                self.add_to_multi_recursive(neighbor, multi)
+            else:
+                # neighbor is a surface
+                log.debug('add_to_multi: object(%s) is surface, not added to multi.' % neighbor)
 
 
         # 3. Initialize and (re-)schedule
         multi.initialize(self.t)
         if isinstance(closest, Multi):
+            # Multi existed before
             self.update_domain_event(self.t + multi.dt, multi)
         else:
+            # In case of new multi
             self.add_domain_event(multi)
 
         return multi
@@ -2187,6 +2196,10 @@ def form_multi(self, single, multi_partners):
     def add_to_multi_recursive(self, domain, multi):
     # adds 'domain' (which can be zero-dt NonInteractionSingle or Multi) to 'multi'
 
+
+        if __debug__:
+            log.debug('add_to_multi_recursive.\n domain: %s, multi: %s' % (domain, multi))
+
         if isinstance(domain, NonInteractionSingle):
             assert domain.is_reset()        # domain must be zero-dt NonInteractionSingle
 
@@ -2213,14 +2226,37 @@ def add_to_multi_recursive(self, domain, multi):
             self.remove_event(domain)
 
             # get distances to closest shell of burst neighbors
-            neighbor_dists = self.obj_distance_array(dompos, burst)
+#            neighbor_dists = self.obj_distance_array(dompos, burst)
+            neighbors = [(burst_domain, self.domain_distance(dompos, burst_domain)) for burst_domain in burst]
+
             # 3. select neighbors in the 'multi_horizon' for adding to the multi
-            neighbors = [burst[i] for i
-                                  in (neighbor_dists <= burstradius).nonzero()[0]]
+#            neighbors = [burst[i] for i
+#                                  in (neighbor_dists <= burstradius).nonzero()[0]]
+
+            multi_partners = []
+            for neighbor, dist_to_shell in neighbors:
+                if (isinstance (neighbor, NonInteractionSingle) and neighbor.is_reset()):
+                    multi_horizon = (domain.pid_particle_pair[1].radius + neighbor.pid_particle_pair[1].radius) * \
+                                    self.MULTI_SHELL_FACTOR
+                    # distance from the center of the particles/domains
+                    distance = self.world.distance(dompos, neighbor.shell.shape.position)
+                    multi_partners.append((neighbor, distance - multi_horizon))
 
-            # 4. not sure we really want to do this
-            for domain in neighbors:
-                self.add_to_multi_recursive(domain, multi)
+                elif isinstance(neighbor, Multi):
+                    # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
+                    # So only the horizon and distance of the current single needs to be taken into account
+                    # Note: this is built on the assumption that the shell of a Multi has the size of the horizon.
+                    multi_horizon = (domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
+                    multi_partners.append((neighbor, dist_to_shell - multi_horizon))
+
+                else:
+                    if __debug__:
+                        assert False, 'add_to_multi_recursive: burst neighbor is not dt-zero NonInteractionSingle or Multi'
+
+            # 4. if the burst neighbors are still in the horizon -> add to multi
+            for neighbor, overlap in multi_partners:
+                if overlap < 0:
+                    self.add_to_multi_recursive(neighbor, multi)
 
         elif isinstance(domain, Multi):
             for pp in multi.particles:
@@ -2249,6 +2285,8 @@ def add_to_multi(self, single, multi):
         multi.add_shell(shell_id_shell_pair)
         multi.add_particle(single.pid_particle_pair)
 
+        # TODO maybe also cache the singles in the Multi for reuse?
+
     def merge_multis(self, multi1, multi2):
         # merge multi1 into multi2. multi1 will be removed.
         if __debug__:

From 1fa049c283cfe301a64295b335623669a481f490 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 1 Dec 2011 11:39:29 +0100
Subject: [PATCH 0420/1541] changed max number of n terms

---
 GreensFunction2DRadAbs.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 398c5154..e825cc2f 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -45,7 +45,7 @@ class GreensFunction2DRadAbs
 
     static const unsigned int MAX_ORDER = 30;		// The maximum number of m 
                                                     // terms
-    static const unsigned int MAX_ALPHA_SEQ = 2000;	// The maximum number of n 
+    static const unsigned int MAX_ALPHA_SEQ = 500;	// The maximum number of n 
                                                     // terms
     
     // Parameters for alpha-root finding

From fa33985ee0c8ec5587409a2e58675507aa7d9582 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 11:18:22 +0100
Subject: [PATCH 0421/1541] multiple changes: mostly revised function of
 burst_non_multi's to reflect new domain bursting strategy -burst_non_multi
 shouldn't burst domains in which no time has passed -small order change in
 form multi -changed comments

---
 egfrd.py | 89 ++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 64 insertions(+), 25 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ac0e4275..c4e39569 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -639,18 +639,41 @@ def burst_volume(self, pos, radius, ignore=[]):
         return self.burst_objs(neighbors)
 
     def burst_non_multis(self, domains):
+        # bursts the domains in 'domains' if appropriate
+        # -doesn't burst multi's
+        # -doesn't burst domains in which no time has passed
+        # -doesn't burst domains that were already a burst NonInteractionSingle
+        # Returns the list of burst (zero-dt) NonInteractionSingles and Multi's, and the list of domains
+        # unaffected by the procedure
+
         bursted = []
+        unbursted = []
+
+#        for domain in domains:
+#            if not isinstance(domain, Multi):
+#                # domain is Single or Pair of some subclass
+#                single_list = self.burst_domain(domain)
+#                bursted.extend(single_list)
+#            else:
+#                # domain is a Multi
+#                bursted.append(domain)
 
         for domain in domains:
-            if not isinstance(domain, Multi):
-                # domain is Single or Pair of some subclass
+            if isinstance(domain, Multi):
+                # domain is a Multi
+                bursted.append(domain)
+            elif (isinstance(domain, NonInteractionSingle) and domain.is_reset()):
+                bursted.append(domain)
+            elif self.t != domain.last_time:
+                # domain is some subclass of Single or Pair in which time has passed
                 single_list = self.burst_domain(domain)
                 bursted.extend(single_list)
             else:
-                # domain is a Multi
-                bursted.append(domain)
+                # domain is Single which is just made (no time passed) and is not reset, or
+                # domain is Pair which is just made (no time passed). -> do nothing
+                unbursted.append(domain)
 
-        return bursted
+        return bursted, unbursted
 
     def fire_single_reaction(self, single, reactant_pos):
         # This takes care of the identity change when a single particle decays into
@@ -1150,6 +1173,7 @@ def make_new_domain(self, single):
         burst = []
         if intruders:
 
+            # TODO replace this with burst_non_multis
             for domain, _ in intruders:
                 if not isinstance(domain, Multi) and \
                    not self.t == domain.last_time and \
@@ -2135,28 +2159,29 @@ def try_pair(self, single1, single2):
 
     def form_multi(self, single, multi_partners):
         # form a Multi with the 'single'
+
         # The 'multi_partners' are neighboring NonInteractionSingles, Multis and surfaces which
         # can be added to the Multi (this can also be empty)
-
-
-        # Filter out relevant neighbors if present
-        # only consider objects that are within the Multi horizon
-        neighbors = [obj for (obj, overlap) in multi_partners if overlap < 0]
-
-        for partner in neighbors:
+        for partner, overlap in multi_partners:
             assert ((isinstance(partner, NonInteractionSingle) and partner.is_reset()) or \
                     isinstance(partner, Multi) or \
                     isinstance(partner, PlanarSurface) or \
                     isinstance(partner, CylindricalSurface)), \
                     'multi_partner %s was not of proper type' % (partner)
 
+
+        # Only consider objects that are within the Multi horizon
+        # assume that the multi_partners are already sorted by overlap
+        neighbors = [obj for (obj, overlap) in multi_partners if overlap < 0]
+
+        # TODO there must be a nicer way to do this
         if neighbors:
             closest = neighbors[0]
         else:
             closest = None
 
 
-        # 1. Make new Multi if Necessary
+        # 1. Make new Multi if Necessary (optimization)
         if isinstance(closest, Multi):
         # if the closest to this Single is a Multi, reuse the Multi.
             multi = closest
@@ -2166,22 +2191,22 @@ def form_multi(self, single, multi_partners):
         # nothing. Create new Multi
             multi = self.create_multi()
 
-
-        # 2. Add the single and neighbors to the Multi
+        # 2. Add the single to the Multi
         self.add_to_multi(single, multi)
         self.remove_domain(single)
 
-        # add everything in the horizon to the multi
-        for neighbor in neighbors:
-            if (isinstance(neighbor, NonInteractionSingle) and neighbor.is_reset()) or \
-               isinstance(neighbor, Multi):
-                self.add_to_multi_recursive(neighbor, multi)
+
+        # Add all partner domains (multi and dt=0 NonInteractionSingles) in the horizon to the multi
+        for partner in neighbors:
+            if (isinstance(partner, NonInteractionSingle) and partner.is_reset()) or \
+               isinstance(partner, Multi):
+                self.add_to_multi_recursive(partner, multi)
             else:
                 # neighbor is a surface
-                log.debug('add_to_multi: object(%s) is surface, not added to multi.' % neighbor)
+                log.debug('add_to_multi: object(%s) is surface, not added to multi.' % partner)
 
 
-        # 3. Initialize and (re-)schedule
+        # 3. Initialize the multi and (re-)schedule
         multi.initialize(self.t)
         if isinstance(closest, Multi):
             # Multi existed before
@@ -2203,6 +2228,7 @@ def add_to_multi_recursive(self, domain, multi):
         if isinstance(domain, NonInteractionSingle):
             assert domain.is_reset()        # domain must be zero-dt NonInteractionSingle
 
+            # check that the particles were not already added to the multi previously
             if multi.has_particle(domain.pid_particle_pair[0]):
                 # Already in the Multi.
                 if __debug__:
@@ -2212,13 +2238,16 @@ def add_to_multi_recursive(self, domain, multi):
             dompos = domain.shell.shape.position
             
             # 1. burst to make space for the multi shell
-            # TODO this is expensive/stupid -> fix
             burstradius = domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
             neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(
                     dompos, burstradius, ignore=[domain.domain_id, multi.domain_id])
             neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
-            burst = self.burst_non_multis(neighbors)
+            # TODO this should only burst domains in which time has passed, it is assumed that other domains
+            # have been made 'socially', meaning that they leave enough space for this particle to make a multi
+            # shell without overlapping. neighbors should therefor contain no domains in which no time has passed
+            # TODO burst should contain all the domains in the neighborhood
+            burst, _ = self.burst_non_multis(neighbors)
 
             # 2. add domain to the multi
             self.add_to_multi(domain, multi)
@@ -2226,7 +2255,7 @@ def add_to_multi_recursive(self, domain, multi):
             self.remove_event(domain)
 
             # get distances to closest shell of burst neighbors
-#            neighbor_dists = self.obj_distance_array(dompos, burst)
+            # We want all zero-dt NonInteractionSingles and Multi's in the multi-horizon
             neighbors = [(burst_domain, self.domain_distance(dompos, burst_domain)) for burst_domain in burst]
 
             # 3. select neighbors in the 'multi_horizon' for adding to the multi
@@ -2258,18 +2287,28 @@ def add_to_multi_recursive(self, domain, multi):
                 if overlap < 0:
                     self.add_to_multi_recursive(neighbor, multi)
 
+
         elif isinstance(domain, Multi):
+
+            # check that the particles were not already added to the multi previously
             for pp in multi.particles:
                 if domain.has_particle(pp[0]):
                     if __debug__:
                         log.debug('%s already added. skipping.' % domain)
                     break
             else:
+                # 1.   No bursting is needed, since the shells in the multi already exist
+                # 2.   Add the domain (the partner multi) to the existing multi
                 self.merge_multis(domain, multi)
+
+                # 3/4. No neighbors are searched and recursively added since everything that was in the multi
+                #      horizon of the domain was already in the multi.
+
         else:
             # only NonInteractionSingles and Multi should be selected
             assert False, 'Trying to add non Single or Multi to Multi.'
 
+
     def add_to_multi(self, single, multi):
     # This method is similar to the 'create_' methods for pair and interaction, except it's now for a multi
     # adding a single to the multi instead of creating a pair or interaction out of single(s)

From f535923d34a1a3d7d5d0bbc97e6e46f52d3d644f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 11:41:31 +0100
Subject: [PATCH 0422/1541] changed comments in add_to_multi_recursive to clear
 up procedure

---
 egfrd.py | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c4e39569..1dbbc7b2 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2243,25 +2243,31 @@ def add_to_multi_recursive(self, domain, multi):
                     dompos, burstradius, ignore=[domain.domain_id, multi.domain_id])
             neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
-            # TODO this should only burst domains in which time has passed, it is assumed that other domains
+            # This should only burst domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
             # shell without overlapping. neighbors should therefor contain no domains in which no time has passed
-            # TODO burst should contain all the domains in the neighborhood
-            burst, _ = self.burst_non_multis(neighbors)
+
+            burst, non_bursted = self.burst_non_multis(neighbors)
+            # burst contains all the domains in the neighborhood that can be added to the multi
+            # -> zero-dt NonInteractionSingles and Multi's
+            # at this point there should be no domains in the multi_horizon that cannot be bursted
+            assert non_bursted == [], 'add_to_multi_recursive: unburstable domains in multi_horizon. %s' % \
+                                      non_bursted
 
             # 2. add domain to the multi
             self.add_to_multi(domain, multi)
             self.remove_domain(domain)
             self.remove_event(domain)
 
-            # get distances to closest shell of burst neighbors
-            # We want all zero-dt NonInteractionSingles and Multi's in the multi-horizon
+            # 3. select neighbors in the 'multi_horizon' for adding to the multi
+            # 3.1 get distances to closest shell of burst neighbors
+            # TODO clean this up! line below is not necessary!!
             neighbors = [(burst_domain, self.domain_distance(dompos, burst_domain)) for burst_domain in burst]
 
-            # 3. select neighbors in the 'multi_horizon' for adding to the multi
 #            neighbors = [burst[i] for i
 #                                  in (neighbor_dists <= burstradius).nonzero()[0]]
 
+            # 3.2 calculate if the domains are within the multi horizon
             multi_partners = []
             for neighbor, dist_to_shell in neighbors:
                 if (isinstance (neighbor, NonInteractionSingle) and neighbor.is_reset()):
@@ -2297,7 +2303,7 @@ def add_to_multi_recursive(self, domain, multi):
                         log.debug('%s already added. skipping.' % domain)
                     break
             else:
-                # 1.   No bursting is needed, since the shells in the multi already exist
+                # 1.   No bursting is needed, since the shells in the multi already exist and no space has be made
                 # 2.   Add the domain (the partner multi) to the existing multi
                 self.merge_multis(domain, multi)
 

From e2d5a820f0ba95912f18470f9d35644317ea6394 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 12:21:58 +0100
Subject: [PATCH 0423/1541] added get_neighbor_surface method

---
 shellcontainer.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/shellcontainer.py b/shellcontainer.py
index 4074b22f..50cbff9c 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -170,6 +170,13 @@ def filter_partners(self, neighbor_domains):
     def sort_domain_distance(self, neighbor_domains):
         return sorted(neighbor_domains, key=lambda domain_dist: domain_dist[1])
 
+    def get_neighbor_surfaces(self, position, ignores=[]):
+        # analogous to get_neighbor domains, this returns a list of (surface, distance) tuples
+
+        # TODO return a list of neighboring surfaces
+        surface, distance = get_closest_surface(self.world, position, ignores)
+        return [(surface, distance), ]
+
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # Get neighbor domains within given radius.
         # Note that the function returns a generator

From e784fac27112860e44d8fc2e09879423e9e8df82 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 14:07:52 +0100
Subject: [PATCH 0424/1541] added also MULTI_SHELL_FACTOR to Domain -> NOTE:
 Code duplication!!

---
 domain.py | 2 ++
 egfrd.py  | 1 +
 2 files changed, 3 insertions(+)

diff --git a/domain.py b/domain.py
index 0fd78d5c..f102085d 100644
--- a/domain.py
+++ b/domain.py
@@ -2,6 +2,7 @@
 
 import numpy
 import myrandom
+import math
 
 __all__ = [
     'Domain',
@@ -14,6 +15,7 @@ class Domain(object):
 # with an own domain_id
 
     SINGLE_SHELL_FACTOR = 2.0
+    MULTI_SHELL_FACTOR = math.sqrt(2)
 
     def __init__(self, domain_id):
         self.domain_id = domain_id      # identifier for this domain object
diff --git a/egfrd.py b/egfrd.py
index 1dbbc7b2..8f1908cb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -121,6 +121,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
                                                 # NonInteractionSingles to a Pair or Interaction. It also defines
                                                 # the radius in which the NonInteractionSingle will burst.
+                                                # NOTE THAT ABOVE CONSTANTS ARE ALSO IN domain.py
         self.MAX_NUM_DT0_STEPS = 1000
 
         self.MAX_TIME_STEP = 10

From 5cc3e4d8e59e97301d119d4a4c30fe2f5b9fd86f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 14:21:20 +0100
Subject: [PATCH 0425/1541] NonInteractionSingle shells now also make sure next
 nearest neighbors have enough space

---
 single.py | 34 +++++++++++++++++++++++++++-------
 1 file changed, 27 insertions(+), 7 deletions(-)

diff --git a/single.py b/single.py
index 152d22a2..8991651b 100644
--- a/single.py
+++ b/single.py
@@ -260,17 +260,37 @@ def get_max_shell_size(self, geometrycontainer, domains):
         # NonInteractionSingles on the dna and membrane this is quite inefficient-> want to
         # size in the appropriate coordinate (r or z).
         singlepos = self.pid_particle_pair[1].position
-        closest, distance_to_shell = \
-            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
-                                              ignores=[self.structure.id])
-
-        # 2. In case the nearest neighbor was a NonInteractionSingle we need to tweak the size
+#        closest, distance_to_shell = \
+#            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
+#                                              ignores=[self.structure.id])
+
+        neighbor_domains = geometrycontainer.get_neighbor_domains(singlepos, domains, ignore=[self.domain_id, ])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, ignores=[self.structure.id])
+        neighbors = neighbor_domains + neighbor_surfaces
+
+        # 2. Calculate the maximum allowed radius of the spherical domain
+        # check ALL domains, not just nearest neighbor but also next nearest etc, and get the nearest one.
+        # In case the neighbor was a NonInteractionSingle we may need to tweak the distance
+        distance_domain_closest = (numpy.inf, None)
+        for domain, distance in neighbors:
+            if isinstance(domain, NonInteractionSingle):
+                # leave at least MULTI_SHELL_FACTOR space for another NonInteractionSingle (to make sure that
+                # the other single will not have an overlapping multi shell when starting to multi
+                distance_max = geometrycontainer.world.distance(singlepos, domain.pid_particle_pair[1].position)
+                distance = min(distance, distance_max - domain.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR)
+                # TODO check this!
+
+            # get the minimum of currect and previous minimum
+            distance_domain = (distance, domain)
+            distance_domain_closest = min(distance_domain_closest, distance_domain)
+
+        distance_to_shell, closest = distance_domain_closest
+
+        # 3. Apply still other rules if the nearest is another NonInteractionSingle (optimization)
         # TODO shell size has no real meaning for cylinderical domains
         if isinstance(closest, NonInteractionSingle):
             new_shell_size = self.calculate_shell_size_to_single(closest, distance_to_shell,
                                                                  geometrycontainer)
-        # TODO This is incorrect. The closest can be a Pair but still NonInteractionSingles may need
-        # more space
         else:  # Pair or Multi or Surface
             new_shell_size = distance_to_shell / SAFETY
 

From 1312ac9a1356a9dfac5195444797b1ac1af18f6c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 14:52:20 +0100
Subject: [PATCH 0426/1541] Next nearest neighbors NonInteractionSingles now
 also get SINGLE_SHELL_FACTOR space from SimplePairs

---
 pair.py | 76 ++++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 46 insertions(+), 30 deletions(-)

diff --git a/pair.py b/pair.py
index 068835c6..f377bdc7 100644
--- a/pair.py
+++ b/pair.py
@@ -245,41 +245,20 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
 
         # TODO get_closest_obj searches the spherical surrounding although this doesn't make sence for
         # a 2D or 1D pair
-        closest, closest_distance = geometrycontainer.get_closest_obj(shell_center, domains, ignore=[single1.domain_id,
-                                                                      single2.domain_id],
-                                                                      ignores=[single1.structure.id])
-        if __debug__:
-            log.debug('Pair closest neighbor: %s, distance: %s' % \
-                      (closest, FORMAT_DOUBLE % closest_distance))
+#        closest, closest_distance = geometrycontainer.get_closest_obj(shell_center, domains, ignore=[single1.domain_id,
+#                                                                      single2.domain_id],
+#                                                                      ignores=[single1.structure.id])
+
+        neighbor_domains = geometrycontainer.get_neighbor_domains(shell_center, domains, ignore=[single1.domain_id, 
+                                                                  single2.domain_id])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, ignores=[single1.structure.id])
+        neighbors = neighbor_domains + neighbor_surfaces
 
-        # shortcut
-        # if closest_distance <0 then neighbor particle overlaps with center of mass ->
-        # neighboring particle is actually closer to the CoM than any of the two member particles
-        # this can happen because we also try to make pairs with the next nearest neighbor if the nearest
-        # neighbor fails
-        if closest_distance <= 0:
-            return 0
 
         # 3. Check if bursted Singles can still make a minimal shell.
         # TODO this is not correct. If the closest domain is not a NonInteractionSingle
         # we still have to make sure that the (non closest) NonInteractionSingles have
         # the required space
-        if isinstance(closest, NonInteractionSingle):
-            closest_particle_distance = geometrycontainer.world.distance(
-                    shell_center, closest.pid_particle_pair[1].position)
-
-            closest_min_radius = closest.pid_particle_pair[1].radius
-            closest_min_shell = closest_min_radius * Domain.SINGLE_SHELL_FACTOR
-
-            # options for shell size:
-            # a. upto the closest shell assuming that this shell is bigger than the minimum
-            # b. The distance to a bursted single including its minimal shell
-            shell_size = min(closest_distance, closest_particle_distance - closest_min_shell)
-            assert shell_size <= closest_distance
-
-        else:
-            assert isinstance(closest, (InteractionSingle, Pair, Multi, Surface, None.__class__))
-            shell_size = closest_distance 
 
         # FIXME Bloody ugly tweak to make sure that in case of a cylinder the 'maximum size' (which is
         # actually the radius) does not stick out of the maximum sphere (which is the real hard max).
@@ -287,7 +266,44 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
         sigma = max(single1.pid_particle_pair[1].radius, single2.pid_particle_pair[1].radius)
         max_shell_size = math.sqrt(geometrycontainer.get_max_shell_size()**2 - sigma**2)
 
-        return min(max_shell_size, shell_size)/SAFETY
+        distance_domain_closest = (max_shell_size, None)
+        for domain, distance in neighbors:
+
+            if isinstance(domain, NonInteractionSingle):
+                closest_particle_distance = geometrycontainer.world.distance(
+                        shell_center, domain.pid_particle_pair[1].position)
+
+                distance = min(distance,
+                               closest_particle_distance - domain.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR)
+
+                # options for shell size:
+                # a. upto the closest shell assuming that this shell is bigger than the minimum
+                # b. The distance to a bursted single including its minimal shell
+            distance_domain = (distance, domain)    
+            distance_domain_closest = min(distance_domain_closest, distance_domain)
+
+        closest_distance, closest = distance_domain_closest
+
+#                shell_size = min(closest_distance, closest_particle_distance - closest_min_shell)
+#                assert shell_size <= closest_distance
+#
+#            else:
+#                assert isinstance(closest, (InteractionSingle, Pair, Multi, Surface, None.__class__))
+#                shell_size = closest_distance 
+
+        if __debug__:
+            log.debug('Pair closest neighbor: %s, distance: %s' % \
+                      (closest, FORMAT_DOUBLE % closest_distance))
+
+        # shortcut
+        # if closest_distance <0 then neighbor particle overlaps with center of mass ->
+        # neighboring particle is actually closer to the CoM than any of the two member particles
+        # this can happen because we also try to make pairs with the next nearest neighbor if the nearest
+        # neighbor fails
+        if closest_distance <= 0:
+            return 0
+        else:
+            return closest_distance/SAFETY
 
 
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,

From 8a06081c6de9d64f93b150fdf63ed845d6de36d1 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 2 Dec 2011 16:12:35 +0100
Subject: [PATCH 0427/1541] Debugging modified greensfuctions.

---
 GreensFunction1DAbsAbs.cpp     | 103 +++++++++++++++++++++++++--------
 GreensFunction1DAbsAbs.hpp     |   1 +
 GreensFunction1DAbsSinkAbs.cpp |  97 ++++++++++++++-----------------
 GreensFunction1DAbsSinkAbs.hpp |  10 +++-
 GreensFunction1DRadAbs.cpp     |  60 +++++++++++++++++--
 GreensFunction1DRadAbs.hpp     |  11 ++--
 freeFunctions.cpp              |  54 ++++++++++++++---
 freeFunctions.hpp              |  12 +++-
 greens_functions.cpp           |   3 +
 9 files changed, 250 insertions(+), 101 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index cfa00c79..efa558da 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -71,10 +71,34 @@ GreensFunction1DAbsAbs::p_survival (Real t) const
 
     if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
     {
-	// The survival probability of a zero domain is zero
-	return 0.0;
+        // The survival probability of a zero domain is zero
+        return 0.0;
+    }
+
+    /* First check if we need full solution. 
+       Else we use approximation. */
+    const Real distToa( geta() - r0 );
+    const Real distTos( r0 - getsigma() );
+    const Real maxDist( CUTOFF_H * sqrt(2.0 * D * t) );
+    
+    //TODO: No drift included for approximations.
+    if( v == 0.0 )
+    {
+        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
+        {
+            if( distTos > maxDist )//And radiation boundary 'not in sight'.
+                return 1.0; //No prob. outflux.
+            else
+                return XS10(t, distTos, D); //Only absorbing BCn of s.
+        }
+        else
+        {
+            if( distTos > maxDist )
+                return XS10(t, distToa, D ); //Only absorbing BCn of a.
+        }
     }
 
+
     // Set values that are constant in this calculation
     const Real expo(-D*t/(L*L));   // part of the exponent -D n^2 PI^2 t / L^2
     const Real r0s(r0 - sigma);
@@ -389,7 +413,7 @@ Real GreensFunction1DAbsAbs::drawT_exponent_table( uint const& i,
         const Real expo(-D/(L*L));
         Real nPi;
 
-        if( v== 0)
+        if( v == 0.0 )
         {
             while(n++ < i)
             {
@@ -435,9 +459,8 @@ Real GreensFunction1DAbsAbs::drawT_Xn_table( uint const& i,
     
         const Real r0s_L((r0-sigma)/L);
 
-        if( v== 0)
+        if( v == 0.0 )
         {
-
             while(n++ < i)
             {
                 nPI = ((Real)(n+1))*M_PI;
@@ -471,19 +494,45 @@ Real GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
 {   
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
+    GreensFunction1DAbsAbs const* gf( params->gf );
+    const Real r0( gf->getr0() );
+
+    /* First check if we need full solution. 
+       Else we use approximation. */
+    const Real distToa( gf->geta() - r0 );
+    const Real distTos( r0 - gf->getsigma() );
+    const Real maxDist( CUTOFF_H * sqrt(2.0 * gf->getD() * t) );
     
+    //TODO: No drift included for approximations.
+    if( gf->getv() == 0.0 )
+    {
+        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
+        {
+            if( distTos > maxDist )//And radiation boundary 'not in sight'.
+                return params->rnd - 1.0; //No prob. outflux.
+            else  //Only absorbing BCn at s.
+                return params->rnd - XS10(t, distTos, gf->getD() );
+        }
+        else
+        {
+            if( distTos > maxDist ) //Only absorbing BCn at a.
+                return params->rnd - XS10(t, distToa, gf->getD() ); 
+        }
+    }
+    
+
     Real sum = 0, term = 0, prev_term = 0;
     Real Xn, exponent, prefactor;
     // the timescale used
     Real tscale = params->tscale;
 
-    const uint maxi( params->gf->guess_maxi( t ) );
+    const uint maxi( gf->guess_maxi( t ) );
 
     if( params->exponent_table.size() < maxi + 1 &&
         params->Xn_table.size() < maxi + 1 )
     {
-        IGNORE_RETURN params->gf->drawT_exponent_table( maxi, params->exponent_table );
-        IGNORE_RETURN params->gf->drawT_Xn_table( maxi, params->Xn_table );
+        IGNORE_RETURN gf->drawT_exponent_table( maxi, params->exponent_table );
+        IGNORE_RETURN gf->drawT_Xn_table( maxi, params->Xn_table );
     }
 
     uint n = 0;
@@ -497,8 +546,8 @@ Real GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
         }
         prev_term = term;
 
-        Xn = params->gf->drawT_Xn_table(n, params->Xn_table);
-        exponent = params->gf->drawT_exponent_table(n, params->exponent_table);
+        Xn = gf->drawT_Xn_table(n, params->Xn_table);
+        exponent = gf->drawT_exponent_table(n, params->exponent_table);
 
         term = Xn * exp(exponent * t);
         sum += term;
@@ -510,8 +559,13 @@ Real GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
 
     prefactor = params->prefactor;
     
+    
+    std::cerr << "S(" << t << ") = " << prefactor * sum << ", rnd = " << params->rnd 
+              << " " << params->rnd - prefactor*sum << std::endl;  
+    
+
     // find intersection with the random number
-    return params->rnd - prefactor*sum; 
+    return params->rnd - prefactor * sum; 
 }
 
 // Draws the first passage time from the propensity function.
@@ -536,7 +590,6 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     }
     else if ( L < 0.0 || fabs(a-r0) < EPSILON*L || fabs(r0-sigma) > (1.0 - EPSILON)*L )
     {
-        // if the domain had zero size
         return 0.0;
     }
 
@@ -545,7 +598,7 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     Real prefactor;
     
     // Find a good interval to determine the first passage time in
-    const Real dist( std::min(r0-sigma, a-r0) );
+    const Real dist( std::min(r0 - sigma, a - r0) );
 
     // construct a guess: MSD = sqrt (2*d*D*t)
     Real t_guess( dist * dist / ( 2.0 * D ) );
@@ -563,23 +616,16 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
       
     t_guess *= .1;
 
-    /* Guess number of terms needed for convergence */
-    const uint maxi( guess_maxi( t_guess ) );
-    
-    /* Build tables of factor not depending on t */
+    /* Set params structure. */
     RealVector exponent_table;
     RealVector Xn_table;
-    drawT_exponent_table( maxi, exponent_table );
-    drawT_Xn_table( maxi, Xn_table );
-
-    /* Set params structure. */
     struct drawT_params parameters = {this, exponent_table, Xn_table};
 
     // the prefactor of the sum is also different in case of drift<>0 :
-    if(v == 0)	
+    if(v == 0.0)	
         prefactor = 2.0;
     else	
-        prefactor = 2.0*exp(vexpo_pref);
+        prefactor = 2.0 * exp(vexpo_pref);
 
     parameters.prefactor = prefactor;
     
@@ -594,6 +640,8 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     Real low( t_guess );
     Real high( t_guess );
 
+    std::cerr << "F(" << t_guess << ") =  " << value << std::endl;
+
     if( value < 0.0 )
     {
 	// scale the interval around the guess such that the function 
@@ -642,6 +690,9 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
         while ( value >= 0.0 );
     }
 
+    std::cerr << "F(" << low << ") = " << value << std::endl;
+
+
     // find the intersection on the y-axis between the random number and 
     // the function
     // define a new solver type brent
@@ -746,7 +797,9 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     // From here on the problem is well defined
 
 
-    const Real thresholdDistance(this->CUTOFF_H * sqrt(2.0 * D * t));
+    const Real maxDist(CUTOFF_H * sqrt(2.0 * D * t));
+    const Real distToa( a - r0 - vt );
+    const Real distTos( r0 + vt - sigma );
 
     struct drawR_params parameters;
     gsl_function F;
@@ -755,7 +808,7 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
 
     const uint maxi( guess_maxi( t ) );
 
-    if ((r0 + vt - sigma) <= thresholdDistance || (a - r0 - vt) <= thresholdDistance)
+    if (distTos < maxDist || distToa < maxDist)
     {
         psurv = p_survival(t);
 
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 11ba98ee..e8a2c86b 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -22,6 +22,7 @@
 #include "Defs.hpp"
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "funcSum.hpp"
+#include "freeFunctions.hpp"
 
 #include "GreensFunction.hpp"
 #include "PairGreensFunction.hpp"	// needed to declare EventType
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index afc68aca..30410a7b 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -17,7 +17,6 @@
 #include <gsl/gsl_roots.h>
 
 #include "findRoot.hpp"
-#include "funcSum.hpp"
 #include "GreensFunction1DAbsSinkAbs.hpp"
 
 /* This is the appropriate definition of the function defining
@@ -96,8 +95,6 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
             lo_up_params.last_long_root = root_i;
         else
             lo_up_params.last_short_root = root_i;
-
-        std::cerr << "root#: " << rootList_size() << " - " << get_last_root() << std::endl;
     }
 
     gsl_root_fsolver_free( solver );
@@ -165,7 +162,7 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     /* f_lower must have correct sign. */
     if( f_lower * parity_op > 0 )
     {
-        std::cerr << "Parity error in lower of root# " << rootList_size() + 1 
+        std::cerr << "Parity error in x_lower of root# " << rootList_size() + 1 
                       << " in GF::AbsSinkAbs " << std::endl;
         std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
                   << upper << ") = " << f_upper << std::endl;
@@ -269,15 +266,9 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
     Real p;
 
     const Real D( getD() );
-    //const Real sigma(getsigma());
-    //const Real a( geta() );
-
-    //    const Real L0( getL0() );
-    //    const Real distToa(a - r0);
-    //    const Real distTos(r0 - sigma);
-
-    //    const Real H(6.0); // a fairly strict criterion for safety.
-    //    const Real maxDist(H * sqrt(2.0 * D * t));
+    const Real sigma(getsigma());
+    const Real a( geta() );
+    const Real L0( getL0() ); 
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
@@ -285,45 +276,26 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
 	    return 1.0;
     }
 
-    /*
-    if (distToa > maxDist)
+    /* First check if we need full solution. 
+       Else we use approximation. */
+    const Real maxDist(CUTOFF_H * sqrt(2.0 * D * t));
+    // dist to nearest absorbing boundary.
+    const Real distToAbs( std::min(a - r0, r0 -sigma) );
+
+    if( L0 > maxDist ) //Sink not in sight
     {
-        if (distTos > maxDist) // far from anything; it'll survive.
-        {
-            if( L0 > maxDist )
-                p = 1.0;
-        }
-        else // close only to s, ignore a
-        {
-            const Real sigma(this->getSigma());
-            const Real kf(this->getkf());
-            p = p_survival_irr(t, r0, kf, D, sigma);
-        }
+        if( distToAbs > maxDist )
+            return 1.0;
+        else
+            return XS10( t, distToAbs, D );  
     }
     else
     {
-        if (distTos > maxDist)  // close only to a.
-        {
-            p = p_survival_nocollision(t, r0, D, a);
-        }
-        else  // close to both boundaries.  do the normal calculation.
+        if( distToAbs > maxDist ) //Only sink in sight.
         {
-            const unsigned int maxi(guess_maxi(t));
-            
-            if (psurvTable.size() < maxi + 1)
-            {
-                IGNORE_RETURN getAlpha0(maxi);  // this updates the table
-                this->createPsurvTable(psurvTable);
-            }
-
-            p = funcSum_all(boost::bind(&GreensFunction3DRadAbs::
-                                          p_survival_i_exp_table, 
-                                          this,
-                                          _1, t, psurvTable),
-                             maxi);
+            return XS030( t, L0, getk(), getD() );
         }
     }
-    */
 
     const uint maxi( guess_maxi(t) );
     
@@ -548,8 +520,13 @@ Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
 Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 {
     const Real D( getD() );
-    Real p;
 
+    if( t == 0 || ( D == 0 && getr0() != getrsink() ) )
+    {
+        return 0.0;
+    }
+
+    Real p;
     const Real maxi( guess_maxi( t ) );
 
     p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_tot_i, 
@@ -635,6 +612,13 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll_i(uint i, Real const& t) const
    at time t */
 Real GreensFunction1DAbsSinkAbs::flux_sink(Real t) const
 {
+    const Real D( getD() );
+
+    if( t == 0 || ( D == 0 && getr0() != getrsink() ) )
+    {
+        return 0.0;
+    }
+
     return getk() * prob_r(getrsink(), t);
 }
 
@@ -698,6 +682,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     const Real a( geta() );    
     const Real r0( getr0() );
     const Real D( getD() );
+    //const Real k( getk() );
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L0( getL0() );
@@ -708,7 +693,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 	    return INFINITY;
     }
 
-    if ( rnd <= EPSILON || L < 0.0 || fabs( a - r0 ) < EPSILON * L )
+    if ( rnd > (1 - EPSILON) || L < 0.0 || fabs( a - r0 ) < EPSILON * L )
     {
 	    return 0.0;
     }
@@ -719,11 +704,12 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 
     /* Find a good interval to determine the first passage time.
        First we get the distance to one of the absorbing boundaries or the sink. */
-    Real t_guess;
     Real dist( std::min(Lr - L0, Ll + L0) );
-    dist = std::min( dist, L0 );
+    Real t_guess( dist * dist / ( 2.0 * D ) );
+
+    if( dist > 10 * L0 )
+        t_guess = std::min(D * 0.01 / ( k * k ), t_guess);
 
-    t_guess = dist * dist / ( 2.0 * D );
     t_guess *= .1;
 
     /* Define the function for the rootfinder */
@@ -745,8 +731,13 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
             // function straddles
             high *= 10;
             value = GSL_FN_EVAL( &F, high );
-            
-            if( fabs( high ) >= t_guess * 1e6 )
+
+            /*
+            std::cerr << "t: " << high << " maxDist: " << CUTOFF_H * sqrt(2.0 * D * high) <<
+                " f(t): " << value << std::endl;
+            */
+
+            if( fabs( high ) >= t_guess * 1e10 )
             {
                 std::cerr << "GF1DSink::drawTime Couldn't adjust high. F("
                           << high << ") = " << value << std::endl;
@@ -763,7 +754,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 	    Real value_prev( 2 );
 	    do
 	    {
-	        if( fabs( low ) <= t_guess * 1e-6 ||
+	        if( fabs( low ) <= t_guess * 1e-10 ||
 	            fabs(value-value_prev) < EPSILON*1.0 )
 	        {
 		    std::cerr << "GF1DSink::drawTime Couldn't adjust low. F(" << low << ") = "
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 742a69c9..f1f3ce8f 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -22,6 +22,8 @@
 #include "Defs.hpp"
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "GreensFunction.hpp"
+#include "funcSum.hpp"
+#include "freeFunctions.hpp"
 
 class GreensFunction1DAbsSinkAbs: public GreensFunction
 {
@@ -43,6 +45,10 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     static const uint MAX_TERMS = 500;
     // The minimum number of terms
     static const uint MIN_TERMS = 20;
+    /* Cutoff distance: When H * sqrt(2Dt) < a - r0 OR ro - sigma
+       use free greensfunction instead of absorbing. */
+    static const Real CUTOFF_H = 6.0;
+
 
 public:
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
@@ -269,7 +275,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
         else
         {
             calculate_n_roots( n );
-            return rootList[ n ];
+            return rootList.back();
         }
     }
 
@@ -299,7 +305,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     void createPsurvTable( RealVector& table ) const;
 
 
-    /* Functions for calculating thegreensfunction. */
+    /* Functions for calculating the greensfunction. */
     Real prob_r_r0_i(uint i, Real const& rr, Real const& t) const;
 
     Real prob_r_nor0_i( uint i, Real const& rr, Real const& t) const;
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 509f2778..137032bb 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -207,6 +207,7 @@ GreensFunction1DRadAbs::p_survival (Real t) const
     const Real L(this->geta()-this->getsigma());
     const Real r0_s(this->getr0() - this->getsigma());
     const Real h((this->getk()+this->getv()/2.0)/this->getD());
+    const Real r0( getr0() );
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
@@ -215,6 +216,28 @@ GreensFunction1DRadAbs::p_survival (Real t) const
         return 1.0;
     }
 
+    /* First check if we need full solution. 
+       Else we use approximation. */
+    const Real distToa( geta() - r0 );
+    const Real distTos( r0 - getsigma() );
+    const Real maxDist( CUTOFF_H * sqrt(2.0 * D * t) );
+
+    //TODO: No drift included for approximations.
+    if( v == 0.0 )
+    {
+        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
+        {
+            if( distTos > maxDist ) //Radiation boundary 'not in sight'.
+                return 1.0; //No prob. outflux.
+            else
+                return XS30(t, distTos, getk(), getD()); //Only radiation BCn.
+        }
+        else
+        {
+            if( distTos > maxDist )
+                return XS10(t, distToa, getD() ); //Only absorbing BCn.
+        }
+    }
 
     Real root_n;
     Real sum = 0, term = 0, term_prev = 0;
@@ -502,7 +525,7 @@ Real GreensFunction1DRadAbs::drawT_Xn_table( uint const& i,
 
         Real root_n, root_n2, root_n_r0_s, root_n_L, h_root_n;	  
 
-        if( v== 0)
+        if( v == 0.0)
         {
             while(n++ < i)
             {
@@ -550,17 +573,44 @@ double GreensFunction1DRadAbs::drawT_f (double t, void *p)
 {
     // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
+    GreensFunction1DRadAbs const* gf = params->gf;
+    const Real r0( gf->getr0() );
+
+    /* First check if we need full solution. 
+       Else we use approximation. */
+    const Real distToa( gf->geta() - r0 );
+    const Real distTos( r0 - gf->getsigma() );
+    const Real maxDist( CUTOFF_H * sqrt(2.0 * gf->getD() * t) );
+    
+    //TODO: No drift included for approximations.
+    if( gf->getv() == 0.0 )
+    {
+        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
+        {
+            if( distTos > maxDist )//And radiation boundary 'not in sight'.
+                return params->rnd - 1.0; //No prob. outflux.
+            else
+                return params->rnd - XS30(t, distTos, gf->getk(), gf->getD()); //Only radiation BCn.
+        }
+        else
+        {
+            if( distTos > maxDist )
+                return params->rnd - XS10(t, distToa, gf->getD() ); //Only absorbing BCn.
+        }
+    }
+
+
     Real Xn = 0, exponent = 0;
     Real prefactor = params->prefactor;
 
-    const uint maxi( params->gf->guess_maxi( t ) );
+    const uint maxi( gf->guess_maxi( t ) );
     
     if( params->exponent_table.size() < maxi + 1 &&
         params->Xn_table.size() < maxi + 1 )
     {
         params->gf->calculate_n_roots( maxi );
-        IGNORE_RETURN params->gf->drawT_exponent_table( maxi, params->exponent_table );
-        IGNORE_RETURN params->gf->drawT_Xn_table( maxi, params->Xn_table );
+        IGNORE_RETURN gf->drawT_exponent_table( maxi, params->exponent_table );
+        IGNORE_RETURN gf->drawT_Xn_table( maxi, params->Xn_table );
     }
 
     Real sum = 0, term = 0, prev_term = 0;
@@ -611,7 +661,7 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
         return INFINITY;
     }
 
-    if ( rnd <= EPSILON || L < 0.0 || fabs(a-r0) < EPSILON*L )
+    if ( rnd > 1 - EPSILON || L < 0.0 || fabs(a-r0) < EPSILON*L )
     {
         return 0.0;
     }
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index d629ac9b..72f7f684 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -20,6 +20,7 @@
 
 #include "findRoot.hpp"
 #include "funcSum.hpp" 
+#include "freeFunctions.hpp"
 #include "Defs.hpp"
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "GreensFunction.hpp"
@@ -43,6 +44,9 @@ class GreensFunction1DRadAbs: public GreensFunction
     static const uint MAX_TERMS = 500;
     // The minimum number of terms
     static const uint MIN_TERMS = 20;
+    /* Cutoff distance: When H * sqrt(2Dt) < a - r0 OR ro - sigma
+       use free greensfunction instead of absorbing. */
+    static const Real CUTOFF_H = 6.0;
 
 public:
     GreensFunction1DRadAbs(Real D, Real k, Real r0, Real sigma, Real a)
@@ -185,9 +189,6 @@ class GreensFunction1DRadAbs: public GreensFunction
     {
         return "GreensFunction1DRadAbs";
     }
-
-    // Calculates the roots of tan(a*x)=-xk/h
-    Real root_n(int n) const;
     
 private:
 
@@ -237,8 +238,8 @@ class GreensFunction1DRadAbs: public GreensFunction
             return rootList[ n ];
         else
         {
-            root_n( n );
-            return rootList[ n ];
+            calculate_n_roots( n );
+            return rootList.back();
         }
     }
 
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index 09ef8085..bdf5da4c 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -65,7 +65,7 @@ Real W(Real a, Real b)
 
 /* List of 1D functions used as approximations for the greensfunctions
    of the full domain. For small t, a particle only scans part of the domain
-   and thus not al the boundary conditions have to be included. Because the
+   and thus not all the boundary conditions have to be included. Because the
    greensfunctions converge bad for small t, we use these approximations.
 
    note: drift not included yet!
@@ -84,6 +84,10 @@ Real W(Real a, Real b)
    1 - Absorbing boundary.
    2 - Reflective boundary.
    3 - Radiation boundary with rate ka.
+
+   Approximation for greensfunction with sink has 3 boundaries: 030
+   left absorbing boundary, sink, right absorbing boundary.
+   
  */
 
 Real XP00( Real r, Real t, Real r0, Real D )
@@ -104,7 +108,7 @@ Real XI00( Real r, Real t, Real r0, Real D )
 }
 
 
-Real XS00( Real r, Real t, Real r0, Real D )
+Real XS00( Real t, Real r0, Real D )
 {
     return 1;
 }
@@ -134,7 +138,7 @@ Real XI10( Real r, Real t, Real r0, Real D )
 }
 
 
-Real XS10( Real r, Real t, Real r0, Real D )
+Real XS10( Real t, Real r0, Real D )
 {
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
 
@@ -175,13 +179,15 @@ Real XP30term( Real r, Real t, Real r0, Real ka, Real D )
     const Real k_D( ka / D );
     const Real rplusr02( gsl_pow_2( r + r0 ) );
     const Real arg( (r + r0)/sqrt(fourDt) + ka * sqrt( t / D ) );
-        
+    r0 = fabs( r0 );
+
     return -k_D * exp( - rplusr02 / fourDt ) * expxsq_erfc( arg );
 }
 
 
 Real XP30( Real r, Real t, Real r0, Real ka, Real D )
-{        
+{
+    r0 = fabs( r0 );
     return XP20(r, t, r0, D) + XP30term(r, t, r0, ka, D);
 }
 
@@ -190,13 +196,15 @@ Real XI30term( Real r, Real t, Real r0, Real ka, Real D )
 {
     const Real sqrt4Dt( sqrt(4 * D * t) );
     const Real k_D( ka / D );
-    const Real rplusr02( gsl_pow_2( r + r0 ) );
+    r0 = fabs( r0 );
         
     const Real term1( erf( r0/sqrt4Dt ) - erf( (r+r0)/sqrt4Dt ) );
 
-    const Real term2( exp( k_D * (ka * t + r0) ) * erfc( (2 * ka * t + r0)/sqrt4Dt ) );
+    const Real term2( exp( k_D * (ka * t + r0) ) * 
+                      erfc( (2 * ka * t + r0)/sqrt4Dt ) );
 
-    const Real term3( exp( k_D * (ka * t + r0 + r) ) * erfc( (2 * ka * t + r0 + r)/sqrt4Dt ) );
+    const Real term3( exp( k_D * (ka * t + r0 + r) ) * 
+                      erfc( (2 * ka * t + r0 + r)/sqrt4Dt ) );
 
     return term1 + term2 - term3;
 }
@@ -204,6 +212,7 @@ Real XI30term( Real r, Real t, Real r0, Real ka, Real D )
 
 Real XI30( Real r, Real t, Real r0, Real ka, Real D )
 {
+    r0 = fabs( r0 );
     return XI20(r, t, r0, D) + XI30term(r, t, r0, ka, D);
 }
 
@@ -212,12 +221,41 @@ Real XS30( Real t, Real r0, Real ka, Real D )
 {
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
     const Real k_D( ka / D );
+    r0 = fabs( r0 );
 
     return erf( r0 / sqrt4Dt ) + 
         exp( k_D * ka * t + k_D * r0 ) * erfc( (2 * ka * t + r0) / sqrt4Dt );
 }
 
 
+Real XP030( Real r, Real t, Real r0, Real ka, Real D )
+{
+    r0 = fabs( r0 );
+
+    return XP00(r, t, r0, D) + .5 * XP30term(fabs(r), t, r0, .5 * ka, D);
+}
+
+
+Real XI030( Real r, Real t, Real r0, Real ka, Real D )
+{
+    ka *= .5;
+    r0 = fabs( r0 );
+    Real sign( 1 );
+
+    if( r < 0 )
+        sign *= -1;
+
+    return XI00(r, t, r0, D) + .5 * ( ( XS30(t, r0, ka, D) - 1 ) + 
+                                      sign * XI30term( fabs(r), t, r0, ka, D ) );
+}
+
+
+Real XS030( Real t, Real r0, Real ka, Real D )
+{
+    return XS30( t, fabs( r0 ), 0.5 * ka, D );
+}
+
+
 Real __p_irr(Real r, Real t, Real r0, Real kf, Real D, Real sigma, Real alpha)
 {
     //  printf("irrp %.16g %.16g %.16g\n",r,r0,t);
diff --git a/freeFunctions.hpp b/freeFunctions.hpp
index 6221ab57..a81eb329 100644
--- a/freeFunctions.hpp
+++ b/freeFunctions.hpp
@@ -14,19 +14,19 @@ Real XP00( Real r, Real t, Real r0, Real D );
 
 Real XI00( Real r, Real t, Real r0, Real D );
 
-Real XS00( Real r, Real t, Real r0, Real D );
+Real XS00( Real t, Real r0, Real D );
 
 Real XP10( Real r, Real t, Real r0, Real D );
 
 Real XI10( Real r, Real t, Real r0, Real D );
 
-Real XS10( Real r, Real t, Real r0, Real D );
+Real XS10( Real t, Real r0, Real D );
 
 Real XP20( Real r, Real t, Real r0, Real D );
 
 Real XI20( Real r, Real t, Real r0, Real D );
 
-Real XS20( Real r, Real t, Real r0, Real D );
+Real XS20( Real t, Real r0, Real D );
 
 Real XP30term( Real r, Real t, Real r0, Real ka, Real D );
 
@@ -38,6 +38,12 @@ Real XI30( Real r, Real t, Real r0, Real ka, Real D );
 
 Real XS30( Real t, Real r0, Real ka, Real D );
 
+Real XP030( Real r, Real t, Real r0, Real ka, Real D );
+
+Real XI030( Real r, Real t, Real r0, Real ka, Real D );
+
+Real XS030( Real t, Real r0, Real ka, Real D );
+
 /* 3D functions below. */
 
 Real p_irr(Real r, Real t, Real r0, Real kf, Real D, Real sigma);
diff --git a/greens_functions.cpp b/greens_functions.cpp
index c4d2c7ff..2eb9e8ec 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -23,6 +23,9 @@ BOOST_PYTHON_MODULE( _greens_functions )
 
     //import_array();
     // free functions
+    def( "XP030", XP030 );
+    def( "XS030", XS030 );
+    def( "XI030", XI030 );
     def( "p_irr", p_irr );
     def( "p_survival_irr", p_survival_irr );
     def( "p_theta_free", p_theta_free );

From f1fe57dcd86ddfb0e4fc9297979fc0ea8317f237 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 17:08:02 +0100
Subject: [PATCH 0428/1541] fixed numerical error in position for singles

---
 single.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/single.py b/single.py
index 8991651b..bdf4b538 100644
--- a/single.py
+++ b/single.py
@@ -354,6 +354,11 @@ def create_new_shell(self, position, radius, domain_id):
 
         # Note that the calculateion of the position of the shell needs to make sure that the
         # coordinates are in the surface
+        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
+        pos_x = self.structure.shape.unit_x * numpy.dot (position, self.structure.shape.unit_x)
+        pos_y = self.structure.shape.unit_y * numpy.dot (position, self.structure.shape.unit_y)
+
+        position = self.structure.shape.position + pos_x + pos_y
         orientation = self.structure.shape.unit_z
         half_length = self.pid_particle_pair[1].radius
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 
@@ -408,10 +413,13 @@ def create_new_shell(self, position, half_length, domain_id):
         # unbinding reaction we still have to clear the target volume 
         # and the move may be rejected.
 
-        unit_z = self.structure.shape.unit_z
-
         # Note that the calculation of the position of the shell has to make sure that the
         # coordinates are in the surface
+        unit_z = self.structure.shape.unit_z
+        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
+        pos_z = unit_z * numpy.dot (position, unit_z)
+
+        position = self.structure.shape.position + pos_z
         radius = self.pid_particle_pair[1].radius
         orientation = unit_z
         return CylindricalShell(self.domain_id, Cylinder(position, radius, 

From 798f0fdcfd4fb853e311756da05977dfe9d59a14 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 2 Dec 2011 17:15:28 +0100
Subject: [PATCH 0429/1541] Removed stupid bug.

---
 GreensFunction1DAbsAbs.cpp | 22 ++++++++--------------
 GreensFunction1DRadAbs.cpp |  9 ++++++---
 2 files changed, 14 insertions(+), 17 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index efa558da..00bcf02c 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -415,20 +415,22 @@ Real GreensFunction1DAbsAbs::drawT_exponent_table( uint const& i,
 
         if( v == 0.0 )
         {
-            while(n++ < i)
+            while(n < i)
             {
                 nPi = ((Real)(n+1)) * M_PI;
                 table.push_back( nPi * nPi * expo );
+                n++;
             }
         }
         else
         {
             const Real vexpo_t(-v*v/4.0/D);
 
-            while(n++ < i)
+            while(n < i)
             {
                 nPi = ((Real)(n+1)) * M_PI;
                 table.push_back( nPi * nPi * expo + vexpo_t );
+                n++;
             }
         }
 
@@ -461,11 +463,12 @@ Real GreensFunction1DAbsAbs::drawT_Xn_table( uint const& i,
 
         if( v == 0.0 )
         {
-            while(n++ < i)
+            while(n < i)
             {
                 nPI = ((Real)(n+1))*M_PI;
                 table.push_back( sin( nPI * r0s_L ) 
                                  * (1.0 - cos(nPI)) / nPI );
+                n++;
             }
         }
         else
@@ -474,11 +477,12 @@ Real GreensFunction1DAbsAbs::drawT_Xn_table( uint const& i,
             const Real av2D(a*v/2.0/D);
             const Real Lv2D(L*v/2.0/D);
 
-            while(n++ < i)
+            while(n < i)
             {
                 nPI = ((Real)(n+1))*M_PI;
                 table.push_back( (exp(sigmav2D) - cos(nPI)*exp(av2D)) * 
                                  nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L) );
+                n++;
             }
         }
         return table.back();
@@ -559,11 +563,6 @@ Real GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
 
     prefactor = params->prefactor;
     
-    
-    std::cerr << "S(" << t << ") = " << prefactor * sum << ", rnd = " << params->rnd 
-              << " " << params->rnd - prefactor*sum << std::endl;  
-    
-
     // find intersection with the random number
     return params->rnd - prefactor * sum; 
 }
@@ -640,8 +639,6 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     Real low( t_guess );
     Real high( t_guess );
 
-    std::cerr << "F(" << t_guess << ") =  " << value << std::endl;
-
     if( value < 0.0 )
     {
 	// scale the interval around the guess such that the function 
@@ -690,9 +687,6 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
         while ( value >= 0.0 );
     }
 
-    std::cerr << "F(" << low << ") = " << value << std::endl;
-
-
     // find the intersection on the y-axis between the random number and 
     // the function
     // define a new solver type brent
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 137032bb..e15d1a68 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -494,10 +494,11 @@ Real GreensFunction1DRadAbs::drawT_exponent_table( uint const& i,
         const Real vexpo_t(-v2/4.0/D);
         Real root_n2;
 
-        while(n++ < i)
+        while(n < i)
         {
             root_n2 = gsl_pow_2( get_root( n ) );
             table.push_back( -D * root_n2 + vexpo_t );
+            n++;
         }
         
         return table.back();
@@ -527,7 +528,7 @@ Real GreensFunction1DRadAbs::drawT_Xn_table( uint const& i,
 
         if( v == 0.0)
         {
-            while(n++ < i)
+            while(n < i)
             {
                 root_n      = get_root(n);	
                 root_n2	    = root_n * root_n;
@@ -538,6 +539,7 @@ Real GreensFunction1DRadAbs::drawT_Xn_table( uint const& i,
                 table.push_back( (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) 
                                  / (L*(root_n2+h*h)+h) * ( h_root_n + sin(root_n_L) 
                                                            - h_root_n*cos(root_n_L) ) );
+                n++;
             }
         }
         else
@@ -546,7 +548,7 @@ Real GreensFunction1DRadAbs::drawT_Xn_table( uint const& i,
             const Real exp_av2D(exp(a*v2D));
             const Real exp_sigmav2D(exp(sigma*v2D));
 
-            while(n++ < i)
+            while(n < i)
             {
                 root_n      = get_root(n);	
                 root_n2	    = root_n * root_n;
@@ -560,6 +562,7 @@ Real GreensFunction1DRadAbs::drawT_Xn_table( uint const& i,
                                                         cos(root_n_L)) / 
                                  (h_root_n * (root_n2 + v2D*v2D))  
                                  );
+                n++;
             }
         }
         return table.back();

From c5cc6d1ed09bb5728de238aa2f195c2c6950b7e6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 17:58:07 +0100
Subject: [PATCH 0430/1541] fixed silly typo

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index f377bdc7..10c943a5 100644
--- a/pair.py
+++ b/pair.py
@@ -713,7 +713,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
         # project the new_iv down on the unit vectors of the surface to prevent the particle from
         # leaving the surface due to numerical problem
-        unit_z = self.surface.shape.unit_z
+        unit_z = self.structure.shape.unit_z
         new_iv_z = unit_z * numpy.dot(new_iv, unit_z)
 
         return new_iv_z

From 9416d91065342d39b87d6fddb94ef62decd7d79a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 2 Dec 2011 19:07:36 +0100
Subject: [PATCH 0431/1541] removed code + moved comment

---
 egfrd.py | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8f1908cb..f1bb560f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2435,17 +2435,8 @@ def check_domain(self, domain):
 
 
 
-        # TODO maybe don't check all the shells, this takes a lot of time
         for shell_id, shell in domain.shell_list:
 
-#            closest, distance = self.geometrycontainer.get_closest_obj(shell.shape.position,
-#                                                                       self.domains,
-#                                                                       ignore=[domain.domain_id],
-#                                                                       ignores=ignores)
-
-#            distance_midpoints = self.world.distance(domain.shell.shape.position, closest.shell.shape.position)
-#            distance_midpoints = 0
-
             # TODO should be replace by list of surface
             surface, distance = get_closest_surface(self.world, shell.shape.position, ignores)
             if surface:
@@ -2458,6 +2449,7 @@ def check_domain(self, domain):
 
             neighbors = self.geometrycontainer.get_neighbor_domains(shell.shape.position,
                                                                     self.domains, ignore=[domain.domain_id])
+            # TODO maybe don't check all the shells, this takes a lot of time
 
             # testing overlap criteria
             for neighbor, _ in neighbors:

From 8d58138cd81383774858de5019f091b6e4db305b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Sat, 3 Dec 2011 22:19:57 +0100
Subject: [PATCH 0432/1541] p_survival and drawT function are now the same.

---
 GreensFunction1DAbsAbs.cpp     | 438 ++++++++++++---------------------
 GreensFunction1DAbsAbs.hpp     |  15 +-
 GreensFunction1DAbsSinkAbs.cpp |   6 +-
 GreensFunction1DRadAbs.cpp     | 429 ++++++++++++--------------------
 GreensFunction1DRadAbs.hpp     |  31 ++-
 5 files changed, 342 insertions(+), 577 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 00bcf02c..f71d0b85 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -4,6 +4,8 @@
 #include <exception>
 #include <vector>
 
+#include <boost/bind.hpp>
+#include <boost/format.hpp>
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_sf_trig.h>
 #include <gsl/gsl_sum.h>
@@ -55,13 +57,21 @@ uint GreensFunction1DAbsAbs::guess_maxi(Real const& t) const
     return std::min(maxi, MAX_TERMS);
 }
 
-// Calculates the probability of finding the particle inside the domain at 
-// time t
-Real
-GreensFunction1DAbsAbs::p_survival (Real t) const
+
+Real GreensFunction1DAbsAbs::p_survival(Real t) const
+{
+    RealVector table;
+    return p_survival_table(t, table);
+}
+
+/* Calculates survival probability using a table. 
+   Switchbox for which greensfunction to use. */
+Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
 
+    Real p;
+
     const Real a(this->geta());
     const Real sigma(this->getsigma());
     const Real L(this->geta() - this->getsigma());
@@ -75,6 +85,12 @@ GreensFunction1DAbsAbs::p_survival (Real t) const
         return 0.0;
     }
 
+    if (t == 0.0 || (D == 0.0 && v == 0.0) )
+    {
+	    //particle can't escape.
+	    return 1.0;
+    }
+
     /* First check if we need full solution. 
        Else we use approximation. */
     const Real distToa( geta() - r0 );
@@ -98,81 +114,107 @@ GreensFunction1DAbsAbs::p_survival (Real t) const
         }
     }
 
+    const uint maxi( guess_maxi(t) );
+    
+    if( maxi == MAX_TERMS )
+        std::cerr << "1DAbs::drawT: maxi was cut to MAX_TERMS for t = " 
+                  << t << std::endl;
+    
+    if (psurvTable.size() < maxi)
+    {
+        createPsurvTable( maxi, psurvTable );
+    }
 
-    // Set values that are constant in this calculation
-    const Real expo(-D*t/(L*L));   // part of the exponent -D n^2 PI^2 t / L^2
-    const Real r0s(r0 - sigma);
-    const Real r0s_L(r0s/L);
+    p = funcSum_all(boost::bind(&GreensFunction1DAbsAbs::p_survival_i, 
+                                this, _1, t, psurvTable),
+                    maxi);
     
-    // some abbreviations for terms appearing in the sums with drift<>0
+    if( v == 0.0 )
+    {   
+        p *= 2.0;
+    }
+    else
+    {       
+        const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+        p *= 2.0 * exp( vexpo );
+    }
+
+    return p;
+}
+
+
+/* Calculates the i'th term of the p_survival sum */
+Real GreensFunction1DAbsAbs::p_survival_i( uint i, 
+                                           Real const& t, 
+                                           RealVector const& table) const
+{
+    return exp( - getD() * t * gsl_pow_2( (i + 1) * M_PI ) ) * table[ i ];
+}
+
+
+/* Calculates the part of the i'th term of p_surv not dependent on t, with drift */
+Real GreensFunction1DAbsAbs::p_survival_table_i_v( uint const& i ) const
+{
+    Real nPI( ((Real)(i+1))*M_PI );
+
+    const Real sigma(this->getsigma());
+    const Real L(this->geta() - this->getsigma());
+    const Real r0(this->getr0());
+    const Real D(this->getD());
+    const Real v(this->getv());
+    
+    const Real r0s_L((r0-sigma)/L);
+
     const Real sigmav2D(sigma*v/2.0/D);
     const Real av2D(a*v/2.0/D);
     const Real Lv2D(L*v/2.0/D);
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);	// exponent of the drift-prefactor
-    
+        
+    return ( exp(sigmav2D) - cos(nPI)*exp(av2D) ) * 
+        nPI/( Lv2D * Lv2D + nPI * nPI ) * sin(nPI*r0s_L);
+}
 
-    // Initialize summation
-    Real sum = 0, term = 0, prev_term = 0;
+
+/* Calculates the part of the i'th term of p_surv not dependent on t, without drift */
+Real GreensFunction1DAbsAbs::p_survival_table_i_nov( uint const& i ) const
+{
     Real nPI;
 
+    const Real sigma(this->getsigma());
+    const Real L(this->geta() - this->getsigma());
+    const Real r0(this->getr0());
+    
+    const Real r0s_L((r0-sigma)/L);
+        
+    nPI = ((Real)(i+1))*M_PI;
+    return sin( nPI * r0s_L ) * (1.0 - cos(nPI)) / nPI;
+}
 
-    // Sum
-    Real n = 1;
-    // different calculations depending on whether v=0 or not
-    if(v==0.0)	// case without drift (v==0); in this case the summation is simpler, so do the complicated caluclation only if necessary
+
+/* Fills table with terms in the p_survival sum which don't depend on t */
+void GreensFunction1DAbsAbs::createPsurvTable( uint const& maxi, RealVector& table) const
+{
+    uint i( table.size() );
+
+    if( getv() == 0.0 )
     {
-      do
-      {
-          if (n >= MAX_TERMS )
-          {
-              std::cerr << "Too many terms for GF1DAbs::p_survival. N: " << n << std::endl;
-              break;
-          }
-	  
-          prev_term = term;
-          nPI = (Real)n*M_PI;
-          term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * (1.0 - cos(nPI)) / nPI;
-          sum += term;
-          n++;
-      }
-      // Is 1 a good measure or will this fail at some point?
-      while (	fabs(term/sum) > EPSILON*1.0 ||
-                fabs(prev_term/sum) > EPSILON*1.0 ||
-                n < MIN_TERMS );
-
-      sum = 2.0 * sum;	// This is a prefactor of every term, so do only one multiplication here
-    }
-    else	// case with drift (v<>0)
+        while( i < maxi )
+        {
+            table.push_back( p_survival_table_i_nov( i++ ) );
+        }
+    }
+    else
     {
-        do
+        while( i < maxi )
         {
-            if (n >= MAX_TERMS )
-            {
-                std::cerr << "Too many terms for p_survival. N: " << n << std::endl;
-                break;
-            }
-	  
-            nPI = (Real)n*M_PI;
-            prev_term = term;
-            term = exp(nPI*nPI*expo) * (exp(sigmav2D) - cos(nPI)*exp(av2D)) * nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L);
-            sum += term;
-            n++;
+            table.push_back( p_survival_table_i_v( i++ ) );
         }
-        // TODO: Is 1 a good measure or will this fail at some point?
-        while (	fabs(term/sum) > EPSILON*1.0 ||
-                fabs(prev_term/sum) > EPSILON*1.0 ||
-                n < MIN_TERMS );
-      
-        sum = 2.0 * exp(vexpo) * sum;	// prefactor containing the drift
     }
-
-    return sum;
 }
 
-// Calculates the probability density of finding the particle at location r at 
-// time t.
-Real
-GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
+
+/* Calculates the probability density of finding the particle at location r at 
+   time t. */
+Real GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= (r-sigma) && r <= a );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
@@ -213,7 +255,7 @@ GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     Real sum = 0, term = 0, prev_term = 0;
 
     // Sum
-    uint n = 1;
+    uint n = 0;
     do
     {
         if (n >= MAX_TERMS )
@@ -224,27 +266,29 @@ GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
 
         prev_term = term;
 
-        nPI = n*M_PI;
-        term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * sin(nPI*rs_L);
+        nPI = (n + 1) * M_PI;
+        term = exp( nPI*nPI*expo ) * sin( nPI * r0s_L ) * sin( nPI * rs_L );
         sum += term;
         n++;
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n <= MIN_TERMS);
+           n < MIN_TERMS);
 
     return 2.0/L * exp(vexpo) * sum;
 }
 
-// Calculates the probability density of finding the particle at location r at 
-// timepoint t, given that the particle is still in the domain.
+
+/* Calculates the probability density of finding the particle at location r at 
+   timepoint t, given that the particle is still in the domain. */
 Real
 GreensFunction1DAbsAbs::calcpcum (Real r, Real t) const
 {
     return prob_r(r, t) / p_survival(t);
 }
 
-// Calculates the amount of flux leaving the left boundary at time t
+
+/* Calculates the amount of flux leaving the left boundary at time t */
 Real
 GreensFunction1DAbsAbs::leaves(Real t) const
 {
@@ -269,7 +313,6 @@ GreensFunction1DAbsAbs::leaves(Real t) const
         return 0.0;
     }
 
-
     Real sum = 0, term = 0, prev_term = 0;
     Real nPI;
     const Real D_L_sq(D/(L*L));
@@ -277,7 +320,7 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     const Real r0s_L((r0-sigma)/L);
     const Real vexpo(-v*v*t/4.0/D - v*(r0-sigma)/2.0/D);
     
-    Real n = 1;
+    Real n = 0;
     do
     {
         if (n >= MAX_TERMS )
@@ -286,9 +329,9 @@ GreensFunction1DAbsAbs::leaves(Real t) const
             break;
         }
 
-        nPI = n*M_PI;
+        nPI = (n + 1) * M_PI;
         prev_term = term;
-        term = nPI * exp(nPI*nPI*expo) * sin(nPI*r0s_L);
+        term = nPI * exp( nPI * nPI * expo) * sin( nPI * r0s_L );
         sum += term;
         n++;
     }
@@ -296,7 +339,7 @@ GreensFunction1DAbsAbs::leaves(Real t) const
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
            n < MIN_TERMS );
 
-    return 2.0*D_L_sq * exp(vexpo) * sum;
+    return 2.0 * D_L_sq * exp( vexpo ) * sum;
 }
 
 // Calculates the amount of flux leaving the right boundary at time t
@@ -332,7 +375,7 @@ GreensFunction1DAbsAbs::leavea(Real t) const
     const Real r0s_L((r0-sigma)/L);
     const Real vexpo(-v*v*t/4.0/D + v*(a-r0)/2.0/D);
     
-    Real n=1;
+    Real n = 0;
     do
      {
          if (n >= MAX_TERMS )
@@ -341,9 +384,9 @@ GreensFunction1DAbsAbs::leavea(Real t) const
              break;
          }
        
-         nPI = n*M_PI;
+         nPI = (n + 1) * M_PI;
          prev_term = term;
-         term = nPI * exp(nPI*nPI*expo) * cos(nPI) * sin(nPI*r0s_L);
+         term = nPI * exp( nPI * nPI * expo ) * cos( nPI ) * sin( nPI * r0s_L );
          sum += term;
          n++;
      }
@@ -354,10 +397,10 @@ GreensFunction1DAbsAbs::leavea(Real t) const
      return - 2.0 * D_L_sq * exp(vexpo) * sum;
 }
 
-// This draws an eventtype of time t based on the flux through the left (z=sigma) 
-// and right (z=a) boundary. Although not completely accurate, it returns an 
-// IV_ESCAPE for an escape through the right boundary and a IV_REACTION for an 
-// escape through the left boundary.
+/* This draws an eventtype of time t based on the flux through the left (z=sigma) 
+   and right (z=a) boundary. Although not completely accurate, it returns an 
+   IV_ESCAPE for an escape through the right boundary and a IV_REACTION for an 
+   escape through the left boundary. */
 GreensFunction1DAbsAbs::EventKind
 GreensFunction1DAbsAbs::drawEventType( Real rnd, Real t ) const
 {
@@ -398,179 +441,21 @@ GreensFunction1DAbsAbs::drawEventType( Real rnd, Real t ) const
 }
 
 
-/* Returns i'th term of table or fills a table with 
-   i exp arguments for drawT. */
-Real GreensFunction1DAbsAbs::drawT_exponent_table( uint const& i, 
-                                                   RealVector& table) const
-{
-    uint n( table.size() );
-
-    if(i < n)
-        return table[i];
-    else
-    {
-        const Real L(this->geta() - this->getsigma());
-        const Real expo(-D/(L*L));
-        Real nPi;
-
-        if( v == 0.0 )
-        {
-            while(n < i)
-            {
-                nPi = ((Real)(n+1)) * M_PI;
-                table.push_back( nPi * nPi * expo );
-                n++;
-            }
-        }
-        else
-        {
-            const Real vexpo_t(-v*v/4.0/D);
-
-            while(n < i)
-            {
-                nPi = ((Real)(n+1)) * M_PI;
-                table.push_back( nPi * nPi * expo + vexpo_t );
-                n++;
-            }
-        }
-
-        return table.back();
-    }
-}
-
-
-/* Returns i'th term of table or fills the table with 
-   i numerators for drawT. */
-Real GreensFunction1DAbsAbs::drawT_Xn_table( uint const& i, 
-                                             RealVector& table) const
-{
-    uint n( table.size() );
-
-    if(i < n)
-        return table[i];
-    else
-    {
-        Real nPI;
-
-        const Real a(this->geta());
-        const Real sigma(this->getsigma());
-        const Real L(this->geta() - this->getsigma());
-        const Real r0(this->getr0());
-        const Real D(this->getD());
-        const Real v(this->getv());
-    
-        const Real r0s_L((r0-sigma)/L);
-
-        if( v == 0.0 )
-        {
-            while(n < i)
-            {
-                nPI = ((Real)(n+1))*M_PI;
-                table.push_back( sin( nPI * r0s_L ) 
-                                 * (1.0 - cos(nPI)) / nPI );
-                n++;
-            }
-        }
-        else
-        {
-            const Real sigmav2D(sigma*v/2.0/D);
-            const Real av2D(a*v/2.0/D);
-            const Real Lv2D(L*v/2.0/D);
-
-            while(n < i)
-            {
-                nPI = ((Real)(n+1))*M_PI;
-                table.push_back( (exp(sigmav2D) - cos(nPI)*exp(av2D)) * 
-                                 nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L) );
-                n++;
-            }
-        }
-        return table.back();
-    }
-}
-
-
 /* This is a help function that casts the drawT_params parameter structure into
    the right form and calculates the survival probability from it (and returns it).
    The routine drawTime uses this one to sample the next-event time from the
    survival probability using a rootfinder from GSL.*/
 Real GreensFunction1DAbsAbs::drawT_f (Real t, void *p)
 {   
-    // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
-    GreensFunction1DAbsAbs const* gf( params->gf );
-    const Real r0( gf->getr0() );
-
-    /* First check if we need full solution. 
-       Else we use approximation. */
-    const Real distToa( gf->geta() - r0 );
-    const Real distTos( r0 - gf->getsigma() );
-    const Real maxDist( CUTOFF_H * sqrt(2.0 * gf->getD() * t) );
-    
-    //TODO: No drift included for approximations.
-    if( gf->getv() == 0.0 )
-    {
-        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
-        {
-            if( distTos > maxDist )//And radiation boundary 'not in sight'.
-                return params->rnd - 1.0; //No prob. outflux.
-            else  //Only absorbing BCn at s.
-                return params->rnd - XS10(t, distTos, gf->getD() );
-        }
-        else
-        {
-            if( distTos > maxDist ) //Only absorbing BCn at a.
-                return params->rnd - XS10(t, distToa, gf->getD() ); 
-        }
-    }
-    
-
-    Real sum = 0, term = 0, prev_term = 0;
-    Real Xn, exponent, prefactor;
-    // the timescale used
-    Real tscale = params->tscale;
-
-    const uint maxi( gf->guess_maxi( t ) );
-
-    if( params->exponent_table.size() < maxi + 1 &&
-        params->Xn_table.size() < maxi + 1 )
-    {
-        IGNORE_RETURN gf->drawT_exponent_table( maxi, params->exponent_table );
-        IGNORE_RETURN gf->drawT_Xn_table( maxi, params->Xn_table );
-    }
-
-    uint n = 0;
-    do
-    {
-        if ( n >= maxi )
-        {
-            std::cerr << "Too many terms needed for DrawTime. N: "
-                      << n << std::endl;
-            break;
-        }
-        prev_term = term;
-
-        Xn = gf->drawT_Xn_table(n, params->Xn_table);
-        exponent = gf->drawT_exponent_table(n, params->exponent_table);
-
-        term = Xn * exp(exponent * t);
-        sum += term;
-        n++;
-    }
-    while (fabs(term/sum) > EPSILON*tscale ||
-           fabs(prev_term/sum) > EPSILON*tscale ||
-           n < MIN_TERMS );
-
-    prefactor = params->prefactor;
-    
-    // find intersection with the random number
-    return params->rnd - prefactor * sum; 
+    return params->rnd - params->gf->p_survival_table( t, params->psurvTable );
 }
 
-// Draws the first passage time from the propensity function.
-// Uses the help routine drawT_f and structure drawT_params for some technical
-// reasons related to the way to input a function and parameters required by
-// the GSL library.
+
+/* Draws the first passage time from the propensity function.
+   Uses the help routine drawT_f and structure drawT_params for some technical
+   reasons related to the way to input a function and parameters required by
+   the GSL library. */
 Real
 GreensFunction1DAbsAbs::drawTime (Real rnd) const
 {
@@ -592,49 +477,36 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
         return 0.0;
     }
 
-    // exponent of the prefactor present in case of v<>0; has to be split because it has a t-dep. and t-indep. part
-    const Real vexpo_pref(-v*r0/2.0/D);
-    Real prefactor;
-    
-    // Find a good interval to determine the first passage time in
-    const Real dist( std::min(r0 - sigma, a - r0) );
-
-    // construct a guess: MSD = sqrt (2*d*D*t)
-    Real t_guess( dist * dist / ( 2.0 * D ) );
-
-    // A different guess has to be made in case of nonzero drift to account for the displacement due to it
-    // When drifting towards the closest boundary...
-    if( ( r0-sigma >= L/2.0 && v > 0.0 ) || 
-        ( r0-sigma <= L/2.0 && v < 0.0 ) )	
-        t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
-
-    // When drifting away from the closest boundary...
-    if( ( r0-sigma  < L/2.0 && v > 0.0 ) || 
-        ( r0-sigma  > L/2.0 && v < 0.0 ) )	
-        t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));
-      
-    t_guess *= .1;
-
     /* Set params structure. */
-    RealVector exponent_table;
-    RealVector Xn_table;
-    struct drawT_params parameters = {this, exponent_table, Xn_table};
-
-    // the prefactor of the sum is also different in case of drift<>0 :
-    if(v == 0.0)	
-        prefactor = 2.0;
-    else	
-        prefactor = 2.0 * exp(vexpo_pref);
-
-    parameters.prefactor = prefactor;
-    
-    parameters.rnd = rnd;
-    parameters.tscale = this->t_scale;
+    RealVector psurvTable;
+    struct drawT_params parameters = {this, psurvTable, rnd};
 
     gsl_function F;
     F.function = &drawT_f;
     F.params = &parameters;
 
+    /* Find a good interval to determine the first passage time in */
+    const Real dist( std::min(r0 - sigma, a - r0) );
+    Real t_guess ( 0 );
+    if( v == 0.0 )
+    {
+        t_guess = dist * dist / ( 2.0 * D ) ;     
+    }
+    else
+    {
+        // When drifting towards the closest boundary...
+        if( ( r0-sigma >= L/2.0 && v > 0.0 ) || 
+            ( r0-sigma <= L/2.0 && v < 0.0 ) )	
+            t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
+        
+        // When drifting away from the closest boundary...
+        if( ( r0-sigma  < L/2.0 && v > 0.0 ) || 
+            ( r0-sigma  > L/2.0 && v < 0.0 ) )	
+            t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));
+    } 
+
+    t_guess *= .1;
+
     Real value( GSL_FN_EVAL( &F, t_guess ) );
     Real low( t_guess );
     Real high( t_guess );
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index e8a2c86b..99a89e7c 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -174,18 +174,21 @@ class GreensFunction1DAbsAbs: public GreensFunction
     struct drawT_params
     {
         GreensFunction1DAbsAbs const* gf;
-        RealVector& exponent_table;
-        RealVector& Xn_table;
-        Real prefactor;
-        Real tscale;
+        RealVector& psurvTable;
         Real rnd;
     };
 
     static double drawT_f (double t, void *p);
 
-    Real drawT_exponent_table( uint const& i, RealVector& table) const;
+    Real p_survival_table( Real  t, RealVector& psurvTable ) const;
 
-    Real drawT_Xn_table( uint const& i, RealVector& table) const;
+    Real p_survival_i(uint i, Real const& t, RealVector const& table ) const;
+
+    Real p_survival_table_i_v( uint const& i ) const;
+
+    Real p_survival_table_i_nov( uint const& i ) const;
+
+    void createPsurvTable( uint const& maxi, RealVector& table) const;
 
     struct drawR_params
     {
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 30410a7b..fb9d0b61 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -303,7 +303,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
         std::cerr << "1DSink::drawT: maxi was cut to MAX_TERMS for t = " 
                   << t << std::endl;
         
-    if (psurvTable.size() < maxi + 1)
+    if (psurvTable.size() < maxi )
     {
         calculate_n_roots( maxi );  // this updates the table
         createPsurvTable( psurvTable );
@@ -357,7 +357,7 @@ void GreensFunction1DAbsSinkAbs::createPsurvTable(RealVector& table) const
     uint const root_nbr( rootList_size() );
     uint i( table.size() );
 
-    while( i <= root_nbr )
+    while( i < root_nbr )
     {
         table.push_back( p_survival_table_i( get_root( i++ ) ) );
     }
@@ -806,7 +806,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
         std::cerr << "1DSink::p_int_r_table: maxi was cut to MAX_TERMS for t = " 
                   << t << std::endl;
    
-    if (table.size() < maxi + 1)
+    if (table.size() < maxi )
     {
         calculate_n_roots( maxi );  // this updates the table
         createP_int_r_Table( t, table );
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index e15d1a68..fa398fd3 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -4,6 +4,7 @@
 #include <exception>
 #include <vector>
 
+#include <boost/bind.hpp>
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_sf_trig.h>
 #include <gsl/gsl_sum.h>
@@ -185,8 +186,7 @@ GreensFunction1DRadAbs::Bn (Real root_n) const
 // appearing in the survival prob. and prop. function.
 //
 // Also here the root is the one refering to the interval of length L.
-Real
-GreensFunction1DRadAbs::Cn (Real root_n, Real t)
+Real GreensFunction1DRadAbs::Cn (Real root_n, Real t)
 const
 {
     const Real D(this->getD());
@@ -194,26 +194,39 @@ const
     return std::exp(-D*root_n*root_n*t);
 }
 
-// Calculates the probability of finding the particle inside the domain
-// at time t, the survival probability.
-Real
-GreensFunction1DRadAbs::p_survival (Real t) const
+
+Real GreensFunction1DRadAbs::p_survival(Real t) const
+{
+    RealVector table;
+    return p_survival_table(t, table);
+}
+
+
+/* Calculates survival probability using a table. 
+   Switchbox for which greensfunction to use. */
+Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-  
+
+    Real p;
+
+    const Real a(this->geta());
+    const Real sigma(this->getsigma());
+    const Real L(this->geta() - this->getsigma());
+    const Real r0(this->getr0());
     const Real D(this->getD());
     const Real v(this->getv());
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
-    const Real L(this->geta()-this->getsigma());
-    const Real r0_s(this->getr0() - this->getsigma());
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    const Real r0( getr0() );
+
+    if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
+    {
+        // The survival probability of a zero domain is zero
+        return 0.0;
+    }
 
     if (t == 0.0 || (D == 0.0 && v == 0.0) )
     {
-        // if there was no time or no movement the particle was always
-        // in the domain
-        return 1.0;
+	    //particle can't escape.
+	    return 1.0;
     }
 
     /* First check if we need full solution. 
@@ -239,70 +252,119 @@ GreensFunction1DRadAbs::p_survival (Real t) const
         }
     }
 
-    Real root_n;
-    Real sum = 0, term = 0, term_prev = 0;
-    uint n = 0;
+    const uint maxi( guess_maxi(t) );
+    
+    if( maxi == MAX_TERMS )
+        std::cerr << "1DRad::drawT: maxi was cut to MAX_TERMS for t = " 
+                  << t << std::endl;
+    
+    if ( psurvTable.size() < maxi )
+    {
+        calculate_n_roots( maxi );
+        createPsurvTable( psurvTable );
+    }
+
+    p = funcSum_all(boost::bind(&GreensFunction1DRadAbs::p_survival_i, 
+                                this, _1, t, psurvTable),
+                    maxi);
+    
+    if( v == 0.0 )
+    {   
+        p *= 2.0;
+    }
+    else
+    {       
+        const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+        p *= 2.0 * exp( vexpo );
+    }
+
+    return p;
+}
+
+
+/* Calculates the i'th term of the p_survival sum */
+Real GreensFunction1DRadAbs::p_survival_i( uint i, 
+                                           Real const& t, 
+                                           RealVector const& table) const
+{
+    return exp( - getD() * t * gsl_pow_2( get_root( i ) ) ) * table[ i ];
+}
 
-    const uint maxi( guess_maxi( t ) );
-    calculate_n_roots( maxi );
 
-    if(h != 0.0)
+/* Calculates the part of the i'th term of p_surv not dependent on t, with drift */
+Real GreensFunction1DRadAbs::p_survival_table_i_v( uint const& i ) const
+{
+    const Real sigma( getsigma() );
+    const Real L( geta() - getsigma() );
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real v( getv() );
+    const Real h( (getk()+v/2.0)/D );
+
+    const Real v2D(v/2.0/D);
+    const Real exp_av2D(exp(a*v2D));
+    const Real exp_sigmav2D(exp(sigma*v2D));
+    
+    const Real root_n( get_root( i ) );	
+    const Real root_n2     = root_n * root_n;
+    const Real root_n_r0_s = root_n * (r0-sigma);
+    const Real root_n_L    = root_n * L;
+    const Real h_root_n    = h / root_n;
+    
+    return ( h * sin( root_n_r0_s ) + root_n * cos( root_n_r0_s ) ) / 
+        ( L * ( root_n2 + h * h) + h ) * ( exp_sigmav2D * h * k / D - 
+                               exp_av2D * ( root_n2 + h * h )*
+                               cos( root_n_L ) ) / 
+            ( h_root_n * (root_n2 + v2D * v2D) );
+}
+
+
+/* Calculates the part of the i'th term of p_surv not dependent on t, without drift */
+Real GreensFunction1DRadAbs::p_survival_table_i_nov( uint const& i ) const
+{
+    const Real sigma( getsigma() );
+    const Real L( geta() - sigma );
+    const Real r0( getr0() );
+    const Real h( (getk()+getv()/2.0)/getD());
+
+    const Real root_n ( get_root( i ) );	
+    const Real root_n2( root_n * root_n );
+    const Real root_n_r0_s( root_n * (r0-sigma) );
+    const Real root_n_L( root_n * L );
+    const Real h_root_n( h / root_n );
+    
+    return (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) 
+        / (L*(root_n2+h*h)+h) * ( h_root_n + sin(root_n_L) 
+                                  - h_root_n*cos(root_n_L) );
+}
+
+
+/* Fills table with terms in the p_survival sum which don't depend on t */
+void GreensFunction1DRadAbs::createPsurvTable( RealVector& table) const
+{
+    const uint root_nbr( rootList_size() );
+    uint i( table.size() );
+
+    if( getv() == 0.0 )
     {
-        do
+        while( i < root_nbr )
         {
-            if ( n >= MAX_TERMS )
-            {
-                std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
-                          << n << std::endl;
-                break;
-            }
-
-	        root_n = this->get_root(n);
-	        term_prev = term;
-    	    term = this->Cn(root_n, t) * this->An(root_n) * this->Bn(root_n);
-	        sum += term;
-	        n++;
+            table.push_back( p_survival_table_i_nov( i++ ) );
         }
-        while ( fabs(term/sum) > EPSILON  ||
-                fabs(term_prev/sum) > EPSILON ||
-                n < MIN_TERMS);
-
     }
     else
     {
-
-        do
+        while( i < root_nbr )
         {
-            if ( n >= MAX_TERMS )
-            {
-                std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
-                          << n << std::endl;
-                break;
-            }
-
-	        root_n = this->get_root(n);
-	        term_prev = term;
-    	    
-            term = this->Cn(root_n, t) * cos( root_n * r0_s ) * sin( root_n * L ) / 
-                ( L * root_n );
-
-	        sum += term;
-	        n++;
+            table.push_back( p_survival_table_i_v( i++ ) );
         }
-        while ( fabs(term/sum) > EPSILON  ||
-                fabs(term_prev/sum) > EPSILON ||
-                n < MIN_TERMS);
-
     }
-    return 2.0 * exp(vexpo) * sum;
 }
 
 
-// Calculates the probability density of finding the particle at location r
-// at time t.
-Real
-GreensFunction1DRadAbs::prob_r (Real r, Real t)
-const
+/* Calculates the probability density of finding the particle at location r
+   at time t. */
+Real GreensFunction1DRadAbs::prob_r (Real r, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
     THROW_UNLESS( std::invalid_argument, (r-sigma) >= 0.0 && r <= a 
@@ -371,20 +433,18 @@ const
 }
 
 
-// Calculates the probability density of finding the particle at location z at
-// timepoint t, given that the particle is still in the domain.
-Real
-GreensFunction1DRadAbs::calcpcum (Real r, Real t) const
+/* Calculates the probability density of finding the particle at location z at
+   timepoint t, given that the particle is still in the domain. */
+Real GreensFunction1DRadAbs::calcpcum (Real r, Real t) const
 {
     return prob_r(r, t)/p_survival(t);
 }
 
 
-// Calculates the total probability flux leaving the domain at time t
-// This is simply the negative of the time derivative of the survival prob.
-// at time t [-dS(t')/dt' for t'=t].
-Real
-GreensFunction1DRadAbs::flux_tot (Real t) const
+/* Calculates the total probability flux leaving the domain at time t
+   This is simply the negative of the time derivative of the survival prob.
+   at time t [-dS(t')/dt' for t'=t]. */
+Real GreensFunction1DRadAbs::flux_tot (Real t) const
 {
     Real root_n;
     const Real D(this->getD());
@@ -424,8 +484,7 @@ GreensFunction1DRadAbs::flux_tot (Real t) const
 
 /* Calculates the probability flux leaving the domain through the radiative
    boundary at time t */
-Real
-GreensFunction1DRadAbs::flux_rad (Real t) const
+Real GreensFunction1DRadAbs::flux_rad (Real t) const
 {
     return this->getk() * prob_r(this->getsigma(), t);
 }
@@ -435,15 +494,14 @@ GreensFunction1DRadAbs::flux_rad (Real t) const
    fraction of the total flux. This is the probability that the particle left
    the domain through the radiative boundary instead of the absorbing
    boundary. */
-Real
-GreensFunction1DRadAbs::fluxRatioRadTot (Real t) const
+Real GreensFunction1DRadAbs::fluxRatioRadTot (Real t) const
 {
     return flux_rad(t)/flux_tot(t);
 }
 
-// Determine which event has occured, an escape or a reaction. Based on the
-// fluxes through the boundaries at the given time. Beware: if t is not a
-// first passage time you still get an answer!
+/* Determine which event has occured, an escape or a reaction. Based on the
+   fluxes through the boundaries at the given time. Beware: if t is not a
+   first passage time you still get an answer! */
 GreensFunction1DRadAbs::EventKind
 GreensFunction1DRadAbs::drawEventType( Real rnd, Real t )
 const
@@ -477,177 +535,18 @@ const
 }
 
 
-
-/* Returns i'th term of table or fills a table with 
-   i exp arguments for drawT. */
-Real GreensFunction1DRadAbs::drawT_exponent_table( uint const& i, 
-                                                   RealVector& table) const
+/* This function is needed to cast the math. form of the function
+   into the form needed by the GSL root solver. */
+Real GreensFunction1DRadAbs::drawT_f (double t, void *p)
 {
-    uint n( table.size() );
-
-    if(i < n)
-        return table[i];
-    else
-    {
-        const Real D( getD() );
-        const Real v2( gsl_pow_2( getv() ) );
-        const Real vexpo_t(-v2/4.0/D);
-        Real root_n2;
-
-        while(n < i)
-        {
-            root_n2 = gsl_pow_2( get_root( n ) );
-            table.push_back( -D * root_n2 + vexpo_t );
-            n++;
-        }
-        
-        return table.back();
-    }
-}
-
-
-/* Returns i'th term of table or fills the table with 
-   i numerators for drawT. */
-Real GreensFunction1DRadAbs::drawT_Xn_table( uint const& i, 
-                                             RealVector& table) const
-{
-    uint n( table.size() );
-
-    if(i < n)
-        return table[i];
-    else
-    {
-        const Real sigma(this->getsigma());
-        const Real L(this->geta() - this->getsigma());
-        const Real r0(this->getr0());
-        const Real D(this->getD());
-        const Real v(this->getv());
-        const Real h((getk()+getv()/2.0)/getD());
-
-        Real root_n, root_n2, root_n_r0_s, root_n_L, h_root_n;	  
-
-        if( v == 0.0)
-        {
-            while(n < i)
-            {
-                root_n      = get_root(n);	
-                root_n2	    = root_n * root_n;
-                root_n_r0_s = root_n * (r0-sigma);
-                root_n_L    = root_n * L;
-                h_root_n    = h / root_n;
-
-                table.push_back( (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) 
-                                 / (L*(root_n2+h*h)+h) * ( h_root_n + sin(root_n_L) 
-                                                           - h_root_n*cos(root_n_L) ) );
-                n++;
-            }
-        }
-        else
-        {
-            const Real v2D(v/2.0/D);
-            const Real exp_av2D(exp(a*v2D));
-            const Real exp_sigmav2D(exp(sigma*v2D));
-
-            while(n < i)
-            {
-                root_n      = get_root(n);	
-                root_n2	    = root_n * root_n;
-                root_n_r0_s = root_n * (r0-sigma);
-                root_n_L    = root_n * L;
-                h_root_n    = h / root_n;
-
-                table.push_back( (h*sin(root_n_r0_s) + root_n*cos(root_n_r0_s)) / 
-                                 (L*(root_n2+h*h)+h) * (exp_sigmav2D*h*k/D - 
-                                                        exp_av2D*(root_n2+h*h)*
-                                                        cos(root_n_L)) / 
-                                 (h_root_n * (root_n2 + v2D*v2D))  
-                                 );
-                n++;
-            }
-        }
-        return table.back();
-    }
-}
-
-
-// This function is needed to cast the math. form of the function
-// into the form needed by the GSL root solver.
-double GreensFunction1DRadAbs::drawT_f (double t, void *p)
-{
-    // casts p to type 'struct drawT_params *'
     struct drawT_params *params = (struct drawT_params *)p;
-    GreensFunction1DRadAbs const* gf = params->gf;
-    const Real r0( gf->getr0() );
-
-    /* First check if we need full solution. 
-       Else we use approximation. */
-    const Real distToa( gf->geta() - r0 );
-    const Real distTos( r0 - gf->getsigma() );
-    const Real maxDist( CUTOFF_H * sqrt(2.0 * gf->getD() * t) );
-    
-    //TODO: No drift included for approximations.
-    if( gf->getv() == 0.0 )
-    {
-        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
-        {
-            if( distTos > maxDist )//And radiation boundary 'not in sight'.
-                return params->rnd - 1.0; //No prob. outflux.
-            else
-                return params->rnd - XS30(t, distTos, gf->getk(), gf->getD()); //Only radiation BCn.
-        }
-        else
-        {
-            if( distTos > maxDist )
-                return params->rnd - XS10(t, distToa, gf->getD() ); //Only absorbing BCn.
-        }
-    }
-
-
-    Real Xn = 0, exponent = 0;
-    Real prefactor = params->prefactor;
-
-    const uint maxi( gf->guess_maxi( t ) );
-    
-    if( params->exponent_table.size() < maxi + 1 &&
-        params->Xn_table.size() < maxi + 1 )
-    {
-        params->gf->calculate_n_roots( maxi );
-        IGNORE_RETURN gf->drawT_exponent_table( maxi, params->exponent_table );
-        IGNORE_RETURN gf->drawT_Xn_table( maxi, params->Xn_table );
-    }
-
-    Real sum = 0, term = 0, prev_term = 0;
-    uint n = 0;
-    do
-    {
-        if ( n >= maxi )
-        {
-            std::cerr << "Too many terms needed for GF1DRad::DrawTime. N: "
-                      << n << ", conv arg: " << exponent * t <<  std::endl;
-            break;
-        }
-        prev_term = term;
-        
-        Xn = params->gf->drawT_Xn_table(n, params->Xn_table);
-        exponent = params->gf->drawT_exponent_table(n, params->exponent_table);
-        term = Xn * exp(exponent * t);
-
-        sum += term;
-        n++;
-    }
-    while (fabs(term/sum) > EPSILON*1.0 ||
-           fabs(prev_term/sum) > EPSILON*1.0 ||
-           n < MIN_TERMS );
-
-    // find the intersection with the random number
-    return params->rnd - prefactor*sum;
+    return params->rnd - params->gf->p_survival_table( t, params->psurvTable );
 }
 
-// Draws the first passage time from the survival probability,
-// using an assistance function drawT_f that casts the math. function
-// into the form needed by the GSL root solver.
-Real
-GreensFunction1DRadAbs::drawTime (Real rnd) const
+/* Draws the first passage time from the survival probability,
+   using an assistance function drawT_f that casts the math. function
+   into the form needed by the GSL root solver. */
+Real GreensFunction1DRadAbs::drawTime (Real rnd) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
   
@@ -657,7 +556,6 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
     const Real r0(this->getr0());
     const Real k(this->getk());
     const Real D(this->getD());
-    const Real v(this->getv());   
 
     if ( D == 0.0 || L == INFINITY )
     {
@@ -669,14 +567,11 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
         return 0.0;
     }
 
-    // some temporary variables
-    const Real vexpo_pref(-v*r0/2.0/D);
-    Real prefactor;
-
     /* Find a good interval to determine the first passage time. */
     Real t_guess;
     Real dist;
 
+    //TODO: make tguess for particle at contact with Rad boundary.
     if (k != 0)
     {
         dist = std::min(a - r0, r0 - sigma);
@@ -698,23 +593,10 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
 
     /* Set params structure. */
     RealVector exponent_table;
-    RealVector Xn_table;
-    struct drawT_params parameters = {this, exponent_table, Xn_table};
+    RealVector psurvTable;
+    struct drawT_params parameters = {this, psurvTable, rnd};
     
-    // the prefactor of the sum is also different in case of drift<>0 :
-    if(v == 0)
-        prefactor = 2.0;
-    else
-        prefactor = 2.0 * exp(vexpo_pref);
-
-    parameters.prefactor  = prefactor;
-    
-    // store the random number for the probability
-    parameters.rnd = rnd;
-    // store the number of terms used
-    parameters.tscale = this->t_scale;
-
-    // Define the function for the rootfinder
+    /* Define the function for the rootfinder. */
     gsl_function F;
     F.function = &GreensFunction1DRadAbs::drawT_f;
     F.params = &parameters;
@@ -770,12 +652,9 @@ GreensFunction1DRadAbs::drawTime (Real rnd) const
         while ( value >= 0.0 );
     }
 
-    // find the intersection on the y-axis between the random number and
-    // the function
-    
-    // define a new solver type brent
+    /* define a new solver type brent */
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
-    // make a new solver instance
+    /* make a new solver instance */
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     const Real t( findRoot( F, solver, low, high, t_scale*EPSILON, EPSILON,
                             "GreensFunction1DRadAbs::drawTime" ) );
@@ -793,7 +672,7 @@ GreensFunction1DRadAbs::drawR_f (double z, void *p)
     Real costerm 	= params->H[1];	// = k/D
     Real sinterm 	= params->H[2];	// = h*v2D
     Real sigma 		= params->H[3];	// = sigma
-    uint  terms = params->terms;
+    uint terms      = params->terms;
 
     Real expsigma(exp(sigma*v2D));
     Real zs(z-sigma);
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 72f7f684..074a0ab9 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -252,23 +252,30 @@ class GreensFunction1DRadAbs: public GreensFunction
     /* this is the appropriate definition of the function in gsl. */
     static double tan_f (double x, void *p);
 
+
+    /* Functions for drawTime */
+
     struct drawT_params
     {
         GreensFunction1DRadAbs const* gf;
-        RealVector& exponent_table;
-        RealVector& Xn_table;
-        double prefactor;
-        // the timescale used for convergence
-        Real   tscale;
-        // the random number associated with the time
-        double rnd;
+        RealVector& psurvTable;
+        Real rnd;
     };
 
-    static double drawT_f (double t, void *p);
+    Real p_survival_table( Real  t, RealVector& psurvTable ) const;
+
+    Real p_survival_i(uint i, Real const& t, RealVector const& table ) const;
+
+    Real p_survival_table_i_v( uint const& i ) const;
 
-    Real drawT_exponent_table( uint const& i, RealVector& table) const;
+    Real p_survival_table_i_nov( uint const& i ) const;
 
-    Real drawT_Xn_table( uint const& i, RealVector& table) const;
+    void createPsurvTable( RealVector& table) const;
+
+    
+    /* functions for drawR */
+
+    static double drawT_f (double t, void *p);
 
     struct drawR_params
     {
@@ -283,6 +290,9 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     static double drawR_f (double z, void *p);
 
+
+    /* Member variables */
+
     // The diffusion constant and drift velocity
     Real v;
     // The reaction constant
@@ -296,6 +306,7 @@ class GreensFunction1DRadAbs: public GreensFunction
     // This is the time scale of the system.
     Real t_scale;
 
+    /* vector containing the roots 0f tan_f. */
     mutable RealVector rootList;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP

From 31df47c8d31e60f183c7fa816efe894a7b2ff52f Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Sat, 3 Dec 2011 22:35:06 +0100
Subject: [PATCH 0433/1541] Removed drift from AbsSinkAbs.

---
 GreensFunction1DAbsSinkAbs.cpp |  8 ++++++--
 GreensFunction1DAbsSinkAbs.hpp | 31 +------------------------------
 greens_functions.cpp           |  2 --
 3 files changed, 7 insertions(+), 34 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index fb9d0b61..bfdb8e7d 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -270,7 +270,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
     const Real a( geta() );
     const Real L0( getL0() ); 
 
-    if (t == 0.0 || (D == 0.0 && v == 0.0) )
+    if (t == 0.0 || D == 0.0 )
     {
 	    //particle can't escape.
 	    return 1.0;
@@ -707,6 +707,10 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     Real dist( std::min(Lr - L0, Ll + L0) );
     Real t_guess( dist * dist / ( 2.0 * D ) );
 
+    /* For a particle at contact, the time after a probability P
+       has dissapeared into the radiation boundary is to first order:
+       t = D * P / (pi * k * k ), we use tis as a guess for the next 
+       event time when a particle is close to the Abs boundary. */
     if( dist > 10 * L0 )
         t_guess = std::min(D * 0.01 / ( k * k ), t_guess);
 
@@ -938,7 +942,7 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     const Real r0( getr0() );
     const Real L( Lr + Ll );
 
-    if (t == 0.0 || (D == 0.0 && v == 0.0) )
+    if (t == 0.0 || D == 0.0 )
     {
 	    // the trivial case
 	    return r0;
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index f1f3ce8f..7bd04a57 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -52,7 +52,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 
 public:
     GreensFunction1DAbsSinkAbs(Real D, Real k, Real r0, Real rsink, Real sigma, Real a)
-	: GreensFunction(D), v(0.0), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
+	: GreensFunction(D), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
     {
 	    /* Set variables which define a domain with the sink at the origin. 
 	       Futhermore r0 is assumed to be ringht from the sink. */
@@ -73,28 +73,6 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
         calculate_n_roots( 1 );
     }
 
-    /* The constructor is overloaded and can be called with or without drift v
-       copy constructor including drift variable v */
-    GreensFunction1DAbsSinkAbs(Real D, Real v, Real k, Real r0, Real rsink, Real sigma, Real a)
-	: GreensFunction(D), v(v), k(k), r0(r0), sigma(sigma), a(a), rsink(rsink), l_scale(L_TYPICAL), t_scale(T_TYPICAL)
-    {
-		assert( a > sigma );
-	    
-	    L0 = fabs( r0 - rsink ); 
-	    if( r0 >= rsink )
-	    {
-	        Lr = a - rsink; 
-	        Ll = rsink - sigma;	        
-	    }
-	    else
-	    {
-	        Lr = rsink - sigma; 
-	        Ll = a - rsink;
-	    }
-
-        calculate_n_roots( 1 );
-    }
-
     ~GreensFunction1DAbsSinkAbs()
     {
 	;   // empty
@@ -140,11 +118,6 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 	    return k;
     }
 
-    Real getv() const
-    {
-	    return v;
-    }
-
     /* Calculates the probability density of finding the particle at 
        location z at timepoint t, given that the particle is still in the 
        domain. */
@@ -349,8 +322,6 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     
     /* Class variables */
 
-    // The drift velocity
-    const Real v;
     // The reaction constant
     const Real k;
     //starting position
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 2eb9e8ec..2b98b633 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -87,11 +87,9 @@ BOOST_PYTHON_MODULE( _greens_functions )
         
     class_<GreensFunction1DAbsSinkAbs>("GreensFunction1DAbsSinkAbs",
                                    init<Real, Real, Real, Real, Real, Real>() )
-        .def( init<Real, Real, Real, Real, Real, Real, Real>())
         .def( "getName", &GreensFunction1DAbsSinkAbs::getName )
         .def( "getk", &GreensFunction1DAbsSinkAbs::getk )
         .def( "getD", &GreensFunction1DAbsSinkAbs::getD )
-        .def( "getv", &GreensFunction1DAbsSinkAbs::getv )
         .def( "getsigma", &GreensFunction1DAbsSinkAbs::getsigma )
         .def( "geta", &GreensFunction1DAbsSinkAbs::geta )
         .def( "getr0", &GreensFunction1DAbsSinkAbs::getr0 )

From 7ce4a85a18afb858ba68135d1aa04f66af01f4ae Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Sun, 4 Dec 2011 14:57:58 +0100
Subject: [PATCH 0434/1541] Included new guess for next event time for a
 particle seperated from a radiation boundary with a distance x0.

---
 GreensFunction1DAbsSinkAbs.cpp | 15 ++++++++-------
 GreensFunction1DRadAbs.cpp     | 11 ++++++-----
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index bfdb8e7d..df9f96f1 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -705,15 +705,16 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     /* Find a good interval to determine the first passage time.
        First we get the distance to one of the absorbing boundaries or the sink. */
     Real dist( std::min(Lr - L0, Ll + L0) );
-    Real t_guess( dist * dist / ( 2.0 * D ) );
 
-    /* For a particle at contact, the time after a probability P
-       has dissapeared into the radiation boundary is to first order:
-       t = D * P / (pi * k * k ), we use tis as a guess for the next 
-       event time when a particle is close to the Abs boundary. */
-    if( dist > 10 * L0 )
-        t_guess = std::min(D * 0.01 / ( k * k ), t_guess);
+    /* For a particle at contact, the time for the particle to be absorbed by the 
+       radiation boundary is 4 D / (k*k). If the particle is at a distace x0 from the
+       radiation boundary, we approximate the gues for the next event-time by:
+       t_guess = D / (k*k) + x0 * x0 / D.
+    */
+    const Real t_Abs( gsl_pow_2( dist ) / D );
+    const Real t_Rad( 4 * D / (k * k) + gsl_pow_2( L0 ) / D );
 
+    t_guess = std::min(t_Abs, t_Rad );
     t_guess *= .1;
 
     /* Define the function for the rootfinder */
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index fa398fd3..89065f81 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -571,17 +571,18 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
     Real t_guess;
     Real dist;
 
-    //TODO: make tguess for particle at contact with Rad boundary.
-    if (k != 0)
+    if( k != 0.0 )
     {
-        dist = std::min(a - r0, r0 - sigma);
+        const Real t_Abs( gsl_pow_2( a - r0 ) / D );
+        const Real t_Rad( D / (k * k) + gsl_pow_2( r0 - sigma ) / D );
+
+        t_guess = std::min(t_Abs, t_Rad );
     }
     else
     {
-        dist = a - r0;
+        t_guess = gsl_pow_2( a - r0 ) / D;
     }
 
-    t_guess = dist * dist / ( 2.0 * D );
     t_guess *= .1;
 
     // A different guess has to be made in case of nonzero drift to account for the displacement due to it

From 89e7612f18fe6d00f11d102d6d57786a38a39091 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 5 Dec 2011 14:48:32 +0100
Subject: [PATCH 0435/1541] streamlined bursting method

---
 egfrd.py | 116 ++++++++++++++++++++++++++-----------------------------
 1 file changed, 55 insertions(+), 61 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f1bb560f..fd6a5dfb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -639,42 +639,47 @@ def burst_volume(self, pos, radius, ignore=[]):
         neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
         return self.burst_objs(neighbors)
 
-    def burst_non_multis(self, domains):
-        # bursts the domains in 'domains' if appropriate
+    def burst_non_multis(self, domain_distances, burstradius):
+        # bursts the domains in 'domains' if within burstradius
         # -doesn't burst multi's
         # -doesn't burst domains in which no time has passed
         # -doesn't burst domains that were already a burst NonInteractionSingle
-        # Returns the list of burst (zero-dt) NonInteractionSingles and Multi's, and the list of domains
+        # Returns the updated list of domains
+        #  NonInteractionSingles and Multi's, and the list of domains
         # unaffected by the procedure
 
-        bursted = []
-        unbursted = []
-
-#        for domain in domains:
-#            if not isinstance(domain, Multi):
-#                # domain is Single or Pair of some subclass
-#                single_list = self.burst_domain(domain)
-#                bursted.extend(single_list)
-#            else:
-#                # domain is a Multi
-#                bursted.append(domain)
-
-        for domain in domains:
-            if isinstance(domain, Multi):
-                # domain is a Multi
-                bursted.append(domain)
-            elif (isinstance(domain, NonInteractionSingle) and domain.is_reset()):
-                bursted.append(domain)
-            elif self.t != domain.last_time:
-                # domain is some subclass of Single or Pair in which time has passed
+        domain_distances_updated = []
+#        unbursted = []
+
+        for domain, distance in domain_distances:
+            if distance <= burstradius and \
+               not isinstance(domain, Multi) and \
+               not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
+               self.t != domain.last_time:
+                # burst domain only if:
+                # -within radius
+                # -domain is not a multi
+                # -domain is not zero dt NonInteractionSingle
+                # -domain has time passed
+#                    # domain is a Multi
+#                    bursted.append(domain)
+#                elif (isinstance(domain, NonInteractionSingle) and domain.is_reset()):
+#                    bursted.append(domain)
+#                elif self.t != domain.last_time:
+                    # domain is some subclass of Single or Pair in which time has passed
                 single_list = self.burst_domain(domain)
-                bursted.extend(single_list)
+                single_distances = [(single, 0) for single in single_list]        # maybe calculate real distance, now just 0
+                domain_distances_updated.extend(single_distances)
             else:
-                # domain is Single which is just made (no time passed) and is not reset, or
-                # domain is Pair which is just made (no time passed). -> do nothing
-                unbursted.append(domain)
+                # don't burst domain if
+                # -domain is farther than burst radius
+                # -domain is a multi
+                # -domain is Single which is just made (no time passed) and is not reset
+                # -domain is Pair which is just made (no time passed)
+                domain_distances_updated.append((domain, distance))
 
-        return bursted, unbursted
+#        return bursted, unbursted
+        return domain_distances_updated
 
     def fire_single_reaction(self, single, reactant_pos):
         # This takes care of the identity change when a single particle decays into
@@ -2236,61 +2241,50 @@ def add_to_multi_recursive(self, domain, multi):
                     log.debug('%s already in multi. skipping.' % domain)
                 return
 
-            dompos = domain.shell.shape.position
             
-            # 1. burst to make space for the multi shell
-            burstradius = domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
-            neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(
-                    dompos, burstradius, ignore=[domain.domain_id, multi.domain_id])
-            neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+            # 1. Get the neighbors of the domain
+            dompos = domain.shell.shape.position
+            neighbor_distances = self.geometrycontainer.get_neighbor_domains(dompos, self.domains,
+                                                                             ignore=[domain.domain_id, multi.domain_id])
 
-            # This should only burst domains in which time has passed, it is assumed that other domains
+            # 2. Burst the domains that interfere with making the multi shell
+            burstradius = domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+            neighbor_distances = self.burst_non_multis(neighbor_distances, burstradius)
+            # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
-            # shell without overlapping. neighbors should therefor contain no domains in which no time has passed
+            # shell without overlapping. 
 
-            burst, non_bursted = self.burst_non_multis(neighbors)
-            # burst contains all the domains in the neighborhood that can be added to the multi
-            # -> zero-dt NonInteractionSingles and Multi's
-            # at this point there should be no domains in the multi_horizon that cannot be bursted
-            assert non_bursted == [], 'add_to_multi_recursive: unburstable domains in multi_horizon. %s' % \
-                                      non_bursted
+            # neighbor_distances has same format as before
+            # It contains the updated list of domains in the neighborhood with distances
 
-            # 2. add domain to the multi
+            # 3. add domain to the multi
             self.add_to_multi(domain, multi)
             self.remove_domain(domain)
             self.remove_event(domain)
 
-            # 3. select neighbors in the 'multi_horizon' for adding to the multi
-            # 3.1 get distances to closest shell of burst neighbors
-            # TODO clean this up! line below is not necessary!!
-            neighbors = [(burst_domain, self.domain_distance(dompos, burst_domain)) for burst_domain in burst]
-
-#            neighbors = [burst[i] for i
-#                                  in (neighbor_dists <= burstradius).nonzero()[0]]
-
-            # 3.2 calculate if the domains are within the multi horizon
-            multi_partners = []
-            for neighbor, dist_to_shell in neighbors:
+            # 4. Neighbors with overlapping 'multi_horizons' that are:
+            #    - Multi or
+            #    - just bursted (initialized) NonInteractionSingles
+            #    are added recursively to the multi
+            for neighbor, dist_to_shell in neighbor_distances:
                 if (isinstance (neighbor, NonInteractionSingle) and neighbor.is_reset()):
                     multi_horizon = (domain.pid_particle_pair[1].radius + neighbor.pid_particle_pair[1].radius) * \
                                     self.MULTI_SHELL_FACTOR
                     # distance from the center of the particles/domains
                     distance = self.world.distance(dompos, neighbor.shell.shape.position)
-                    multi_partners.append((neighbor, distance - multi_horizon))
+                    overlap = distance - multi_horizon
 
                 elif isinstance(neighbor, Multi):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
                     # So only the horizon and distance of the current single needs to be taken into account
                     # Note: this is built on the assumption that the shell of a Multi has the size of the horizon.
                     multi_horizon = (domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
-                    multi_partners.append((neighbor, dist_to_shell - multi_horizon))
-
+                    overlap = dist_to_shell - multi_horizon
                 else:
-                    if __debug__:
-                        assert False, 'add_to_multi_recursive: burst neighbor is not dt-zero NonInteractionSingle or Multi'
+                    # neighbor is not addible to multi
+                    overlap = numpy.inf
 
-            # 4. if the burst neighbors are still in the horizon -> add to multi
-            for neighbor, overlap in multi_partners:
+                # 4.2 if the domains are within the multi horizon
                 if overlap < 0:
                     self.add_to_multi_recursive(neighbor, multi)
 

From c3ff6f33a01e52670fef1085eb5759aaebcc7c3b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 5 Dec 2011 16:35:17 +0100
Subject: [PATCH 0436/1541] shellcontainer should return empty list in case of
 no surfaces Was returning list with (None, smt) tuple

---
 shellcontainer.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/shellcontainer.py b/shellcontainer.py
index 50cbff9c..f583bf37 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -175,7 +175,10 @@ def get_neighbor_surfaces(self, position, ignores=[]):
 
         # TODO return a list of neighboring surfaces
         surface, distance = get_closest_surface(self.world, position, ignores)
-        return [(surface, distance), ]
+        if surface:
+            return [(surface, distance), ]
+        else:
+            return []
 
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # Get neighbor domains within given radius.

From b563d83db0995a25693812acb7990ae9d2bfbad6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 5 Dec 2011 16:40:24 +0100
Subject: [PATCH 0437/1541] cleanup of code of make_new_domain including
 burst_non_multis Mostly rearranging, cleaning up comments and throwing away
 commented stuff

---
 egfrd.py | 190 +++++++++++++++++++++----------------------------------
 1 file changed, 72 insertions(+), 118 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fd6a5dfb..f71af38f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -640,45 +640,32 @@ def burst_volume(self, pos, radius, ignore=[]):
         return self.burst_objs(neighbors)
 
     def burst_non_multis(self, domain_distances, burstradius):
-        # bursts the domains in 'domains' if within burstradius
-        # -doesn't burst multi's
-        # -doesn't burst domains in which no time has passed
-        # -doesn't burst domains that were already a burst NonInteractionSingle
-        # Returns the updated list of domains
-        #  NonInteractionSingles and Multi's, and the list of domains
-        # unaffected by the procedure
+        # Bursts the domains in 'domains' if within burstradius
+        # Returns the updated list of domains with their distances
 
         domain_distances_updated = []
-#        unbursted = []
 
         for domain, distance in domain_distances:
             if distance <= burstradius and \
                not isinstance(domain, Multi) and \
                not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
                self.t != domain.last_time:
-                # burst domain only if:
+                # Burst domain only if (AND):
                 # -within radius
                 # -domain is not a multi
                 # -domain is not zero dt NonInteractionSingle
                 # -domain has time passed
-#                    # domain is a Multi
-#                    bursted.append(domain)
-#                elif (isinstance(domain, NonInteractionSingle) and domain.is_reset()):
-#                    bursted.append(domain)
-#                elif self.t != domain.last_time:
-                    # domain is some subclass of Single or Pair in which time has passed
                 single_list = self.burst_domain(domain)
-                single_distances = [(single, 0) for single in single_list]        # maybe calculate real distance, now just 0
+                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
                 domain_distances_updated.extend(single_distances)
             else:
-                # don't burst domain if
+                # Don't burst domain if (OR):
                 # -domain is farther than burst radius
                 # -domain is a multi
-                # -domain is Single which is just made (no time passed) and is not reset
-                # -domain is Pair which is just made (no time passed)
+                # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
+                # -domain is domain in which no time has passed
                 domain_distances_updated.append((domain, distance))
 
-#        return bursted, unbursted
         return domain_distances_updated
 
     def fire_single_reaction(self, single, reactant_pos):
@@ -1147,123 +1134,96 @@ def make_new_domain(self, single):
         single_pos = single.pid_particle_pair[1].position
         single_radius = single.pid_particle_pair[1].radius
 
-        # 2.1
         # We prefer to make NonInteractionSingles for efficiency.
         # But if objects (Shells and surfaces) get close enough (closer than
         # reaction_threshold) we want to try Interaction and/or Pairs
 
+        # 1.0 Get neighboring domains and surfacesget neighboring domains and surfaces
+        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+        # Get also surfaces but only if the particle is in 3D
+        surface_distances = []
+        if isinstance(single, SphericalSingle):
+            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, ignores=[single.structure.id])
+
+
         # Check if there are shells with the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
         # with a sphere (should be cylinder for 2D or 1D particle)
         reaction_threshold = single.pid_particle_pair[1].radius * \
                              self.SINGLE_SHELL_FACTOR
 
-#        intruder_ids, _, _ = \
-#            self.geometrycontainer.get_intruders(single_pos, reaction_threshold,
-#                                                 ignore=[single.domain_id, ])
-#        intruders = [self.domains[domain_id] for domain_id in intruder_ids]
-
-        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+        # TODO redundant
         intruders = self.geometrycontainer.filter_distance(neighbors, reaction_threshold)
-
         if __debug__:
             log.debug("intruders: %s" %
                       (', '.join(str(i) for i in intruders)))
 
+        neighbor_distances = self.burst_non_multis(neighbors, reaction_threshold)
 
-        # 2.2 Burst the shells with the following conditions
-        # -shell is in the burst radius (intruder)
-        # -shell is burstable (not Multi)
-        # -shell is not newly made
-        # -shell is not already a zero shell (just bursted)
-        burst = []
-        if intruders:
-
-            # TODO replace this with burst_non_multis
-            for domain, _ in intruders:
-                if not isinstance(domain, Multi) and \
-                   not self.t == domain.last_time and \
-                   not domain.dt == 0.0:
-                    # domain is Single or Pair of some subclass
-                    single_list = self.burst_domain(domain)
-                    burst.extend(single_list)
-                elif isinstance(domain, Multi):
-                    # domain is a Multi
-                    burst.append(domain)
-
-            # burst now contains all the Domains resulting from the burst.
-            # These are NonInteractionSingles and Multis
-
+#        # 2.2 Burst the shells with the following conditions
+#        # -shell is in the burst radius (intruder)
+#        # -shell is burstable (not Multi)
+#        # -shell is not newly made
+#        # -shell is not already a zero shell (just bursted)
+#        burst = []
+#        if intruders:
+#
+#            # TODO replace this with burst_non_multis
+#            for domain, _ in intruders:
+#                if not isinstance(domain, Multi) and \
+#                   not self.t == domain.last_time and \
+#                   not domain.dt == 0.0:
+#                    # domain is Single or Pair of some subclass
+#                    single_list = self.burst_domain(domain)
+#                    burst.extend(single_list)
+#                elif isinstance(domain, Multi):
+#                    # domain is a Multi
+#                    burst.append(domain)
+#
+#            # burst now contains all the Domains resulting from the burst.
+#            # These are NonInteractionSingles and Multis
 
-        # 2.3 get the closest object (a Domain or surface) which can be a
-        # partner for a new domain. This can be:
-        # zero-shell NonInteractionSingle -> Pair or Multi
-        # Multi -> Multi
-        # Surface -> Interaction
-#        closest_obj, closest_distance = self.geometrycontainer.get_closest_obj(single_pos, self.domains,
-#                                                                        ignore=[single.domain_id],
-#                                                                        ignores=[single.structure.id])
 
-        # New situation -> re-get the neighbors
-        # TODO: modify the existing neighbor list by removing burst domains, and adding the new ones + distance
-        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+#        # New situation -> re-get the neighbors
+#        # TODO: modify the existing neighbor list by removing burst domains, and adding the new ones + distance
+#        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
 
+        # 2.3 From the updated list of neighbors, we calculate the thresholds (horizons) for trying to form
+        #     the various domains. The domains can be:
+        # -zero-shell NonInteractionSingle -> Pair or Multi
+        # -Surface -> Interaction
+        # -Multi -> Multi
+        # Note that we do not differentiate between directions. This means that we
+        # look around in a sphere, the horizons are spherical
         pair_partners = []
-        for domain, _ in neighbors:
+        for domain, _ in neighbor_distances:
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
                 pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
                 pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
                 pair_partners.append((domain, pair_distance - pair_horizon))
-
         
-        # Potential partners are also surfaces but only if the particle is in 3D
         interaction_partners = []
-        if isinstance(single, SphericalSingle):
-            # TODO get a list of the surfaces sorted by distance instead of just the closest
-            closest_surface, surface_distance = \
-             get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
-            if closest_surface:
-                surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
-                interaction_partners = [(closest_surface, surface_distance - surface_horizon), ]
-            # else no interaction is possible
+        for surface, distance in surface_distances:
+            surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+            interaction_partners.append((surface, distance - surface_horizon))
 
         pair_interaction_partners = pair_partners + interaction_partners
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
 
-#        ### START LEGACY
-#        partners = burst
-#        dists = []
-#        if partners:
-##            for domain, _ in partners:
-##            if isinstance(domain, NonInteractionSingle):
-#            # sort partners by distance
-#            dists = self.obj_distance_array(single_pos, partners)
-#            if len(dists) >= 2:
-#                n = dists.argsort()
-#                partners = numpy.take(partners, n)      # sort the potential partners using the index
-#                dists = dists.take(n)                   # sort the distances using the index
-#        ### END LEGACY
-
-
-        # 2.4 calculate the thresholds (horizons) for trying to form the various domains.
-        # Note that we do not differentiate between directions. This means that we
-        # look around in a sphere, the horizons are spherical
-
-        # 2.4 check that the object is a potential partner for an
-        # -Pair         (a zero dt NonInteractionSingle)
-        # -Interaction  (a surface)
-        # -Multi        (a zero dt NonInteractionSingle or Multi)
+        # For each particles/particle or particle/surface pair, check if a pair of interaction can be
+        # made. Note that we check the closest one first and only check if the object are within the horizon
         domain = None
         for obj, hor_overlap in pair_interaction_partners:
 
             if hor_overlap > 0.0 or domain:
-                break       # there are no more potential partners (everything is out of range)
-                            # or a domain was formed successfully previously
+                # there are no more potential partners (everything is out of range)
+                # or a domain was formed successfully previously
+                break
 
             if isinstance(obj, NonInteractionSingle):
-                # try making a Pair (can still be Mixed Pair or Normal Pair)
+                # try making a Pair (can be Mixed Pair or Normal Pair)
                 domain = self.try_pair (single, obj)
 
             elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
@@ -1272,14 +1232,14 @@ def make_new_domain(self, single):
 
 
         if not domain:
-            # No Pair or Interaction could be formed
+            # No Pair or Interaction domain was formed
             # Now choose between NonInteractionSingle and Multi
 
             # make a new list of potential partners
             # Is now zero-dt NonInteractionSingles and Multi's
             # TODO: combine with first selection such that we have to do this loop only once
             multi_partners = []
-            for domain, dist_to_shell in neighbors:
+            for domain, dist_to_shell in neighbor_distances:
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                     multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
                     # distance from the center of the particles/domains
@@ -1293,21 +1253,13 @@ def make_new_domain(self, single):
                     multi_horizon = (single_radius * self.MULTI_SHELL_FACTOR)
                     multi_partners.append((domain, dist_to_shell - multi_horizon))
 
-
-            # Potential partners are also surfaces
-            interaction_partners = []
-            if isinstance(single, SphericalSingle):
-                # TODO get a list of the surfaces sorted by distance instead of just the closest
-                closest_surface, surface_distance = \
-                    get_closest_surface(self.world, single_pos, ignore=[single.structure.id])
-                if closest_surface:
-                    surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
-                    interaction_partners = [(closest_surface, surface_distance - surface_horizon), ]
+            # Also add surfaces
+            for surface, distance in surface_distances:
+                surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
+                multi_partners.append((surface, distance - surface_horizon))
                 # else no interaction is possible
 
-            multi_partners = multi_partners + interaction_partners
-
-
+            # get the closest object (if there)
             if multi_partners:
                 multi_partners = sorted(multi_partners, key=lambda domain_overlap: domain_overlap[1])
 #                log.debug('multi_partners: %s' % str(multi_partners))
@@ -1318,6 +1270,7 @@ def make_new_domain(self, single):
 
             log.debug('Single or Multi: closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
 
+            # If the closest partner is within the multi horizon we do Multi, otherwise Single
             if closest_overlap > 0.0: 
                 # just make a normal NonInteractionSingle
                 self.update_single(single)
@@ -2262,10 +2215,10 @@ def add_to_multi_recursive(self, domain, multi):
             self.remove_domain(domain)
             self.remove_event(domain)
 
-            # 4. Neighbors with overlapping 'multi_horizons' that are:
-            #    - Multi or
-            #    - just bursted (initialized) NonInteractionSingles
-            #    are added recursively to the multi
+            # 4. Add recursively to multi, neighbors that:
+            #    - have overlapping 'multi_horizons'
+            #    - are Multi or
+            #    - are just bursted (initialized) NonInteractionSingles
             for neighbor, dist_to_shell in neighbor_distances:
                 if (isinstance (neighbor, NonInteractionSingle) and neighbor.is_reset()):
                     multi_horizon = (domain.pid_particle_pair[1].radius + neighbor.pid_particle_pair[1].radius) * \
@@ -2352,6 +2305,7 @@ def merge_multis(self, multi1, multi2):
         del self.domains[multi1.domain_id]
         self.remove_event(multi1)
 
+
     def domain_distance(self, pos, domain):
         # calculates the shortest distance from 'pos' to A shell (a Multi
         # can have multiple) of 'domain'.

From 72e0825a2faf20bde6a9894bab879f9ea10e35f1 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 5 Dec 2011 16:41:07 +0100
Subject: [PATCH 0438/1541] Included drift in approximations. Except for c.d.f.
 needed in drawR. However, these functions are not used yet but might be
 needed in the future.

---
 GreensFunction1DAbsAbs.cpp     |  70 +++++++-------
 GreensFunction1DAbsSinkAbs.cpp |  19 ++--
 GreensFunction1DRadAbs.cpp     |  14 ++-
 freeFunctions.cpp              | 172 +++++++++++++++++++++++++--------
 freeFunctions.hpp              |  30 +++---
 5 files changed, 195 insertions(+), 110 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index f71d0b85..60e64348 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -36,7 +36,7 @@ uint GreensFunction1DAbsAbs::guess_maxi(Real const& t) const
     const Real D( getD() );
     const Real L( fabs( geta() - getsigma() ) );
 
-    const Real root0( M_PI );
+    const Real root0( M_PI / L);
     const Real Dt(D * t);
 
     const Real thr(exp(- Dt * root0 * root0) * EPSILON * 1e-1);
@@ -98,20 +98,17 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
     const Real maxDist( CUTOFF_H * sqrt(2.0 * D * t) );
     
     //TODO: No drift included for approximations.
-    if( v == 0.0 )
+    if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
     {
-        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
-        {
-            if( distTos > maxDist )//And radiation boundary 'not in sight'.
-                return 1.0; //No prob. outflux.
-            else
-                return XS10(t, distTos, D); //Only absorbing BCn of s.
-        }
+        if( distTos > maxDist )//And radiation boundary 'not in sight'.
+            return 1.0; //No prob. outflux.
         else
-        {
-            if( distTos > maxDist )
-                return XS10(t, distToa, D ); //Only absorbing BCn of a.
-        }
+            return XS10(t, distTos, D, v); //Only absorbing BCn of s.
+    }
+    else
+    {
+        if( distTos > maxDist )
+            return XS10(t, distToa, D, v ); //Only absorbing BCn of a.
     }
 
     const uint maxi( guess_maxi(t) );
@@ -148,7 +145,8 @@ Real GreensFunction1DAbsAbs::p_survival_i( uint i,
                                            Real const& t, 
                                            RealVector const& table) const
 {
-    return exp( - getD() * t * gsl_pow_2( (i + 1) * M_PI ) ) * table[ i ];
+    const Real L( geta() - getsigma() );
+    return exp( - getD() * t * gsl_pow_2( (i + 1) * M_PI / L ) ) * table[ i ];
 }
 
 
@@ -177,15 +175,14 @@ Real GreensFunction1DAbsAbs::p_survival_table_i_v( uint const& i ) const
 /* Calculates the part of the i'th term of p_surv not dependent on t, without drift */
 Real GreensFunction1DAbsAbs::p_survival_table_i_nov( uint const& i ) const
 {
-    Real nPI;
+    Real nPI( ((Real)(i+1))*M_PI );
 
-    const Real sigma(this->getsigma());
-    const Real L(this->geta() - this->getsigma());
-    const Real r0(this->getr0());
+    const Real sigma( getsigma() );
+    const Real L( geta() - getsigma() );
+    const Real r0( getr0() );
     
-    const Real r0s_L((r0-sigma)/L);
+    const Real r0s_L( (r0-sigma) / L );
         
-    nPI = ((Real)(i+1))*M_PI;
     return sin( nPI * r0s_L ) * (1.0 - cos(nPI)) / nPI;
 }
 
@@ -513,23 +510,22 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
 
     if( value < 0.0 )
     {
-	// scale the interval around the guess such that the function 
-	// straddles if the guess was too low
-	do
-	{
-	    // keep increasing the upper boundary until the 
-	    // function straddles
-	    high *= 10.0;
-	    value = GSL_FN_EVAL( &F, high );
-
-	    if( fabs( high ) >= t_guess * 1e6 )
-	    {
-            std::cerr << "Couldn't adjust high. F(" << high << ") = "
-                      << value << std::endl;
-            throw std::exception();
-	    }
-	}
-	while ( value <= 0.0 );
+        // scale the interval around the guess such that the function 
+        // straddles if the guess was too low
+        do
+        {
+            if( fabs( high ) >= t_guess * 1e6 )
+            {
+                std::cerr << "Couldn't adjust high. F(" << high << ") = "
+                          << value << std::endl;
+                throw std::exception();
+            }
+            // keep increasing the upper boundary until the 
+            // function straddles
+            high *= 10.0;
+            value = GSL_FN_EVAL( &F, high );            
+        }
+        while ( value <= 0.0 );
     }
     else
     {
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index df9f96f1..f8ad6d3c 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -287,13 +287,13 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
         if( distToAbs > maxDist )
             return 1.0;
         else
-            return XS10( t, distToAbs, D );  
+            return XS10( t, distToAbs, D, 0.0 );  
     }
     else
     {
         if( distToAbs > maxDist ) //Only sink in sight.
         {
-            return XS030( t, L0, getk(), getD() );
+            return XS030( t, L0, getk(), D );
         }
     }
 
@@ -705,6 +705,7 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
     /* Find a good interval to determine the first passage time.
        First we get the distance to one of the absorbing boundaries or the sink. */
     Real dist( std::min(Lr - L0, Ll + L0) );
+    Real t_guess;
 
     /* For a particle at contact, the time for the particle to be absorbed by the 
        radiation boundary is 4 D / (k*k). If the particle is at a distace x0 from the
@@ -732,22 +733,16 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
         // if the guess was too low
         do
         {
-            // keep increasing the upper boundary until the
-            // function straddles
-            high *= 10;
-            value = GSL_FN_EVAL( &F, high );
-
-            /*
-            std::cerr << "t: " << high << " maxDist: " << CUTOFF_H * sqrt(2.0 * D * high) <<
-                " f(t): " << value << std::endl;
-            */
-
             if( fabs( high ) >= t_guess * 1e10 )
             {
                 std::cerr << "GF1DSink::drawTime Couldn't adjust high. F("
                           << high << ") = " << value << std::endl;
                 throw std::exception();
             }
+            // keep increasing the upper boundary until the
+            // function straddles
+            high *= 10;
+            value = GSL_FN_EVAL( &F, high );
         }
         while ( value <= 0.0 );
     }
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 89065f81..26e65459 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -243,12 +243,12 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
             if( distTos > maxDist ) //Radiation boundary 'not in sight'.
                 return 1.0; //No prob. outflux.
             else
-                return XS30(t, distTos, getk(), getD()); //Only radiation BCn.
+                return XS30(t, distTos, getk(), D, v); //Only radiation BCn.
         }
         else
         {
             if( distTos > maxDist )
-                return XS10(t, distToa, getD() ); //Only absorbing BCn.
+                return XS10(t, distToa, D, v); //Only absorbing BCn.
         }
     }
 
@@ -569,7 +569,6 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
 
     /* Find a good interval to determine the first passage time. */
     Real t_guess;
-    Real dist;
 
     if( k != 0.0 )
     {
@@ -612,17 +611,16 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
         // if the guess was too low
         do
         {
-            // keep increasing the upper boundary until the
-            // function straddles
-            high *= 10;
-            value = GSL_FN_EVAL( &F, high );
-
             if( fabs( high ) >= t_guess * 1e6 )
             {
                 std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
                           << high << ") = " << value << std::endl;
                 throw std::exception();
             }
+            // keep increasing the upper boundary until the
+            // function straddles
+            high *= 10;
+            value = GSL_FN_EVAL( &F, high );
         }
         while ( value <= 0.0 );
     }
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index bdf5da4c..dc1ce1a4 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -85,114 +85,187 @@ Real W(Real a, Real b)
    2 - Reflective boundary.
    3 - Radiation boundary with rate ka.
 
-   Approximation for greensfunction with sink has 3 boundaries: 030
+   The approximation for the greensfunction with a sink has 3 boundaries: 030
    left absorbing boundary, sink, right absorbing boundary.
    
  */
 
-Real XP00( Real r, Real t, Real r0, Real D )
+Real XP00( Real r, Real t, Real r0, Real D, Real v )
 {
     const Real fourDt( 4 * D * t );
-    const Real rminr02( gsl_pow_2( r - r0 ) );
+    const Real rminr0minv2( gsl_pow_2( r - r0 - v * t) );
 
-    return 1. / sqrt( fourDt * M_PI ) * exp( - rminr02 / fourDt );
+    return 1. / sqrt( fourDt * M_PI ) * exp( - rminr0minv2 / fourDt );
 }
 
 
-Real XI00( Real r, Real t, Real r0, Real D )
+Real XI00( Real r, Real t, Real r0, Real D, Real v )
 {
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
-    const Real rminr0( r - r0 );
+    const Real rminr0minv( r - r0 - v * t);
 
-    return 0.5 * ( 1.0 + erf( rminr0 / sqrt4Dt ) );
+    return 0.5 * ( 1.0 + erf( rminr0minv / sqrt4Dt ) );
 }
 
 
-Real XS00( Real t, Real r0, Real D )
+Real XS00( Real t, Real r0, Real D, Real v )
 {
     return 1;
 }
 
 
-Real XP10( Real r, Real t, Real r0, Real D )
+Real XP10( Real r, Real t, Real r0, Real D, Real v )
 {
     const Real fourDt( 4 * D * t );
     const Real rminr02( gsl_pow_2( r - r0 ) );
     const Real rplusr02( gsl_pow_2( r + r0 ) );
+    const Real v_2( v /2.0 );
+
+    Real drift_prefac;
+    if( v == 0.0 )
+        drift_prefac = 1.0;
+    else
+        drift_prefac = exp( v_2 / D * ( r - r0 - v_2 * t ) );   
 
-    return 1. / sqrt( fourDt * M_PI ) * 
+    return drift_prefac / sqrt( fourDt * M_PI ) * 
         ( exp( - rminr02 / fourDt ) - exp( - rplusr02 / fourDt ) );
 }
 
 
-Real XI10( Real r, Real t, Real r0, Real D )
+Real XI10( Real r, Real t, Real r0, Real D, Real v )
 {
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
     const Real rminr0( r - r0 );
     const Real rplusr0( r + r0 );
 
-    const Real temp( 2.0 * erf( r0 / sqrt4Dt ) 
-                     + erf( rminr0/sqrt4Dt ) - erf( rplusr0/sqrt4Dt ) );
+    if( v == 0.0 )
+    {
+
+        const Real temp( 2.0 * erf( r0 / sqrt4Dt ) 
+                         + erf( rminr0/sqrt4Dt ) - erf( rplusr0/sqrt4Dt ) );
 
-    return 0.5 * temp;
+        return 0.5 * temp;
+    }
+    else
+    {
+        //TODO: include c.d.f. with drift. It exists, but is not included yet.
+        return Real();
+    }
 }
 
 
-Real XS10( Real t, Real r0, Real D )
+Real XS10( Real t, Real r0, Real D, Real v )
 {
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
+    const Real vt( v * t );
 
-    return erf( r0 / sqrt4Dt );
+    if( v == 0.0 )
+        return erf( r0 / sqrt4Dt );
+    else
+    {
+        const Real temp( erfc( -(r0 + vt) / sqrt4Dt ) - 
+                         exp(- v * r0 / D ) * erfc( (r0 - vt) / sqrt4Dt) );
+        return 0.5 * temp;
+    }
 }
 
 
-Real XP20( Real r, Real t, Real r0, Real D )
+Real XP20( Real r, Real t, Real r0, Real D, Real v )
 {
     const Real fourDt( 4 * D * t );
+    const Real sqrt4Dt( fourDt );
     const Real rminr02( gsl_pow_2( r - r0 ) );
     const Real rplusr02( gsl_pow_2( r + r0 ) );
 
-    return 1. / sqrt( fourDt * M_PI ) * 
-        ( exp( - rminr02 / fourDt ) + exp( - rplusr02 / fourDt ) );
+    const Real XP20_nov( 1. / sqrt( fourDt * M_PI ) * 
+                         ( exp( - rminr02 / fourDt ) + 
+                           exp( - rplusr02 / fourDt ) ) );
+
+    if( v == 0.0 )
+    {
+        return XP20_nov;
+    }
+    else
+    {
+        const Real v_2( v / 2.0 );
+        const Real drift_prefac( exp( v_2 / D * ( r - r0 - v_2 * t ) ) );
+
+        const Real XP20_v( exp(v_2 / D * (r + r0) + v_2 * v_2 / D * t) 
+                           * erfc( (r + r0 + v * t)/sqrt4Dt ) );
+
+        return drift_prefac * ( v_2 / D * XP20_v + XP20_nov );
+    }
 }
 
 
-Real XI20( Real r, Real t, Real r0, Real D )
+Real XI20( Real r, Real t, Real r0, Real D, Real v )
 {
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
 
-    const Real temp( erf( (r - r0)/sqrt4Dt ) - erf( (r + r0)/sqrt4Dt ) );
-
-    return 0.5 * temp;
+    if( v == 0.0 )
+    {
+        const Real temp( erf( (r - r0)/sqrt4Dt ) - erf( (r + r0)/sqrt4Dt ) );
+        return 0.5 * temp;
+    }
+    else
+    {
+        //TODO: c.d.f. not with drift. But it does exist!
+        return Real();
+    }
 }
 
 
-Real XS20( Real r, Real t, Real r0, Real D )
+Real XS20( Real r, Real t, Real r0, Real D, Real v )
 {
     return 1;
 }
 
 
-Real XP30term( Real r, Real t, Real r0, Real ka, Real D )
+Real XP30term_nov( Real r, Real t, Real r0, Real ka, Real D )
 {
+    r0 = fabs( r0 );
     const Real fourDt( 4 * D * t );
     const Real k_D( ka / D );
     const Real rplusr02( gsl_pow_2( r + r0 ) );
     const Real arg( (r + r0)/sqrt(fourDt) + ka * sqrt( t / D ) );
-    r0 = fabs( r0 );
 
     return -k_D * exp( - rplusr02 / fourDt ) * expxsq_erfc( arg );
 }
 
 
-Real XP30( Real r, Real t, Real r0, Real ka, Real D )
+Real XP30term_v( Real r, Real t, Real r0, Real ka, Real D, Real v )
 {
     r0 = fabs( r0 );
-    return XP20(r, t, r0, D) + XP30term(r, t, r0, ka, D);
+    const Real sqrt4Dt( sqrt( 4 * D * t ) );
+    const Real v_2( v / 2.0 );
+    const Real kplusv2( ka + v_2 );
+
+    const Real erfc_arg( (r + r0 + 2 * kplusv2 * t ) / sqrt4Dt);
+
+    const Real exp_arg( 1 / D * ( kplusv2 * kplusv2 * t + 
+                                  kplusv2 * (r + r0) ) );
+
+    return -exp( exp_arg ) * erfc( erfc_arg );
+}
+
+
+Real XP30( Real r, Real t, Real r0, Real ka, Real D, Real v )
+{
+    r0 = fabs( r0 );
+    if( v == 0.0 )
+        return XP20(r, t, r0, D, 0.0) + XP30term_nov(r, t, r0, ka, D);
+    else
+    {
+        const Real v_2( v / 2.0 );
+        const Real drift_prefac( exp( v_2 / D * ( r - r0 - v_2 * t ) ) );
+        
+        return drift_prefac * ( XP20(r, t, r0, D, 0.0) + 
+                                1/D * (ka - v/2) * XP30term_v(r, t, r0, ka, D, v) );
+    }
 }
 
 
-Real XI30term( Real r, Real t, Real r0, Real ka, Real D )
+Real XI30term_nov( Real r, Real t, Real r0, Real ka, Real D, Real v )
 {
     const Real sqrt4Dt( sqrt(4 * D * t) );
     const Real k_D( ka / D );
@@ -210,21 +283,42 @@ Real XI30term( Real r, Real t, Real r0, Real ka, Real D )
 }
 
 
-Real XI30( Real r, Real t, Real r0, Real ka, Real D )
+Real XI30( Real r, Real t, Real r0, Real ka, Real D, Real v )
 {
     r0 = fabs( r0 );
-    return XI20(r, t, r0, D) + XI30term(r, t, r0, ka, D);
+    if( v == 0.0 )
+        return XI20(r, t, r0, D, 0.0) + XI30term_nov(r, t, r0, ka, D);
+    else
+        //TODO: c.d.f with drift not included yet. Does exist!
+        return Real();
 }
 
 
-Real XS30( Real t, Real r0, Real ka, Real D )
+Real XS30( Real t, Real r0, Real ka, Real D, Real v )
 {
+    r0 = fabs( r0 );
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
     const Real k_D( ka / D );
-    r0 = fabs( r0 );
 
-    return erf( r0 / sqrt4Dt ) + 
-        exp( k_D * ka * t + k_D * r0 ) * erfc( (2 * ka * t + r0) / sqrt4Dt );
+    if( v == 0.0 )
+        return erf( r0 / sqrt4Dt ) + 
+            exp( k_D * ka * t + k_D * r0 ) * erfc( (2 * ka * t + r0) / sqrt4Dt );
+    else
+    {
+        const Real v_2( v / 2.0 );
+        const Real kplusv2( ka + v_2 );
+        const Real r0plusvt( r0 + v * t );
+        const Real r0minvt( r0 - v * t );
+
+        const Real erfc_arg( ( r0 + 2 * kplusv2 * t ) / sqrt4Dt);
+
+        const Real exp_arg( k_D * ( r0 + (ka + r0) * t ) );
+
+        const Real term2( erfc( -r0plusvt / sqrt4Dt ) - 
+                          ka / (ka + v) * exp(v / D * r0) * erfc( r0minvt/sqrt4Dt ) );
+        
+        return (ka + v_2)/(ka + v) * exp( exp_arg ) * erfc( erfc_arg ) + 0.5 * term2;
+    }
 }
 
 
@@ -232,7 +326,7 @@ Real XP030( Real r, Real t, Real r0, Real ka, Real D )
 {
     r0 = fabs( r0 );
 
-    return XP00(r, t, r0, D) + .5 * XP30term(fabs(r), t, r0, .5 * ka, D);
+    return XP00(r, t, r0, D, 0.0) + .5 * XP30term_nov(fabs(r), t, r0, .5 * ka, D);
 }
 
 
@@ -245,14 +339,14 @@ Real XI030( Real r, Real t, Real r0, Real ka, Real D )
     if( r < 0 )
         sign *= -1;
 
-    return XI00(r, t, r0, D) + .5 * ( ( XS30(t, r0, ka, D) - 1 ) + 
-                                      sign * XI30term( fabs(r), t, r0, ka, D ) );
+    return XI00(r, t, r0, D, 0.0) + .5 * ( ( XS30(t, r0, ka, D, 0.0) - 1 ) + 
+                                           sign * XI30term_nov( fabs(r), t, r0, ka, D ) );
 }
 
 
 Real XS030( Real t, Real r0, Real ka, Real D )
 {
-    return XS30( t, fabs( r0 ), 0.5 * ka, D );
+    return XS30( t, fabs( r0 ), 0.5 * ka, D, 0.0 );
 }
 
 
diff --git a/freeFunctions.hpp b/freeFunctions.hpp
index a81eb329..f7ae61fa 100644
--- a/freeFunctions.hpp
+++ b/freeFunctions.hpp
@@ -10,33 +10,35 @@ Real W(Real a, Real b);
 /* Functions needed in 1D Green's functions. For
    explanation, see the cpp file. */
 
-Real XP00( Real r, Real t, Real r0, Real D );
+Real XP00( Real r, Real t, Real r0, Real D, Real v );
 
-Real XI00( Real r, Real t, Real r0, Real D );
+Real XI00( Real r, Real t, Real r0, Real D, Real v );
 
-Real XS00( Real t, Real r0, Real D );
+Real XS00( Real t, Real r0, Real D, Real v );
 
-Real XP10( Real r, Real t, Real r0, Real D );
+Real XP10( Real r, Real t, Real r0, Real D, Real v );
 
-Real XI10( Real r, Real t, Real r0, Real D );
+Real XI10( Real r, Real t, Real r0, Real D, Real v );
 
-Real XS10( Real t, Real r0, Real D );
+Real XS10( Real t, Real r0, Real D, Real v );
 
-Real XP20( Real r, Real t, Real r0, Real D );
+Real XP20( Real r, Real t, Real r0, Real D, Real v );
 
-Real XI20( Real r, Real t, Real r0, Real D );
+Real XI20( Real r, Real t, Real r0, Real D, Real v );
 
-Real XS20( Real t, Real r0, Real D );
+Real XS20( Real t, Real r0, Real D, Real v );
 
-Real XP30term( Real r, Real t, Real r0, Real ka, Real D );
+Real XP30term_nov( Real r, Real t, Real r0, Real ka, Real D );
 
-Real XP30( Real r, Real t, Real r0, Real ka, Real D );
+Real XP30term_v( Real r, Real t, Real r0, Real ka, Real D, Real v );
 
-Real XI30term( Real r, Real t, Real r0, Real ka, Real D );
+Real XP30( Real r, Real t, Real r0, Real ka, Real D, Real v );
 
-Real XI30( Real r, Real t, Real r0, Real ka, Real D );
+Real XI30term_nov( Real r, Real t, Real r0, Real ka, Real D );
 
-Real XS30( Real t, Real r0, Real ka, Real D );
+Real XI30( Real r, Real t, Real r0, Real ka, Real D, Real v );
+
+Real XS30( Real t, Real r0, Real ka, Real D, Real v );
 
 Real XP030( Real r, Real t, Real r0, Real ka, Real D );
 

From ca1feabcece97464cc1bbb2b65bb94cbcd19dcfe Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 5 Dec 2011 17:13:05 +0100
Subject: [PATCH 0439/1541] some more cleanup of domain making code

---
 egfrd.py | 59 ++++++++++++++++++--------------------------------------
 1 file changed, 19 insertions(+), 40 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f71af38f..ea056113 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1131,13 +1131,10 @@ def make_new_domain(self, single):
             return single
 
 
+        # 0. Get generic info
         single_pos = single.pid_particle_pair[1].position
         single_radius = single.pid_particle_pair[1].radius
 
-        # We prefer to make NonInteractionSingles for efficiency.
-        # But if objects (Shells and surfaces) get close enough (closer than
-        # reaction_threshold) we want to try Interaction and/or Pairs
-
         # 1.0 Get neighboring domains and surfacesget neighboring domains and surfaces
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
@@ -1149,8 +1146,8 @@ def make_new_domain(self, single):
         # Check if there are shells with the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
         # with a sphere (should be cylinder for 2D or 1D particle)
-        reaction_threshold = single.pid_particle_pair[1].radius * \
-                             self.SINGLE_SHELL_FACTOR
+        reaction_threshold = single_radius * self.SINGLE_SHELL_FACTOR
+
 
         # TODO redundant
         intruders = self.geometrycontainer.filter_distance(neighbors, reaction_threshold)
@@ -1158,35 +1155,18 @@ def make_new_domain(self, single):
             log.debug("intruders: %s" %
                       (', '.join(str(i) for i in intruders)))
 
-        neighbor_distances = self.burst_non_multis(neighbors, reaction_threshold)
 
-#        # 2.2 Burst the shells with the following conditions
-#        # -shell is in the burst radius (intruder)
-#        # -shell is burstable (not Multi)
-#        # -shell is not newly made
-#        # -shell is not already a zero shell (just bursted)
-#        burst = []
-#        if intruders:
-#
-#            # TODO replace this with burst_non_multis
-#            for domain, _ in intruders:
-#                if not isinstance(domain, Multi) and \
-#                   not self.t == domain.last_time and \
-#                   not domain.dt == 0.0:
-#                    # domain is Single or Pair of some subclass
-#                    single_list = self.burst_domain(domain)
-#                    burst.extend(single_list)
-#                elif isinstance(domain, Multi):
-#                    # domain is a Multi
-#                    burst.append(domain)
-#
-#            # burst now contains all the Domains resulting from the burst.
-#            # These are NonInteractionSingles and Multis
+        # 2.2 Burst the shells with the following conditions
+        # -shell is in the reaction_threshold (intruder)
+        # -shell is burstable (not Multi)
+        # -shell is not newly made
+        # -shell is not already a zero shell (just bursted)
+        neighbor_distances = self.burst_non_multis(neighbors, reaction_threshold)
 
 
-#        # New situation -> re-get the neighbors
-#        # TODO: modify the existing neighbor list by removing burst domains, and adding the new ones + distance
-#        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+        # We prefer to make NonInteractionSingles for efficiency.
+        # But if objects (Shells and surfaces) get close enough (closer than
+        # reaction_threshold) we want to try Interaction and/or Pairs
 
         # 2.3 From the updated list of neighbors, we calculate the thresholds (horizons) for trying to form
         #     the various domains. The domains can be:
@@ -1195,24 +1175,23 @@ def make_new_domain(self, single):
         # -Multi -> Multi
         # Note that we do not differentiate between directions. This means that we
         # look around in a sphere, the horizons are spherical
-        pair_partners = []
+        pair_interaction_partners = []
         for domain, _ in neighbor_distances:
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
                 pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
                 pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
-                pair_partners.append((domain, pair_distance - pair_horizon))
+                pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
-        interaction_partners = []
-        for surface, distance in surface_distances:
+        for surface, surface_distance in surface_distances:
             surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
-            interaction_partners.append((surface, distance - surface_horizon))
+            pair_interaction_partners.append((surface, surface_distance - surface_horizon))
 
-        pair_interaction_partners = pair_partners + interaction_partners
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
+        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners))
 
-        # For each particles/particle or particle/surface pair, check if a pair of interaction can be
+        # For each particles/particle or particle/surface pair, check if a pair or interaction can be
         # made. Note that we check the closest one first and only check if the object are within the horizon
         domain = None
         for obj, hor_overlap in pair_interaction_partners:
@@ -1257,7 +1236,7 @@ def make_new_domain(self, single):
             for surface, distance in surface_distances:
                 surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
                 multi_partners.append((surface, distance - surface_horizon))
-                # else no interaction is possible
+
 
             # get the closest object (if there)
             if multi_partners:

From 10827c9a731140f1d88625c279668947285eec18 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 6 Dec 2011 10:27:15 +0100
Subject: [PATCH 0440/1541] some comments changed

---
 egfrd.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ea056113..33ca28a6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1135,7 +1135,7 @@ def make_new_domain(self, single):
         single_pos = single.pid_particle_pair[1].position
         single_radius = single.pid_particle_pair[1].radius
 
-        # 1.0 Get neighboring domains and surfacesget neighboring domains and surfaces
+        # 1.0 Get neighboring domains and surfaces
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
         surface_distances = []
@@ -1221,7 +1221,6 @@ def make_new_domain(self, single):
             for domain, dist_to_shell in neighbor_distances:
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                     multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
-                    # distance from the center of the particles/domains
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
                     multi_partners.append((domain, distance - multi_horizon))
 

From ba7cb8bd56e71110b03c86420b1e4a92b57d15ab Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 6 Dec 2011 14:03:42 +0100
Subject: [PATCH 0441/1541] Removing bugs...

---
 GreensFunction1DAbsAbs.cpp |  2 +-
 GreensFunction1DRadAbs.cpp | 35 ++++++++++++++++-------------------
 freeFunctions.cpp          | 28 +++++++++++++++-------------
 greens_functions.cpp       |  9 +++++++++
 multi.py                   |  2 +-
 5 files changed, 42 insertions(+), 34 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 60e64348..cac35a11 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -108,7 +108,7 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
     else
     {
         if( distTos > maxDist )
-            return XS10(t, distToa, D, v ); //Only absorbing BCn of a.
+            return XS10(t, distToa, D, -v); //Only absorbing BCn of a.
     }
 
     const uint maxi( guess_maxi(t) );
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 26e65459..956c35d6 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -212,12 +212,12 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     const Real a(this->geta());
     const Real sigma(this->getsigma());
-    const Real L(this->geta() - this->getsigma());
+    const Real L(a - sigma );
     const Real r0(this->getr0());
     const Real D(this->getD());
     const Real v(this->getv());
 
-    if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
+    if ( fabs(a-r0) < L*EPSILON || L < 0.0 )
     {
         // The survival probability of a zero domain is zero
         return 0.0;
@@ -236,20 +236,17 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
     const Real maxDist( CUTOFF_H * sqrt(2.0 * D * t) );
 
     //TODO: No drift included for approximations.
-    if( v == 0.0 )
+    if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
     {
-        if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
-        {
-            if( distTos > maxDist ) //Radiation boundary 'not in sight'.
-                return 1.0; //No prob. outflux.
-            else
-                return XS30(t, distTos, getk(), D, v); //Only radiation BCn.
-        }
+        if( distTos > maxDist ) //Radiation boundary 'not in sight'.
+            return 1.0; //No prob. outflux.
         else
-        {
-            if( distTos > maxDist )
-                return XS10(t, distToa, D, v); //Only absorbing BCn.
-        }
+            return XS30(t, distTos, getk(), D, v); //Only radiation BCn.
+    }
+    else
+    {
+        if( distTos > maxDist )
+            return XS10(t, distToa, D, -v); //Only absorbing BCn.
     }
 
     const uint maxi( guess_maxi(t) );
@@ -295,11 +292,11 @@ Real GreensFunction1DRadAbs::p_survival_i( uint i,
 Real GreensFunction1DRadAbs::p_survival_table_i_v( uint const& i ) const
 {
     const Real sigma( getsigma() );
-    const Real L( geta() - getsigma() );
+    const Real L( geta() - sigma );
     const Real r0( getr0() );
     const Real D( getD() );
     const Real v( getv() );
-    const Real h( (getk()+v/2.0)/D );
+    const Real h( (getk() + v / 2.0) / D );
 
     const Real v2D(v/2.0/D);
     const Real exp_av2D(exp(a*v2D));
@@ -325,7 +322,7 @@ Real GreensFunction1DRadAbs::p_survival_table_i_nov( uint const& i ) const
     const Real sigma( getsigma() );
     const Real L( geta() - sigma );
     const Real r0( getr0() );
-    const Real h( (getk()+getv()/2.0)/getD());
+    const Real h( getk()/getD() );
 
     const Real root_n ( get_root( i ) );	
     const Real root_n2( root_n * root_n );
@@ -611,7 +608,7 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
         // if the guess was too low
         do
         {
-            if( fabs( high ) >= t_guess * 1e6 )
+            if( fabs( high ) >= t_guess * 1e10 )
             {
                 std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
                           << high << ") = " << value << std::endl;
@@ -632,7 +629,7 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
         Real value_prev( 2 );
         do
         {
-            if( fabs( low ) <= t_guess * 1e-6 ||
+            if( fabs( low ) <= t_guess * 1e-10 ||
                 fabs(value-value_prev) < EPSILON*1.0 )
             {
                 std::cerr << "GF1DRad::drawTime Couldn't adjust low. F(" << low << ") = "
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index dc1ce1a4..a355c26f 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -110,7 +110,7 @@ Real XI00( Real r, Real t, Real r0, Real D, Real v )
 
 Real XS00( Real t, Real r0, Real D, Real v )
 {
-    return 1;
+    return 1.0;
 }
 
 
@@ -204,20 +204,20 @@ Real XI20( Real r, Real t, Real r0, Real D, Real v )
 
     if( v == 0.0 )
     {
-        const Real temp( erf( (r - r0)/sqrt4Dt ) - erf( (r + r0)/sqrt4Dt ) );
+        const Real temp( erf( (r - r0)/sqrt4Dt ) + erf( (r + r0)/sqrt4Dt ) );
         return 0.5 * temp;
     }
     else
     {
-        //TODO: c.d.f. not with drift. But it does exist!
+        //TODO: c.d.f. not with drift. It exist!
         return Real();
     }
 }
 
 
-Real XS20( Real r, Real t, Real r0, Real D, Real v )
+Real XS20( Real t, Real r0, Real D, Real v )
 {
-    return 1;
+    return 1.0;
 }
 
 
@@ -242,8 +242,8 @@ Real XP30term_v( Real r, Real t, Real r0, Real ka, Real D, Real v )
 
     const Real erfc_arg( (r + r0 + 2 * kplusv2 * t ) / sqrt4Dt);
 
-    const Real exp_arg( 1 / D * ( kplusv2 * kplusv2 * t + 
-                                  kplusv2 * (r + r0) ) );
+    const Real exp_arg( 1.0 / D * ( kplusv2 * kplusv2 * t + 
+                                    kplusv2 * (r + r0) ) );
 
     return -exp( exp_arg ) * erfc( erfc_arg );
 }
@@ -252,20 +252,22 @@ Real XP30term_v( Real r, Real t, Real r0, Real ka, Real D, Real v )
 Real XP30( Real r, Real t, Real r0, Real ka, Real D, Real v )
 {
     r0 = fabs( r0 );
+    const Real XP20temp( XP20(r, t, r0, D, 0.0) );
+
     if( v == 0.0 )
-        return XP20(r, t, r0, D, 0.0) + XP30term_nov(r, t, r0, ka, D);
+        return XP20temp + XP30term_nov(r, t, r0, ka, D);
     else
     {
         const Real v_2( v / 2.0 );
         const Real drift_prefac( exp( v_2 / D * ( r - r0 - v_2 * t ) ) );
         
-        return drift_prefac * ( XP20(r, t, r0, D, 0.0) + 
-                                1/D * (ka - v/2) * XP30term_v(r, t, r0, ka, D, v) );
+        return drift_prefac * ( XP20temp + 
+                                1/D * (ka + v/2) * XP30term_v(r, t, r0, ka, D, v) );
     }
 }
 
 
-Real XI30term_nov( Real r, Real t, Real r0, Real ka, Real D, Real v )
+Real XI30term_nov( Real r, Real t, Real r0, Real ka, Real D )
 {
     const Real sqrt4Dt( sqrt(4 * D * t) );
     const Real k_D( ka / D );
@@ -312,10 +314,10 @@ Real XS30( Real t, Real r0, Real ka, Real D, Real v )
 
         const Real erfc_arg( ( r0 + 2 * kplusv2 * t ) / sqrt4Dt);
 
-        const Real exp_arg( k_D * ( r0 + (ka + r0) * t ) );
+        const Real exp_arg( k_D * ( r0 + (ka + v) * t ) );
 
         const Real term2( erfc( -r0plusvt / sqrt4Dt ) - 
-                          ka / (ka + v) * exp(v / D * r0) * erfc( r0minvt/sqrt4Dt ) );
+                          ka / (ka + v) * exp(- v / D * r0) * erfc( r0minvt/sqrt4Dt ) );
         
         return (ka + v_2)/(ka + v) * exp( exp_arg ) * erfc( erfc_arg ) + 0.5 * term2;
     }
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 2b98b633..0f0ce8ac 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -26,6 +26,15 @@ BOOST_PYTHON_MODULE( _greens_functions )
     def( "XP030", XP030 );
     def( "XS030", XS030 );
     def( "XI030", XI030 );
+    
+    def( "XP30", XP30 );
+    def( "XI30", XI30 );
+    def( "XS30", XS30 );
+    
+    def( "XP20", XP20 );
+    def( "XI20", XI20 );
+    def( "XS20", XS20 );
+    
     def( "p_irr", p_irr );
     def( "p_survival_irr", p_survival_irr );
     def( "p_theta_free", p_theta_free );
diff --git a/multi.py b/multi.py
index ba0646b7..9b079d41 100644
--- a/multi.py
+++ b/multi.py
@@ -31,7 +31,7 @@ def initialize(self, t):
         self.start_time = t
         main = self.main()
         self.set_dt_and_reaction_length()
-        print "BD intit, dt = %s, rl = %s" %(self.dt, self.reaction_length)
+        #print "BD intit, dt = %s, rl = %s" %(self.dt, self.reaction_length)
         #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):

From b03b61f28f05718bba5a95f24c193dfbe8d5fb7e Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 6 Dec 2011 20:46:21 +0100
Subject: [PATCH 0442/1541] Changed drawR in 1DAbsAbs as a switchbox. Used
 W(a,b) function for convergence of XS30. Included logging in GF's, instead of
 using cerr.

---
 GreensFunction1DAbsAbs.cpp     | 252 ++++++++++++++++-----------------
 GreensFunction1DAbsAbs.hpp     |  35 +++--
 GreensFunction1DAbsSinkAbs.cpp |  46 +++---
 GreensFunction1DAbsSinkAbs.hpp |   3 +
 GreensFunction1DRadAbs.cpp     |  40 +++---
 GreensFunction1DRadAbs.hpp     |   3 +
 freeFunctions.cpp              |   4 +-
 7 files changed, 198 insertions(+), 185 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index cac35a11..b720f1ec 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -113,9 +113,8 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi == MAX_TERMS )
-        std::cerr << "1DAbs::drawT: maxi was cut to MAX_TERMS for t = " 
-                  << t << std::endl;
+    if( maxi >= MAX_TERMS )
+        log_.warn("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
     
     if (psurvTable.size() < maxi)
     {
@@ -257,7 +256,7 @@ Real GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     {
         if (n >= MAX_TERMS )
         {
-            std::cerr << "Too many terms for GF1DAbs::prob_r. N: " << n << std::endl;
+            log_.warn("Too many terms for prob_r. N: %6u", n);
             break;
         }
 
@@ -317,16 +316,16 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     const Real r0s_L((r0-sigma)/L);
     const Real vexpo(-v*v*t/4.0/D - v*(r0-sigma)/2.0/D);
     
-    Real n = 0;
+    uint n = 0;
     do
     {
         if (n >= MAX_TERMS )
         {
-            std::cerr << "Too many terms for GF1DAbs::leaves. N: " << n << std::endl;
+            log_.warn("Too many terms for leaves. N: %6u", n);
             break;
         }
 
-        nPI = (n + 1) * M_PI;
+        nPI = (Real (n + 1.0)) * M_PI;
         prev_term = term;
         term = nPI * exp( nPI * nPI * expo) * sin( nPI * r0s_L );
         sum += term;
@@ -377,7 +376,7 @@ GreensFunction1DAbsAbs::leavea(Real t) const
      {
          if (n >= MAX_TERMS )
          {
-             std::cerr << "Too many terms for GF1DAbs::leavea. N: " << n << std::endl;
+             log_.warn("Too many terms for leavea. N: %6u ", n);
              break;
          }
        
@@ -516,8 +515,8 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
         {
             if( fabs( high ) >= t_guess * 1e6 )
             {
-                std::cerr << "Couldn't adjust high. F(" << high << ") = "
-                          << value << std::endl;
+                log_.error("drawTime: couldn't adjust high. F( %.16g ) = %.16g"
+                          , high, value);
                 throw std::exception();
             }
             // keep increasing the upper boundary until the 
@@ -537,10 +536,14 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
             if( fabs( low ) <= t_guess * 1.0e-6 ||
                 fabs(value-value_prev) < EPSILON*this->t_scale )
             {
+                log_.warn("drawTime: couldn't adjust low. F( %.16g ) = %.16g"
+                          , low, value);
+                /*
                 std::cerr << "GF1DAbs::drawTime Couldn't adjust low. F(" << low << ") = "
                           << value << " t_guess: " << t_guess << " diff: "
                           << (value - value_prev) << " value: " << value
                           << " value_prev: " << value_prev << std::endl;
+                */
                 return low;
             }
 
@@ -569,40 +572,55 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
     return t;
 }
 
-Real GreensFunction1DAbsAbs::drawR_free_f(Real r, drawR_params const* params)
-{
-    const Real D(params->H[0]);
-    const Real vt(params->H[1]*params->H[2]);
-    const Real sqrt4Dt(sqrt( 4 * D * params->H[2] ));
-
-    return 0.5*( 1.0 + erf( (r - vt) / sqrt4Dt ) ) - params->rnd;
-}
-
-// This is a help function that casts the drawR_params parameter structure into
-// the right form and calculates the survival probability from it (and returns it).
-// The routine drawR uses this function to sample the exit point, making use of the
-// GSL root finder to draw the random position.
-Real
-GreensFunction1DAbsAbs::drawR_f (Real r, drawR_params const* params)
+Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r, 
+                                           Real const& t, 
+                                           RealVector& table) const
 {   
+    const Real a( geta() );
+    const Real sigma( getsigma() );
+    const Real L( a - sigma );
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real v( getv() );
+    const Real vt( v*t );
+    const Real v2D( getv()/(2*D) );
+
     Real sum = 0, term = 0, prev_term = 0;
     Real S_Cn_An, n_L;
-    uint terms = params->terms;
-    Real sigma = params->H[0];
-    Real v2D = params->H[1];	// =v/(2D)
+
+    const Real maxDist(CUTOFF_H * sqrt(2.0 * D * t));
+    const Real distToAbs( std::min(a - r0 - vt, r0 + vt - sigma ) );
+    if ( distToAbs > maxDist )
+    {
+        return XI00(r, t, r0, D, v);
+    }
+
+
+    const uint maxi( guess_maxi( t ) );
+    if( table.size() < maxi )
+    {
+        createP_int_r_Table(t, maxi, table);
+    }
+    
+    if( maxi >= MAX_TERMS )
+    {
+        log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
+        std::cerr << dump();
+        std::cerr << "L: " <<  L << " r0: " << r0 - sigma << std::endl;
+    }
 
     uint n = 0;
     do
     {
-        if (n >= terms )
+        if (n >= maxi )
         {
-            std::cerr << "Too many terms for DrawR. N: " << n << std::endl;
+            log_.info("Too many terms needed for DrawR. N: %6u", n );
             break;
         }
         prev_term = term;
         
-        S_Cn_An = params->S_Cn_An[n];
-        n_L = params->n_L[n];	// this is n*pi/L
+        S_Cn_An = table[n];
+        n_L = ((Real)(n + 1.0)) * M_PI / L;
         if(v2D==0.0)	
             term = S_Cn_An * ( 1.0 - cos(n_L*(r-sigma)) );
         else		
@@ -610,11 +628,10 @@ GreensFunction1DAbsAbs::drawR_f (Real r, drawR_params const* params)
                                ( v2D/n_L*sin(n_L*(r-sigma)) 
                                  - cos(n_L*(r-sigma)) ));
 
-	  // S_Cn_An contains all expon. prefactors, the 1/S(t) term and all parts
-	  // of the terms that do not depend on r.
-	  //
-	  // In case of zero drift the terms become S_An_Cn * ( 1 - cos(nPi/L*(r-sigma)) )
-	  // as it should be. The if-statement is only to avoid calculation costs.
+        // S_Cn_An contains all expon. prefactors, the 1/S(t) term and all parts
+        // of the terms that do not depend on r.
+        // In case of zero drift the terms become S_An_Cn * ( 1 - cos(nPi/L*(r-sigma)) )
+        // as it should be. The if-statement is only to avoid calculation costs.
 
         sum += term;
         n++;
@@ -623,14 +640,59 @@ GreensFunction1DAbsAbs::drawR_f (Real r, drawR_params const* params)
            fabs(prev_term/sum) > EPSILON ||
            n < MIN_TERMS );
 
-    // find the intersection with the random number
-    return sum - params->rnd;
+    return sum;
 }
 
-// Draws the position of the particle at a given time from p(r,t), assuming 
-// that the particle is still in the domain
-Real
-GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
+/* Fills table for p_int_r of factors independent of r. */
+void GreensFunction1DAbsAbs::createP_int_r_Table( Real const& t,
+                                                  uint const& maxi,
+                                                  RealVector& table ) const
+{    
+    uint n( table.size() );
+
+    const Real sigma( getsigma() );
+    const Real L( geta() - getsigma() );
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real v( getv() );
+
+    const Real expo (-D*t/(L*L));
+    const Real r0s_L((r0-sigma)/L);
+    const Real Lv2D(L*v/2.0/D);
+    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+
+    Real S_Cn_An;
+    Real nPI;
+    Real psurv;
+
+    psurv = p_survival(t);
+    assert(psurv >= 0.0);
+    const Real S = 2.0*exp(vexpo)/psurv;
+
+    while( n < maxi )
+    {
+        nPI = ((Real)(n+1))*M_PI;	    // note: summation starting with n=1, indexing with n=0, therefore we need n+1 here
+	    
+        if( v == 0.0 )
+            S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
+        else
+            S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) * nPI/(nPI*nPI + Lv2D*Lv2D);
+
+        table.push_back( S_Cn_An );
+        n++;
+    }
+}
+
+/* Function for GSL rootfinder of drawR. */
+Real GreensFunction1DAbsAbs::drawR_f(Real r, void *p)
+{
+    struct drawR_params *params = (struct drawR_params *)p;
+    return params->gf->p_int_r_table(r, params->t, params->table) - params->rnd;
+}
+
+/* Draws the position of the particle at a given time from p(r,t), assuming 
+   that the particle is still in the domain */
+Real GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
 {
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
@@ -641,112 +703,35 @@ GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     const Real r0(this->getr0());
     const Real D(this->getD());
     const Real v(this->getv());
-    const Real vt( v*t );
 
     // the trivial case: if there was no movement or the domain was zero
-    if ( (D==0.0 && v==0.0) || L<0.0 || t==0.0)
-    {
-	return r0;
-    }
-    else
-    {
-	// if the initial condition is at the boundary, raise an error
-	// The particle can only be at the boundary in the ABOVE cases
-	THROW_UNLESS( std::invalid_argument,
-	              (r0-sigma) >= L*EPSILON && (r0-sigma) <= L*(1.0-EPSILON) );
-    }
-    // else the normal case
-    // From here on the problem is well defined
-
-
-    const Real maxDist(CUTOFF_H * sqrt(2.0 * D * t));
-    const Real distToa( a - r0 - vt );
-    const Real distTos( r0 + vt - sigma );
-
-    struct drawR_params parameters;
-    gsl_function F;
-    F.params = &parameters;
-    Real psurv;
-
-    const uint maxi( guess_maxi( t ) );
-
-    if (distTos < maxDist || distToa < maxDist)
+    if ( (D == 0.0 && v == 0.0) || L < 0.0 || t == 0.0)
     {
-        psurv = p_survival(t);
-
-        assert(psurv >= 0.0);
-
-        // structure to store the numbers to calculate numbers for 1-S(t)
-        Real S_Cn_An;
-        Real nPI;
-        const Real expo (-D*t/(L*L));
-        const Real r0s_L((r0-sigma)/L);
-        const Real v2D(v/2.0/D);
-        const Real Lv2D(L*v/2.0/D);
-        const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);	// exponent of the drift-prefactor, same as in survival prob.
-        const Real S = 2.0*exp(vexpo)/psurv;	// This is a prefactor to every term, so it also contains there
-							// exponential drift-prefactor.
-
-        // store needed constants
-        parameters.H[0] = sigma;
-        parameters.H[1] = v2D;
-
-        // Construct the coefficients and the terms in the exponent and put them 
-        // in the params structure
-        uint n = 0;
-        do
-        {
-	        nPI = ((Real)(n+1))*M_PI;	    // note: summation starting with n=1, indexing with n=0, therefore we need n+1 here
-	    
-	        if(v==0.0)	S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
-	        else		S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) * nPI/(nPI*nPI + Lv2D*Lv2D);
-	        // The rest is the z-dependent part, which has to be defined directly in drawR_f(z).
-	        // Of course also the summation happens there because the terms now are z-dependent.
-	        // The last term originates from the integrated prob. density including drift.
-	        //
-	        // In case of zero drift this expression becomes: 2.0/p_survival(t) * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI
-	      
-	        // also store the values for the exponent, so they don't have to be recalculated in drawR_f
-	        parameters.S_Cn_An[n]= S_Cn_An;
-	        parameters.n_L[n]    = nPI/L;
-	        n++;
-        }
-        while (n<maxi);
-    
-        F.function = reinterpret_cast<typeof(F.function)>(&drawR_f);
+        return r0;
     }
     else
     {
-        parameters.H[0] = D;
-        parameters.H[1] = v;
-        parameters.H[3] = t;
-
-        // drawR_f < drawR_free_f
-        if (drawR_free_f(L, &parameters) < rnd)
-        {
-            std::cerr << "drawR_free_f(L, t) < rnd, returning (r0 - sigma) <= (a - r0) ? sigma : a" << std::endl;
-            return (r0 - sigma) <= (a - r0) ? sigma : a;
-        }
-    
-        F.function = reinterpret_cast<typeof(F.function)>(&drawR_free_f);
+        // if the initial condition is at the boundary, raise an error
+        // The particle can only be at the boundary in the ABOVE cases
+        THROW_UNLESS( std::invalid_argument,
+                      (r0-sigma) >= L*EPSILON && (r0-sigma) <= L*(1.0-EPSILON) );
     }
     
-    // store the random number for the probability
-    parameters.rnd = rnd ;
-    // store the number of terms used
-    parameters.terms = maxi;
-   
+    RealVector pintTable;
+    struct drawR_params parameters = { this, t, pintTable, rnd};
+    gsl_function F;
+    F.function = &drawR_f;
+    F.params = &parameters; 
 
     // find the intersection on the y-axis between the random number and the function
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+
     // make a new solver instance
-    // TODO: incl typecast?
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     const Real r( findRoot( F, solver, sigma, a, L*EPSILON, EPSILON,
                             "GreensFunction1DAbsAbs::drawR" ) );
 
-    // return the drawn position
     return r;
 }
 
@@ -757,3 +742,6 @@ std::string GreensFunction1DAbsAbs::dump() const
         ", a = " << this->geta() << std::endl;
     return ss.str();
 }
+
+Logger& GreensFunction1DAbsAbs::log_(
+        Logger::get_logger("GreensFunction1DAbsAbs"));
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 99a89e7c..a5b9f487 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -23,6 +23,7 @@
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "funcSum.hpp"
 #include "freeFunctions.hpp"
+#include "Logger.hpp"
 
 #include "GreensFunction.hpp"
 #include "PairGreensFunction.hpp"	// needed to declare EventType
@@ -40,7 +41,7 @@ class GreensFunction1DAbsAbs: public GreensFunction
     // The typical timescale of the system, may also not be true!!
     static const Real T_TYPICAL = 1E-6;
     // measure of 'sameness' when comparing floating points numbers
-    static const Real EPSILON = 1E-12;
+    static const Real EPSILON = 1E-10;
     //E3; Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms in the sum
@@ -178,7 +179,18 @@ class GreensFunction1DAbsAbs: public GreensFunction
         Real rnd;
     };
 
-    static double drawT_f (double t, void *p);
+   struct drawR_params
+    {
+        GreensFunction1DAbsAbs const* gf;
+        const Real t;
+        RealVector table;
+        Real rnd;
+    };
+
+    uint guess_maxi(Real const& t ) const;
+
+
+    static Real drawT_f (Real t, void *p);
 
     Real p_survival_table( Real  t, RealVector& psurvTable ) const;
 
@@ -190,21 +202,12 @@ class GreensFunction1DAbsAbs: public GreensFunction
 
     void createPsurvTable( uint const& maxi, RealVector& table) const;
 
-    struct drawR_params
-    {
-        Real S_Cn_An[MAX_TERMS];
-        Real n_L[MAX_TERMS];
-        // variables H: for additional terms appearing as multiplicative factors etc.
-        Real H[5];
-        uint terms;
-        // random number
-        Real rnd;
-    };
 
-    uint guess_maxi(Real const& t ) const;
+    static Real drawR_f (Real z, void* p);
+
+    Real p_int_r_table(Real const& r, Real const& t, RealVector& table) const;
 
-    static Real drawR_f (Real z, drawR_params const* params);
-    static Real drawR_free_f (Real z, drawR_params const* params);
+    void createP_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
 
 private:
     // The diffusion constant and drift velocity
@@ -218,5 +221,7 @@ class GreensFunction1DAbsAbs: public GreensFunction
     Real l_scale;
     // This is the time scale of the system, used by drawTime_f
     Real t_scale;
+
+    static Logger& log_;
 };
 #endif // __GREENSFUNCTION1DABSABS_HPP
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index f8ad6d3c..472b63f9 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -162,10 +162,11 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     /* f_lower must have correct sign. */
     if( f_lower * parity_op > 0 )
     {
-        std::cerr << "Parity error in x_lower of root# " << rootList_size() + 1 
-                      << " in GF::AbsSinkAbs " << std::endl;
-        std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
-                  << upper << ") = " << f_upper << std::endl;
+        log_.warn("Parity error in x_lower of root# %6u .",
+                  rootList_size() + 1);
+
+        log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
+                  lower, f_lower, upper, f_upper);
     }
 
     /* If the parity is incorrect -> correct it */
@@ -186,10 +187,10 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
 
         if(cntr >= 10)
         {
-            std::cerr << "Failed to straddle root # " << rootList_size() + 1 
-                      << " in GF::AbsSinkAbs " << std::endl;
-            std::cerr << "f_low(" << lower << ") = " << f_lower << ", f_high(" 
-                  << upper << ") = " << f_upper << std::endl;
+            log_.warn("Failed to straddle root# %6u . ",
+                      rootList_size() + 1);
+            log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
+                  lower, f_lower, upper, f_upper);
         }
 
     }
@@ -300,8 +301,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
     const uint maxi( guess_maxi(t) );
     
     if( maxi == MAX_TERMS )
-        std::cerr << "1DSink::drawT: maxi was cut to MAX_TERMS for t = " 
-                  << t << std::endl;
+        log_.info("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
         
     if (psurvTable.size() < maxi )
     {
@@ -735,8 +735,8 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
         {
             if( fabs( high ) >= t_guess * 1e10 )
             {
-                std::cerr << "GF1DSink::drawTime Couldn't adjust high. F("
-                          << high << ") = " << value << std::endl;
+                log_.error("drawTime: couldn't adjust high. F( %.16g ) = %.16g"
+                          , high, value);
                 throw std::exception();
             }
             // keep increasing the upper boundary until the
@@ -757,12 +757,16 @@ Real GreensFunction1DAbsSinkAbs::drawTime(Real rnd) const
 	        if( fabs( low ) <= t_guess * 1e-10 ||
 	            fabs(value-value_prev) < EPSILON*1.0 )
 	        {
-		    std::cerr << "GF1DSink::drawTime Couldn't adjust low. F(" << low << ") = "
-		              << value << " t_guess: " << t_guess << " diff: "
-		              << (value - value_prev) << " value: " << value
-		              << " value_prev: " << value_prev << " rnd: "
-		              << rnd << std::endl;
-		    return low;
+                log_.warn("drawTime Couldn't adjust low. F( %.16g ) = %.16g"
+                          , low, value);
+                /*
+                  std::cerr << "GF1DSink::drawTime Couldn't adjust low. F(" << low << ") = "
+                  << value << " t_guess: " << t_guess << " diff: "
+                  << (value - value_prev) << " value: " << value
+                  << " value_prev: " << value_prev << " rnd: "
+                  << rnd << std::endl;
+                */
+                return low;
 	        }
 	        value_prev = value;
 	        // keep decreasing the lower boundary until the function straddles
@@ -803,8 +807,8 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
     const uint maxi( guess_maxi(t) );
 
     if( maxi == MAX_TERMS )
-        std::cerr << "1DSink::p_int_r_table: maxi was cut to MAX_TERMS for t = " 
-                  << t << std::endl;
+        log_.warn("p_int_r_table: maxi was cut to MAX_TERMS for t = %.16g"
+                  , t);
    
     if (table.size() < maxi )
     {
@@ -994,3 +998,5 @@ std::string GreensFunction1DAbsSinkAbs::dump() const
     return ss.str();
 }
 
+Logger& GreensFunction1DAbsSinkAbs::log_(
+        Logger::get_logger("GreensFunction1DAbsSinkAbs"));
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 7bd04a57..1e3b9275 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -24,6 +24,7 @@
 #include "GreensFunction.hpp"
 #include "funcSum.hpp"
 #include "freeFunctions.hpp"
+#include "Logger.hpp"
 
 class GreensFunction1DAbsSinkAbs: public GreensFunction
 {
@@ -352,5 +353,7 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
 
     // Stores params for rootfiner.
     mutable struct lower_upper_params lo_up_params;
+
+    static Logger& log_;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 956c35d6..c4dcc4d6 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -57,10 +57,13 @@ void GreensFunction1DRadAbs::calculate_n_roots(uint const& n) const
     uint i( rootList_size() );
 
     //No drift, and k = 0, use reflective solution.
-    if (h < EPSILON)
+    if (getk() < EPSILON && fabs( getv() ) < EPSILON )
     {
-        while(i++ < n)
-            ad_to_rootList( M_PI * ( n - 1./2 ) / L );
+        while(i < n)
+        {
+            ad_to_rootList( M_PI * ( i + 1.0/2 ) / L );
+            i++;
+        }
         return;
     }
     
@@ -251,9 +254,8 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi == MAX_TERMS )
-        std::cerr << "1DRad::drawT: maxi was cut to MAX_TERMS for t = " 
-                  << t << std::endl;
+    if( maxi >= MAX_TERMS )
+        log_.warn("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
     
     if ( psurvTable.size() < maxi )
     {
@@ -408,8 +410,7 @@ Real GreensFunction1DRadAbs::prob_r (Real r, Real t) const
     {
         if ( n >= MAX_TERMS )
         {
-            std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
-                      << n << std::endl;
+            log_.warn("Too many terms needed for prob_r. N: %5u", n);
             break;
         }
 
@@ -460,8 +461,7 @@ Real GreensFunction1DRadAbs::flux_tot (Real t) const
     {
         if ( n >= MAX_TERMS )
         {
-            std::cerr << "Too many terms needed for GF1DRad::flux_tot. N: "
-                      << n << std::endl;
+            log_.warn("Too many terms needed for flux_tot. N: %5u", n );
             break;
         }
 
@@ -610,8 +610,8 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
         {
             if( fabs( high ) >= t_guess * 1e10 )
             {
-                std::cerr << "GF1DRad::drawTime Couldn't adjust high. F("
-                          << high << ") = " << value << std::endl;
+                log_.error("drawTime: couldn't adjust high. F( %.16g ) = %.16g"
+                          , high, value);
                 throw std::exception();
             }
             // keep increasing the upper boundary until the
@@ -632,11 +632,15 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
             if( fabs( low ) <= t_guess * 1e-10 ||
                 fabs(value-value_prev) < EPSILON*1.0 )
             {
+                log_.warn("drawTime: couldn't adjust low. F( %.16g ) = %.16g"
+                          , low, value);
+                /*
                 std::cerr << "GF1DRad::drawTime Couldn't adjust low. F(" << low << ") = "
                           << value << " t_guess: " << t_guess << " diff: "
                           << (value - value_prev) << " value: " << value
                           << " value_prev: " << value_prev << " rnd: "
                           << rnd << std::endl;
+                */
                 return low;
             }
             value_prev = value;
@@ -659,8 +663,7 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
     return t;
 }
 
-double
-GreensFunction1DRadAbs::drawR_f (double z, void *p)
+Real GreensFunction1DRadAbs::drawR_f (double z, void *p)
 {
     // casts p to type 'struct drawR_params *'
     struct drawR_params *params = (struct drawR_params *)p;
@@ -681,8 +684,7 @@ GreensFunction1DRadAbs::drawR_f (double z, void *p)
     {
         if ( n >= terms )
         {
-            std::cerr << "GF1DRad: Too many terms needed for DrawR. N: "
-                      << n << std::endl;
+            log_.info("Too many terms needed for DrawR. N: %6u", n );
             break;
         }
         prev_term = term;
@@ -746,6 +748,10 @@ GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
     assert(p_survival(t) >= 0.0);
 
     const uint maxi( guess_maxi( t ) );
+
+    if( maxi >= MAX_TERMS )
+        log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
+
     calculate_n_roots( maxi );
 
     // produce the coefficients and the terms in the exponent and put them
@@ -803,3 +809,5 @@ std::string GreensFunction1DRadAbs::dump() const
     return ss.str();
 }
 
+Logger& GreensFunction1DRadAbs::log_(
+        Logger::get_logger("GreensFunction1DRadAbs"));
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 074a0ab9..454f8611 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -24,6 +24,7 @@
 #include "Defs.hpp"
 #include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "GreensFunction.hpp"
+#include "Logger.hpp"
 
 class GreensFunction1DRadAbs: public GreensFunction
 {
@@ -308,5 +309,7 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     /* vector containing the roots 0f tan_f. */
     mutable RealVector rootList;
+
+    static Logger& log_;
 };
 #endif // __GREENSFUNCTION1DRADABS_HPP
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index a355c26f..163648e7 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -303,8 +303,8 @@ Real XS30( Real t, Real r0, Real ka, Real D, Real v )
     const Real k_D( ka / D );
 
     if( v == 0.0 )
-        return erf( r0 / sqrt4Dt ) + 
-            exp( k_D * ka * t + k_D * r0 ) * erfc( (2 * ka * t + r0) / sqrt4Dt );
+        return erf( r0 / sqrt4Dt ) + W( r0 / sqrt4Dt, 2 * ka * t / sqrt4Dt );
+    // exp( k_D * ka * t + k_D * r0 ) * erfc( (2 * ka * t + r0) / sqrt4Dt );
     else
     {
         const Real v_2( v / 2.0 );

From 7ad717fd6ae863526c328d69159db0ba459496b4 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 7 Dec 2011 14:00:52 +0100
Subject: [PATCH 0443/1541] Included final approximations for drawR.

---
 GreensFunction1DAbsAbs.cpp |  38 ++++---
 GreensFunction1DRadAbs.cpp | 216 ++++++++++++++++++++++---------------
 GreensFunction1DRadAbs.hpp |  43 ++++----
 freeFunctions.cpp          |  26 +++--
 greens_functions.cpp       |   6 +-
 5 files changed, 193 insertions(+), 136 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index b720f1ec..136059a3 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -72,12 +72,12 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     Real p;
 
-    const Real a(this->geta());
-    const Real sigma(this->getsigma());
-    const Real L(this->geta() - this->getsigma());
-    const Real r0(this->getr0());
-    const Real D(this->getD());
-    const Real v(this->getv());
+    const Real a( geta() );
+    const Real sigma( getsigma() );
+    const Real L( a - sigma );
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real v( getv() );
 
     if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
     {
@@ -93,9 +93,9 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     /* First check if we need full solution. 
        Else we use approximation. */
-    const Real distToa( geta() - r0 );
-    const Real distTos( r0 - getsigma() );
-    const Real maxDist( CUTOFF_H * sqrt(2.0 * D * t) );
+    const Real distToa( a - r0 );
+    const Real distTos( r0 - sigma );
+    const Real maxDist( CUTOFF_H * (sqrt(2.0 * D * t) + fabs(v*t)) );
     
     //TODO: No drift included for approximations.
     if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
@@ -582,19 +582,27 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
     const Real r0( getr0() );
     const Real D( getD() );
     const Real v( getv() );
-    const Real vt( v*t );
     const Real v2D( getv()/(2*D) );
 
     Real sum = 0, term = 0, prev_term = 0;
     Real S_Cn_An, n_L;
 
-    const Real maxDist(CUTOFF_H * sqrt(2.0 * D * t));
-    const Real distToAbs( std::min(a - r0 - vt, r0 + vt - sigma ) );
-    if ( distToAbs > maxDist )
+    const Real distToa( a - r0 );
+    const Real distTos( r0 - sigma );
+    const Real maxDist( CUTOFF_H * ( sqrt(2.0 * D * t) + fabs(v * t) ) );
+
+    if( distToa > maxDist ) //Absorbing boundary a 'not in sight'.
     {
-        return XI00(r, t, r0, D, v);
+        if( distTos > maxDist ) //Absorbing boundary sigma 'not in sight'.
+            return XI00(r, t, r0, D, v); //free particle.
+        else
+            return XI10(r - sigma, t, distTos, D, v); //Only absorbing BCn at sigma.
+    }
+    else
+    {
+        if( distTos > maxDist )
+            return XI10(a - r, t, distToa, D, -v); //Only absorbing BCn at a.
     }
-
 
     const uint maxi( guess_maxi( t ) );
     if( table.size() < maxi )
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index c4dcc4d6..4b3a4761 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -213,12 +213,12 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     Real p;
 
-    const Real a(this->geta());
-    const Real sigma(this->getsigma());
+    const Real a( geta() );
+    const Real sigma( getsigma() );
     const Real L(a - sigma );
-    const Real r0(this->getr0());
-    const Real D(this->getD());
-    const Real v(this->getv());
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real v( getv() );
 
     if ( fabs(a-r0) < L*EPSILON || L < 0.0 )
     {
@@ -234,11 +234,10 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     /* First check if we need full solution. 
        Else we use approximation. */
-    const Real distToa( geta() - r0 );
-    const Real distTos( r0 - getsigma() );
-    const Real maxDist( CUTOFF_H * sqrt(2.0 * D * t) );
+    const Real distToa( a - r0 );
+    const Real distTos( r0 - sigma );
+    const Real maxDist( CUTOFF_H * ( sqrt(2.0 * D * t) + fabs(v * t) ) );
 
-    //TODO: No drift included for approximations.
     if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
     {
         if( distTos > maxDist ) //Radiation boundary 'not in sight'.
@@ -663,131 +662,174 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
     return t;
 }
 
-Real GreensFunction1DRadAbs::drawR_f (double z, void *p)
+/* Returns c.d.f. for drawR */
+Real GreensFunction1DRadAbs::p_int_r_table(Real const& r, 
+                                           Real const& t, 
+                                           RealVector& table) const
 {
-    // casts p to type 'struct drawR_params *'
-    struct drawR_params *params = (struct drawR_params *)p;
-    Real v2D 		= params->H[0];	// = v2D = v/(2D)
-    Real costerm 	= params->H[1];	// = k/D
-    Real sinterm 	= params->H[2];	// = h*v2D
-    Real sigma 		= params->H[3];	// = sigma
-    uint terms      = params->terms;
+    const Real a( geta() );
+    const Real sigma( getsigma() );
+    const Real L( a - sigma );
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real k( getk() );
+    const Real v( getv() );
+    const Real h(( k + v/2.0)/ D );
+    const Real v2D( v/(2*D) );
 
-    Real expsigma(exp(sigma*v2D));
-    Real zs(z-sigma);
+    /* If not all boundaries are 'visible' to the particle,
+       use approximation. */
+    const Real distToa( a - r0 );
+    const Real distTos( r0 - sigma );
+    const Real maxDist( CUTOFF_H * ( sqrt(2.0 * D * t) + fabs(v * t) ) );
+
+    //TODO: include XI30 (c.d.f) with drift.
+    if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
+    {
+        if( distTos > maxDist ) //Radiation boundary 'not in sight'.
+            return XI00(r, t, r0, D, v); //free particle.
+        else
+        {
+            if( k != 0.0 && v == 0.0 )
+                return XI30(r - sigma, t, distTos, getk(), D, 0.0); //Only radiation BCn.
+            else if( k == 0.0 && v == 0.0 )
+                return XI20(r - sigma, t, distTos, D, 0.0); //Only reflecting BCn.
+        }
+    }
+    else
+    {
+        if( distTos > maxDist )
+            return XI10(a - r, t, distToa, D, -v); //Only absorbing BCn.
+    }
+
+    const uint maxi( guess_maxi( t ) );
+    if( table.size() < maxi )
+    {
+        createP_int_r_Table(t, maxi, table);
+    }
     
+    if( maxi >= MAX_TERMS )
+    {
+        log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
+        std::cerr << dump();
+        std::cerr << "L: " <<  L << " r0: " << r0 - sigma << std::endl;
+    }
+  
+    Real costerm( k / D );	
+    Real sinterm( h * v2D );
+
+    Real expsigma(exp(sigma*v2D));
+    Real zs(r - sigma);
+
     Real sum = 0, term = 0, prev_term = 0;
     Real root_n, S_Cn_root_n;
-    
+
     uint n = 0;
     do
     {
-        if ( n >= terms )
+        if (n >= maxi )
         {
             log_.info("Too many terms needed for DrawR. N: %6u", n );
             break;
         }
         prev_term = term;
         
-        S_Cn_root_n = params->S_Cn_root_n[n];
-        root_n  = params->root_n[n];
-        term = S_Cn_root_n * ( expsigma*costerm - exp(v2D*z)*
+        S_Cn_root_n = table[n];
+        root_n  = get_root( n );
+
+        term = S_Cn_root_n * ( expsigma*costerm - exp(v2D*r)*
                                ( costerm*cos(root_n*zs) - 
                                  (root_n+sinterm/root_n)*sin(root_n*zs) ));
 
         sum += term;
         n++;
     }
-    while (fabs(term/sum) > EPSILON*1.0 ||
-           fabs(prev_term/sum) > EPSILON*1.0 ||
+    while (fabs(term/sum) > EPSILON ||
+           fabs(prev_term/sum) > EPSILON ||
            n < MIN_TERMS );
 
-    // Find the intersection with the random number
-    return sum - params->rnd;
+    return sum;
 }
 
-Real
-GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
-{
-    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
-    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-    
-    const Real sigma(this->getsigma());
-    const Real a(this->geta());
-    const Real L(this->geta()-this->getsigma());
-    const Real r0(this->getr0());
-    const Real D(this->getD());
-    const Real v(this->getv());
-    const Real k(this->getk());
-    const Real h((this->getk()+this->getv()/2.0)/this->getD());
-    
-
-    if (t==0.0 || (D==0.0 && v==0.0) )
-    {
-        // the trivial case
-        //return r0*this->l_scale;	// renormalized version, discontinued
-        return r0;
-    }
-    if ( a<0.0 )
-    {
-        // if the domain had zero size
-        return 0.0;
-    }
+/* Fills table for p_int_r of factors independent of r. */
+void GreensFunction1DRadAbs::createP_int_r_Table( Real const& t,
+                                                  uint const& maxi,
+                                                  RealVector& table ) const
+{    
+    uint n( table.size() );
 
-    // the structure to store the numbers to calculate the numbers for 1-S
-    struct drawR_params parameters;
-    double root_n = 0;
-    double S_Cn_root_n;
-    double root_n2, root_n_r0_s;
+    const Real sigma( getsigma() );
+    const Real L( geta() - getsigma() );
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real v( getv() );
+    const Real h(( k + v/2.0)/ D );
 
     const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D); // exponent of the drift-prefactor, same as in survival prob.
     const Real v2D(v/2.0/D);
     const Real v2Dv2D(v2D*v2D);
-    const Real S = 2.0*exp(vexpo)/p_survival(t); 
-
-    assert(p_survival(t) >= 0.0);
 
-    const uint maxi( guess_maxi( t ) );
-
-    if( maxi >= MAX_TERMS )
-        log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
+    Real psurv;
+    Real S_Cn_root_n;
+    Real root_n2, root_n_r0_s, root_n;
 
-    calculate_n_roots( maxi );
+    psurv = p_survival(t);
+    assert(psurv >= 0.0);
+    const Real S = 2.0*exp(vexpo)/psurv;
 
-    // produce the coefficients and the terms in the exponent and put them
-    // in the params structure
-    for (uint n = 0; n < maxi; n++)
+    while( n < maxi )
     {
-	    root_n = this->get_root(n);  // get the n-th root of tan(alfa*a)=alfa/-k
+        root_n = get_root(n);
        	root_n2 = root_n * root_n;
        	root_n_r0_s = root_n * (r0-sigma);
+
        	S_Cn_root_n =	S * exp(-D*root_n2*t)
 	         * (root_n*cos(root_n_r0_s) + h*sin(root_n_r0_s)) / (L*(root_n2 + h*h) + h)
 	         * root_n / (root_n2 + v2Dv2D);
 
-      	// store the coefficients in the structure
-	    parameters.root_n[n] = root_n;
-        // also store the values for the exponent
-        parameters.S_Cn_root_n[n] = S_Cn_root_n;
+        table.push_back( S_Cn_root_n );
+        n++;
     }
+}
+
+/* Function for GSL rootfinder of drawR. */
+Real GreensFunction1DRadAbs::drawR_f(Real r, void *p)
+{
+    struct drawR_params *params = (struct drawR_params *)p;
+    return params->gf->p_int_r_table(r, params->t, params->table) - params->rnd;
+}
+
+/* Return new position */
+Real GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
+{
+    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
     
-    // also store constant prefactors that appear in the calculation of the
-    // r-dependent terms
-    parameters.H[0] = v2D;		// appears together with z in one of the prefactors
-    parameters.H[1] = k/D;		// further constant terms of the cosine prefactor
-    parameters.H[2] = h*v2D;		// further constant terms of the sine prefactor
-    parameters.H[3] = sigma;
+    const Real sigma( getsigma() );
+    const Real a( geta() );
+    const Real L( a - sigma );
+    const Real r0( getr0() );
+    const Real D( getD() );
+    const Real v( getv() );
+    
+    if (t == 0.0 || (D == 0.0 && v == 0.0) )
+    {
+        return r0;
+    }
+    if ( a < 0.0 )
+    {
+        return 0.0;
+    }
+
+    // the structure to store the numbers to calculate the numbers for 1-S
+    RealVector pintTable;
+    struct drawR_params parameters = {this, t, pintTable, rnd};
 
     // define gsl function for rootfinder
     gsl_function F;
     F.function = &GreensFunction1DRadAbs::drawR_f;
     F.params = &parameters;
 
-    // store the random number for the probability
-    parameters.rnd = rnd;
-    // store the number of terms used
-    parameters.terms = maxi;
-
     // define a new solver type brent
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 454f8611..bef9f976 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -205,6 +205,21 @@ class GreensFunction1DRadAbs: public GreensFunction
         Real h;
     };
 
+    struct drawT_params
+    {
+        GreensFunction1DRadAbs const* gf;
+        RealVector& psurvTable;
+        Real rnd;
+    };
+
+   struct drawR_params
+    {
+        GreensFunction1DRadAbs const* gf;
+        const Real t;
+        RealVector table;
+        Real rnd;
+    };
+
 
     /* Functions managing the rootList */
     
@@ -254,14 +269,9 @@ class GreensFunction1DRadAbs: public GreensFunction
     static double tan_f (double x, void *p);
 
 
-    /* Functions for drawTime */
+    /* functions for drawTime / p_survival */
 
-    struct drawT_params
-    {
-        GreensFunction1DRadAbs const* gf;
-        RealVector& psurvTable;
-        Real rnd;
-    };
+    static double drawT_f (double t, void *p);
 
     Real p_survival_table( Real  t, RealVector& psurvTable ) const;
 
@@ -273,24 +283,15 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     void createPsurvTable( RealVector& table) const;
 
-    
-    /* functions for drawR */
 
-    static double drawT_f (double t, void *p);
+    /* functions for drawR */
 
-    struct drawR_params
-    {
-        double root_n[MAX_TERMS];
-        double S_Cn_root_n[MAX_TERMS];
-        // variables H: for additional terms appearing as multiplicative factors etc.
-        double H[5];
-        uint terms;
-        // the random number associated with the time
-        double rnd;
-    };
+    static Real drawR_f (Real z, void* p);
 
-    static double drawR_f (double z, void *p);
+    Real p_int_r_table(Real const& r, Real const& t, RealVector& table) const;
 
+    void createP_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
+    
 
     /* Member variables */
 
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index 163648e7..8fe45337 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -135,11 +135,11 @@ Real XP10( Real r, Real t, Real r0, Real D, Real v )
 Real XI10( Real r, Real t, Real r0, Real D, Real v )
 {
     const Real sqrt4Dt( sqrt( 4 * D * t ) );
-    const Real rminr0( r - r0 );
-    const Real rplusr0( r + r0 );
 
     if( v == 0.0 )
     {
+        const Real rminr0( r - r0 );
+        const Real rplusr0( r + r0 );
 
         const Real temp( 2.0 * erf( r0 / sqrt4Dt ) 
                          + erf( rminr0/sqrt4Dt ) - erf( rplusr0/sqrt4Dt ) );
@@ -148,8 +148,13 @@ Real XI10( Real r, Real t, Real r0, Real D, Real v )
     }
     else
     {
-        //TODO: include c.d.f. with drift. It exists, but is not included yet.
-        return Real();
+        const Real r0minvt( r0 - v*t);
+        const Real r0plusvt( r0 + v*t );
+
+        const Real term1( erfc( (r0minvt + r)/sqrt4Dt ) - erfc( r0minvt/sqrt4Dt ) );
+        const Real term2( erf( r0plusvt/sqrt4Dt ) - erf( (r0plusvt - r)/sqrt4Dt ) );
+
+        return 0.5 * ( exp(- v * r0 / D ) * term1 + term2 );
     }
 }
 
@@ -209,7 +214,7 @@ Real XI20( Real r, Real t, Real r0, Real D, Real v )
     }
     else
     {
-        //TODO: c.d.f. not with drift. It exist!
+        //TODO: c.d.f. with drift. It exist!
         return Real();
     }
 }
@@ -270,16 +275,17 @@ Real XP30( Real r, Real t, Real r0, Real ka, Real D, Real v )
 Real XI30term_nov( Real r, Real t, Real r0, Real ka, Real D )
 {
     const Real sqrt4Dt( sqrt(4 * D * t) );
-    const Real k_D( ka / D );
     r0 = fabs( r0 );
         
     const Real term1( erf( r0/sqrt4Dt ) - erf( (r+r0)/sqrt4Dt ) );
 
-    const Real term2( exp( k_D * (ka * t + r0) ) * 
-                      erfc( (2 * ka * t + r0)/sqrt4Dt ) );
+    const Real term2( W( r0/sqrt4Dt, 2*ka*t/sqrt4Dt ) );
+
+    //exp( k_D * (ka * t + r0) ) * erfc( (2 * ka * t + r0)/sqrt4Dt ) );
+
+    const Real term3( W( (r + r0)/sqrt4Dt, 2*ka*t/sqrt4Dt ) ); 
 
-    const Real term3( exp( k_D * (ka * t + r0 + r) ) * 
-                      erfc( (2 * ka * t + r0 + r)/sqrt4Dt ) );
+    //exp( k_D * (ka * t + r0 + r) ) * erfc( (2 * ka * t + r0 + r)/sqrt4Dt ) );
 
     return term1 + term2 - term3;
 }
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 0f0ce8ac..ccb6cfbf 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -31,9 +31,9 @@ BOOST_PYTHON_MODULE( _greens_functions )
     def( "XI30", XI30 );
     def( "XS30", XS30 );
     
-    def( "XP20", XP20 );
-    def( "XI20", XI20 );
-    def( "XS20", XS20 );
+    def( "XP10", XP10 );
+    def( "XI10", XI10 );
+    def( "XS10", XS10 );
     
     def( "p_irr", p_irr );
     def( "p_survival_irr", p_survival_irr );

From 442c102792db8ffeca4b81359280f614b34de3ce Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 7 Dec 2011 14:03:33 +0100
Subject: [PATCH 0444/1541] Smallest possible change.

---
 GreensFunction1DAbsAbs.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 136059a3..903a2cfd 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -97,7 +97,6 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
     const Real distTos( r0 - sigma );
     const Real maxDist( CUTOFF_H * (sqrt(2.0 * D * t) + fabs(v*t)) );
     
-    //TODO: No drift included for approximations.
     if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
     {
         if( distTos > maxDist )//And radiation boundary 'not in sight'.

From 847480990f9e517245a7ebb7b7d892c84cbde1e7 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Wed, 7 Dec 2011 14:32:43 +0100
Subject: [PATCH 0445/1541] Forgot normalization with p_survival(t) in
 approximations.

---
 GreensFunction1DAbsAbs.cpp | 14 +++++++++-----
 GreensFunction1DAbsAbs.hpp |  4 +++-
 GreensFunction1DRadAbs.cpp | 17 +++++++++++------
 GreensFunction1DRadAbs.hpp |  4 +++-
 4 files changed, 26 insertions(+), 13 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 903a2cfd..eb3e6fe0 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -572,7 +572,8 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
 }
 
 Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r, 
-                                           Real const& t, 
+                                           Real const& t,
+                                           Real const& p_surv,
                                            RealVector& table) const
 {   
     const Real a( geta() );
@@ -595,12 +596,14 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
         if( distTos > maxDist ) //Absorbing boundary sigma 'not in sight'.
             return XI00(r, t, r0, D, v); //free particle.
         else
-            return XI10(r - sigma, t, distTos, D, v); //Only absorbing BCn at sigma.
+            //Only absorbing BCn at sigma.
+            return XI10(r - sigma, t, distTos, D, v) / p_surv; 
     }
     else
     {
         if( distTos > maxDist )
-            return XI10(a - r, t, distToa, D, -v); //Only absorbing BCn at a.
+            //Only absorbing BCn at a.
+            return XI10(a - r, t, distToa, D, -v) / p_surv;
     }
 
     const uint maxi( guess_maxi( t ) );
@@ -694,7 +697,8 @@ void GreensFunction1DAbsAbs::createP_int_r_Table( Real const& t,
 Real GreensFunction1DAbsAbs::drawR_f(Real r, void *p)
 {
     struct drawR_params *params = (struct drawR_params *)p;
-    return params->gf->p_int_r_table(r, params->t, params->table) - params->rnd;
+    return params->gf->p_int_r_table(r, params->t, params->p_surv, params->table) 
+        - params->rnd;
 }
 
 /* Draws the position of the particle at a given time from p(r,t), assuming 
@@ -725,7 +729,7 @@ Real GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     }
     
     RealVector pintTable;
-    struct drawR_params parameters = { this, t, pintTable, rnd};
+    struct drawR_params parameters = { this, t, pintTable, rnd, p_survival( t )};
     gsl_function F;
     F.function = &drawR_f;
     F.params = &parameters; 
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index a5b9f487..f19e8345 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -185,6 +185,7 @@ class GreensFunction1DAbsAbs: public GreensFunction
         const Real t;
         RealVector table;
         Real rnd;
+        Real p_surv;
     };
 
     uint guess_maxi(Real const& t ) const;
@@ -205,7 +206,8 @@ class GreensFunction1DAbsAbs: public GreensFunction
 
     static Real drawR_f (Real z, void* p);
 
-    Real p_int_r_table(Real const& r, Real const& t, RealVector& table) const;
+    Real p_int_r_table(Real const& r, Real const& t, Real const& p_surv, 
+                       RealVector& table) const;
 
     void createP_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
 
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 4b3a4761..6e75a209 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -664,7 +664,8 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
 
 /* Returns c.d.f. for drawR */
 Real GreensFunction1DRadAbs::p_int_r_table(Real const& r, 
-                                           Real const& t, 
+                                           Real const& t,
+                                           Real const& p_surv,
                                            RealVector& table) const
 {
     const Real a( geta() );
@@ -691,15 +692,18 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
         else
         {
             if( k != 0.0 && v == 0.0 )
-                return XI30(r - sigma, t, distTos, getk(), D, 0.0); //Only radiation BCn.
+                //Only radiation BCn.
+                return XI30(r - sigma, t, distTos, getk(), D, 0.0) / p_surv;
             else if( k == 0.0 && v == 0.0 )
-                return XI20(r - sigma, t, distTos, D, 0.0); //Only reflecting BCn.
+                //Only reflecting BCn.
+                return XI20(r - sigma, t, distTos, D, 0.0);
         }
     }
     else
     {
         if( distTos > maxDist )
-            return XI10(a - r, t, distToa, D, -v); //Only absorbing BCn.
+            //Only absorbing BCn.
+            return XI10(a - r, t, distToa, D, -v) / p_surv;
     }
 
     const uint maxi( guess_maxi( t ) );
@@ -796,7 +800,8 @@ void GreensFunction1DRadAbs::createP_int_r_Table( Real const& t,
 Real GreensFunction1DRadAbs::drawR_f(Real r, void *p)
 {
     struct drawR_params *params = (struct drawR_params *)p;
-    return params->gf->p_int_r_table(r, params->t, params->table) - params->rnd;
+    return params->gf->p_int_r_table(r, params->t, params->p_surv, params->table) 
+        - params->rnd;
 }
 
 /* Return new position */
@@ -823,7 +828,7 @@ Real GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
 
     // the structure to store the numbers to calculate the numbers for 1-S
     RealVector pintTable;
-    struct drawR_params parameters = {this, t, pintTable, rnd};
+    struct drawR_params parameters = {this, t, pintTable, rnd, p_survival( t )};
 
     // define gsl function for rootfinder
     gsl_function F;
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index bef9f976..9872e769 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -218,6 +218,7 @@ class GreensFunction1DRadAbs: public GreensFunction
         const Real t;
         RealVector table;
         Real rnd;
+        Real p_surv;
     };
 
 
@@ -288,7 +289,8 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     static Real drawR_f (Real z, void* p);
 
-    Real p_int_r_table(Real const& r, Real const& t, RealVector& table) const;
+    Real p_int_r_table(Real const& r, Real const& t, Real const& p_surv, 
+                       RealVector& table) const;
 
     void createP_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
     

From 3f121aa424a2374563744d78a6bebd31552a7c63 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Dec 2011 10:19:04 +0100
Subject: [PATCH 0446/1541] small hack to fix numerical errors

---
 egfrd.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index 33ca28a6..072c7373 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1821,6 +1821,8 @@ def try_interaction(self, single, surface):
         dr /= SAFETY
         dz_right /= SAFETY
         # Don't tweak dz_left, this will break the conditions below for membrane interaction
+        if isinstance(surface, CylindricalSurface):
+            dz_left /= SAFETY
 
         # Decide if interaction domain is possible.
         if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:

From 1bfcebb4952904f18d9d690090b35a49e60e13d4 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 9 Dec 2011 11:37:44 +0100
Subject: [PATCH 0447/1541] Changed pair.py such that 1D GF's dont need
 ipv-domain rescaling for convergence. Tried to include Sink GF's to
 documentrations - failed.

---
 doc/greens_functions/tex/Makefile            | 10 ++++++++--
 doc/greens_functions/tex/greensFunctions.tex |  3 +++
 doc/greens_functions/tex/include/include.tex |  2 +-
 freeFunctions.cpp                            |  9 ++++-----
 pair.py                                      |  8 +++++++-
 5 files changed, 23 insertions(+), 9 deletions(-)

diff --git a/doc/greens_functions/tex/Makefile b/doc/greens_functions/tex/Makefile
index 3b842c79..edcc7db0 100644
--- a/doc/greens_functions/tex/Makefile
+++ b/doc/greens_functions/tex/Makefile
@@ -11,11 +11,11 @@
 
 PDFLATEX=pdflatex -output-directory=../build
 
-greensFunctions.pdf: greensFunctions.tex greensFunction1DAbsAbs.pdf greensFunction1DAbsInf.pdf greensFunction1DRadAbs.pdf greensFunction1DRadInf.pdf greensFunction2DRadAbs.pdf
+greensFunctions.pdf: greensFunctions.tex greensFunction1DAbsAbs.pdf greensFunction1DAbsInf.pdf greensFunction1DRadAbs.pdf greensFunction1DRadInf.pdf greensFunction1DAbsSinkAbs.pdf greensFunction1DInfSinkInf.pdf greensFunction2DRadAbs.pdf
 	$(PDFLATEX) greensFunctions.tex
 
 greensFunction1DAbsAbs.pdf: greensFunction1DAbsAbs.tex include/greensFunction1DAbsAbs.include.tex 
-	$(PDFLATEX) greensFunction1DAbsAbs.tex 
+	$(PDFLATEX) greensFunction1DAbsAbs.tex
 
 greensFunction1DAbsInf.pdf: greensFunction1DAbsInf.tex include/greensFunction1DAbsInf.include.tex
 	$(PDFLATEX) greensFunction1DAbsInf.tex
@@ -26,6 +26,12 @@ greensFunction1DRadAbs.pdf: greensFunction1DRadAbs.tex include/greensFunction1DR
 greensFunction1DRadInf.pdf: greensFunction1DRadInf.tex include/greensFunction1DRadInf.include.tex
 	$(PDFLATEX) greensFunction1DRadInf.tex
 
+greensFunction1DAbsSinkAbs.pdf: greensFunction1DAbsSinkAbs.tex include/greensFunction1DAbsSinkAbs.include.tex 
+	$(PDFLATEX) greensFunction1DAbsSinkAbs.tex 
+	
+greensFunction1DInfSinkInf.pdf: greensFunction1DInfSinkInf.tex include/greensFunction1DInfSinkInf.include.tex 
+	$(PDFLATEX) greensFunction1DInfSinkInf.tex 
+
 greensFunction2DRadAbs.pdf: greensFunction2DRadAbs.tex include/greensFunction2DRadAbs.include.tex
 	$(PDFLATEX) greensFunction2DRadAbs.tex
 
diff --git a/doc/greens_functions/tex/greensFunctions.tex b/doc/greens_functions/tex/greensFunctions.tex
index 3dbaf570..31ee61bb 100644
--- a/doc/greens_functions/tex/greensFunctions.tex
+++ b/doc/greens_functions/tex/greensFunctions.tex
@@ -27,6 +27,9 @@
 \newpage\include{include/greensFunction1DRadInf.include}
 \newpage\include{include/greensFunction1DwDriftRadInf.include}
 
+\newpage\input{include/greensFunction1DAbsSinkAbs.include}
+\newpage\input{include/greensFunction1DInfSinkInf.include}
+
 \newpage\include{include/greensFunction2DRadAbs.include}
 
 \end{document}
diff --git a/doc/greens_functions/tex/include/include.tex b/doc/greens_functions/tex/include/include.tex
index 755dfe88..0f85f0ee 100644
--- a/doc/greens_functions/tex/include/include.tex
+++ b/doc/greens_functions/tex/include/include.tex
@@ -1,5 +1,5 @@
 
-\author{Thomas Miedema (miedema@amolf.nl)\\Thomas Sokolowski (sokolowski@amolf.nl)}
+\author{Thomas Miedema (miedema@amolf.nl)\\Thomas Sokolowski (sokolowski@amolf.nl)\\Joris Paijmans (paijmans@amolf.nl)}
 \date{}
 
 \usepackage{amsmath}
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index 8fe45337..c58793fb 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -87,7 +87,6 @@ Real W(Real a, Real b)
 
    The approximation for the greensfunction with a sink has 3 boundaries: 030
    left absorbing boundary, sink, right absorbing boundary.
-   
  */
 
 Real XP00( Real r, Real t, Real r0, Real D, Real v )
@@ -168,9 +167,9 @@ Real XS10( Real t, Real r0, Real D, Real v )
         return erf( r0 / sqrt4Dt );
     else
     {
-        const Real temp( erfc( -(r0 + vt) / sqrt4Dt ) - 
-                         exp(- v * r0 / D ) * erfc( (r0 - vt) / sqrt4Dt) );
-        return 0.5 * temp;
+        const Real corr( exp((6*v*r0 - v*vt ) / (4 * D)) ); 
+        //erfc( -(r0 + vt) / sqrt4Dt ) - exp(- v * r0 / D ) * erfc( (r0 - vt) / sqrt4Dt) );
+        return 0.5 * corr * W(r0/sqrt4Dt, -vt/sqrt4Dt);
     }
 }
 
@@ -318,7 +317,7 @@ Real XS30( Real t, Real r0, Real ka, Real D, Real v )
         const Real r0plusvt( r0 + v * t );
         const Real r0minvt( r0 - v * t );
 
-        const Real erfc_arg( ( r0 + 2 * kplusv2 * t ) / sqrt4Dt);
+        const Real erfc_arg( ( r0 + 2 * kplusv2 * t ) / sqrt4Dt );
 
         const Real exp_arg( k_D * ( r0 + (ka + v) * t ) );
 
diff --git a/pair.py b/pair.py
index 10c943a5..18b2dde7 100644
--- a/pair.py
+++ b/pair.py
@@ -372,7 +372,7 @@ def determine_radii(self, r0, shell_size):
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
 
-        LD_MAX = 20 # temporary value
+        LD_MAX = self.LD_MAX # temporary value
         a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
         # a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
 
@@ -451,6 +451,8 @@ class SphericalPair(SimplePair):
     """
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
+
+        self.LD_MAX = 20
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 
@@ -554,6 +556,8 @@ class PlanarSurfacePair(SimplePair):
     """
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
+
+        self.LD_MAX = 20
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 
@@ -658,6 +662,8 @@ class CylindricalSurfacePair(SimplePair):
     """
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
+        self.LD_MAX = numpy.inf
+
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 

From 8dc13c7397d8aea657ef3cb329fdcb4bb7f70fe3 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Fri, 9 Dec 2011 12:09:56 +0100
Subject: [PATCH 0448/1541] Changed ipv dissociation vector and reaction
 volumes back to 'react at particle surface' case.

---
 CylindricalSurface.hpp | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 7cabcb35..23fe750a 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -92,7 +92,7 @@ class CylindricalSurface
 
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
-        length_type rc( base_type::shape().radius() ); 
+        length_type rc( base_type::shape().radius() + r0 ); 
         length_type rcl( rc + rl );
         length_type rcl_sq( rcl * rcl );
         length_type rc_sq( rc * rc );
@@ -106,9 +106,9 @@ class CylindricalSurface
         length_type const rod_radius = base_type::shape().radius();
         position_type const unit_z = base_type::shape().unit_z();
 
-        length_type const rrl( rod_radius + rl );
+        length_type const rrl( rod_radius + r0 + rl );
         length_type const rrl_sq( gsl_pow_2(rrl) );
-        length_type const rr_sq( gsl_pow_2(rod_radius) );
+        length_type const rr_sq( gsl_pow_2(rod_radius + r0) );
         
         length_type const diss_vec_length( sqrt( X * (rrl_sq - rr_sq) + rr_sq ) );
 
@@ -137,13 +137,20 @@ class CylindricalSurface
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
         position_type const& op_surf, length_type const& rl ) const
     {
+        Real const rod_radius( base_type::shape().radius() );
+        
+        //Species living on the rod should have a larger radius than the rod.
+        ASSERT( rod_radius < s_surf.radius() );
+    
         length_type const r01( s_bulk.radius() + s_surf.radius() );
         Real const D01( s_bulk.D() + s_surf.D() );
         Real const D_bulk_D01( s_bulk.D() / D01 );
         Real const D_surf_D01( s_surf.D() / D01 );
-          
-        Real const theta_min( asin(base_type::shape().radius() / r01) );       
-        Real const theta( theta_min + rng.uniform(0.,1.) * (M_PI - 2 * theta_min) );        
+        
+        //Commented code for direct binding case with c.o.m. reaction.
+        //Real const theta_min( asin(rod_radius / r01) );       
+        Real const theta_min( asin( (rod_radius + s_bulk.radius()) / r01) );       
+        Real const theta( theta_min + rng.uniform(0.,1.) * (M_PI - 2 * theta_min) );  
         Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
         
         Real const X( rng.uniform(0.,1.) );

From 429f48a870e2714138b11bbafafca59befc24602 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Dec 2011 13:21:01 +0100
Subject: [PATCH 0449/1541] changed critirium for overlap of a particle with
 the membrane Previously the particle overlapped with the membrane if the
 surface of the particle overlapped Now the surface can overlap, but the
 center of mass cannot intersect with the membrane. The particle can therefore
 move through the membrane but cannot cross it. For the cylinder (rod surface)
 the criterium is still the former one, the particle can touch the cylinder
 but cannot overlap with it.

---
 egfrd.py  | 22 ++++++++++++++++++----
 pair.py   |  7 +++++--
 single.py |  4 +++-
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 072c7373..09e2787f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -712,7 +712,8 @@ def fire_single_reaction(self, single, reactant_pos):
                 if isinstance(reactant_structure, PlanarSurface):
                     a = myrandom.choice(-1, 1)
                     directions = [-a,a]
-                    vector_length = (product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # the thickness of the membrane is 0.0
+                    # place the center of mass of the particle 'at contact' with the membrane
+                    vector_length = (product_radius + 0.0) * (MINIMAL_SEPARATION_FACTOR - 1.0)  # the thickness of the membrane is 0.0
                     product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
                                         for direction in directions]
 
@@ -847,7 +848,7 @@ def fire_single_reaction(self, single, reactant_pos):
                         newposB = self.world.apply_boundary(newposB)
 
                         assert (self.world.distance(newposA, newposB) >= particle_radius12)
-                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
+#                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
 
                         if default:
                             newpos1, newpos2 = newposA, newposB
@@ -1184,7 +1185,12 @@ def make_new_domain(self, single):
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
-            surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+            if isinstance(surface, PlanarSurface):
+                # with a planar surface it is the center of mass that 'looks around'
+                surface_horizon = single_radius * (self.SINGLE_SHELL_FACTOR - 1.0)
+            else:
+                # with a cylindrical surface it is the surface of the particle
+                surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
@@ -1233,7 +1239,12 @@ def make_new_domain(self, single):
 
             # Also add surfaces
             for surface, distance in surface_distances:
-                surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
+                if isinstance(surface, PlanarSurface):
+                    # with a planar surface it is the center of mass that 'looks around'
+                    surface_horizon = single_radius * (self.MULTI_SHELL_FACTOR - 1.0)
+                else:
+                    # with a cylindrical surface it is the surface of the particle
+                    surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
                 multi_partners.append((surface, distance - surface_horizon))
 
 
@@ -2355,6 +2366,9 @@ def check_domain(self, domain):
             # Ignore all surfaces, multi shells can overlap with 
             # surfaces.
             ignores = [s.id for s in self.world.structures]
+        elif isinstance(domain, SphericalSingle):
+            # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
+            ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair):
             # Ignore surface of the particle and interaction surface
             ignores = [domain.structure.id, domain.surface.id]
diff --git a/pair.py b/pair.py
index 10c943a5..da008cd1 100644
--- a/pair.py
+++ b/pair.py
@@ -1268,7 +1268,9 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         weight1 = D1 / D_tot
         weight2 = D2 / D_tot
 
-        min_iv_z_length = radius2
+#        min_iv_z_length = radius2
+        # get a sence of scale of the separation between the particle and the membrane
+        min_iv_z_length = (radius1 + radius2) * 0.5 * (MINIMAL_SEPARATION_FACTOR - 1.0)
 
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
         iv_x = surface.shape.unit_x * numpy.dot(iv, surface.shape.unit_x)
@@ -1283,8 +1285,9 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         iv_z_length = iv_z_length / cls.calc_z_scaling_factor(D1, D2)
 
         # if the particle is overlapping with the membrane, make sure it doesn't
+        # IS THIS STILL NECESSARY?
         if iv_z_length < min_iv_z_length:
-            iv_z_length = min_iv_z_length * MINIMAL_SEPARATION_FACTOR
+            iv_z_length = min_iv_z_length #* MINIMAL_SEPARATION_FACTOR
 
         iv_z = unit_z * iv_z_length
 
diff --git a/single.py b/single.py
index bdf4b538..17b19847 100644
--- a/single.py
+++ b/single.py
@@ -279,6 +279,8 @@ def get_max_shell_size(self, geometrycontainer, domains):
                 distance_max = geometrycontainer.world.distance(singlepos, domain.pid_particle_pair[1].position)
                 distance = min(distance, distance_max - domain.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR)
                 # TODO check this!
+            elif isinstance(domain, PlanarSurface):
+                distance = distance + self.pid_particle_pair[1].radius
 
             # get the minimum of currect and previous minimum
             distance_domain = (distance, domain)
@@ -563,7 +565,7 @@ def get_inner_dz_left(self):
         # of the planar surface by the particle radius, and that the surface
         # has no thickness.
         dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair[1].radius
-        return dist_to_surface - self.pid_particle_pair[1].radius
+        return dist_to_surface #- self.pid_particle_pair[1].radius
 
     def greens_function(self):
         # This is the Greens function that does not produce REACTION event

From a76d19e1ba962a564134e9b04f0cf5fd346462de Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Dec 2011 15:22:22 +0100
Subject: [PATCH 0450/1541] ugly fixes to ugly bugs

---
 pair.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/pair.py b/pair.py
index da008cd1..e4bba02f 100644
--- a/pair.py
+++ b/pair.py
@@ -260,11 +260,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
         # we still have to make sure that the (non closest) NonInteractionSingles have
         # the required space
 
-        # FIXME Bloody ugly tweak to make sure that in case of a cylinder the 'maximum size' (which is
-        # actually the radius) does not stick out of the maximum sphere (which is the real hard max).
-        # BLoody UGLY because it now applies to ALL SimplePairs.
-        sigma = max(single1.pid_particle_pair[1].radius, single2.pid_particle_pair[1].radius)
-        max_shell_size = math.sqrt(geometrycontainer.get_max_shell_size()**2 - sigma**2)
+        max_shell_size = geometrycontainer.get_max_shell_size()
 
         distance_domain_closest = (max_shell_size, None)
         for domain, distance in neighbors:
@@ -303,6 +299,11 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
         if closest_distance <= 0:
             return 0
         else:
+            # FIXME Bloody ugly tweak to make sure that in case of a cylinder the 'maximum size' (which is
+            # actually the radius) does not stick out of the maximum sphere (which is the real hard max).
+            # BLoody UGLY because it now applies to ALL SimplePairs.
+            sigma = max(single1.pid_particle_pair[1].radius, single2.pid_particle_pair[1].radius)
+            closest_distance = math.sqrt(abs(closest_distance**2 - sigma**2))
             return closest_distance/SAFETY
 
 
@@ -1317,7 +1318,8 @@ def com_greens_function(self):
 
     def iv_greens_function(self, r0):
         # diffusion of the interparticle vector is three dimensional
-        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
+        # TODO Fix ugly hack to prevent particle overlap problem
+        return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, max(r0, self.sigma),
                                       self.sigma, self.a_r)
 
     def create_new_shell(self, position, radius, half_length, orientation_vector, domain_id):

From e5009ae3ae02cfbaf10ed29b58cb3c8131d7798e Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 12 Dec 2011 15:53:09 +0100
Subject: [PATCH 0451/1541] Change surface interaction to 'the new consensus'.

---
 CuboidalRegion.hpp     |  12 ++++
 CylindricalSurface.hpp |  21 +++++-
 PlanarSurface.hpp      |  26 +++++++
 SphericalSurface.hpp   |  11 +++
 Structure.hpp          |   4 ++
 newBDPropagator.hpp    | 153 ++++++++++++++++++++++-------------------
 6 files changed, 155 insertions(+), 72 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 24865258..3a5c9c65 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -121,6 +121,18 @@ class CuboidalRegion
     {
         return position_pair_type(); //No special geminate dissociation 'from' the bulk
     }
+    
+    /* Determine if particle has bouned from the surface */
+    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
+        length_type const& dist_to_surface, length_type const& particle_radius) const
+    {       
+        return false; //Can't use cuboidal region as surface jet.
+    }
+    
+    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
+    {
+        return false; //Cube has no reaction volume.
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 23fe750a..897c44e3 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -5,6 +5,7 @@
 #include "Surface.hpp"
 #include "Cylinder.hpp"
 #include "freeFunctions.hpp"
+#include "geometry.hpp"
 
 template<typename Ttraits_>
 class CylindricalSurface
@@ -140,7 +141,7 @@ class CylindricalSurface
         Real const rod_radius( base_type::shape().radius() );
         
         //Species living on the rod should have a larger radius than the rod.
-        ASSERT( rod_radius < s_surf.radius() );
+        assert( rod_radius < s_surf.radius() );
     
         length_type const r01( s_bulk.radius() + s_surf.radius() );
         Real const D01( s_bulk.D() + s_surf.D() );
@@ -184,6 +185,24 @@ class CylindricalSurface
         return pp01;
     }
 
+    /* Determine if particle has bouned from the surface. */
+    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
+        length_type const& dist_to_surface, length_type const& particle_radius) const
+    {       
+        if( dist_to_surface < particle_radius )
+            return true;
+        else
+            return false;
+    }
+    
+    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
+    {
+        if( dist_to_surface - particle_radius <= rl )
+            return true;
+        else
+            return false;
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         length_type cylinder_radius = base_type::shape().radius();
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 83b558eb..85dbe873 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -20,6 +20,7 @@ class PlanarSurface
     typedef typename base_type::length_type length_type;
     typedef typename Ttraits_::world_type::species_type species_type;
     typedef std::pair<position_type, position_type> position_pair_type;
+    typedef std::pair<position_type, length_type> projected_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
@@ -166,6 +167,31 @@ class PlanarSurface
         return pp01;
         
     }
+    
+    /* Determine if particle has bouned from the surface */
+    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
+        length_type const& dist_to_surface, length_type const& particle_radius) const
+    {       
+         if( dist_to_surface > particle_radius )
+            return false;
+            
+        projected_type const old_projection( base_type::projected_point_on_surface( old_pos ) );
+        projected_type const new_projection( base_type::projected_point_on_surface( new_pos ) );
+        
+        if( old_projection.second * new_projection.second <= 0 )
+            return true;
+        else
+            return false;
+    }
+    
+    /* Determine wether particle lies inside reaction volume. */
+    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
+    {
+        if( dist_to_surface <= rl )
+            return true;
+        else
+            return false;
+    }
 
     virtual length_type minimal_distance(length_type const& radius) const
     {
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index a5244b5a..76b03545 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -86,6 +86,17 @@ class SphericalSurface
     {
         return position_pair_type(); //TODO
     }
+    
+    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
+        length_type const& dist_to_surface, length_type const& particle_radius) const
+    {  
+        return false; //TODO
+    }
+    
+    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
+    {
+        return false; //TODO
+    }
 
     virtual length_type minimal_distance(length_type const& radius) const
     {
diff --git a/Structure.hpp b/Structure.hpp
index 24d8566e..82d3ccf3 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -86,6 +86,10 @@ class Structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const = 0;
     
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const = 0;
+    
+    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, length_type const& dist_to_surface, length_type const& particle_radius) const = 0;
+    
+    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const = 0;
 
     virtual projected_type projected_point(position_type const& pos) const = 0;
     
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 68fd2aa0..b64e0ee5 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -105,6 +105,7 @@ class newBDPropagator
         
         species_type const pp_species(tx_.get_species(pp.second.sid()));
         length_type const r0( pp_species.radius() );
+        position_type const old_pos( pp.second.position() );
         boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( pp_species.structure_id() ) );
         
         structure_id_and_distance_pair struct_id_distance_pair;
@@ -124,7 +125,7 @@ class newBDPropagator
         }
         else
         {
-            new_pos = pp.second.position();
+            new_pos = old_pos;
         }
         
         /* Use a spherical shape with radius = particle_radius + reaction_length.
@@ -134,8 +135,8 @@ class newBDPropagator
         int particles_in_overlap(overlapped ? overlapped->size(): 0);
 
         /* Check if the particle at new_pos overlaps with any particle cores. */        
-        bool bounced = false;
-        int j = 0;
+        bool bounced( false );
+        int j( 0 );
         while(!bounced && j < particles_in_overlap)
             bounced = overlapped->at(j++).second < r0;
         
@@ -143,17 +144,20 @@ class newBDPropagator
            check for core overlap with a surface. */
         if(!bounced && pp_structure->id() == "world")
         {
-            /* Check for overlap with nearest surface. */
             struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
             particle_surface_distance = struct_id_distance_pair.second;
-        
-            bounced = determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair, r0);
+
+            /* Check for overlap with nearest surface. */
+            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+            bounced = closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->structure_position() ), 
+                                               tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
+                                               particle_surface_distance, r0);
         }
          
-        /* If particle is bounced, check reaction_volume for reaction partners at old_pos. */     
+        /* If particle is bounced, check reaction_volume for reaction partners at old_pos. */
         if(bounced)
         {
-            new_pos = pp.second.position();
+            new_pos = old_pos;
             
             boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_after_bounce( 
                     tx_.check_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), 
@@ -176,40 +180,45 @@ class newBDPropagator
         Real const rnd( rng_() );
         
         /* First, if a surface is inside the reaction volume, attempt an interaction. */
-        if( particle_surface_distance < reaction_length_ && pp_structure->id() == "world")
-        {        
-            boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure(struct_id_distance_pair.first) );
-            
-            accumulated_prob += k_total( pp.second.sid(), closest_surf->sid() ) * dt_ / 
-                closest_surf->surface_reaction_volume( r0, reaction_length_ );
-        
-            if(accumulated_prob >= 1.)
-            {
-                LOG_WARNING((
-                    "the acceptance probability of an interaction exeeded one; %f.",
-                    accumulated_prob));
-            } 
+        if( pp_structure->id() == "world" )
+        {
+            if( tx_.get_structure( struct_id_distance_pair.first )->
+                in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
+            {        
+                boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure( struct_id_distance_pair.first) );
+                
+                accumulated_prob += k_total( pp.second.sid(), closest_surf->sid() ) * dt_ / 
+                    closest_surf->surface_reaction_volume( r0, reaction_length_ );
         
-            if( accumulated_prob > rnd )
-            {            
-                try
+                if(accumulated_prob >= 1.)
                 {
-                    LOG_DEBUG(("fire surface interaction"));
-                    if(fire_interaction(pp, closest_surf ))
-                        return true;
-                }   
-                catch (propagation_error const& reason)
+                    LOG_WARNING((
+                                 "the acceptance probability of an interaction exeeded one; %f.",
+                                 accumulated_prob));
+                } 
+                
+                if( accumulated_prob > rnd )
+                {            
+                    try
+                    {
+                        LOG_DEBUG(("fire surface interaction"));
+                        if(fire_interaction(pp, closest_surf ))
+                            return true;
+                    }   
+                    catch (propagation_error const& reason)
+                    {
+                        log_.info("surface interaction rejected (reason: %s)", reason.what());
+                        ++rejected_move_count_;
+                    }
+                }
+                else                
                 {
-                    log_.info("surface interaction rejected (reason: %s)", reason.what());
+                    LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
+                               boost::lexical_cast<std::string>(closest_surf->id()).c_str()));
                     ++rejected_move_count_;
                 }
             }
-            else                
-            {
-                LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
-                    boost::lexical_cast<std::string>(closest_surf->id()).c_str()));
-                ++rejected_move_count_;
-            }
+
         }
         
         /* Now attempt a reaction with all particles inside the reaction volume. */
@@ -249,7 +258,7 @@ class newBDPropagator
                 LOG_DEBUG(("fire reaction"));
     		    try
                 {
-                    if( fire_reaction(pp, closest.first) )
+                    if( fire_reaction(pp, closest.first, s0, s1) )
                         return true;
                 }
                 catch (propagation_error const& reason)
@@ -386,7 +395,11 @@ class newBDPropagator
                         {
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id()) );
                             
-                            if( determine_surface_passage(new_pos, pp.second.position(), struct_id_distance_pair, s0.radius()) )
+                            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+
+                            if( closest_struct->bounced( tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
+                                                         tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
+                                                         struct_id_distance_pair.second, s0.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
 
@@ -454,17 +467,27 @@ class newBDPropagator
                                     pp.first));
                                     
                             /* Only when both products live in the bulk, check for possible overlap with a surface. */
-                            bool surface_overlap = false;
+                            bool surface_bounce0( false );
+                            bool surface_bounce1( false );
                             if( s0.structure_id() == "world" && s1.structure_id() == "world" )
                             {
                                 structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, s0.structure_id() ) );
-                                surface_overlap = determine_surface_passage(pp01.first, pp.second.position(), struct_id_distance_pair, s0.radius());
+                                boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+
+                                surface_bounce0 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->structure_position() ), 
+                                                                          tx_.cyclic_transpose( pp01.first, closest_struct->structure_position() ), 
+                                                                          struct_id_distance_pair.second, s0.radius() );
 
                                 struct_id_distance_pair = tx_.get_closest_surface( pp01.second, s1.structure_id() );
-                                surface_overlap = determine_surface_passage(pp01.second, pp.second.position(), struct_id_distance_pair, s1.radius());                          
+                                closest_struct = tx_.get_structure( struct_id_distance_pair.first );
+
+                                surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->structure_position() ), 
+                                                                          tx_.cyclic_transpose( pp01.second, closest_struct->structure_position() ), 
+                                                                          struct_id_distance_pair.second, s1.radius() );
                             }
                                     
-                            if (!(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0) && !surface_overlap)
+                            if ( !(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0) 
+                                && !surface_bounce0 && !surface_bounce1 )
                                 break;
                         }
 
@@ -523,14 +546,11 @@ class newBDPropagator
     }
     
     
-    bool fire_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1)
+    bool fire_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1, species_type const& s0, species_type const& s1)
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
         if(::size(rules) == 0)
             throw propagation_error("trying to fire a reaction between non-reactive particles");
-
-        species_type s0(tx_.get_species(pp0.second.sid())),
-                s1(tx_.get_species(pp1.second.sid()));
         
         boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
         
@@ -567,7 +587,9 @@ class newBDPropagator
                         if(sp.structure_id() != s1.structure_id())
                         {
                             boost::shared_ptr<structure_type> sp_struct( tx_.get_structure( sp.structure_id() ) );
-                            projected_type const position_on_surface( sp_struct->projected_point(new_pos) );
+                            projected_type const position_on_surface( sp_struct->
+                                                                      projected_point( tx_.cyclic_transpose( new_pos, 
+                                                                                                             sp_struct->structure_position() ) ) );
                             
                             new_pos = tx_.apply_boundary( position_on_surface.first );
                         }
@@ -575,12 +597,12 @@ class newBDPropagator
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                             tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
                                               pp0.first, pp1.first));
-                        if (overlapped && overlapped->size() > 0)
+                        if( overlapped && overlapped->size() > 0 )
                         {
                             throw propagation_error("no space due to particle");
                         }
 
-                        if (vc_)
+                        if( vc_ )
                         {
                             if (!(*vc_)(
                                     particle_shape_type(new_pos, sp.radius()), 
@@ -593,8 +615,11 @@ class newBDPropagator
                         if( sp.structure_id() == "world" )
                         {
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, sp.structure_id() ) );
-                            
-                            if( determine_surface_passage(new_pos, pp0.second.position(), struct_id_distance_pair, sp.radius()) )
+                            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+
+                            if( closest_struct->bounced( tx_.cyclic_transpose( pp0.second.position(), closest_struct->structure_position() ), 
+                                                         tx_.cyclic_transpose( pp1.second.position(), closest_struct->structure_position() ), 
+                                                         struct_id_distance_pair.second, sp.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
 
@@ -710,23 +735,6 @@ class newBDPropagator
         return false;
     }
     
-    /* Function determines wether old_pos lies on the other side of the surface than new_pos. */
-    bool determine_surface_passage(position_type const& new_pos, position_type const& old_pos, 
-                                    structure_id_and_distance_pair const& struct_id_distance_pair, length_type const& radius)
-    {
-        if( struct_id_distance_pair.second > radius )
-            return false;
-    
-        boost::shared_ptr<structure_type> surface( tx_.get_structure( struct_id_distance_pair.first ) );
-        
-        projected_type const old_projection( surface->projected_point_on_surface( old_pos ) );
-        projected_type const new_projection( surface->projected_point_on_surface( new_pos ) );
-        
-        if( old_projection.second * new_projection.second <= 0 )
-            return true;
-        else
-            return false;
-    }
     
     /* Given a position pair and two species, the function generates two new 
        positions based on two moves drawn from the free propegator. */
@@ -770,7 +778,7 @@ class newBDPropagator
         boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
 
         position_type displacement( s0_struct->
-                                        bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
+                                    bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
 
         position_type new_pos(tx_.apply_boundary( add( old_pos, displacement ) ));
                         
@@ -785,8 +793,11 @@ class newBDPropagator
         if(s0.structure_id() == "world")
         {
             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id() ) );
-                             
-            if( determine_surface_passage(new_pos, old_pos, struct_id_distance_pair, s0.radius()) )
+            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+
+            if( closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->structure_position() ), 
+                                         tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
+                                         struct_id_distance_pair.second, s0.radius() ) )    
                 return old_pos;        
         }
             

From 2fd3c1b36edb56db0d471055a4c7c65d13b48b1d Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 12 Dec 2011 17:54:37 +0100
Subject: [PATCH 0452/1541] Removed bucks and checked.:

---
 BDSimulator.hpp        | 24 ++++++++----------------
 CuboidalRegion.hpp     |  4 ++--
 CylindricalSurface.hpp |  4 ++--
 Multi.hpp              | 11 +++++++----
 PlanarSurface.hpp      |  2 +-
 SphericalSurface.hpp   |  2 +-
 Structure.hpp          |  2 +-
 7 files changed, 22 insertions(+), 27 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 75090399..514d0800 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -53,7 +53,6 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
           reaction_length_factor_(reaction_length_factor)
     {
         calculate_dt_and_reaction_length();
-        bound_time = 0;
     }
 
     void calculate_dt_and_reaction_length()
@@ -62,8 +61,6 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         base_type::dt_ = determine_dt();
         reaction_length_ = determine_reaction_length();
         log_.info( "dt=%e, reaction length=%e", base_type::dt_, reaction_length_ );
-        
-        LOG_DEBUG(("dt=%e, reaction length=%e", base_type::dt_, reaction_length_));
     }
 
     virtual void step()
@@ -86,9 +83,6 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
             base_type::t_ = upto;
         }
         
-        if(base_type::world_->num_particles() == 1)
-            bound_time += base_type::dt_;
-        
         return true;
     }
 
@@ -170,7 +164,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
                 for (typename boost::range_const_iterator<reaction_rules>::type
                     it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
-                    Real const k( structure->get_1D_rate_surface( (*it).k() ) ); 
+                    Real const k( structure->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
     
                     if ( k_max < k )
                         k_max = k;
@@ -178,6 +172,9 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
             }
         }
         
+        //Since surface rates are not devided by 2 to compensate for double reaction attempts.
+        k_max *= 2.0;
+        
         BOOST_FOREACH(species_type s0, base_type::world_->get_species())
         {
             j = 0;
@@ -225,16 +222,12 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
         return reaction_length_;    
     }
     
-    double set_reaction_length_factor(length_type new_reaction_length_factor, time_type new_dt_factor)
-    {
-        double old_bound_time = bound_time;
-        bound_time = 0;
-        
+    void set_reaction_length_factor(length_type new_reaction_length_factor, time_type new_dt_factor)
+    {        
         dt_factor_ = new_dt_factor;
         reaction_length_factor_ = new_reaction_length_factor;
-        calculate_dt_and_reaction_length();
-
-        return old_bound_time;        
+        
+        calculate_dt_and_reaction_length();     
     }
 
 protected:
@@ -263,7 +256,6 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     length_type reaction_length_factor_;
     length_type reaction_length_;
     static Logger& log_;
-    Real bound_time;
 };
 
 template<typename Ttraits_>
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 3a5c9c65..560e7747 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -72,9 +72,9 @@ class CuboidalRegion
         return k / ( 4 * M_PI * r01 * r01 );    
     }
     
-    virtual Real get_1D_rate_surface( Real const& k ) const
+    virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
-        return Real(); //No reaction rates with bulk;    
+        return Real(); //No reaction rates with bulk;
     }
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 897c44e3..a6fae23e 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -81,9 +81,9 @@ class CylindricalSurface
         return k;
     }
     
-    virtual Real get_1D_rate_surface( Real const& k ) const
+    virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
-        return k / ( 2 * M_PI * base_type::shape().radius() );
+        return k / ( 2 * M_PI * (base_type::shape().radius() + r0 ) );
     }
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
diff --git a/Multi.hpp b/Multi.hpp
index 18ee80b7..1a0363de 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -267,7 +267,7 @@ class MultiParticleContainer
             structure_id_and_distance_pair const strc_id_and_dist( 
                 get_closest_surface( pp.second.position(), s.structure_id() ) );
                 
-            if( strc_id_and_dist.second < s.radius() && s.structure_id() == "world" )
+            if( strc_id_and_dist.second < 2.0 * s.radius() && s.structure_id() == "world" )
             {
                 species_id_type const strc_sid( get_structure( strc_id_and_dist.first )->sid() );
                 reaction_rules const& rrules(rules.query_reaction_rule( s.id(), strc_sid ));
@@ -277,7 +277,7 @@ class MultiParticleContainer
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
-                    Real const k( get_structure( strc_id_and_dist.first )->get_1D_rate_surface( (*it).k() ) ); 
+                    Real const k( get_structure( strc_id_and_dist.first )->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
 
                     if ( k_max < k )
                         k_max = k;
@@ -286,6 +286,9 @@ class MultiParticleContainer
             
         }
         
+        //Since surface rates are not devided by 2 to compensate for double reaction attempts.
+        k_max *= 2.0;
+        
         BOOST_FOREACH(species_type s0, get_species_in_multi())
         {
             j = 0;
@@ -346,12 +349,12 @@ class MultiParticleContainer
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
         const Real Pacc_max( 0.01 ); //Maximum allowed value of the acceptance probability.
-        const Real tau_D( 2 * gsl_pow_2(step_size_factor * r_min) / D_max );
         Real dt;
+        const Real tau_D( 2. * gsl_pow_2(step_size_factor * r_min) / D_max );
         
         if( k_max > 0)
         {
-            Real dt_temp( 2 * Pacc_max * step_size_factor * r_min / k_max );
+            Real dt_temp( 2. * Pacc_max * step_size_factor * r_min / k_max );
             dt = std::min( dt_temp, tau_D ); // tau_D is upper limit of dt.
         }
         else
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 85dbe873..cfac7c3c 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -70,7 +70,7 @@ class PlanarSurface
         return k / (2 * M_PI * r01);    
     }
     
-    virtual Real get_1D_rate_surface( Real const& k ) const
+    virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
         return k;    
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 76b03545..5d60711e 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -57,7 +57,7 @@ class SphericalSurface
         return Real(); //TODO
     }
     
-    virtual Real get_1D_rate_surface( Real const& k ) const
+    virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
         return Real(); //TODO
     }
diff --git a/Structure.hpp b/Structure.hpp
index 82d3ccf3..69e91bc8 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -75,7 +75,7 @@ class Structure
     
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const = 0;
     
-    virtual Real get_1D_rate_surface( Real const& k ) const = 0;
+    virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const = 0;
 
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const = 0;
     

From 2ae3667a5b5c60768f73f0ab660b31fcbbc03749 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Dec 2011 14:38:43 +0100
Subject: [PATCH 0453/1541] new shells classes to tryout better shell making
 structure

---
 shells.py | 220 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 220 insertions(+)
 create mode 100644 shells.py

diff --git a/shells.py b/shells.py
new file mode 100644
index 00000000..c62b0943
--- /dev/null
+++ b/shells.py
@@ -0,0 +1,220 @@
+#!/usr/bin/python
+
+class hasShell(object):
+
+class hasSphericalShell(hasShell):
+
+    def __init__(self, sphericaltestShell):
+        self.center = sphericaltestShell.center
+        self.radius = sphericaltestShell.radius
+
+    # these return potentially corrected dimensions
+    def get_center:
+    def get_radius:
+
+class SphericalSingle(hasSphericalShell):
+
+    def get_radius_for_single(self):
+        return max(self.get_min_radius(), self.radius)
+    def get_radius_for_other(self):
+        return max(particle_radius * SINGLE_SHELL_FACTOR, self.radius)
+
+class SphericalPair(hasSphericalShell):
+
+    def get_radius_for_single(self):
+        return self.radius
+    def get_radius_for_other(self):
+        return self.radius
+
+class Multi(hasSphericalShell):
+
+
+
+
+class hasCylindricalShell(hasShell):
+
+    def __init__(self, cylindricaltestShell):
+        self.center = uitrekenen zie interactions
+        self.radius = cylindricaltestShell.dr
+        self.half_length = uitrekenen zie interactions
+
+    def get_center:
+
+class PlanarSurfaceSingle(hasCylindricalShell):
+
+    # these return corrected dimensions
+    def get_dimensions_for_single(self):
+        return max(self.get_min_dimensions, (self.radius, self.half_length))
+    def get_dimensions_for_other(self):
+        return (max(particle_radius * SINGLE_SHELL_FACTOR, self.radius), self.half_length)
+
+class PlanarSurfaceInteraction(hasCylindricalShell):
+
+    # these return corrected dimensions
+    def get_dimensions_for_single(self):
+        return (self.radius, self.half_length)
+    def get_dimensions_for_other(self):
+        return (self.radius, self.half_length)
+
+
+
+
+#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+class testShell(object):
+
+    def get_neighbors(self):
+        searchpoint = self.get_searchpoint()
+        radius = self.get_searchradius()
+        return self.geometrycontainer.get_neigbors(searchpoint, radius)
+
+##########################
+class SphericaltestShell(testShell):
+
+    self.radius
+    self.center
+
+    def create_shell:
+        neighbors = self.get_neighbors()
+        min_radius = self.get_min_radius()
+        max_radius = self.get_max_radius()
+        for neighbor in neighbors:
+            if isinstance(neighbor, hasCylindricalShell):
+                neighbor_dimensions = self.get_neighbor_dimensions(neighbor)
+                radius = self.scale_max_sphere_cylinder(neighbor_dimensions)
+            elif isinstance(neighbor, hasSphericalShell):
+                neighbor_radius = self.get_neighbor_radius(neighbor)
+                radius = self.scale_max_sphere_sphere(neighbor_radius)
+            min(radius, max_radius)
+            if radius < min_radius:
+                break
+        create_new_shell(radius)
+            
+
+    def get_searchpoint(self):
+        return self.center
+    def get_searchradius(self):
+        return self.geometrycontainer.max()
+
+    def get_max_radius(self):
+        return shell_container.get_max()
+
+    def get_radius_SphericalNeighbor(self, neighbor_radius):
+        # SphericaltestShell (self) -> SphericalShell (neighbor)
+        # Simple distance calculation to sphere
+        return r
+
+    def get_radius_CylindricalNeighbor(self, neighbor_dimensions):
+        # SphericaltestShell (asker) -> CylindricalShell (self)
+        # Simple distance calculation to cylinder
+        return r
+
+class SphericalSingletestShell(testSphericalShell):
+
+    self.center = particle_position
+    def get_min_radius(self):
+        return particle_radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
+
+class SphericalPairtestShell(testSphericalShell):
+
+    self.center = calculate CoM
+    def get_min_radius:
+        return calculate_min_radius_see_sphericalpair
+
+
+
+###########################
+class CylindricaltestShell(testShell):
+
+    self.dr
+    self.dz_right
+    self.dz_left
+
+    def determine_possible_shell(self):
+        neighbors = self.get_neighbors()
+        min_dr_dzright_dzleft = self.get_min_dr_dzright_dzleft()
+        max_dr_dzright_dzleft = self.get_max_dr_dzright_dzleft()
+        for neighbor in neighbors:
+            if isinstance(neighbor, hasCylindricalShell):
+                dr_dzright_dzleft = self.get_dr_dzright_dzleft_CylindricalNeighbor(neighbor)
+            elif isinstance(neighbor, hasSphericalShell):
+                dr_dzright_dzleft = self.get_dr_dzright_dzleft_SphericalNeighbor(neighbor)
+            min(dr_dzright_dzleft, max_dr_dzright_dzleft)
+            if dr_dzright_dzleft < min_dr_dzright_dzleft:
+                dr_dzright_dzleft = None
+                break
+        if dr_dzright_dzleft:
+            return self.create_new_shell(dr_dzright_dzleft)
+        else
+            return None
+
+    def get_searchradius():
+        return max_that_fits_correctly
+            
+    def get_dr_dzright_dzleft_CylindricalNeighbor(self, neighbor):
+        # get's the maximal (dr, dz_right, dz_left) values for a neighboring CYLINDRICAL domain
+        # CylindricaltestShell (self) -> CylindricalShell (neighbor)
+        # Laurens' algorithm (part2)
+        neighbor_dimensions = self.get_neighbor_dimensions(neighbor)
+        return (r, z_right, z_left)
+
+    def get_dr_dzright_dzleft_SphericalNeighbor(self, neighbor):
+        # get's the maximal (dr, dz_right, dz_left) values for a neighboring SPHERICAL domain
+        # CylindricaltestShell (self) -> SphericalShell (neighbor)
+        # Laurens' algorithm (part1)
+        neighbor_radius = self.get_neighbor_radius(neighbor)
+        return (r, z_right, z_left)
+
+class PlanarSurfaceSingletestShell(CylindricaltestShell):
+
+    def get_orientation_vector(self):
+        return structure.shape.unit_z   # just copy from structure
+
+    def get_searchpoint(self):
+        return particle_pos
+
+    def get_min_dr_dzright_dzleft(self):
+        dr = particle_radius * MULTI_SHELL_FACTOR
+        dz_right = particle_radius
+        dz_left = particle_radius
+        return (dr, dz_right, dz_left)
+
+    def get_max_dr_dzright_dzleft(self):
+        dr = math.sqrt(geometrycontainer_max**2 - particle_radius**2)
+        dz_right = particle_radius
+        dz_left = particle_radius
+        return (dr, dz_right, dz_left)
+
+    # always the same for NonInteractionSingle
+    def get_neighbor_dimensions(self, neighbor):
+        # note that this returns (radius, half_length) tuple, NOT dr, dz_right, dz_left
+        return neighbor.get_dimensions_for_single()
+    def get_neighbor_radius(self, neighbor):
+        return neighbor.get_radius_for_single()
+
+
+class PlanarSurfaceInteractiontestShell(CylindricaltestShell):
+
+    def get_orientation_vector(self):
+        result = do_calculation
+        return result
+
+    def get_searchpoint(self):
+        result = calculate_searchpoint
+        return result
+
+    def get_min_dr_dzright_dzleft(self):
+        dz_right, r = calc_based_on_scaling_stuff
+        dz_left = particle_radius
+        return (dr, dz_right, dz_left)
+
+    def get_max_dr_dzright_dzleft(self):
+        result = calc_based_on_scaling_stuff
+        return (dr, dz_right, dz_left)
+
+    # always the same for other (InteractionSingle, Pair, Multi)
+    def get_neighbor_dimensions(self, neighbor):
+        # note that this returns (radius, half_length) tuple, NOT dr, dz_right, dz_left
+        return neighbor.get_dimensions_for_other()
+    def get_neighbor_radius(self, neighbor):
+        return neighbor.get_radius_for_other()
+

From 5b9ffe908d1ba474efffe176016c3e931074bf3e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Dec 2011 15:56:19 +0100
Subject: [PATCH 0454/1541] Existing hasShell objects now return (faked) shell
 lists to putatively change their perceived dimensions

---
 shells.py | 99 +++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 64 insertions(+), 35 deletions(-)

diff --git a/shells.py b/shells.py
index c62b0943..4e7411ac 100644
--- a/shells.py
+++ b/shells.py
@@ -2,8 +2,13 @@
 
 class hasShell(object):
 
+    def shell_list(self):
+            return self.shell_list
+
 class hasSphericalShell(hasShell):
 
+    self.shell
+
     def __init__(self, sphericaltestShell):
         self.center = sphericaltestShell.center
         self.radius = sphericaltestShell.radius
@@ -14,21 +19,34 @@ def get_radius:
 
 class SphericalSingle(hasSphericalShell):
 
-    def get_radius_for_single(self):
-        return max(self.get_min_radius(), self.radius)
-    def get_radius_for_other(self):
-        return max(particle_radius * SINGLE_SHELL_FACTOR, self.radius)
+    def shell_list_for_single(self):
+        if self.get_min_radius() > self.shell.radius:
+            fake_shell = make_new_shell_with_min_radius
+            return [fake_shell, ]
+        else:
+            return real_shell_list
+
+    def shell_list_for_other(self):
+        if shellradius < particle_radius * SINGLE_SHELL_FACTOR:
+            fake_shell = make_new_shell (particle_radius * SINGLE_SHELL_FACTOR)
+            return [fake_shell, ]
+        else:
+            return real_shell_list
+
 
 class SphericalPair(hasSphericalShell):
 
-    def get_radius_for_single(self):
-        return self.radius
-    def get_radius_for_other(self):
-        return self.radius
+    def shell_list_for_single(self):
+        return real_shell_list
+    def shell_list_for_other(self):
+        return real_shell_list
 
 class Multi(hasSphericalShell):
 
-
+    def shell_list_for_single(self):
+        return self.shell_list
+    def shell_list_for_other(self):
+        return self.shell_list
 
 
 class hasCylindricalShell(hasShell):
@@ -42,19 +60,24 @@ def get_center:
 
 class PlanarSurfaceSingle(hasCylindricalShell):
 
-    # these return corrected dimensions
-    def get_dimensions_for_single(self):
-        return max(self.get_min_dimensions, (self.radius, self.half_length))
-    def get_dimensions_for_other(self):
+    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+    def shell_list_for_single(self):
+        if self.get_min_dimensions > shell.dimensions:
+            fake_shell = create_shell(min_dimensions)
+            return [fake_shell, ]
+        else:
+            return self.shell_list
+
+    def shell_list_for_other(self):
         return (max(particle_radius * SINGLE_SHELL_FACTOR, self.radius), self.half_length)
 
 class PlanarSurfaceInteraction(hasCylindricalShell):
 
-    # these return corrected dimensions
-    def get_dimensions_for_single(self):
-        return (self.radius, self.half_length)
-    def get_dimensions_for_other(self):
-        return (self.radius, self.half_length)
+    # these return uncorrected dimensions because Interactions seem the same
+    def shell_list_for_single(self):
+        return self.shell_list
+    def shell_list_for_other(self):
+        return self.shell_list
 
 
 
@@ -133,11 +156,19 @@ def determine_possible_shell(self):
         neighbors = self.get_neighbors()
         min_dr_dzright_dzleft = self.get_min_dr_dzright_dzleft()
         max_dr_dzright_dzleft = self.get_max_dr_dzright_dzleft()
+
+        dr_dzright_dzleft = max_dr_dzright_dzleft
         for neighbor in neighbors:
-            if isinstance(neighbor, hasCylindricalShell):
-                dr_dzright_dzleft = self.get_dr_dzright_dzleft_CylindricalNeighbor(neighbor)
-            elif isinstance(neighbor, hasSphericalShell):
-                dr_dzright_dzleft = self.get_dr_dzright_dzleft_SphericalNeighbor(neighbor)
+
+            shell_list = self.get_neighbor_shell_list(neighbor)
+            for _, shell in shell_list:
+                # use the right algorithm for the neighbor
+                if isinstance(shell, CylindricalShell):
+                    dr_dzright_dzleft = self.get_dr_dzright_dzleft_CylindricalNeighbor(shell)
+                elif isinstance(shell, SphericalShell):
+                    dr_dzright_dzleft = self.get_dr_dzright_dzleft_SphericalNeighbor(shell)
+
+            # if the newly calculated dimensions are smaller than the current one, use them
             min(dr_dzright_dzleft, max_dr_dzright_dzleft)
             if dr_dzright_dzleft < min_dr_dzright_dzleft:
                 dr_dzright_dzleft = None
@@ -150,18 +181,20 @@ def determine_possible_shell(self):
     def get_searchradius():
         return max_that_fits_correctly
             
-    def get_dr_dzright_dzleft_CylindricalNeighbor(self, neighbor):
+    def get_dr_dzright_dzleft_CylindricalNeighbor(self, shell):
         # get's the maximal (dr, dz_right, dz_left) values for a neighboring CYLINDRICAL domain
         # CylindricaltestShell (self) -> CylindricalShell (neighbor)
         # Laurens' algorithm (part2)
-        neighbor_dimensions = self.get_neighbor_dimensions(neighbor)
+        assert type(shell, Cylinder)
+
         return (r, z_right, z_left)
 
     def get_dr_dzright_dzleft_SphericalNeighbor(self, neighbor):
         # get's the maximal (dr, dz_right, dz_left) values for a neighboring SPHERICAL domain
         # CylindricaltestShell (self) -> SphericalShell (neighbor)
         # Laurens' algorithm (part1)
-        neighbor_radius = self.get_neighbor_radius(neighbor)
+        assert type(shell, Sphere)
+
         return (r, z_right, z_left)
 
 class PlanarSurfaceSingletestShell(CylindricaltestShell):
@@ -185,11 +218,9 @@ def get_max_dr_dzright_dzleft(self):
         return (dr, dz_right, dz_left)
 
     # always the same for NonInteractionSingle
-    def get_neighbor_dimensions(self, neighbor):
-        # note that this returns (radius, half_length) tuple, NOT dr, dz_right, dz_left
-        return neighbor.get_dimensions_for_single()
-    def get_neighbor_radius(self, neighbor):
-        return neighbor.get_radius_for_single()
+    def get_neighbor_shell_list(self, neighbor):
+        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        return neighbor.shell_list_for_single()
 
 
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell):
@@ -212,9 +243,7 @@ def get_max_dr_dzright_dzleft(self):
         return (dr, dz_right, dz_left)
 
     # always the same for other (InteractionSingle, Pair, Multi)
-    def get_neighbor_dimensions(self, neighbor):
-        # note that this returns (radius, half_length) tuple, NOT dr, dz_right, dz_left
-        return neighbor.get_dimensions_for_other()
-    def get_neighbor_radius(self, neighbor):
-        return neighbor.get_radius_for_other()
+    def get_neighbor_shell_list(self, neighbor):
+        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        return neighbor.shell_list_for_other()
 

From 47815ce219853ae85965f831cbea344cc88bbe04 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Dec 2011 17:49:22 +0100
Subject: [PATCH 0455/1541] moved shell scaling code form the scaling domain to
 the neighboring domain Now the code is free from 'isinstance' nonsence

---
 shells.py | 214 ++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 144 insertions(+), 70 deletions(-)
 mode change 100644 => 100755 shells.py

diff --git a/shells.py b/shells.py
old mode 100644
new mode 100755
index 4e7411ac..500ce8d6
--- a/shells.py
+++ b/shells.py
@@ -1,10 +1,12 @@
 #!/usr/bin/python
 
+##################################
 class hasShell(object):
 
     def shell_list(self):
             return self.shell_list
 
+#######################
 class hasSphericalShell(hasShell):
 
     self.shell
@@ -13,34 +15,55 @@ def __init__(self, sphericaltestShell):
         self.center = sphericaltestShell.center
         self.radius = sphericaltestShell.radius
 
-    # these return potentially corrected dimensions
-    def get_center:
-    def get_radius:
+    # methods to size up a shell to this shell
+    def get_dr_dzright_dzleft_to_shell(self, shell_appearance, domain_to_scale):
+        # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
+        # CylindricaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
+
+        assert type(shell_appearance, Sphere)        # because the shell actually originated here
+        # Do Laurens' algorithm (part1)
+
+        return (r, z_right, z_left)
+
 
+    def get_radius_to_shell(self, shell_appearance, domain_to_scale):
+        # SphericaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
+
+        assert type(shell_appearance, Sphere)        # because the shell actually originated here
+        # Do simple distance calculation to sphere
+
+        return r
+
+#####
 class SphericalSingle(hasSphericalShell):
 
+    # these return potentially corrected dimensions
     def shell_list_for_single(self):
-        if self.get_min_radius() > self.shell.radius:
-            fake_shell = make_new_shell_with_min_radius
+        min_radius = self.get_min_radius()
+        if  self.shell.shape.radius < min_radius:
+            fake_shell = make_new_shell (min_radius)
             return [fake_shell, ]
         else:
-            return real_shell_list
+            return self.shell_list
 
     def shell_list_for_other(self):
-        if shellradius < particle_radius * SINGLE_SHELL_FACTOR:
-            fake_shell = make_new_shell (particle_radius * SINGLE_SHELL_FACTOR)
+        min_radius = particle_radius * SINGLE_SHELL_FACTOR
+        if self.shell.shape.radius < min_radius:
+            fake_shell = make_new_shell (min_radius)
             return [fake_shell, ]
         else:
-            return real_shell_list
-
+            return self.shell_list
 
+# Others
+#####
 class SphericalPair(hasSphericalShell):
 
     def shell_list_for_single(self):
-        return real_shell_list
+        return self.shell_list
     def shell_list_for_other(self):
-        return real_shell_list
+        return self.shell_list
 
+#####
 class Multi(hasSphericalShell):
 
     def shell_list_for_single(self):
@@ -49,6 +72,8 @@ def shell_list_for_other(self):
         return self.shell_list
 
 
+
+#########################
 class hasCylindricalShell(hasShell):
 
     def __init__(self, cylindricaltestShell):
@@ -58,19 +83,73 @@ def __init__(self, cylindricaltestShell):
 
     def get_center:
 
+    def get_dr_dzright_dzleft_to_shell(self, shell_appearance, domain_to_scale):
+        # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
+        # CylindricaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
+
+        assert type(shell_appearance, Cylinder)        # because the shell actually originated here
+        # Do Laurens' algorithm (part2)
+
+        return (r, z_right, z_left)
+
+    def get_radius_to_shell(self, shell_appearance, domain_to_scale):
+        # SphericaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
+
+        assert type(shell_appearance, Cylinder)        # because the shell actually originated here
+        # Do simple distance calculation to cylinder
+
+        return r
+
+#####
 class PlanarSurfaceSingle(hasCylindricalShell):
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
-        if self.get_min_dimensions > shell.dimensions:
-            fake_shell = create_shell(min_dimensions)
+        min_radius = particle_radius * MULTI_SHELL_FACTOR
+        if self.shell.shape.radius < min_radius:
+            fake_shell = create_shell(min_radius, normal_half_length)
+            return [fake_shell, ]
+        else:
+            return self.shell_list
+
+    def shell_list_for_other(self):
+        min_radius = particle_radius * SINGLE_SHELL_FACTOR
+        if self.shell.shape.radius < min_radius:
+            fake_shell = create_shell(min_radius, normal_half_length)
+            return [fake_shell, ]
+        else:
+            return self.shell_list
+
+#####
+class CylindricalSurfaceSingle(hasCylindricalShell):
+
+    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+    def shell_list_for_single(self):
+        min_half_length = particle_radius * MULTI_SHELL_FACTOR
+        if self.shell.shape.half_length < min_half_length:
+            fake_shell = create_shell(radius, min_half_length)
             return [fake_shell, ]
         else:
             return self.shell_list
 
     def shell_list_for_other(self):
-        return (max(particle_radius * SINGLE_SHELL_FACTOR, self.radius), self.half_length)
+        min_half_length = particle_radius * SINGLE_SHELL_FACTOR
+        if self.shell.shape.half_length < min_half_length:
+            fake_shell = create_shell(radius, min_half_length)
+            return [fake_shell, ]
+        else:
+            return self.shell_list
 
+# Others
+#####
+class PlanarSurfacePair(hasCylindricalShell):
+
+    def shell_list_for_single(self):
+        return self.shell_list
+    def shell_list_for_other(self):
+        return self.shell_list
+
+#####
 class PlanarSurfaceInteraction(hasCylindricalShell):
 
     # these return uncorrected dimensions because Interactions seem the same
@@ -79,10 +158,15 @@ def shell_list_for_single(self):
     def shell_list_for_other(self):
         return self.shell_list
 
+#####
+class CylindricalSurfacePair(hasCylindricalShell):
+class CylindricalSurfaceInteraction(hasCylindricalShell):
+class MixedPair3D2D(hasCylindricalShell):
+#class MixedPair3D1D(hasCylindricalShell):
 
 
-
-#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+#######################################################
+#######################################################
 class testShell(object):
 
     def get_neighbors(self):
@@ -90,28 +174,34 @@ def get_neighbors(self):
         radius = self.get_searchradius()
         return self.geometrycontainer.get_neigbors(searchpoint, radius)
 
-##########################
+########################
 class SphericaltestShell(testShell):
 
     self.radius
     self.center
 
-    def create_shell:
+    def determine_possible_shell(self):
         neighbors = self.get_neighbors()
         min_radius = self.get_min_radius()
         max_radius = self.get_max_radius()
+
+        radius = max_radius
         for neighbor in neighbors:
-            if isinstance(neighbor, hasCylindricalShell):
-                neighbor_dimensions = self.get_neighbor_dimensions(neighbor)
-                radius = self.scale_max_sphere_cylinder(neighbor_dimensions)
-            elif isinstance(neighbor, hasSphericalShell):
-                neighbor_radius = self.get_neighbor_radius(neighbor)
-                radius = self.scale_max_sphere_sphere(neighbor_radius)
-            min(radius, max_radius)
-            if radius < min_radius:
-                break
-        create_new_shell(radius)
-            
+
+            shell_list = self.get_neighbor_shell_list(neighbor)
+            for _, shell_appearance in shell_list:
+                new_radius = neighbor.get_radius_to_shell(shell_appearance, self)
+                # if the newly calculated dimensions are smaller than the current one, use them
+                radius = min(radius, new_radius)
+
+                if radius < min_radius:
+                    radius = None
+                    break
+
+        if radius:
+            return self.create_new_shell(radius)
+        else
+            return None
 
     def get_searchpoint(self):
         return self.center
@@ -121,31 +211,33 @@ def get_searchradius(self):
     def get_max_radius(self):
         return shell_container.get_max()
 
-    def get_radius_SphericalNeighbor(self, neighbor_radius):
-        # SphericaltestShell (self) -> SphericalShell (neighbor)
-        # Simple distance calculation to sphere
-        return r
-
-    def get_radius_CylindricalNeighbor(self, neighbor_dimensions):
-        # SphericaltestShell (asker) -> CylindricalShell (self)
-        # Simple distance calculation to cylinder
-        return r
-
+#####
 class SphericalSingletestShell(testSphericalShell):
 
     self.center = particle_position
+
     def get_min_radius(self):
         return particle_radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
 
+    # always the same for singles
+    def get_neighbor_shell_list(self, neighbor):
+        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        return neighbor.shell_list_for_single()
+
+#####
 class SphericalPairtestShell(testSphericalShell):
 
     self.center = calculate CoM
     def get_min_radius:
         return calculate_min_radius_see_sphericalpair
 
+    # always the same for other (InteractionSingle, Pair, Multi)
+    def get_neighbor_shell_list(self, neighbor):
+        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        return neighbor.shell_list_for_other()
 
 
-###########################
+##########################
 class CylindricaltestShell(testShell):
 
     self.dr
@@ -161,18 +253,15 @@ def determine_possible_shell(self):
         for neighbor in neighbors:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
-            for _, shell in shell_list:
-                # use the right algorithm for the neighbor
-                if isinstance(shell, CylindricalShell):
-                    dr_dzright_dzleft = self.get_dr_dzright_dzleft_CylindricalNeighbor(shell)
-                elif isinstance(shell, SphericalShell):
-                    dr_dzright_dzleft = self.get_dr_dzright_dzleft_SphericalNeighbor(shell)
-
-            # if the newly calculated dimensions are smaller than the current one, use them
-            min(dr_dzright_dzleft, max_dr_dzright_dzleft)
-            if dr_dzright_dzleft < min_dr_dzright_dzleft:
-                dr_dzright_dzleft = None
-                break
+            for _, shell_appearance in shell_list:
+                new_dr_dzright_dzleft = neighbor.get_dr_dzright_dzleft(shell_appearance, self)
+
+                # if the newly calculated dimensions are smaller than the current one, use them
+                dr_dzright_dzleft = min(dr_dzright_dzleft, new_dr_dzright_dzleft)
+                if dr_dzright_dzleft < min_dr_dzright_dzleft:
+                    dr_dzright_dzleft = None
+                    break
+
         if dr_dzright_dzleft:
             return self.create_new_shell(dr_dzright_dzleft)
         else
@@ -181,22 +270,7 @@ def determine_possible_shell(self):
     def get_searchradius():
         return max_that_fits_correctly
             
-    def get_dr_dzright_dzleft_CylindricalNeighbor(self, shell):
-        # get's the maximal (dr, dz_right, dz_left) values for a neighboring CYLINDRICAL domain
-        # CylindricaltestShell (self) -> CylindricalShell (neighbor)
-        # Laurens' algorithm (part2)
-        assert type(shell, Cylinder)
-
-        return (r, z_right, z_left)
-
-    def get_dr_dzright_dzleft_SphericalNeighbor(self, neighbor):
-        # get's the maximal (dr, dz_right, dz_left) values for a neighboring SPHERICAL domain
-        # CylindricaltestShell (self) -> SphericalShell (neighbor)
-        # Laurens' algorithm (part1)
-        assert type(shell, Sphere)
-
-        return (r, z_right, z_left)
-
+#####
 class PlanarSurfaceSingletestShell(CylindricaltestShell):
 
     def get_orientation_vector(self):
@@ -222,7 +296,7 @@ def get_neighbor_shell_list(self, neighbor):
         # note that this returns the list of shells, NOT dr, dz_right, dz_left
         return neighbor.shell_list_for_single()
 
-
+#####
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell):
 
     def get_orientation_vector(self):

From 85e658389fa7499dbd5ad99c504ef41678ab7c40 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Dec 2011 18:06:43 +0100
Subject: [PATCH 0456/1541] moved methods reused for NonInteractionSingles and
 Others to separate classes and inherited them

---
 shells.py | 108 ++++++++++++++++++++++++------------------------------
 1 file changed, 47 insertions(+), 61 deletions(-)

diff --git a/shells.py b/shells.py
index 500ce8d6..26d10c56 100755
--- a/shells.py
+++ b/shells.py
@@ -1,5 +1,32 @@
 #!/usr/bin/python
 
+
+class Others(object):
+
+    # stuff for hasShell subclasses
+    def shell_list_for_single(self):
+        return self.shell_list
+    def shell_list_for_other(self):
+        return self.shell_list
+
+    # stuff for testShell subclasses
+    def get_neighbor_shell_list(self, neighbor):
+        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        return neighbor.shell_list_for_other()
+
+class NonInteractionSingles(object):
+
+    # stuff for hasShell subclasses
+    def shell_list_for_single(self):
+        pass    # needs to be overloaded
+    def shell_list_for_other(self):
+        pass    # needs to be overloaded
+
+    # stuff for testShell subclasses
+    def get_neighbor_shell_list(self, neighbor):
+        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        return neighbor.shell_list_for_single()
+
 ##################################
 class hasShell(object):
 
@@ -35,7 +62,7 @@ def get_radius_to_shell(self, shell_appearance, domain_to_scale):
         return r
 
 #####
-class SphericalSingle(hasSphericalShell):
+class SphericalSingle(hasSphericalShell, NonInteractionSingles):
 
     # these return potentially corrected dimensions
     def shell_list_for_single(self):
@@ -54,23 +81,11 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-# Others
 #####
-class SphericalPair(hasSphericalShell):
-
-    def shell_list_for_single(self):
-        return self.shell_list
-    def shell_list_for_other(self):
-        return self.shell_list
+class SphericalPair(hasSphericalShell, Others):
 
 #####
-class Multi(hasSphericalShell):
-
-    def shell_list_for_single(self):
-        return self.shell_list
-    def shell_list_for_other(self):
-        return self.shell_list
-
+class Multi(hasSphericalShell, Others):
 
 
 #########################
@@ -101,7 +116,7 @@ def get_radius_to_shell(self, shell_appearance, domain_to_scale):
         return r
 
 #####
-class PlanarSurfaceSingle(hasCylindricalShell):
+class PlanarSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
@@ -121,7 +136,7 @@ def shell_list_for_other(self):
             return self.shell_list
 
 #####
-class CylindricalSurfaceSingle(hasCylindricalShell):
+class CylindricalSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
@@ -140,28 +155,12 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-# Others
 #####
-class PlanarSurfacePair(hasCylindricalShell):
-
-    def shell_list_for_single(self):
-        return self.shell_list
-    def shell_list_for_other(self):
-        return self.shell_list
-
-#####
-class PlanarSurfaceInteraction(hasCylindricalShell):
-
-    # these return uncorrected dimensions because Interactions seem the same
-    def shell_list_for_single(self):
-        return self.shell_list
-    def shell_list_for_other(self):
-        return self.shell_list
-
-#####
-class CylindricalSurfacePair(hasCylindricalShell):
-class CylindricalSurfaceInteraction(hasCylindricalShell):
-class MixedPair3D2D(hasCylindricalShell):
+class PlanarSurfacePair(hasCylindricalShell, Others):
+class PlanarSurfaceInteraction(hasCylindricalShell, Others):
+class CylindricalSurfacePair(hasCylindricalShell, Others):
+class CylindricalSurfaceInteraction(hasCylindricalShell, Others):
+class MixedPair3D2D(hasCylindricalShell, Others):
 #class MixedPair3D1D(hasCylindricalShell):
 
 
@@ -212,30 +211,20 @@ def get_max_radius(self):
         return shell_container.get_max()
 
 #####
-class SphericalSingletestShell(testSphericalShell):
+class SphericalSingletestShell(testSphericalShell, NonInteractionSingles):
 
     self.center = particle_position
 
     def get_min_radius(self):
         return particle_radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
 
-    # always the same for singles
-    def get_neighbor_shell_list(self, neighbor):
-        # note that this returns the list of shells, NOT dr, dz_right, dz_left
-        return neighbor.shell_list_for_single()
-
 #####
-class SphericalPairtestShell(testSphericalShell):
+class SphericalPairtestShell(testSphericalShell, Others):
 
     self.center = calculate CoM
     def get_min_radius:
         return calculate_min_radius_see_sphericalpair
 
-    # always the same for other (InteractionSingle, Pair, Multi)
-    def get_neighbor_shell_list(self, neighbor):
-        # note that this returns the list of shells, NOT dr, dz_right, dz_left
-        return neighbor.shell_list_for_other()
-
 
 ##########################
 class CylindricaltestShell(testShell):
@@ -271,7 +260,7 @@ def get_searchradius():
         return max_that_fits_correctly
             
 #####
-class PlanarSurfaceSingletestShell(CylindricaltestShell):
+class PlanarSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
 
     def get_orientation_vector(self):
         return structure.shape.unit_z   # just copy from structure
@@ -291,13 +280,8 @@ def get_max_dr_dzright_dzleft(self):
         dz_left = particle_radius
         return (dr, dz_right, dz_left)
 
-    # always the same for NonInteractionSingle
-    def get_neighbor_shell_list(self, neighbor):
-        # note that this returns the list of shells, NOT dr, dz_right, dz_left
-        return neighbor.shell_list_for_single()
-
 #####
-class PlanarSurfaceInteractiontestShell(CylindricaltestShell):
+class PlanarSurfaceInteractiontestShell(CylindricaltestShell, Others):
 
     def get_orientation_vector(self):
         result = do_calculation
@@ -316,8 +300,10 @@ def get_max_dr_dzright_dzleft(self):
         result = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
 
-    # always the same for other (InteractionSingle, Pair, Multi)
-    def get_neighbor_shell_list(self, neighbor):
-        # note that this returns the list of shells, NOT dr, dz_right, dz_left
-        return neighbor.shell_list_for_other()
 
+class PlanarSurfacePairtestShell(hasCylindricalShell, Others):
+class CylindricalSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
+class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
+class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, Others):
+class MixedPair3D2DtestShell(CylindricaltestShell, Others):
+#class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From 9d140f50859d8d4acf7f27015fa4a480c2dbe5f0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 14 Dec 2011 11:51:21 +0100
Subject: [PATCH 0457/1541] some added flesh to classes

---
 shells.py | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 60 insertions(+), 5 deletions(-)

diff --git a/shells.py b/shells.py
index 26d10c56..b056ced2 100755
--- a/shells.py
+++ b/shells.py
@@ -208,7 +208,7 @@ def get_searchradius(self):
         return self.geometrycontainer.max()
 
     def get_max_radius(self):
-        return shell_container.get_max()
+        return shell_container.get_max_shell_size()
 
 #####
 class SphericalSingletestShell(testSphericalShell, NonInteractionSingles):
@@ -280,6 +280,49 @@ def get_max_dr_dzright_dzleft(self):
         dz_left = particle_radius
         return (dr, dz_right, dz_left)
 
+#####
+class PlanarSurfacePairtestShell(hasCylindricalShell, Others):
+
+    def get_orientation_vector(self):
+        return structure.shape.unit_z
+
+    def get_searchpoint(self):
+        return CoM
+
+    def get_min_dr_dzright_dzleft(self):
+        do calculation
+        return (dr, dz_right, dz_left)
+
+    def get_max_dr_dzright_dzleft(self):
+        dr = math.sqrt(geometrycontainer_max**2 - particle_radius**2)
+        dz_right = particle_radius
+        dz_left = particle_radius
+        return (dr, dz_right, dz_left)
+        
+#####
+class CylindricalSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
+
+    def orientation_vector(self):
+        return structure.shape.unit_z   # just copy from structure
+
+    def get_searchpoint(self):
+        return particle_pos
+
+    def get_min_dr_dzright_dzleft(self):
+        dr = particle_radius
+        dz_right = particle_radius * MULTI_SHELL_FACTOR
+        dz_left = particle_radius * MULTI_SHELL_FACTOR
+        return (dr, dz_right, dz_left)
+
+    def get_max_dr_dzright_dzleft(self):
+        dr = particle_radius
+        dz_right = math.sqrt(geometrycontainer_max**2 - particle_radius**2)
+        dz_left = dz_right
+        return (dr, dz_right, dz_left)
+
+#####
+class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
+
 #####
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell, Others):
 
@@ -300,10 +343,22 @@ def get_max_dr_dzright_dzleft(self):
         result = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
 
-
-class PlanarSurfacePairtestShell(hasCylindricalShell, Others):
-class CylindricalSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
-class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
+#####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, Others):
+
+    def get_orientation_vector(self):
+        return structure.shape.unit_z
+
+    def get_searchpoint(self):
+        return projected_point_of_particle
+
+    def get_min_dr_dzright_dzleft(self):
+        result = calc_based_on_scaling_stuff
+        return (dr, dz_right, dz_left)
+        
+    def get_max_dr_dzright_dzleft(self):
+        result = calc_based_on_scaling_stuff
+        return (dr, dz_right, dz_left)
+
 class MixedPair3D2DtestShell(CylindricaltestShell, Others):
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From e835d48dcc98dddd8625423993e9c08ab2d88944 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 14 Dec 2011 16:59:06 +0100
Subject: [PATCH 0458/1541] started to add laurens' algorithm to shells.py

---
 shells.py | 286 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 284 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index b056ced2..3caf6df8 100755
--- a/shells.py
+++ b/shells.py
@@ -43,13 +43,172 @@ def __init__(self, sphericaltestShell):
         self.radius = sphericaltestShell.radius
 
     # methods to size up a shell to this shell
-    def get_dr_dzright_dzleft_to_shell(self, shell_appearance, domain_to_scale):
+    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
         # CylindricaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
 
-        assert type(shell_appearance, Sphere)        # because the shell actually originated here
+        assert type(shell, Sphere)        # because the shell actually originated here
         # Do Laurens' algorithm (part1)
 
+        # get the reference point and orientation of the domain to scale
+        reference_point = domain_to_scale.get_referencepoint()
+        orientation_vector = domain_to_scale.get_orientation_vector()
+
+        # determine on what side the midpoint of the shell is relative to the reference_point
+        shell_position_t = world.cyclic_transpose (shell.shape.position, reference_point)
+        ref_to_shell = shell_position_t - reference_point
+        ref_to_shell_z_len = numpy.dot(ref_to_shell, orientation_vector)
+        # express the ref_to_shell vector in the coordinate system
+        ref_to_shell_z = ref_to_shell_z_len * orientation_vector
+        ref_to_shell_r = ref_to_shell - ref_to_shell_z
+
+        # if the shell is on the side of orientation_vector -> use z_right
+        # also use this one if the shell is in plane with the reference_point
+        if ref_to_shell_z_len >= 0:
+            phi = domain_to_scale.get_right_scalingangle()
+            scalecenter_h0 = cls.z_right(single1, single2, r0, 0.0)   # r = 0.0
+            r1_function =  cls.r_right
+            z1_function = cls.z_right
+            z2_function = cls.z_left
+            z1 = z_right
+            z2 = z_left
+            direction = 1           # improve direction specification such that following calculations still work
+                                    # Otherwise problems when direction = 0
+        # else -> use z_left
+        else:
+            phi = cls.calc_left_scalingangle(D1, D2)
+            scalecenter_h0 = cls.z_left(single1, single2, r0, 0.0)    # r = 0.0
+            r1_function =  cls.r_left
+            z1_function = cls.z_left
+            z2_function = cls.z_right
+            z1 = z_left
+            z2 = z_right
+            direction = -1
+
+
+        # calculate the orientation vectors
+        orientation_vector_z = orientation_vector * direction
+        if length(ref_to_shell_r) == 0:
+            # produce a random vector perpendicular to the 'orientation_vector_z'
+            unit_vector3D = random_unit_vector()
+            orientation_vector_r = normalize(unit_vector3D - numpy.dot(unit_vector3D, orientation_vector_z))
+        else:
+            orientation_vector_r = normalize(ref_to_shell_r)
+
+
+        # calculate the center from which linear scaling will take place
+        if phi == 0.0:
+            scalecenter_r0 = r  # This is an approximation, since the h0 is infinitely far away of phi == 0,
+        else:                   # we introduce an r0
+            scalecenter_r0 = 0
+
+        scale_center = reference_point + scalecenter_h0 * orientation_vector_z \
+                                       + scalecenter_r0 * orientation_vector_r
+        scale_center = world.apply_boundary(scale_center)
+
+
+        # calculate the vector from the scale center to the center of the shell
+        shell_position_t = world.cyclic_transpose (shell_position, scale_center)
+        shell_scale_center = shell_position_t - scale_center
+        shell_scalecenter_z = numpy.dot(shell_scale_center, orientation_vector_z)
+        shell_scalecenter_r = numpy.dot(shell_scale_center, orientation_vector_r)
+        #length(shell_scale_center - (shell_scalecenter_z * orientation_vector_z))
+
+
+        # calculate the angle theta of the vector from the scale center to the shell with the vector
+        # to the scale center (which is +- the orientation_vector)
+        theta = vector_angle (shell_scale_center, orientation_vector_z)
+
+        psi = theta - phi
+
+        ### check what situation arrises
+        # The shell can hit the cylinder on the flat side (situation 1),
+        #                                on the edge (situation 2),
+        #                                or on the round side (situation 3).
+        # I think this also works for phi == 0 and phi == Pi/2
+        if psi <= -phi:
+        # The midpoint of the shell lies on the axis of the cylinder
+            situation = 1
+
+        elif -phi < psi and psi < 0:
+        # The (spherical) shell can touch the cylinder on its flat side or its edge
+            if phi == Pi/2.0:
+                r_tan_phi = 0
+            else:
+                r_tan_phi = abs(shell_scalecenter_r)/math.tan(phi)   # phi == 0 should not get here
+                                                                     # TODO the abs may be wrong/unnecessary
+
+            a_thres = shell_scalecenter_z - r_tan_phi
+            if shell_size < a_thres:
+                situation = 1
+            else:
+                situation = 2
+
+        elif 0 <= psi and psi < (Pi/2.0 - phi):
+        # The (spherical) shell can touch the cylinder on its edge or its radial side
+            tan_phi = math.tan(phi)                             # phi == Pi/2 should not get here
+            a_thres = abs(shell_scalecenter_r) - shell_scalecenter_z * tan_phi  # TODO same here
+            if shell_size > a_thres:
+                situation = 2
+            else:
+                situation = 3
+
+        elif (Pi/2.0 - phi) <= psi:
+        # The shell is always only on the radial side of the cylinder
+            situation = 3
+
+        else:
+        # Don't know how we would get here, but it shouldn't happen
+            raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
+                               (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
+
+
+        ### Get the right values for z and r for the given situation
+        if situation == 1:      # shell hits cylinder on the flat side
+            z1_new = min(z1, (scalecenter_h0 + shell_scalecenter_z - shell_size)/SAFETY)
+                                                        # note that shell_size may also mean half_length
+            r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
+            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+
+        elif situation == 2:    # shell hits sphere on the edge
+            a_sq = shell_size*shell_size
+            shell_scalecenter_len = length(shell_scale_center)
+            ss_sq = shell_scalecenter_len*shell_scalecenter_len
+            sin_phi = math.sin(phi)
+            sin_psi = math.sin(psi)
+            cos_psi = math.cos(psi)
+            scalecenter_shell_dist = (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
+            # FIXME UGLY FIX BELOW
+            scalecenter_shell_dist /= 1.1
+            scalecenter_shell_dist /= SAFETY
+
+            if phi <= Pi/4:
+#                print "scale z first."
+                z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
+                r_new  = min(r, r1_function(single1, single2, r0, z1_new))
+                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+            else:
+#                print "scale r first."
+                r_new = min(r, scalecenter_r0 + sin_phi * scalecenter_shell_dist)
+                z1_new = min(z1, z1_function(single1, single2, r0, r_new))
+                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+
+        elif situation == 3:    # shell hits cylinder on the round side
+            r_new = min(r, (scalecenter_r0 + abs(shell_scalecenter_r) - shell_size)/SAFETY)   # note that shell_size here means radius
+            z1_new = min(z1, z1_function(single1, single2, r0, r_new))
+            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+        else:
+            raise RuntimeError('Bad situation for MixedPair shell making')
+
+        # switch the z values in case it's necessary. r doesn't have to be switched.
+        r = r_new
+        if direction >= 0.0:
+            z_right = z1_new
+            z_left  = z2_new
+        else:
+            z_right = z2_new
+            z_left  = z1_new
+
         return (r, z_right, z_left)
 
 
@@ -232,6 +391,7 @@ class CylindricaltestShell(testShell):
     self.dr
     self.dz_right
     self.dz_left
+    self.scaling_angle_right = None     # this needs to be calculated once
 
     def determine_possible_shell(self):
         neighbors = self.get_neighbors()
@@ -268,6 +428,9 @@ def get_orientation_vector(self):
     def get_searchpoint(self):
         return particle_pos
 
+    def get_referencepoint(self):
+        return particle_pos
+
     def get_min_dr_dzright_dzleft(self):
         dr = particle_radius * MULTI_SHELL_FACTOR
         dz_right = particle_radius
@@ -280,6 +443,20 @@ def get_max_dr_dzright_dzleft(self):
         dz_left = particle_radius
         return (dr, dz_right, dz_left)
 
+    def get_right_scalingcenter(self, orientation_z, orientation_r):
+        # returns the scaling center in the coordinate system of the plane through
+        # scaling cylinder and the neighboring shell
+        return particle_radius * orientation_z
+
+    def get_left_scalingcenter(self, orientation_z, orientation_r):
+        return particle_radius * orientation_z
+
+    def get_right_scalingangle(self):
+        return Pi/2.0
+
+    def get_left_scalingangle(self):
+        return Pi/2.0
+
 #####
 class PlanarSurfacePairtestShell(hasCylindricalShell, Others):
 
@@ -289,6 +466,9 @@ def get_orientation_vector(self):
     def get_searchpoint(self):
         return CoM
 
+    def get_referencepoint(self):
+        return CoM
+
     def get_min_dr_dzright_dzleft(self):
         do calculation
         return (dr, dz_right, dz_left)
@@ -308,6 +488,9 @@ def orientation_vector(self):
     def get_searchpoint(self):
         return particle_pos
 
+    def get_referencepoint(self):
+        return particle_pos
+
     def get_min_dr_dzright_dzleft(self):
         dr = particle_radius
         dz_right = particle_radius * MULTI_SHELL_FACTOR
@@ -320,6 +503,24 @@ def get_max_dr_dzright_dzleft(self):
         dz_left = dz_right
         return (dr, dz_right, dz_left)
 
+    def get_right_scalingcenter(self, orientation_z, orientation_r):
+        # returns the scaling center in the coordinate system of the plane through
+        # scaling cylinder and the neighboring shell
+        #
+        # Note that the scalingcenter depends on the position of the shell,
+        # and therefor orientation_r changes for every shell -> recalculate
+        return orientation_r * self.particle_radius
+
+    def get_left_scalingcenter(self, orientation_z, orientation_r):
+        # same here
+        return orientation_r * self.particle_radius
+
+    def get_right_scalingangle(self):
+        return 0
+
+    def get_left_scalingangle(self):
+        return 0
+
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
 
@@ -334,6 +535,9 @@ def get_searchpoint(self):
         result = calculate_searchpoint
         return result
 
+    def get_referencepoint(self):
+        return projected_point_of_particle
+
     def get_min_dr_dzright_dzleft(self):
         dz_right, r = calc_based_on_scaling_stuff
         dz_left = particle_radius
@@ -343,6 +547,23 @@ def get_max_dr_dzright_dzleft(self):
         result = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
 
+    def get_right_scalingcenter(self, orientation_z, orientation_r):
+        # note calculate this only once since 'orientation_z' doens't change
+        # for different shells -> scalingcenter is a fixed point
+        h0_right = distance_particle_surface
+        return orientation_z * h0_right
+
+    def get_left_scalingcenter(self, orientation_z, orientation_r):
+        # note calculate this only once since orientation_z doesn't change
+        # for difference shells -> scalingcenter is a fixed point
+        return orientation_z * particle_radius
+
+    def get_right_scalingangle(self):
+        return bla
+
+    def get_left_scalingangle(self):
+        return Pi/2.0
+
 #####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, Others):
 
@@ -352,6 +573,9 @@ def get_orientation_vector(self):
     def get_searchpoint(self):
         return projected_point_of_particle
 
+    def get_referencepoint(self):
+        return projected_point_of_particle
+
     def get_min_dr_dzright_dzleft(self):
         result = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
@@ -360,5 +584,63 @@ def get_max_dr_dzright_dzleft(self):
         result = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
 
+    def get_right_scalingcenter(self, orientation_z, orientation_r):
+        # note calculate this only once since 'orientation_z' doens't change
+        # for different shells -> scalingcenter is a fixed point
+        h0_right = smt
+        return orientation_z * h0_right
+
+    def get_left_scalingcenter(self, orientation_z, orientation_r):
+        # note calculate this only once since orientation_z doesn't change
+        # for difference shells -> scalingcenter is a fixed point
+        h0_left = h0_right
+        return orientation_z * h0_left
+
+    def get_right_scalingangle(self):
+        return bla
+
+    def get_left_scalingangle(self):
+        return Pi/2.0
+
+#####
 class MixedPair3D2DtestShell(CylindricaltestShell, Others):
+
+    def get_orientation_vector(self):
+        result = do_calculation
+        return result
+
+    def get_searchpoint(self):
+        return caculated_search_point
+
+    def get_referencepoint(self):
+        return CoM
+
+    def get_min_dr_dzright_dzleft(self):
+        dz_left = particle_radius
+        dr, dz_right = calc_based_on_scaling_stuff
+        return (dr, dz_right, dz_left)
+        
+    def get_max_dr_dzright_dzleft(self):
+        dz_left = particle_radius
+        dr, dz_right = calc_based_on_scaling_stuff
+        return (dr, dz_right, dz_left)
+
+    def get_right_scalingcenter(self, orientation_z, orientation_r):
+        # note calculate this only once since 'orientation_z' doens't change
+        # for different shells
+        h0_right = bla
+        return orientation_z * h0_right
+
+    def get_left_scalingcenter(self, orientation_z, orientation_r):
+        # note calculate this only once since orientation_z doesn't change
+        # for difference shells
+        return orientation_z * particle_radius
+
+    def get_right_scalingangle(self):
+        return bla
+
+    def get_left_scalingangle(self):
+        return Pi/2.0
+
+#####
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From dd021ef9dc83aa329d6840564599f70fffd8cbe8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 14 Dec 2011 17:33:27 +0100
Subject: [PATCH 0459/1541] adjusting Laurens' algorithm into its new position

---
 shells.py | 51 ++++++++++++++++++++++-----------------------------
 1 file changed, 22 insertions(+), 29 deletions(-)

diff --git a/shells.py b/shells.py
index 3caf6df8..c4f5caac 100755
--- a/shells.py
+++ b/shells.py
@@ -43,19 +43,22 @@ def __init__(self, sphericaltestShell):
         self.radius = sphericaltestShell.radius
 
     # methods to size up a shell to this shell
-    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
+    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
         # CylindricaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
 
-        assert type(shell, Sphere)        # because the shell actually originated here
+        assert type(shell, Sphere)        # because the shell actually is part of the current object
+
         # Do Laurens' algorithm (part1)
+        shell_position = shell.shape.position
+        shell_size = shell.shape.radius
 
         # get the reference point and orientation of the domain to scale
         reference_point = domain_to_scale.get_referencepoint()
         orientation_vector = domain_to_scale.get_orientation_vector()
 
         # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = world.cyclic_transpose (shell.shape.position, reference_point)
+        shell_position_t = world.cyclic_transpose (shell_position, reference_point)
         ref_to_shell = shell_position_t - reference_point
         ref_to_shell_z_len = numpy.dot(ref_to_shell, orientation_vector)
         # express the ref_to_shell vector in the coordinate system
@@ -65,45 +68,39 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
         # if the shell is on the side of orientation_vector -> use z_right
         # also use this one if the shell is in plane with the reference_point
         if ref_to_shell_z_len >= 0:
-            phi = domain_to_scale.get_right_scalingangle()
-            scalecenter_h0 = cls.z_right(single1, single2, r0, 0.0)   # r = 0.0
+            direction = 1           # improve direction specification such that following calculations still work
+                                    # Otherwise problems when direction = 0
+            get_scale_angle  = domain_to_scale.get_right_scalingangle
+            get_scale_center = domain_to_scale.get_right_scalingcenter
             r1_function =  cls.r_right
             z1_function = cls.z_right
             z2_function = cls.z_left
             z1 = z_right
             z2 = z_left
-            direction = 1           # improve direction specification such that following calculations still work
-                                    # Otherwise problems when direction = 0
         # else -> use z_left
         else:
-            phi = cls.calc_left_scalingangle(D1, D2)
-            scalecenter_h0 = cls.z_left(single1, single2, r0, 0.0)    # r = 0.0
+            direction = -1
+            get_scalingangle  = domain_to_scale.get_left_scalingangle
+            get_scalingcenter = domain_to_scale.get_left_scalingcenter
             r1_function =  cls.r_left
             z1_function = cls.z_left
             z2_function = cls.z_right
             z1 = z_left
             z2 = z_right
-            direction = -1
 
-
-        # calculate the orientation vectors
-        orientation_vector_z = orientation_vector * direction
+        # correct the orientation vectors
+        orientation_z = orientation_vector * direction
         if length(ref_to_shell_r) == 0:
             # produce a random vector perpendicular to the 'orientation_vector_z'
-            unit_vector3D = random_unit_vector()
-            orientation_vector_r = normalize(unit_vector3D - numpy.dot(unit_vector3D, orientation_vector_z))
+            unit_vector3D = random_unit_vector()    # TODO find cheaper way
+            orientation_r = normalize(unit_vector3D - numpy.dot(unit_vector3D, orientation_z))
         else:
-            orientation_vector_r = normalize(ref_to_shell_r)
+            orientation_r = normalize(ref_to_shell_r)
 
 
         # calculate the center from which linear scaling will take place
-        if phi == 0.0:
-            scalecenter_r0 = r  # This is an approximation, since the h0 is infinitely far away of phi == 0,
-        else:                   # we introduce an r0
-            scalecenter_r0 = 0
-
-        scale_center = reference_point + scalecenter_h0 * orientation_vector_z \
-                                       + scalecenter_r0 * orientation_vector_r
+        phi = get_scalingangle()
+        scale_center = get_scalingcenter(orientation_z, orientation_r) + reference_point
         scale_center = world.apply_boundary(scale_center)
 
 
@@ -112,12 +109,11 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
         shell_scale_center = shell_position_t - scale_center
         shell_scalecenter_z = numpy.dot(shell_scale_center, orientation_vector_z)
         shell_scalecenter_r = numpy.dot(shell_scale_center, orientation_vector_r)
-        #length(shell_scale_center - (shell_scalecenter_z * orientation_vector_z))
 
 
         # calculate the angle theta of the vector from the scale center to the shell with the vector
         # to the scale center (which is +- the orientation_vector)
-        theta = vector_angle (shell_scale_center, orientation_vector_z)
+        theta = vector_angle (shell_scale_center, orientation_z)
 
         psi = theta - phi
 
@@ -166,7 +162,6 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
         ### Get the right values for z and r for the given situation
         if situation == 1:      # shell hits cylinder on the flat side
             z1_new = min(z1, (scalecenter_h0 + shell_scalecenter_z - shell_size)/SAFETY)
-                                                        # note that shell_size may also mean half_length
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
@@ -183,18 +178,16 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
             scalecenter_shell_dist /= SAFETY
 
             if phi <= Pi/4:
-#                print "scale z first."
                 z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
                 r_new  = min(r, r1_function(single1, single2, r0, z1_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
             else:
-#                print "scale r first."
                 r_new = min(r, scalecenter_r0 + sin_phi * scalecenter_shell_dist)
                 z1_new = min(z1, z1_function(single1, single2, r0, r_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 3:    # shell hits cylinder on the round side
-            r_new = min(r, (scalecenter_r0 + abs(shell_scalecenter_r) - shell_size)/SAFETY)   # note that shell_size here means radius
+            r_new = min(r, (scalecenter_r0 + abs(shell_scalecenter_r) - shell_size)/SAFETY)
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
         else:

From d042ba6c85c0f1f9a4f0c1026bdd5fe4c76af14e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 13:32:54 +0100
Subject: [PATCH 0460/1541] renaming variables in laurens' algorithm for
 clarification

---
 shells.py | 124 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 65 insertions(+), 59 deletions(-)

diff --git a/shells.py b/shells.py
index c4f5caac..712530cb 100755
--- a/shells.py
+++ b/shells.py
@@ -51,7 +51,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         # Do Laurens' algorithm (part1)
         shell_position = shell.shape.position
-        shell_size = shell.shape.radius
+        shell_radius = shell.shape.radius
 
         # get the reference point and orientation of the domain to scale
         reference_point = domain_to_scale.get_referencepoint()
@@ -61,7 +61,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         shell_position_t = world.cyclic_transpose (shell_position, reference_point)
         ref_to_shell = shell_position_t - reference_point
         ref_to_shell_z_len = numpy.dot(ref_to_shell, orientation_vector)
-        # express the ref_to_shell vector in the coordinate system
+        # express the ref_to_shell vector in the coordinate systema going through the reference
+        # point and the position of the shell
         ref_to_shell_z = ref_to_shell_z_len * orientation_vector
         ref_to_shell_r = ref_to_shell - ref_to_shell_z
 
@@ -72,9 +73,9 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
                                     # Otherwise problems when direction = 0
             get_scale_angle  = domain_to_scale.get_right_scalingangle
             get_scale_center = domain_to_scale.get_right_scalingcenter
-            r1_function =  cls.r_right
-            z1_function = cls.z_right
-            z2_function = cls.z_left
+            r1_function =  domain_to_scale.r_right
+            z1_function = domain_to_scale.z_right
+            z2_function = domain_to_scale.z_left
             z1 = z_right
             z2 = z_left
         # else -> use z_left
@@ -82,15 +83,18 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
             direction = -1
             get_scalingangle  = domain_to_scale.get_left_scalingangle
             get_scalingcenter = domain_to_scale.get_left_scalingcenter
-            r1_function =  cls.r_left
-            z1_function = cls.z_left
-            z2_function = cls.z_right
+            r1_function =  domain_to_scale.r_left
+            z1_function = domain_to_scale.z_left
+            z2_function = domain_to_scale.z_right
             z1 = z_left
             z2 = z_right
 
-        # correct the orientation vectors
+        # The orientation vectors are the normalized ref_to_shell_z/r vectors
         orientation_z = orientation_vector * direction
         if length(ref_to_shell_r) == 0:
+            # In this case there is a problem normalizing the ref_to_shell_r vector (happens
+            # for example when treating CylindricalSurfaceSingles)
+
             # produce a random vector perpendicular to the 'orientation_vector_z'
             unit_vector3D = random_unit_vector()    # TODO find cheaper way
             orientation_r = normalize(unit_vector3D - numpy.dot(unit_vector3D, orientation_z))
@@ -99,99 +103,101 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
 
         # calculate the center from which linear scaling will take place
-        phi = get_scalingangle()
-        scale_center = get_scalingcenter(orientation_z, orientation_r) + reference_point
+        scale_angle = get_scalingangle()
+        scale_center = get_scalingcenter(orientation_z, orientation_r) 
         scale_center = world.apply_boundary(scale_center)
-
+        scale_center_z = 
+        scale_center_r = 
 
         # calculate the vector from the scale center to the center of the shell
         shell_position_t = world.cyclic_transpose (shell_position, scale_center)
-        shell_scale_center = shell_position_t - scale_center
-        shell_scalecenter_z = numpy.dot(shell_scale_center, orientation_vector_z)
-        shell_scalecenter_r = numpy.dot(shell_scale_center, orientation_vector_r)
+        scale_center_to_shell = shell_position_t - scale_center
+        scale_center_to_shell_z = numpy.dot(scale_center_to_shell, orientation_vector_z)
+        scale_center_to_shell_r = numpy.dot(scale_center_to_shell, orientation_vector_r)
 
 
-        # calculate the angle theta of the vector from the scale center to the shell with the vector
+        # calculate the angle shell_angle of the vector from the scale center to the shell with the vector
         # to the scale center (which is +- the orientation_vector)
-        theta = vector_angle (shell_scale_center, orientation_z)
+        shell_angle = vector_angle (scale_center_to_shell, orientation_z)
 
-        psi = theta - phi
+        psi = shell_angle - scale_angle
 
         ### check what situation arrises
         # The shell can hit the cylinder on the flat side (situation 1),
         #                                on the edge (situation 2),
         #                                or on the round side (situation 3).
-        # I think this also works for phi == 0 and phi == Pi/2
-        if psi <= -phi:
+        # I think this also works for scale_angle == 0 and scale_angle == Pi/2
+        if psi <= -scale_angle:
         # The midpoint of the shell lies on the axis of the cylinder
             situation = 1
 
-        elif -phi < psi and psi < 0:
-        # The (spherical) shell can touch the cylinder on its flat side or its edge
-            if phi == Pi/2.0:
-                r_tan_phi = 0
+        elif -scale_angle < psi and psi < 0:
+        # The spherical shell can touch the cylinder on its flat side or its edge
+            if scale_angle == Pi/2.0:
+                r_tan_scale_angle = 0
             else:
-                r_tan_phi = abs(shell_scalecenter_r)/math.tan(phi)   # phi == 0 should not get here
-                                                                     # TODO the abs may be wrong/unnecessary
+                # scale_angle == 0 should not get here
+                r_tan_scale_angle = abs(scale_center_to_shell_r)/math.tan(scale_angle)
+                                    # TODO the abs may be wrong/unnecessary
 
-            a_thres = shell_scalecenter_z - r_tan_phi
-            if shell_size < a_thres:
+            shell_radius_thres = scale_center_to_shell_z - r_tan_scale_angle
+            if shell_radius < shell_radius_thres:
                 situation = 1
             else:
                 situation = 2
 
-        elif 0 <= psi and psi < (Pi/2.0 - phi):
+        elif 0 <= psi and psi < (Pi/2.0 - scale_angle):
         # The (spherical) shell can touch the cylinder on its edge or its radial side
-            tan_phi = math.tan(phi)                             # phi == Pi/2 should not get here
-            a_thres = abs(shell_scalecenter_r) - shell_scalecenter_z * tan_phi  # TODO same here
-            if shell_size > a_thres:
+            tan_scale_angle = math.tan(scale_angle)                             # scale_angle == Pi/2 should not get here
+            shell_radius_thres = abs(scale_center_to_shell_r) - scale_center_to_shell_z * tan_scale_angle  # TODO same here
+            if shell_radius > shell_radius_thres:
                 situation = 2
             else:
                 situation = 3
 
-        elif (Pi/2.0 - phi) <= psi:
+        elif (Pi/2.0 - scale_angle) <= psi:
         # The shell is always only on the radial side of the cylinder
             situation = 3
 
         else:
         # Don't know how we would get here, but it shouldn't happen
-            raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
-                               (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
+            raise RuntimeError('Error: psi was not in valid range. psi = %s, scale_angle = %s, shell_angle = %s' %
+                               (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % scale_angle, FORMAT_DOUBLE % shell_angle))
 
 
         ### Get the right values for z and r for the given situation
-        if situation == 1:      # shell hits cylinder on the flat side
-            z1_new = min(z1, (scalecenter_h0 + shell_scalecenter_z - shell_size)/SAFETY)
+        if situation == 1:      # the spherical shell hits cylinder on the flat side
+            z1_new = min(z1, (scale_center_z + scale_center_to_shell_z - shell_radius)/SAFETY)
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 2:    # shell hits sphere on the edge
-            a_sq = shell_size*shell_size
-            shell_scalecenter_len = length(shell_scale_center)
-            ss_sq = shell_scalecenter_len*shell_scalecenter_len
-            sin_phi = math.sin(phi)
+            shell_radius_sq = shell_radius*shell_radius
+            scale_center_to_shell_len = length(scale_center_to_shell)
+            ss_sq = scale_center_to_shell_len*scale_center_to_shell_len
+            sin_scale_angle = math.sin(scale_angle)
             sin_psi = math.sin(psi)
             cos_psi = math.cos(psi)
-            scalecenter_shell_dist = (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
+            scale_center_shell_dist = (scale_center_to_shell_len * cos_psi - math.sqrt(shell_radius_sq - ss_sq*sin_psi*sin_psi) )
             # FIXME UGLY FIX BELOW
-            scalecenter_shell_dist /= 1.1
-            scalecenter_shell_dist /= SAFETY
+#            scale_center_shell_dist /= 1.1
+            scale_center_shell_dist /= SAFETY
 
-            if phi <= Pi/4:
-                z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
+            if scale_angle <= Pi/4:
+                z1_new = min(z1, scale_center_z + cos_scale_angle * scale_center_shell_dist)
                 r_new  = min(r, r1_function(single1, single2, r0, z1_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
             else:
-                r_new = min(r, scalecenter_r0 + sin_phi * scalecenter_shell_dist)
+                r_new = min(r, scale_center_r + sin_scale_angle * scale_center_shell_dist)
                 z1_new = min(z1, z1_function(single1, single2, r0, r_new))
                 z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 3:    # shell hits cylinder on the round side
-            r_new = min(r, (scalecenter_r0 + abs(shell_scalecenter_r) - shell_size)/SAFETY)
+            r_new = min(r, (scale_center_r + abs(scale_center_to_shell_r) - shell_radius)/SAFETY)
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
             z2_new = min(z2, z2_function(single1, single2, r0, r_new))
         else:
-            raise RuntimeError('Bad situation for MixedPair shell making')
+            raise RuntimeError('Bad situation for cylindrical shell making to sphere.')
 
         # switch the z values in case it's necessary. r doesn't have to be switched.
         r = r_new
@@ -439,10 +445,10 @@ def get_max_dr_dzright_dzleft(self):
     def get_right_scalingcenter(self, orientation_z, orientation_r):
         # returns the scaling center in the coordinate system of the plane through
         # scaling cylinder and the neighboring shell
-        return particle_radius * orientation_z
+        return particle_radius * orientation_z + self.reference_point
 
     def get_left_scalingcenter(self, orientation_z, orientation_r):
-        return particle_radius * orientation_z
+        return particle_radius * orientation_z + self.reference_point
 
     def get_right_scalingangle(self):
         return Pi/2.0
@@ -502,11 +508,11 @@ def get_right_scalingcenter(self, orientation_z, orientation_r):
         #
         # Note that the scalingcenter depends on the position of the shell,
         # and therefor orientation_r changes for every shell -> recalculate
-        return orientation_r * self.particle_radius
+        return orientation_r * self.particle_radius + self.reference_point
 
     def get_left_scalingcenter(self, orientation_z, orientation_r):
         # same here
-        return orientation_r * self.particle_radius
+        return orientation_r * self.particle_radius + self.reference_point
 
     def get_right_scalingangle(self):
         return 0
@@ -544,12 +550,12 @@ def get_right_scalingcenter(self, orientation_z, orientation_r):
         # note calculate this only once since 'orientation_z' doens't change
         # for different shells -> scalingcenter is a fixed point
         h0_right = distance_particle_surface
-        return orientation_z * h0_right
+        return orientation_z * h0_right + self.reference_point
 
     def get_left_scalingcenter(self, orientation_z, orientation_r):
         # note calculate this only once since orientation_z doesn't change
         # for difference shells -> scalingcenter is a fixed point
-        return orientation_z * particle_radius
+        return orientation_z * particle_radius + self.reference_point
 
     def get_right_scalingangle(self):
         return bla
@@ -581,13 +587,13 @@ def get_right_scalingcenter(self, orientation_z, orientation_r):
         # note calculate this only once since 'orientation_z' doens't change
         # for different shells -> scalingcenter is a fixed point
         h0_right = smt
-        return orientation_z * h0_right
+        return orientation_z * h0_right + self.reference_point
 
     def get_left_scalingcenter(self, orientation_z, orientation_r):
         # note calculate this only once since orientation_z doesn't change
         # for difference shells -> scalingcenter is a fixed point
         h0_left = h0_right
-        return orientation_z * h0_left
+        return orientation_z * h0_left + self.reference_point
 
     def get_right_scalingangle(self):
         return bla
@@ -622,12 +628,12 @@ def get_right_scalingcenter(self, orientation_z, orientation_r):
         # note calculate this only once since 'orientation_z' doens't change
         # for different shells
         h0_right = bla
-        return orientation_z * h0_right
+        return orientation_z * h0_right + self.reference_point
 
     def get_left_scalingcenter(self, orientation_z, orientation_r):
         # note calculate this only once since orientation_z doesn't change
         # for difference shells
-        return orientation_z * particle_radius
+        return orientation_z * particle_radius + self.reference_point
 
     def get_right_scalingangle(self):
         return bla

From 66aa5bb3ee4af830ef78e7fb87fce5e5c3705a63 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 13:47:35 +0100
Subject: [PATCH 0461/1541] simplified the shell center calculation ->
 everything happens in the plane through the axis of the cylinder and the
 position of the spherical shell

---
 shells.py | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/shells.py b/shells.py
index 712530cb..617a09d5 100755
--- a/shells.py
+++ b/shells.py
@@ -104,21 +104,14 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         # calculate the center from which linear scaling will take place
         scale_angle = get_scalingangle()
-        scale_center = get_scalingcenter(orientation_z, orientation_r) 
-        scale_center = world.apply_boundary(scale_center)
-        scale_center_z = 
-        scale_center_r = 
-
-        # calculate the vector from the scale center to the center of the shell
-        shell_position_t = world.cyclic_transpose (shell_position, scale_center)
-        scale_center_to_shell = shell_position_t - scale_center
-        scale_center_to_shell_z = numpy.dot(scale_center_to_shell, orientation_vector_z)
-        scale_center_to_shell_r = numpy.dot(scale_center_to_shell, orientation_vector_r)
+        scale_center_z, scale_center_r = get_scalingcenter(orientation_z, orientation_r) 
+        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
+        scale_center_to_shell_r = ref_to_shell_r - scale_center_r
 
 
         # calculate the angle shell_angle of the vector from the scale center to the shell with the vector
         # to the scale center (which is +- the orientation_vector)
-        shell_angle = vector_angle (scale_center_to_shell, orientation_z)
+        shell_angle = math.atan(scale_center_to_shell_r/scale_center_to_shell_z)
 
         psi = shell_angle - scale_angle
 
@@ -173,8 +166,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         elif situation == 2:    # shell hits sphere on the edge
             shell_radius_sq = shell_radius*shell_radius
-            scale_center_to_shell_len = length(scale_center_to_shell)
-            ss_sq = scale_center_to_shell_len*scale_center_to_shell_len
+            ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_r**2)
+            scale_center_to_shell_len = math.sqrt(ss_sq)
             sin_scale_angle = math.sin(scale_angle)
             sin_psi = math.sin(psi)
             cos_psi = math.cos(psi)

From c464bb8070fa6f4d6b316b7c8411ab4fa0bb86c1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 14:05:32 +0100
Subject: [PATCH 0462/1541] shell_center getters now return in cylindrical
 coordinates cylindrical coordinate system is in domain_to_scale and r-axis
 goes through the shell

---
 shells.py | 75 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 47 insertions(+), 28 deletions(-)

diff --git a/shells.py b/shells.py
index 617a09d5..b1814819 100755
--- a/shells.py
+++ b/shells.py
@@ -104,7 +104,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         # calculate the center from which linear scaling will take place
         scale_angle = get_scalingangle()
-        scale_center_z, scale_center_r = get_scalingcenter(orientation_z, orientation_r) 
+        scale_center_r, scale_center_z = get_scalingcenter() 
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
         scale_center_to_shell_r = ref_to_shell_r - scale_center_r
 
@@ -435,13 +435,17 @@ def get_max_dr_dzright_dzleft(self):
         dz_left = particle_radius
         return (dr, dz_right, dz_left)
 
-    def get_right_scalingcenter(self, orientation_z, orientation_r):
-        # returns the scaling center in the coordinate system of the plane through
-        # scaling cylinder and the neighboring shell
-        return particle_radius * orientation_z + self.reference_point
+    def get_right_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
+        return 0, particle_radius
 
-    def get_left_scalingcenter(self, orientation_z, orientation_r):
-        return particle_radius * orientation_z + self.reference_point
+    def get_left_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
+        return 0, particle_radius 
 
     def get_right_scalingangle(self):
         return Pi/2.0
@@ -495,17 +499,17 @@ def get_max_dr_dzright_dzleft(self):
         dz_left = dz_right
         return (dr, dz_right, dz_left)
 
-    def get_right_scalingcenter(self, orientation_z, orientation_r):
-        # returns the scaling center in the coordinate system of the plane through
-        # scaling cylinder and the neighboring shell
-        #
-        # Note that the scalingcenter depends on the position of the shell,
-        # and therefor orientation_r changes for every shell -> recalculate
-        return orientation_r * self.particle_radius + self.reference_point
+    def get_right_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note1: we assume cylindrical symmetry
+        # Note2: it is relative to the 'side' (right/left) of the cylinder
+        # Note3: we assume that the r-axis goes from the center of the cylinder to the
+        #        center of the shell.
+        return self.particle_radius, 0
 
-    def get_left_scalingcenter(self, orientation_z, orientation_r):
+    def get_left_scalingcenter(self):
         # same here
-        return orientation_r * self.particle_radius + self.reference_point
+        return self.particle_radius, 0
 
     def get_right_scalingangle(self):
         return 0
@@ -539,16 +543,22 @@ def get_max_dr_dzright_dzleft(self):
         result = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
 
-    def get_right_scalingcenter(self, orientation_z, orientation_r):
+    def get_right_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
         # note calculate this only once since 'orientation_z' doens't change
         # for different shells -> scalingcenter is a fixed point
         h0_right = distance_particle_surface
-        return orientation_z * h0_right + self.reference_point
+        return 0, h0_right
 
-    def get_left_scalingcenter(self, orientation_z, orientation_r):
+    def get_left_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
         # note calculate this only once since orientation_z doesn't change
         # for difference shells -> scalingcenter is a fixed point
-        return orientation_z * particle_radius + self.reference_point
+        return 0, particle_radius
 
     def get_right_scalingangle(self):
         return bla
@@ -576,17 +586,23 @@ def get_max_dr_dzright_dzleft(self):
         result = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
 
-    def get_right_scalingcenter(self, orientation_z, orientation_r):
+    def get_right_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
         # note calculate this only once since 'orientation_z' doens't change
         # for different shells -> scalingcenter is a fixed point
         h0_right = smt
-        return orientation_z * h0_right + self.reference_point
+        return 0, h0_right
 
-    def get_left_scalingcenter(self, orientation_z, orientation_r):
+    def get_left_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
         # note calculate this only once since orientation_z doesn't change
         # for difference shells -> scalingcenter is a fixed point
         h0_left = h0_right
-        return orientation_z * h0_left + self.reference_point
+        return 0, h0_left
 
     def get_right_scalingangle(self):
         return bla
@@ -617,16 +633,19 @@ def get_max_dr_dzright_dzleft(self):
         dr, dz_right = calc_based_on_scaling_stuff
         return (dr, dz_right, dz_left)
 
-    def get_right_scalingcenter(self, orientation_z, orientation_r):
+    def get_right_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
         # note calculate this only once since 'orientation_z' doens't change
         # for different shells
         h0_right = bla
-        return orientation_z * h0_right + self.reference_point
+        return 0, h0_right
 
-    def get_left_scalingcenter(self, orientation_z, orientation_r):
+    def get_left_scalingcenter(self):
         # note calculate this only once since orientation_z doesn't change
         # for difference shells
-        return orientation_z * particle_radius + self.reference_point
+        return 0, particle_radius
 
     def get_right_scalingangle(self):
         return bla

From 6f18977b67e981c5a7bd75d8ca54987874070b32 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 14:27:38 +0100
Subject: [PATCH 0463/1541] removed orientation vectors from Laurens' algorithm
 -> no longer needed (too expensive anyway)

---
 shells.py | 31 ++++++++++---------------------
 1 file changed, 10 insertions(+), 21 deletions(-)

diff --git a/shells.py b/shells.py
index b1814819..b26187e7 100755
--- a/shells.py
+++ b/shells.py
@@ -59,16 +59,12 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         # determine on what side the midpoint of the shell is relative to the reference_point
         shell_position_t = world.cyclic_transpose (shell_position, reference_point)
-        ref_to_shell = shell_position_t - reference_point
-        ref_to_shell_z_len = numpy.dot(ref_to_shell, orientation_vector)
-        # express the ref_to_shell vector in the coordinate systema going through the reference
-        # point and the position of the shell
-        ref_to_shell_z = ref_to_shell_z_len * orientation_vector
-        ref_to_shell_r = ref_to_shell - ref_to_shell_z
+        ref_to_shell_vec = shell_position_t - reference_point
+        ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
 
         # if the shell is on the side of orientation_vector -> use z_right
         # also use this one if the shell is in plane with the reference_point
-        if ref_to_shell_z_len >= 0:
+        if ref_to_shell_z >= 0:
             direction = 1           # improve direction specification such that following calculations still work
                                     # Otherwise problems when direction = 0
             get_scale_angle  = domain_to_scale.get_right_scalingangle
@@ -89,24 +85,17 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
             z1 = z_left
             z2 = z_right
 
-        # The orientation vectors are the normalized ref_to_shell_z/r vectors
-        orientation_z = orientation_vector * direction
-        if length(ref_to_shell_r) == 0:
-            # In this case there is a problem normalizing the ref_to_shell_r vector (happens
-            # for example when treating CylindricalSurfaceSingles)
+        # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
+        ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
+        ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
+        ref_to_shell_r = length(ref_to_shell_r_vec)
+        ref_to_shell_z = abs(ref_to_shell_z)
 
-            # produce a random vector perpendicular to the 'orientation_vector_z'
-            unit_vector3D = random_unit_vector()    # TODO find cheaper way
-            orientation_r = normalize(unit_vector3D - numpy.dot(unit_vector3D, orientation_z))
-        else:
-            orientation_r = normalize(ref_to_shell_r)
-
-
-        # calculate the center from which linear scaling will take place
+        # get the center from which linear scaling will take place
         scale_angle = get_scalingangle()
         scale_center_r, scale_center_z = get_scalingcenter() 
-        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
         scale_center_to_shell_r = ref_to_shell_r - scale_center_r
+        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
 
         # calculate the angle shell_angle of the vector from the scale center to the shell with the vector

From 00d8a3f17e4da38c1c7b4dceb3dc397b8ea275b0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 14:51:04 +0100
Subject: [PATCH 0464/1541] added Laurens' algorithm variant for
 cylinder/cylinder scaling

---
 shells.py | 78 +++++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 76 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index b26187e7..8b076f3b 100755
--- a/shells.py
+++ b/shells.py
@@ -238,13 +238,87 @@ def __init__(self, cylindricaltestShell):
 
     def get_center:
 
-    def get_dr_dzright_dzleft_to_shell(self, shell_appearance, domain_to_scale):
+    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
         # CylindricaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
 
-        assert type(shell_appearance, Cylinder)        # because the shell actually originated here
+        log.debug('cylinder')
+
+        assert type(shell, Cylinder)        # because the shell actually originated here
         # Do Laurens' algorithm (part2)
 
+        shell_position = shell.shape.position
+        shell_radius = shell.shape.radius
+        shell_half_length = shell.shape.half_length
+
+
+        # get the reference point and orientation of the domain to scale
+        reference_point = domain_to_scale.get_referencepoint()
+        orientation_vector = domain_to_scale.get_orientation_vector()
+
+        # determine on what side the midpoint of the shell is relative to the reference_point
+        shell_position_t = world.cyclic_transpose (shell_position, reference_point)
+        ref_to_shell_vec = shell_position_t - reference_point
+        ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
+
+        # if the shell is on the side of orientation_vector -> use z_right
+        # also use this one if the shell is in plane with the reference_point
+        if ref_to_shell_z >= 0:
+            direction = 1           # improve direction specification such that following calculations still work
+                                    # Otherwise problems when direction = 0
+            scale_angle = domain_to_scale.get_right_scalingangle()
+            scale_center_r, scale_center_z = domain_to_scale.get_right_scalingcenter() 
+            r1_function =  domain_to_scale.r_right
+            z1_function = domain_to_scale.z_right
+            z2_function = domain_to_scale.z_left
+            z1 = z_right
+            z2 = z_left
+        # else -> use z_left
+        else:
+            direction = -1
+            scale_angle = domain_to_scale.get_left_scalingangle()
+            scale_center_r, scale_center_z = domain_to_scale.get_left_scalingcenter() 
+            r1_function =  domain_to_scale.r_left
+            z1_function = domain_to_scale.z_left
+            z2_function = domain_to_scale.z_right
+            z1 = z_left
+            z2 = z_right
+
+        # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
+        ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
+        ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
+        ref_to_shell_r = length(ref_to_shell_r_vec)
+        ref_to_shell_z = abs(ref_to_shell_z)
+
+        # calculate the distances in r/z from the scaling center to the shell
+        scale_center_to_shell_r = ref_to_shell_r - scale_center_r
+        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
+
+        # get angles
+        omega = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
+        omega += Pi
+
+        if __debug__:
+            log.debug('omega = %s' % FORMAT_DOUBLE % omega)
+
+        if omega <= scale_angle:
+            z1_new = min(z1, (ref_to_shell_z - shell_half_length)/SAFETY)
+            r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
+        else:
+            r_new = min(r, (ref_to_shell_r) - shell_radius)/SAFETY)
+            z1_new = min(z1, z1_function(single1, single2, r0, r_new))
+        z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+
+
+        # switch the z values in case it's necessary. r doesn't have to be switched.
+        r = r_new
+        if direction >= 0.0:
+            z_right = z1_new
+            z_left  = z2_new
+        else:
+            z_right = z2_new
+            z_left  = z1_new
+
         return (r, z_right, z_left)
 
     def get_radius_to_shell(self, shell_appearance, domain_to_scale):

From bd7cbc4241884490cacd229ce85df505be81a2bc Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 15:00:20 +0100
Subject: [PATCH 0465/1541] small changes to laurens's algorithm for
 cylindrical shells

---
 shells.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 8b076f3b..2b6de3b1 100755
--- a/shells.py
+++ b/shells.py
@@ -238,11 +238,12 @@ def __init__(self, cylindricaltestShell):
 
     def get_center:
 
-    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
+    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
         # CylindricaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
 
-        log.debug('cylinder')
+        if __debug__:
+            log.debug('cylinder')
 
         assert type(shell, Cylinder)        # because the shell actually originated here
         # Do Laurens' algorithm (part2)
@@ -302,9 +303,11 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale):
             log.debug('omega = %s' % FORMAT_DOUBLE % omega)
 
         if omega <= scale_angle:
+            # shell hits the scaling cylinder on top
             z1_new = min(z1, (ref_to_shell_z - shell_half_length)/SAFETY)
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
         else:
+            # shell hits the scaling cylinder on the radial side
             r_new = min(r, (ref_to_shell_r) - shell_radius)/SAFETY)
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
         z2_new = min(z2, z2_function(single1, single2, r0, r_new))

From 35eb8a73de2309ace3e0d95d8cb808f05bc08988 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 19:12:19 +0100
Subject: [PATCH 0466/1541] small clarifications in the scaling functions

---
 pair.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/pair.py b/pair.py
index e4bba02f..08edd740 100644
--- a/pair.py
+++ b/pair.py
@@ -742,6 +742,7 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
         D1 = single1.pid_particle_pair[1].D
         D2 = single2.pid_particle_pair[1].D
         D12 = D1 + D2
+        z_scaling = cls.calc_z_scaling_factor (D1, D2)
 
         # calculate the interparticle vector and project it onto the coordinate system of the structure
         # of particle1
@@ -751,7 +752,6 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
         iv_y =     numpy.dot(iv, single1.structure.shape.unit_y)
         iv_z = abs(numpy.dot(iv, single1.structure.shape.unit_z))
 
-        z_scaling = cls.calc_z_scaling_factor (D1, D2)
         r0 = math.sqrt( iv_x**2 + iv_y**2 + (iv_z*z_scaling)**2)
 
         # calculate the minimal height z_right1 of the shell including burst radius
@@ -1056,12 +1056,11 @@ def calc_right_scalingangle(cls, D1, D2):
         # TODO change this to scaling ratio (this saves us an unnecassary arctan)
         D_r = D1 + D2
         D_R = (D1*D2)/(D1 + D2)
-
         z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
+        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
 
-        angle = math.atan( ( z_scaling_factor * ( math.sqrt( (2*D_R)/(3*D_r) ) + \
-                                                      max( D1/D_r, D2/D_r )
-                                                    )))
+        drdz =  z_scaling_factor * ( sqrt_DRDr + max( D1/D_r, D2/D_r ))
+        angle = math.atan( drdz )
         return angle
 
     @classmethod
@@ -1073,16 +1072,16 @@ def z_right(cls, single1, single2, r0, r):
         D2 = single2.pid_particle_pair[1].D
         D_r = D1 + D2
         D_R = (D1*D2)/(D1 + D2)
+        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
+        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
 
         # calculate a_r such that the expected first-passage for the CoM and IV are equal
-        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
         a_r1 = (r - radius1 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D1/D_r) )
         a_r2 = (r - radius2 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D2/D_r) )
         # take the smallest that, if entered in the function for r below, would lead to this z_right
         a_r = min (a_r1, a_r2)
 
-        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
-        z_right = (a_r/z_scaling_factor) + (radius2)
+        z_right = (a_r/z_scaling_factor) + radius2
 
         return z_right
 
@@ -1095,14 +1094,15 @@ def r_right(cls, single1, single2, r0, z_right):
         D2 = single2.pid_particle_pair[1].D
         D_r = D1 + D2
         D_R = (D1*D2)/(D1 + D2)
+        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
+        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
 
         # we first calculate the a_r, since it is the only radius that depends on z_right only.
-        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
-        a_r = (z_right - (radius2)) * z_scaling_factor
+        a_r = (z_right - radius2) * z_scaling_factor
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
         # Note that for the IV we only take the distance to the outer boundary into account.
-        a_R = (a_r - r0)*math.sqrt((2*D_R)/(3*D_r))
+        a_R = (a_r - r0)*sqrt_DRDr
 
         # We calculate the maximum space needed for particles A and B based on maximum IV displacement
         iv_max = max( (D1/D_r * a_r + radius1),

From 26b7d3057f6654403645be64420284854ded603a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Dec 2011 19:12:55 +0100
Subject: [PATCH 0467/1541] more added code for proper shell making

---
 shells.py | 92 +++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 65 insertions(+), 27 deletions(-)

diff --git a/shells.py b/shells.py
index 2b6de3b1..e449a93a 100755
--- a/shells.py
+++ b/shells.py
@@ -67,8 +67,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         if ref_to_shell_z >= 0:
             direction = 1           # improve direction specification such that following calculations still work
                                     # Otherwise problems when direction = 0
-            get_scale_angle  = domain_to_scale.get_right_scalingangle
-            get_scale_center = domain_to_scale.get_right_scalingcenter
+            scale_angle = domain_to_scale.get_right_scalingangle()
+            scale_center_r, scale_center_z = domain_to_scale.get_right_scalingcenter() 
             r1_function =  domain_to_scale.r_right
             z1_function = domain_to_scale.z_right
             z2_function = domain_to_scale.z_left
@@ -77,8 +77,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         # else -> use z_left
         else:
             direction = -1
-            get_scalingangle  = domain_to_scale.get_left_scalingangle
-            get_scalingcenter = domain_to_scale.get_left_scalingcenter
+            scale_angle = domain_to_scale.get_left_scalingangle()
+            scale_center_r, scale_center_z = domain_to_scale.get_left_scalingcenter() 
             r1_function =  domain_to_scale.r_left
             z1_function = domain_to_scale.z_left
             z2_function = domain_to_scale.z_right
@@ -92,8 +92,6 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         ref_to_shell_z = abs(ref_to_shell_z)
 
         # get the center from which linear scaling will take place
-        scale_angle = get_scalingangle()
-        scale_center_r, scale_center_z = get_scalingcenter() 
         scale_center_to_shell_r = ref_to_shell_r - scale_center_r
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
@@ -149,9 +147,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         ### Get the right values for z and r for the given situation
         if situation == 1:      # the spherical shell hits cylinder on the flat side
-            z1_new = min(z1, (scale_center_z + scale_center_to_shell_z - shell_radius)/SAFETY)
+            z1_new = min(z1, (ref_to_shell_z - shell_radius)/SAFETY)
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
-            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 2:    # shell hits sphere on the edge
             shell_radius_sq = shell_radius*shell_radius
@@ -163,24 +160,22 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
             scale_center_shell_dist = (scale_center_to_shell_len * cos_psi - math.sqrt(shell_radius_sq - ss_sq*sin_psi*sin_psi) )
             # FIXME UGLY FIX BELOW
 #            scale_center_shell_dist /= 1.1
-            scale_center_shell_dist /= SAFETY
 
             if scale_angle <= Pi/4:
-                z1_new = min(z1, scale_center_z + cos_scale_angle * scale_center_shell_dist)
+                z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist)/SAFETY)
                 r_new  = min(r, r1_function(single1, single2, r0, z1_new))
-                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
             else:
-                r_new = min(r, scale_center_r + sin_scale_angle * scale_center_shell_dist)
+                r_new = min(r, (scale_center_r + sin_scale_angle * scale_center_shell_dist)/SAFETY)
                 z1_new = min(z1, z1_function(single1, single2, r0, r_new))
-                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
         elif situation == 3:    # shell hits cylinder on the round side
-            r_new = min(r, (scale_center_r + abs(scale_center_to_shell_r) - shell_radius)/SAFETY)
+            r_new = min(r, (ref_to_shell_r - shell_radius)/SAFETY)
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
-            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
         else:
             raise RuntimeError('Bad situation for cylindrical shell making to sphere.')
 
+        z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+
         # switch the z values in case it's necessary. r doesn't have to be switched.
         r = r_new
         if direction >= 0.0:
@@ -193,12 +188,14 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         return (r, z_right, z_left)
 
 
-    def get_radius_to_shell(self, shell_appearance, domain_to_scale):
+    def get_radius_to_shell(self, shell, domain_to_scale):
         # SphericaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
 
-        assert type(shell_appearance, Sphere)        # because the shell actually originated here
+        assert type(shell, Sphere)        # because the shell actually originated here
         # Do simple distance calculation to sphere
 
+        scale_point = domain_to_scale.center
+        r = world.distance(shell.shape, scale_point)
         return r
 
 #####
@@ -224,9 +221,12 @@ def shell_list_for_other(self):
 #####
 class SphericalPair(hasSphericalShell, Others):
 
+    pass
+
 #####
 class Multi(hasSphericalShell, Others):
 
+    pass
 
 #########################
 class hasCylindricalShell(hasShell):
@@ -237,6 +237,7 @@ def __init__(self, cylindricaltestShell):
         self.half_length = uitrekenen zie interactions
 
     def get_center:
+        pass
 
     def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
@@ -324,12 +325,14 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         return (r, z_right, z_left)
 
-    def get_radius_to_shell(self, shell_appearance, domain_to_scale):
+    def get_radius_to_shell(self, shell, domain_to_scale):
         # SphericaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
 
-        assert type(shell_appearance, Cylinder)        # because the shell actually originated here
+        assert type(shell, Cylinder)        # because the shell actually originated here
         # Do simple distance calculation to cylinder
 
+        scale_point = domain_to_scale.center
+        r = world.distance(shell.shape, scale_point)
         return r
 
 #####
@@ -679,6 +682,9 @@ def get_left_scalingangle(self):
 #####
 class MixedPair3D2DtestShell(CylindricaltestShell, Others):
 
+    def __init__(self, single2D, single3D):
+
+
     def get_orientation_vector(self):
         result = do_calculation
         return result
@@ -703,21 +709,53 @@ def get_right_scalingcenter(self):
         # returns the scaling center in the cylindrical coordinates r, z of the shell
         # Note that we assume cylindrical symmetry
         # Note also that it is relative to the 'side' (right/left) of the cylinder
-        # note calculate this only once since 'orientation_z' doens't change
-        # for different shells
-        h0_right = bla
-        return 0, h0_right
+        return 0.0, self.z_right(0.0)
 
     def get_left_scalingcenter(self):
-        # note calculate this only once since orientation_z doesn't change
-        # for difference shells
-        return 0, particle_radius
+        return 0.0, self.z_left(0.0)
 
     def get_right_scalingangle(self):
-        return bla
+        drdz =  z_scaling_factor * ( sqrt_DRDr + max( D1/D_r, D2/D_r ))
+        angle = math.atan( drdz )
+        return angle
 
     def get_left_scalingangle(self):
         return Pi/2.0
 
+    def z_right(self, r):
+        # calculate a_r such that the expected first-passage for the CoM and IV are equal
+        a_r1 = (r - radius1 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D1/D_r) )
+        a_r2 = (r - radius2 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D2/D_r) )
+        # take the smallest that, if entered in the function for r below, would lead to this z_right
+        a_r = min (a_r1, a_r2)
+
+        return (a_r/z_scaling_factor) + radius2
+
+    def r_right(self, z):
+        # we first calculate the a_r, since it is the only radius that depends on z_right only.
+        a_r = (z_right - radius2) * self.z_scaling_factor
+
+        # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
+        # Note that for the IV we only take the distance to the outer boundary into account.
+        a_R = (a_r - r0)*sqrt_DRDr
+
+        # We calculate the maximum space needed for particles A and B based on maximum IV displacement
+        iv_max = max( (D1/D_r * a_r + radius1),
+                      (D2/D_r * a_r + radius2))
+
+        return a_R + iv_max
+
+    def z_left(self, r):
+        return single1.pid_particle_pair[1].radius
+
+    def r_left(self, z):
+        return numpy.inf
+
+
+    def get_z_scaling_factor(self):
+        D2d = self.single2D.pid_partcle_pair[1].D
+        D3d = self.single3D.pid_partcle_pair[1].D
+        return math.sqrt( (D2d + D3d) / D3d)
+
 #####
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From c4cd0009b53852a9825253e50e5e4d9b63d0b558 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Dec 2011 16:45:31 +0100
Subject: [PATCH 0468/1541] started builing the hiearchy for the shell making
 methods

---
 shells.py | 46 +++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index e449a93a..e14cc0d2 100755
--- a/shells.py
+++ b/shells.py
@@ -480,6 +480,18 @@ def determine_possible_shell(self):
     def get_searchradius():
         return max_that_fits_correctly
             
+    def r_right(self, z_right):
+        return self.drdz_right * z_right + self.r0_right
+    def z_right(self, r_right):
+        return self.dzdr_right * r_right + self.z0_right
+    def r_left(self, z_left):
+        return self.drdz_left * z_left + self.r0_left
+    def z_left(self, r_left):
+        return self.dzdr_left * r_left + self.z0_left
+
+    def max_shell_thing(self):
+        pass    # todo
+
 #####
 class PlanarSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
 
@@ -547,6 +559,16 @@ def get_max_dr_dzright_dzleft(self):
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
 
+        # scaling parameters
+        self.dzdr_right = numpy.inf
+        self.drdz_right = 0.0
+        self.r0_right   = particle_radius
+        self.z0_right   = 0.0
+        self.dzdr_left  = numpy.inf
+        self.drdz_left  = 0.0
+        self.r0_left    = particle_radius
+        self.z0_left    = 0.0
+
     def orientation_vector(self):
         return structure.shape.unit_z   # just copy from structure
 
@@ -592,6 +614,16 @@ class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
 #####
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell, Others):
 
+        # scaling parameters
+        self.dzdr_right = 1.0
+        self.drdz_right = 1.0
+        self.r0_right   = 0.0
+        self.z0_right   = distance_particle_refpoint
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = 0.0
+        self.z0_left    = particle_radius
+
     def get_orientation_vector(self):
         result = do_calculation
         return result
@@ -630,7 +662,7 @@ def get_left_scalingcenter(self):
         return 0, particle_radius
 
     def get_right_scalingangle(self):
-        return bla
+        return Pi/4.0
 
     def get_left_scalingangle(self):
         return Pi/2.0
@@ -638,6 +670,18 @@ def get_left_scalingangle(self):
 #####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, Others):
 
+    def __init__(self):
+
+        # scaling parameters
+        self.dzdr_right = 1.0
+        self.drdz_right = 1.0
+        self.r0_right   = 0.0
+        self.z0_right   = calculate_it
+        self.dzdr_left  = 1.0
+        self.drdz_left  = 1.0
+        self.r0_left    = 0.0
+        self.z0_left    = calculate_it
+
     def get_orientation_vector(self):
         return structure.shape.unit_z
 

From 14dc082e1c0c267f7b3b954912ac9103e3834f9f Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 19 Dec 2011 10:25:38 +0100
Subject: [PATCH 0469/1541] Useless change makefile

---
 doc/greens_functions/tex/Makefile | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/greens_functions/tex/Makefile b/doc/greens_functions/tex/Makefile
index edcc7db0..945c889b 100644
--- a/doc/greens_functions/tex/Makefile
+++ b/doc/greens_functions/tex/Makefile
@@ -26,11 +26,11 @@ greensFunction1DRadAbs.pdf: greensFunction1DRadAbs.tex include/greensFunction1DR
 greensFunction1DRadInf.pdf: greensFunction1DRadInf.tex include/greensFunction1DRadInf.include.tex
 	$(PDFLATEX) greensFunction1DRadInf.tex
 
-greensFunction1DAbsSinkAbs.pdf: greensFunction1DAbsSinkAbs.tex include/greensFunction1DAbsSinkAbs.include.tex 
-	$(PDFLATEX) greensFunction1DAbsSinkAbs.tex 
-	
-greensFunction1DInfSinkInf.pdf: greensFunction1DInfSinkInf.tex include/greensFunction1DInfSinkInf.include.tex 
-	$(PDFLATEX) greensFunction1DInfSinkInf.tex 
+greensFunction1DAbsSinkAbs.pdf: greensFunction1DAbsSinkAbs.tex include/greensFunction1DAbsSinkAbs.include.tex
+	$(PDFLATEX) greensFunction1DAbsSinkAbs.tex
+
+greensFunction1DInfSinkInf.pdf: greensFunction1DInfSinkInf.tex include/greensFunction1DInfSinkInf.include.tex
+	$(PDFLATEX) greensFunction1DInfSinkInf.tex
 
 greensFunction2DRadAbs.pdf: greensFunction2DRadAbs.tex include/greensFunction2DRadAbs.include.tex
 	$(PDFLATEX) greensFunction2DRadAbs.tex

From e9c92e8f68ecc14d9efee49c0a4f6eaa75f7c3d9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Dec 2011 15:23:54 +0100
Subject: [PATCH 0470/1541] moved to situation where the scalingangle(ratio)
 and scalingcenter are the base of all the scaling functions

---
 shells.py | 56 +++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 48 insertions(+), 8 deletions(-)

diff --git a/shells.py b/shells.py
index e14cc0d2..1b1837e7 100755
--- a/shells.py
+++ b/shells.py
@@ -36,8 +36,6 @@ def shell_list(self):
 #######################
 class hasSphericalShell(hasShell):
 
-    self.shell
-
     def __init__(self, sphericaltestShell):
         self.center = sphericaltestShell.center
         self.radius = sphericaltestShell.radius
@@ -477,9 +475,7 @@ def determine_possible_shell(self):
         else
             return None
 
-    def get_searchradius():
-        return max_that_fits_correctly
-            
+    # default functions for evaluating z_right/z_left/r after one of parameters changed
     def r_right(self, z_right):
         return self.drdz_right * z_right + self.r0_right
     def z_right(self, r_right):
@@ -489,12 +485,23 @@ def r_left(self, z_left):
     def z_left(self, r_left):
         return self.dzdr_left * r_left + self.z0_left
 
-    def max_shell_thing(self):
-        pass    # todo
+    def get_max_dr_dzright_dzleft(self):
+        pass    # todo, we should be able to derive this from the scaling parameters and searchpoint
 
 #####
 class PlanarSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
 
+    def __init__(self):
+        # scaling parameters
+        self.dzdr_right = 0.0
+        self.drdz_right = numpy.inf
+        self.r0_right   = 0.0
+        self.z0_right   = particle_radius
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = 0.0
+        self.z0_left    = particle_radius
+
     def get_orientation_vector(self):
         return structure.shape.unit_z   # just copy from structure
 
@@ -537,6 +544,17 @@ def get_left_scalingangle(self):
 #####
 class PlanarSurfacePairtestShell(hasCylindricalShell, Others):
 
+    def __init__(self):
+        # scaling parameters
+        self.dzdr_right = 0.0
+        self.drdz_right = numpy.inf
+        self.r0_right   = 0.0
+        self.z0_right   = max(particle_radius1, particle_radius2)
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = 0.0
+        self.z0_left    = max(particle_radius1, particle_radius2)
+
     def get_orientation_vector(self):
         return structure.shape.unit_z
 
@@ -559,6 +577,7 @@ def get_max_dr_dzright_dzleft(self):
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
 
+    def __init__(self):
         # scaling parameters
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
@@ -611,9 +630,21 @@ def get_left_scalingangle(self):
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
 
+    def __init__(self):
+        # scaling parameters
+        self.dzdr_right = numpy.inf
+        self.drdz_right = 0.0
+        self.r0_right   = max(particle_radius1, particle_radius2)
+        self.z0_right   = 0.0
+        self.dzdr_left  = numpy.inf
+        self.drdz_left  = 0.0
+        self.r0_left    = max(particle_radius1, particle_radius2)
+        self.z0_left    = 0.0
+
 #####
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell, Others):
 
+    def __init__(self):
         # scaling parameters
         self.dzdr_right = 1.0
         self.drdz_right = 1.0
@@ -680,7 +711,7 @@ def __init__(self):
         self.dzdr_left  = 1.0
         self.drdz_left  = 1.0
         self.r0_left    = 0.0
-        self.z0_left    = calculate_it
+        self.z0_left    = calculate_it (same as above)
 
     def get_orientation_vector(self):
         return structure.shape.unit_z
@@ -728,6 +759,15 @@ class MixedPair3D2DtestShell(CylindricaltestShell, Others):
 
     def __init__(self, single2D, single3D):
 
+        # scaling parameters
+        self.dzdr_right = calculate_it
+        self.drdz_right = calculate_it
+        self.r0_right   = 0.0
+        self.z0_right   = calculate_it
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = 0.0
+        self.z0_left    = particle2D_radius
 
     def get_orientation_vector(self):
         result = do_calculation

From 4dd77fb518f47e9876baf3cb8b6fde3b4d81eda1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Dec 2011 17:50:08 +0100
Subject: [PATCH 0471/1541] prepared the SphericalSingle for the transition to
 testShells -> code still commented out

---
 single.py | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/single.py b/single.py
index 17b19847..3621d41a 100644
--- a/single.py
+++ b/single.py
@@ -37,6 +37,8 @@ def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
 
         self.pid_particle_pair = pid_particle_pair      # the particle in the single
         self.structure = structure                      # the structure in/on which the particle lives
+#        self.pid_particle_pair = testShell.pid_particle_pair      # the particle in the single
+#        self.structure = testShell.structure                      # the structure in/on which the particle lives
 
         self.reactionrules = reactionrules              # the reaction rules for mono molecular reactions
         self.rrule = None                               # the reaction rule of the actual reaction (property reactionrule)
@@ -300,6 +302,7 @@ def get_max_shell_size(self, geometrycontainer, domains):
 
 
 class SphericalSingle(NonInteractionSingle):
+#class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalShell):
     """1 Particle inside a (spherical) shell not on any surface.
 
         * Particle coordinate inside shell: r, theta, phi.
@@ -311,16 +314,43 @@ class SphericalSingle(NonInteractionSingle):
     """
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
                  structure):
+#    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+#        This should also be moved to single, since it's the same for all NonInteractionSingles
+#        -> change constructor
+#        pid_particle_pair = testShell.pid_particle_pair
+#        structure = testShell.structure
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
                                       shell_id, reactionrules, structure)
+#        hasSphericalShell.__init__(self, testShell)
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
                                           self.get_inner_a())
 
+# this can go
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(self.domain_id, Sphere(position, radius))
 
+# instead we have this
+    # specific shell methods for the SphericalSingle
+    # these return potentially corrected dimensions
+    def shell_list_for_single(self):
+        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+        if  self.shell.shape.radius < min_radius:
+            fake_shell = self.testShell.create_new_shell(min_radius, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
+
+    def shell_list_for_other(self):
+        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+        if self.shell.shape.radius < min_radius:
+            fake_shell = self.testShell.create_new_shell(min_radius, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
+
+
     def create_position_vector(self, r):
         return random_vector(r)
 

From 1cacd7ede53bd83a6498330334180f5a2f7db11f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Dec 2011 17:51:29 +0100
Subject: [PATCH 0472/1541] replace concept code (more explanation) by real
 code.

---
 shells.py | 90 +++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 58 insertions(+), 32 deletions(-)

diff --git a/shells.py b/shells.py
index 1b1837e7..c3029ad3 100755
--- a/shells.py
+++ b/shells.py
@@ -30,15 +30,23 @@ def get_neighbor_shell_list(self, neighbor):
 ##################################
 class hasShell(object):
 
-    def shell_list(self):
-            return self.shell_list
+    def __init__(self, testShell):
+        self.testShell = testShell
+
+#    def shell_list(self):
+#            return self.shell_list
 
 #######################
 class hasSphericalShell(hasShell):
+# The testShell is now converted into smt that we can use in the domain instance
 
     def __init__(self, sphericaltestShell):
-        self.center = sphericaltestShell.center
-        self.radius = sphericaltestShell.radius
+
+        hasShell.__init__(self, sphericaltestShell)
+
+        self.center = self.sphericaltestShell.center
+        self.radius = self.sphericaltestShell.radius
+        self.shell = self.testShell.create_new_shell(self.radius, self.domain_id)
 
     # methods to size up a shell to this shell
     def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
@@ -193,7 +201,7 @@ def get_radius_to_shell(self, shell, domain_to_scale):
         # Do simple distance calculation to sphere
 
         scale_point = domain_to_scale.center
-        r = world.distance(shell.shape, scale_point)
+        r = self.world.distance(shell.shape, scale_point)
         return r
 
 #####
@@ -201,18 +209,18 @@ class SphericalSingle(hasSphericalShell, NonInteractionSingles):
 
     # these return potentially corrected dimensions
     def shell_list_for_single(self):
-        min_radius = self.get_min_radius()
+        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if  self.shell.shape.radius < min_radius:
-            fake_shell = make_new_shell (min_radius)
-            return [fake_shell, ]
+            fake_shell = self.shell_object.create_new_shell(min_radius, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_radius = particle_radius * SINGLE_SHELL_FACTOR
+        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
-            fake_shell = make_new_shell (min_radius)
-            return [fake_shell, ]
+            fake_shell = self.shell_object.create_new_shell(min_radius, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
@@ -330,7 +338,7 @@ def get_radius_to_shell(self, shell, domain_to_scale):
         # Do simple distance calculation to cylinder
 
         scale_point = domain_to_scale.center
-        r = world.distance(shell.shape, scale_point)
+        r = self.world.distance(shell.shape, scale_point)
         return r
 
 #####
@@ -338,18 +346,20 @@ class PlanarSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
-        min_radius = particle_radius * MULTI_SHELL_FACTOR
+        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
-            fake_shell = create_shell(min_radius, normal_half_length)
-            return [fake_shell, ]
+            half_length = self.shell.shape.half_length
+            fake_shell = self.shell_object.create_new_shell(min_radius, half_length, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_radius = particle_radius * SINGLE_SHELL_FACTOR
+        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
-            fake_shell = create_shell(min_radius, normal_half_length)
-            return [fake_shell, ]
+            half_length = self.shell.shape.half_length
+            fake_shell = self.shell_object.create_new_shell(min_radius, half_length, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
@@ -358,18 +368,20 @@ class CylindricalSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
-        min_half_length = particle_radius * MULTI_SHELL_FACTOR
+        min_half_length = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if self.shell.shape.half_length < min_half_length:
-            fake_shell = create_shell(radius, min_half_length)
-            return [fake_shell, ]
+            radius = self.shell.shape.radius
+            fake_shell = self.shell_object.create_new_shell(radius, min_half_length, domain_id)
+            return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_half_length = particle_radius * SINGLE_SHELL_FACTOR
+        min_half_length = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.half_length < min_half_length:
-            fake_shell = create_shell(radius, min_half_length)
-            return [fake_shell, ]
+            radius = self.shell.shape.radius
+            fake_shell = self.shell_object.create_new_shell(radius, min_half_length, domain_id)
+            return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
@@ -386,6 +398,9 @@ class MixedPair3D2D(hasCylindricalShell, Others):
 #######################################################
 class testShell(object):
 
+    def __init__(self):
+        self.shell = None
+
     def get_neighbors(self):
         searchpoint = self.get_searchpoint()
         radius = self.get_searchradius()
@@ -394,8 +409,9 @@ def get_neighbors(self):
 ########################
 class SphericaltestShell(testShell):
 
-    self.radius
-    self.center
+    def __init__(self):
+        self.radius = 0
+        self.center = None
 
     def determine_possible_shell(self):
         neighbors = self.get_neighbors()
@@ -407,7 +423,7 @@ def determine_possible_shell(self):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                new_radius = neighbor.get_radius_to_shell(shell_appearance, self)
+                new_radius = neighbor.shell_object.get_radius_to_shell(shell_appearance, self)
                 # if the newly calculated dimensions are smaller than the current one, use them
                 radius = min(radius, new_radius)
 
@@ -416,10 +432,15 @@ def determine_possible_shell(self):
                     break
 
         if radius:
-            return self.create_new_shell(radius)
+            self.radius = radius
+            return radius
         else
             return None
 
+    def create_new_shell(self, radius, domain_id):
+        position = self.center
+        return SphericalShell(domain_id, Sphere(position, radius))
+
     def get_searchpoint(self):
         return self.center
     def get_searchradius(self):
@@ -447,10 +468,10 @@ def get_min_radius:
 ##########################
 class CylindricaltestShell(testShell):
 
-    self.dr
-    self.dz_right
-    self.dz_left
-    self.scaling_angle_right = None     # this needs to be calculated once
+    def __init__(self):
+        self.position = calc from self.dr
+        self.radius =        self.dz_right
+        self.half_length =        self.dz_left
 
     def determine_possible_shell(self):
         neighbors = self.get_neighbors()
@@ -475,6 +496,11 @@ def determine_possible_shell(self):
         else
             return None
 
+    def create_new_shell(self, radius, half_length, domain_id):
+        position = self.position
+        orientation = self.get_orientation_vector()
+        return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
+
     # default functions for evaluating z_right/z_left/r after one of parameters changed
     def r_right(self, z_right):
         return self.drdz_right * z_right + self.r0_right

From ac1648cb60a7987211efa7fb295572a8f112c60f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Dec 2011 18:24:57 +0100
Subject: [PATCH 0473/1541] Code finalized to initialize hasShell objects with
 testShells

---
 shells.py | 69 +++++++++++++++++++++++++++++++++----------------------
 single.py |  6 +++--
 2 files changed, 46 insertions(+), 29 deletions(-)

diff --git a/shells.py b/shells.py
index c3029ad3..af76aa2a 100755
--- a/shells.py
+++ b/shells.py
@@ -44,9 +44,14 @@ def __init__(self, sphericaltestShell):
 
         hasShell.__init__(self, sphericaltestShell)
 
-        self.center = self.sphericaltestShell.center
-        self.radius = self.sphericaltestShell.radius
-        self.shell = self.testShell.create_new_shell(self.radius, self.domain_id)
+        self.shell_center = self.sphericaltestShell.center
+        self.shell_radius = self.sphericaltestShell.radius
+        self.shell = self.create_new_shell(self.shell_center,
+                                           self.shell_radius,
+                                           self.domain_id)
+
+    def create_new_shell(self, position, radius, domain_id):
+        return SphericalShell(domain_id, Sphere(position, radius))
 
     # methods to size up a shell to this shell
     def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
@@ -211,7 +216,8 @@ class SphericalSingle(hasSphericalShell, NonInteractionSingles):
     def shell_list_for_single(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if  self.shell.shape.radius < min_radius:
-            fake_shell = self.shell_object.create_new_shell(min_radius, self.domain_id)
+            position = self.shape.shell.position
+            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -219,7 +225,8 @@ def shell_list_for_single(self):
     def shell_list_for_other(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
-            fake_shell = self.shell_object.create_new_shell(min_radius, self.domain_id)
+            position = self.shape.shell.position
+            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -238,12 +245,24 @@ class Multi(hasSphericalShell, Others):
 class hasCylindricalShell(hasShell):
 
     def __init__(self, cylindricaltestShell):
-        self.center = uitrekenen zie interactions
-        self.radius = cylindricaltestShell.dr
-        self.half_length = uitrekenen zie interactions
 
-    def get_center:
-        pass
+        hasShell.__init__(self, cylindricaltestShell)
+
+        self.shell_center = cylindricaltestShell.get_referencepoint() + \
+                            ((cylindricaltestShell.dz_right - cylindricaltestShell.dz_left)/2.0) * \
+                            cylindricaltestShell.get_orientation_vector()
+        self.shell_center = self.world.apply_boundary(self.shell_center)
+        self.shell_radius = cylindricaltestShell.dr
+        self.shell_half_length = (cylindricaltestShell.dz_left + cylindricaltestShell.dz_right) / 2.0
+
+        self.shell = self.create_new_shell(self.shell_center,
+                                           self.shell_radius,
+                                           self.shell_half_length,
+                                           self.domain_id)
+
+    def create_new_shell(self, position, radius, half_length, domain_id):
+        orientation = self.get_orientation_vector()
+        return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
 
     def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
@@ -348,8 +367,9 @@ class PlanarSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
     def shell_list_for_single(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
+            position = self.shell.shape.position
             half_length = self.shell.shape.half_length
-            fake_shell = self.shell_object.create_new_shell(min_radius, half_length, self.domain_id)
+            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -357,8 +377,9 @@ def shell_list_for_single(self):
     def shell_list_for_other(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
+            position = self.shell.shape.position
             half_length = self.shell.shape.half_length
-            fake_shell = self.shell_object.create_new_shell(min_radius, half_length, self.domain_id)
+            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -370,8 +391,9 @@ class CylindricalSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
     def shell_list_for_single(self):
         min_half_length = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if self.shell.shape.half_length < min_half_length:
+            position = self.shell.shape.position
             radius = self.shell.shape.radius
-            fake_shell = self.shell_object.create_new_shell(radius, min_half_length, domain_id)
+            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -379,8 +401,9 @@ def shell_list_for_single(self):
     def shell_list_for_other(self):
         min_half_length = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.half_length < min_half_length:
+            position = self.shell.shape.position
             radius = self.shell.shape.radius
-            fake_shell = self.shell_object.create_new_shell(radius, min_half_length, domain_id)
+            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -437,10 +460,6 @@ def determine_possible_shell(self):
         else
             return None
 
-    def create_new_shell(self, radius, domain_id):
-        position = self.center
-        return SphericalShell(domain_id, Sphere(position, radius))
-
     def get_searchpoint(self):
         return self.center
     def get_searchradius(self):
@@ -461,6 +480,7 @@ def get_min_radius(self):
 class SphericalPairtestShell(testSphericalShell, Others):
 
     self.center = calculate CoM
+
     def get_min_radius:
         return calculate_min_radius_see_sphericalpair
 
@@ -469,9 +489,9 @@ def get_min_radius:
 class CylindricaltestShell(testShell):
 
     def __init__(self):
-        self.position = calc from self.dr
-        self.radius =        self.dz_right
-        self.half_length =        self.dz_left
+        self.dz_right = 0
+        self.dz_left  = 0
+        self.dr       = 0
 
     def determine_possible_shell(self):
         neighbors = self.get_neighbors()
@@ -492,15 +512,10 @@ def determine_possible_shell(self):
                     break
 
         if dr_dzright_dzleft:
-            return self.create_new_shell(dr_dzright_dzleft)
+            return dr_dz_right_dzleft
         else
             return None
 
-    def create_new_shell(self, radius, half_length, domain_id):
-        position = self.position
-        orientation = self.get_orientation_vector()
-        return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
-
     # default functions for evaluating z_right/z_left/r after one of parameters changed
     def r_right(self, z_right):
         return self.drdz_right * z_right + self.r0_right
diff --git a/single.py b/single.py
index 3621d41a..7e597323 100644
--- a/single.py
+++ b/single.py
@@ -337,7 +337,8 @@ def create_new_shell(self, position, radius, domain_id):
     def shell_list_for_single(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if  self.shell.shape.radius < min_radius:
-            fake_shell = self.testShell.create_new_shell(min_radius, self.domain_id)
+            position = self.shape.shell.position
+            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -345,7 +346,8 @@ def shell_list_for_single(self):
     def shell_list_for_other(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
-            fake_shell = self.testShell.create_new_shell(min_radius, self.domain_id)
+            position = self.shape.shell.position
+            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list

From 1b8f966bb693e5c4642c61591dca83bf76dfb977 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Dec 2011 18:38:20 +0100
Subject: [PATCH 0474/1541] minor fixed typos

---
 shells.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index af76aa2a..0d04d155 100755
--- a/shells.py
+++ b/shells.py
@@ -39,13 +39,14 @@ def __init__(self, testShell):
 #######################
 class hasSphericalShell(hasShell):
 # The testShell is now converted into smt that we can use in the domain instance
+# FIXME TODO This doesn't work for a Multi!!
 
     def __init__(self, sphericaltestShell):
 
         hasShell.__init__(self, sphericaltestShell)
 
-        self.shell_center = self.sphericaltestShell.center
-        self.shell_radius = self.sphericaltestShell.radius
+        self.shell_center = sphericaltestShell.center
+        self.shell_radius = sphericaltestShell.radius
         self.shell = self.create_new_shell(self.shell_center,
                                            self.shell_radius,
                                            self.domain_id)

From 82b42c7acaa5c251146f2447551ac213f52aa1a4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Dec 2011 18:44:40 +0100
Subject: [PATCH 0475/1541] moved all initialization to the hasSphericalShell
 and hasCylindricalShell inits to avoid problems with Multis

---
 shells.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index 0d04d155..0b64f6c0 100755
--- a/shells.py
+++ b/shells.py
@@ -31,7 +31,7 @@ def get_neighbor_shell_list(self, neighbor):
 class hasShell(object):
 
     def __init__(self, testShell):
-        self.testShell = testShell
+        pass
 
 #    def shell_list(self):
 #            return self.shell_list
@@ -39,12 +39,13 @@ def __init__(self, testShell):
 #######################
 class hasSphericalShell(hasShell):
 # The testShell is now converted into smt that we can use in the domain instance
-# FIXME TODO This doesn't work for a Multi!!
 
     def __init__(self, sphericaltestShell):
+    # Note that the Multi should not call __init__ because we don't want to initialize the shell
 
         hasShell.__init__(self, sphericaltestShell)
 
+        self.testShell = sphericaltestShell
         self.shell_center = sphericaltestShell.center
         self.shell_radius = sphericaltestShell.radius
         self.shell = self.create_new_shell(self.shell_center,
@@ -249,6 +250,7 @@ def __init__(self, cylindricaltestShell):
 
         hasShell.__init__(self, cylindricaltestShell)
 
+        self.testShell = cylindricaltestShell
         self.shell_center = cylindricaltestShell.get_referencepoint() + \
                             ((cylindricaltestShell.dz_right - cylindricaltestShell.dz_left)/2.0) * \
                             cylindricaltestShell.get_orientation_vector()
@@ -262,7 +264,7 @@ def __init__(self, cylindricaltestShell):
                                            self.domain_id)
 
     def create_new_shell(self, position, radius, half_length, domain_id):
-        orientation = self.get_orientation_vector()
+        orientation = self.testShell.get_orientation_vector()
         return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
 
     def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):

From 6d6c83d7d7a2b4265d48effc4106f588b07ba248 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 20 Dec 2011 10:21:34 +0100
Subject: [PATCH 0476/1541] Added CylindricalSurfaceSink, for a 1D domain with
 sink.

---
 single.py | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/single.py b/single.py
index bdf4b538..ae276f0e 100644
--- a/single.py
+++ b/single.py
@@ -751,6 +751,90 @@ def get_shell_size(self):
     def __str__(self):
         return 'CylindricalSurfaceInteraction' + Single.__str__(self)
 
+
+class CylindricalSurfaceSink(InteractionSingle):
+    """1 Particle inside a (Cylindrical) shell on a CylindricalSurface.
+        Inside the domain is a sink.
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+        * Selected randomly when drawing displacement vector: none.
+    """
+    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
+                 shell_id, shell_center, shell_half_length, zsink, interactionrules, sink_surface):
+
+        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
+                                   structure, shell_id, interactionrules, sink_surface)
+
+        # z0 is implied to be zero (the particle being in the center of the shell in the z direction)
+        self.zsink = zsink # Position of the sink, given that the particle is at the origin.
+        self.shell = self.create_new_shell(shell_center, 
+                                           pid_particle_pair[1].radius,
+                                           structure.shape.unit_z, 
+                                           shell_half_length)
+
+    def get_inner_a(self):
+        return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+
+    def iv_greens_function(self):
+        # The Green's function used for both ESCAPE and IV (sink) events.
+        # Particle allways starts in the middle for now.
+        half_inner_length = self.get_innet_a()
+        return GreensFunction1DAbsSinkAbs(self.D, self.interaction_ktot, 0.0, self.zsink, 
+                                          -inner_half_length, inner_half_length)
+
+    def determine_next_event(self):
+        """Return an (event_time, event_type)-tuple.
+
+        """
+        return min(self.draw_reaction_time_tuple(),
+                   self.draw_iv_event_time_tuple())
+
+    def draw_new_position(self, dt, event_type):
+        oldpos = self.pid_particle_pair[1].position
+
+        if self.D == 0 or \
+                (event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0):
+            newpos = oldpos
+        else:
+            gf = self.iv_greens_function()
+
+            if event_type == EventType.IV_EVENT:
+                self.event_type = self.draw_iv_event_type()
+                event_type = self.event_type
+
+            if event_type == EventType.IV_ESCAPE:
+                #Determine wether particle escaped at left (s) or right (a) boundary.
+                flux_a = fabs( gf.flux_leavea( dt ) )
+                flux_s = fabs( gf.flux_leaves( dt ) )
+                rnd = myrandom.uniform() * ( flux_a + flux_s )
+                
+                if( rnd < flux_a ):
+                    z = -get_inner_a();
+                else:
+                    z = get_inner_a();
+            elif event_type == EventType.IV_INTERACTION:
+                z = self.zsink
+            else:
+                z = draw_r_wrapper(gf, dt, get_inner_a(), -get_inner_a())
+
+        # Add displacement to shell.shape.position, not to particle.position.
+        z_vector = self.structure.shape.unit_z * z
+        newpos = self.shell.shape.position + z_vector
+
+        return newpos
+
+    def get_shell_size(self):
+        # REMOVE this method, it doesn't mean anything here.
+        # THis method is only used for making an Interaction
+        # Heads up. The cylinder's *half_length*, not radius, 
+        # determines the size in case of a cylindrical surface.
+        return self.shell.shape.half_length
+
+    def __str__(self):
+        return 'CylindricalSurfaceInteraction' + Single.__str__(self)
+
 class DummySingle(object):
     def __init__(self):
         self.multiplicity = 1

From 069b8b3bdd3956f195761befd2a10f92671cbaf8 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 20 Dec 2011 10:35:48 +0100
Subject: [PATCH 0477/1541] Included the new Sink GreensFunctions to the doc
 dir

---
 .../tex/greensFunction1DAbsSinkAbs.tex        | 12 ++++++
 .../tex/greensFunction1DInfSinkInf.tex        | 12 ++++++
 .../greensFunction1DAbsSinkAbs.include.tex    | 40 +++++++++++++++++++
 .../greensFunction1DInfSinkInf.include.tex    | 29 ++++++++++++++
 4 files changed, 93 insertions(+)
 create mode 100644 doc/greens_functions/tex/greensFunction1DAbsSinkAbs.tex
 create mode 100644 doc/greens_functions/tex/greensFunction1DInfSinkInf.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex
 create mode 100644 doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex

diff --git a/doc/greens_functions/tex/greensFunction1DAbsSinkAbs.tex b/doc/greens_functions/tex/greensFunction1DAbsSinkAbs.tex
new file mode 100644
index 00000000..05c7874b
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunction1DAbsSinkAbs.tex
@@ -0,0 +1,12 @@
+
+\documentclass{article}
+
+\include{include/include}
+\include{include/subSectionOnly}
+
+
+\begin{document}
+
+\include{include/greensFunction1DAbsSinkAbs.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/greensFunction1DInfSinkInf.tex b/doc/greens_functions/tex/greensFunction1DInfSinkInf.tex
new file mode 100644
index 00000000..389eaf15
--- /dev/null
+++ b/doc/greens_functions/tex/greensFunction1DInfSinkInf.tex
@@ -0,0 +1,12 @@
+
+\documentclass{article}
+
+\include{include/include}
+\include{include/subSectionOnly}
+
+
+\begin{document}
+
+\include{include/greensFunction1DInfSinkInf.include}
+
+\end{document}
diff --git a/doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex b/doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex
new file mode 100644
index 00000000..7a0056cd
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex
@@ -0,0 +1,40 @@
+
+\subsection{1D Abs Abs}
+
+\paragraph{Green's function}
+
+ \begin{multline}
+ p_r(x,t|x_0) = -2 \sum_{i=1}^{\infty} \, e^{- D \beta_i ^2 t} \, \mathrm{sin} \, \beta_i (L_r - x) \\ 
+\frac{D \beta_i \, \mathrm{sin} \, \beta_i (L_l + x_0) + k \, \mathrm{sin} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i x_0}{D \, (L \beta_i \mathrm{cos} \, \beta_i L + \, \mathrm{sin} \, L \beta_i ) + k \,( L_r \, \mathrm{cos} \, \beta_i L_r \,\, \mathrm{sin} \, \beta_i L_l + L_l \, \mathrm{cos} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i L_r )},
+ \label{FSOL_R}
+\end{multline}
+
+\begin{multline}
+ p_l(x,t,|x_0) = -\sum_{i=1}^{\infty} e^{- D \beta_i ^2 t} \, 2 D \beta_i \, \\ 
+\frac{\mathrm{sin} \, \beta_i (L_l + x) \,\, \mathrm{sin} \, \beta_i (L_r - x_0)}{D \, (L \beta_i \mathrm{cos} \, \beta_i L + \, \mathrm{sin} \, L \beta_i ) + k \,( L_r \, \mathrm{cos} \, \beta_i L_r \,\, \mathrm{sin} \, \beta_i L_l + L_l \, \mathrm{cos} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i L_r )},
+\label{FSOL_L}
+\end{multline}
+
+where $L=L_r + L_l$ in both equations. Note that when $p_r$ is evaluated for $x<x_0$, $x$ and $x_0$ have to be interchanged in equation (\ref{FSOL_R}). This is due to the absolute sign in the Ansatz (\ref{Anz_R}).
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_z(t) = \int_0^L p dz = \frac{4}{\pi} \sum_{m=0}^{\infty} \frac{1}{2m+1}
+  e^{-D_1(2m+1)^2\pi^2t/L^2} \sin\left(\frac{(2m+1)\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Propensity function}
+\begin{align}
+  q_{z=0}(t) &= \left.D_1 \pd{p}{z}\right|_{z=0} = \frac{2\pi D_1}{L^2} 
+  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n \sin\left(\frac{n\pi z'}{L}\right),\\
+  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=L} = \frac{2\pi D_1}{L^2} 
+  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n (-1)^{n+1} \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P(Z,t|z',t'=0) = \int_0^Z p dz =
+  \frac{2}{\pi} \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2 t/L^2}
+      \frac{1}{n} \left[ 1 - \cos\left(\frac{n\pi Z}{L}\right) \right] \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
\ No newline at end of file
diff --git a/doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex b/doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex
new file mode 100644
index 00000000..e5118ced
--- /dev/null
+++ b/doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex
@@ -0,0 +1,29 @@
+
+\subsection{1D Abs Abs}
+
+\paragraph{Green's function}
+\begin{align}
+  p(z,t|z',t'=0) = \frac{2}{L}\sum_{n=1}^{\infty}
+  e^{-D_1n^2\pi^2t/L^2} \sin\bigg(\frac{n\pi z}{L}\bigg) \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_z(t) = \int_0^L p dz = \frac{4}{\pi} \sum_{m=0}^{\infty} \frac{1}{2m+1}
+  e^{-D_1(2m+1)^2\pi^2t/L^2} \sin\left(\frac{(2m+1)\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Propensity function}
+\begin{align}
+  q_{z=0}(t) &= \left.D_1 \pd{p}{z}\right|_{z=0} = \frac{2\pi D_1}{L^2} 
+  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n \sin\left(\frac{n\pi z'}{L}\right),\\
+  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=L} = \frac{2\pi D_1}{L^2} 
+  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n (-1)^{n+1} \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P(Z,t|z',t'=0) = \int_0^Z p dz =
+  \frac{2}{\pi} \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2 t/L^2}
+      \frac{1}{n} \left[ 1 - \cos\left(\frac{n\pi Z}{L}\right) \right] \sin\left(\frac{n\pi z'}{L}\right).
+\end{align}
\ No newline at end of file

From 5bdbc40e383e83906e8a2376da64a2e992b6859c Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 20 Dec 2011 13:52:09 +0100
Subject: [PATCH 0478/1541] Changed get_neighbor_structures to work wih
 base_structure.

---
 egfrd.py          | 3 +--
 pair.py           | 2 +-
 shellcontainer.py | 8 +++++++-
 single.py         | 2 +-
 4 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 33ca28a6..ce6615dd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1140,8 +1140,7 @@ def make_new_domain(self, single):
         # Get also surfaces but only if the particle is in 3D
         surface_distances = []
         if isinstance(single, SphericalSingle):
-            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, ignores=[single.structure.id])
-
+            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
 
         # Check if there are shells with the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
diff --git a/pair.py b/pair.py
index 10c943a5..10482e15 100644
--- a/pair.py
+++ b/pair.py
@@ -251,7 +251,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(shell_center, domains, ignore=[single1.domain_id, 
                                                                   single2.domain_id])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, ignores=[single1.structure.id])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, single1.structure.id, ignores=[])
         neighbors = neighbor_domains + neighbor_surfaces
 
 
diff --git a/shellcontainer.py b/shellcontainer.py
index f583bf37..80d8b3c1 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -170,8 +170,14 @@ def filter_partners(self, neighbor_domains):
     def sort_domain_distance(self, neighbor_domains):
         return sorted(neighbor_domains, key=lambda domain_dist: domain_dist[1])
 
-    def get_neighbor_surfaces(self, position, ignores=[]):
+    def get_neighbor_surfaces(self, position, base_structure_id, ignores=[]):
         # analogous to get_neighbor domains, this returns a list of (surface, distance) tuples
+        # The base_structure_id argument is the id of the structure on which the particle lives
+        # calling this function. In the future, this function will only return surfaces a particle
+        # living on the base_structure can have interactions with.
+        
+        # We assume a particle can't have an interaction with the same surface on/in which it lives.
+        ignores.append( base_structure_id )
 
         # TODO return a list of neighboring surfaces
         surface, distance = get_closest_surface(self.world, position, ignores)
diff --git a/single.py b/single.py
index ae276f0e..c01f2b5d 100644
--- a/single.py
+++ b/single.py
@@ -265,7 +265,7 @@ def get_max_shell_size(self, geometrycontainer, domains):
 #                                              ignores=[self.structure.id])
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(singlepos, domains, ignore=[self.domain_id, ])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, ignores=[self.structure.id])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, self.structure.id, ignores=[])
         neighbors = neighbor_domains + neighbor_surfaces
 
         # 2. Calculate the maximum allowed radius of the spherical domain

From 0a85be67df54b096c6e531506120bab213b783d8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Dec 2011 14:39:52 +0100
Subject: [PATCH 0479/1541] small change in comments

---
 single.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/single.py b/single.py
index 7e597323..10b11ebe 100644
--- a/single.py
+++ b/single.py
@@ -315,8 +315,8 @@ class SphericalSingle(NonInteractionSingle):
     def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
                  structure):
 #    def __init__(self, domain_id, shell_id, testShell, reactionrules):
-#        This should also be moved to single, since it's the same for all NonInteractionSingles
-#        -> change constructor
+        # This should also be moved to single, since it's the same for all NonInteractionSingles
+        # -> change constructor
 #        pid_particle_pair = testShell.pid_particle_pair
 #        structure = testShell.structure
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 

From be0207607e84ca25c701b863cd1c8df884875606 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Dec 2011 14:46:22 +0100
Subject: [PATCH 0480/1541] added commented concept code to make a
 SphericalPair out of a testShell

---
 pair.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/pair.py b/pair.py
index 08edd740..2928d5ca 100644
--- a/pair.py
+++ b/pair.py
@@ -309,14 +309,17 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
 
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure):
+#    def __init__(self, domain_id, shell_id, testShell, rrs) # TODO constructor above does not support this yet
         Pair.__init__(self, domain_id, single1, single2, shell_id,
                       r0, rrs)
 
         self.structure = structure              # structure on which both particles live
+#        self.structure = testShell.structure
 
         self.a_R, self.a_r = self.determine_radii(r0, shell_size)
         # set the radii of the inner domains as a function of the outer protective domain
 
+# this can go
         self.shell = self.create_new_shell(shell_center, shell_size, domain_id)
 
 
@@ -447,13 +450,24 @@ def determine_radii(self, r0, shell_size):
 
 
 class SphericalPair(SimplePair):
+#class SphericalPair(SimplePair, Other, hasSphericalShell):
     """2 Particles inside a (spherical) shell not on any surface.
 
     """
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
+#    def __init__(self, domain_id, shell_id, testShell, rrs):
+#        single1 = testShell.single1
+#        single2 = testShell.single2
+#        structure = testShell.structure
+#        shell_size = testShell.radius  # TODO this should be removed
+#        r0 = testShell.get_r0()        # TODO this should be removed
+
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
+#        SimplePair.__init__(self, domain_id, shell_id, testShell, rrs) # TODO constructor above does not support this yet
+#        hasSphericalShell.__init__(self, testShell)
+
 
     def com_greens_function(self):
         # Green's function for centre of mass inside absorbing sphere.
@@ -465,9 +479,11 @@ def iv_greens_function(self, r0):
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
+# this can go
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
 
+# maybe this should be a part of hasShell
     def get_shell_direction(self):
         return random_vector(1.0)
 

From ed6c5c3220db0dc011e7152968b1c0e7bc9fde5d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Dec 2011 18:01:34 +0100
Subject: [PATCH 0481/1541] small change in comment

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 2928d5ca..a408b76d 100644
--- a/pair.py
+++ b/pair.py
@@ -483,7 +483,7 @@ def iv_greens_function(self, r0):
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
 
-# maybe this should be a part of hasShell
+# this is a part of hasShell (see testShell.get_orientation_vector())
     def get_shell_direction(self):
         return random_vector(1.0)
 

From 2290988fd2d67ad720cf55ebe2c2d1750e217118 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Dec 2011 18:02:05 +0100
Subject: [PATCH 0482/1541] lots of changes to make SphericalSingletestShells
 and SphericalPairtestShells

---
 shells.py | 159 ++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 142 insertions(+), 17 deletions(-)

diff --git a/shells.py b/shells.py
index 0b64f6c0..bc8f07de 100755
--- a/shells.py
+++ b/shells.py
@@ -3,6 +3,8 @@
 
 class Others(object):
 
+    def __init__(self):
+        pass    # do nothing
     # stuff for hasShell subclasses
     def shell_list_for_single(self):
         return self.shell_list
@@ -16,6 +18,8 @@ def get_neighbor_shell_list(self, neighbor):
 
 class NonInteractionSingles(object):
 
+    def __init__(self):
+        pass    # do nothing
     # stuff for hasShell subclasses
     def shell_list_for_single(self):
         pass    # needs to be overloaded
@@ -27,6 +31,76 @@ def get_neighbor_shell_list(self, neighbor):
         # note that this returns the list of shells, NOT dr, dz_right, dz_left
         return neighbor.shell_list_for_single()
 
+##################################
+
+class testSingle(object):
+    def __init__(self, pid_particle_pair, structure):
+        self.pid_particle_pair = pid_particle_pair
+        self.structure = structure
+
+class testNonInteractionSingle(testSingle, NonInteractionSingles):
+    def __init__(self, pid_particle_pair, structure):
+        testSingle.__init__(self, pid_particle_pair, structure)
+
+class testInteractionSingle(testSingle, Others):
+    def __init__(self, single, structure, surface):
+        testSingle.__init__(self, single.pid_particle_pair, structure)
+        self.surface = surface
+
+##############
+class testPair(Others):
+    def __init__(self, single1, single2, structure):
+
+        assert single1.structure == single2.structure
+        self.single1 = single1
+        self.single2 = single2
+        self.pid_particle_pair1 = single1.pid_particle_pair
+        self.pid_particle_pair2 = single2.pid_particle_pair
+        self.structure = structure
+        self.com, self.iv = self.do_transform()
+        self.r0 = length(self.iv)
+
+    def do_transform(self):
+        pass        # overloaded later
+
+class testSimplePair(Pair):
+    def __init__(self, single1, single2, structure):
+        testPair.__init__(self, single1, single2, structure)
+
+    def get_D_tot(self):
+        return self.pid_particle_pair1[1].D + \
+               self.pid_particle_pair2[1].D
+    D_tot = property(get_D_tot)
+    D_r   = property(get_D_tot)
+
+    def get_D_R(self):
+        return (self.pid_particle_pair1[1].D *
+                self.pid_particle_pair2[1].D) / self.D_tot
+    D_R = property(get_D_R)
+
+    def get_sigma(self):
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        return radius1 + radius2
+    sigma = property(get_sigma)
+
+    def do_transform(self):
+    # TODO replace with get_com, get_iv methods/properties
+        pos1 = self.pid_particle_pair1[1].position
+        pos2 = self.pid_particle_pair2[1].position
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
+
+        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = self.world.apply_boundary(com)
+        # make sure that the com is in the structure of the particle (assume that this is done correctly in
+        # calculate_pair_CoM)
+
+        pos2t = self.world.cyclic_transpose(pos2, pos1)
+        iv = pos2t - pos1
+
+        return com, iv
+
 ##################################
 class hasShell(object):
 
@@ -424,32 +498,46 @@ class MixedPair3D2D(hasCylindricalShell, Others):
 #######################################################
 class testShell(object):
 
-    def __init__(self):
-        self.shell = None
+    def __init__(self, geometrycontainer, domains):
+        self.geometrycontainer = geometerycontainer
+        self.world = geometrycontainer.world
+        self.domains = domains
 
-    def get_neighbors(self):
+    def get_neighbors(self, ignore, ignores):
         searchpoint = self.get_searchpoint()
         radius = self.get_searchradius()
-        return self.geometrycontainer.get_neigbors(searchpoint, radius)
+
+        neighbor_domains  = self.geometrycontainer.get_neighbor_domains(searchpoint, self.domains, ignore)
+        neighbor_surfaces = self.geometrycontainer.get_neighbor_surfaces(searchpoint, ignores)
+        return 
+
+    def get_orientation_vector(self):
+        pass    # overloaded later
 
 ########################
 class SphericaltestShell(testShell):
 
-    def __init__(self):
+    def __init__(self, geometrycontainer, domains):
+        testShell.__init__(self, geometrycontainer, domains)
+
+        self.center = None          # there are the parameters that we ultimately want to know
         self.radius = 0
-        self.center = None
 
-    def determine_possible_shell(self):
-        neighbors = self.get_neighbors()
+    def determine_possible_shell(self, ignore, ignores):
+        neighbors = self.get_neighbors (ignore, ignores)
         min_radius = self.get_min_radius()
         max_radius = self.get_max_radius()
 
         radius = max_radius
+        # first check the surfaces
+
+
+        # then check the domains
         for neighbor in neighbors:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                new_radius = neighbor.shell_object.get_radius_to_shell(shell_appearance, self)
+                new_radius = neighbor.get_radius_to_shell(shell_appearance, self)
                 # if the newly calculated dimensions are smaller than the current one, use them
                 radius = min(radius, new_radius)
 
@@ -467,25 +555,62 @@ def get_searchpoint(self):
         return self.center
     def get_searchradius(self):
         return self.geometrycontainer.max()
+    def get_orientation_vector(self):
+        return random_vector(1.0)
 
     def get_max_radius(self):
-        return shell_container.get_max_shell_size()
+        return self.geometrycontainer.get_max_shell_size()
 
 #####
-class SphericalSingletestShell(testSphericalShell, NonInteractionSingles):
+class SphericalSingletestShell(SphericaltestShell, testNonInteractionSingle):
 
-    self.center = particle_position
+    def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
+        SphericaltestShell.__init__(self, geometrycontainer, domains)
+        testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
+
+        self.center = self.pid_particle_pair[1].position
+        self.radius = self.determine_possible_shell([], [structure.id])
 
     def get_min_radius(self):
-        return particle_radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
+        return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
 
 #####
-class SphericalPairtestShell(testSphericalShell, Others):
+class SphericalPairtestShell(SphericaltestShell, testSimplePair):
+
+    def __init__(self, single1, single2, structure, geomterycontainer, domains):
+        SphericaltestShell.__init__(self, geometrycontainer, domains)
+        testSimplePair.__init__(self, single1, single2, structure)  # this should be second because of world definition
+
+        self.center = self.com
+        self.radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
+                                                    [structure.id])
+
+    def get_min_radius(self):
+        # TODO this doesn't really belong in testSimplePair, but is also general for all SimplePairs
+
+        # Is this assert here ok?
+        assert self.r0 >= self.sigma, \
+            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
+            (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma))
+
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+
+        dist_from_com1 = self.r0 * D1 / self.D_tot      # particle distance from CoM
+        dist_from_com2 = self.r0 * D2 / self.D_tot
+        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
+        iv_shell_size2 = dist_from_com2 + radius2
+
+        # also fix the minimum shellsize for the CoM domain
+        com_shell_size = max(radius1, radius2)
 
-    self.center = calculate CoM
+        # calculate total radii including the margin for the burst volume for the particles
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - SINGLE_SHELL_FACTOR),
+                         iv_shell_size2 + com_shell_size + radius2 * (1 - SINGLE_SHELL_FACTOR))
 
-    def get_min_radius:
-        return calculate_min_radius_see_sphericalpair
+        return shell_size
 
 
 ##########################

From 855733132d6d6186efe0156f25646ebecbb4e6bb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 12:07:58 +0100
Subject: [PATCH 0483/1541] finished algorithm to determine largest shell
 radius for SphericaltestShells

---
 shells.py | 26 +++++++++++++++-----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/shells.py b/shells.py
index bc8f07de..8ad71308 100755
--- a/shells.py
+++ b/shells.py
@@ -509,7 +509,7 @@ def get_neighbors(self, ignore, ignores):
 
         neighbor_domains  = self.geometrycontainer.get_neighbor_domains(searchpoint, self.domains, ignore)
         neighbor_surfaces = self.geometrycontainer.get_neighbor_surfaces(searchpoint, ignores)
-        return 
+        return neighbor_domains, neighbor_surfaces
 
     def get_orientation_vector(self):
         pass    # overloaded later
@@ -524,16 +524,22 @@ def __init__(self, geometrycontainer, domains):
         self.radius = 0
 
     def determine_possible_shell(self, ignore, ignores):
-        neighbors = self.get_neighbors (ignore, ignores)
+        neighbor_domains, neighbor_surfaces = self.get_neighbors (ignore, ignores)
         min_radius = self.get_min_radius()
         max_radius = self.get_max_radius()
 
         radius = max_radius
         # first check the surfaces
-
+        for surface, distance in neighbor_surfaces:
+            # FIXME ugly hack to make spherical singles overlap with membranes
+            if isinstance(surface, PlanarSurface) and isinstance(self, SphericalSingletestShell):
+                distance += self.pid_particle_pair[1].radius
+            radius = min(radius, distance)
+            if radius < min_radius:
+                return None
 
         # then check the domains
-        for neighbor in neighbors:
+        for neighbor, _ in neighbor_domains:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
@@ -542,14 +548,12 @@ def determine_possible_shell(self, ignore, ignores):
                 radius = min(radius, new_radius)
 
                 if radius < min_radius:
-                    radius = None
-                    break
+                    return None
 
-        if radius:
-            self.radius = radius
-            return radius
-        else
-            return None
+        # we calculated a valid radius -> suscess!
+        assert radius >= min_radius, 'SphericaltestShell radius smaller than the minimum, radius = %s, min_radius = %s.' % \
+                                     (radius, min_radius)
+        return radius
 
     def get_searchpoint(self):
         return self.center

From ae3140af31cf33ca9cd297d541edff3c809728e9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 13:35:19 +0100
Subject: [PATCH 0484/1541] changed initialisation of SphericalSingle and
 SphericalPair testShells

---
 shells.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index 8ad71308..3abfd458 100755
--- a/shells.py
+++ b/shells.py
@@ -573,7 +573,11 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
         self.center = self.pid_particle_pair[1].position
-        self.radius = self.determine_possible_shell([], [structure.id])
+        self.radius = self.pid_particle_pair[1].radius
+
+    def update_radius(self):
+        self.radius = self.determine_possible_shell([], [self.structure.id])
+        return self.radius
 
     def get_min_radius(self):
         return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
@@ -586,8 +590,12 @@ def __init__(self, single1, single2, structure, geomterycontainer, domains):
         testSimplePair.__init__(self, single1, single2, structure)  # this should be second because of world definition
 
         self.center = self.com
-        self.radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
-                                                    [structure.id])
+        radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
+                                               [structure.id])
+        if radius == None:
+            raise Exception("SphericalPairtestShell_exception")
+        else:
+            self.radius = radius
 
     def get_min_radius(self):
         # TODO this doesn't really belong in testSimplePair, but is also general for all SimplePairs

From 05340bbbbd7759cddd68a19c9d4de95b5b1ceb60 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 13:41:45 +0100
Subject: [PATCH 0485/1541] fixed small errors and typos

---
 shells.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/shells.py b/shells.py
index 3abfd458..e18eb8f8 100755
--- a/shells.py
+++ b/shells.py
@@ -63,7 +63,7 @@ def __init__(self, single1, single2, structure):
     def do_transform(self):
         pass        # overloaded later
 
-class testSimplePair(Pair):
+class testSimplePair(testPair):
     def __init__(self, single1, single2, structure):
         testPair.__init__(self, single1, single2, structure)
 
@@ -411,7 +411,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
             r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
         else:
             # shell hits the scaling cylinder on the radial side
-            r_new = min(r, (ref_to_shell_r) - shell_radius)/SAFETY)
+            r_new = min(r, (ref_to_shell_r - shell_radius)/SAFETY)
             z1_new = min(z1, z1_function(single1, single2, r0, r_new))
         z2_new = min(z2, z2_function(single1, single2, r0, r_new))
 
@@ -487,10 +487,15 @@ def shell_list_for_other(self):
 
 #####
 class PlanarSurfacePair(hasCylindricalShell, Others):
+    pass
 class PlanarSurfaceInteraction(hasCylindricalShell, Others):
+    pass
 class CylindricalSurfacePair(hasCylindricalShell, Others):
+    pass
 class CylindricalSurfaceInteraction(hasCylindricalShell, Others):
+    pass
 class MixedPair3D2D(hasCylindricalShell, Others):
+    pass
 #class MixedPair3D1D(hasCylindricalShell):
 
 
@@ -653,7 +658,7 @@ def determine_possible_shell(self):
 
         if dr_dzright_dzleft:
             return dr_dz_right_dzleft
-        else
+        else:
             return None
 
     # default functions for evaluating z_right/z_left/r after one of parameters changed
@@ -746,7 +751,7 @@ def get_referencepoint(self):
         return CoM
 
     def get_min_dr_dzright_dzleft(self):
-        do calculation
+        dr, dz_right, dz_left = do_calculation
         return (dr, dz_right, dz_left)
 
     def get_max_dr_dzright_dzleft(self):
@@ -888,11 +893,11 @@ def __init__(self):
         self.dzdr_right = 1.0
         self.drdz_right = 1.0
         self.r0_right   = 0.0
-        self.z0_right   = calculate_it
+        self.z0_right   = 0.0 # calculate_it
         self.dzdr_left  = 1.0
         self.drdz_left  = 1.0
         self.r0_left    = 0.0
-        self.z0_left    = calculate_it (same as above)
+        self.z0_left    = 0.0 # calculate_it (same as above)
 
     def get_orientation_vector(self):
         return structure.shape.unit_z

From f10a9a0fcae84cd1e4fafc0af35e741920c67779 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 14:00:42 +0100
Subject: [PATCH 0486/1541] typo

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index e18eb8f8..751f2828 100755
--- a/shells.py
+++ b/shells.py
@@ -504,7 +504,7 @@ class MixedPair3D2D(hasCylindricalShell, Others):
 class testShell(object):
 
     def __init__(self, geometrycontainer, domains):
-        self.geometrycontainer = geometerycontainer
+        self.geometrycontainer = geometrycontainer
         self.world = geometrycontainer.world
         self.domains = domains
 

From 0df795b4d547cdd32c627bf743834b4aa442b774 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 14:01:07 +0100
Subject: [PATCH 0487/1541] added name references to the new SphericaltestShell
 in egfrd.py

---
 egfrd.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 09e2787f..b8d8ed91 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -33,6 +33,14 @@
 from utils import *
 from constants import *
 from shellcontainer import ShellContainer
+from shells import (
+    hasSphericalShell,
+    hasCylindricalShell,
+    NonInteractionSingles,
+    Others,
+    SphericalSingletestShell,
+    SphericalPairtestShell
+    )
 
 import logging
 import os
@@ -43,8 +51,10 @@
     PRECISION = 7
     FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
 
-def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure):
+def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure, geometrycontainer, domains):
     if isinstance(structure, CuboidalRegion):
+        # first make the test shell
+        testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return SphericalSingle(domain_id, pid_particle_pair,
                                shell_id, rt, structure)
     elif isinstance(structure, CylindricalSurface):
@@ -362,6 +372,7 @@ def step(self):
 
 
     def create_single(self, pid_particle_pair):
+
         # 1. generate identifiers for the domain and shell. The event_id is
         # generated by the scheduler
         domain_id = self.domain_id_generator()
@@ -378,7 +389,8 @@ def create_single(self, pid_particle_pair):
         # in/on. Either SphericalSingle, PlanarSurfaceSingle, or 
         # CylindricalSurfaceSingle.
         single = create_default_single(domain_id, pid_particle_pair, 
-                                       shell_id, rrs, structure)
+                                       shell_id, rrs, structure,
+                                       self.geometrycontainer, self.domains)
 
         assert isinstance(single, NonInteractionSingle)
         single.initialize(self.t)               # set the initial event and event time

From a64dd143060e0bc5a6c3682e1ec5f618c97a6833 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 15:14:44 +0100
Subject: [PATCH 0488/1541] overriding the create_new_shell method seems to
 produce an error

---
 domain.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/domain.py b/domain.py
index f102085d..78a3b0b6 100644
--- a/domain.py
+++ b/domain.py
@@ -59,8 +59,8 @@ def draw_reaction_rule(self, reactionrules):
 
         return reactionrules[i]
 
-    def create_new_shell(self):         # needs to be overloaded in subclasses
-        pass                            # creates an appropriate shell object
+#    def create_new_shell(self):         # needs to be overloaded in subclasses
+#        pass                            # creates an appropriate shell object
 
 
 class ProtectiveDomain(Domain):

From 70efd252bfd55340cb5eb9e44b258e82746473a0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 15:17:09 +0100
Subject: [PATCH 0489/1541] adding name references and commenting out old
 (prototype) code

---
 shells.py | 57 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 34 insertions(+), 23 deletions(-)

diff --git a/shells.py b/shells.py
index 751f2828..c0ee1ff9 100755
--- a/shells.py
+++ b/shells.py
@@ -1,5 +1,13 @@
 #!/usr/bin/python
 
+from _gfrd import (
+    Sphere,
+    SphericalShell,
+    Cylinder,
+    CylindricalShell,
+    )
+
+import utils
 
 class Others(object):
 
@@ -286,26 +294,29 @@ def get_radius_to_shell(self, shell, domain_to_scale):
         return r
 
 #####
-class SphericalSingle(hasSphericalShell, NonInteractionSingles):
-
-    # these return potentially corrected dimensions
-    def shell_list_for_single(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
-        if  self.shell.shape.radius < min_radius:
-            position = self.shape.shell.position
-            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
-
-    def shell_list_for_other(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
-        if self.shell.shape.radius < min_radius:
-            position = self.shape.shell.position
-            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
+#class SphericalSingle(hasSphericalShell, NonInteractionSingles):
+#
+#    def update_radius(self):
+#        return self.testShell.determine_possible_shell([], [self.structure.id])
+#
+#    # these return potentially corrected dimensions
+#    def shell_list_for_single(self):
+#        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+#        if  self.shell.shape.radius < min_radius:
+#            position = self.shape.shell.position
+#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
+#            return [(self.shell_id, fake_shell), ]
+#        else:
+#            return self.shell_list
+#
+#    def shell_list_for_other(self):
+#        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+#        if self.shell.shape.radius < min_radius:
+#            position = self.shape.shell.position
+#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
+#            return [(self.shell_id, fake_shell), ]
+#        else:
+#            return self.shell_list
 
 #####
 class SphericalPair(hasSphericalShell, Others):
@@ -580,9 +591,9 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.center = self.pid_particle_pair[1].position
         self.radius = self.pid_particle_pair[1].radius
 
-    def update_radius(self):
-        self.radius = self.determine_possible_shell([], [self.structure.id])
-        return self.radius
+#    def update_radius(self):
+#        self.radius = self.determine_possible_shell([], [self.structure.id])
+#        return self.radius
 
     def get_min_radius(self):
         return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle

From 79cfffd0dd757e2bc974c8c76ba38903e51bebe3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 18:35:10 +0100
Subject: [PATCH 0490/1541] fixed typos and incorrections. Also added
 MULTI/SINGLE_SHELL_FACTOR to testShells. very ugly -> FIX

---
 shells.py | 27 +++++++++++++++++++--------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/shells.py b/shells.py
index c0ee1ff9..d5cebb7f 100755
--- a/shells.py
+++ b/shells.py
@@ -1,5 +1,7 @@
 #!/usr/bin/python
 
+import math
+
 from _gfrd import (
     Sphere,
     SphericalShell,
@@ -46,6 +48,10 @@ def __init__(self, pid_particle_pair, structure):
         self.pid_particle_pair = pid_particle_pair
         self.structure = structure
 
+        # FIXME FIXME This is defined multiple times!!!
+        self.MULTI_SHELL_FACTOR = math.sqrt(2)
+        self.SINGLE_SHELL_FACTOR = 2.0
+
 class testNonInteractionSingle(testSingle, NonInteractionSingles):
     def __init__(self, pid_particle_pair, structure):
         testSingle.__init__(self, pid_particle_pair, structure)
@@ -68,6 +74,10 @@ def __init__(self, single1, single2, structure):
         self.com, self.iv = self.do_transform()
         self.r0 = length(self.iv)
 
+        # FIXME FIXME This is defined multiple times!!!
+        self.MULTI_SHELL_FACTOR = math.sqrt(2)
+        self.SINGLE_SHELL_FACTOR = 2.0
+
     def do_transform(self):
         pass        # overloaded later
 
@@ -142,7 +152,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
         # CylindricaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
 
-        assert type(shell, Sphere)        # because the shell actually is part of the current object
+        assert (type(shell.shape) is Sphere)        # because the shell actually is part of the current object
 
         # Do Laurens' algorithm (part1)
         shell_position = shell.shape.position
@@ -286,7 +296,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
     def get_radius_to_shell(self, shell, domain_to_scale):
         # SphericaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
 
-        assert type(shell, Sphere)        # because the shell actually originated here
+        assert (type(shell.shape) is Sphere)        # because the shell actually originated here
         # Do simple distance calculation to sphere
 
         scale_point = domain_to_scale.center
@@ -359,7 +369,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         if __debug__:
             log.debug('cylinder')
 
-        assert type(shell, Cylinder)        # because the shell actually originated here
+        assert (type(shell.shape) is Cylinder)        # because the shell actually originated here
         # Do Laurens' algorithm (part2)
 
         shell_position = shell.shape.position
@@ -441,7 +451,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
     def get_radius_to_shell(self, shell, domain_to_scale):
         # SphericaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
 
-        assert type(shell, Cylinder)        # because the shell actually originated here
+        assert (type(shell.shape) is Cylinder)        # because the shell actually originated here
         # Do simple distance calculation to cylinder
 
         scale_point = domain_to_scale.center
@@ -569,12 +579,13 @@ def determine_possible_shell(self, ignore, ignores):
         # we calculated a valid radius -> suscess!
         assert radius >= min_radius, 'SphericaltestShell radius smaller than the minimum, radius = %s, min_radius = %s.' % \
                                      (radius, min_radius)
+
         return radius
 
     def get_searchpoint(self):
         return self.center
     def get_searchradius(self):
-        return self.geometrycontainer.max()
+        return self.geometrycontainer.get_max_shell_size()
     def get_orientation_vector(self):
         return random_vector(1.0)
 
@@ -596,7 +607,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
 #        return self.radius
 
     def get_min_radius(self):
-        return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
+        return self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
 
 #####
 class SphericalPairtestShell(SphericaltestShell, testSimplePair):
@@ -635,8 +646,8 @@ def get_min_radius(self):
         com_shell_size = max(radius1, radius2)
 
         # calculate total radii including the margin for the burst volume for the particles
-        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - SINGLE_SHELL_FACTOR),
-                         iv_shell_size2 + com_shell_size + radius2 * (1 - SINGLE_SHELL_FACTOR))
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - self.SINGLE_SHELL_FACTOR),
+                         iv_shell_size2 + com_shell_size + radius2 * (1 - self.SINGLE_SHELL_FACTOR))
 
         return shell_size
 

From 57293004f2ee8fce8e754eb697d9c1a53d97f8b5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Dec 2011 18:38:43 +0100
Subject: [PATCH 0491/1541] fixed SphericalSingle such that it uses a
 testSphericalSingle for creation Also now uses shell sizing code in shells.py

---
 egfrd.py  | 21 ++++++++++----------
 single.py | 59 ++++++++++++++++++++++++++++++++++++-------------------
 2 files changed, 50 insertions(+), 30 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b8d8ed91..c24232a8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -34,10 +34,6 @@
 from constants import *
 from shellcontainer import ShellContainer
 from shells import (
-    hasSphericalShell,
-    hasCylindricalShell,
-    NonInteractionSingles,
-    Others,
     SphericalSingletestShell,
     SphericalPairtestShell
     )
@@ -55,8 +51,7 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure,
     if isinstance(structure, CuboidalRegion):
         # first make the test shell
         testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
-        return SphericalSingle(domain_id, pid_particle_pair,
-                               shell_id, rt, structure)
+        return SphericalSingle(domain_id, shell_id, testSingle, rt)
     elif isinstance(structure, CylindricalSurface):
         return CylindricalSurfaceSingle(domain_id, pid_particle_pair, 
                                         shell_id, rt, structure)
@@ -1406,11 +1401,17 @@ def calculate_mixedpair_shell_dimensions (self, single2D, single3D):
     def update_single(self, single): 
         assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
-        min_shell_size = single.get_min_shell_size()
-        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
+#        min_shell_size = single.get_min_shell_size()
+#        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
+#
+#        # Make sure that the new shell size is not too small or big
+#        new_shell_size = max(max_shell_size, min_shell_size)
+
+        new_shell_size = single.update_radius()
 
-        # Make sure that the new shell size is not too small or big
-        new_shell_size = max(max_shell_size, min_shell_size)
+        if __debug__:
+            log.info('update_single: single: %s, new_shell_size = %s' % \
+                     (single, FORMAT_DOUBLE % new_shell_size))
 
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.
diff --git a/single.py b/single.py
index 10b11ebe..7d0c9e8a 100644
--- a/single.py
+++ b/single.py
@@ -1,4 +1,11 @@
-from _gfrd import *
+from _gfrd import (
+    SphericalShell,
+    CylindricalShell,
+    Cylinder,
+    Sphere,
+    CylindricalSurface,
+    PlanarSurface,
+    )
 from _greens_functions import *
 from greens_function_wrapper import *
 from constants import EventType
@@ -8,6 +15,13 @@
     Domain,
     ProtectiveDomain)
 
+from shells import (
+    hasSphericalShell,
+    hasCylindricalShell,
+    NonInteractionSingles,
+    Others,
+    )
+
 __all__ = [
     'CylindricalSurfaceSingle',
     'PlanarSurfaceSingle',
@@ -148,14 +162,14 @@ def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules,
 
         # Create shell.
         self.shell_id = shell_id
-        self.shell = self.create_new_shell(pid_particle_pair[1].position,
-                                      pid_particle_pair[1].radius, domain_id)
+#        self.shell = self.create_new_shell(pid_particle_pair[1].position,
+#                                      pid_particle_pair[1].radius, domain_id)
 
-    def get_shell_size(self):
-        # Note: this method only means something for Protective Domains that can
-        # only be sized in one direction
-        # This is predominantly used when making Interaction domains
-        return self.shell.shape.radius
+#    def get_shell_size(self):
+#        # Note: this method only means something for Protective Domains that can
+#        # only be sized in one direction
+#        # This is predominantly used when making Interaction domains
+#        return self.shell.shape.radius
 
 
     def initialize(self, t):
@@ -219,6 +233,7 @@ def draw_new_position(self, dt, event_type):
 
         return newpos
 
+### TODO move this in some way to the shell making stuff in shells.py
     def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycontainer):
         # only if the closest shell is also a 'simple' Single
         assert isinstance(closest, NonInteractionSingle)
@@ -247,6 +262,8 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
 
         return shell_size
 
+
+### this can probably both go
     def get_min_shell_size(self):
         return self.pid_particle_pair[1].radius
 
@@ -301,8 +318,8 @@ def get_max_shell_size(self, geometrycontainer, domains):
         return min(new_shell_size, geometrycontainer.get_max_shell_size())
 
 
-class SphericalSingle(NonInteractionSingle):
-#class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalShell):
+#class SphericalSingle(NonInteractionSingle):
+class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalShell):
     """1 Particle inside a (spherical) shell not on any surface.
 
         * Particle coordinate inside shell: r, theta, phi.
@@ -312,24 +329,24 @@ class SphericalSingle(NonInteractionSingle):
           theta, phi.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-                 structure):
-#    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
+#                 structure):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
         # This should also be moved to single, since it's the same for all NonInteractionSingles
         # -> change constructor
-#        pid_particle_pair = testShell.pid_particle_pair
-#        structure = testShell.structure
+        pid_particle_pair = testShell.pid_particle_pair
+        structure = testShell.structure
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
                                       shell_id, reactionrules, structure)
-#        hasSphericalShell.__init__(self, testShell)
+        hasSphericalShell.__init__(self, testShell)                         # here also the shell is created
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
                                           self.get_inner_a())
 
 # this can go
-    def create_new_shell(self, position, radius, domain_id):
-        return SphericalShell(self.domain_id, Sphere(position, radius))
+#    def create_new_shell(self, position, radius, domain_id):
+#        return SphericalShell(self.domain_id, Sphere(position, radius))
 
 # instead we have this
     # specific shell methods for the SphericalSingle
@@ -337,7 +354,7 @@ def create_new_shell(self, position, radius, domain_id):
     def shell_list_for_single(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
         if  self.shell.shape.radius < min_radius:
-            position = self.shape.shell.position
+            position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
@@ -346,12 +363,14 @@ def shell_list_for_single(self):
     def shell_list_for_other(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
-            position = self.shape.shell.position
+            position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
+    def update_radius(self):
+        return self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
 
     def create_position_vector(self, r):
         return random_vector(r)

From 4500ef059d35585492bd91cee6131430d1ad36de Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 22 Dec 2011 10:02:45 +0100
Subject: [PATCH 0492/1541] Changed code such that it works

---
 GreensFunction1DAbsSinkAbs.cpp | 13 +++--
 egfrd.py                       | 96 +++++++++++++++++++++++++++++++---
 shellcontainer.py              |  5 +-
 single.py                      | 28 ++++++----
 4 files changed, 117 insertions(+), 25 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 472b63f9..7062e4e7 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -52,11 +52,6 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
 
     real_pair lower_upper_pair;
 
-    lo_up_params.h = h;
-    lo_up_params.Lm_L = Lm_L;
-    lo_up_params.long_period = std::max( L/Lr * M_PI, L/Ll * M_PI );
-    lo_up_params.short_period = std::min( L/Lr * M_PI, L/Ll * M_PI );
-
     /* Define the root function. */
     gsl_function F;
     struct root_f_params params = { Lm_L, h };
@@ -73,6 +68,10 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
     /* Stores the last root with long or short period. */
     if(i == 0)
     {
+        lo_up_params.h = h;
+        lo_up_params.Lm_L = Lm_L;
+        lo_up_params.long_period = std::max( L/Lr * M_PI, L/Ll * M_PI );
+        lo_up_params.short_period = std::min( L/Lr * M_PI, L/Ll * M_PI );
         lo_up_params.last_long_root = 0.0;
         lo_up_params.last_short_root = 0.0;
     }
@@ -162,8 +161,8 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     /* f_lower must have correct sign. */
     if( f_lower * parity_op > 0 )
     {
-        log_.warn("Parity error in x_lower of root# %6u .",
-                  rootList_size() + 1);
+        log_.warn("Parity error in x_lower of root# %6u, for h = %.5g, Lm/L = %.5g.",
+                  rootList_size() + 1, lo_up_params.h, lo_up_params.Lm_L );
 
         log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
                   lower, f_lower, upper, f_upper);
diff --git a/egfrd.py b/egfrd.py
index ce6615dd..3941f617 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -146,6 +146,21 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         self.reset()                            # The Simulator is only initialized at the first step, allowing
                                                 # modifications to the world to be made before simulation starts
+                                                
+        self.sinklist = []                      # Hack to keep track of sinks in the system. Contains structure_id's of the sinks
+
+    def add_to_sinklist(self, sink_id):
+        self.sinklist.append(sink_id)
+        
+    def get_neighbor_sinks(self, position, structure_id):
+        sink_distance_list = []
+        sinklist = self.sinklist
+        
+        for i in range( len( sinklist ) ):
+            sink_i = self.world.get_structure( sinklist[i] )        
+            sink_distance_list.append((sink_i, self.world.distance( position, sink_i.shape.position )))
+        
+        return sink_distance_list
 
     def get_next_time(self):
         """ 
@@ -417,8 +432,16 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
 
         particle_pos = pid_particle_pair[1].position
-
-        if isinstance(surface, CylindricalSurface):
+        if isinstance(surface, CylindricalSurface) and isinstance(structure, CylindricalSurface):
+            particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)     
+            zsink = numpy.dot( surface.shape.position - particle_pos, surface.shape.unit_z )
+
+            interaction = CylindricalSurfaceSink(domain_id, pid_particle_pair,
+                                                 reaction_rules, structure,
+                                                 shell_id, shell_center, shell_half_length, 
+                                                 zsink, interaction_rules, surface)
+                                                 
+        elif isinstance(surface, CylindricalSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
             projected_point, r0 = surface.projected_point(particle_pos)
             shell_unit_r = normalize(particle_pos - projected_point)
@@ -430,6 +453,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
                                                         shell_id, shell_center, shell_radius,
                                                         shell_half_length, shell_unit_z, z0,
                                                         shell_unit_r, r0, interaction_rules, surface)
+                                                        
         elif isinstance(surface, PlanarSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
             z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
@@ -440,7 +464,6 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
                                                    shell_half_length, shell_unit_z,
                                                    z0, interaction_rules, surface)
 
-
         assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
         self.domains[domain_id] = interaction
@@ -1138,9 +1161,14 @@ def make_new_domain(self, single):
         # 1.0 Get neighboring domains and surfaces
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
+        # Here ignore the sink surfaces. Should be moved into get_neighbor_surfaces.
         surface_distances = []
         if isinstance(single, SphericalSingle):
-            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
+            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, self.sinklist )
+            
+        # For a particle on a rod (1D) only consider sinks. - one rod, with one sink for now.
+        if isinstance(single, CylindricalSurfaceSingle):
+            surface_distances = self.get_neighbor_sinks( single_pos, single.structure.id )
 
         # Check if there are shells with the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
@@ -1199,8 +1227,12 @@ def make_new_domain(self, single):
                 # there are no more potential partners (everything is out of range)
                 # or a domain was formed successfully previously
                 break
+                            
+            if isinstance(obj, CylindricalSurface) and isinstance(single, CylindricalSurfaceSingle):
+                # try making a Interaction with a sink. (Not in try_interaction because to different/ to much hacking)
+                domain = self.try_interaction_sink(single, obj)
 
-            if isinstance(obj, NonInteractionSingle):
+            elif isinstance(obj, NonInteractionSingle):
                 # try making a Pair (can be Mixed Pair or Normal Pair)
                 domain = self.try_pair (single, obj)
 
@@ -1383,7 +1415,7 @@ def update_single(self, single):
         assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
         min_shell_size = single.get_min_shell_size()
-        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
+        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, sinklist=[])
 
         # Make sure that the new shell size is not too small or big
         new_shell_size = max(max_shell_size, min_shell_size)
@@ -1865,7 +1897,58 @@ def try_interaction(self, single, surface):
 
         return interaction
 
+    def try_interaction_sink(self, single, sink):
+        # Try to form an interaction between the 'single' particle and a sink (Cyl-surface).
+
+        pid_particle_pair = single.pid_particle_pair
+        particle = pid_particle_pair[1]
+        structure = single.structure
+        
+        if __debug__:
+            log.debug('trying to form Interaction with sink(%s, %s)' % (particle, sink))
+
+
+        ### 1. See if there is enough space for the shell
+        # Uses the same methods as Update_single for finding optimal domain size.
+        min_shell_size = single.get_min_shell_size()
+        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, self.sinklist)
+
+        # Make sure that the new shell size is not too small or big
+        new_shell_size = max(max_shell_size, min_shell_size)
+        
+        # Check if c.o.m. of particle can reach the sink, so that it is not blocked by
+        # it's radius hitting the boundary.
+        dist_to_sink = self.world.distance( sink.shape.position, particle.position )
+        if( new_shell_size - particle.radius - dist_to_sink < 0.0 ):
+            return None
+       
+       
+        ### 2. The shell can be made. Now do what's necessary to make it
+        # Compute origin, radius and half_length of cylinder.
+        orientation_vector = structure.shape.unit_z
+        radius = particle.radius
+        origin = particle.position
+        half_length = new_shell_size
+        
+        interaction = self.create_interaction(pid_particle_pair, sink,
+                                              origin, radius, half_length,
+                                              orientation_vector)
+
+        interaction.dt, interaction.event_type, = \
+            interaction.determine_next_event()
+        assert interaction.dt >= 0
+
+        self.last_time = self.t
+
+        self.remove_domain(single)
+        # the event associated with the single will be removed by the scheduler.
 
+        assert self.check_domain(interaction)
+        self.add_domain_event(interaction)
+
+        return interaction
+        
+        
     def calculate_max_cylinder(self, single, surface, projected_point, 
                                    particle_distance, orientation_vector,
                                    dr, dz_left, dz_right):
@@ -2355,6 +2438,7 @@ def check_domain(self, domain):
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair):
             # Ignore surface of the particle and interaction surface
             ignores = [domain.structure.id, domain.surface.id]
+            ignores.extend( self.sinklist )
         else:
             ignores = [domain.structure.id]
 
diff --git a/shellcontainer.py b/shellcontainer.py
index 80d8b3c1..1b97cc75 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -177,10 +177,11 @@ def get_neighbor_surfaces(self, position, base_structure_id, ignores=[]):
         # living on the base_structure can have interactions with.
         
         # We assume a particle can't have an interaction with the same surface on/in which it lives.
-        ignores.append( base_structure_id )
+        base_ignores =  [base_structure_id, ]
+        base_ignores.extend( ignores )
 
         # TODO return a list of neighboring surfaces
-        surface, distance = get_closest_surface(self.world, position, ignores)
+        surface, distance = get_closest_surface(self.world, position, base_ignores)
         if surface:
             return [(surface, distance), ]
         else:
diff --git a/single.py b/single.py
index c01f2b5d..1c9c6326 100644
--- a/single.py
+++ b/single.py
@@ -17,6 +17,7 @@
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'PlanarSurfaceInteraction',
+    'CylindricalSurfaceSink',
     ]
 
 
@@ -248,7 +249,7 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
     def get_min_shell_size(self):
         return self.pid_particle_pair[1].radius
 
-    def get_max_shell_size(self, geometrycontainer, domains):
+    def get_max_shell_size(self, geometrycontainer, domains, sinklist):
         # This calculates the maximum shell size that the single can have in the current
         # situation.
         # TODO This is now general for all NonInteractionSingles and should be different
@@ -265,7 +266,7 @@ def get_max_shell_size(self, geometrycontainer, domains):
 #                                              ignores=[self.structure.id])
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(singlepos, domains, ignore=[self.domain_id, ])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, self.structure.id, ignores=[])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, self.structure.id, sinklist)
         neighbors = neighbor_domains + neighbor_surfaces
 
         # 2. Calculate the maximum allowed radius of the spherical domain
@@ -285,7 +286,7 @@ def get_max_shell_size(self, geometrycontainer, domains):
             distance_domain_closest = min(distance_domain_closest, distance_domain)
 
         distance_to_shell, closest = distance_domain_closest
-
+        
         # 3. Apply still other rules if the nearest is another NonInteractionSingle (optimization)
         # TODO shell size has no real meaning for cylinderical domains
         if isinstance(closest, NonInteractionSingle):
@@ -294,7 +295,9 @@ def get_max_shell_size(self, geometrycontainer, domains):
         else:  # Pair or Multi or Surface
             new_shell_size = distance_to_shell / SAFETY
 
-        return min(new_shell_size, geometrycontainer.get_max_shell_size())
+        max_size = numpy.sqrt( geometrycontainer.get_max_shell_size()**2 - self.shell.shape.radius**2 )
+
+        return min(new_shell_size, max_size )
 
 
 class SphericalSingle(NonInteractionSingle):
@@ -780,7 +783,10 @@ def get_inner_a(self):
     def iv_greens_function(self):
         # The Green's function used for both ESCAPE and IV (sink) events.
         # Particle allways starts in the middle for now.
-        half_inner_length = self.get_innet_a()
+        inner_half_length = self.get_inner_a()
+        
+        print "Sink GF'n params: h = %s, zsink = %s" %(inner_half_length, self.zsink)
+
         return GreensFunction1DAbsSinkAbs(self.D, self.interaction_ktot, 0.0, self.zsink, 
                                           -inner_half_length, inner_half_length)
 
@@ -806,18 +812,20 @@ def draw_new_position(self, dt, event_type):
 
             if event_type == EventType.IV_ESCAPE:
                 #Determine wether particle escaped at left (s) or right (a) boundary.
-                flux_a = fabs( gf.flux_leavea( dt ) )
-                flux_s = fabs( gf.flux_leaves( dt ) )
+                flux_a = abs( gf.flux_leavea( dt ) )
+                flux_s = abs( gf.flux_leaves( dt ) )
                 rnd = myrandom.uniform() * ( flux_a + flux_s )
                 
+                inner_half_length = self.get_inner_a()
+                
                 if( rnd < flux_a ):
-                    z = -get_inner_a();
+                    z = inner_half_length
                 else:
-                    z = get_inner_a();
+                    z = -inner_half_length
             elif event_type == EventType.IV_INTERACTION:
                 z = self.zsink
             else:
-                z = draw_r_wrapper(gf, dt, get_inner_a(), -get_inner_a())
+                z = draw_r_wrapper(gf, dt, self.get_inner_a(), -self.get_inner_a())
 
         # Add displacement to shell.shape.position, not to particle.position.
         z_vector = self.structure.shape.unit_z * z

From 5c6c44e1534176824bc856d3a9307090ed85ed61 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 22 Dec 2011 10:08:17 +0100
Subject: [PATCH 0493/1541] ignores list in get_max_shell_size of
 NonInteractingSingle

---
 egfrd.py  | 4 ++--
 single.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3941f617..f8887b82 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1415,7 +1415,7 @@ def update_single(self, single):
         assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
         min_shell_size = single.get_min_shell_size()
-        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, sinklist=[])
+        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, ignores=[])
 
         # Make sure that the new shell size is not too small or big
         new_shell_size = max(max_shell_size, min_shell_size)
@@ -1911,7 +1911,7 @@ def try_interaction_sink(self, single, sink):
         ### 1. See if there is enough space for the shell
         # Uses the same methods as Update_single for finding optimal domain size.
         min_shell_size = single.get_min_shell_size()
-        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, self.sinklist)
+        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, ignores=[sink.id,])
 
         # Make sure that the new shell size is not too small or big
         new_shell_size = max(max_shell_size, min_shell_size)
diff --git a/single.py b/single.py
index 1c9c6326..f51480ce 100644
--- a/single.py
+++ b/single.py
@@ -249,7 +249,7 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
     def get_min_shell_size(self):
         return self.pid_particle_pair[1].radius
 
-    def get_max_shell_size(self, geometrycontainer, domains, sinklist):
+    def get_max_shell_size(self, geometrycontainer, domains, ignores=[]):
         # This calculates the maximum shell size that the single can have in the current
         # situation.
         # TODO This is now general for all NonInteractionSingles and should be different
@@ -266,7 +266,7 @@ def get_max_shell_size(self, geometrycontainer, domains, sinklist):
 #                                              ignores=[self.structure.id])
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(singlepos, domains, ignore=[self.domain_id, ])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, self.structure.id, sinklist)
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, self.structure.id, ignores)
         neighbors = neighbor_domains + neighbor_surfaces
 
         # 2. Calculate the maximum allowed radius of the spherical domain

From 7e85cd8cebfefa9838ba45e82ab42d91cd2793a3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Dec 2011 15:31:07 +0100
Subject: [PATCH 0494/1541] Multiple changes: -included checks when attempting
 a Pair testShell -moved the single structure variable for Pair to SimplePair
 (MixedPair basically has two structures) -included SAFETY distance to be
 obeyed between spherical shells -intruduced Exceptions as the failure
 mechanism of shells making (instead of returning None)

---
 shells.py | 47 ++++++++++++++++++++++++++++-------------------
 1 file changed, 28 insertions(+), 19 deletions(-)

diff --git a/shells.py b/shells.py
index d5cebb7f..877f2e94 100755
--- a/shells.py
+++ b/shells.py
@@ -9,7 +9,7 @@
     CylindricalShell,
     )
 
-import utils
+from utils import *
 
 class Others(object):
 
@@ -63,14 +63,15 @@ def __init__(self, single, structure, surface):
 
 ##############
 class testPair(Others):
-    def __init__(self, single1, single2, structure):
+    def __init__(self, single1, single2):
+
+        assert single1.dt == 0.0
+        assert single2.dt == 0.0
 
-        assert single1.structure == single2.structure
         self.single1 = single1
         self.single2 = single2
         self.pid_particle_pair1 = single1.pid_particle_pair
         self.pid_particle_pair2 = single2.pid_particle_pair
-        self.structure = structure
         self.com, self.iv = self.do_transform()
         self.r0 = length(self.iv)
 
@@ -83,7 +84,11 @@ def do_transform(self):
 
 class testSimplePair(testPair):
     def __init__(self, single1, single2, structure):
-        testPair.__init__(self, single1, single2, structure)
+
+        assert single1.structure == single2.structure
+        self.structure = structure
+
+        testPair.__init__(self, single1, single2)
 
     def get_D_tot(self):
         return self.pid_particle_pair1[1].D + \
@@ -300,7 +305,7 @@ def get_radius_to_shell(self, shell, domain_to_scale):
         # Do simple distance calculation to sphere
 
         scale_point = domain_to_scale.center
-        r = self.world.distance(shell.shape, scale_point)
+        r = self.world.distance(shell.shape, scale_point)/SAFETY
         return r
 
 #####
@@ -455,7 +460,7 @@ def get_radius_to_shell(self, shell, domain_to_scale):
         # Do simple distance calculation to cylinder
 
         scale_point = domain_to_scale.center
-        r = self.world.distance(shell.shape, scale_point)
+        r = self.world.distance(shell.shape, scale_point)/SAFETY
         return r
 
 #####
@@ -562,7 +567,9 @@ def determine_possible_shell(self, ignore, ignores):
                 distance += self.pid_particle_pair[1].radius
             radius = min(radius, distance)
             if radius < min_radius:
-                return None
+                raise Exception('Surface too close to make spherical testshell.'
+                                'surface = %s, distance = %s, testShell = %s' %
+                                (surface, distance, self))
 
         # then check the domains
         for neighbor, _ in neighbor_domains:
@@ -574,7 +581,9 @@ def determine_possible_shell(self, ignore, ignores):
                 radius = min(radius, new_radius)
 
                 if radius < min_radius:
-                    return None
+                    raise Exception('Domain too close to make spherical testshell.'
+                                    'domain = %s, distance = %s, testShell = %s' %
+                                    (neighbor, radius, self))
 
         # we calculated a valid radius -> suscess!
         assert radius >= min_radius, 'SphericaltestShell radius smaller than the minimum, radius = %s, min_radius = %s.' % \
@@ -612,22 +621,22 @@ def get_min_radius(self):
 #####
 class SphericalPairtestShell(SphericaltestShell, testSimplePair):
 
-    def __init__(self, single1, single2, structure, geomterycontainer, domains):
-        SphericaltestShell.__init__(self, geometrycontainer, domains)
-        testSimplePair.__init__(self, single1, single2, structure)  # this should be second because of world definition
+    def __init__(self, single1, single2, structure, geometrycontainer, domains):
+        SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testSimplePair.__init__(self, single1, single2, structure)
 
         self.center = self.com
-        radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
-                                               [structure.id])
-        if radius == None:
-            raise Exception("SphericalPairtestShell_exception")
-        else:
-            self.radius = radius
+        try:
+            self.radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
+                                                   [structure.id])
+        except Exception as e:
+            raise Exception('SphericalPairtestShell failed: %s' %
+                            (str(e)))
 
     def get_min_radius(self):
         # TODO this doesn't really belong in testSimplePair, but is also general for all SimplePairs
 
-        # Is this assert here ok?
+        # TODO Is this assert here ok?
         assert self.r0 >= self.sigma, \
             'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
             (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma))

From 87a268e589a63df668e0f9803d3842d656daa28b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Dec 2011 15:33:32 +0100
Subject: [PATCH 0495/1541] Now using the exceptions to handle failure of shell
 making for spherical singles

---
 single.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 7d0c9e8a..3e61c2fa 100644
--- a/single.py
+++ b/single.py
@@ -370,7 +370,11 @@ def shell_list_for_other(self):
             return self.shell_list
 
     def update_radius(self):
-        return self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+        try:
+            return self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+        except Exception as e:
+            raise Exception('SphericalSingle, update_radius failed: %s' %
+                            (str(e)))
 
     def create_position_vector(self, r):
         return random_vector(r)

From 0b98961614bfe2ab57abdcf12cd60c5832d25dcb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Dec 2011 15:35:28 +0100
Subject: [PATCH 0496/1541] activated the code needed to use
 SphericalPairtestShells for domain making

---
 egfrd.py | 67 ++++++++++++++++++++++++++++++--------------------------
 pair.py  | 40 +++++++++++++++++++--------------
 2 files changed, 60 insertions(+), 47 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c24232a8..b2e7268c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -60,17 +60,15 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure,
                                    shell_id, rt, structure)
 
 
-def create_default_pair(domain_id, single1, single2, shell_id, com,
-                        shell_size, r0, rrs, structure):
-    if isinstance(structure, CuboidalRegion):
-        return SphericalPair(domain_id, com, single1, single2,
-                             shell_id, r0, shell_size, rrs, structure)
-    elif isinstance(structure, CylindricalSurface):
-        return CylindricalSurfacePair(domain_id, com, single1, single2,
-                                      shell_id, r0, shell_size, rrs, structure)
-    elif isinstance(structure, PlanarSurface):
-        return PlanarSurfacePair(domain_id, com, single1, single2,
-                                 shell_id, r0, shell_size, rrs, structure)
+def create_default_pair(domain_id, shell_id, testShell, rrs):
+    if   isinstance(testShell, SphericalPairtestShell):
+        return SphericalPair          (domain_id, shell_id, testShell, rrs)
+    elif isinstance(testShell, CylindricalSurfacePairtestShell):
+        return CylindricalSurfacePair (domain_id, shell_id, testShell, rrs)
+    elif isinstance(testShell, PlanarSurfacePairtestShell):
+        return PlanarSurfacePair      (domain_id, shell_id, testShell, rrs)
+    elif isinstance(testShell, MixedPair3D2DtestShell):
+        return MixedPair3D2D          (domain_id, shell_id, testShell, rrs)
 
 
 class DomainEvent(Event):
@@ -461,14 +459,17 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
         return interaction
 
-    def create_pair(self, single1, single2, shell_center, shell_radius, r0, shell_half_length=0,
-                    shell_orientation_vector=None):
+#    def create_pair(self, single1, single2, shell_center, shell_radius, r0, shell_half_length=0,
+#                    shell_orientation_vector=None):
+    def create_pair(self, testShell):
 
-        assert single1.dt == 0.0
-        assert single2.dt == 0.0
+#        assert single1.dt == 0.0
+#        assert single2.dt == 0.0
 
-        pid_particle_pair1 = single1.pid_particle_pair
-        pid_particle_pair2 = single2.pid_particle_pair
+#        pid_particle_pair1 = single1.pid_particle_pair
+#        pid_particle_pair2 = single2.pid_particle_pair
+        pid_particle_pair1 = testShell.pid_particle_pair1
+        pid_particle_pair2 = testShell.pid_particle_pair2
 
         # 1. generate needed identifiers
         domain_id = self.domain_id_generator()
@@ -489,8 +490,9 @@ def create_pair(self, single1, single2, shell_center, shell_radius, r0, shell_ha
         if structure1 == structure2:
             # Either SphericalPair, PlanarSurfacePair, or 
             # CylindricalSurfacePair.
-            pair = create_default_pair(domain_id, single1, single2, shell_id, shell_center,
-                                       shell_radius, r0, rrs, structure1)
+#            pair = create_default_pair(domain_id, single1, single2, shell_id, shell_center,
+#                                       shell_radius, r0, rrs, structure1)
+            pair = create_default_pair(domain_id, shell_id, testShell, rrs)
         else:
             # MixedPair (3D/2D)
             assert shell_orientation_vector != None
@@ -1408,6 +1410,7 @@ def update_single(self, single):
 #        new_shell_size = max(max_shell_size, min_shell_size)
 
         new_shell_size = single.update_radius()
+        assert new_shell_size, 'single.update_radius() returned None.'
 
         if __debug__:
             log.info('update_single: single: %s, new_shell_size = %s' % \
@@ -2045,16 +2048,15 @@ def try_pair(self, single1, single2):
         if single1.structure == single2.structure:
             # particles are on the same structure
 
-            center, r0, shell_size = self.calculate_simplepair_shell_size (single1, single2)
-            if shell_size:
-                # A shell could be made and makes sense. Create a Pair
-                pair = self.create_pair(single1, single2, center, shell_size, r0)
+            try:
+                testShell = SphericalPairtestShell(single1, single2, single1.structure,
+                                                   self.geometrycontainer, self.domains)
+            except Exception as e:
+                testShell = None
                 if __debug__:
-                    log.debug('Created: %s, shell_size = %.3g, r0 = %.3g' %
-                              (pair, shell_size, r0))
-
-            else:
-                pair = None
+                    log.debug('%s not formed: %s' % \
+                              ('Pair(%s, %s)' % (single1.pid_particle_pair[0], single2.pid_particle_pair[0]),
+                              str(e) ))
 
         elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)) ^ \
              (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
@@ -2093,11 +2095,14 @@ def try_pair(self, single1, single2):
             pair = None
 
 
-        # if a pair has been formed
-        if pair:
+        # if a pair could be formed
+        if testShell:
+            pair = self.create_pair(testShell)
+            if __debug__:
+                log.debug('Created: %s' % (pair))
 
             pair.dt, pair.event_type, pair.reactingsingle = \
-            pair.determine_next_event(r0)
+            pair.determine_next_event(pair.r0)
 
             assert pair.dt >= 0
 
diff --git a/pair.py b/pair.py
index a408b76d..ee90ad84 100644
--- a/pair.py
+++ b/pair.py
@@ -11,6 +11,12 @@
     InteractionSingle)
 from multi import (
     Multi)
+from shells import (
+    hasSphericalShell,
+    hasCylindricalShell,
+    Others,
+    )
+
 
 __all__ = [
     'CylindricalSurfacePair',
@@ -53,6 +59,7 @@ def __init__(self, domain_id, single1, single2, shell_id, r0,
 
         self.interparticle_rrs = rrs
         self.interparticle_ktot = self.calc_ktot(rrs)
+        self.r0 = r0
 
         self.shell_id = shell_id
 
@@ -320,7 +327,7 @@ def __init__(self, domain_id, shell_center, single1, single2, shell_id,
         # set the radii of the inner domains as a function of the outer protective domain
 
 # this can go
-        self.shell = self.create_new_shell(shell_center, shell_size, domain_id)
+#        self.shell = self.create_new_shell(shell_center, shell_size, domain_id)
 
 
     def getSigma(self):
@@ -361,8 +368,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
 
         return pos1, pos2
 
-    def get_shell_size(self):
-        return self.shell.shape.radius
+#    def get_shell_size(self):
+#        return self.shell.shape.radius
 
     def determine_radii(self, r0, shell_size):
         """Determine a_r and a_R from the size of the protective domain.
@@ -449,24 +456,25 @@ def determine_radii(self, r0, shell_size):
         return a_R, a_r
 
 
-class SphericalPair(SimplePair):
-#class SphericalPair(SimplePair, Other, hasSphericalShell):
+#class SphericalPair(SimplePair):
+class SphericalPair(SimplePair, Others, hasSphericalShell):
     """2 Particles inside a (spherical) shell not on any surface.
 
     """
-    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-                 r0, shell_size, rrs, structure):
-#    def __init__(self, domain_id, shell_id, testShell, rrs):
-#        single1 = testShell.single1
-#        single2 = testShell.single2
-#        structure = testShell.structure
-#        shell_size = testShell.radius  # TODO this should be removed
-#        r0 = testShell.get_r0()        # TODO this should be removed
+#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
+#                 r0, shell_size, rrs, structure):
+    def __init__(self, domain_id, shell_id, testShell, rrs):
+        single1 = testShell.single1
+        single2 = testShell.single2
+        structure = testShell.structure
+        shell_center = testShell.center
+        shell_size = testShell.radius  # TODO this should be removed
+        r0 = testShell.r0        # TODO this should be removed
 
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 #        SimplePair.__init__(self, domain_id, shell_id, testShell, rrs) # TODO constructor above does not support this yet
-#        hasSphericalShell.__init__(self, testShell)
+        hasSphericalShell.__init__(self, testShell)
 
 
     def com_greens_function(self):
@@ -480,8 +488,8 @@ def iv_greens_function(self, r0):
                                               self.sigma, self.a_r)
 
 # this can go
-    def create_new_shell(self, position, radius, domain_id):
-        return SphericalShell(domain_id, Sphere(position, radius))
+#    def create_new_shell(self, position, radius, domain_id):
+#        return SphericalShell(domain_id, Sphere(position, radius))
 
 # this is a part of hasShell (see testShell.get_orientation_vector())
     def get_shell_direction(self):

From f2aaf2b6c71b7c683eb2eb769e7f07b865f37e4b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 22 Dec 2011 15:36:41 +0100
Subject: [PATCH 0497/1541] Removed cyclic error bug.

---
 egfrd.py  | 19 ++++++++++---------
 single.py |  9 ++++-----
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f8887b82..0f7fa923 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -446,7 +446,9 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
             projected_point, r0 = surface.projected_point(particle_pos)
             shell_unit_r = normalize(particle_pos - projected_point)
 
-            z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
+            projected_point = self.world.cyclic_transpose(projected_point, shell_center)
+
+            z0 = numpy.dot (shell_unit_z, projected_point - shell_center)
 
             interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
                                                         reaction_rules, structure,
@@ -1216,7 +1218,7 @@ def make_new_domain(self, single):
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
-        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners))
+        log.debug('pair_interaction_partners: %s' %str(pair_interaction_partners))
 
         # For each particles/particle or particle/surface pair, check if a pair or interaction can be
         # made. Note that we check the closest one first and only check if the object are within the horizon
@@ -1436,8 +1438,6 @@ def process_single_event(self, single):
             log.info('FIRE SINGLE: %s' % single.event_type)
             log.info('single = %s' % single)
 
-
-
         if single.is_reset():
         ### If no event event really happened and just need to make new domain
             domains = [self.make_new_domain(single)]
@@ -1880,7 +1880,7 @@ def try_interaction(self, single, surface):
         interaction.dt, interaction.event_type, = \
             interaction.determine_next_event()
         assert interaction.dt >= 0
-
+        
         self.last_time = self.t
 
         self.remove_domain(single)
@@ -1891,9 +1891,9 @@ def try_interaction(self, single, surface):
 
         if __debug__:
             log.debug('        *create_interaction\n'
-                      '            dr = %s. dz_left = %s. dz_right = %s.\n' %
+                      '            dr = %s. dz_left = %s. dz_right = %s. dt = %s\n' %
                       (FORMAT_DOUBLE % dr, FORMAT_DOUBLE % dz_left,
-                       FORMAT_DOUBLE % dz_right))
+                       FORMAT_DOUBLE % dz_right, FORMAT_DOUBLE % interaction.dt))
 
         return interaction
 
@@ -2461,13 +2461,14 @@ def check_domain(self, domain):
             # TODO maybe don't check all the shells, this takes a lot of time
 
             # testing overlap criteria
+            '''
             for neighbor, _ in neighbors:
                 for _, neighbor_shell in neighbor.shell_list:
                     overlap = self.check_shell_overlap(shell, neighbor_shell)
-                    assert overlap >= 0.0, \
+                    assert overlap >= 0.0 - 1e-15, \
                         '%s (%s) overlaps with %s (%s) by %s.' % \
                         (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
-
+            '''
 
             # checking wether the shell don't exceed the maximum size
             if (type(shell.shape) is Cylinder):
diff --git a/single.py b/single.py
index f51480ce..fe9da1d3 100644
--- a/single.py
+++ b/single.py
@@ -500,6 +500,7 @@ def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
         """
+       
         return min(self.draw_escape_time_tuple(),
                    self.draw_reaction_time_tuple(),
                    self.draw_iv_event_time_tuple())     # above two events also occur in NonInteractingSingle
@@ -516,7 +517,7 @@ def draw_iv_event_time_tuple(self):
 
         """
         dt = draw_time_wrapper(self.iv_greens_function())
-
+        
         return dt, EventType.IV_EVENT
 
     def draw_iv_event_type(self):
@@ -752,7 +753,7 @@ def get_shell_size(self):
         return self.shell.shape.half_length
 
     def __str__(self):
-        return 'CylindricalSurfaceInteraction' + Single.__str__(self)
+        return 'CylindricalSurfaceInteraction ' + Single.__str__(self)
 
 
 class CylindricalSurfaceSink(InteractionSingle):
@@ -785,8 +786,6 @@ def iv_greens_function(self):
         # Particle allways starts in the middle for now.
         inner_half_length = self.get_inner_a()
         
-        print "Sink GF'n params: h = %s, zsink = %s" %(inner_half_length, self.zsink)
-
         return GreensFunction1DAbsSinkAbs(self.D, self.interaction_ktot, 0.0, self.zsink, 
                                           -inner_half_length, inner_half_length)
 
@@ -841,7 +840,7 @@ def get_shell_size(self):
         return self.shell.shape.half_length
 
     def __str__(self):
-        return 'CylindricalSurfaceInteraction' + Single.__str__(self)
+        return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 class DummySingle(object):
     def __init__(self):

From 49e33de87004a16c567373424a5dd374e3c629f1 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 22 Dec 2011 15:38:48 +0100
Subject: [PATCH 0498/1541] Minor change.

---
 GreensFunction1DAbsSinkAbs.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 472b63f9..9113cc99 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -52,11 +52,6 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
 
     real_pair lower_upper_pair;
 
-    lo_up_params.h = h;
-    lo_up_params.Lm_L = Lm_L;
-    lo_up_params.long_period = std::max( L/Lr * M_PI, L/Ll * M_PI );
-    lo_up_params.short_period = std::min( L/Lr * M_PI, L/Ll * M_PI );
-
     /* Define the root function. */
     gsl_function F;
     struct root_f_params params = { Lm_L, h };
@@ -73,6 +68,10 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
     /* Stores the last root with long or short period. */
     if(i == 0)
     {
+        lo_up_params.h = h;
+        lo_up_params.Lm_L = Lm_L;
+        lo_up_params.long_period = std::max( L/Lr * M_PI, L/Ll * M_PI );
+        lo_up_params.short_period = std::min( L/Lr * M_PI, L/Ll * M_PI );    
         lo_up_params.last_long_root = 0.0;
         lo_up_params.last_short_root = 0.0;
     }

From b3fb2a4d2284662779890ff047abc728ca6cbd81 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Dec 2011 15:39:46 +0100
Subject: [PATCH 0499/1541] bugfix

---
 egfrd.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/egfrd.py b/egfrd.py
index 09e2787f..7e993d0e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -423,6 +423,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
             projected_point, r0 = surface.projected_point(particle_pos)
             shell_unit_r = normalize(particle_pos - projected_point)
 
+            projected_point = self.world.cyclic_transpose(projected_point, shell_center)
             z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
 
             interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,

From 053a797f3653ebdc15e6041ef0f95037c5741f9e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Dec 2011 17:31:55 +0100
Subject: [PATCH 0500/1541] changed logging, comments and fix for minimal
 spherical pair shell size

---
 egfrd.py  |  4 ++--
 shells.py | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 15df2c90..d5953dc7 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1281,7 +1281,7 @@ def make_new_domain(self, single):
 
         return domain
 
-
+##### Redundant but maybe useful for parts
     def calculate_simplepair_shell_size(self, single1, single2):
         assert single1.structure == single2.structure
 
@@ -2055,7 +2055,7 @@ def try_pair(self, single1, single2):
             except Exception as e:
                 testShell = None
                 if __debug__:
-                    log.debug('%s not formed: %s' % \
+                    log.debug('%s not formed %s' % \
                               ('Pair(%s, %s)' % (single1.pid_particle_pair[0], single2.pid_particle_pair[0]),
                               str(e) ))
 
diff --git a/shells.py b/shells.py
index 877f2e94..5c940d4c 100755
--- a/shells.py
+++ b/shells.py
@@ -567,7 +567,7 @@ def determine_possible_shell(self, ignore, ignores):
                 distance += self.pid_particle_pair[1].radius
             radius = min(radius, distance)
             if radius < min_radius:
-                raise Exception('Surface too close to make spherical testshell.'
+                raise Exception('Surface too close to make spherical testshell, '
                                 'surface = %s, distance = %s, testShell = %s' %
                                 (surface, distance, self))
 
@@ -581,7 +581,7 @@ def determine_possible_shell(self, ignore, ignores):
                 radius = min(radius, new_radius)
 
                 if radius < min_radius:
-                    raise Exception('Domain too close to make spherical testshell.'
+                    raise Exception('Domain too close to make spherical testshell, '
                                     'domain = %s, distance = %s, testShell = %s' %
                                     (neighbor, radius, self))
 
@@ -628,9 +628,9 @@ def __init__(self, single1, single2, structure, geometrycontainer, domains):
         self.center = self.com
         try:
             self.radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
-                                                   [structure.id])
+                                                        [structure.id])
         except Exception as e:
-            raise Exception('SphericalPairtestShell failed: %s' %
+            raise Exception('(SphericalPair). %s' %
                             (str(e)))
 
     def get_min_radius(self):
@@ -655,8 +655,8 @@ def get_min_radius(self):
         com_shell_size = max(radius1, radius2)
 
         # calculate total radii including the margin for the burst volume for the particles
-        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - self.SINGLE_SHELL_FACTOR),
-                         iv_shell_size2 + com_shell_size + radius2 * (1 - self.SINGLE_SHELL_FACTOR))
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (self.SINGLE_SHELL_FACTOR),
+                         iv_shell_size2 + com_shell_size + radius2 * (self.SINGLE_SHELL_FACTOR))
 
         return shell_size
 

From 487971d3307f9e2f700b2564ffaf293988cff26c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Dec 2011 18:36:05 +0100
Subject: [PATCH 0501/1541] preparing the PlanarSurfaceSingle for using the new
 shell making code

---
 single.py | 75 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 55 insertions(+), 20 deletions(-)

diff --git a/single.py b/single.py
index 3e61c2fa..23d3d690 100644
--- a/single.py
+++ b/single.py
@@ -383,7 +383,8 @@ def __str__(self):
         return 'Spherical' + Single.__str__(self)
 
 
-class PlanarSurfaceSingle(NonInteractionSingle):
+#class PlanarSurfaceSingle(NonInteractionSingle):
+class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionsSingles, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a PlanarSurface. (Hockey 
     pucks).
 
@@ -393,33 +394,67 @@ class PlanarSurfaceSingle(NonInteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-                 structure):
+#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
+#                 structure):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+
+        pid_particle_pair = testShell.pid_particle_pair
+        structure = testShell.structure
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
                                       shell_id, reactionrules, structure)
+        hasCylindricalShell.__init__(self, testShell)
 
     def greens_function(self):
         return GreensFunction2DAbsSym(self.D,
                                           self.get_inner_a())
+# this can go
+#    def create_new_shell(self, position, radius, domain_id):
+#        # The half_length (thickness) of a hockey puck is not more than 
+#        # it has to be (namely the radius of the particle), so if the 
+#        # particle undergoes an unbinding reaction we still have to 
+#        # clear the target volume and the move may be rejected (NoSpace 
+#        # error).
+#
+#        # Note that the calculateion of the position of the shell needs to make sure that the
+#        # coordinates are in the surface
+#        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
+#        pos_x = self.structure.shape.unit_x * numpy.dot (position, self.structure.shape.unit_x)
+#        pos_y = self.structure.shape.unit_y * numpy.dot (position, self.structure.shape.unit_y)
+#
+#        position = self.structure.shape.position + pos_x + pos_y
+#        orientation = self.structure.shape.unit_z
+#        half_length = self.pid_particle_pair[1].radius
+#        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
+#                                                    orientation, half_length))
+
+    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+    def shell_list_for_single(self):
+        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+        if self.shell.shape.radius < min_radius:
+            position = self.shell.shape.position
+            half_length = self.shell.shape.half_length
+            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
 
-    def create_new_shell(self, position, radius, domain_id):
-        # The half_length (thickness) of a hockey puck is not more than 
-        # it has to be (namely the radius of the particle), so if the 
-        # particle undergoes an unbinding reaction we still have to 
-        # clear the target volume and the move may be rejected (NoSpace 
-        # error).
-
-        # Note that the calculateion of the position of the shell needs to make sure that the
-        # coordinates are in the surface
-        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
-        pos_x = self.structure.shape.unit_x * numpy.dot (position, self.structure.shape.unit_x)
-        pos_y = self.structure.shape.unit_y * numpy.dot (position, self.structure.shape.unit_y)
+    def shell_list_for_other(self):
+        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+        if self.shell.shape.radius < min_radius:
+            position = self.shell.shape.position
+            half_length = self.shell.shape.half_length
+            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
 
-        position = self.structure.shape.position + pos_x + pos_y
-        orientation = self.structure.shape.unit_z
-        half_length = self.pid_particle_pair[1].radius
-        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
-                                                    orientation, half_length))
+    def update_radius(self):
+        # TODO update_single_shell doesn't work with this now
+        try:
+            return self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+        except Exception as e:
+            raise Exception('SphericalSingle, update_radius failed: %s' %
+                            (str(e)))
 
     def create_position_vector(self, r):
         # project the vector onto the surface unit vectors to make sure that the coordinates are in the surface

From 1da12ec6022fcf59a119624eeb030eb3420650df Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Dec 2011 18:39:33 +0100
Subject: [PATCH 0502/1541] multiple changes (not such a good idea) -modified
 radius_to_shell to return the minimum of the current and the calculated
 (before just calculated) -removed some old (out commented) code -updated
 determine_possible_shell for cylindrical shell

---
 shells.py | 130 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 73 insertions(+), 57 deletions(-)

diff --git a/shells.py b/shells.py
index 5c940d4c..ccbc0294 100755
--- a/shells.py
+++ b/shells.py
@@ -298,15 +298,17 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         return (r, z_right, z_left)
 
 
-    def get_radius_to_shell(self, shell, domain_to_scale):
+    def get_radius_to_shell(self, shell, domain_to_scale, r):
         # SphericaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
 
         assert (type(shell.shape) is Sphere)        # because the shell actually originated here
         # Do simple distance calculation to sphere
 
         scale_point = domain_to_scale.center
-        r = self.world.distance(shell.shape, scale_point)/SAFETY
-        return r
+        r_new = self.world.distance(shell.shape, scale_point)/SAFETY
+
+        # if the newly calculated dimensions are smaller than the current one, use them
+        return min(r, r_new)
 
 #####
 #class SphericalSingle(hasSphericalShell, NonInteractionSingles):
@@ -332,11 +334,11 @@ def get_radius_to_shell(self, shell, domain_to_scale):
 #            return [(self.shell_id, fake_shell), ]
 #        else:
 #            return self.shell_list
-
-#####
-class SphericalPair(hasSphericalShell, Others):
-
-    pass
+#
+######
+#class SphericalPair(hasSphericalShell, Others):
+#
+#    pass
 
 #####
 class Multi(hasSphericalShell, Others):
@@ -348,6 +350,8 @@ class hasCylindricalShell(hasShell):
 
     def __init__(self, cylindricaltestShell):
 
+        assert isinstance(cylindricaltestShell, CylindricaltestShell)
+
         hasShell.__init__(self, cylindricaltestShell)
 
         self.testShell = cylindricaltestShell
@@ -453,39 +457,41 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         return (r, z_right, z_left)
 
-    def get_radius_to_shell(self, shell, domain_to_scale):
+    def get_radius_to_shell(self, shell, domain_to_scale, r):
         # SphericaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
 
         assert (type(shell.shape) is Cylinder)        # because the shell actually originated here
         # Do simple distance calculation to cylinder
 
         scale_point = domain_to_scale.center
-        r = self.world.distance(shell.shape, scale_point)/SAFETY
-        return r
-
-#####
-class PlanarSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
+        r_new = self.world.distance(shell.shape, scale_point)/SAFETY
 
-    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
-    def shell_list_for_single(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
-        if self.shell.shape.radius < min_radius:
-            position = self.shell.shape.position
-            half_length = self.shell.shape.half_length
-            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
+        # if the newly calculated dimensions are smaller than the current one, use them
+        return min(r, r_new)
 
-    def shell_list_for_other(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
-        if self.shell.shape.radius < min_radius:
-            position = self.shell.shape.position
-            half_length = self.shell.shape.half_length
-            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
+#####
+#class PlanarSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
+#
+#    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+#    def shell_list_for_single(self):
+#        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+#        if self.shell.shape.radius < min_radius:
+#            position = self.shell.shape.position
+#            half_length = self.shell.shape.half_length
+#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+#            return [(self.shell_id, fake_shell), ]
+#        else:
+#            return self.shell_list
+#
+#    def shell_list_for_other(self):
+#        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+#        if self.shell.shape.radius < min_radius:
+#            position = self.shell.shape.position
+#            half_length = self.shell.shape.half_length
+#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+#            return [(self.shell_id, fake_shell), ]
+#        else:
+#            return self.shell_list
 
 #####
 class CylindricalSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
@@ -572,13 +578,12 @@ def determine_possible_shell(self, ignore, ignores):
                                 (surface, distance, self))
 
         # then check the domains
+        # TODO first sort the neighbors -> faster to find if we fail
         for neighbor, _ in neighbor_domains:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                new_radius = neighbor.get_radius_to_shell(shell_appearance, self)
-                # if the newly calculated dimensions are smaller than the current one, use them
-                radius = min(radius, new_radius)
+                radius = neighbor.get_radius_to_shell(shell_appearance, self, radius)
 
                 if radius < min_radius:
                     raise Exception('Domain too close to make spherical testshell, '
@@ -596,6 +601,7 @@ def get_searchpoint(self):
     def get_searchradius(self):
         return self.geometrycontainer.get_max_shell_size()
     def get_orientation_vector(self):
+#        return unit_vector # much faster and doesn't matter anyway
         return random_vector(1.0)
 
     def get_max_radius(self):
@@ -611,10 +617,6 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.center = self.pid_particle_pair[1].position
         self.radius = self.pid_particle_pair[1].radius
 
-#    def update_radius(self):
-#        self.radius = self.determine_possible_shell([], [self.structure.id])
-#        return self.radius
-
     def get_min_radius(self):
         return self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
 
@@ -664,33 +666,47 @@ def get_min_radius(self):
 ##########################
 class CylindricaltestShell(testShell):
 
-    def __init__(self):
+    def __init__(self, geometrycontainer, domains):
+        testShell.__init__(self, geometrycontainer, domains)
+
         self.dz_right = 0
         self.dz_left  = 0
         self.dr       = 0
 
-    def determine_possible_shell(self):
-        neighbors = self.get_neighbors()
-        min_dr_dzright_dzleft = self.get_min_dr_dzright_dzleft()
-        max_dr_dzright_dzleft = self.get_max_dr_dzright_dzleft()
+    def determine_possible_shell(self, ignore, ignores):
+        neighbor_domains, neighbor_surfaces = self.get_neighbors (ignore, ignores)
+        min_dr, min_dz_right, min_dz_left = self.get_min_dr_dzright_dzleft()
+        max_dr, max_dz_right, max_dz_left = self.get_max_dr_dzright_dzleft()
+
+        dr, dz_right, dz_left = max_dr, max_dz_right, max_dz_left
+        # first check the surfaces
+#        for surface, distance in neighbor_surfaces:
+#            radius = min(radius, distance)     # TODO
+#            if radius < min_radius:
+#                raise Exception('Surface too close to make cylindrical testshell, '
+#                                'surface = %s, distance = %s, testShell = %s' %
+#                                (surface, distance, self))
 
-        dr_dzright_dzleft = max_dr_dzright_dzleft
-        for neighbor in neighbors:
+        # then check the domains
+        # TODO first sort the neighbors -> faster to find if we fail
+        for neighbor, distance in neighbors:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                new_dr_dzright_dzleft = neighbor.get_dr_dzright_dzleft(shell_appearance, self)
+                dr, dz_right, dz_left = neighbor.get_dr_dzright_dzleft_to_shell(shell_appearance, self,
+                                                                                dr, dz_right, dz_left)
 
-                # if the newly calculated dimensions are smaller than the current one, use them
-                dr_dzright_dzleft = min(dr_dzright_dzleft, new_dr_dzright_dzleft)
-                if dr_dzright_dzleft < min_dr_dzright_dzleft:
-                    dr_dzright_dzleft = None
-                    break
+                if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
+                    raise Exception('Domain too close to make cylindrical testshell, '
+                                    'domain = %s, distance = %s, testShell = %s' %
+                                    (neighbor, distance, self))
 
-        if dr_dzright_dzleft:
-            return dr_dz_right_dzleft
-        else:
-            return None
+        # we calculated a valid radius -> suscess!
+        assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, 
+               'CylindricaltestShell dimensions smaller than the minimum, radius = %s, min_radius = %s.' % \
+                (radius, min_radius)
+        
+        return (dr, dz_right, dzleft)
 
     # default functions for evaluating z_right/z_left/r after one of parameters changed
     def r_right(self, z_right):

From e425036eca7c2cec0cd9c44bb8c51563f40f6058 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 11:39:13 +0100
Subject: [PATCH 0503/1541] changed update_single such that the single makes
 the updated shell, not update_single itself Also updated the switchbox to
 select the right NonInteractionSingle for the appropriate structure

---
 egfrd.py | 35 ++++++++++++++++++-----------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d5953dc7..0ccab00c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -35,7 +35,8 @@
 from shellcontainer import ShellContainer
 from shells import (
     SphericalSingletestShell,
-    SphericalPairtestShell
+    SphericalPairtestShell,
+    PlanarSurfaceSingletestShell,
     )
 
 import logging
@@ -53,11 +54,11 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure,
         testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return SphericalSingle(domain_id, shell_id, testSingle, rt)
     elif isinstance(structure, CylindricalSurface):
-        return CylindricalSurfaceSingle(domain_id, pid_particle_pair, 
-                                        shell_id, rt, structure)
+        testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+        return CylindricalSurfaceSingle(domain_id, shell_id, testSingle, rt)
     elif isinstance(structure, PlanarSurface):
-        return PlanarSurfaceSingle(domain_id, pid_particle_pair, 
-                                   shell_id, rt, structure)
+        testSingle = PlanarSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+        return PlanarSurfaceSingle(domain_id, shell_id, testSingle, rt)
 
 
 def create_default_pair(domain_id, shell_id, testShell, rrs):
@@ -530,17 +531,17 @@ def create_multi(self):
 #        single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
 #        self.update_single_shell(single, position, radius)
 
-    def update_single_shell(self, single, position, radius=None):
-        if radius == None:
-            # By default, don't change radius.
-            radius = single.shell.shape.radius
+    def update_single_shell(self, single, shell):#position, radius=None):
+#        if radius == None:
+#            # By default, don't change radius.
+#            radius = single.shell.shape.radius
 
         # Reuse shell_id and domain_id.
         shell_id = single.shell_id
-        domain_id = single.domain_id
+#        domain_id = single.domain_id
 
         # Replace shell.
-        shell = single.create_new_shell(position, radius, domain_id)
+#        shell = single.create_new_shell(position, radius, domain_id)
         shell_id_shell_pair = (shell_id, shell) 
 
         single.shell_id_shell_pair = shell_id_shell_pair
@@ -1410,17 +1411,17 @@ def update_single(self, single):
 #        # Make sure that the new shell size is not too small or big
 #        new_shell_size = max(max_shell_size, min_shell_size)
 
-        new_shell_size = single.update_radius()
-        assert new_shell_size, 'single.update_radius() returned None.'
+        singlepos = single.pid_particle_pair[1].position
+        new_shell = single.update_radius(singlepos)
+        assert new_shell, 'single.update_radius() returned None.'
 
         if __debug__:
-            log.info('update_single: single: %s, new_shell_size = %s' % \
-                     (single, FORMAT_DOUBLE % new_shell_size))
+            log.info('update_single: single: %s, new_shell = %s' % \
+                     (single, str(new_shell)))
 
         # Resize shell, don't change position.
         # Note: this should be done before determine_next_event.
-        singlepos = single.pid_particle_pair[1].position
-        self.update_single_shell(single, singlepos, new_shell_size)        
+        self.update_single_shell(single, new_shell)        
 
         single.dt, single.event_type = single.determine_next_event()
         single.last_time = self.t

From 2869f00bdf18ea6c58180c3beb1e460e75748140 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 11:49:29 +0100
Subject: [PATCH 0504/1541] changed single.update_radius to return the updated
 new shell instead of just the radius

---
 single.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/single.py b/single.py
index 23d3d690..acb97992 100644
--- a/single.py
+++ b/single.py
@@ -369,9 +369,11 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-    def update_radius(self):
+    def update_radius(self, position):
         try:
-            return self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            radius = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            return self.create_new_shell(position, radius, self.domain_id)
+
         except Exception as e:
             raise Exception('SphericalSingle, update_radius failed: %s' %
                             (str(e)))
@@ -384,7 +386,7 @@ def __str__(self):
 
 
 #class PlanarSurfaceSingle(NonInteractionSingle):
-class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionsSingles, hasCylindricalShell):
+class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a PlanarSurface. (Hockey 
     pucks).
 
@@ -448,10 +450,14 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-    def update_radius(self):
+    def update_radius(self, position):
         # TODO update_single_shell doesn't work with this now
         try:
-            return self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            dr, dz_right, dz_left = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
+                                                                             self.testShell.get_orientation_vector(),
+                                                                             dr, dz_right, dz_left)            
+            return self.create_new_shell(center, radius, half_length, self.domain_id)
         except Exception as e:
             raise Exception('SphericalSingle, update_radius failed: %s' %
                             (str(e)))

From 30767c2700c0173280f8c0976994e0df2a878019 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 11:50:21 +0100
Subject: [PATCH 0505/1541] Multiple changes: -changed concept code of the
 PlanarSurfaceSingletestShell into working code -moved the dr, dz_right,
 dz_left to radius, half_length calculation to separate function -fixed many
 typos

---
 shells.py | 66 +++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 42 insertions(+), 24 deletions(-)

diff --git a/shells.py b/shells.py
index ccbc0294..b75fb3ac 100755
--- a/shells.py
+++ b/shells.py
@@ -355,18 +355,26 @@ def __init__(self, cylindricaltestShell):
         hasShell.__init__(self, cylindricaltestShell)
 
         self.testShell = cylindricaltestShell
-        self.shell_center = cylindricaltestShell.get_referencepoint() + \
-                            ((cylindricaltestShell.dz_right - cylindricaltestShell.dz_left)/2.0) * \
-                            cylindricaltestShell.get_orientation_vector()
-        self.shell_center = self.world.apply_boundary(self.shell_center)
-        self.shell_radius = cylindricaltestShell.dr
-        self.shell_half_length = (cylindricaltestShell.dz_left + cylindricaltestShell.dz_right) / 2.0
+        self.shell_center, self.shell_radius, self.shell_half_length = \
+                    self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
+                                                       self.testShell.get_orientation_vector(),
+                                                       self.testShell.dr,
+                                                       self.testShell.dz_right,
+                                                       self.testShell.dz_left)
+        self.shell_center = self.testShell.world.apply_boundary(self.shell_center)
 
         self.shell = self.create_new_shell(self.shell_center,
                                            self.shell_radius,
                                            self.shell_half_length,
                                            self.domain_id)
 
+    @ classmethod
+    def r_zright_zleft_to_r_center_hl(cls, referencepoint, orientation_vector, dr, dz_right, dz_left):
+        center = referencepoint + ((dz_right - dz_left)/2.0) * orientation_vector
+        radius = dr
+        half_length = (dz_left + dz_right) / 2.0
+        return center, radius, half_length
+
     def create_new_shell(self, position, radius, half_length, domain_id):
         orientation = self.testShell.get_orientation_vector()
         return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
@@ -689,7 +697,7 @@ def determine_possible_shell(self, ignore, ignores):
 
         # then check the domains
         # TODO first sort the neighbors -> faster to find if we fail
-        for neighbor, distance in neighbors:
+        for neighbor, distance in neighbor_domains:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
@@ -702,12 +710,14 @@ def determine_possible_shell(self, ignore, ignores):
                                     (neighbor, distance, self))
 
         # we calculated a valid radius -> suscess!
-        assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, 
+        assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
                'CylindricaltestShell dimensions smaller than the minimum, radius = %s, min_radius = %s.' % \
                 (radius, min_radius)
         
-        return (dr, dz_right, dzleft)
+        return dr, dz_right, dz_left
 
+    def get_searchradius(self):
+        return self.geometrycontainer.get_max_shell_size()
     # default functions for evaluating z_right/z_left/r after one of parameters changed
     def r_right(self, z_right):
         return self.drdz_right * z_right + self.r0_right
@@ -722,40 +732,48 @@ def get_max_dr_dzright_dzleft(self):
         pass    # todo, we should be able to derive this from the scaling parameters and searchpoint
 
 #####
-class PlanarSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
+class PlanarSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
+
+    def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)
+        testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
+
+        self.dz_right = self.pid_particle_pair[1].radius
+        self.dz_left  = self.pid_particle_pair[1].radius
+        self.dr       = self.pid_particle_pair[1].radius
 
-    def __init__(self):
         # scaling parameters
         self.dzdr_right = 0.0
         self.drdz_right = numpy.inf
         self.r0_right   = 0.0
-        self.z0_right   = particle_radius
+        self.z0_right   = self.pid_particle_pair[1].radius
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
-        self.z0_left    = particle_radius
+        self.z0_left    = self.pid_particle_pair[1].radius
 
     def get_orientation_vector(self):
-        return structure.shape.unit_z   # just copy from structure
+        return self.structure.shape.unit_z   # just copy from structure
 
     def get_searchpoint(self):
-        return particle_pos
+        return self.pid_particle_pair[1].position
 
     def get_referencepoint(self):
-        return particle_pos
+        return self.pid_particle_pair[1].position
 
     def get_min_dr_dzright_dzleft(self):
-        dr = particle_radius * MULTI_SHELL_FACTOR
-        dz_right = particle_radius
-        dz_left = particle_radius
-        return (dr, dz_right, dz_left)
+        dr = self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+        dz_right = self.pid_particle_pair[1].radius
+        dz_left = dz_right
+        return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
-        dr = math.sqrt(geometrycontainer_max**2 - particle_radius**2)
-        dz_right = particle_radius
-        dz_left = particle_radius
-        return (dr, dz_right, dz_left)
+        dz_right = self.pid_particle_pair[1].radius
+        dz_left = dz_right
+        dr = math.sqrt(self.get_searchradius()**2 - dz_right**2) # stay within the searchradius
+        return dr, dz_right, dz_left
 
+# TODO?
     def get_right_scalingcenter(self):
         # returns the scaling center in the cylindrical coordinates r, z of the shell
         # Note that we assume cylindrical symmetry

From 16db4b7e32520dceb7a3d8a87a5647cf55b9efe7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 11:58:12 +0100
Subject: [PATCH 0506/1541] namechange of update_radius -> create_updated_shell

---
 egfrd.py  |  2 +-
 single.py | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0ccab00c..1406d3cd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1412,7 +1412,7 @@ def update_single(self, single):
 #        new_shell_size = max(max_shell_size, min_shell_size)
 
         singlepos = single.pid_particle_pair[1].position
-        new_shell = single.update_radius(singlepos)
+        new_shell = single.create_updated_shell(singlepos)
         assert new_shell, 'single.update_radius() returned None.'
 
         if __debug__:
diff --git a/single.py b/single.py
index acb97992..9f0a7a52 100644
--- a/single.py
+++ b/single.py
@@ -369,13 +369,13 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-    def update_radius(self, position):
+    def create_updated_shell(self, position):
         try:
             radius = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
             return self.create_new_shell(position, radius, self.domain_id)
 
         except Exception as e:
-            raise Exception('SphericalSingle, update_radius failed: %s' %
+            raise Exception('SphericalSingle, create_updated_shell failed: %s' %
                             (str(e)))
 
     def create_position_vector(self, r):
@@ -450,8 +450,8 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-    def update_radius(self, position):
-        # TODO update_single_shell doesn't work with this now
+    def create_updated_shell(self, position):
+        # TODO what should we do with the position now?
         try:
             dr, dz_right, dz_left = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
             center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
@@ -459,7 +459,7 @@ def update_radius(self, position):
                                                                              dr, dz_right, dz_left)            
             return self.create_new_shell(center, radius, half_length, self.domain_id)
         except Exception as e:
-            raise Exception('SphericalSingle, update_radius failed: %s' %
+            raise Exception('SphericalSingle, create_updated_shell failed: %s' %
                             (str(e)))
 
     def create_position_vector(self, r):

From 8066bbd2d923b6554f475064aab166c94744a9b6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 14:21:07 +0100
Subject: [PATCH 0507/1541] fixes in cylinder_to_cylinder scaling + adjustments
 to PlanarSurfaceSingletestShell and CylindricaltestShell to allow cylinder
 scaling

---
 shells.py | 97 ++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 56 insertions(+), 41 deletions(-)

diff --git a/shells.py b/shells.py
index b75fb3ac..5a96b098 100755
--- a/shells.py
+++ b/shells.py
@@ -7,6 +7,7 @@
     SphericalShell,
     Cylinder,
     CylindricalShell,
+    PlanarSurface,
     )
 
 from utils import *
@@ -168,7 +169,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         orientation_vector = domain_to_scale.get_orientation_vector()
 
         # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = world.cyclic_transpose (shell_position, reference_point)
+        shell_position_t = domain_to_scale.world.cyclic_transpose (shell_position, reference_point)
         ref_to_shell_vec = shell_position_t - reference_point
         ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
 
@@ -295,7 +296,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
             z_right = z2_new
             z_left  = z1_new
 
-        return (r, z_right, z_left)
+        return r, z_right, z_left
 
 
     def get_radius_to_shell(self, shell, domain_to_scale, r):
@@ -305,7 +306,7 @@ def get_radius_to_shell(self, shell, domain_to_scale, r):
         # Do simple distance calculation to sphere
 
         scale_point = domain_to_scale.center
-        r_new = self.world.distance(shell.shape, scale_point)/SAFETY
+        r_new = domain_to_scale.world.distance(shell.shape, scale_point)/SAFETY
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
@@ -383,9 +384,6 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
         # CylindricaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
 
-        if __debug__:
-            log.debug('cylinder')
-
         assert (type(shell.shape) is Cylinder)        # because the shell actually originated here
         # Do Laurens' algorithm (part2)
 
@@ -399,7 +397,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         orientation_vector = domain_to_scale.get_orientation_vector()
 
         # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = world.cyclic_transpose (shell_position, reference_point)
+        shell_position_t = domain_to_scale.world.cyclic_transpose (shell_position, reference_point)
         ref_to_shell_vec = shell_position_t - reference_point
         ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
 
@@ -408,8 +406,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         if ref_to_shell_z >= 0:
             direction = 1           # improve direction specification such that following calculations still work
                                     # Otherwise problems when direction = 0
-            scale_angle = domain_to_scale.get_right_scalingangle()
-            scale_center_r, scale_center_z = domain_to_scale.get_right_scalingcenter() 
+            scale_angle = domain_to_scale.right_scalingangle
+            scale_center_r, scale_center_z = domain_to_scale.right_scalingcenter 
             r1_function =  domain_to_scale.r_right
             z1_function = domain_to_scale.z_right
             z2_function = domain_to_scale.z_left
@@ -418,8 +416,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         # else -> use z_left
         else:
             direction = -1
-            scale_angle = domain_to_scale.get_left_scalingangle()
-            scale_center_r, scale_center_z = domain_to_scale.get_left_scalingcenter() 
+            scale_angle = domain_to_scale.left_scalingangle
+            scale_center_r, scale_center_z = domain_to_scale.left_scalingcenter 
             r1_function =  domain_to_scale.r_left
             z1_function = domain_to_scale.z_left
             z2_function = domain_to_scale.z_right
@@ -429,8 +427,9 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
         ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
         ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
-        ref_to_shell_r = length(ref_to_shell_r_vec)
-        ref_to_shell_z = abs(ref_to_shell_z)
+        ref_to_shell_r = length(ref_to_shell_r_vec)         # the radius is always positive
+        ref_to_shell_z = ref_to_shell_z * direction         # ref_to_shell_z is positive on the scaling side (right/left)
+
 
         # calculate the distances in r/z from the scaling center to the shell
         scale_center_to_shell_r = ref_to_shell_r - scale_center_r
@@ -438,32 +437,29 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         # get angles
         omega = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
-        omega += Pi
-
-        if __debug__:
-            log.debug('omega = %s' % FORMAT_DOUBLE % omega)
+        omega += Pi         # TODO not sure why this is necessary
 
         if omega <= scale_angle:
             # shell hits the scaling cylinder on top
             z1_new = min(z1, (ref_to_shell_z - shell_half_length)/SAFETY)
-            r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
+            r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
         else:
             # shell hits the scaling cylinder on the radial side
             r_new = min(r, (ref_to_shell_r - shell_radius)/SAFETY)
-            z1_new = min(z1, z1_function(single1, single2, r0, r_new))
-        z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+            z1_new = min(z1, z1_function(r_new))
+        z2_new = min(z2, z2_function(r_new))
 
 
         # switch the z values in case it's necessary. r doesn't have to be switched.
         r = r_new
-        if direction >= 0.0:
+        if direction == 1:
             z_right = z1_new
             z_left  = z2_new
         else:
             z_right = z2_new
             z_left  = z1_new
 
-        return (r, z_right, z_left)
+        return r, z_right, z_left
 
     def get_radius_to_shell(self, shell, domain_to_scale, r):
         # SphericaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
@@ -472,7 +468,7 @@ def get_radius_to_shell(self, shell, domain_to_scale, r):
         # Do simple distance calculation to cylinder
 
         scale_point = domain_to_scale.center
-        r_new = self.world.distance(shell.shape, scale_point)/SAFETY
+        r_new = domain_to_scale.world.distance(shell.shape, scale_point)/SAFETY
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
@@ -718,6 +714,8 @@ def determine_possible_shell(self, ignore, ignores):
 
     def get_searchradius(self):
         return self.geometrycontainer.get_max_shell_size()
+
+
     # default functions for evaluating z_right/z_left/r after one of parameters changed
     def r_right(self, z_right):
         return self.drdz_right * z_right + self.r0_right
@@ -728,6 +726,39 @@ def r_left(self, z_left):
     def z_left(self, r_left):
         return self.dzdr_left * r_left + self.z0_left
 
+    def get_right_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
+        return self.r0_right, self.z0_right
+    right_scalingcenter = property(get_right_scalingcenter)
+
+    def get_left_scalingcenter(self):
+        # returns the scaling center in the cylindrical coordinates r, z of the shell
+        # Note that we assume cylindrical symmetry
+        # Note also that it is relative to the 'side' (right/left) of the cylinder
+        return self.r0_left, self.z0_left
+    left_scalingcenter = property(get_left_scalingcenter)
+
+    def get_right_scalingangle(self):
+        if self.drdz_right == numpy.inf:
+            right_scaling_angle = Pi/2.0       # atan(infinity) == Pi/2 -> angle is 90 degrees
+        elif self.drdz_right == 0.0:
+            right_scaling_angle = 0.0          # atan(0.0) = 0.0 -> faster
+        else:
+            right_scaling_angle = math.atan(self.drdz_right)
+        return right_scaling_angle
+
+    def get_left_scalingangle(self):
+        if self.drdz_left == numpy.inf:
+            left_scaling_angle = Pi/2.0       # atan(infinity) == Pi/2 -> angle is 90 degrees
+        elif self.drdz_left == 0.0:
+            left_scaling_angle = 0.0          # atan(0.0) = 0.0 -> faster
+        else:
+            left_scaling_angle = math.atan(self.drdz_left)
+        return left_scaling_angle
+
+
     def get_max_dr_dzright_dzleft(self):
         pass    # todo, we should be able to derive this from the scaling parameters and searchpoint
 
@@ -751,6 +782,8 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
         self.z0_left    = self.pid_particle_pair[1].radius
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z   # just copy from structure
@@ -773,24 +806,6 @@ def get_max_dr_dzright_dzleft(self):
         dr = math.sqrt(self.get_searchradius()**2 - dz_right**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
-# TODO?
-    def get_right_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
-        return 0, particle_radius
-
-    def get_left_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
-        return 0, particle_radius 
-
-    def get_right_scalingangle(self):
-        return Pi/2.0
-
-    def get_left_scalingangle(self):
-        return Pi/2.0
 
 #####
 class PlanarSurfacePairtestShell(hasCylindricalShell, Others):

From 8225d28679425259b46f80657a6538f7e311df4d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 14:26:32 +0100
Subject: [PATCH 0508/1541] replaced general Exception by more specific Errors
 to disallow general catching of programming errors

---
 egfrd.py  |  3 ++-
 shells.py | 36 +++++++++++++++++++++---------------
 single.py |  8 ++++----
 3 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1406d3cd..b000445f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -34,6 +34,7 @@
 from constants import *
 from shellcontainer import ShellContainer
 from shells import (
+    testShellError,
     SphericalSingletestShell,
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
@@ -2053,7 +2054,7 @@ def try_pair(self, single1, single2):
             try:
                 testShell = SphericalPairtestShell(single1, single2, single1.structure,
                                                    self.geometrycontainer, self.domains)
-            except Exception as e:
+            except testShellError as e:
                 testShell = None
                 if __debug__:
                     log.debug('%s not formed %s' % \
diff --git a/shells.py b/shells.py
index 5a96b098..b1ed0d4f 100755
--- a/shells.py
+++ b/shells.py
@@ -12,6 +12,12 @@
 
 from utils import *
 
+class ShellmakingError(Exception):
+    pass
+
+class testShellError(Exception):
+    pass
+
 class Others(object):
 
     def __init__(self):
@@ -577,9 +583,9 @@ def determine_possible_shell(self, ignore, ignores):
                 distance += self.pid_particle_pair[1].radius
             radius = min(radius, distance)
             if radius < min_radius:
-                raise Exception('Surface too close to make spherical testshell, '
-                                'surface = %s, distance = %s, testShell = %s' %
-                                (surface, distance, self))
+                raise ShellmakingError('Surface too close to make spherical testshell, '
+                                       'surface = %s, distance = %s, testShell = %s' %
+                                       (surface, distance, self))
 
         # then check the domains
         # TODO first sort the neighbors -> faster to find if we fail
@@ -590,9 +596,9 @@ def determine_possible_shell(self, ignore, ignores):
                 radius = neighbor.get_radius_to_shell(shell_appearance, self, radius)
 
                 if radius < min_radius:
-                    raise Exception('Domain too close to make spherical testshell, '
-                                    'domain = %s, distance = %s, testShell = %s' %
-                                    (neighbor, radius, self))
+                    raise ShellmakingError('Domain too close to make spherical testshell, '
+                                           'domain = %s, distance = %s, testShell = %s' %
+                                           (neighbor, radius, self))
 
         # we calculated a valid radius -> suscess!
         assert radius >= min_radius, 'SphericaltestShell radius smaller than the minimum, radius = %s, min_radius = %s.' % \
@@ -635,9 +641,9 @@ def __init__(self, single1, single2, structure, geometrycontainer, domains):
         try:
             self.radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
                                                         [structure.id])
-        except Exception as e:
-            raise Exception('(SphericalPair). %s' %
-                            (str(e)))
+        except ShellmakingError as e:
+            raise testShellError('(SphericalPair). %s' %
+                                 (str(e)))
 
     def get_min_radius(self):
         # TODO this doesn't really belong in testSimplePair, but is also general for all SimplePairs
@@ -687,9 +693,9 @@ def determine_possible_shell(self, ignore, ignores):
 #        for surface, distance in neighbor_surfaces:
 #            radius = min(radius, distance)     # TODO
 #            if radius < min_radius:
-#                raise Exception('Surface too close to make cylindrical testshell, '
-#                                'surface = %s, distance = %s, testShell = %s' %
-#                                (surface, distance, self))
+#                raise ShellmakingError('Surface too close to make cylindrical testshell, '
+#                                       'surface = %s, distance = %s, testShell = %s' %
+#                                       (surface, distance, self))
 
         # then check the domains
         # TODO first sort the neighbors -> faster to find if we fail
@@ -701,9 +707,9 @@ def determine_possible_shell(self, ignore, ignores):
                                                                                 dr, dz_right, dz_left)
 
                 if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
-                    raise Exception('Domain too close to make cylindrical testshell, '
-                                    'domain = %s, distance = %s, testShell = %s' %
-                                    (neighbor, distance, self))
+                    raise ShellmakingError('Domain too close to make cylindrical testshell, '
+                                           'domain = %s, distance = %s, testShell = %s' %
+                                           (neighbor, distance, self))
 
         # we calculated a valid radius -> suscess!
         assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
diff --git a/single.py b/single.py
index 9f0a7a52..586915f2 100644
--- a/single.py
+++ b/single.py
@@ -16,6 +16,7 @@
     ProtectiveDomain)
 
 from shells import (
+    ShellmakingError,
     hasSphericalShell,
     hasCylindricalShell,
     NonInteractionSingles,
@@ -374,7 +375,7 @@ def create_updated_shell(self, position):
             radius = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
             return self.create_new_shell(position, radius, self.domain_id)
 
-        except Exception as e:
+        except ShellmakingError as e:
             raise Exception('SphericalSingle, create_updated_shell failed: %s' %
                             (str(e)))
 
@@ -458,9 +459,8 @@ def create_updated_shell(self, position):
                                                                              self.testShell.get_orientation_vector(),
                                                                              dr, dz_right, dz_left)            
             return self.create_new_shell(center, radius, half_length, self.domain_id)
-        except Exception as e:
-            raise Exception('SphericalSingle, create_updated_shell failed: %s' %
-                            (str(e)))
+        except ShellmakingError as e:
+            raise Exception('SphericalSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, r):
         # project the vector onto the surface unit vectors to make sure that the coordinates are in the surface

From 1db188597463613aad48f1e700f81a9a13893343 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 14:46:10 +0100
Subject: [PATCH 0509/1541] completing the PlanarSurfacePairtestShell

---
 shells.py | 40 ++++++++++++++++++++++++++--------------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/shells.py b/shells.py
index b1ed0d4f..49018782 100755
--- a/shells.py
+++ b/shells.py
@@ -812,40 +812,52 @@ def get_max_dr_dzright_dzleft(self):
         dr = math.sqrt(self.get_searchradius()**2 - dz_right**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
-
 #####
 class PlanarSurfacePairtestShell(hasCylindricalShell, Others):
 
-    def __init__(self):
+    def __init__(self, single1, single2, structure, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testSimplePair.__init__(self, single1, single2, structure)
+
         # scaling parameters
         self.dzdr_right = 0.0
         self.drdz_right = numpy.inf
         self.r0_right   = 0.0
-        self.z0_right   = max(particle_radius1, particle_radius2)
+        self.z0_right   = max(self.pid_particle_pair1[1].radius, pid_particle_pair2[1].radius)
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
-        self.z0_left    = max(particle_radius1, particle_radius2)
+        self.z0_left    = self.z0_right
+
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
+                                                          [structure.id])
+        except ShellmakingError as e:
+            raise testShellError('(CylindricalPair). %s' %
+                                 (str(e)))
 
     def get_orientation_vector(self):
-        return structure.shape.unit_z
+        return self.structure.shape.unit_z
 
     def get_searchpoint(self):
-        return CoM
+        return self.com
 
     def get_referencepoint(self):
-        return CoM
+        return self.com
 
     def get_min_dr_dzright_dzleft(self):
-        dr, dz_right, dz_left = do_calculation
-        return (dr, dz_right, dz_left)
+        dr = self.get_min_pair_size()
+        dz_right = max(self.pid_particle_pair1[1].radius, pid_particle_pair2[1].radius)
+        dz_left = dz_right
+        return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
-        dr = math.sqrt(geometrycontainer_max**2 - particle_radius**2)
-        dz_right = particle_radius
-        dz_left = particle_radius
-        return (dr, dz_right, dz_left)
-        
+        dz_right = max(self.pid_particle_pair1[1].radius, pid_particle_pair2[1].radius)
+        dz_left = dz_right
+        dr = math.sqrt(self.get_searchradius()**2 - dz_right**2) # stay within the searchradius
+        return dr, dz_right, dz_left
+
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
 

From b1fdb136abc7cb1d3a1d7d9fe3ea965003c3913a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 14:54:29 +0100
Subject: [PATCH 0510/1541] moved the minimal 'size' of a simplePair to
 simplePair. Separate pair classes will reinterpret the 'size'

---
 shells.py | 52 ++++++++++++++++++++++++++--------------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/shells.py b/shells.py
index 49018782..63e7f9b2 100755
--- a/shells.py
+++ b/shells.py
@@ -131,6 +131,31 @@ def do_transform(self):
 
         return com, iv
 
+    def get_min_pair_size(self):
+        # TODO Is this assert here ok?
+        assert self.r0 >= self.sigma, \
+            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
+            (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma))
+
+        D1 = self.pid_particle_pair1[1].D
+        D2 = self.pid_particle_pair2[1].D
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+
+        dist_from_com1 = self.r0 * D1 / self.D_tot      # particle distance from CoM
+        dist_from_com2 = self.r0 * D2 / self.D_tot
+        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
+        iv_shell_size2 = dist_from_com2 + radius2
+
+        # also fix the minimum shellsize for the CoM domain
+        com_shell_size = max(radius1, radius2)
+
+        # calculate total radii including the margin for the burst volume for the particles
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (self.SINGLE_SHELL_FACTOR),
+                         iv_shell_size2 + com_shell_size + radius2 * (self.SINGLE_SHELL_FACTOR))
+
+        return shell_size
+
 ##################################
 class hasShell(object):
 
@@ -646,32 +671,7 @@ def __init__(self, single1, single2, structure, geometrycontainer, domains):
                                  (str(e)))
 
     def get_min_radius(self):
-        # TODO this doesn't really belong in testSimplePair, but is also general for all SimplePairs
-
-        # TODO Is this assert here ok?
-        assert self.r0 >= self.sigma, \
-            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
-            (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma))
-
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-
-        dist_from_com1 = self.r0 * D1 / self.D_tot      # particle distance from CoM
-        dist_from_com2 = self.r0 * D2 / self.D_tot
-        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
-        iv_shell_size2 = dist_from_com2 + radius2
-
-        # also fix the minimum shellsize for the CoM domain
-        com_shell_size = max(radius1, radius2)
-
-        # calculate total radii including the margin for the burst volume for the particles
-        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (self.SINGLE_SHELL_FACTOR),
-                         iv_shell_size2 + com_shell_size + radius2 * (self.SINGLE_SHELL_FACTOR))
-
-        return shell_size
-
+        return self.get_min_pair_size()
 
 ##########################
 class CylindricaltestShell(testShell):

From ef32b88bd518fcfde1362776b00c6a038a257094 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 15:32:13 +0100
Subject: [PATCH 0511/1541] fixed error messages and small movement of
 initialization

---
 shells.py | 11 ++++++-----
 single.py |  2 +-
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/shells.py b/shells.py
index 63e7f9b2..fed879e6 100755
--- a/shells.py
+++ b/shells.py
@@ -775,10 +775,6 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
-        self.dz_right = self.pid_particle_pair[1].radius
-        self.dz_left  = self.pid_particle_pair[1].radius
-        self.dr       = self.pid_particle_pair[1].radius
-
         # scaling parameters
         self.dzdr_right = 0.0
         self.drdz_right = numpy.inf
@@ -791,6 +787,11 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.right_scalingangle = self.get_right_scalingangle()
         self.left_scalingangle  = self.get_left_scalingangle()
 
+        # sizing up the shell to a zero shell
+        self.dz_right = self.pid_particle_pair[1].radius
+        self.dz_left  = self.pid_particle_pair[1].radius
+        self.dr       = self.pid_particle_pair[1].radius
+
     def get_orientation_vector(self):
         return self.structure.shape.unit_z   # just copy from structure
 
@@ -834,7 +835,7 @@ def __init__(self, single1, single2, structure, geometrycontainer, domains):
                             self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
                                                           [structure.id])
         except ShellmakingError as e:
-            raise testShellError('(CylindricalPair). %s' %
+            raise testShellError('(PlanarSurfacePair). %s' %
                                  (str(e)))
 
     def get_orientation_vector(self):
diff --git a/single.py b/single.py
index 586915f2..d6e90338 100644
--- a/single.py
+++ b/single.py
@@ -460,7 +460,7 @@ def create_updated_shell(self, position):
                                                                              dr, dz_right, dz_left)            
             return self.create_new_shell(center, radius, half_length, self.domain_id)
         except ShellmakingError as e:
-            raise Exception('SphericalSingle, create_updated_shell failed: %s' % str(e) )
+            raise Exception('PlanarSurfaceSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, r):
         # project the vector onto the surface unit vectors to make sure that the coordinates are in the surface

From 8d9c44a597fa4a9c536834807bc9ee6b689d6c38 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 15:34:02 +0100
Subject: [PATCH 0512/1541] extended switching functions for selecting proper
 testPair and Pair domains

---
 egfrd.py | 29 ++++++++++++++++++++++-------
 1 file changed, 22 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b000445f..7aeb28ff 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -38,6 +38,7 @@
     SphericalSingletestShell,
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
+    PlanarSurfacePairtestShell,
     )
 
 import logging
@@ -54,24 +55,39 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure,
         # first make the test shell
         testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return SphericalSingle(domain_id, shell_id, testSingle, rt)
-    elif isinstance(structure, CylindricalSurface):
-        testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
-        return CylindricalSurfaceSingle(domain_id, shell_id, testSingle, rt)
     elif isinstance(structure, PlanarSurface):
         testSingle = PlanarSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return PlanarSurfaceSingle(domain_id, shell_id, testSingle, rt)
+    elif isinstance(structure, CylindricalSurface):
+        testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+        return CylindricalSurfaceSingle(domain_id, shell_id, testSingle, rt)
 
 
 def create_default_pair(domain_id, shell_id, testShell, rrs):
     if   isinstance(testShell, SphericalPairtestShell):
         return SphericalPair          (domain_id, shell_id, testShell, rrs)
-    elif isinstance(testShell, CylindricalSurfacePairtestShell):
-        return CylindricalSurfacePair (domain_id, shell_id, testShell, rrs)
     elif isinstance(testShell, PlanarSurfacePairtestShell):
         return PlanarSurfacePair      (domain_id, shell_id, testShell, rrs)
+    elif isinstance(testShell, CylindricalSurfacePairtestShell):
+        return CylindricalSurfacePair (domain_id, shell_id, testShell, rrs)
     elif isinstance(testShell, MixedPair3D2DtestShell):
         return MixedPair3D2D          (domain_id, shell_id, testShell, rrs)
 
+def try_default_testpair(single1, single2, self.geometrycontainer, self.domains):
+    if single1.structure == single2.structure:
+        if isinstance(single1.structure, CuboidalRegion):
+            return SphericalPairtestShell(single1, single2, single1.structure, self.geometrycontainer, self.domains)
+        elif isinstance(single1.structure, PlanarSurface):
+            return PlanarSurfacePairtestShell(single1, single2, single1.structure, self.geometrycontainer, self.domains)
+        elif isinstance(single1.structure, CylindricalSurface):
+            return CylindricalSurfacePairtestShell(single1, single2, single1.structure, self.geometrycontainer, self.domains)
+    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+        return MixedPair3D2DtestShell(single1, single2, self.geometrycontainer, self.domains) 
+    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+        return MixedPair3D2DtestShell(single2, single1, self.geometrycontainer, self.domains)
+    else:
+        raise testShellError('(MixedPair). combination of structure not supported')
+        
 
 class DomainEvent(Event):
     __slot__ = ['data']
@@ -2052,8 +2068,7 @@ def try_pair(self, single1, single2):
             # particles are on the same structure
 
             try:
-                testShell = SphericalPairtestShell(single1, single2, single1.structure,
-                                                   self.geometrycontainer, self.domains)
+                testShell = try_default_testpair(single1, single2, self.geometrycontainer, self.domains)
             except testShellError as e:
                 testShell = None
                 if __debug__:

From 2df1a547e90ee9d58d24e640fe7b78f5def1d50c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 15:48:56 +0100
Subject: [PATCH 0513/1541] structure doesn't need to be passed to Pair
 constructor explicitly. Also fixed number of typos

---
 egfrd.py  |  6 +++---
 shells.py | 30 ++++++++++++++++--------------
 2 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7aeb28ff..fd8903df 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -76,11 +76,11 @@ def create_default_pair(domain_id, shell_id, testShell, rrs):
 def try_default_testpair(single1, single2, self.geometrycontainer, self.domains):
     if single1.structure == single2.structure:
         if isinstance(single1.structure, CuboidalRegion):
-            return SphericalPairtestShell(single1, single2, single1.structure, self.geometrycontainer, self.domains)
+            return SphericalPairtestShell(single1, single2, self.geometrycontainer, self.domains)
         elif isinstance(single1.structure, PlanarSurface):
-            return PlanarSurfacePairtestShell(single1, single2, single1.structure, self.geometrycontainer, self.domains)
+            return PlanarSurfacePairtestShell(single1, single2, self.geometrycontainer, self.domains)
         elif isinstance(single1.structure, CylindricalSurface):
-            return CylindricalSurfacePairtestShell(single1, single2, single1.structure, self.geometrycontainer, self.domains)
+            return CylindricalSurfacePairtestShell(single1, single2, self.geometrycontainer, self.domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
         return MixedPair3D2DtestShell(single1, single2, self.geometrycontainer, self.domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
diff --git a/shells.py b/shells.py
index fed879e6..1d1b1aaf 100755
--- a/shells.py
+++ b/shells.py
@@ -72,6 +72,7 @@ def __init__(self, single, structure, surface):
 class testPair(Others):
     def __init__(self, single1, single2):
 
+        # assert both reset
         assert single1.dt == 0.0
         assert single2.dt == 0.0
 
@@ -90,10 +91,11 @@ def do_transform(self):
         pass        # overloaded later
 
 class testSimplePair(testPair):
-    def __init__(self, single1, single2, structure):
+    def __init__(self, single1, single2):
 
+        # simple pairs are pairs of particles on the same structure
         assert single1.structure == single2.structure
-        self.structure = structure
+        self.structure = single1.structure
 
         testPair.__init__(self, single1, single2)
 
@@ -658,14 +660,14 @@ def get_min_radius(self):
 #####
 class SphericalPairtestShell(SphericaltestShell, testSimplePair):
 
-    def __init__(self, single1, single2, structure, geometrycontainer, domains):
+    def __init__(self, single1, single2, geometrycontainer, domains):
         SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testSimplePair.__init__(self, single1, single2, structure)
+        testSimplePair.__init__(self, single1, single2)
 
         self.center = self.com
         try:
-            self.radius = self.determine_possible_shell([single1.domain_id, single2.domain_id],
-                                                        [structure.id])
+            self.radius = self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
+                                                        [self.structure.id])
         except ShellmakingError as e:
             raise testShellError('(SphericalPair). %s' %
                                  (str(e)))
@@ -814,17 +816,17 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
 #####
-class PlanarSurfacePairtestShell(hasCylindricalShell, Others):
+class PlanarSurfacePairtestShell(CylindricaltestShell, testSimplePair):
 
-    def __init__(self, single1, single2, structure, geometrycontainer, domains):
+    def __init__(self, single1, single2, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testSimplePair.__init__(self, single1, single2, structure)
+        testSimplePair.__init__(self, single1, single2)
 
         # scaling parameters
         self.dzdr_right = 0.0
         self.drdz_right = numpy.inf
         self.r0_right   = 0.0
-        self.z0_right   = max(self.pid_particle_pair1[1].radius, pid_particle_pair2[1].radius)
+        self.z0_right   = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
@@ -833,7 +835,7 @@ def __init__(self, single1, single2, structure, geometrycontainer, domains):
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
-                                                          [structure.id])
+                                                          [self.structure.id])
         except ShellmakingError as e:
             raise testShellError('(PlanarSurfacePair). %s' %
                                  (str(e)))
@@ -849,18 +851,18 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         dr = self.get_min_pair_size()
-        dz_right = max(self.pid_particle_pair1[1].radius, pid_particle_pair2[1].radius)
+        dz_right = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         dz_left = dz_right
         return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
-        dz_right = max(self.pid_particle_pair1[1].radius, pid_particle_pair2[1].radius)
+        dz_right = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         dz_left = dz_right
         dr = math.sqrt(self.get_searchradius()**2 - dz_right**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
 #####
-class CylindricalSurfaceSingletestShell(CylindricaltestShell, NonInteractionSingles):
+class CylindricalSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
 
     def __init__(self):
         # scaling parameters

From f970b54d3158d5f5dd5e458f95fb2f383cbdbd69 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 16:46:51 +0100
Subject: [PATCH 0514/1541] fixed silly typos

---
 egfrd.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fd8903df..2c51732f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -73,18 +73,18 @@ def create_default_pair(domain_id, shell_id, testShell, rrs):
     elif isinstance(testShell, MixedPair3D2DtestShell):
         return MixedPair3D2D          (domain_id, shell_id, testShell, rrs)
 
-def try_default_testpair(single1, single2, self.geometrycontainer, self.domains):
+def try_default_testpair(single1, single2, geometrycontainer, domains):
     if single1.structure == single2.structure:
         if isinstance(single1.structure, CuboidalRegion):
-            return SphericalPairtestShell(single1, single2, self.geometrycontainer, self.domains)
+            return SphericalPairtestShell(single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, PlanarSurface):
-            return PlanarSurfacePairtestShell(single1, single2, self.geometrycontainer, self.domains)
+            return PlanarSurfacePairtestShell(single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, CylindricalSurface):
-            return CylindricalSurfacePairtestShell(single1, single2, self.geometrycontainer, self.domains)
+            return CylindricalSurfacePairtestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        return MixedPair3D2DtestShell(single1, single2, self.geometrycontainer, self.domains) 
+        return MixedPair3D2DtestShell(single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        return MixedPair3D2DtestShell(single2, single1, self.geometrycontainer, self.domains)
+        return MixedPair3D2DtestShell(single2, single1, geometrycontainer, domains)
     else:
         raise testShellError('(MixedPair). combination of structure not supported')
         

From 971b69106b6f24b8a5282ff63894d9d725f46dba Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 17:15:43 +0100
Subject: [PATCH 0515/1541] changed order of initialization of superclasses for
 Pairs (and Singles) + adoptation of new shell code for PlanarSurfacePair

---
 domain.py |   2 +-
 pair.py   | 101 ++++++++++++++++++++++++++++++------------------------
 shells.py |   8 ++---
 single.py |   5 +--
 4 files changed, 65 insertions(+), 51 deletions(-)

diff --git a/domain.py b/domain.py
index 78a3b0b6..bab62b66 100644
--- a/domain.py
+++ b/domain.py
@@ -73,7 +73,7 @@ def __init__(self, domain_id):
         Domain.__init__(self, domain_id)
 
         self.shell_id = None
-        self.shell = None
+#        self.shell = None
         self.num_shells = 1             # all protective domains have only one shell
 
     def get_shell_id_shell_pair(self):
diff --git a/pair.py b/pair.py
index ee90ad84..c0b1074b 100644
--- a/pair.py
+++ b/pair.py
@@ -46,20 +46,23 @@ class Pair(ProtectiveDomain):
     # 5.6: ~1e-8, 6.0: ~1e-9
     CUTOFF_FACTOR = 5.6
 
-    def __init__(self, domain_id, single1, single2, shell_id, r0, 
-                 rrs):
+#    def __init__(self, domain_id, single1, single2, shell_id, r0, 
+#                 rrs):
+    def __init__(self, domain_id, shell_id, testShell, rrs):
         ProtectiveDomain.__init__(self, domain_id)
 
+        assert self.testShell       # assume that the testShell exists
+
         self.multiplicity = 2
 
-        self.single1 = single1
-        self.single2 = single2 
-        self.pid_particle_pair1 = single1.pid_particle_pair
-        self.pid_particle_pair2 = single2.pid_particle_pair
+        self.single1 = testShell.single1
+        self.single2 = testShell.single2 
+        self.pid_particle_pair1 = testShell.pid_particle_pair1
+        self.pid_particle_pair2 = testShell.pid_particle_pair2
 
         self.interparticle_rrs = rrs
         self.interparticle_ktot = self.calc_ktot(rrs)
-        self.r0 = r0
+        self.r0 = testShell.r0
 
         self.shell_id = shell_id
 
@@ -314,16 +317,15 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
             return closest_distance/SAFETY
 
 
-    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-                      r0, shell_size, rrs, structure):
-#    def __init__(self, domain_id, shell_id, testShell, rrs) # TODO constructor above does not support this yet
-        Pair.__init__(self, domain_id, single1, single2, shell_id,
-                      r0, rrs)
+#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
+#                      r0, shell_size, rrs, structure):
+    def __init__(self, domain_id, shell_id, testShell, rrs):
+        Pair.__init__(self, domain_id, shell_id, testShell, rrs)
 
-        self.structure = structure              # structure on which both particles live
-#        self.structure = testShell.structure
+        self.structure = self.testShell.structure              # structure on which both particles live
 
-        self.a_R, self.a_r = self.determine_radii(r0, shell_size)
+        shell_size = self.get_shell_size()                  # FIXME
+        self.a_R, self.a_r = self.determine_radii(self.r0, shell_size)
         # set the radii of the inner domains as a function of the outer protective domain
 
 # this can go
@@ -368,8 +370,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
 
         return pos1, pos2
 
-#    def get_shell_size(self):
-#        return self.shell.shape.radius
+    def get_shell_size(self):
+        return self.shell.shape.radius
 
     def determine_radii(self, r0, shell_size):
         """Determine a_r and a_R from the size of the protective domain.
@@ -464,17 +466,17 @@ class SphericalPair(SimplePair, Others, hasSphericalShell):
 #    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
 #                 r0, shell_size, rrs, structure):
     def __init__(self, domain_id, shell_id, testShell, rrs):
-        single1 = testShell.single1
-        single2 = testShell.single2
-        structure = testShell.structure
-        shell_center = testShell.center
-        shell_size = testShell.radius  # TODO this should be removed
-        r0 = testShell.r0        # TODO this should be removed
+#        single1 = testShell.single1
+#        single2 = testShell.single2
+#        structure = testShell.structure
+#        shell_center = testShell.center
+#        shell_size = testShell.radius  # TODO this should be removed
+#        r0 = testShell.r0        # TODO this should be removed
 
-        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
-                      r0, shell_size, rrs, structure)
-#        SimplePair.__init__(self, domain_id, shell_id, testShell, rrs) # TODO constructor above does not support this yet
-        hasSphericalShell.__init__(self, testShell)
+#        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
+#                      r0, shell_size, rrs, structure)
+        hasSphericalShell.__init__(self, testShell, domain_id)
+        SimplePair.__init__(self, domain_id, shell_id, testShell, rrs) # Always initialize after hasSphericalShell
 
 
     def com_greens_function(self):
@@ -572,15 +574,26 @@ def __str__(self):
         return 'Spherical' + Pair.__str__(self)
 
 
-class PlanarSurfacePair(SimplePair):
+#class PlanarSurfacePair(SimplePair):
+class PlanarSurfacePair(SimplePair, Others, hasCylindricalShell):
     """2 Particles inside a (cylindrical) shell on a PlanarSurface. 
     (Hockey pucks).
 
     """
-    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-                 r0, shell_size, rrs, structure):
-        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
-                      r0, shell_size, rrs, structure)
+    def __init__(self, domain_id, shell_id, testShell, rrs):
+#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
+#                 r0, shell_size, rrs, structure):
+#        single1 = testShell.single1
+#        single2 = testShell.single2
+#        structure = testShell.structure
+#        shell_center = testShell.center
+#        shell_size = testShell.radius  # TODO this should be removed
+#        r0 = testShell.r0        # TODO this should be removed
+
+#        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
+#                      r0, shell_size, rrs, structure)
+        hasCylindricalShell.__init__(self, testShell, domain_id)
+        SimplePair.__init__(self, domain_id, shell_id, testShell, rrs)
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
@@ -589,18 +602,18 @@ def iv_greens_function(self, r0):
         return GreensFunction2DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                       self.sigma, self.a_r)
 
-    def create_new_shell(self, position, radius, domain_id):
-        # The half_length (thickness/2) of a hockey puck is not more 
-        # than it has to be (namely the radius of the particle), so if 
-        # the particle undergoes an unbinding reaction we still have to 
-        # clear the target volume and the move may be rejected (NoSpace 
-        # error).
-        orientation = crossproduct(self.structure.shape.unit_x,
-                                   self.structure.shape.unit_y)
-        half_length = max(self.pid_particle_pair1[1].radius,
-                          self.pid_particle_pair2[1].radius)
-        return CylindricalShell(domain_id, Cylinder(position, radius, 
-                                                    orientation, half_length))
+#    def create_new_shell(self, position, radius, domain_id):
+#        # The half_length (thickness/2) of a hockey puck is not more 
+#        # than it has to be (namely the radius of the particle), so if 
+#        # the particle undergoes an unbinding reaction we still have to 
+#        # clear the target volume and the move may be rejected (NoSpace 
+#        # error).
+#        orientation = crossproduct(self.structure.shape.unit_x,
+#                                   self.structure.shape.unit_y)
+#        half_length = max(self.pid_particle_pair1[1].radius,
+#                          self.pid_particle_pair2[1].radius)
+#        return CylindricalShell(domain_id, Cylinder(position, radius, 
+#                                                    orientation, half_length))
 
     def get_shell_direction(self):
         return self.shell.shape.unit_z
diff --git a/shells.py b/shells.py
index 1d1b1aaf..69a7f4f5 100755
--- a/shells.py
+++ b/shells.py
@@ -171,7 +171,7 @@ def __init__(self, testShell):
 class hasSphericalShell(hasShell):
 # The testShell is now converted into smt that we can use in the domain instance
 
-    def __init__(self, sphericaltestShell):
+    def __init__(self, sphericaltestShell, domain_id):
     # Note that the Multi should not call __init__ because we don't want to initialize the shell
 
         hasShell.__init__(self, sphericaltestShell)
@@ -181,7 +181,7 @@ def __init__(self, sphericaltestShell):
         self.shell_radius = sphericaltestShell.radius
         self.shell = self.create_new_shell(self.shell_center,
                                            self.shell_radius,
-                                           self.domain_id)
+                                           domain_id)
 
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
@@ -382,7 +382,7 @@ class Multi(hasSphericalShell, Others):
 #########################
 class hasCylindricalShell(hasShell):
 
-    def __init__(self, cylindricaltestShell):
+    def __init__(self, cylindricaltestShell, domain_id):
 
         assert isinstance(cylindricaltestShell, CylindricaltestShell)
 
@@ -400,7 +400,7 @@ def __init__(self, cylindricaltestShell):
         self.shell = self.create_new_shell(self.shell_center,
                                            self.shell_radius,
                                            self.shell_half_length,
-                                           self.domain_id)
+                                           domain_id)
 
     @ classmethod
     def r_zright_zleft_to_r_center_hl(cls, referencepoint, orientation_vector, dr, dz_right, dz_left):
diff --git a/single.py b/single.py
index d6e90338..05d79290 100644
--- a/single.py
+++ b/single.py
@@ -337,9 +337,10 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         # -> change constructor
         pid_particle_pair = testShell.pid_particle_pair
         structure = testShell.structure
+
+        hasSphericalShell.__init__(self, testShell, domain_id)           # here also the shell is created
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
                                       shell_id, reactionrules, structure)
-        hasSphericalShell.__init__(self, testShell)                         # here also the shell is created
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
@@ -403,9 +404,9 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         pid_particle_pair = testShell.pid_particle_pair
         structure = testShell.structure
+        hasCylindricalShell.__init__(self, testShell, domain_id)
         NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
                                       shell_id, reactionrules, structure)
-        hasCylindricalShell.__init__(self, testShell)
 
     def greens_function(self):
         return GreensFunction2DAbsSym(self.D,

From 840b62ae36a82f85c6f7f32b38ec99355980888a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 18:04:38 +0100
Subject: [PATCH 0516/1541] added list of exportable classes (right?)

---
 shells.py | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/shells.py b/shells.py
index 69a7f4f5..cefa1001 100755
--- a/shells.py
+++ b/shells.py
@@ -12,6 +12,29 @@
 
 from utils import *
 
+__all__ = [
+    'ShellmakingError',
+    'testShellError',
+    'Others',
+    'NonInteractionSingles',
+    'testSingle',
+    'testNonInteractionSingle',
+    'testInteractionSingle',
+    'testPair',
+    'testSimplePair',
+    'hasSphericalShell',
+    'hasCylindricalShell',   
+    'SphericalSingletestShell',
+    'SphericalPairtestShell',
+    'PlanarSurfaceSingletestShell',
+    'PlanarSurfacePairtestShell',
+    'CylindricalSurfaceSingletestShell',
+    'CylindricalSurfacePairtestShell',
+    'PlanarSurfaceInteractiontestShell',
+    'CylindricalSurfaceInteractiontestShell',
+    'MixedPair3D2DtestShell',
+    ]
+
 class ShellmakingError(Exception):
     pass
 

From b057148578a565b264801e4a3c87875b1039a156 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 23 Dec 2011 18:09:15 +0100
Subject: [PATCH 0517/1541] changed parameters passed on to parent constructors
 (initializors) from the NonInteractionSingle domains and Pairs

---
 domain.py |  4 +--
 pair.py   | 34 +++++++++++-----------
 single.py | 85 ++++++++++++++++++++++++++++++++-----------------------
 3 files changed, 67 insertions(+), 56 deletions(-)

diff --git a/domain.py b/domain.py
index bab62b66..33f2608e 100644
--- a/domain.py
+++ b/domain.py
@@ -69,10 +69,10 @@ class ProtectiveDomain(Domain):
 # which have only one shell. Multi's on the other hand, have multiple shells and can still leave
 # their shell within a timestep, breaking the principle of a Protective Domain
 
-    def __init__(self, domain_id):
+    def __init__(self, domain_id, shell_id):
         Domain.__init__(self, domain_id)
 
-        self.shell_id = None
+        self.shell_id = shell_id
 #        self.shell = None
         self.num_shells = 1             # all protective domains have only one shell
 
diff --git a/pair.py b/pair.py
index c0b1074b..a11a8dc3 100644
--- a/pair.py
+++ b/pair.py
@@ -11,11 +11,7 @@
     InteractionSingle)
 from multi import (
     Multi)
-from shells import (
-    hasSphericalShell,
-    hasCylindricalShell,
-    Others,
-    )
+from shells import *
 
 
 __all__ = [
@@ -48,23 +44,23 @@ class Pair(ProtectiveDomain):
 
 #    def __init__(self, domain_id, single1, single2, shell_id, r0, 
 #                 rrs):
-    def __init__(self, domain_id, shell_id, testShell, rrs):
-        ProtectiveDomain.__init__(self, domain_id)
+    def __init__(self, domain_id, shell_id, rrs):
+        ProtectiveDomain.__init__(self, domain_id, shell_id)
 
         assert self.testShell       # assume that the testShell exists
-
+        assert isinstance(self.testShell, testPair)
         self.multiplicity = 2
 
-        self.single1 = testShell.single1
-        self.single2 = testShell.single2 
-        self.pid_particle_pair1 = testShell.pid_particle_pair1
-        self.pid_particle_pair2 = testShell.pid_particle_pair2
+        self.single1 = self.testShell.single1
+        self.single2 = self.testShell.single2 
+        self.pid_particle_pair1 = self.testShell.pid_particle_pair1
+        self.pid_particle_pair2 = self.testShell.pid_particle_pair2
 
         self.interparticle_rrs = rrs
         self.interparticle_ktot = self.calc_ktot(rrs)
-        self.r0 = testShell.r0
+        self.r0 = self.testShell.r0
 
-        self.shell_id = shell_id
+#        self.shell_id = shell_id
 
     def __del__(self):
         if __debug__:
@@ -319,9 +315,11 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
 
 #    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
 #                      r0, shell_size, rrs, structure):
-    def __init__(self, domain_id, shell_id, testShell, rrs):
-        Pair.__init__(self, domain_id, shell_id, testShell, rrs)
+    def __init__(self, domain_id, shell_id, rrs):
+        Pair.__init__(self, domain_id, shell_id, rrs)
 
+        assert self.testShell
+        assert isinstance(self.testShell, testSimplePair)
         self.structure = self.testShell.structure              # structure on which both particles live
 
         shell_size = self.get_shell_size()                  # FIXME
@@ -476,7 +474,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 #        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
 #                      r0, shell_size, rrs, structure)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        SimplePair.__init__(self, domain_id, shell_id, testShell, rrs) # Always initialize after hasSphericalShell
+        SimplePair.__init__(self, domain_id, shell_id, rrs) # Always initialize after hasSphericalShell
 
 
     def com_greens_function(self):
@@ -593,7 +591,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 #        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
 #                      r0, shell_size, rrs, structure)
         hasCylindricalShell.__init__(self, testShell, domain_id)
-        SimplePair.__init__(self, domain_id, shell_id, testShell, rrs)
+        SimplePair.__init__(self, domain_id, shell_id, rrs)
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
diff --git a/single.py b/single.py
index 05d79290..1c899ae8 100644
--- a/single.py
+++ b/single.py
@@ -15,13 +15,7 @@
     Domain,
     ProtectiveDomain)
 
-from shells import (
-    ShellmakingError,
-    hasSphericalShell,
-    hasCylindricalShell,
-    NonInteractionSingles,
-    Others,
-    )
+from shells import *
 
 __all__ = [
     'CylindricalSurfaceSingle',
@@ -45,15 +39,18 @@ class Single(ProtectiveDomain):
     specified.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
-        ProtectiveDomain.__init__(self, domain_id)
+#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
+    def __init__(self, domain_id, shell_id, reactionrules):
+        ProtectiveDomain.__init__(self, domain_id, shell_id)
 
         self.multiplicity = 1                           # all singles have only one particle
 
-        self.pid_particle_pair = pid_particle_pair      # the particle in the single
-        self.structure = structure                      # the structure in/on which the particle lives
-#        self.pid_particle_pair = testShell.pid_particle_pair      # the particle in the single
-#        self.structure = testShell.structure                      # the structure in/on which the particle lives
+#        self.pid_particle_pair = pid_particle_pair      # the particle in the single
+#        self.structure = structure                      # the structure in/on which the particle lives
+        assert self.testShell
+        assert isinstance(self.testShell, testSingle)
+        self.pid_particle_pair = self.testShell.pid_particle_pair      # the particle in the single
+        self.structure = self.testShell.structure                      # the structure in/on which the particle lives
 
         self.reactionrules = reactionrules              # the reaction rules for mono molecular reactions
         self.rrule = None                               # the reaction rule of the actual reaction (property reactionrule)
@@ -156,13 +153,16 @@ class NonInteractionSingle(Single):
         * Decay process of the particle
 
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-                 structure):
-        Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
-                        structure)
+#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
+#                 structure):
+    def __init__(self, domain_id, shell_id, reactionrules):
+#        Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
+#                        structure)
+
+        Single.__init__(self, domain_id, shell_id, reactionrules)
 
         # Create shell.
-        self.shell_id = shell_id
+#        self.shell_id = shell_id
 #        self.shell = self.create_new_shell(pid_particle_pair[1].position,
 #                                      pid_particle_pair[1].radius, domain_id)
 
@@ -335,12 +335,15 @@ class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalS
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
         # This should also be moved to single, since it's the same for all NonInteractionSingles
         # -> change constructor
-        pid_particle_pair = testShell.pid_particle_pair
-        structure = testShell.structure
+#        pid_particle_pair = testShell.pid_particle_pair
+#        structure = testShell.structure
+
+        assert isinstance(testShell, SphericalSingletestShell)
 
         hasSphericalShell.__init__(self, testShell, domain_id)           # here also the shell is created
-        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactionrules, structure)
+#        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
+#                                      shell_id, reactionrules, structure)
+        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
@@ -402,11 +405,12 @@ class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylind
 #                 structure):
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
-        pid_particle_pair = testShell.pid_particle_pair
-        structure = testShell.structure
+#        pid_particle_pair = testShell.pid_particle_pair
+#        structure = testShell.structure
         hasCylindricalShell.__init__(self, testShell, domain_id)
-        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactionrules, structure)
+#        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
+#                                      shell_id, reactionrules, structure)
+        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
     def greens_function(self):
         return GreensFunction2DAbsSym(self.D,
@@ -481,10 +485,14 @@ class CylindricalSurfaceSingle(NonInteractionSingle):
         * Initial position: z = 0.
         * Selected randomly when drawing displacement vector: none.
     """
-    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-                 structure):
-        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-                                      shell_id, reactionrules, structure)
+#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
+#                 structure):
+#        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
+#                                      shell_id, reactionrules, structure)
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+
+        hasCylindricalShell.__init__(self, testShell, domain_id)
+        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
     def getv(self):
         return self.pid_particle_pair[1].v
@@ -552,17 +560,22 @@ class InteractionSingle(Single):
         * Diffusion in the direction that is normal the the direction of interaction
         * Decay of the particle into a different or no particle
     """
-    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell_id,   
-                 interactionrules, surface):
+#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell_id,   
+#                 interactionrules, surface):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
-        Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
-                        structure)
+        hasCylindricalShell.__init__(self, testShell, domain_id)
+
+        assert self.testShell
+        assert isinstance(self.testShell, testInteractionSingle)
+        Single.__init__(self, domain_id, shell_id, reactionrules)
 
-        self.shell_id = shell_id
+#        self.shell_id = shell_id
         self.interactionrules = interactionrules        # the surface interaction 'reactions'
         self.intrule = None
         self.interaction_ktot = self.calc_ktot(interactionrules)
-        self.surface = surface                          # The surface with which the particle is
+
+        self.surface = self.testShell.surface           # The surface with which the particle is
                                                         # trying to interact
 
     def get_interaction_rule(self):

From 0d8717e65d99088b96f43bd4bc0f0678ec37e0f2 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 2 Jan 2012 09:31:16 +0100
Subject: [PATCH 0518/1541] Extended packages used in greens_functions doc.

---
 doc/greens_functions/tex/include/include.tex | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/doc/greens_functions/tex/include/include.tex b/doc/greens_functions/tex/include/include.tex
index 0f85f0ee..dd5c30e0 100644
--- a/doc/greens_functions/tex/include/include.tex
+++ b/doc/greens_functions/tex/include/include.tex
@@ -9,6 +9,8 @@
 \usepackage{graphicx}
 \usepackage{algorithmic}
 \usepackage{algorithm}
+\usepackage{amssymb}
+\usepackage{amsmath}
 
 \hbadness 10000  % Disable underfull hbox warnings.
 

From d72a8c3da8dd554aee9881aef0d6183f1af2860c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 2 Jan 2012 15:05:07 +0100
Subject: [PATCH 0519/1541] implemented the testShell for the
 CylindricalSurfaceSingle + small tweaks/changes

---
 egfrd.py  |  6 ++++-
 shells.py | 62 +++++++++++++++++++++----------------------
 single.py | 78 +++++++++++++++++++++++++++++++++++++++----------------
 3 files changed, 90 insertions(+), 56 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2c51732f..bdf9dc62 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -39,6 +39,8 @@
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
     PlanarSurfacePairtestShell,
+    CylindricalSurfaceSingletestShell,
+    CylindricalSurfacePairtestShell,
     )
 
 import logging
@@ -56,9 +58,11 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure,
         testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return SphericalSingle(domain_id, shell_id, testSingle, rt)
     elif isinstance(structure, PlanarSurface):
+        # first make the test shell
         testSingle = PlanarSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return PlanarSurfaceSingle(domain_id, shell_id, testSingle, rt)
     elif isinstance(structure, CylindricalSurface):
+        # first make the test shell
         testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return CylindricalSurfaceSingle(domain_id, shell_id, testSingle, rt)
 
@@ -1430,7 +1434,7 @@ def update_single(self, single):
 
         singlepos = single.pid_particle_pair[1].position
         new_shell = single.create_updated_shell(singlepos)
-        assert new_shell, 'single.update_radius() returned None.'
+        assert new_shell, 'single.create_updated_shell() returned None.'
 
         if __debug__:
             log.info('update_single: single: %s, new_shell = %s' % \
diff --git a/shells.py b/shells.py
index cefa1001..23a3b44c 100755
--- a/shells.py
+++ b/shells.py
@@ -197,6 +197,8 @@ class hasSphericalShell(hasShell):
     def __init__(self, sphericaltestShell, domain_id):
     # Note that the Multi should not call __init__ because we don't want to initialize the shell
 
+        assert isinstance(sphericaltestShell, SphericaltestShell)
+
         hasShell.__init__(self, sphericaltestShell)
 
         self.testShell = sphericaltestShell
@@ -661,7 +663,7 @@ def get_searchpoint(self):
     def get_searchradius(self):
         return self.geometrycontainer.get_max_shell_size()
     def get_orientation_vector(self):
-#        return unit_vector # much faster and doesn't matter anyway
+#        return unit_vector # TODO much faster and doesn't matter anyway
         return random_vector(1.0)
 
     def get_max_radius(self):
@@ -736,7 +738,7 @@ def determine_possible_shell(self, ignore, ignores):
                                            'domain = %s, distance = %s, testShell = %s' %
                                            (neighbor, distance, self))
 
-        # we calculated a valid radius -> suscess!
+        # we calculated valid dimensions -> success!
         assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
                'CylindricaltestShell dimensions smaller than the minimum, radius = %s, min_radius = %s.' % \
                 (radius, min_radius)
@@ -887,55 +889,49 @@ def get_max_dr_dzright_dzleft(self):
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
 
-    def __init__(self):
+    def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)
+        testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
+
         # scaling parameters
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = particle_radius
+        self.r0_right   = self.pid_particle_pair[1].radius
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = particle_radius
+        self.r0_left    = self.pid_particle_pair[1].radius
         self.z0_left    = 0.0
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+
 
-    def orientation_vector(self):
-        return structure.shape.unit_z   # just copy from structure
+        # sizing up the shell to a zero shell
+        self.dz_right = self.pid_particle_pair[1].radius
+        self.dz_left  = self.pid_particle_pair[1].radius
+        self.dr       = self.pid_particle_pair[1].radius
+
+    def get_orientation_vector(self):
+        return self.structure.shape.unit_z   # just copy from structure
 
     def get_searchpoint(self):
-        return particle_pos
+        return self.pid_particle_pair[1].position
 
     def get_referencepoint(self):
-        return particle_pos
+        return self.pid_particle_pair[1].position
 
     def get_min_dr_dzright_dzleft(self):
-        dr = particle_radius
-        dz_right = particle_radius * MULTI_SHELL_FACTOR
-        dz_left = particle_radius * MULTI_SHELL_FACTOR
-        return (dr, dz_right, dz_left)
+        dr = self.pid_particle_pair[1].radius
+        dz_right = self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+        dz_left = self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+        return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
-        dr = particle_radius
-        dz_right = math.sqrt(geometrycontainer_max**2 - particle_radius**2)
+        dr = self.pid_particle_pair[1].radius
+        dz_right = math.sqrt(self.get_searchradius()**2 - dr**2) # stay within the searchradius
         dz_left = dz_right
-        return (dr, dz_right, dz_left)
-
-    def get_right_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note1: we assume cylindrical symmetry
-        # Note2: it is relative to the 'side' (right/left) of the cylinder
-        # Note3: we assume that the r-axis goes from the center of the cylinder to the
-        #        center of the shell.
-        return self.particle_radius, 0
-
-    def get_left_scalingcenter(self):
-        # same here
-        return self.particle_radius, 0
-
-    def get_right_scalingangle(self):
-        return 0
+        return dr, dz_right, dz_left
 
-    def get_left_scalingangle(self):
-        return 0
 
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
diff --git a/single.py b/single.py
index 1c899ae8..d0ee8324 100644
--- a/single.py
+++ b/single.py
@@ -476,7 +476,8 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
-class CylindricalSurfaceSingle(NonInteractionSingle):
+#class CylindricalSurfaceSingle(NonInteractionSingle):
+class CylindricalSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a CylindricalSurface. 
     (Rods).
 
@@ -498,10 +499,10 @@ def getv(self):
         return self.pid_particle_pair[1].v
     v = property(getv)
 
-    def get_shell_size(self):
-        # Heads up. The cylinder's *half_length*, not radius, 
-        # determines the size in case of a cylindrical surface.
-        return self.shell.shape.half_length
+#    def get_shell_size(self):
+#        # Heads up. The cylinder's *half_length*, not radius, 
+#        # determines the size in case of a cylindrical surface.
+#        return self.shell.shape.half_length
 
     def get_inner_a(self):
         # Here the free coordinate is not the radius of the domain as in the
@@ -514,23 +515,56 @@ def greens_function(self):
         inner_half_length = self.get_inner_a()
         return GreensFunction1DAbsAbs(self.D, self.v, 0.0, -inner_half_length, inner_half_length)
 
-    def create_new_shell(self, position, half_length, domain_id):
-        # The radius of a rod is not more than it has to be (namely the 
-        # radius of the particle), so if the particle undergoes an 
-        # unbinding reaction we still have to clear the target volume 
-        # and the move may be rejected.
-
-        # Note that the calculation of the position of the shell has to make sure that the
-        # coordinates are in the surface
-        unit_z = self.structure.shape.unit_z
-        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
-        pos_z = unit_z * numpy.dot (position, unit_z)
-
-        position = self.structure.shape.position + pos_z
-        radius = self.pid_particle_pair[1].radius
-        orientation = unit_z
-        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
-                                                    orientation, half_length))
+#    def create_new_shell(self, position, half_length, domain_id):
+#        # The radius of a rod is not more than it has to be (namely the 
+#        # radius of the particle), so if the particle undergoes an 
+#        # unbinding reaction we still have to clear the target volume 
+#        # and the move may be rejected.
+#
+#        # Note that the calculation of the position of the shell has to make sure that the
+#        # coordinates are in the surface
+#        unit_z = self.structure.shape.unit_z
+#        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
+#        pos_z = unit_z * numpy.dot (position, unit_z)
+#
+#        position = self.structure.shape.position + pos_z
+#        radius = self.pid_particle_pair[1].radius
+#        orientation = unit_z
+#        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
+#                                                    orientation, half_length))
+
+    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+    def shell_list_for_single(self):
+        min_half_length = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+        if self.shell.shape.half_length < min_half_length:
+            position = self.shell.shape.position
+            radius = self.shell.shape.radius
+            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
+
+    def shell_list_for_other(self):
+        min_half_length = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+        if self.shell.shape.half_length < min_half_length:
+            position = self.shell.shape.position
+            radius = self.shell.shape.radius
+            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
+
+    def create_updated_shell(self, position):
+        # TODO what should we do with the position now?
+        # maybe update the reference_point of the shell before updating the shell
+        try:
+            dr, dz_right, dz_left = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
+                                                                             self.testShell.get_orientation_vector(),
+                                                                             dr, dz_right, dz_left)
+            return self.create_new_shell(center, radius, half_length, self.domain_id)
+        except ShellmakingError as e:
+            raise Exception('CylindricalSurfaceSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, z):
         if utils.feq(z, self.get_inner_a()):

From 137f9ccb6dea845bb6f854e972d5d31b89d9035e Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Mon, 2 Jan 2012 17:01:14 +0100
Subject: [PATCH 0520/1541] Removed bug in the roots rootfinder of Sink GFn.
 update_particle -> new_particle in NewBD

---
 GreensFunction1DAbsSinkAbs.cpp | 35 +++++++++++++++++++++++++++-------
 egfrd.py                       |  2 +-
 newBDPropagator.hpp            | 26 +++++++++----------------
 3 files changed, 38 insertions(+), 25 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 7062e4e7..7f2eeba1 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -161,7 +161,7 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     /* f_lower must have correct sign. */
     if( f_lower * parity_op > 0 )
     {
-        log_.warn("Parity error in x_lower of root# %6u, for h = %.5g, Lm/L = %.5g.",
+        log_.warn("f(lower) has wrong sign at root# %6u, for h = %.5g, Lm/L = %.5g.",
                   rootList_size() + 1, lo_up_params.h, lo_up_params.Lm_L );
 
         log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
@@ -174,22 +174,43 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
         int cntr = 0;
 
         const Real delta( .1 * std::min(left_offset, right_offset) );
+        const Real save_upper( upper );
         
         cntr = 0;
-        //TODO: find out is upper is left or right from next_root.
+
+        /* Assuming the upper point has overshoot the straddle region,
+           subtract from the upper limit, until endpoits do straddle.
+         */
         while(f_upper * parity_op < 0 && cntr++ < 10 )
         {
-            //Assume overshoot for now.
+            //Correct for overshoot.
             upper -= delta;
             f_upper = root_f( upper, &p );
         }
 
+        /* If upper point still doesn't straddle the root, increase the old estimate 
+           of upper, until it does straddle*/
         if(cntr >= 10)
         {
-            log_.warn("Failed to straddle root# %6u . ",
-                      rootList_size() + 1);
-            log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
-                  lower, f_lower, upper, f_upper);
+            cntr = 0;
+            upper = save_upper;
+            f_upper = root_f( upper, &p );
+
+            while(f_upper * parity_op < 0 && cntr++ < 10 )
+            {
+                //Correct for undershoot.
+                upper += delta;
+                f_upper = root_f( upper, &p );
+            }
+
+            // Still no straddle? => Crash is imminent.
+            if(cntr >= 10)
+            {
+                log_.warn("Failed to straddle root# %6u . ",
+                          rootList_size() + 1);
+                log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
+                          lower, f_lower, upper, f_upper);
+            }
         }
 
     }
diff --git a/egfrd.py b/egfrd.py
index 0f7fa923..2169bd85 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -782,7 +782,7 @@ def fire_single_reaction(self, single, reactant_pos):
                     # exit the loop, we have found a new position
                     break
 
-            else:
+                else:
                     # 4. Process (the lack of) change
                     moved_reactant = self.move_particle(reactant, reactant_pos)
                     products = [moved_reactant]     # no change
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b64e0ee5..dc68638b 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -371,13 +371,9 @@ class newBDPropagator
                             new_pos = make_move(s0, new_pos, pp.first);
                         }
                       
-                        const particle_id_pair new_p(
-                            pp.first, particle_type(products[0],
-                                particle_shape_type(new_pos,
-                                                    s0.radius()),
-                                                    s0.D()));
+                        const particle_shape_type new_shape(new_pos, s0.radius());
                                                     
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_p.second.shape(), new_p.first));
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_shape, pp.first));
                         if (overlapped && overlapped->size() > 0)
                         {
                             throw propagation_error("no space due to other particle");
@@ -385,7 +381,7 @@ class newBDPropagator
 
                         if (vc_)
                         {
-                            if (!(*vc_)(new_p.second.shape(), pp.first))
+                            if (!(*vc_)(new_shape, pp.first))
                             {
                                 throw propagation_error("no space due to other particle (vc)");
                             }
@@ -403,13 +399,14 @@ class newBDPropagator
                                 throw propagation_error("no space due to near surface");
                         }
 
-                        tx_.update_particle(new_p);
+                        tx_.remove_particle(pp.first);
+                        const particle_id_pair product( tx_.new_particle(s0.id(), new_pos) );
 
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(new_p.first), pp.first));
+                                    r.id(), array_gen(product.first), pp.first));
                         }
                     }
                     break;
@@ -703,18 +700,13 @@ class newBDPropagator
                             }
                         }
 
-			            const particle_id_pair new_p(
-			              pp.first, particle_type(sp.id(),
-				            particle_shape_type(new_pos,
-					          sp.radius()),
-					            sp.D()));
-
-                        tx_.update_particle(new_p);
+                        remove_particle(pp.first);
+                        const particle_id_pair product_particle( tx_.new_particle(sp.id(), new_pos) );
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(new_p.first), pp.first));
+                                    r.id(), array_gen(product_particle.first), pp.first));
                         }
                         break;
                     }

From 04d0cda236af7d43801cec47b7094f406c23791d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 2 Jan 2012 17:11:31 +0100
Subject: [PATCH 0521/1541] small change to make sure that 1D singles make
 symmetric domains

---
 single.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/single.py b/single.py
index d0ee8324..d75553bd 100644
--- a/single.py
+++ b/single.py
@@ -559,6 +559,8 @@ def create_updated_shell(self, position):
         # maybe update the reference_point of the shell before updating the shell
         try:
             dr, dz_right, dz_left = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            dz_right = min(dz_right, dz_left)       # make sure the domain is symmetric around the particle
+            dz_left  = dz_right                     # This is not necessary but it's assumed later
             center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
                                                                              self.testShell.get_orientation_vector(),
                                                                              dr, dz_right, dz_left)

From 91101c207b2de8301c96d0721f8d9d981a05f153 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 2 Jan 2012 17:13:05 +0100
Subject: [PATCH 0522/1541] implemented testShell for CylindricalSurfacePair
 and use it + some small mods

---
 egfrd.py  |  1 +
 pair.py   | 34 +++++++++++++++-------------
 shells.py | 67 ++++++++++++++++++++++++++++++++++++++++++-------------
 3 files changed, 71 insertions(+), 31 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index bdf9dc62..b08e6dce 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2068,6 +2068,7 @@ def try_pair(self, single1, single2):
 
 
         # Try forming a Pair only if singles are on same structure.
+        # FIXME this is already handled in the 'try_default_testpair' function
         if single1.structure == single2.structure:
             # particles are on the same structure
 
diff --git a/pair.py b/pair.py
index a11a8dc3..35ee2bf0 100644
--- a/pair.py
+++ b/pair.py
@@ -687,15 +687,19 @@ def __str__(self):
         return 'PlanarSurface' + Pair.__str__(self)
 
 
-class CylindricalSurfacePair(SimplePair):
+#class CylindricalSurfacePair(SimplePair):
+class CylindricalSurfacePair(SimplePair, Others, hasCylindricalShell):
     """2 Particles inside a (cylindrical) shell on a CylindricalSurface.  
     (Rods).
 
     """
-    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-                 r0, shell_size, rrs, structure):
-        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
-                      r0, shell_size, rrs, structure)
+    def __init__(self, domain_id, shell_id, testShell, rrs):
+#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
+#                 r0, shell_size, rrs, structure):
+#        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
+#                      r0, shell_size, rrs, structure)
+        hasCylindricalShell.__init__(self, testShell, domain_id)
+        SimplePair.__init__(self, domain_id, shell_id, rrs)
 
     def get_v_tot(self):
         return self.pid_particle_pair2[1].v - \
@@ -718,16 +722,16 @@ def com_greens_function(self):
     def iv_greens_function(self, r0):
         return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
-    def create_new_shell(self, position, half_length, domain_id):
-        # The radius of a rod is not more than it has to be (namely the 
-        # radius of the biggest particle), so if the particle undergoes 
-        # an unbinding reaction we still have to clear the target volume 
-        # and the move may be rejected (NoSpace error).
-        radius = max(self.pid_particle_pair1[1].radius,
-                     self.pid_particle_pair2[1].radius)
-        orientation = self.structure.shape.unit_z
-        return CylindricalShell(domain_id, Cylinder(position, radius, 
-                                                    orientation, half_length))
+#    def create_new_shell(self, position, half_length, domain_id):
+#        # The radius of a rod is not more than it has to be (namely the 
+#        # radius of the biggest particle), so if the particle undergoes 
+#        # an unbinding reaction we still have to clear the target volume 
+#        # and the move may be rejected (NoSpace error).
+#        radius = max(self.pid_particle_pair1[1].radius,
+#                     self.pid_particle_pair2[1].radius)
+#        orientation = self.structure.shape.unit_z
+#        return CylindricalShell(domain_id, Cylinder(position, radius, 
+#                                                    orientation, half_length))
 
     def get_shell_direction(self):
         return self.shell.shape.unit_z
diff --git a/shells.py b/shells.py
index 23a3b44c..669e924e 100755
--- a/shells.py
+++ b/shells.py
@@ -236,8 +236,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         if ref_to_shell_z >= 0:
             direction = 1           # improve direction specification such that following calculations still work
                                     # Otherwise problems when direction = 0
-            scale_angle = domain_to_scale.get_right_scalingangle()
-            scale_center_r, scale_center_z = domain_to_scale.get_right_scalingcenter() 
+            scale_angle = domain_to_scale.right_scalingangle
+            scale_center_r, scale_center_z = domain_to_scale.right_scalingcenter 
             r1_function =  domain_to_scale.r_right
             z1_function = domain_to_scale.z_right
             z2_function = domain_to_scale.z_left
@@ -246,8 +246,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         # else -> use z_left
         else:
             direction = -1
-            scale_angle = domain_to_scale.get_left_scalingangle()
-            scale_center_r, scale_center_z = domain_to_scale.get_left_scalingcenter() 
+            scale_angle = domain_to_scale.left_scalingangle
+            scale_center_r, scale_center_z = domain_to_scale.left_scalingcenter 
             r1_function =  domain_to_scale.r_left
             z1_function = domain_to_scale.z_left
             z2_function = domain_to_scale.z_right
@@ -495,7 +495,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         # get angles
         omega = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
-        omega += Pi         # TODO not sure why this is necessary
+        if (omega < 0) and (scale_center_to_shell_r - shell_radius) > 0.0:
+            omega += Pi         # FIXME strange construction. If the negative angle was caused by a negative denominator above
 
         if omega <= scale_angle:
             # shell hits the scaling cylinder on top
@@ -735,8 +736,8 @@ def determine_possible_shell(self, ignore, ignores):
 
                 if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
                     raise ShellmakingError('Domain too close to make cylindrical testshell, '
-                                           'domain = %s, distance = %s, testShell = %s' %
-                                           (neighbor, distance, self))
+                                           'domain = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
+                                           (neighbor, dr, dz_right, dz_left, self))
 
         # we calculated valid dimensions -> success!
         assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
@@ -781,6 +782,7 @@ def get_right_scalingangle(self):
         else:
             right_scaling_angle = math.atan(self.drdz_right)
         return right_scaling_angle
+    right_scalingangle = property(get_right_scalingangle)
 
     def get_left_scalingangle(self):
         if self.drdz_left == numpy.inf:
@@ -790,6 +792,7 @@ def get_left_scalingangle(self):
         else:
             left_scaling_angle = math.atan(self.drdz_left)
         return left_scaling_angle
+    left_scalingangle = property(get_left_scalingangle)
 
 
     def get_max_dr_dzright_dzleft(self):
@@ -811,8 +814,8 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
         self.z0_left    = self.pid_particle_pair[1].radius
-        self.right_scalingangle = self.get_right_scalingangle()
-        self.left_scalingangle  = self.get_left_scalingangle()
+#        self.right_scalingangle = self.get_right_scalingangle()
+#        self.left_scalingangle  = self.get_left_scalingangle()
 
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
@@ -902,8 +905,8 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.drdz_left  = 0.0
         self.r0_left    = self.pid_particle_pair[1].radius
         self.z0_left    = 0.0
-        self.right_scalingangle = self.get_right_scalingangle()
-        self.left_scalingangle  = self.get_left_scalingangle()
+#        self.right_scalingangle = self.get_right_scalingangle()
+#        self.left_scalingangle  = self.get_left_scalingangle()
 
 
         # sizing up the shell to a zero shell
@@ -934,19 +937,51 @@ def get_max_dr_dzright_dzleft(self):
 
 
 #####
-class CylindricalSurfacePairtestShell(CylindricaltestShell, Others):
+class CylindricalSurfacePairtestShell(CylindricaltestShell, testSimplePair):
 
-    def __init__(self):
-        # scaling parameters
+    def __init__(self, single1, single2, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testSimplePair.__init__(self, single1, single2)
+
+        # initialize scaling parameters
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = max(particle_radius1, particle_radius2)
+        self.r0_right   = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = max(particle_radius1, particle_radius2)
+        self.r0_left    = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         self.z0_left    = 0.0
 
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
+                                                          [self.structure.id])
+        except ShellmakingError as e:
+            raise testShellError('(CylindricalSurfacePair). %s' %
+                                 (str(e)))
+
+    def get_orientation_vector(self):
+        return self.structure.shape.unit_z
+
+    def get_searchpoint(self):
+        return self.com
+
+    def get_referencepoint(self):
+        return self.com
+
+    def get_min_dr_dzright_dzleft(self):
+        dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        dz_right = self.get_min_pair_size()
+        dz_left = dz_right
+        return dr, dz_right, dz_left
+
+    def get_max_dr_dzright_dzleft(self):
+        dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        dz_right = math.sqrt(self.get_searchradius()**2 - dr**2) # stay within the searchradius
+        dz_left = dz_right
+        return dr, dz_right, dz_left
+
 #####
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell, Others):
 

From 211405834c0d33551d5180ad8fecd00768e7dfbd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 2 Jan 2012 17:17:08 +0100
Subject: [PATCH 0523/1541] removed some old unused code

---
 shells.py | 86 -------------------------------------------------------
 1 file changed, 86 deletions(-)

diff --git a/shells.py b/shells.py
index 669e924e..5adf408f 100755
--- a/shells.py
+++ b/shells.py
@@ -369,36 +369,6 @@ def get_radius_to_shell(self, shell, domain_to_scale, r):
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
 
-#####
-#class SphericalSingle(hasSphericalShell, NonInteractionSingles):
-#
-#    def update_radius(self):
-#        return self.testShell.determine_possible_shell([], [self.structure.id])
-#
-#    # these return potentially corrected dimensions
-#    def shell_list_for_single(self):
-#        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
-#        if  self.shell.shape.radius < min_radius:
-#            position = self.shape.shell.position
-#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-#
-#    def shell_list_for_other(self):
-#        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
-#        if self.shell.shape.radius < min_radius:
-#            position = self.shape.shell.position
-#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-#
-######
-#class SphericalPair(hasSphericalShell, Others):
-#
-#    pass
-
 #####
 class Multi(hasSphericalShell, Others):
 
@@ -532,61 +502,9 @@ def get_radius_to_shell(self, shell, domain_to_scale, r):
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
 
-#####
-#class PlanarSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
-#
-#    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
-#    def shell_list_for_single(self):
-#        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
-#        if self.shell.shape.radius < min_radius:
-#            position = self.shell.shape.position
-#            half_length = self.shell.shape.half_length
-#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-#
-#    def shell_list_for_other(self):
-#        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
-#        if self.shell.shape.radius < min_radius:
-#            position = self.shell.shape.position
-#            half_length = self.shell.shape.half_length
-#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-
-#####
-class CylindricalSurfaceSingle(hasCylindricalShell, NonInteractionSingles):
-
-    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
-    def shell_list_for_single(self):
-        min_half_length = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
-        if self.shell.shape.half_length < min_half_length:
-            position = self.shell.shape.position
-            radius = self.shell.shape.radius
-            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
 
-    def shell_list_for_other(self):
-        min_half_length = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
-        if self.shell.shape.half_length < min_half_length:
-            position = self.shell.shape.position
-            radius = self.shell.shape.radius
-            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
-
-#####
-class PlanarSurfacePair(hasCylindricalShell, Others):
-    pass
 class PlanarSurfaceInteraction(hasCylindricalShell, Others):
     pass
-class CylindricalSurfacePair(hasCylindricalShell, Others):
-    pass
 class CylindricalSurfaceInteraction(hasCylindricalShell, Others):
     pass
 class MixedPair3D2D(hasCylindricalShell, Others):
@@ -814,8 +732,6 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
         self.z0_left    = self.pid_particle_pair[1].radius
-#        self.right_scalingangle = self.get_right_scalingangle()
-#        self.left_scalingangle  = self.get_left_scalingangle()
 
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
@@ -905,8 +821,6 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.drdz_left  = 0.0
         self.r0_left    = self.pid_particle_pair[1].radius
         self.z0_left    = 0.0
-#        self.right_scalingangle = self.get_right_scalingangle()
-#        self.left_scalingangle  = self.get_left_scalingangle()
 
 
         # sizing up the shell to a zero shell

From a690e20aeaba8b4057309cf6195938767e7222dd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 2 Jan 2012 17:27:47 +0100
Subject: [PATCH 0524/1541] make sure that also the max shell is well withing
 limits (or else numerical errors)

---
 shells.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/shells.py b/shells.py
index 5adf408f..6ae72f56 100755
--- a/shells.py
+++ b/shells.py
@@ -586,7 +586,7 @@ def get_orientation_vector(self):
         return random_vector(1.0)
 
     def get_max_radius(self):
-        return self.geometrycontainer.get_max_shell_size()
+        return self.get_searchradius()/SAFETY
 
 #####
 class SphericalSingletestShell(SphericaltestShell, testNonInteractionSingle):
@@ -756,7 +756,7 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dz_right = self.pid_particle_pair[1].radius
         dz_left = dz_right
-        dr = math.sqrt(self.get_searchradius()**2 - dz_right**2) # stay within the searchradius
+        dr = math.sqrt((self.get_searchradius()/SAFETY)**2 - dz_right**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
 #####
@@ -802,7 +802,7 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dz_right = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         dz_left = dz_right
-        dr = math.sqrt(self.get_searchradius()**2 - dz_right**2) # stay within the searchradius
+        dr = math.sqrt((self.get_searchradius()/SAFETY)**2 - dz_right**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
 #####
@@ -845,7 +845,7 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = self.pid_particle_pair[1].radius
-        dz_right = math.sqrt(self.get_searchradius()**2 - dr**2) # stay within the searchradius
+        dz_right = math.sqrt((self.get_searchradius()/SAFETY)**2 - dr**2) # stay within the searchradius
         dz_left = dz_right
         return dr, dz_right, dz_left
 
@@ -892,7 +892,7 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_right = math.sqrt(self.get_searchradius()**2 - dr**2) # stay within the searchradius
+        dz_right = math.sqrt((self.get_searchradius()/SAFETY)**2 - dr**2) # stay within the searchradius
         dz_left = dz_right
         return dr, dz_right, dz_left
 

From 51b032b58561238bf77b3c4a8410cf2797fa020e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Jan 2012 12:33:05 +0100
Subject: [PATCH 0525/1541] implemented testShells for the
 PlanarSurfaceInteraction

---
 egfrd.py  | 236 ++++++++++++++++++++++++++++++------------------------
 shells.py | 106 +++++++++++++-----------
 single.py |  55 +++++++------
 3 files changed, 222 insertions(+), 175 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b08e6dce..dab5ee34 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -41,6 +41,8 @@
     PlanarSurfacePairtestShell,
     CylindricalSurfaceSingletestShell,
     CylindricalSurfacePairtestShell,
+    testInteractionSingle,
+    PlanarSurfaceInteractiontestShell,
     )
 
 import logging
@@ -92,6 +94,14 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
     else:
         raise testShellError('(MixedPair). combination of structure not supported')
         
+def try_default_testinteraction(single, surface, geometrycontainer, domains):
+    if isinstance(surface, PlanarSurface):
+        return PlanarSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+    elif isinstance(surface, CylindricalSurface):
+        return CylindricalSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+    else:
+        raise testShellError('(Interaction). surface is not supported')
+
 
 class DomainEvent(Event):
     __slot__ = ['data']
@@ -419,23 +429,26 @@ def create_single(self, pid_particle_pair):
             single.world = self.world
         return single
 
-    def create_interaction(self, pid_particle_pair, surface, shell_center,
-                           shell_radius, shell_half_length, shell_unit_z):
+#    def create_interaction(self, pid_particle_pair, surface, shell_center,
+#                           shell_radius, shell_half_length, shell_unit_z):
+    def create_interaction(self, testShell):
 
 ##        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
 #       assert that the particle is not already associate with another domain
 
+        assert isinstance(testShell, testInteractionSingle)
+
         # 1. generate identifiers for the domain and shell. event_id is generated by
         # the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
-        species_id = pid_particle_pair[1].sid
+        species_id = testShell.pid_particle_pair[1].sid
         species = self.world.get_species(species_id)
         # the structure on which the particle lives
         structure = self.world.get_structure(species.structure_id)
         # the surface_id if the interaction surface
-        surface_id = surface.sid
+        surface_id = testShell.surface.sid
 
         # get unimolecular reaction rules
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
@@ -443,9 +456,9 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
         interaction_rules = self.network_rules.query_reaction_rule(species_id, surface_id)
 
 
-        particle_pos = pid_particle_pair[1].position
+#        particle_pos = pid_particle_pair[1].position
 
-        if isinstance(surface, CylindricalSurface):
+        if isinstance(testShell.surface, CylindricalSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
             projected_point, r0 = surface.projected_point(particle_pos)
             shell_unit_r = normalize(particle_pos - projected_point)
@@ -458,16 +471,18 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
                                                         shell_id, shell_center, shell_radius,
                                                         shell_half_length, shell_unit_z, z0,
                                                         shell_unit_r, r0, interaction_rules, surface)
-        elif isinstance(surface, PlanarSurface):
-            particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
-            z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
-
-            interaction = PlanarSurfaceInteraction(domain_id, pid_particle_pair,
-                                                   reaction_rules, structure,
-                                                   shell_id, shell_center, shell_radius,
-                                                   shell_half_length, shell_unit_z,
-                                                   z0, interaction_rules, surface)
+        elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
+#            particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
+#            z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
+#
+#            interaction = PlanarSurfaceInteraction(domain_id, pid_particle_pair,
+#                                                   reaction_rules, structure,
+#                                                   shell_id, shell_center, shell_radius,
+#                                                   shell_half_length, shell_unit_z,
+#                                                   z0, interaction_rules, surface)
 
+            interaction = PlanarSurfaceInteraction(domain_id, shell_id, testShell,
+                                                   reaction_rules, interaction_rules)
 
         assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
@@ -1809,114 +1824,123 @@ def burst_pair(self, pair):
 
     def try_interaction(self, single, surface):
         # Try to form an interaction between the 'single' particle and the 'surface'.
+        assert single.is_reset()
 
         pid_particle_pair = single.pid_particle_pair
         particle = pid_particle_pair[1]
-
-        # calculate the Projected_point and distance to the surface
-        # Cyclic transpose needed when calling surface.projected_point!
-        pos_transposed = self.world.cyclic_transpose(particle.position, 
-                                                     surface.shape.position) 
-        projected_point, projection_distance = \
-                surface.projected_point(pos_transposed)
-
-        # projection_distance is relative to the unit_z of the surface -> can be negative
-        particle_distance = abs(projection_distance)
-
-        # For interaction with a planar surface, decide orientation. 
-        # Note that the orientation_vector is normalized
-        orientation_vector = cmp(projection_distance, 0) * surface.shape.unit_z 
-
+#
+#        # calculate the Projected_point and distance to the surface
+#        # Cyclic transpose needed when calling surface.projected_point!
+#        pos_transposed = self.world.cyclic_transpose(particle.position, 
+#                                                     surface.shape.position) 
+#        projected_point, projection_distance = \
+#                surface.projected_point(pos_transposed)
+#
+#        # projection_distance is relative to the unit_z of the surface -> can be negative
+#        particle_distance = abs(projection_distance)
+#
+#        # For interaction with a planar surface, decide orientation. 
+#        # Note that the orientation_vector is normalized
+#        orientation_vector = cmp(projection_distance, 0) * surface.shape.unit_z 
+#
         if __debug__:
            log.debug('trying to form Interaction(%s, %s)' % (particle, surface))
 
 
         ### 1. See if there is enough space for the shell
-
-
-        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
-        # doesn't allow to check for shells outside the maximal sphere.
-        max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
-        max_cylinder_half_length = max_cylinder_radius
-
-        # Initialize dr, dz_left, dz_right to maximum allowed values.
-        # And decide minimal dr, dz_left, dz_right.
-        if isinstance(surface, PlanarSurface):
-            dr = max_cylinder_radius
-            # Leave enough for the particle itself to the left.
-            dz_left = particle.radius
-            dz_right = max_cylinder_half_length * 2 - dz_left
-
-            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
-            min_dz_left = dz_left
-            min_dz_right = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
-
-        elif isinstance(surface, CylindricalSurface):
-            dr = max_cylinder_radius
-            dz_left = max_cylinder_half_length
-            dz_right = max_cylinder_half_length
-
-            min_dr = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
-            min_dz_left = particle.radius * self.SINGLE_SHELL_FACTOR
-            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
-
-        # Miedema's algorithm.
-        dr, dz_left, dz_right = \
-            self.calculate_max_cylinder(single, surface,
-                                        projected_point,
-                                        particle_distance,
-                                        orientation_vector,
-                                        dr, dz_left, dz_right)
-
-        dr /= SAFETY
-        dz_right /= SAFETY
-        # Don't tweak dz_left, this will break the conditions below for membrane interaction
-        if isinstance(surface, CylindricalSurface):
-            dz_left /= SAFETY
-
-        # Decide if interaction domain is possible.
-        if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
+        try:
+            testShell = try_default_testinteraction(single, surface, self.geometrycontainer, self.domains)
+        except testShellError as e:
+            testShell = None
             if __debug__:
-                log.debug('        *Interaction not possible:\n'
-                          '            %s +\n'
-                          '            %s.\n'
-                          '            dr = %.3g. min_dr = %.3g.\n'
-                          '            dz_left = %.3g. min_dz_left = %.3g.\n'
-                          '            dz_right = %.3g. min_dz_right = %.3g.' %
-                          (single, surface, dr, min_dr, dz_left, min_dz_left, 
-                           dz_right, min_dz_right))
-            return None
+                log.debug('%s not formed %s' % \
+                          ('Interaction(%s, %s)' % (single.pid_particle_pair[0], surface),
+                          str(e) ))
 
-        ### 2. The shell can be made. Now do what's necessary to make it
-        # Compute origin, radius and half_length of cylinder.
-        origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
-        origin = self.world.apply_boundary(origin)
-        half_length = (dz_left + dz_right) / 2.0
-        radius = dr
 
-        interaction = self.create_interaction(pid_particle_pair, surface,
-                                              origin, radius, half_length,
-                                              orientation_vector)
+#        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
+#        # doesn't allow to check for shells outside the maximal sphere.
+#        max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
+#        max_cylinder_half_length = max_cylinder_radius
+#
+#        # Initialize dr, dz_left, dz_right to maximum allowed values.
+#        # And decide minimal dr, dz_left, dz_right.
+#        if isinstance(surface, PlanarSurface):
+#            dr = max_cylinder_radius
+#            # Leave enough for the particle itself to the left.
+#            dz_left = particle.radius
+#            dz_right = max_cylinder_half_length * 2 - dz_left
+#
+#            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dz_left = dz_left
+#            min_dz_right = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
+#
+#        elif isinstance(surface, CylindricalSurface):
+#            dr = max_cylinder_radius
+#            dz_left = max_cylinder_half_length
+#            dz_right = max_cylinder_half_length
+#
+#            min_dr = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dz_left = particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
+#
+#        # Miedema's algorithm.
+#        dr, dz_left, dz_right = \
+#            self.calculate_max_cylinder(single, surface,
+#                                        projected_point,
+#                                        particle_distance,
+#                                        orientation_vector,
+#                                        dr, dz_left, dz_right)
+#
+#        dr /= SAFETY
+#        dz_right /= SAFETY
+#        # Don't tweak dz_left, this will break the conditions below for membrane interaction
+#        if isinstance(surface, CylindricalSurface):
+#            dz_left /= SAFETY
+#
+#        # Decide if interaction domain is possible.
+#        if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
+#            if __debug__:
+#                log.debug('        *Interaction not possible:\n'
+#                          '            %s +\n'
+#                          '            %s.\n'
+#                          '            dr = %.3g. min_dr = %.3g.\n'
+#                          '            dz_left = %.3g. min_dz_left = %.3g.\n'
+#                          '            dz_right = %.3g. min_dz_right = %.3g.' %
+#                          (single, surface, dr, min_dr, dz_left, min_dz_left, 
+#                           dz_right, min_dz_right))
+#            return None
+
+#        ### 2. The shell can be made. Now do what's necessary to make it
+#        # Compute origin, radius and half_length of cylinder.
+#        origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
+#        origin = self.world.apply_boundary(origin)
+#        half_length = (dz_left + dz_right) / 2.0
+#        radius = dr
+
+        if testShell:
+#            interaction = self.create_interaction(pid_particle_pair, surface,
+#                                                  origin, radius, half_length,
+#                                                  orientation_vector)
+            interaction = self.create_interaction(testShell)
 
-        interaction.dt, interaction.event_type, = \
-            interaction.determine_next_event()
-        assert interaction.dt >= 0
+            interaction.dt, interaction.event_type, = interaction.determine_next_event()
+            assert interaction.dt >= 0
 
-        self.last_time = self.t
+            self.last_time = self.t
 
-        self.remove_domain(single)
-        # the event associated with the single will be removed by the scheduler.
+            self.remove_domain(single)
+            # the event associated with the single will be removed by the scheduler.
 
-        assert self.check_domain(interaction)
-        self.add_domain_event(interaction)
+            assert self.check_domain(interaction)
+            self.add_domain_event(interaction)
 
-        if __debug__:
-            log.debug('        *create_interaction\n'
-                      '            dr = %s. dz_left = %s. dz_right = %s.\n' %
-                      (FORMAT_DOUBLE % dr, FORMAT_DOUBLE % dz_left,
-                       FORMAT_DOUBLE % dz_right))
+            if __debug__:
+                log.debug('        *Created: %s' % (interaction))
 
-        return interaction
+            return interaction
+        else:
+            return None
 
 
     def calculate_max_cylinder(self, single, surface, projected_point, 
diff --git a/shells.py b/shells.py
index 6ae72f56..e32e294b 100755
--- a/shells.py
+++ b/shells.py
@@ -74,6 +74,7 @@ def get_neighbor_shell_list(self, neighbor):
 ##################################
 
 class testSingle(object):
+
     def __init__(self, pid_particle_pair, structure):
         self.pid_particle_pair = pid_particle_pair
         self.structure = structure
@@ -83,14 +84,35 @@ def __init__(self, pid_particle_pair, structure):
         self.SINGLE_SHELL_FACTOR = 2.0
 
 class testNonInteractionSingle(testSingle, NonInteractionSingles):
+
     def __init__(self, pid_particle_pair, structure):
         testSingle.__init__(self, pid_particle_pair, structure)
 
 class testInteractionSingle(testSingle, Others):
+
     def __init__(self, single, structure, surface):
         testSingle.__init__(self, single.pid_particle_pair, structure)
+
+        self.single  = single
         self.surface = surface
 
+        ### initialize some constants that are common for the interactions
+
+        # calculate the Projected_point and distance to the surface
+        # Cyclic transpose needed when calling surface.projected_point!
+        pos_transposed = self.world.cyclic_transpose(self.pid_particle_pair[1].position,
+                                                     self.surface.shape.position)
+        self.reference_point, projection_length = self.surface.projected_point(pos_transposed)
+
+        # projection_distance can be negative in case of plane
+        # note that the distance is to the center of the cylinder in case of cylinders
+        self.particle_surface_distance = abs(projection_length)
+
+        # For interaction with a planar surface, decide orientation, 
+        # Note that the orientation_vector is normalized
+        self.orientation_vector = cmp(projection_length, 0) * self.surface.shape.unit_z
+
+
 ##############
 class testPair(Others):
     def __init__(self, single1, single2):
@@ -317,33 +339,34 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         ### Get the right values for z and r for the given situation
         if situation == 1:      # the spherical shell hits cylinder on the flat side
             z1_new = min(z1, (ref_to_shell_z - shell_radius)/SAFETY)
-            r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
+            r_new  = min(r,  r1_function(z1_new))
 
         elif situation == 2:    # shell hits sphere on the edge
             shell_radius_sq = shell_radius*shell_radius
             ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_r**2)
             scale_center_to_shell_len = math.sqrt(ss_sq)
             sin_scale_angle = math.sin(scale_angle)
+            cos_scale_angle = math.cos(scale_angle)
             sin_psi = math.sin(psi)
             cos_psi = math.cos(psi)
             scale_center_shell_dist = (scale_center_to_shell_len * cos_psi - math.sqrt(shell_radius_sq - ss_sq*sin_psi*sin_psi) )
             # FIXME UGLY FIX BELOW
-#            scale_center_shell_dist /= 1.1
+            scale_center_shell_dist /= 1.1
 
             if scale_angle <= Pi/4:
                 z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist)/SAFETY)
-                r_new  = min(r, r1_function(single1, single2, r0, z1_new))
+                r_new  = min(r, r1_function(z1_new))
             else:
-                r_new = min(r, (scale_center_r + sin_scale_angle * scale_center_shell_dist)/SAFETY)
-                z1_new = min(z1, z1_function(single1, single2, r0, r_new))
+                r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist)/SAFETY)
+                z1_new = min(z1, z1_function(r_new))
 
         elif situation == 3:    # shell hits cylinder on the round side
             r_new = min(r, (ref_to_shell_r - shell_radius)/SAFETY)
-            z1_new = min(z1, z1_function(single1, single2, r0, r_new))
+            z1_new = min(z1, z1_function(r_new))
         else:
             raise RuntimeError('Bad situation for cylindrical shell making to sphere.')
 
-        z2_new = min(z2, z2_function(single1, single2, r0, r_new))
+        z2_new = min(z2, z2_function(r_new))
 
         # switch the z values in case it's necessary. r doesn't have to be switched.
         r = r_new
@@ -897,61 +920,54 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
 #####
-class PlanarSurfaceInteractiontestShell(CylindricaltestShell, Others):
+class PlanarSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
-    def __init__(self):
-        # scaling parameters
+    def __init__(self, single, surface, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testInteractionSingle.__init__(self, single, single.structure, surface)
+
+        # initialize scaling parameters
         self.dzdr_right = 1.0
         self.drdz_right = 1.0
         self.r0_right   = 0.0
-        self.z0_right   = distance_particle_refpoint
+        self.z0_right   = self.particle_surface_distance # calculated in the __init__ of testInteractionSingle
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
-        self.z0_left    = particle_radius
+        self.z0_left    = self.pid_particle_pair[1].radius
+
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
+        except ShellmakingError as e:
+            raise testShellError('(PlanarSurfaceInteration). %s' %
+                                 (str(e)))
+
 
     def get_orientation_vector(self):
-        result = do_calculation
-        return result
+        return self.orientation_vector      # calculated in the __init__ of testInteractionSingle
 
     def get_searchpoint(self):
-        result = calculate_searchpoint
-        return result
+#        return self.pid_particle_pair[1].position   # since the shell is scaled equally in all directions
+        # TODO this can be improved
+        search_distance = self.get_searchradius()/math.sqrt(2) - self.z0_left
+        return self.get_referencepoint() + search_distance * self.get_orientation_vector()
 
     def get_referencepoint(self):
-        return projected_point_of_particle
+        return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_min_dr_dzright_dzleft(self):
-        dz_right, r = calc_based_on_scaling_stuff
-        dz_left = particle_radius
-        return (dr, dz_right, dz_left)
+        dr       = self.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
+        dz_right = self.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR + self.particle_surface_distance
+        dz_left  = self.pid_particle_pair[1].radius
+        return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
-        result = calc_based_on_scaling_stuff
-        return (dr, dz_right, dz_left)
-
-    def get_right_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
-        # note calculate this only once since 'orientation_z' doens't change
-        # for different shells -> scalingcenter is a fixed point
-        h0_right = distance_particle_surface
-        return 0, h0_right
-
-    def get_left_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
-        # note calculate this only once since orientation_z doesn't change
-        # for difference shells -> scalingcenter is a fixed point
-        return 0, particle_radius
-
-    def get_right_scalingangle(self):
-        return Pi/4.0
-
-    def get_left_scalingangle(self):
-        return Pi/2.0
+        # TODO this can be improved
+        dr       = (self.get_searchradius()/math.sqrt(2))/SAFETY
+        dz_right = dr + self.particle_surface_distance
+        dz_left  = self.pid_particle_pair[1].radius
+        return dr, dz_right, dz_left
 
 #####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, Others):
diff --git a/single.py b/single.py
index d75553bd..6d6536ad 100644
--- a/single.py
+++ b/single.py
@@ -583,7 +583,7 @@ def __str__(self):
         return 'CylindricalSurface' + Single.__str__(self)
 
 
-class InteractionSingle(Single):
+class InteractionSingle(Single, hasCylindricalShell, Others):
     """Interactions singles are used when a particle is close to a 
     surface.
 
@@ -601,9 +601,9 @@ class InteractionSingle(Single):
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
         hasCylindricalShell.__init__(self, testShell, domain_id)
-
         assert self.testShell
         assert isinstance(self.testShell, testInteractionSingle)
+
         Single.__init__(self, domain_id, shell_id, reactionrules)
 
 #        self.shell_id = shell_id
@@ -636,10 +636,10 @@ def initialize(self, t):
         self.last_time = t
         self.event_type = None
 
-        # This is defined here, but only used in the subclasses
-    def create_new_shell(self, position, radius, orientation_vector, half_length):
-        return CylindricalShell(self.domain_id, Cylinder(position, radius,
-                                                    orientation_vector, half_length))
+#        # This is defined here, but only used in the subclasses
+#    def create_new_shell(self, position, radius, orientation_vector, half_length):
+#        return CylindricalShell(self.domain_id, Cylinder(position, radius,
+#                                                    orientation_vector, half_length))
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -673,6 +673,8 @@ def draw_iv_event_type(self):
             return EventType.IV_ESCAPE
         raise NotImplemented()
 
+    def __str__(self):
+        pass
 
 class PlanarSurfaceInteraction(InteractionSingle):
     """1 Particle close to a PlanarSurface, inside a cylindrical shell 
@@ -684,29 +686,32 @@ class PlanarSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
-                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
-                 interactionrules, surface):
+#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
+#                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
+#                 interactionrules, surface):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
         # shell_orientation_vector and z0 are supplied by arguments because Domains can't do
         # spatial calculations (they don't know about the world)
         # NOTE shell_orientation_vector should be normalized and pointing from the surface to the particle!
 
-        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
-                                   structure, shell_id, interactionrules, surface)
+#        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
+#                                   structure, shell_id, interactionrules, surface)
+        InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
         # z0 is the initial position of the particle relative to the center
-        # of the shell in the direction normal to the surface.
-        self.z0 = z0
-        self.shell = self.create_new_shell(shell_center, shell_radius, 
-                                           shell_orientation_vector, shell_half_length)
+        # of the shell in the direction normal to the surface (so z0 is usually negative).
+        self.z0 = -self.get_inner_dz_left() + self.testShell.particle_surface_distance
+
+#        self.shell = self.create_new_shell(shell_center, shell_radius, 
+#                                           shell_orientation_vector, shell_half_length)
 
     def get_inner_dz_right(self):
-        # This is the distance the particle can travel from its initial position
+        # This is the distance from the center of the shell
         # to the flat boundary away from the surface
         return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_dz_left(self):
-        # This is the distance the particle can traval towards the surface
+        # This is the distance from the center of the shell to the surface
         # Note that it is implied that the shell sticks out at the other end
         # of the planar surface by the particle radius, and that the surface
         # has no thickness.
@@ -778,15 +783,17 @@ def draw_new_position(self, dt, event_type):
         return newpos
 
 
-    def get_shell_size(self):
-        # REMOVE this method, it doesn't mean anything here.
-        # THis method is only used for making an Interaction
-        # Heads up. The cylinder's *half_length*, not radius, 
-        # determines the size in case of a cylindrical surface.
-        return self.shell.shape.radius
+#    def get_shell_size(self):
+#        # REMOVE this method, it doesn't mean anything here.
+#        # THis method is only used for making an Interaction
+#        # Heads up. The cylinder's *half_length*, not radius, 
+#        # determines the size in case of a cylindrical surface.
+#        return self.shell.shape.radius
 
     def __str__(self):
-        return 'PlanarSurfaceInteraction' + Single.__str__(self)
+        return ('PlanarSurfaceInteraction' + Single.__str__(self) + \
+               'radius = %s, half_length = %s' %
+                (self.shell.shape.radius, self.shell.shape.half_length))
 
 
 class CylindricalSurfaceInteraction(InteractionSingle):

From a0d557c133e2e8c687dfb323e18930e4096e667a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Jan 2012 12:34:18 +0100
Subject: [PATCH 0526/1541] beginning of improved logging

---
 pair.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pair.py b/pair.py
index 35ee2bf0..b075e08a 100644
--- a/pair.py
+++ b/pair.py
@@ -455,6 +455,8 @@ def determine_radii(self, r0, shell_size):
 
         return a_R, a_r
 
+    def __str__(self):
+        pass
 
 #class SphericalPair(SimplePair):
 class SphericalPair(SimplePair, Others, hasSphericalShell):

From afa164eded16927bd13a0661645989f79bf3364c Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Tue, 3 Jan 2012 15:45:08 +0100
Subject: [PATCH 0527/1541] Modified t_guess in 2DRadAbs for particles at
 contact.

---
 GreensFunction2DRadAbs.cpp | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 85d333c9..f469ab08 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -871,26 +871,28 @@ Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
     THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
 
-    Real dist;
-
+    Real t_guess;
 
     if( r0 == a || a == sigma )		// when the particle is at the border or if the PD has no real size
     {
 	return 0.0;
     }
 
+    // get some initial guess for the time, dr=sqrt(2dDt) with d
+    // the dimensionality (2 in this case)
+    const Real t_Abs( gsl_pow_2( a - r0 ) / ( 4.0 * D ) );
     if ( kf == 0.0 )			// if there was only one absorbing boundary
     {	
-        dist = a - r0;
+        t_guess = t_Abs;
     }
     else
     {	
-        dist = std::min( a - r0, r0 - sigma );	// take the shortest distance to a boundary
+        const Real t_Rad( D / gsl_pow_2( kf/(2*M_PI*a) ) + gsl_pow_2( r0 - sigma ) / D );
+        t_guess = std::min( t_Abs, t_Rad );	// take the shortest distance to a boundary
     }
-    Real t_guess = dist * dist / ( 4.0 * D );	// get some initial guess for the time, dr=sqrt(2dDt) with d
-						// the dimensionality (2 in this case)
-
-
+    
+    t_guess *= .1;
+    
 	const Real minT( std::min( sigma * sigma / D * this->MIN_T_FACTOR,
                                t_guess * 1e-7 ) );	// something with determining the lowest possible t
 

From 51c1b5626280519b1b64a29a66212aecd47f1a71 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Jan 2012 16:50:22 +0100
Subject: [PATCH 0528/1541] fixes and clarifications to the cylindrical shell
 making algorithm

---
 shells.py | 70 +++++++++++++++++++++++++++++++------------------------
 1 file changed, 40 insertions(+), 30 deletions(-)

diff --git a/shells.py b/shells.py
index e32e294b..8479f706 100755
--- a/shells.py
+++ b/shells.py
@@ -280,61 +280,63 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
         ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
         ref_to_shell_r = length(ref_to_shell_r_vec)
-        ref_to_shell_z = abs(ref_to_shell_z)
+        ref_to_shell_z = ref_to_shell_z * direction
 
-        # get the center from which linear scaling will take place
+        # calculate the distances in r/z from the scaling center to the shell
         scale_center_to_shell_r = ref_to_shell_r - scale_center_r
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
-
         # calculate the angle shell_angle of the vector from the scale center to the shell with the vector
         # to the scale center (which is +- the orientation_vector)
         shell_angle = math.atan(scale_center_to_shell_r/scale_center_to_shell_z)
 
-        psi = shell_angle - scale_angle
+        if scale_center_to_shell_z < 0.0:
+            shell_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
+        # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
+        # otherwise: shell_angle is ok -> do nothing
 
         ### check what situation arrises
         # The shell can hit the cylinder on the flat side (situation 1),
         #                                on the edge (situation 2),
         #                                or on the round side (situation 3).
         # I think this also works for scale_angle == 0 and scale_angle == Pi/2
-        if psi <= -scale_angle:
+        if shell_angle <= 0.0:
         # The midpoint of the shell lies on the axis of the cylinder
             situation = 1
 
-        elif -scale_angle < psi and psi < 0:
+        elif 0.0 < shell_angle and shell_angle < scale_angle:
         # The spherical shell can touch the cylinder on its flat side or its edge
+
             if scale_angle == Pi/2.0:
-                r_tan_scale_angle = 0
+                scale_center_to_shell_z_thres = 0
             else:
                 # scale_angle == 0 should not get here
-                r_tan_scale_angle = abs(scale_center_to_shell_r)/math.tan(scale_angle)
-                                    # TODO the abs may be wrong/unnecessary
+                scale_center_to_shell_z_thres = abs(scale_center_to_shell_r)/math.tan(scale_angle)
 
-            shell_radius_thres = scale_center_to_shell_z - r_tan_scale_angle
+            shell_radius_thres = scale_center_to_shell_z - scale_center_to_shell_z_thres
             if shell_radius < shell_radius_thres:
                 situation = 1
             else:
                 situation = 2
 
-        elif 0 <= psi and psi < (Pi/2.0 - scale_angle):
+        elif scale_angle <= shell_angle and shell_angle < Pi/2.0:
         # The (spherical) shell can touch the cylinder on its edge or its radial side
             tan_scale_angle = math.tan(scale_angle)                             # scale_angle == Pi/2 should not get here
-            shell_radius_thres = abs(scale_center_to_shell_r) - scale_center_to_shell_z * tan_scale_angle  # TODO same here
+            shell_radius_thres = scale_center_to_shell_r - scale_center_to_shell_z * tan_scale_angle  # TODO same here
+
             if shell_radius > shell_radius_thres:
                 situation = 2
             else:
                 situation = 3
 
-        elif (Pi/2.0 - scale_angle) <= psi:
+        elif Pi/2.0 <= shell_angle:
         # The shell is always only on the radial side of the cylinder
             situation = 3
 
         else:
         # Don't know how we would get here, but it shouldn't happen
-            raise RuntimeError('Error: psi was not in valid range. psi = %s, scale_angle = %s, shell_angle = %s' %
-                               (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % scale_angle, FORMAT_DOUBLE % shell_angle))
-
+            raise RuntimeError('Error: shell_angle was not in valid range. shell_angle = %s, scale_angle = %s' %
+                               (FORMAT_DOUBLE % shell_angle, FORMAT_DOUBLE % scale_angle))
 
         ### Get the right values for z and r for the given situation
         if situation == 1:      # the spherical shell hits cylinder on the flat side
@@ -343,20 +345,25 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         elif situation == 2:    # shell hits sphere on the edge
             shell_radius_sq = shell_radius*shell_radius
+
             ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_r**2)
-            scale_center_to_shell_len = math.sqrt(ss_sq)
-            sin_scale_angle = math.sin(scale_angle)
-            cos_scale_angle = math.cos(scale_angle)
-            sin_psi = math.sin(psi)
-            cos_psi = math.cos(psi)
-            scale_center_shell_dist = (scale_center_to_shell_len * cos_psi - math.sqrt(shell_radius_sq - ss_sq*sin_psi*sin_psi) )
-            # FIXME UGLY FIX BELOW
-            scale_center_shell_dist /= 1.1
-
-            if scale_angle <= Pi/4:
+            scale_center_to_shell = math.sqrt(ss_sq)
+
+            angle_diff = shell_angle - scale_angle
+            sin_angle_diff = math.sin(angle_diff)
+            cos_angle_diff = math.cos(angle_diff)
+
+            scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff - 
+                                       math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
+            # FIXME UGLY FIX BELOW to prevent bogus numerical errors
+#            scale_center_shell_dist /= 1.1
+
+            if scale_angle <= Pi/4.0:
+                cos_scale_angle = math.cos(scale_angle)
                 z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist)/SAFETY)
                 r_new  = min(r, r1_function(z1_new))
             else:
+                sin_scale_angle = math.sin(scale_angle)
                 r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist)/SAFETY)
                 z1_new = min(z1, z1_function(r_new))
 
@@ -487,11 +494,14 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
         # get angles
-        omega = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
-        if (omega < 0) and (scale_center_to_shell_r - shell_radius) > 0.0:
-            omega += Pi         # FIXME strange construction. If the negative angle was caused by a negative denominator above
+        to_edge_angle = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
+
+        if (scale_center_to_shell_z - shell_half_length) < 0.0:
+            to_edge_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
+        # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
+        # otherwise: shell_angle is ok -> do nothing
 
-        if omega <= scale_angle:
+        if to_edge_angle <= scale_angle:
             # shell hits the scaling cylinder on top
             z1_new = min(z1, (ref_to_shell_z - shell_half_length)/SAFETY)
             r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this

From af05620f7f060ae81aea90ac3c25f6050f9d3182 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Jan 2012 17:18:18 +0100
Subject: [PATCH 0529/1541] cleaning up of the try_pair method for testShell
 using

---
 egfrd.py | 102 +++++++++++++++++++++++++++----------------------------
 1 file changed, 51 insertions(+), 51 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index dab5ee34..18804637 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -87,10 +87,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return PlanarSurfacePairtestShell(single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, CylindricalSurface):
             return CylindricalSurfacePairtestShell(single1, single2, geometrycontainer, domains)
-    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        return MixedPair3D2DtestShell(single1, single2, geometrycontainer, domains) 
-    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        return MixedPair3D2DtestShell(single2, single1, geometrycontainer, domains)
+#    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+#        return MixedPair3D2DtestShell(single1, single2, geometrycontainer, domains) 
+#    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+#        return MixedPair3D2DtestShell(single2, single1, geometrycontainer, domains)
     else:
         raise testShellError('(MixedPair). combination of structure not supported')
         
@@ -1925,7 +1925,7 @@ def try_interaction(self, single, surface):
             interaction = self.create_interaction(testShell)
 
             interaction.dt, interaction.event_type, = interaction.determine_next_event()
-            assert interaction.dt >= 0
+            assert interaction.dt > 0.0
 
             self.last_time = self.t
 
@@ -2091,55 +2091,55 @@ def try_pair(self, single1, single2):
         assert single2.is_reset()
 
 
-        # Try forming a Pair only if singles are on same structure.
-        # FIXME this is already handled in the 'try_default_testpair' function
-        if single1.structure == single2.structure:
-            # particles are on the same structure
-
-            try:
-                testShell = try_default_testpair(single1, single2, self.geometrycontainer, self.domains)
-            except testShellError as e:
-                testShell = None
-                if __debug__:
-                    log.debug('%s not formed %s' % \
-                              ('Pair(%s, %s)' % (single1.pid_particle_pair[0], single2.pid_particle_pair[0]),
-                              str(e) ))
-
-        elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)) ^ \
-             (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-            # one particle in 2D, the other in 3D
+#        # Try forming a Pair only if singles are on same structure.
+#        # FIXME this is already handled in the 'try_default_testpair' function
+#        if single1.structure == single2.structure:
+#            # particles are on the same structure
 
+        try:
+            testShell = try_default_testpair(single1, single2, self.geometrycontainer, self.domains)
+        except testShellError as e:
+            testShell = None
             if __debug__:
-                log.debug('Mixed pair')
-
-            # make sure that we know which single is on what structure
-            if isinstance (single1.structure, PlanarSurface):
-                single2D = single1
-                single3D = single2
-            else:
-                single2D = single2
-                single3D = single1
-
-            center, shell_radius, shell_half_length, r0, shell_orientation_vector = \
-            self.calculate_mixedpair_shell_dimensions (single2D, single3D)
-
-            if shell_radius:
-                pair = self.create_pair(single2D, single3D, center, shell_radius, r0,
-                                        shell_half_length, shell_orientation_vector)
-                if __debug__:
-                    log.debug('Created: %s, shell_radius = %.3g, shell_half_length = %.3g, r0 = %.3g' %
-                              (pair, shell_radius, shell_half_length, r0))
-
-            else:
-                pair = None
+                log.debug('%s not formed %s' % \
+                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], single2.pid_particle_pair[0]),
+                          str(e) ))
 
-        else:
-            # a 1D/3D pair was supposed to be formed -> unsupported
-            if __debug__:
-                log.debug('Pair(%s, %s) not formed: combination of structures not supported.' %
-                          (single1.pid_particle_pair[0],
-                           single2.pid_particle_pair[0]))
-            pair = None
+#        elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)) ^ \
+#             (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+#            # one particle in 2D, the other in 3D
+#
+#            if __debug__:
+#                log.debug('Mixed pair')
+#
+#            # make sure that we know which single is on what structure
+#            if isinstance (single1.structure, PlanarSurface):
+#                single2D = single1
+#                single3D = single2
+#            else:
+#                single2D = single2
+#                single3D = single1
+#
+#            center, shell_radius, shell_half_length, r0, shell_orientation_vector = \
+#            self.calculate_mixedpair_shell_dimensions (single2D, single3D)
+#
+#            if shell_radius:
+#                pair = self.create_pair(single2D, single3D, center, shell_radius, r0,
+#                                        shell_half_length, shell_orientation_vector)
+#                if __debug__:
+#                    log.debug('Created: %s, shell_radius = %.3g, shell_half_length = %.3g, r0 = %.3g' %
+#                              (pair, shell_radius, shell_half_length, r0))
+#
+#            else:
+#                pair = None
+#
+#        else:
+#            # a 1D/3D pair was supposed to be formed -> unsupported
+#            if __debug__:
+#                log.debug('Pair(%s, %s) not formed: combination of structures not supported.' %
+#                          (single1.pid_particle_pair[0],
+#                           single2.pid_particle_pair[0]))
+#            pair = None
 
 
         # if a pair could be formed

From 241049a8cf5147b923f09cc5a702055adea6524b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Jan 2012 17:19:20 +0100
Subject: [PATCH 0530/1541] modifying Multi or testShell framework, Multi is
 subclass of hasShpericalShell and Others

---
 egfrd.py | 3 ++-
 multi.py | 9 ++++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 18804637..61917031 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2328,7 +2328,8 @@ def add_to_multi(self, single, multi):
 
         shell_id = self.shell_id_generator()
         shell = multi.create_new_shell(single.pid_particle_pair[1].position,
-                single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
+                                       single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR,
+                                       multi.domain_id)
         shell_id_shell_pair = (shell_id, shell)
         self.geometrycontainer.move_shell(shell_id_shell_pair)
         multi.add_shell(shell_id_shell_pair)
diff --git a/multi.py b/multi.py
index a8f46e5a..53a4bec1 100644
--- a/multi.py
+++ b/multi.py
@@ -8,12 +8,15 @@
 from _gfrd import (SphericalShell, Sphere)
 from constants import EventType
 from domain import Domain
+from shells import (hasSphericalShell, Others)
 
 import os
 
-class Multi(Domain):
+class Multi(Domain, hasSphericalShell, Others):
     def __init__(self, domain_id, main, step_size_factor):
         Domain.__init__(self, domain_id)
+        # note: hasSphericalShell.__init__ is not called and that the Multi has no self.testShell
+        #       Only the methods of the hasSphericalShell class are used
 
         self.main = ref(main)
         self.last_event = None
@@ -50,8 +53,8 @@ def get_multiplicity(self):
         return self.particle_container.num_particles
     multiplicity = property(get_multiplicity)
 
-    def create_new_shell(self, position, radius):
-        return SphericalShell(self.domain_id, Sphere(position, radius))
+#    def create_new_shell(self, position, radius):
+#        return SphericalShell(self.domain_id, Sphere(position, radius))
 
     def within_shell(self, pp):
         return bool(self.sphere_container.get_neighbors_within_radius(pp[1].position, -(pp[1].radius + self.reaction_length)))

From fa310014d19d0080985f47b1daaea75ed4f7057f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 4 Jan 2012 14:32:52 +0100
Subject: [PATCH 0531/1541] The minimal cylindrical single should fit inside
 the spherical multi shell. When sizing up a 2D/1D single with a 3D single in
 close proximity (just outside of the multi horizon), or sizing up a 3D single
 with a 2D/1D single in close proximity, the single might fail because it
 can't make its minimal since the minimal is bigger than the multi horizon.

---
 shells.py | 18 ++++++++++++------
 single.py | 11 +++++++++--
 2 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/shells.py b/shells.py
index 8479f706..840e6458 100755
--- a/shells.py
+++ b/shells.py
@@ -632,7 +632,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.radius = self.pid_particle_pair[1].radius
 
     def get_min_radius(self):
-        return self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR     # the minimum radius of a NonInteractionSingle
+        return self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR / SAFETY    # the minimum radius of a NonInteractionSingle
 
 #####
 class SphericalPairtestShell(SphericaltestShell, testSimplePair):
@@ -781,9 +781,12 @@ def get_referencepoint(self):
         return self.pid_particle_pair[1].position
 
     def get_min_dr_dzright_dzleft(self):
-        dr = self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+        # we need to make sure that the minimal cylinder for the Single fits inside the putative
+        # spherical Multi shell.
+        # NOTE the MULTI_SHELL_FACTOR should therefore be at least sqrt(2)!!
+        dr       = self.pid_particle_pair[1].radius * math.sqrt(self.MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
         dz_right = self.pid_particle_pair[1].radius
-        dz_left = dz_right
+        dz_left  = dz_right
         return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
@@ -871,9 +874,12 @@ def get_referencepoint(self):
         return self.pid_particle_pair[1].position
 
     def get_min_dr_dzright_dzleft(self):
-        dr = self.pid_particle_pair[1].radius
-        dz_right = self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
-        dz_left = self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+        # we need to make sure that the minimal cylinder for the Single fits inside the putative
+        # spherical Multi shell.
+        # NOTE the MULTI_SHELL_FACTOR should therefore be at least sqrt(2)!!
+        dr       = self.pid_particle_pair[1].radius
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(Domain.MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
+        dz_left  = dz_right
         return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
diff --git a/single.py b/single.py
index 6d6536ad..c62ce3f8 100644
--- a/single.py
+++ b/single.py
@@ -358,6 +358,7 @@ def greens_function(self):
     # these return potentially corrected dimensions
     def shell_list_for_single(self):
         min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+#        min_radius = self.testShell.get_min_radius()
         if  self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
@@ -437,7 +438,10 @@ def greens_function(self):
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+        # The shell should always be larger that the bare minimum for a test shell
+        # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
+        min_radius = self.pid_particle_pair[1].radius * math.sqrt(Domain.MULTI_SHELL_FACTOR**2 - 1.0)
+#        min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             half_length = self.shell.shape.half_length
@@ -535,7 +539,10 @@ def greens_function(self):
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
-        min_half_length = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+        # The shell should always be larger that the bare minimum for a test shell
+        # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
+        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(Domain.MULTI_SHELL_FACTOR**2 - 1.0)
+#        _, min_half_length, _ = self.testShell.get_min_dr_dzright_dzleft()
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
             radius = self.shell.shape.radius

From ac21db0e94e6a0aa57b083d5edfbe8fe42f810cb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 4 Jan 2012 15:15:54 +0100
Subject: [PATCH 0532/1541] moved SINGLE_SHELL_FACTOR and MULTI_SHELL_FACTOR
 constants to utils.py

---
 domain.py |  3 ---
 egfrd.py  | 47 ++++++++++++++++++++---------------------------
 pair.py   | 16 ++++++++--------
 shells.py | 22 +++++++---------------
 single.py | 14 +++++++-------
 utils.py  | 13 +++++++++++--
 6 files changed, 53 insertions(+), 62 deletions(-)

diff --git a/domain.py b/domain.py
index 33f2608e..55f452f8 100644
--- a/domain.py
+++ b/domain.py
@@ -14,9 +14,6 @@ class Domain(object):
 # The domain is the main unit of eGFRD. Single, Pairs and Multis are all domains
 # with an own domain_id
 
-    SINGLE_SHELL_FACTOR = 2.0
-    MULTI_SHELL_FACTOR = math.sqrt(2)
-
     def __init__(self, domain_id):
         self.domain_id = domain_id      # identifier for this domain object
         self.event_id = None            # identifier for the event coupled to this domain
diff --git a/egfrd.py b/egfrd.py
index 61917031..b6ab1bea 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -150,13 +150,6 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.shell_id_generator = ShellIDGenerator(0)
 
         # some constants
-        self.MULTI_SHELL_FACTOR = math.sqrt(2)  # This stems from the fact that there vacant space in the cylinder
-                                                # NonInteractionSingles to a Multi and also defines the Multi
-                                                # shell size.
-        self.SINGLE_SHELL_FACTOR = 2.0          # This is the threshold for when the algorithm switches from
-                                                # NonInteractionSingles to a Pair or Interaction. It also defines
-                                                # the radius in which the NonInteractionSingle will burst.
-                                                # NOTE THAT ABOVE CONSTANTS ARE ALSO IN domain.py
         self.MAX_NUM_DT0_STEPS = 1000
 
         self.MAX_TIME_STEP = 10
@@ -1194,7 +1187,7 @@ def make_new_domain(self, single):
         # Check if there are shells with the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
         # with a sphere (should be cylinder for 2D or 1D particle)
-        reaction_threshold = single_radius * self.SINGLE_SHELL_FACTOR
+        reaction_threshold = single_radius * SINGLE_SHELL_FACTOR
 
 
         # TODO redundant
@@ -1228,16 +1221,16 @@ def make_new_domain(self, single):
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
                 pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
-                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * self.SINGLE_SHELL_FACTOR
+                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
             if isinstance(surface, PlanarSurface):
                 # with a planar surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (self.SINGLE_SHELL_FACTOR - 1.0)
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
             else:
                 # with a cylindrical surface it is the surface of the particle
-                surface_horizon = single_radius * self.SINGLE_SHELL_FACTOR
+                surface_horizon = single_radius * SINGLE_SHELL_FACTOR
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
@@ -1273,7 +1266,7 @@ def make_new_domain(self, single):
             multi_partners = []
             for domain, dist_to_shell in neighbor_distances:
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
-                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * self.MULTI_SHELL_FACTOR
+                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * MULTI_SHELL_FACTOR
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
                     multi_partners.append((domain, distance - multi_horizon))
 
@@ -1281,17 +1274,17 @@ def make_new_domain(self, single):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
                     # So only the horizon and distance of the current single needs to be taken into account
                     # Note: this is built on the assumption that the shell of a Multi has the size of the horizon.
-                    multi_horizon = (single_radius * self.MULTI_SHELL_FACTOR)
+                    multi_horizon = (single_radius * MULTI_SHELL_FACTOR)
                     multi_partners.append((domain, dist_to_shell - multi_horizon))
 
             # Also add surfaces
             for surface, distance in surface_distances:
                 if isinstance(surface, PlanarSurface):
                     # with a planar surface it is the center of mass that 'looks around'
-                    surface_horizon = single_radius * (self.MULTI_SHELL_FACTOR - 1.0)
+                    surface_horizon = single_radius * (MULTI_SHELL_FACTOR - 1.0)
                 else:
                     # with a cylindrical surface it is the surface of the particle
-                    surface_horizon = single_radius * self.MULTI_SHELL_FACTOR
+                    surface_horizon = single_radius * MULTI_SHELL_FACTOR
                 multi_partners.append((surface, distance - surface_horizon))
 
 
@@ -1377,9 +1370,9 @@ def calculate_simplepair_shell_size(self, single1, single2):
         d2 = self.world.distance(com, pos2)
 
         if shell_size < max(d1 + single1.pid_particle_pair[1].radius *
-                            self.SINGLE_SHELL_FACTOR, \
+                            SINGLE_SHELL_FACTOR, \
                             d2 + single2.pid_particle_pair[1].radius * \
-                            self.SINGLE_SHELL_FACTOR) * 1.3:
+                            SINGLE_SHELL_FACTOR) * 1.3:
             if __debug__:
                 log.debug('%s not formed: singles are better' %
                           'Pair(%s, %s)' % (single1.pid_particle_pair[0], 
@@ -1871,18 +1864,18 @@ def try_interaction(self, single, surface):
 #            dz_left = particle.radius
 #            dz_right = max_cylinder_half_length * 2 - dz_left
 #
-#            min_dr = particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dr = particle.radius * SINGLE_SHELL_FACTOR
 #            min_dz_left = dz_left
-#            min_dz_right = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dz_right = particle_distance + particle.radius * SINGLE_SHELL_FACTOR
 #
 #        elif isinstance(surface, CylindricalSurface):
 #            dr = max_cylinder_radius
 #            dz_left = max_cylinder_half_length
 #            dz_right = max_cylinder_half_length
 #
-#            min_dr = particle_distance + particle.radius * self.SINGLE_SHELL_FACTOR
-#            min_dz_left = particle.radius * self.SINGLE_SHELL_FACTOR
-#            min_dz_right = particle.radius * self.SINGLE_SHELL_FACTOR
+#            min_dr = particle_distance + particle.radius * SINGLE_SHELL_FACTOR
+#            min_dz_left = particle.radius * SINGLE_SHELL_FACTOR
+#            min_dz_right = particle.radius * SINGLE_SHELL_FACTOR
 #
 #        # Miedema's algorithm.
 #        dr, dz_left, dz_right = \
@@ -2001,7 +1994,7 @@ def calculate_max_cylinder(self, single, surface, projected_point,
                 if domain.dt == 0.0 and domain.getD() > 0:
                     # This is one of the bursted singles.
                     # Or a particle that just escaped it's multi.
-                    shell_size *= self.SINGLE_SHELL_FACTOR
+                    shell_size *= SINGLE_SHELL_FACTOR
 
                 dr, dz_left, dz_right = \
                     self.miedema_algorithm(shell_position, shell_size, 
@@ -2257,7 +2250,7 @@ def add_to_multi_recursive(self, domain, multi):
                                                                              ignore=[domain.domain_id, multi.domain_id])
 
             # 2. Burst the domains that interfere with making the multi shell
-            burstradius = domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR
+            burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
             neighbor_distances = self.burst_non_multis(neighbor_distances, burstradius)
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
@@ -2278,7 +2271,7 @@ def add_to_multi_recursive(self, domain, multi):
             for neighbor, dist_to_shell in neighbor_distances:
                 if (isinstance (neighbor, NonInteractionSingle) and neighbor.is_reset()):
                     multi_horizon = (domain.pid_particle_pair[1].radius + neighbor.pid_particle_pair[1].radius) * \
-                                    self.MULTI_SHELL_FACTOR
+                                    MULTI_SHELL_FACTOR
                     # distance from the center of the particles/domains
                     distance = self.world.distance(dompos, neighbor.shell.shape.position)
                     overlap = distance - multi_horizon
@@ -2287,7 +2280,7 @@ def add_to_multi_recursive(self, domain, multi):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
                     # So only the horizon and distance of the current single needs to be taken into account
                     # Note: this is built on the assumption that the shell of a Multi has the size of the horizon.
-                    multi_horizon = (domain.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR)
+                    multi_horizon = (domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR)
                     overlap = dist_to_shell - multi_horizon
                 else:
                     # neighbor is not addible to multi
@@ -2328,7 +2321,7 @@ def add_to_multi(self, single, multi):
 
         shell_id = self.shell_id_generator()
         shell = multi.create_new_shell(single.pid_particle_pair[1].position,
-                                       single.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR,
+                                       single.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR,
                                        multi.domain_id)
         shell_id_shell_pair = (shell_id, shell)
         self.geometrycontainer.move_shell(shell_id_shell_pair)
diff --git a/pair.py b/pair.py
index b075e08a..e9a089ec 100644
--- a/pair.py
+++ b/pair.py
@@ -12,7 +12,7 @@
 from multi import (
     Multi)
 from shells import *
-
+from utils import *
 
 __all__ = [
     'CylindricalSurfacePair',
@@ -227,8 +227,8 @@ def get_min_shell_size(cls, single1, single2, geometrycontainer):
         com_shell_size = max(radius1, radius2)
 
         # calculate total radii including the margin for the burst volume for the particles
-        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - Domain.SINGLE_SHELL_FACTOR),
-                         iv_shell_size2 + com_shell_size + radius2 * (1 - Domain.SINGLE_SHELL_FACTOR))
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - SINGLE_SHELL_FACTOR),
+                         iv_shell_size2 + com_shell_size + radius2 * (1 - SINGLE_SHELL_FACTOR))
 
         return shell_size
 
@@ -276,7 +276,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
                         shell_center, domain.pid_particle_pair[1].position)
 
                 distance = min(distance,
-                               closest_particle_distance - domain.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR)
+                               closest_particle_distance - domain.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR)
 
                 # options for shell size:
                 # a. upto the closest shell assuming that this shell is bigger than the minimum
@@ -797,7 +797,7 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
 
         # calculate the minimal height z_right1 of the shell including burst radius
         # with the accompanying radius r1
-        z_right1 = iv_z + radius2 * Domain.SINGLE_SHELL_FACTOR
+        z_right1 = iv_z + radius2 * SINGLE_SHELL_FACTOR
         r1       = cls.r_right(single1, single2, r0, z_right1)
 
         len_iv = r0
@@ -809,8 +809,8 @@ def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
 
         # calculate the minimal dimensions of the protective domain including space for the
         # burst volumes of the particles
-        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * Domain.SINGLE_SHELL_FACTOR,
-                 iv_shell_radius2 + com_shell_radius + radius2 * Domain.SINGLE_SHELL_FACTOR)
+        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * SINGLE_SHELL_FACTOR,
+                 iv_shell_radius2 + com_shell_radius + radius2 * SINGLE_SHELL_FACTOR)
         z_right2 = cls.z_right(single1, single2, r0, r2)
 
         # of both alternatives pick the largest one
@@ -870,7 +870,7 @@ def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
                 if domain.dt == 0.0 and domain.getD() > 0:
                     # This is one of the bursted singles.
                     # Or a particle that just escaped it's multi.
-                    shell_size *= Domain.SINGLE_SHELL_FACTOR
+                    shell_size *= SINGLE_SHELL_FACTOR
 
                 r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, domain.shell,
                                                                  reference_point, orientation_vector, r, z_left,
diff --git a/shells.py b/shells.py
index 840e6458..8d7004bf 100755
--- a/shells.py
+++ b/shells.py
@@ -79,10 +79,6 @@ def __init__(self, pid_particle_pair, structure):
         self.pid_particle_pair = pid_particle_pair
         self.structure = structure
 
-        # FIXME FIXME This is defined multiple times!!!
-        self.MULTI_SHELL_FACTOR = math.sqrt(2)
-        self.SINGLE_SHELL_FACTOR = 2.0
-
 class testNonInteractionSingle(testSingle, NonInteractionSingles):
 
     def __init__(self, pid_particle_pair, structure):
@@ -128,10 +124,6 @@ def __init__(self, single1, single2):
         self.com, self.iv = self.do_transform()
         self.r0 = length(self.iv)
 
-        # FIXME FIXME This is defined multiple times!!!
-        self.MULTI_SHELL_FACTOR = math.sqrt(2)
-        self.SINGLE_SHELL_FACTOR = 2.0
-
     def do_transform(self):
         pass        # overloaded later
 
@@ -198,8 +190,8 @@ def get_min_pair_size(self):
         com_shell_size = max(radius1, radius2)
 
         # calculate total radii including the margin for the burst volume for the particles
-        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (self.SINGLE_SHELL_FACTOR),
-                         iv_shell_size2 + com_shell_size + radius2 * (self.SINGLE_SHELL_FACTOR))
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * SINGLE_SHELL_FACTOR,
+                         iv_shell_size2 + com_shell_size + radius2 * SINGLE_SHELL_FACTOR)
 
         return shell_size
 
@@ -632,7 +624,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.radius = self.pid_particle_pair[1].radius
 
     def get_min_radius(self):
-        return self.pid_particle_pair[1].radius * self.MULTI_SHELL_FACTOR / SAFETY    # the minimum radius of a NonInteractionSingle
+        return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR / SAFETY    # the minimum radius of a NonInteractionSingle
 
 #####
 class SphericalPairtestShell(SphericaltestShell, testSimplePair):
@@ -784,7 +776,7 @@ def get_min_dr_dzright_dzleft(self):
         # we need to make sure that the minimal cylinder for the Single fits inside the putative
         # spherical Multi shell.
         # NOTE the MULTI_SHELL_FACTOR should therefore be at least sqrt(2)!!
-        dr       = self.pid_particle_pair[1].radius * math.sqrt(self.MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
+        dr       = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
         dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
         return dr, dz_right, dz_left
@@ -878,7 +870,7 @@ def get_min_dr_dzright_dzleft(self):
         # spherical Multi shell.
         # NOTE the MULTI_SHELL_FACTOR should therefore be at least sqrt(2)!!
         dr       = self.pid_particle_pair[1].radius
-        dz_right = self.pid_particle_pair[1].radius * math.sqrt(Domain.MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
         dz_left  = dz_right
         return dr, dz_right, dz_left
 
@@ -973,8 +965,8 @@ def get_referencepoint(self):
         return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = self.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR
-        dz_right = self.pid_particle_pair[1].radius * self.SINGLE_SHELL_FACTOR + self.particle_surface_distance
+        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        dz_right = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + self.particle_surface_distance
         dz_left  = self.pid_particle_pair[1].radius
         return dr, dz_right, dz_left
 
diff --git a/single.py b/single.py
index c62ce3f8..77ee7904 100644
--- a/single.py
+++ b/single.py
@@ -297,7 +297,7 @@ def get_max_shell_size(self, geometrycontainer, domains):
                 # leave at least MULTI_SHELL_FACTOR space for another NonInteractionSingle (to make sure that
                 # the other single will not have an overlapping multi shell when starting to multi
                 distance_max = geometrycontainer.world.distance(singlepos, domain.pid_particle_pair[1].position)
-                distance = min(distance, distance_max - domain.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR)
+                distance = min(distance, distance_max - domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR)
                 # TODO check this!
             elif isinstance(domain, PlanarSurface):
                 distance = distance + self.pid_particle_pair[1].radius
@@ -357,7 +357,7 @@ def greens_function(self):
     # specific shell methods for the SphericalSingle
     # these return potentially corrected dimensions
     def shell_list_for_single(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.MULTI_SHELL_FACTOR
+        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
 #        min_radius = self.testShell.get_min_radius()
         if  self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
@@ -367,7 +367,7 @@ def shell_list_for_single(self):
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
@@ -440,7 +440,7 @@ def greens_function(self):
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
-        min_radius = self.pid_particle_pair[1].radius * math.sqrt(Domain.MULTI_SHELL_FACTOR**2 - 1.0)
+        min_radius = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
 #        min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
@@ -451,7 +451,7 @@ def shell_list_for_single(self):
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_radius = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             half_length = self.shell.shape.half_length
@@ -541,7 +541,7 @@ def greens_function(self):
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
-        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(Domain.MULTI_SHELL_FACTOR**2 - 1.0)
+        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
 #        _, min_half_length, _ = self.testShell.get_min_dr_dzright_dzleft()
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
@@ -552,7 +552,7 @@ def shell_list_for_single(self):
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_half_length = self.pid_particle_pair[1].radius * Domain.SINGLE_SHELL_FACTOR
+        min_half_length = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
             radius = self.shell.shape.radius
diff --git a/utils.py b/utils.py
index d590f902..bf0bdeeb 100644
--- a/utils.py
+++ b/utils.py
@@ -16,7 +16,7 @@
 ZEROPOS = numpy.array([0., 0., 0.])
 NOWHERE = numpy.array((INF, INF, INF))
 
-SAFETY = 1.0 + 1e-5
+SAFETY = 1.0 + 1e-3
 
 # Tolerance used for float comparison functions. Oversimplifying: two floats a 
 # and b are considered to be equal if abs(a - b) < TOLERANCE * abs(a).
@@ -26,7 +26,16 @@
 # Multiplication factor used for seperating 2 particles or a particle and a 
 # surface after unbinding.
 MINIMAL_SEPARATION_FACTOR = 1.0 + TOLERANCE
-  
+
+
+MULTI_SHELL_FACTOR = math.sqrt(2.1) # MULTI_SHELL_FACTOR should be AT LEAST sqrt(2)
+                                    # This stems from the fact that there vacant space in the cylinder
+                                    # NonInteractionSingles to a Multi and also defines the Multi
+                                    # shell size.
+SINGLE_SHELL_FACTOR = 2.0           # This is the threshold for when the algorithm switches from
+                                    # NonInteractionSingles to a Pair or Interaction. It also defines
+                                    # the radius in which the NonInteractionSingle will burst.
+
 # Float comparison functions.
 def feq(a, b, typical=1, tolerance=TOLERANCE):
     """Return True if a and b are equal, subject to given tolerances.  

From 412c284ec2dd4e95c363de95ce60afab96df858a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 4 Jan 2012 19:31:07 +0100
Subject: [PATCH 0533/1541] Implemented CylindricalSurfaceInteraction to use
 testShell formalism. + fixed stupid mistake in cylinder scaling functions

---
 egfrd.py  | 29 +++++++++++---------
 shells.py | 79 ++++++++++++++++++++++++-------------------------------
 single.py | 52 ++++++++++++++++++++----------------
 3 files changed, 81 insertions(+), 79 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b6ab1bea..ed9be579 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -43,6 +43,7 @@
     CylindricalSurfacePairtestShell,
     testInteractionSingle,
     PlanarSurfaceInteractiontestShell,
+    CylindricalSurfaceInteractiontestShell,
     )
 
 import logging
@@ -451,19 +452,21 @@ def create_interaction(self, testShell):
 
 #        particle_pos = pid_particle_pair[1].position
 
-        if isinstance(testShell.surface, CylindricalSurface):
-            particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
-            projected_point, r0 = surface.projected_point(particle_pos)
-            shell_unit_r = normalize(particle_pos - projected_point)
-
-            projected_point = self.world.cyclic_transpose(projected_point, shell_center)
-            z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
-
-            interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
-                                                        reaction_rules, structure,
-                                                        shell_id, shell_center, shell_radius,
-                                                        shell_half_length, shell_unit_z, z0,
-                                                        shell_unit_r, r0, interaction_rules, surface)
+        if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
+#            particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
+#            projected_point, r0 = surface.projected_point(particle_pos)
+#            shell_unit_r = normalize(particle_pos - projected_point)
+#
+#            projected_point = self.world.cyclic_transpose(projected_point, shell_center)
+#            z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
+#
+#            interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
+#                                                        reaction_rules, structure,
+#                                                        shell_id, shell_center, shell_radius,
+#                                                        shell_half_length, shell_unit_z, z0,
+#                                                        shell_unit_r, r0, interaction_rules, surface)
+            interaction = CylindricalSurfaceInteraction(domain_id, shell_id, testShell,
+                                                        reaction_rules, interaction_rules)
         elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
 #            particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
 #            z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
diff --git a/shells.py b/shells.py
index 8d7004bf..b448e6b2 100755
--- a/shells.py
+++ b/shells.py
@@ -104,9 +104,8 @@ def __init__(self, single, structure, surface):
         # note that the distance is to the center of the cylinder in case of cylinders
         self.particle_surface_distance = abs(projection_length)
 
-        # For interaction with a planar surface, decide orientation, 
-        # Note that the orientation_vector is normalized
-        self.orientation_vector = cmp(projection_length, 0) * self.surface.shape.unit_z
+        # The reference_vector is the normalized vector from the reference_point to the particle
+        self.reference_vector = normalize(pos_transposed - self.reference_point)
 
 
 ##############
@@ -695,13 +694,13 @@ def get_searchradius(self):
 
     # default functions for evaluating z_right/z_left/r after one of parameters changed
     def r_right(self, z_right):
-        return self.drdz_right * z_right + self.r0_right
+        return self.drdz_right * (z_right - self.z0_right) + self.r0_right
     def z_right(self, r_right):
-        return self.dzdr_right * r_right + self.z0_right
+        return self.dzdr_right * (r_right - self.r0_right) + self.z0_right
     def r_left(self, z_left):
-        return self.drdz_left * z_left + self.r0_left
+        return self.drdz_left * (z_left - self.z0_left) + self.r0_left
     def z_left(self, r_left):
-        return self.dzdr_left * r_left + self.z0_left
+        return self.dzdr_left * (r_left - self.r0_left) + self.z0_left
 
     def get_right_scalingcenter(self):
         # returns the scaling center in the cylindrical coordinates r, z of the shell
@@ -953,7 +952,7 @@ def __init__(self, single, surface, geometrycontainer, domains):
 
 
     def get_orientation_vector(self):
-        return self.orientation_vector      # calculated in the __init__ of testInteractionSingle
+        return self.reference_vector      # calculated in the __init__ of testInteractionSingle
 
     def get_searchpoint(self):
 #        return self.pid_particle_pair[1].position   # since the shell is scaled equally in all directions
@@ -978,60 +977,52 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
 #####
-class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, Others):
+class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
-    def __init__(self):
+    def __init__(self, single, surface, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testInteractionSingle.__init__(self, single, single.structure, surface)
 
-        # scaling parameters
+        # initialize scaling parameters
         self.dzdr_right = 1.0
         self.drdz_right = 1.0
         self.r0_right   = 0.0
-        self.z0_right   = 0.0 # calculate_it
+        self.z0_right   = -self.particle_surface_distance   # note that this is because dzdr_right = 1.0
         self.dzdr_left  = 1.0
         self.drdz_left  = 1.0
         self.r0_left    = 0.0
-        self.z0_left    = 0.0 # calculate_it (same as above)
+        self.z0_left    = -self.particle_surface_distance
+
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
+        except ShellmakingError as e:
+            raise testShellError('(CylindricalSurfaceInteraction). %s' %
+                                 (str(e)))
+
 
     def get_orientation_vector(self):
-        return structure.shape.unit_z
+        return self.surface.shape.unit_z
 
     def get_searchpoint(self):
-        return projected_point_of_particle
+        return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_referencepoint(self):
-        return projected_point_of_particle
+        return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_min_dr_dzright_dzleft(self):
-        result = calc_based_on_scaling_stuff
-        return (dr, dz_right, dz_left)
+        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + self.particle_surface_distance
+        dz_right = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        dz_left  = dz_right
+        return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        result = calc_based_on_scaling_stuff
-        return (dr, dz_right, dz_left)
-
-    def get_right_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
-        # note calculate this only once since 'orientation_z' doens't change
-        # for different shells -> scalingcenter is a fixed point
-        h0_right = smt
-        return 0, h0_right
-
-    def get_left_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
-        # note calculate this only once since orientation_z doesn't change
-        # for difference shells -> scalingcenter is a fixed point
-        h0_left = h0_right
-        return 0, h0_left
-
-    def get_right_scalingangle(self):
-        return bla
-
-    def get_left_scalingangle(self):
-        return Pi/2.0
+        # TODO clarify
+        dz_right = ((-self.particle_surface_distance + \
+                     math.sqrt(2*(self.get_searchradius()**2) - self.particle_surface_distance**2)) / 2.0)/SAFETY
+        dz_left  = dz_right
+        dr       = (self.particle_surface_distance + dz_right)/SAFETY
+        return dr, dz_right, dz_left
 
 #####
 class MixedPair3D2DtestShell(CylindricaltestShell, Others):
diff --git a/single.py b/single.py
index 77ee7904..e42ea09d 100644
--- a/single.py
+++ b/single.py
@@ -813,20 +813,25 @@ class CylindricalSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: none.
 
     """
-    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
-                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
-                 unit_r, r0, interactionrules, surface):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
+#                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
+#                 unit_r, r0, interactionrules, surface):
+
+        InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+#        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
+#                                   structure, shell_id, interactionrules, surface)
 
-        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
-                                   structure, shell_id, interactionrules, surface)
 
-        # z0 is implied to be zero (the particle being in the center of the shell in the z direction)
-        self.z0 = z0
-        self.unit_r = unit_r    # This is the vector from the cylinder to the particle
-        self.r0 = r0            # r0 is the distance from the center of the cylinder to the
-                                # center of the particle
-        self.shell = self.create_new_shell(shell_center, shell_radius,
-                                           shell_orientation_vector, shell_half_length)
+        # unit_r is the vector from the cylindrical surface to the particle
+        # r0 is the distance from the center of the cylinder to the center of the particle
+        # z0 is known to be zero (the particle being in the center of the shell in the z direction)
+        self.unit_r = self.testShell.reference_vector    
+        self.r0     = self.testShell.particle_surface_distance
+        self.z0     = 0.0
+
+#        self.shell = self.create_new_shell(shell_center, shell_radius,
+#                                           shell_orientation_vector, shell_half_length)
 
 
     def get_inner_dz_left(self):
@@ -840,7 +845,7 @@ def get_inner_sigma(self):
 
     def greens_function(self):
         # The greens function not used for the interaction but for the other coordinate
-        # Free diffusion in z direction, drift is zero.
+        # Free diffusion in z direction, drift is zero. Note that also z0 = 0.0
         return GreensFunction1DAbsAbs(self.D, 0.0, self.z0,
                                       -self.get_inner_dz_left(),
                                       self.get_inner_dz_right())
@@ -872,9 +877,10 @@ def draw_new_position(self, dt, event_type):
 
             # Direction matters, so determine the direction of the shell relative to the surface
             # first
-            direction = cmp(numpy.dot(self.shell.shape.unit_z, self.structure.shape.unit_z), 0)
+#            direction = cmp(numpy.dot(self.shell.shape.unit_z, self.structure.shape.unit_z), 0)
             # express the z_vector into the surface unit vectors to make sure that the coordinates are in the surface
-            z_vector = z * direction * self.structure.shape.unit_z
+#            z_vector = z * direction * self.structure.shape.unit_z
+            z_vector = z * self.shell.shape.unit_z
 
 
             # 2) Draw r and theta.
@@ -903,15 +909,17 @@ def draw_new_position(self, dt, event_type):
 
         return newpos
 
-    def get_shell_size(self):
-        # REMOVE this method, it doesn't mean anything here.
-        # THis method is only used for making an Interaction
-        # Heads up. The cylinder's *half_length*, not radius, 
-        # determines the size in case of a cylindrical surface.
-        return self.shell.shape.half_length
+#    def get_shell_size(self):
+#        # REMOVE this method, it doesn't mean anything here.
+#        # THis method is only used for making an Interaction
+#        # Heads up. The cylinder's *half_length*, not radius, 
+#        # determines the size in case of a cylindrical surface.
+#        return self.shell.shape.half_length
 
     def __str__(self):
-        return 'CylindricalSurfaceInteraction' + Single.__str__(self)
+        return ('CylindricalSurfaceInteraction' + Single.__str__(self) + \
+               'radius = %s, half_length = %s' %
+                (self.shell.shape.radius, self.shell.shape.half_length))
 
 class DummySingle(object):
     def __init__(self):

From 77db81f281cc8fc716573a9c5d28534a90d9abe4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 4 Jan 2012 19:40:48 +0100
Subject: [PATCH 0534/1541] removed stupid fix for stupid mistake fixed in
 previous commit -> Hoera!

---
 shells.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/shells.py b/shells.py
index b448e6b2..8e90cdaa 100755
--- a/shells.py
+++ b/shells.py
@@ -346,8 +346,6 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
             scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff - 
                                        math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
-            # FIXME UGLY FIX BELOW to prevent bogus numerical errors
-#            scale_center_shell_dist /= 1.1
 
             if scale_angle <= Pi/4.0:
                 cos_scale_angle = math.cos(scale_angle)

From 35b1e091957f7f6c780334534cb07146b338b775 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 5 Jan 2012 12:32:38 +0100
Subject: [PATCH 0535/1541] Enhanced Rootfinder of Sink GFn. Included Error
 message for 2DRadAbs drawTime. Made max domain size for interaction domain
 with cylinder: for convergence.

---
 GreensFunction1DAbsSinkAbs.cpp |  8 +++++---
 GreensFunction2DRadAbs.cpp     |  7 ++++++-
 egfrd.py                       |  3 +++
 newBDPropagator.hpp            | 22 +---------------------
 4 files changed, 15 insertions(+), 25 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 7f2eeba1..15fd0a79 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -173,7 +173,7 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     {
         int cntr = 0;
 
-        const Real delta( .1 * std::min(left_offset, right_offset) );
+        Real delta( .1 * safety * right_offset ); //std::min(left_offset, right_offset);
         const Real save_upper( upper );
         
         cntr = 0;
@@ -206,9 +206,11 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
             // Still no straddle? => Crash is imminent.
             if(cntr >= 10)
             {
-                log_.warn("Failed to straddle root# %6u . ",
+                log_.warn("Failed to straddle root# %6u. ",
                           rootList_size() + 1);
-                log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
+                log_.warn("next root est. = %.16g with stepsize: %.16g, ll: %.16g, ls: %.16g.", 
+                          next_root_est, delta, lo_up_params.last_long_root, lo_up_params.last_short_root);
+                log_.warn("f_low( %.16g ) =  %.16g, f_high( %.16g ) = %.16g.",
                           lower, f_lower, upper, f_upper);
             }
         }
diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index f469ab08..1b3e79b5 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -770,6 +770,9 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
 	Real p;
 	const unsigned int maxi( guess_maxi( t ) );	// guess the maximum number of iterations required
             
+    if( maxi == this->MAX_ALPHA_SEQ )
+        std::cerr << " p_survival_table (used by drawTime) couldn't converge; max terms reached: " << maxi << std::endl;
+           
         if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
         {						// that the table is filled
         	IGNORE_RETURN getAlpha( 0, maxi );	// this updates the table of roots
@@ -1237,7 +1240,9 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 		m++;
 		if( m >= this->MAX_ORDER )		// If the number of terms is too large
 		{
-			std::cerr << "p_m didn't converge (m=" << m << "), continuing..." << std::endl;
+			std::cerr << "p_m didn't converge (m=" << m << "), t = " << t << " r0, r = " << getr0() << ", " << r << 
+			    " t_est = " << gsl_pow_2( r - getr0() ) / getD() << ", continuing..." << std::endl;
+    		std::cerr << dump() <<std::endl;	    
 			break;
 		}
 
diff --git a/egfrd.py b/egfrd.py
index 2169bd85..eca8a50b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -450,6 +450,9 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
             z0 = numpy.dot (shell_unit_z, projected_point - shell_center)
 
+            #Very ugly hack to make the function converge for drawTime.
+            shell_radius = min( shell_radius, 1e-8 )
+
             interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
                                                         reaction_rules, structure,
                                                         shell_id, shell_center, shell_radius,
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index dc68638b..c4d31303 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -276,27 +276,7 @@ class newBDPropagator
             
             j++;
         }
-        
-        
-        /*Debug overlap failed error.
-        std::cerr << " &&&& : " << pp.first << std::endl;
-        
-        j = 0;
-        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_last( 
-                    tx_.check_overlap( particle_shape_type( new_pos, 10*r0 ), 
-                            pp.first) );
-                            
-        particles_in_overlap = overlapped_last ? overlapped_last->size(): 0;
-        while(j < particles_in_overlap)
-        {
-            particle_id_pair_and_distance const& closest( overlapped_last->at(j++) );
-            const Real dist( tx_.distance( closest.first.second.position(), pp.second.position() ) );
-            std::cerr << "### pp id: " << pp.first << " ppi id: " << closest.first.first << " ipv length @ old_pos = " << dist << 
-                " dist till shell @ new_pos: " << closest.second << std::endl;
-            std::cerr << "Bounced? " << bounced << ", d (after move) = " << tx_.distance( new_pos, closest.first.second.position() ) << std::endl;
-        }
-        */
-                       
+                               
         /* If the particle did neither react, interact or bounce, update it to it's new position. */
         if(!bounced)
         {   

From 287b3bb3dc329e2b26bc3926f20889e39f9242e9 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 5 Jan 2012 12:35:12 +0100
Subject: [PATCH 0536/1541] Included changes in pair.py for faster 1D GFs.

---
 pair.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 10482e15..18b2dde7 100644
--- a/pair.py
+++ b/pair.py
@@ -251,7 +251,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(shell_center, domains, ignore=[single1.domain_id, 
                                                                   single2.domain_id])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, single1.structure.id, ignores=[])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, ignores=[single1.structure.id])
         neighbors = neighbor_domains + neighbor_surfaces
 
 
@@ -372,7 +372,7 @@ def determine_radii(self, r0, shell_size):
         D1 = self.pid_particle_pair1[1].D
         D2 = self.pid_particle_pair2[1].D
 
-        LD_MAX = 20 # temporary value
+        LD_MAX = self.LD_MAX # temporary value
         a_r_max = LD_MAX * (r0 - self.sigma) + self.sigma
         # a_r_max is the maximum size of a_r for a given maximum ratio of l/delta
 
@@ -451,6 +451,8 @@ class SphericalPair(SimplePair):
     """
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
+
+        self.LD_MAX = 20
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 
@@ -554,6 +556,8 @@ class PlanarSurfacePair(SimplePair):
     """
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
+
+        self.LD_MAX = 20
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 
@@ -658,6 +662,8 @@ class CylindricalSurfacePair(SimplePair):
     """
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
+        self.LD_MAX = numpy.inf
+
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 

From 12dfa8bdfd56bd19cfd024cb9680049445741f0f Mon Sep 17 00:00:00 2001
From: Joris Paijmans <j.paijmans@amolf.nl>
Date: Thu, 5 Jan 2012 15:55:32 +0100
Subject: [PATCH 0537/1541] An important change in pair.py

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 18b2dde7..b81d8b39 100644
--- a/pair.py
+++ b/pair.py
@@ -251,7 +251,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(shell_center, domains, ignore=[single1.domain_id, 
                                                                   single2.domain_id])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, ignores=[single1.structure.id])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, single1.structure.id, ignores=[])
         neighbors = neighbor_domains + neighbor_surfaces
 
 

From fbbb37a0dea5c7adff056d5d35c515b2e232f067 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 5 Jan 2012 16:03:27 +0100
Subject: [PATCH 0538/1541] implemented MixedPair2D3D as part of the testShell
 framework

---
 egfrd.py  | 125 ++++-----
 pair.py   | 769 +++++++++++++++++-------------------------------------
 shells.py | 227 +++++++++++-----
 3 files changed, 471 insertions(+), 650 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ed9be579..471a3334 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -44,6 +44,7 @@
     testInteractionSingle,
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
+    MixedPair2D3DtestShell,
     )
 
 import logging
@@ -77,8 +78,8 @@ def create_default_pair(domain_id, shell_id, testShell, rrs):
         return PlanarSurfacePair      (domain_id, shell_id, testShell, rrs)
     elif isinstance(testShell, CylindricalSurfacePairtestShell):
         return CylindricalSurfacePair (domain_id, shell_id, testShell, rrs)
-    elif isinstance(testShell, MixedPair3D2DtestShell):
-        return MixedPair3D2D          (domain_id, shell_id, testShell, rrs)
+    elif isinstance(testShell, MixedPair2D3DtestShell):
+        return MixedPair2D3D          (domain_id, shell_id, testShell, rrs)
 
 def try_default_testpair(single1, single2, geometrycontainer, domains):
     if single1.structure == single2.structure:
@@ -88,10 +89,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return PlanarSurfacePairtestShell(single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, CylindricalSurface):
             return CylindricalSurfacePairtestShell(single1, single2, geometrycontainer, domains)
-#    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-#        return MixedPair3D2DtestShell(single1, single2, geometrycontainer, domains) 
-#    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-#        return MixedPair3D2DtestShell(single2, single1, geometrycontainer, domains)
+    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell(single1, single2, geometrycontainer, domains) 
+    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     else:
         raise testShellError('(MixedPair). combination of structure not supported')
         
@@ -521,18 +522,18 @@ def create_pair(self, testShell):
 
         # 2. Create pair. The type of the pair that will be created depends
         # on the structure (region or surface) the particles are in/on.  
-        if structure1 == structure2:
-            # Either SphericalPair, PlanarSurfacePair, or 
-            # CylindricalSurfacePair.
+        pair = create_default_pair(domain_id, shell_id, testShell, rrs)
+#        if structure1 == structure2:
+#            # Either SphericalPair, PlanarSurfacePair, or 
+#            # CylindricalSurfacePair.
 #            pair = create_default_pair(domain_id, single1, single2, shell_id, shell_center,
 #                                       shell_radius, r0, rrs, structure1)
-            pair = create_default_pair(domain_id, shell_id, testShell, rrs)
-        else:
-            # MixedPair (3D/2D)
-            assert shell_orientation_vector != None
-            assert shell_half_length != 0
-            pair = MixedPair(domain_id, single1, single2, shell_id, shell_center, shell_radius,
-                             shell_half_length, shell_orientation_vector, r0, rrs)
+#        else:
+#            # MixedPair (3D/2D)
+#            assert shell_orientation_vector != None
+#            assert shell_half_length != 0
+#            pair = MixedPair(domain_id, single1, single2, shell_id, shell_center, shell_radius,
+#                             shell_half_length, shell_orientation_vector, r0, rrs)
 
         assert isinstance(pair, Pair)
         pair.initialize(self.t)
@@ -879,13 +880,13 @@ def fire_single_reaction(self, single, reactant_pos):
                         # do the backtransform with a random iv with length such that the particles are at contact
                         # Note we make the iv slightly longer because otherwise the anisotropic transform will produce illegal
                         # positions
-                        iv = random_vector(particle_radius12 * MixedPair.calc_z_scaling_factor(DA, DB))
+                        iv = random_vector(particle_radius12 * MixedPair2D3D.calc_z_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
                         unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-                        newposA, newposB = MixedPair.do_back_transform(reactant_pos, iv, DA, DB,
-                                                                       productA_radius, productB_radius,
-                                                                       reactant_structure, unit_z)
+                        newposA, newposB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
+                                                                           productA_radius, productB_radius,
+                                                                           reactant_structure, unit_z)
 
                         newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
@@ -905,10 +906,10 @@ def fire_single_reaction(self, single, reactant_pos):
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
 
-                        iv = random_vector(particle_radius12 * MixedPair3D1D.calc_r_scaling_factor(DA, DB))
+                        iv = random_vector(particle_radius12 * MixedPair1D3D.calc_r_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
-                        newposA, newposB = MixedPair3D1D.do_back_transform(reactant_pos, iv, DA, DB,
+                        newposA, newposB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                            productA_radius, productB_radius, reactant_structure)
 
                         newposA = self.world.apply_boundary(newposA)
@@ -1396,41 +1397,41 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
 
 
-    def calculate_mixedpair_shell_dimensions (self, single2D, single3D):
-
-
-        # 1. Get the minimal possible shell size (including margin?)
-        r_min, z_left_min, z_right_min = MixedPair.get_min_shell_dimensions(single2D, single3D, self.geometrycontainer)
-
-        # 2. Get the maximum possible shell size
-        r, z_left, z_right = MixedPair.get_max_shell_dimensions(single2D, single3D, self.geometrycontainer, self.domains)
-
-        # Decide if MixedPair domain is possible.
-        if r < r_min or z_left < z_left_min or z_right < z_right_min:
-            if __debug__:
-                log.debug('        *MixedPair not possible:\n'
-                          '            %s +\n'
-                          '            %s.\n'
-                          '            r = %.3g. r_min = %.3g.\n'
-                          '            z_left = %.3g. z_left_min = %.3g.\n'
-                          '            z_right = %.3g. z_right_min = %.3g.' %
-                          (single2D, single3D, r, r_min, z_left, z_left_min, 
-                           z_right, z_right_min))
-            return None, None, None, None, None
-        else:
-
-            # Compute origin, radius and half_length of cylinder.
-            com, iv = MixedPair.do_transform(single2D, single3D, self.geometrycontainer.world)
-            reference_point = com
-            orientation_vector = normalize(single2D.structure.shape.unit_z * numpy.dot (iv, single2D.structure.shape.unit_z))
-            r0 = length(iv)
-
-            center = reference_point + ((z_right - z_left)/2.0) * orientation_vector
-            center = self.world.apply_boundary(center)
-            shell_half_length = (z_left + z_right) / 2.0
-            shell_radius = r
-
-            return center, shell_radius, shell_half_length, r0, orientation_vector
+#    def calculate_mixedpair_shell_dimensions (self, single2D, single3D):
+#
+#
+#        # 1. Get the minimal possible shell size (including margin?)
+#        r_min, z_left_min, z_right_min = MixedPair.get_min_shell_dimensions(single2D, single3D, self.geometrycontainer)
+#
+#        # 2. Get the maximum possible shell size
+#        r, z_left, z_right = MixedPair.get_max_shell_dimensions(single2D, single3D, self.geometrycontainer, self.domains)
+#
+#        # Decide if MixedPair domain is possible.
+#        if r < r_min or z_left < z_left_min or z_right < z_right_min:
+#            if __debug__:
+#                log.debug('        *MixedPair not possible:\n'
+#                          '            %s +\n'
+#                          '            %s.\n'
+#                          '            r = %.3g. r_min = %.3g.\n'
+#                          '            z_left = %.3g. z_left_min = %.3g.\n'
+#                          '            z_right = %.3g. z_right_min = %.3g.' %
+#                          (single2D, single3D, r, r_min, z_left, z_left_min, 
+#                           z_right, z_right_min))
+#            return None, None, None, None, None
+#        else:
+#
+#            # Compute origin, radius and half_length of cylinder.
+#            com, iv = MixedPair.do_transform(single2D, single3D, self.geometrycontainer.world)
+#            reference_point = com
+#            orientation_vector = normalize(single2D.structure.shape.unit_z * numpy.dot (iv, single2D.structure.shape.unit_z))
+#            r0 = length(iv)
+#
+#            center = reference_point + ((z_right - z_left)/2.0) * orientation_vector
+#            center = self.world.apply_boundary(center)
+#            shell_half_length = (z_left + z_right) / 2.0
+#            shell_radius = r
+#
+#            return center, shell_radius, shell_half_length, r0, orientation_vector
 
 
 
@@ -1583,19 +1584,19 @@ def process_pair_event(self, pair):
         pos2 = pid_particle_pair2[1].position
 
         # TODO store old_iv, old_com, r0 in pair object -> useless to recalculate these things all the time
-        old_com, old_iv = pair.do_transform(single1, single2, self.world)
-        r0 = length(old_iv)
+#        old_com, old_iv = pair.do_transform(single1, single2, self.world)
+#        r0 = length(old_iv)
 
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
-            pair.event_type = pair.draw_iv_event_type(r0)
+            pair.event_type = pair.draw_iv_event_type(pair.r0)
 
         self.pair_steps[pair.event_type] += 1
 
 
         # Get new position of particles
         if pair.dt > 0.0:
-            newpos1, newpos2 = pair.draw_new_positions(pair.dt, r0, old_iv, pair.event_type)
+            newpos1, newpos2 = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
             newpos1 = self.world.apply_boundary(newpos1)
             newpos2 = self.world.apply_boundary(newpos2)
 
@@ -2431,7 +2432,7 @@ def check_domain(self, domain):
         elif isinstance(domain, SphericalSingle):
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
-        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair):
+        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
             ignores = [domain.structure.id, domain.surface.id]
         else:
diff --git a/pair.py b/pair.py
index e9a089ec..3d003c5c 100644
--- a/pair.py
+++ b/pair.py
@@ -20,8 +20,8 @@
     'SphericalPair',
     'Pair',
     'SimplePair',
-    'MixedPair',
-    'MixedPair3D1D',
+    'MixedPair2D3D',
+    'MixedPair1D3D',
     ]
 
 if __debug__:
@@ -58,7 +58,10 @@ def __init__(self, domain_id, shell_id, rrs):
 
         self.interparticle_rrs = rrs
         self.interparticle_ktot = self.calc_ktot(rrs)
-        self.r0 = self.testShell.r0
+        self.com   = self.testShell.com
+        self.iv    = self.testShell.iv
+        self.r0    = self.testShell.r0
+        self.sigma = self.testShell.sigma
 
 #        self.shell_id = shell_id
 
@@ -330,32 +333,32 @@ def __init__(self, domain_id, shell_id, rrs):
 #        self.shell = self.create_new_shell(shell_center, shell_size, domain_id)
 
 
-    def getSigma(self):
-        return self.pid_particle_pair1[1].radius + \
-               self.pid_particle_pair2[1].radius
-    sigma = property(getSigma)
-
-    def get_com(self):
-        return self.shell.shape.position
-    com = property(get_com)
-
-    @classmethod
-    def do_transform(cls, single1, single2, world):
-
-        pos1 = single1.pid_particle_pair[1].position
-        pos2 = single2.pid_particle_pair[1].position
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-
-        com = world.calculate_pair_CoM(pos1, pos2, D1, D2)
-        com = world.apply_boundary(com)
-        # make sure that the com is in the structure of the particle (assume that this is done correctly in
-        # calculate_pair_CoM)
-
-        pos2t = world.cyclic_transpose(pos2, pos1)
-        iv = pos2t - pos1
+#    def getSigma(self):
+#        return self.pid_particle_pair1[1].radius + \
+#               self.pid_particle_pair2[1].radius
+#    sigma = property(getSigma)
+#
+#    def get_com(self):
+#        return self.shell.shape.position
+#    com = property(get_com)
 
-        return com, iv
+#    @classmethod
+#    def do_transform(cls, single1, single2, world):
+#
+#        pos1 = single1.pid_particle_pair[1].position
+#        pos2 = single2.pid_particle_pair[1].position
+#        D1 = single1.pid_particle_pair[1].D
+#        D2 = single2.pid_particle_pair[1].D
+#
+#        com = world.calculate_pair_CoM(pos1, pos2, D1, D2)
+#        com = world.apply_boundary(com)
+#        # make sure that the com is in the structure of the particle (assume that this is done correctly in
+#        # calculate_pair_CoM)
+#
+#        pos2t = world.cyclic_transpose(pos2, pos1)
+#        iv = pos2t - pos1
+#
+#        return com, iv
 
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
@@ -760,451 +763,175 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
         return new_iv_z
 
-    def get_shell_size(self):
-        # Heads up.
-        return self.shell.shape.half_length
+#    def get_shell_size(self):
+#        # Heads up.
+#        return self.shell.shape.half_length
 
     def __str__(self):
         return 'CylindricalSurface' + Pair.__str__(self)
 
 
-class MixedPair(Pair):
-
-    @classmethod
-    def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
-
-        assert isinstance (single1.structure, PlanarSurface)
-        assert isinstance (single2.structure, CuboidalRegion)
-
-        pos1 = single1.pid_particle_pair[1].position
-        pos2 = single2.pid_particle_pair[1].position
-        radius1 = single1.pid_particle_pair[1].radius
-        radius2 = single2.pid_particle_pair[1].radius
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-        D12 = D1 + D2
-        z_scaling = cls.calc_z_scaling_factor (D1, D2)
-
-        # calculate the interparticle vector and project it onto the coordinate system of the structure
-        # of particle1
-        pos2_t = geometrycontainer.world.cyclic_transpose(pos2, pos1)
-        iv = pos2_t - pos1
-        iv_x =     numpy.dot(iv, single1.structure.shape.unit_x)
-        iv_y =     numpy.dot(iv, single1.structure.shape.unit_y)
-        iv_z = abs(numpy.dot(iv, single1.structure.shape.unit_z))
-
-        r0 = math.sqrt( iv_x**2 + iv_y**2 + (iv_z*z_scaling)**2)
-
-        # calculate the minimal height z_right1 of the shell including burst radius
-        # with the accompanying radius r1
-        z_right1 = iv_z + radius2 * SINGLE_SHELL_FACTOR
-        r1       = cls.r_right(single1, single2, r0, z_right1)
-
-        len_iv = r0
-        iv_shell_radius1 = len_iv * D1 / D12 
-        iv_shell_radius2 = len_iv * D2 / D12 
-
-        # fix the minimum shell size for the CoM domain
-        com_shell_radius = max(radius1, radius2)
-
-        # calculate the minimal dimensions of the protective domain including space for the
-        # burst volumes of the particles
-        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * SINGLE_SHELL_FACTOR,
-                 iv_shell_radius2 + com_shell_radius + radius2 * SINGLE_SHELL_FACTOR)
-        z_right2 = cls.z_right(single1, single2, r0, r2)
-
-        # of both alternatives pick the largest one
-        z_right, r = max((z_right1, r1),(z_right2, r2))
-
-        # z_left is always the same
-        z_left = radius1
-
-        return r, z_left, z_right
-
-    @classmethod
-    def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
-        # Properties of the MixedPair system
-
-        assert isinstance (single1.structure, PlanarSurface)
-        assert isinstance (single2.structure, CuboidalRegion)
-
-        com, iv = cls.do_transform(single1, single2, geometrycontainer.world)
-        reference_point = com
-        orientation_vector = normalize(single1.structure.shape.unit_z * numpy.dot (iv, single1.structure.shape.unit_z))
-        r0 = length(iv)
-
-        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
-        # doesn't allow to check for shells outside the maximal sphere.
-        max_cylinder_radius      = geometrycontainer.get_max_shell_size()/math.sqrt(2)
-        max_cylinder_half_length = max_cylinder_radius
-
-        # set initial values of shell dimensions
-        z_left = single1.pid_particle_pair[1].radius
-        z_right = max_cylinder_half_length * 2 - z_left
-        r = max_cylinder_radius
-        
-        # get all the domains in the neighborhood
-        search_point = reference_point + ((z_right - z_left)/2.0) * orientation_vector
-        search_point = geometrycontainer.world.apply_boundary(search_point)
-        all_neighbor_ids = \
-            geometrycontainer.get_neighbors_within_radius_no_sort(search_point,
-                                                     geometrycontainer.get_max_shell_size(),
-                                                     ignore=[single1.domain_id, single2.domain_id])
-        all_neighbors = [domains[domain_id] for domain_id in all_neighbor_ids]
-
-        world = geometrycontainer.world
-
-        # adjust the maximal shell dimensions for every shell in the neighborhood
-        for domain in all_neighbors:
-            if isinstance(domain, Multi):
-                for _, shell in domain.shell_list:
-                    shell_position = shell.shape.position
-                    shell_size = shell.shape.radius
-                    r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, shell,
-                                                                     reference_point, orientation_vector, r, z_left,
-                                                                     z_right, world)
-            else:
-                shell_position = domain.shell.shape.position
-                shell_size = domain.get_shell_size()
-
-                if domain.dt == 0.0 and domain.getD() > 0:
-                    # This is one of the bursted singles.
-                    # Or a particle that just escaped it's multi.
-                    shell_size *= SINGLE_SHELL_FACTOR
-
-                r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, domain.shell,
-                                                                 reference_point, orientation_vector, r, z_left,
-                                                                 z_right, world)
-
-
-
-        return r, z_left, z_right
-
-    @classmethod
-    def laurens_algorithm(cls, single1, single2, r0, shell_position, shell_size, shell, reference_point,
-                          orientation_vector, r, z_left, z_right, world):
-
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-
-
-        # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = world.cyclic_transpose (shell_position, reference_point)
-        ref_to_shell = shell_position_t - reference_point
-        ref_to_shell_z_len = numpy.dot(ref_to_shell, orientation_vector)
-        ref_to_shell_z = ref_to_shell_z_len * orientation_vector
-        ref_to_shell_r = ref_to_shell - ref_to_shell_z
-
-        # if the shell is on the side of orientation_vector -> use z_right
-        # also use this one if the shell is in plane with the reference_point
-        if ref_to_shell_z_len >= 0:
-            phi = cls.calc_right_scalingangle(D1, D2)
-            scalecenter_h0 = cls.z_right(single1, single2, r0, 0.0)   # r = 0.0
-            r1_function =  cls.r_right
-            z1_function = cls.z_right
-            z2_function = cls.z_left
-            z1 = z_right
-            z2 = z_left
-            direction = 1           # improve direction specification such that following calculations still work
-                                    # Otherwise problems when direction = 0
-        # else -> use z_left
-        else:
-            phi = cls.calc_left_scalingangle(D1, D2)
-            scalecenter_h0 = cls.z_left(single1, single2, r0, 0.0)    # r = 0.0
-            r1_function =  cls.r_left
-            z1_function = cls.z_left
-            z2_function = cls.z_right
-            z1 = z_left
-            z2 = z_right
-            direction = -1
-
-
-        # calculate the orientation vectors
-        orientation_vector_z = orientation_vector * direction
-        if length(ref_to_shell_r) == 0:
-            # produce a random vector perpendicular to the 'orientation_vector_z'
-            unit_vector3D = random_unit_vector()
-            orientation_vector_r = normalize(unit_vector3D - numpy.dot(unit_vector3D, orientation_vector_z))
-        else:
-            orientation_vector_r = normalize(ref_to_shell_r)
-
-
-        # calculate the center from which linear scaling will take place
-        if phi == 0.0:
-            scalecenter_r0 = r  # This is an approximation, since the h0 is infinitely far away of phi == 0,
-        else:                   # we introduce an r0
-            scalecenter_r0 = 0
-
-        scale_center = reference_point + scalecenter_h0 * orientation_vector_z \
-                                       + scalecenter_r0 * orientation_vector_r
-        scale_center = world.apply_boundary(scale_center)
-
-        # calculate the vector from the scale center to the center of the shell
-        shell_position_t = world.cyclic_transpose (shell_position, scale_center)
-        shell_scale_center = shell_position_t - scale_center
-        shell_scalecenter_z = numpy.dot(shell_scale_center, orientation_vector_z)
-        shell_scalecenter_r = numpy.dot(shell_scale_center, orientation_vector_r) 
-        #length(shell_scale_center - (shell_scalecenter_z * orientation_vector_z))
-
-
-        if (type(shell.shape) is Sphere):
-
-            log.debug('sphere')
-            # calculate the angle theta of the vector from the scale center to the shell with the vector
-            # to the scale center (which is +- the orientation_vector)
-            theta = vector_angle (shell_scale_center, orientation_vector_z)
-
-            psi = theta - phi
-
-            ### check what situation arrises
-            # The shell can hit the cylinder on the flat side (situation 1),
-            #                                on the edge (situation 2),
-            #                                or on the round side (situation 3).
-            # I think this also works for phi == 0 and phi == Pi/2
-            if psi <= -phi:
-            # The midpoint of the shell lies on the axis of the cylinder
-                situation = 1
-
-            elif -phi < psi and psi < 0:
-            # The (spherical) shell can touch the cylinder on its flat side or its edge
-                if phi == Pi/2.0:
-                    r_tan_phi = 0
-                else:
-                    r_tan_phi = abs(shell_scalecenter_r)/math.tan(phi)   # phi == 0 should not get here
-                                                                         # TODO the abs may be wrong/unnecessary
-
-                a_thres = shell_scalecenter_z - r_tan_phi
-                if shell_size < a_thres:
-                    situation = 1
-                else:
-                    situation = 2
-
-            elif 0 <= psi and psi < (Pi/2.0 - phi):
-            # The (spherical) shell can touch the cylinder on its edge or its radial side
-                tan_phi = math.tan(phi)                             # phi == Pi/2 should not get here
-                a_thres = abs(shell_scalecenter_r) - shell_scalecenter_z * tan_phi  # TODO same here
-                if shell_size > a_thres:
-                    situation = 2
-                else:
-                    situation = 3
-
-            elif (Pi/2.0 - phi) <= psi:
-            # The shell is always only on the radial side of the cylinder
-                situation = 3
-
-            else:
-            # Don't know how we would get here, but it shouldn't happen
-                raise RuntimeError('Error: psi was not in valid range. psi = %s, phi = %s, theta = %s' %
-                                   (FORMAT_DOUBLE % psi, FORMAT_DOUBLE % phi, FORMAT_DOUBLE % theta))
-
-        elif (type(shell.shape) is Cylinder):
-            omega = math.atan( (shell_scalecenter_r - shell.shape.radius) / (shell_scalecenter_z - shell.shape.half_length) )
-            omega += Pi
-
-            log.debug('cylinder')
-            log.debug('omega = %s' % FORMAT_DOUBLE % omega)
-
-            if omega <= phi:
-                situation = 1
-            elif omega > phi:
-                situation = 3
-            # situation 2 does not occur since we assume that the cylinders are oriented in same direction
-
-        else:
-            raise RuntimeError('Laurens algorithm: Shelltype was unsupported')
-
-
-        if __debug__:
-            log.debug('situation = %s' % (situation))
-    #        print "h0", scalecenter_h0
-    #        print "scale_center" , scale_center
-    #        print "theta = " ,theta
-    #        print "phi= ", phi
-    #        print "psi= ", psi
-    #        print "shell_scale_center= ", shell_scale_center
-    #        print "shell_scalecenter_r= ", shell_scalecenter_r
-    #        print "shell_scalecenter_z= ", shell_scalecenter_z
-    #        print "shell_size=", shell_size
-
-
-        ### Get the right values for z and r for the given situation
-        if situation == 1:      # shell hits cylinder on the flat side
-            z1_new = min(z1, (scalecenter_h0 + shell_scalecenter_z - shell_size)/SAFETY)
-                                                        # note that shell_size may also mean half_length
-            r_new  = min(r,  r1_function(single1, single2, r0, z1_new))
-            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
-
-        elif situation == 2:    # shell hits sphere on the edge
-            a_sq = shell_size*shell_size
-            shell_scalecenter_len = length(shell_scale_center)
-            ss_sq = shell_scalecenter_len*shell_scalecenter_len
-            sin_phi = math.sin(phi)
-            sin_psi = math.sin(psi)
-            cos_psi = math.cos(psi)
-            scalecenter_shell_dist = (shell_scalecenter_len * cos_psi - math.sqrt(a_sq - ss_sq*sin_psi*sin_psi) )
-            # FIXME UGLY FIX BELOW
-            scalecenter_shell_dist /= 1.1
-            scalecenter_shell_dist /= SAFETY
-
-            if phi <= Pi/4:
-#                print "scale z first."
-                z1_new = min(z1, scalecenter_h0 + cos_phi * scalecenter_shell_dist)
-                r_new  = min(r, r1_function(single1, single2, r0, z1_new))
-                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
-            else:
-#                print "scale r first."
-                r_new = min(r, scalecenter_r0 + sin_phi * scalecenter_shell_dist)
-                z1_new = min(z1, z1_function(single1, single2, r0, r_new))
-                z2_new = min(z2, z2_function(single1, single2, r0, r_new))
-
-        elif situation == 3:    # shell hits cylinder on the round side
-            r_new = min(r, (scalecenter_r0 + abs(shell_scalecenter_r) - shell_size)/SAFETY)   # note that shell_size here means radius
-            z1_new = min(z1, z1_function(single1, single2, r0, r_new))
-            z2_new = min(z2, z2_function(single1, single2, r0, r_new))
-        else:
-            raise RuntimeError('Bad situation for MixedPair shell making')
-
-        ## DEBUGGING
-        if __debug__:
-            h_l = (z1_new + z2_new)/2.0
-#            print "h_l = ", h_l
-#            g = z1_new - h_l - scalecenter_h0
-#            print "g = ", g
-#            x = length(shell_scale_center) 
-#            print "distance = ", math.sqrt(g*g + x*x - 2.0*g*x*math.cos(theta))
-
-
-        # switch the z values in case it's necessary. r doesn't have to be switched.
-        r = r_new
-        if direction >= 0.0:
-            z_right = z1_new
-            z_left  = z2_new
-        else:
-            z_right = z2_new
-            z_left  = z1_new
-
-        ## DEBUGGING
-        if __debug__:
-            log.debug('r = %s' % (FORMAT_DOUBLE % r))
-#            print "z_left = ", z_left
-#            print "z_right = ", z_right
-
-        return r, z_left, z_right
-
-    ### class methods that are for the right side of the cylindrical shell
-    @classmethod
-    def calc_right_scalingangle(cls, D1, D2):
-        # TODO change this to scaling ratio (this saves us an unnecassary arctan)
-        D_r = D1 + D2
-        D_R = (D1*D2)/(D1 + D2)
-        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
-        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
-
-        drdz =  z_scaling_factor * ( sqrt_DRDr + max( D1/D_r, D2/D_r ))
-        angle = math.atan( drdz )
-        return angle
-
-    @classmethod
-    def z_right(cls, single1, single2, r0, r):
-        # if the radius is known and we want to determine the height z_right
-        radius1 = single1.pid_particle_pair[1].radius
-        radius2 = single2.pid_particle_pair[1].radius
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-        D_r = D1 + D2
-        D_R = (D1*D2)/(D1 + D2)
-        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
-        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
-
-        # calculate a_r such that the expected first-passage for the CoM and IV are equal
-        a_r1 = (r - radius1 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D1/D_r) )
-        a_r2 = (r - radius2 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D2/D_r) )
-        # take the smallest that, if entered in the function for r below, would lead to this z_right
-        a_r = min (a_r1, a_r2)
-
-        z_right = (a_r/z_scaling_factor) + radius2
-
-        return z_right
-
-    @classmethod
-    def r_right(cls, single1, single2, r0, z_right):
-        # if the z_right is known and we want to know the radius r
-        radius1 = single1.pid_particle_pair[1].radius
-        radius2 = single2.pid_particle_pair[1].radius
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-        D_r = D1 + D2
-        D_R = (D1*D2)/(D1 + D2)
-        z_scaling_factor = cls.calc_z_scaling_factor(D1, D2)
-        sqrt_DRDr = math.sqrt((2*D_R)/(3*D_r))
-
-        # we first calculate the a_r, since it is the only radius that depends on z_right only.
-        a_r = (z_right - radius2) * z_scaling_factor
-
-        # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
-        # Note that for the IV we only take the distance to the outer boundary into account.
-        a_R = (a_r - r0)*sqrt_DRDr
-
-        # We calculate the maximum space needed for particles A and B based on maximum IV displacement
-        iv_max = max( (D1/D_r * a_r + radius1),
-                      (D2/D_r * a_r + radius2))
-
-        r = a_R + iv_max
-        return r
-
-    ### class methods for the left side of the cylindrical shell
-    @classmethod
-    def calc_left_scalingangle(cls, D1, D2):
-        return Pi/2
-
-    @classmethod
-    def z_left(cls, single1, single2, r0, r):
-        return single1.pid_particle_pair[1].radius
-
-    @classmethod
-    def r_left(cls, single1, single2, r0, z_left):
-        # FIXME this should return the maximum of the shell container
-        return numpy.inf
+class MixedPair2D3D(Pair, Others, hasCylindricalShell):
 
+#    @classmethod
+#    def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
+#
+#        assert isinstance (single1.structure, PlanarSurface)
+#        assert isinstance (single2.structure, CuboidalRegion)
+#
+#        pos1 = single1.pid_particle_pair[1].position
+#        pos2 = single2.pid_particle_pair[1].position
+#        radius1 = single1.pid_particle_pair[1].radius
+#        radius2 = single2.pid_particle_pair[1].radius
+#        D1 = single1.pid_particle_pair[1].D
+#        D2 = single2.pid_particle_pair[1].D
+#        D12 = D1 + D2
+#        z_scaling = cls.calc_z_scaling_factor (D1, D2)
+#
+#        # calculate the interparticle vector and project it onto the coordinate system of the structure
+#        # of particle1
+#        pos2_t = geometrycontainer.world.cyclic_transpose(pos2, pos1)
+#        iv = pos2_t - pos1
+#        iv_x =     numpy.dot(iv, single1.structure.shape.unit_x)
+#        iv_y =     numpy.dot(iv, single1.structure.shape.unit_y)
+#        iv_z = abs(numpy.dot(iv, single1.structure.shape.unit_z))
+#
+#        r0 = math.sqrt( iv_x**2 + iv_y**2 + (iv_z*z_scaling)**2)
+#
+#        # calculate the minimal height z_right1 of the shell including burst radius
+#        # with the accompanying radius r1
+#        z_right1 = iv_z + radius2 * SINGLE_SHELL_FACTOR
+#        r1       = cls.r_right(single1, single2, r0, z_right1)
+#
+#        len_iv = r0
+#        iv_shell_radius1 = len_iv * D1 / D12 
+#        iv_shell_radius2 = len_iv * D2 / D12 
+#
+#        # fix the minimum shell size for the CoM domain
+#        com_shell_radius = max(radius1, radius2)
+#
+#        # calculate the minimal dimensions of the protective domain including space for the
+#        # burst volumes of the particles
+#        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * SINGLE_SHELL_FACTOR,
+#                 iv_shell_radius2 + com_shell_radius + radius2 * SINGLE_SHELL_FACTOR)
+#        z_right2 = cls.z_right(single1, single2, r0, r2)
+#
+#        # of both alternatives pick the largest one
+#        z_right, r = max((z_right1, r1),(z_right2, r2))
+#
+#        # z_left is always the same
+#        z_left = radius1
+#
+#        return r, z_left, z_right
+#
+#    @classmethod
+#    def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
+#        # Properties of the MixedPair system
+#
+#        assert isinstance (single1.structure, PlanarSurface)
+#        assert isinstance (single2.structure, CuboidalRegion)
+#
+#        com, iv = cls.do_transform(single1, single2, geometrycontainer.world)
+#        reference_point = com
+#        orientation_vector = normalize(single1.structure.shape.unit_z * numpy.dot (iv, single1.structure.shape.unit_z))
+#        r0 = length(iv)
+#
+#        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
+#        # doesn't allow to check for shells outside the maximal sphere.
+#        max_cylinder_radius      = geometrycontainer.get_max_shell_size()/math.sqrt(2)
+#        max_cylinder_half_length = max_cylinder_radius
+#
+#        # set initial values of shell dimensions
+#        z_left = single1.pid_particle_pair[1].radius
+#        z_right = max_cylinder_half_length * 2 - z_left
+#        r = max_cylinder_radius
+#        
+#        # get all the domains in the neighborhood
+#        search_point = reference_point + ((z_right - z_left)/2.0) * orientation_vector
+#        search_point = geometrycontainer.world.apply_boundary(search_point)
+#        all_neighbor_ids = \
+#            geometrycontainer.get_neighbors_within_radius_no_sort(search_point,
+#                                                     geometrycontainer.get_max_shell_size(),
+#                                                     ignore=[single1.domain_id, single2.domain_id])
+#        all_neighbors = [domains[domain_id] for domain_id in all_neighbor_ids]
+#
+#        world = geometrycontainer.world
+#
+#        # adjust the maximal shell dimensions for every shell in the neighborhood
+#        for domain in all_neighbors:
+#            if isinstance(domain, Multi):
+#                for _, shell in domain.shell_list:
+#                    shell_position = shell.shape.position
+#                    shell_size = shell.shape.radius
+#                    r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, shell,
+#                                                                     reference_point, orientation_vector, r, z_left,
+#                                                                     z_right, world)
+#            else:
+#                shell_position = domain.shell.shape.position
+#                shell_size = domain.get_shell_size()
+#
+#                if domain.dt == 0.0 and domain.getD() > 0:
+#                    # This is one of the bursted singles.
+#                    # Or a particle that just escaped it's multi.
+#                    shell_size *= SINGLE_SHELL_FACTOR
+#
+#                r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, domain.shell,
+#                                                                 reference_point, orientation_vector, r, z_left,
+#                                                                 z_right, world)
+#
+#
+#
+#        return r, z_left, z_right
 
-    ### class methods that are general
+    ################
     @classmethod
     def calc_z_scaling_factor(cls, D2d, D3d):
         # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
         return math.sqrt( (D2d + D3d) / D3d)
 
-    ################
+    def __init__(self, domain_id, shell_id, testShell, rrs):
+#    def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
+#                 shell_half_length, shell_orientation_vector, r0, rrs):
+
+#        Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
 
-    def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
-                 shell_half_length, shell_orientation_vector, r0, rrs):
+        hasCylindricalShell.__init__(self, testShell, domain_id)
+        Pair.__init__(self, domain_id, shell_id, rrs)
 
-        Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
+        assert self.testShell
+        assert isinstance(self.testShell, testMixedPair2D3D)
+        self.surface = self.testShell.surface       # the surface on which particle1 lives
+        self.structure = self.testShell.structure   # structure on which both particles live
 
-        self.surface = single1.structure    # the surface on which particle1 lives
-        self.structure = single1.structure    # the surface on which particle1 lives
-        self.r0 = r0
+        self.z_scaling_factor = self.testShell.get_scaling_factor()
 
-        self.a_R, self.a_r = self.determine_radii(shell_half_length, shell_radius)
+        # set the radii of the inner domains as a function of the outer protective domain
+#        self.r0 = r0
+        self.a_R, self.a_r = self.determine_radii()
 
-        self.shell = self.create_new_shell (shell_center, shell_radius, shell_half_length, shell_orientation_vector,
-                                            domain_id)
+#        self.shell = self.create_new_shell (shell_center, shell_radius, shell_half_length, shell_orientation_vector,
+#                                            domain_id)
 
-    def determine_radii(self, half_length, radius):
+    def determine_radii(self):
         # determines the dimensions of the domains used for the Green's functions from the dimensions
         # of the cylindrical shell.
         # Note that the function assumes that the cylinder is dimensioned properly
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
+
+        half_length = self.shell.shape.half_length
+        radius = self.shell.shape.radius
 
         # use class methods to check dimensions of the cylinder
         # note that we assume that only the z_right is scalable
-        r_check = self.r_right (self.single1, self.single2, self.r0, half_length*2 - radius1)
-        hl2_check = self.z_right (self.single1, self.single2, self.r0, radius) + \
-                    self.z_left  (self.single1, self.single2, self.r0, radius)
+        r_check   = self.testShell.r_right (half_length*2 - radius1)
+        hl2_check = self.testShell.z_right (radius) + self.testShell.z_left  (radius)
         if r_check > radius:
             # radius should have been larger, adjust z_right instead
             if __debug__:
-                log.debug('MixedPair: half_length was too high for radius. '
+                log.debug('MixedPair2D3D: half_length was too high for radius. '
                           'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
                           (radius, r_check, half_length*2, hl2_check))
 
@@ -1213,7 +940,7 @@ def determine_radii(self, half_length, radius):
         elif hl2_check > (half_length*2):
             # half_length should have been larger, adjust radius instead
             if __debug__:
-                log.debug('MixedPair: radius was too high for half_length. '
+                log.debug('MixedPair2D3D: radius was too high for half_length. '
                           'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
                           (radius, r_check, half_length*2, hl2_check))
             radius = r_check
@@ -1221,17 +948,13 @@ def determine_radii(self, half_length, radius):
             # dimensions were ok
             pass
 
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
-        D12 = D1 + D2
-
         z_left  = radius1
         z_right = half_length * 2 - z_left
         a_r = (z_right - radius2) * self.z_scaling_factor
 
         # calculate the maximal displacement of a particle given an a_r. Also include its radius
-        space_for_iv = max( (D1/D12) * a_r + radius1,
-                            (D2/D12) * a_r + radius2)
+        space_for_iv = max( (D_1/self.D_tot) * a_r + radius1,
+                            (D_2/self.D_tot) * a_r + radius2)
         a_R = radius - space_for_iv
 
 
@@ -1250,56 +973,56 @@ def determine_radii(self, half_length, radius):
 
         return a_R, a_r
 
-    def get_com(self):
-        # Note that it is implied that the center of the shell is chosen such that its projection on the
-        # membrane is the CoM of the particles.
-        dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair1[1].radius
-        return self.shell.shape.position - dist_to_surface * self.shell.shape.unit_z
-    com = property(get_com)
-
-    def get_scaling_factor(self):
-        D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
-                                                # normal to the plane
-        return math.sqrt(self.D_r/D_2)
-    z_scaling_factor = property(get_scaling_factor)
-
-    @classmethod
-    def do_transform(cls, single1, single2, world):
-
-        pos1 = single1.pid_particle_pair[1].position
-        pos2 = single2.pid_particle_pair[1].position
-        D_1 = single1.pid_particle_pair[1].D
-        D_2 = single2.pid_particle_pair[1].D
-
-        surface = single1.structure
-        # we assume that the particle of single1 lives on the membrane
-        assert isinstance(surface, PlanarSurface)
-
-
-        # the CoM is calculated in a similar way to a normal 3D pair
-        com = (D_2 * pos1 + D_1 * pos2) / (D_1 + D_2)
-        # and then projected onto the plane to make sure the CoM is in the surface
-        com = world.cyclic_transpose(com, surface.shape.position)
-        com, _ = surface.projected_point (com)
-        com = world.apply_boundary(com)
-
-        # calculate the interparticle vector
-        pos2t = world.cyclic_transpose(pos2, pos1)
-        iv = pos2t - pos1
-
-        # calculate the scaling factor due to anisotropic diffusion of iv
-        z_scaling_factor = math.sqrt((D_1 + D_2)/D_2)
-
-        # move and recale the iv in the axis normal to the plane
-        iv_z = surface.shape.unit_z * numpy.dot (iv, surface.shape.unit_z)
-        iv_z_length = length(iv_z)
-
-        new_iv_z_length = (iv_z_length) * z_scaling_factor
-        new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
-
-        iv = iv - iv_z + new_iv_z
-
-        return com, iv
+#    def get_com(self):
+#        # Note that it is implied that the center of the shell is chosen such that its projection on the
+#        # membrane is the CoM of the particles.
+#        dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair1[1].radius
+#        return self.shell.shape.position - dist_to_surface * self.shell.shape.unit_z
+#    com = property(get_com)
+#
+#    def get_scaling_factor(self):
+#        D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
+#                                                # normal to the plane
+#        return math.sqrt(self.D_r/D_2)
+#    z_scaling_factor = property(get_scaling_factor)
+#
+#    @classmethod
+#    def do_transform(cls, single1, single2, world):
+#
+#        pos1 = single1.pid_particle_pair[1].position
+#        pos2 = single2.pid_particle_pair[1].position
+#        D_1 = single1.pid_particle_pair[1].D
+#        D_2 = single2.pid_particle_pair[1].D
+#
+#        surface = single1.structure
+#        # we assume that the particle of single1 lives on the membrane
+#        assert isinstance(surface, PlanarSurface)
+#
+#
+#        # the CoM is calculated in a similar way to a normal 3D pair
+#        com = (D_2 * pos1 + D_1 * pos2) / (D_1 + D_2)
+#        # and then projected onto the plane to make sure the CoM is in the surface
+#        com = world.cyclic_transpose(com, surface.shape.position)
+#        com, _ = surface.projected_point (com)
+#        com = world.apply_boundary(com)
+#
+#        # calculate the interparticle vector
+#        pos2t = world.cyclic_transpose(pos2, pos1)
+#        iv = pos2t - pos1
+#
+#        # calculate the scaling factor due to anisotropic diffusion of iv
+#        z_scaling_factor = math.sqrt((D_1 + D_2)/D_2)
+#
+#        # move and recale the iv in the axis normal to the plane
+#        iv_z = surface.shape.unit_z * numpy.dot (iv, surface.shape.unit_z)
+#        iv_z_length = length(iv_z)
+#
+#        new_iv_z_length = (iv_z_length) * z_scaling_factor
+#        new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
+#
+#        iv = iv - iv_z + new_iv_z
+#
+#        return com, iv
 
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
@@ -1324,7 +1047,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         iv_z_length = abs(numpy.dot(iv, unit_z))   # FIXME maybe first project the shell unit_z onto the 
                                                    # surface unit_z to prevent numerical problems?
         # do the reverse scaling
-        iv_z_length = iv_z_length / cls.calc_z_scaling_factor(D1, D2)
+        iv_z_length = iv_z_length / math.sqrt(D_tot/D2)
 
         # if the particle is overlapping with the membrane, make sure it doesn't
         # IS THIS STILL NECESSARY?
@@ -1338,17 +1061,17 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
 
         return pos1, pos2
 
-    def get_sigma(self):
-        # rescale sigma to correct for the rescaling of the coordinate system
-        # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
-        # different than the sums of the radii of the particleso
-        xi = self.z_scaling_factor
-        xi_inv = 1.0/xi
-        alpha = math.acos(xi_inv)
-        sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
-        rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
-        return rho
-    sigma = property (get_sigma)
+#    def get_sigma(self):
+#        # rescale sigma to correct for the rescaling of the coordinate system
+#        # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
+#        # different than the sums of the radii of the particleso
+#        xi = self.z_scaling_factor
+#        xi_inv = 1.0/xi
+#        alpha = math.acos(xi_inv)
+#        sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
+#        rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
+#        return rho
+#    sigma = property (get_sigma)
 
     def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
@@ -1363,15 +1086,15 @@ def iv_greens_function(self, r0):
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, max(r0, self.sigma),
                                       self.sigma, self.a_r)
 
-    def create_new_shell(self, position, radius, half_length, orientation_vector, domain_id):
-        # It is assumed that the parameter are correct -> the 'bottom' of the cylinder
-        # sticks through the membrane enough to accomodate the particle in the membrane
-        # assert that orientation_vector is on same line as surface.shape.unit_z
-        return CylindricalShell(domain_id, Cylinder(position, radius, orientation_vector,
-                                                    half_length))
-
-    def get_shell_size(self):
-        return self.shell.shape.radius
+#    def create_new_shell(self, position, radius, half_length, orientation_vector, domain_id):
+#        # It is assumed that the parameter are correct -> the 'bottom' of the cylinder
+#        # sticks through the membrane enough to accomodate the particle in the membrane
+#        # assert that orientation_vector is on same line as surface.shape.unit_z
+#        return CylindricalShell(domain_id, Cylinder(position, radius, orientation_vector,
+#                                                    half_length))
+#
+#    def get_shell_size(self):
+#        return self.shell.shape.radius
 
     def get_shell_direction(self):
         return self.shell.shape.unit_z
@@ -1414,7 +1137,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
     def __str__(self):
         return 'Mixed' + Pair.__str__(self)
 
-class MixedPair3D1D(Pair):
+class MixedPair1D3D(Pair):
 
     @classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
diff --git a/shells.py b/shells.py
index 8e90cdaa..afc91d62 100755
--- a/shells.py
+++ b/shells.py
@@ -8,6 +8,7 @@
     Cylinder,
     CylindricalShell,
     PlanarSurface,
+    CuboidalRegion,
     )
 
 from utils import *
@@ -22,6 +23,7 @@
     'testInteractionSingle',
     'testPair',
     'testSimplePair',
+    'testMixedPair2D3D',
     'hasSphericalShell',
     'hasCylindricalShell',   
     'SphericalSingletestShell',
@@ -32,7 +34,7 @@
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
-    'MixedPair3D2DtestShell',
+    'MixedPair2D3DtestShell',
     ]
 
 class ShellmakingError(Exception):
@@ -123,6 +125,17 @@ def __init__(self, single1, single2):
         self.com, self.iv = self.do_transform()
         self.r0 = length(self.iv)
 
+    def get_D_tot(self):
+        return self.pid_particle_pair1[1].D + \
+               self.pid_particle_pair2[1].D
+    D_tot = property(get_D_tot)
+    D_r   = property(get_D_tot)
+
+    def get_D_R(self):
+        return (self.pid_particle_pair1[1].D *
+                self.pid_particle_pair2[1].D) / self.D_tot
+    D_R = property(get_D_R)
+
     def do_transform(self):
         pass        # overloaded later
 
@@ -135,17 +148,6 @@ def __init__(self, single1, single2):
 
         testPair.__init__(self, single1, single2)
 
-    def get_D_tot(self):
-        return self.pid_particle_pair1[1].D + \
-               self.pid_particle_pair2[1].D
-    D_tot = property(get_D_tot)
-    D_r   = property(get_D_tot)
-
-    def get_D_R(self):
-        return (self.pid_particle_pair1[1].D *
-                self.pid_particle_pair2[1].D) / self.D_tot
-    D_R = property(get_D_R)
-
     def get_sigma(self):
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
@@ -194,6 +196,67 @@ def get_min_pair_size(self):
 
         return shell_size
 
+class testMixedPair2D3D(testPair):
+
+    def __init__(self, single2D, single3D):
+
+        assert isinstance(single2D.structure, PlanarSurface) 
+        assert isinstance(single3D.structure, CuboidalRegion) 
+        self.surface   = single2D.structure         # note that these need to be initialized before calling testPair.__init__
+        self.structure = single3D.structure         # since then these are needed for calculating the transform
+
+        testPair.__init__(self, single2D, single3D)       # note that this makes self.single1/self.pid_particle_pair1 the 2D particle
+                                                    # and self.single2/self.pid_particle_pair2 the 3D particle
+    def get_sigma(self):
+        # rescale sigma to correct for the rescaling of the coordinate system
+        # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
+        # different than the sums of the radii of the particleso
+        xi = self.get_scaling_factor()
+        xi_inv = 1.0/xi
+        alpha = math.acos(xi_inv)
+        sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
+        rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
+        return rho
+    sigma = property(get_sigma)
+
+    def do_transform(self):
+        pos1 = self.pid_particle_pair1[1].position
+        pos2 = self.pid_particle_pair2[1].position
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
+
+        # the CoM is calculated in a similar way to a normal 3D pair
+        com = (D_2 * pos1 + D_1 * pos2) / (self.D_tot)
+
+        # and then projected onto the plane to make sure the CoM is in the surface
+        com = self.world.cyclic_transpose(com, self.surface.shape.position)
+        com, _ = self.surface.projected_point (com)
+        com = self.world.apply_boundary(com)
+
+
+        # calculate the interparticle vector
+        pos2t = self.world.cyclic_transpose(pos2, pos1)
+        iv = pos2t - pos1
+
+        # rescale the iv in the axis normal to the plane
+        iv_z_component = numpy.dot (iv, self.surface.shape.unit_z)
+        iv_z = self.surface.shape.unit_z * iv_z_component
+        new_iv_z = self.surface.shape.unit_z * (iv_z_component * self.get_scaling_factor())
+#        iv_z_length = abs(iv_z_component)
+#
+#        new_iv_z_length = (iv_z_length) * self.get_scaling_factor()
+#        new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
+
+        iv = iv - iv_z + new_iv_z
+
+        return com, iv
+
+    def get_scaling_factor(self):
+        D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
+                                                # normal to the plane
+        return math.sqrt(self.D_r/D_2)
+
+
 ##################################
 class hasShell(object):
 
@@ -1023,91 +1086,125 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
 #####
-class MixedPair3D2DtestShell(CylindricaltestShell, Others):
+class MixedPair2D3DtestShell(CylindricaltestShell, testMixedPair2D3D):
 
-    def __init__(self, single2D, single3D):
+    def __init__(self, single2D, single3D, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testMixedPair2D3D.__init__(self, single2D, single3D)
 
-        # scaling parameters
-        self.dzdr_right = calculate_it
-        self.drdz_right = calculate_it
+        # initialize commonly used constants
+        self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
+
+        # initialize scaling parameters
+        self.drdz_right = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.pid_particle_pair1[1].D/self.D_tot,
+                                                                              self.pid_particle_pair2[1].D/self.D_tot ))
+        self.dzdr_right = 1.0/self.drdz_right
         self.r0_right   = 0.0
-        self.z0_right   = calculate_it
+        self.z0_right   = self.z_right(self.r0_right)
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
-        self.z0_left    = particle2D_radius
+        self.z0_left    = self.pid_particle_pair1[1].radius
+
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
+                                                          [self.structure.id, self.surface.id])
+        except ShellmakingError as e:
+            raise testShellError('(MixedPair2D3D). %s' %
+                                 (str(e)))
+
 
     def get_orientation_vector(self):
-        result = do_calculation
-        return result
+        # if the dot product is negative, then take the -unit_z, otherwise take unit_z
+        return self.surface.shape.unit_z * cmp(numpy.dot(self.iv, self.surface.shape.unit_z), 0)
 
     def get_searchpoint(self):
-        return caculated_search_point
+        # TODO this can be improved, now same as PlanarSurfaceInteraction
+        search_distance = self.get_searchradius()/math.sqrt(2) - self.z0_left
+        return self.get_referencepoint() + search_distance * self.get_orientation_vector()
 
     def get_referencepoint(self):
-        return CoM
+        return self.com
 
     def get_min_dr_dzright_dzleft(self):
-        dz_left = particle_radius
-        dr, dz_right = calc_based_on_scaling_stuff
-        return (dr, dz_right, dz_left)
-        
-    def get_max_dr_dzright_dzleft(self):
-        dz_left = particle_radius
-        dr, dz_right = calc_based_on_scaling_stuff
-        return (dr, dz_right, dz_left)
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
 
-    def get_right_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
-        return 0.0, self.z_right(0.0)
 
-    def get_left_scalingcenter(self):
-        return 0.0, self.z_left(0.0)
+        ### calculate the minimal height z_right1 of the shell including burst radius
+        iv_z = self.r0      # approximation, actually the height of the domain can be slightly lower.
+        dz_right1 = iv_z + radius2 * SINGLE_SHELL_FACTOR
+        # with the accompanying radius r1
+        dr_1 = self.r_right(dz_right1)
 
-    def get_right_scalingangle(self):
-        drdz =  z_scaling_factor * ( sqrt_DRDr + max( D1/D_r, D2/D_r ))
-        angle = math.atan( drdz )
-        return angle
 
-    def get_left_scalingangle(self):
-        return Pi/2.0
+        ### calculate the minimal radius r2 of the shell including the burst radius
+        # First calculate the minimal size of the iv shell (r0 is at outer boundary)
+        iv_shell_radius1 = self.r0 * D_1 / self.D_tot
+        iv_shell_radius2 = self.r0 * D_2 / self.D_tot
+
+        # fix the minimum shell size for the CoM domain
+        com_shell_radius = max(radius1, radius2)
+
+        # calculate the minimal dimensions of the protective domain including space for the
+        # burst volumes of the particles
+        dr_2 = max(iv_shell_radius1 + com_shell_radius + radius1 * SINGLE_SHELL_FACTOR,
+                   iv_shell_radius2 + com_shell_radius + radius2 * SINGLE_SHELL_FACTOR)
+        dz_right2 = self.z_right(dr_2)
+
+        # of both alternatives pick the largest one. Here we just compare the height, but the
+        # radius scales accordingly.
+        dz_right, dr = max((dz_right1, dr_1),(dz_right2, dr_2))
+
+
+        dz_left  = self.pid_particle_pair1[1].radius
+        return dr, dz_right, dz_left
+        
+    def get_max_dr_dzright_dzleft(self):
+        # TODO this can be improved, now the shell same height as diameter
+        dr       = self.get_searchradius()/math.sqrt(2)/SAFETY
+        dz_left  = self.pid_particle_pair1[1].radius
+        dz_right = (dr * 2 - dz_left)/SAFETY
+
+        return dr, dz_right, dz_left
+
+    def z_right(self, r_right):
+        # if the radius is known and we want to determine the height z_right
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
 
-    def z_right(self, r):
         # calculate a_r such that the expected first-passage for the CoM and IV are equal
-        a_r1 = (r - radius1 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D1/D_r) )
-        a_r2 = (r - radius2 + r0*sqrt_DRDr ) / (sqrt_DRDr + (D2/D_r) )
+        a_r1 = (r_right - radius1 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_1/self.D_tot) )
+        a_r2 = (r_right - radius2 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2/self.D_tot) )
         # take the smallest that, if entered in the function for r below, would lead to this z_right
         a_r = min (a_r1, a_r2)
 
-        return (a_r/z_scaling_factor) + radius2
+        return (a_r/self.get_scaling_factor()) + radius2
+
+    def r_right(self, z_right):
+        # if the z_right is known and we want to know the radius r
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
 
-    def r_right(self, z):
         # we first calculate the a_r, since it is the only radius that depends on z_right only.
-        a_r = (z_right - radius2) * self.z_scaling_factor
+        a_r = (z_right - radius2) * self.get_scaling_factor()
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
         # Note that for the IV we only take the distance to the outer boundary into account.
-        a_R = (a_r - r0)*sqrt_DRDr
+        a_R = (a_r - self.r0)*self.sqrt_DRDr
 
         # We calculate the maximum space needed for particles A and B based on maximum IV displacement
-        iv_max = max( (D1/D_r * a_r + radius1),
-                      (D2/D_r * a_r + radius2))
+        iv_max = max( (D_1/self.D_tot * a_r + radius1),
+                      (D_2/self.D_tot * a_r + radius2))
 
         return a_R + iv_max
 
-    def z_left(self, r):
-        return single1.pid_particle_pair[1].radius
-
-    def r_left(self, z):
-        return numpy.inf
-
-
-    def get_z_scaling_factor(self):
-        D2d = self.single2D.pid_partcle_pair[1].D
-        D3d = self.single3D.pid_partcle_pair[1].D
-        return math.sqrt( (D2d + D3d) / D3d)
-
 #####
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From bf3c34e49dfee7f4802329ab17abcbcecd88a218 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 5 Jan 2012 16:24:31 +0100
Subject: [PATCH 0539/1541] removed old stuff, more to be done

---
 egfrd.py  | 331 +-----------------------------------------------------
 pair.py   | 178 -----------------------------
 single.py | 134 ----------------------
 3 files changed, 5 insertions(+), 638 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 471a3334..7e3918ed 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -72,12 +72,14 @@ def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure,
 
 
 def create_default_pair(domain_id, shell_id, testShell, rrs):
+    # Either SphericalPair, PlanarSurfacePair, or CylindricalSurfacePair.
     if   isinstance(testShell, SphericalPairtestShell):
         return SphericalPair          (domain_id, shell_id, testShell, rrs)
     elif isinstance(testShell, PlanarSurfacePairtestShell):
         return PlanarSurfacePair      (domain_id, shell_id, testShell, rrs)
     elif isinstance(testShell, CylindricalSurfacePairtestShell):
         return CylindricalSurfacePair (domain_id, shell_id, testShell, rrs)
+    # or MixedPair (3D/2D)
     elif isinstance(testShell, MixedPair2D3DtestShell):
         return MixedPair2D3D          (domain_id, shell_id, testShell, rrs)
 
@@ -94,6 +96,7 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
         return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     else:
+        # a 1D/3D pair was supposed to be formed -> unsupported
         raise testShellError('(MixedPair). combination of structure not supported')
         
 def try_default_testinteraction(single, surface, geometrycontainer, domains):
@@ -454,30 +457,9 @@ def create_interaction(self, testShell):
 #        particle_pos = pid_particle_pair[1].position
 
         if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
-#            particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
-#            projected_point, r0 = surface.projected_point(particle_pos)
-#            shell_unit_r = normalize(particle_pos - projected_point)
-#
-#            projected_point = self.world.cyclic_transpose(projected_point, shell_center)
-#            z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
-#
-#            interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
-#                                                        reaction_rules, structure,
-#                                                        shell_id, shell_center, shell_radius,
-#                                                        shell_half_length, shell_unit_z, z0,
-#                                                        shell_unit_r, r0, interaction_rules, surface)
             interaction = CylindricalSurfaceInteraction(domain_id, shell_id, testShell,
                                                         reaction_rules, interaction_rules)
         elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
-#            particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
-#            z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
-#
-#            interaction = PlanarSurfaceInteraction(domain_id, pid_particle_pair,
-#                                                   reaction_rules, structure,
-#                                                   shell_id, shell_center, shell_radius,
-#                                                   shell_half_length, shell_unit_z,
-#                                                   z0, interaction_rules, surface)
-
             interaction = PlanarSurfaceInteraction(domain_id, shell_id, testShell,
                                                    reaction_rules, interaction_rules)
 
@@ -494,15 +476,11 @@ def create_interaction(self, testShell):
 
         return interaction
 
-#    def create_pair(self, single1, single2, shell_center, shell_radius, r0, shell_half_length=0,
-#                    shell_orientation_vector=None):
     def create_pair(self, testShell):
 
 #        assert single1.dt == 0.0
 #        assert single2.dt == 0.0
 
-#        pid_particle_pair1 = single1.pid_particle_pair
-#        pid_particle_pair2 = single2.pid_particle_pair
         pid_particle_pair1 = testShell.pid_particle_pair1
         pid_particle_pair2 = testShell.pid_particle_pair2
 
@@ -523,17 +501,6 @@ def create_pair(self, testShell):
         # 2. Create pair. The type of the pair that will be created depends
         # on the structure (region or surface) the particles are in/on.  
         pair = create_default_pair(domain_id, shell_id, testShell, rrs)
-#        if structure1 == structure2:
-#            # Either SphericalPair, PlanarSurfacePair, or 
-#            # CylindricalSurfacePair.
-#            pair = create_default_pair(domain_id, single1, single2, shell_id, shell_center,
-#                                       shell_radius, r0, rrs, structure1)
-#        else:
-#            # MixedPair (3D/2D)
-#            assert shell_orientation_vector != None
-#            assert shell_half_length != 0
-#            pair = MixedPair(domain_id, single1, single2, shell_id, shell_center, shell_radius,
-#                             shell_half_length, shell_orientation_vector, r0, rrs)
 
         assert isinstance(pair, Pair)
         pair.initialize(self.t)
@@ -565,16 +532,10 @@ def create_multi(self):
 #        self.update_single_shell(single, position, radius)
 
     def update_single_shell(self, single, shell):#position, radius=None):
-#        if radius == None:
-#            # By default, don't change radius.
-#            radius = single.shell.shape.radius
-
-        # Reuse shell_id and domain_id.
+        # Reuse shell_id.
         shell_id = single.shell_id
-#        domain_id = single.domain_id
 
         # Replace shell.
-#        shell = single.create_new_shell(position, radius, domain_id)
         shell_id_shell_pair = (shell_id, shell) 
 
         single.shell_id_shell_pair = shell_id_shell_pair
@@ -1317,19 +1278,6 @@ def make_new_domain(self, single):
 
 ##### Redundant but maybe useful for parts
     def calculate_simplepair_shell_size(self, single1, single2):
-        assert single1.structure == single2.structure
-
-        # 0. Get some necessary information
-        com, iv = SimplePair.do_transform(single1, single2, self.world)
-        r0 = length (iv)
-
-        # 1. Get the minimal possible shell size (including margin?)
-        min_shell_size = SimplePair.get_min_shell_size(single1, single2, self.geometrycontainer)
-
-        # 2. Get the maximum possible shell size
-        max_shell_size = SimplePair.get_max_shell_size(com, single1, single2,
-                                                       self.geometrycontainer, self.domains)
-
         # 3. Calculate the maximum based on some other criterium (convergence?)
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
@@ -1338,19 +1286,6 @@ def calculate_simplepair_shell_size(self, single1, single2):
 #        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin                # FIXME
 #       max_shell_size = min(max_shell_size, convergence_max)
 
-
-        # 4. Check if min shell size for the Pair not larger than max shell size or 
-        # sim cell size.
-        if min_shell_size >= max_shell_size:
-            if __debug__:
-                log.debug('%s not formed: min_shell_size %s >='
-                          'max_shell_size %s' %
-                          ('Pair(%s, %s)' % (single1.pid_particle_pair[0], 
-                                             single2.pid_particle_pair[0]),
-                           FORMAT_DOUBLE % min_shell_size,
-                           FORMAT_DOUBLE % max_shell_size))
-            return None, None, None
-
         # 5. Calculate the 'ideal' shell size, it matches the expected first-passage time of the closest particle
         # with the expected time of the particles in the pair.
 #        D1 = single1.pid_particle_pair[1].D
@@ -1383,67 +1318,10 @@ def calculate_simplepair_shell_size(self, single1, single2):
                                             single2.pid_particle_pair[0]))
             return None, None, None
 
-        shell_size = min(shell_size, max_shell_size)
-
-        assert shell_size >= min_shell_size
-        assert shell_size <= max_shell_size
-
-        if __debug__:
-            log.info('SimplePair shell can be made. shell_size=%s, '
-                     'closest_shell_distance=%s,\nclosest = %s' %
-                     (FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % 0, None))
-
-        return com, r0, shell_size
-
-
-
-#    def calculate_mixedpair_shell_dimensions (self, single2D, single3D):
-#
-#
-#        # 1. Get the minimal possible shell size (including margin?)
-#        r_min, z_left_min, z_right_min = MixedPair.get_min_shell_dimensions(single2D, single3D, self.geometrycontainer)
-#
-#        # 2. Get the maximum possible shell size
-#        r, z_left, z_right = MixedPair.get_max_shell_dimensions(single2D, single3D, self.geometrycontainer, self.domains)
-#
-#        # Decide if MixedPair domain is possible.
-#        if r < r_min or z_left < z_left_min or z_right < z_right_min:
-#            if __debug__:
-#                log.debug('        *MixedPair not possible:\n'
-#                          '            %s +\n'
-#                          '            %s.\n'
-#                          '            r = %.3g. r_min = %.3g.\n'
-#                          '            z_left = %.3g. z_left_min = %.3g.\n'
-#                          '            z_right = %.3g. z_right_min = %.3g.' %
-#                          (single2D, single3D, r, r_min, z_left, z_left_min, 
-#                           z_right, z_right_min))
-#            return None, None, None, None, None
-#        else:
-#
-#            # Compute origin, radius and half_length of cylinder.
-#            com, iv = MixedPair.do_transform(single2D, single3D, self.geometrycontainer.world)
-#            reference_point = com
-#            orientation_vector = normalize(single2D.structure.shape.unit_z * numpy.dot (iv, single2D.structure.shape.unit_z))
-#            r0 = length(iv)
-#
-#            center = reference_point + ((z_right - z_left)/2.0) * orientation_vector
-#            center = self.world.apply_boundary(center)
-#            shell_half_length = (z_left + z_right) / 2.0
-#            shell_radius = r
-#
-#            return center, shell_radius, shell_half_length, r0, orientation_vector
-
-
 
     def update_single(self, single): 
         assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
-#        min_shell_size = single.get_min_shell_size()
-#        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
-#
-#        # Make sure that the new shell size is not too small or big
-#        new_shell_size = max(max_shell_size, min_shell_size)
-
         singlepos = single.pid_particle_pair[1].position
         new_shell = single.create_updated_shell(singlepos)
         assert new_shell, 'single.create_updated_shell() returned None.'
@@ -1583,10 +1461,6 @@ def process_pair_event(self, pair):
         pos1 = pid_particle_pair1[1].position
         pos2 = pid_particle_pair2[1].position
 
-        # TODO store old_iv, old_com, r0 in pair object -> useless to recalculate these things all the time
-#        old_com, old_iv = pair.do_transform(single1, single2, self.world)
-#        r0 = length(old_iv)
-
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
             pair.event_type = pair.draw_iv_event_type(pair.r0)
@@ -1825,21 +1699,7 @@ def try_interaction(self, single, surface):
 
         pid_particle_pair = single.pid_particle_pair
         particle = pid_particle_pair[1]
-#
-#        # calculate the Projected_point and distance to the surface
-#        # Cyclic transpose needed when calling surface.projected_point!
-#        pos_transposed = self.world.cyclic_transpose(particle.position, 
-#                                                     surface.shape.position) 
-#        projected_point, projection_distance = \
-#                surface.projected_point(pos_transposed)
-#
-#        # projection_distance is relative to the unit_z of the surface -> can be negative
-#        particle_distance = abs(projection_distance)
-#
-#        # For interaction with a planar surface, decide orientation. 
-#        # Note that the orientation_vector is normalized
-#        orientation_vector = cmp(projection_distance, 0) * surface.shape.unit_z 
-#
+
         if __debug__:
            log.debug('trying to form Interaction(%s, %s)' % (particle, surface))
 
@@ -1855,70 +1715,10 @@ def try_interaction(self, single, surface):
                           str(e) ))
 
 
-#        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
-#        # doesn't allow to check for shells outside the maximal sphere.
-#        max_cylinder_radius      = self.geometrycontainer.get_max_shell_size()/math.sqrt(2)
-#        max_cylinder_half_length = max_cylinder_radius
-#
-#        # Initialize dr, dz_left, dz_right to maximum allowed values.
-#        # And decide minimal dr, dz_left, dz_right.
-#        if isinstance(surface, PlanarSurface):
-#            dr = max_cylinder_radius
-#            # Leave enough for the particle itself to the left.
-#            dz_left = particle.radius
-#            dz_right = max_cylinder_half_length * 2 - dz_left
-#
-#            min_dr = particle.radius * SINGLE_SHELL_FACTOR
-#            min_dz_left = dz_left
-#            min_dz_right = particle_distance + particle.radius * SINGLE_SHELL_FACTOR
-#
-#        elif isinstance(surface, CylindricalSurface):
-#            dr = max_cylinder_radius
-#            dz_left = max_cylinder_half_length
-#            dz_right = max_cylinder_half_length
-#
-#            min_dr = particle_distance + particle.radius * SINGLE_SHELL_FACTOR
-#            min_dz_left = particle.radius * SINGLE_SHELL_FACTOR
-#            min_dz_right = particle.radius * SINGLE_SHELL_FACTOR
-#
-#        # Miedema's algorithm.
-#        dr, dz_left, dz_right = \
-#            self.calculate_max_cylinder(single, surface,
-#                                        projected_point,
-#                                        particle_distance,
-#                                        orientation_vector,
-#                                        dr, dz_left, dz_right)
-#
-#        dr /= SAFETY
-#        dz_right /= SAFETY
-#        # Don't tweak dz_left, this will break the conditions below for membrane interaction
-#        if isinstance(surface, CylindricalSurface):
-#            dz_left /= SAFETY
-#
-#        # Decide if interaction domain is possible.
-#        if dr < min_dr or dz_left < min_dz_left or dz_right < min_dz_right:
-#            if __debug__:
-#                log.debug('        *Interaction not possible:\n'
-#                          '            %s +\n'
-#                          '            %s.\n'
-#                          '            dr = %.3g. min_dr = %.3g.\n'
-#                          '            dz_left = %.3g. min_dz_left = %.3g.\n'
-#                          '            dz_right = %.3g. min_dz_right = %.3g.' %
-#                          (single, surface, dr, min_dr, dz_left, min_dz_left, 
-#                           dz_right, min_dz_right))
-#            return None
 
 #        ### 2. The shell can be made. Now do what's necessary to make it
-#        # Compute origin, radius and half_length of cylinder.
-#        origin = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
-#        origin = self.world.apply_boundary(origin)
-#        half_length = (dz_left + dz_right) / 2.0
-#        radius = dr
 
         if testShell:
-#            interaction = self.create_interaction(pid_particle_pair, surface,
-#                                                  origin, radius, half_length,
-#                                                  orientation_vector)
             interaction = self.create_interaction(testShell)
 
             interaction.dt, interaction.event_type, = interaction.determine_next_event()
@@ -1970,17 +1770,6 @@ def calculate_max_cylinder(self, single, surface, projected_point,
                                                      ignore=[single.domain_id])
         all_neighbors = [self.domains[domain_id] for domain_id in all_neighbor_ids]
 
-        for domain in all_neighbors:
-            if isinstance(domain, Multi):
-                for _, shell in domain.shell_list:
-                    shell_position = shell.shape.position
-                    shell_size = shell.shape.radius
-                    dr, dz_left, dz_right = \
-                        self.miedema_algorithm(shell_position, shell_size,
-                                               projected_point, 
-                                               orientation_vector, dr, 
-                                               dz_left, dz_right, 
-                                               surface, particle_distance)
             else:
                 # Get shell size, which normally is the radius of the 
                 # shell, but in case of a cylinder around the same 
@@ -2010,75 +1799,6 @@ def calculate_max_cylinder(self, single, surface, projected_point,
 
         return dr, dz_left, dz_right
 
-    def miedema_algorithm(self, shell_position, shell_size, projected_point,
-                          orientation_vector, dr, dz_left, dz_right,
-                          surface, particle_distance):
-        # Find optimal cylinder around particle and surface, such that 
-        # it does not interfere with the shell at position 
-        # shell_position and with size (radius or half_length) 
-        # shell_size.
-
-        shell_position = self.world.cyclic_transpose(shell_position, projected_point)
-        shell_vector = shell_position - projected_point
-
-        # Calculate zi and ri for this shell.
-        zi = numpy.dot(shell_vector, orientation_vector)
-        z_vector = zi * numpy.array(orientation_vector)
-        r_vector = numpy.array(shell_vector) - numpy.array(z_vector)
-        ri = numpy.linalg.norm(r_vector)
-
-        # Calculate dr_i for this shell.
-        dr_i = ri - shell_size
-
-        if isinstance(surface, PlanarSurface):
-            dz_right -= particle_distance
-        elif isinstance(surface, CylindricalSurface):
-            # Run Miedema's algorithm in the r direction 
-            # relative to the particle's position, not to 
-            # projected point (r=0).
-            dr_i -= particle_distance
-            dr -= particle_distance
-        else:
-            raise SystemError('Error in Miedema\'s algorithm: surface is not a Surface')
-
-        # Calculate dz_left_i or dz_right_i (both will usually 
-        # be positive values).
-        if zi < 0:
-            # Calculate dz_left_i for this shell.
-            dz_left_i = - zi - shell_size
-
-            # Miedema's algorithm left side.
-            if dz_left_i < dz_left and dr_i < dr:
-                if dz_left_i > dr_i:
-                    dz_left = dz_left_i
-                else:
-                    dr = dr_i
-        else:
-            # Calculate dz_right_i for this shell.
-            dz_right_i = zi - shell_size
-
-            if isinstance(surface, PlanarSurface):
-                # On the particle side (right side), run 
-                # Miedema's algorithm in the z direction 
-                # relative to the particle's position, not the 
-                # projected point (z=0).
-                dz_right_i -= particle_distance
-
-            # Miedema's algorithm right side.
-            if dz_right_i < dz_right and dr_i < dr:
-                if dz_right_i > dr_i:
-                    dz_right = dz_right_i
-                else:
-                    dr = dr_i
-
-        if isinstance(surface, PlanarSurface):
-            dz_right += particle_distance
-        elif isinstance(surface, CylindricalSurface):
-            dr += particle_distance
-
-        return dr, dz_left, dz_right
-
-
     def try_pair(self, single1, single2):
         if __debug__:
             log.debug('trying to form Pair(%s, %s)' %
@@ -2087,12 +1807,6 @@ def try_pair(self, single1, single2):
         assert single1.is_reset()
         assert single2.is_reset()
 
-
-#        # Try forming a Pair only if singles are on same structure.
-#        # FIXME this is already handled in the 'try_default_testpair' function
-#        if single1.structure == single2.structure:
-#            # particles are on the same structure
-
         try:
             testShell = try_default_testpair(single1, single2, self.geometrycontainer, self.domains)
         except testShellError as e:
@@ -2102,41 +1816,6 @@ def try_pair(self, single1, single2):
                           ('Pair(%s, %s)' % (single1.pid_particle_pair[0], single2.pid_particle_pair[0]),
                           str(e) ))
 
-#        elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)) ^ \
-#             (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-#            # one particle in 2D, the other in 3D
-#
-#            if __debug__:
-#                log.debug('Mixed pair')
-#
-#            # make sure that we know which single is on what structure
-#            if isinstance (single1.structure, PlanarSurface):
-#                single2D = single1
-#                single3D = single2
-#            else:
-#                single2D = single2
-#                single3D = single1
-#
-#            center, shell_radius, shell_half_length, r0, shell_orientation_vector = \
-#            self.calculate_mixedpair_shell_dimensions (single2D, single3D)
-#
-#            if shell_radius:
-#                pair = self.create_pair(single2D, single3D, center, shell_radius, r0,
-#                                        shell_half_length, shell_orientation_vector)
-#                if __debug__:
-#                    log.debug('Created: %s, shell_radius = %.3g, shell_half_length = %.3g, r0 = %.3g' %
-#                              (pair, shell_radius, shell_half_length, r0))
-#
-#            else:
-#                pair = None
-#
-#        else:
-#            # a 1D/3D pair was supposed to be formed -> unsupported
-#            if __debug__:
-#                log.debug('Pair(%s, %s) not formed: combination of structures not supported.' %
-#                          (single1.pid_particle_pair[0],
-#                           single2.pid_particle_pair[0]))
-#            pair = None
 
 
         # if a pair could be formed
diff --git a/pair.py b/pair.py
index 3d003c5c..081d2038 100644
--- a/pair.py
+++ b/pair.py
@@ -42,8 +42,6 @@ class Pair(ProtectiveDomain):
     # 5.6: ~1e-8, 6.0: ~1e-9
     CUTOFF_FACTOR = 5.6
 
-#    def __init__(self, domain_id, single1, single2, shell_id, r0, 
-#                 rrs):
     def __init__(self, domain_id, shell_id, rrs):
         ProtectiveDomain.__init__(self, domain_id, shell_id)
 
@@ -63,8 +61,6 @@ def __init__(self, domain_id, shell_id, rrs):
         self.r0    = self.testShell.r0
         self.sigma = self.testShell.sigma
 
-#        self.shell_id = shell_id
-
     def __del__(self):
         if __debug__:
             log.debug('del %s' % str(self))
@@ -316,8 +312,6 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
             return closest_distance/SAFETY
 
 
-#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-#                      r0, shell_size, rrs, structure):
     def __init__(self, domain_id, shell_id, rrs):
         Pair.__init__(self, domain_id, shell_id, rrs)
 
@@ -329,37 +323,6 @@ def __init__(self, domain_id, shell_id, rrs):
         self.a_R, self.a_r = self.determine_radii(self.r0, shell_size)
         # set the radii of the inner domains as a function of the outer protective domain
 
-# this can go
-#        self.shell = self.create_new_shell(shell_center, shell_size, domain_id)
-
-
-#    def getSigma(self):
-#        return self.pid_particle_pair1[1].radius + \
-#               self.pid_particle_pair2[1].radius
-#    sigma = property(getSigma)
-#
-#    def get_com(self):
-#        return self.shell.shape.position
-#    com = property(get_com)
-
-#    @classmethod
-#    def do_transform(cls, single1, single2, world):
-#
-#        pos1 = single1.pid_particle_pair[1].position
-#        pos2 = single2.pid_particle_pair[1].position
-#        D1 = single1.pid_particle_pair[1].D
-#        D2 = single2.pid_particle_pair[1].D
-#
-#        com = world.calculate_pair_CoM(pos1, pos2, D1, D2)
-#        com = world.apply_boundary(com)
-#        # make sure that the com is in the structure of the particle (assume that this is done correctly in
-#        # calculate_pair_CoM)
-#
-#        pos2t = world.cyclic_transpose(pos2, pos1)
-#        iv = pos2t - pos1
-#
-#        return com, iv
-
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
@@ -461,23 +424,11 @@ def determine_radii(self, r0, shell_size):
     def __str__(self):
         pass
 
-#class SphericalPair(SimplePair):
 class SphericalPair(SimplePair, Others, hasSphericalShell):
     """2 Particles inside a (spherical) shell not on any surface.
 
     """
-#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-#                 r0, shell_size, rrs, structure):
     def __init__(self, domain_id, shell_id, testShell, rrs):
-#        single1 = testShell.single1
-#        single2 = testShell.single2
-#        structure = testShell.structure
-#        shell_center = testShell.center
-#        shell_size = testShell.radius  # TODO this should be removed
-#        r0 = testShell.r0        # TODO this should be removed
-
-#        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
-#                      r0, shell_size, rrs, structure)
         hasSphericalShell.__init__(self, testShell, domain_id)
         SimplePair.__init__(self, domain_id, shell_id, rrs) # Always initialize after hasSphericalShell
 
@@ -492,10 +443,6 @@ def iv_greens_function(self, r0):
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
-# this can go
-#    def create_new_shell(self, position, radius, domain_id):
-#        return SphericalShell(domain_id, Sphere(position, radius))
-
 # this is a part of hasShell (see testShell.get_orientation_vector())
     def get_shell_direction(self):
         return random_vector(1.0)
@@ -577,24 +524,12 @@ def __str__(self):
         return 'Spherical' + Pair.__str__(self)
 
 
-#class PlanarSurfacePair(SimplePair):
 class PlanarSurfacePair(SimplePair, Others, hasCylindricalShell):
     """2 Particles inside a (cylindrical) shell on a PlanarSurface. 
     (Hockey pucks).
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
-#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-#                 r0, shell_size, rrs, structure):
-#        single1 = testShell.single1
-#        single2 = testShell.single2
-#        structure = testShell.structure
-#        shell_center = testShell.center
-#        shell_size = testShell.radius  # TODO this should be removed
-#        r0 = testShell.r0        # TODO this should be removed
-
-#        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
-#                      r0, shell_size, rrs, structure)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
@@ -605,19 +540,6 @@ def iv_greens_function(self, r0):
         return GreensFunction2DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                       self.sigma, self.a_r)
 
-#    def create_new_shell(self, position, radius, domain_id):
-#        # The half_length (thickness/2) of a hockey puck is not more 
-#        # than it has to be (namely the radius of the particle), so if 
-#        # the particle undergoes an unbinding reaction we still have to 
-#        # clear the target volume and the move may be rejected (NoSpace 
-#        # error).
-#        orientation = crossproduct(self.structure.shape.unit_x,
-#                                   self.structure.shape.unit_y)
-#        half_length = max(self.pid_particle_pair1[1].radius,
-#                          self.pid_particle_pair2[1].radius)
-#        return CylindricalShell(domain_id, Cylinder(position, radius, 
-#                                                    orientation, half_length))
-
     def get_shell_direction(self):
         return self.shell.shape.unit_z
 
@@ -692,17 +614,12 @@ def __str__(self):
         return 'PlanarSurface' + Pair.__str__(self)
 
 
-#class CylindricalSurfacePair(SimplePair):
 class CylindricalSurfacePair(SimplePair, Others, hasCylindricalShell):
     """2 Particles inside a (cylindrical) shell on a CylindricalSurface.  
     (Rods).
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
-#    def __init__(self, domain_id, shell_center, single1, single2, shell_id,
-#                 r0, shell_size, rrs, structure):
-#        SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
-#                      r0, shell_size, rrs, structure)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
@@ -727,17 +644,6 @@ def com_greens_function(self):
     def iv_greens_function(self, r0):
         return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
-#    def create_new_shell(self, position, half_length, domain_id):
-#        # The radius of a rod is not more than it has to be (namely the 
-#        # radius of the biggest particle), so if the particle undergoes 
-#        # an unbinding reaction we still have to clear the target volume 
-#        # and the move may be rejected (NoSpace error).
-#        radius = max(self.pid_particle_pair1[1].radius,
-#                     self.pid_particle_pair2[1].radius)
-#        orientation = self.structure.shape.unit_z
-#        return CylindricalShell(domain_id, Cylinder(position, radius, 
-#                                                    orientation, half_length))
-
     def get_shell_direction(self):
         return self.shell.shape.unit_z
 
@@ -763,10 +669,6 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
         return new_iv_z
 
-#    def get_shell_size(self):
-#        # Heads up.
-#        return self.shell.shape.half_length
-
     def __str__(self):
         return 'CylindricalSurface' + Pair.__str__(self)
 
@@ -890,11 +792,6 @@ def calc_z_scaling_factor(cls, D2d, D3d):
         return math.sqrt( (D2d + D3d) / D3d)
 
     def __init__(self, domain_id, shell_id, testShell, rrs):
-#    def __init__(self, domain_id, single1, single2, shell_id, shell_center, shell_radius,
-#                 shell_half_length, shell_orientation_vector, r0, rrs):
-
-#        Pair.__init__(self, domain_id, single1, single2, shell_id, r0, rrs)
-
         hasCylindricalShell.__init__(self, testShell, domain_id)
         Pair.__init__(self, domain_id, shell_id, rrs)
 
@@ -906,11 +803,8 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.z_scaling_factor = self.testShell.get_scaling_factor()
 
         # set the radii of the inner domains as a function of the outer protective domain
-#        self.r0 = r0
         self.a_R, self.a_r = self.determine_radii()
 
-#        self.shell = self.create_new_shell (shell_center, shell_radius, shell_half_length, shell_orientation_vector,
-#                                            domain_id)
 
     def determine_radii(self):
         # determines the dimensions of the domains used for the Green's functions from the dimensions
@@ -973,56 +867,6 @@ def determine_radii(self):
 
         return a_R, a_r
 
-#    def get_com(self):
-#        # Note that it is implied that the center of the shell is chosen such that its projection on the
-#        # membrane is the CoM of the particles.
-#        dist_to_surface = self.shell.shape.half_length - self.pid_particle_pair1[1].radius
-#        return self.shell.shape.position - dist_to_surface * self.shell.shape.unit_z
-#    com = property(get_com)
-#
-#    def get_scaling_factor(self):
-#        D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
-#                                                # normal to the plane
-#        return math.sqrt(self.D_r/D_2)
-#    z_scaling_factor = property(get_scaling_factor)
-#
-#    @classmethod
-#    def do_transform(cls, single1, single2, world):
-#
-#        pos1 = single1.pid_particle_pair[1].position
-#        pos2 = single2.pid_particle_pair[1].position
-#        D_1 = single1.pid_particle_pair[1].D
-#        D_2 = single2.pid_particle_pair[1].D
-#
-#        surface = single1.structure
-#        # we assume that the particle of single1 lives on the membrane
-#        assert isinstance(surface, PlanarSurface)
-#
-#
-#        # the CoM is calculated in a similar way to a normal 3D pair
-#        com = (D_2 * pos1 + D_1 * pos2) / (D_1 + D_2)
-#        # and then projected onto the plane to make sure the CoM is in the surface
-#        com = world.cyclic_transpose(com, surface.shape.position)
-#        com, _ = surface.projected_point (com)
-#        com = world.apply_boundary(com)
-#
-#        # calculate the interparticle vector
-#        pos2t = world.cyclic_transpose(pos2, pos1)
-#        iv = pos2t - pos1
-#
-#        # calculate the scaling factor due to anisotropic diffusion of iv
-#        z_scaling_factor = math.sqrt((D_1 + D_2)/D_2)
-#
-#        # move and recale the iv in the axis normal to the plane
-#        iv_z = surface.shape.unit_z * numpy.dot (iv, surface.shape.unit_z)
-#        iv_z_length = length(iv_z)
-#
-#        new_iv_z_length = (iv_z_length) * z_scaling_factor
-#        new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
-#
-#        iv = iv - iv_z + new_iv_z
-#
-#        return com, iv
 
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
@@ -1061,18 +905,6 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
 
         return pos1, pos2
 
-#    def get_sigma(self):
-#        # rescale sigma to correct for the rescaling of the coordinate system
-#        # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
-#        # different than the sums of the radii of the particleso
-#        xi = self.z_scaling_factor
-#        xi_inv = 1.0/xi
-#        alpha = math.acos(xi_inv)
-#        sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
-#        rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
-#        return rho
-#    sigma = property (get_sigma)
-
     def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
 
@@ -1086,16 +918,6 @@ def iv_greens_function(self, r0):
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, max(r0, self.sigma),
                                       self.sigma, self.a_r)
 
-#    def create_new_shell(self, position, radius, half_length, orientation_vector, domain_id):
-#        # It is assumed that the parameter are correct -> the 'bottom' of the cylinder
-#        # sticks through the membrane enough to accomodate the particle in the membrane
-#        # assert that orientation_vector is on same line as surface.shape.unit_z
-#        return CylindricalShell(domain_id, Cylinder(position, radius, orientation_vector,
-#                                                    half_length))
-#
-#    def get_shell_size(self):
-#        return self.shell.shape.radius
-
     def get_shell_direction(self):
         return self.shell.shape.unit_z
 
diff --git a/single.py b/single.py
index e42ea09d..6def581c 100644
--- a/single.py
+++ b/single.py
@@ -39,14 +39,11 @@ class Single(ProtectiveDomain):
     specified.
 
     """
-#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure):
     def __init__(self, domain_id, shell_id, reactionrules):
         ProtectiveDomain.__init__(self, domain_id, shell_id)
 
         self.multiplicity = 1                           # all singles have only one particle
 
-#        self.pid_particle_pair = pid_particle_pair      # the particle in the single
-#        self.structure = structure                      # the structure in/on which the particle lives
         assert self.testShell
         assert isinstance(self.testShell, testSingle)
         self.pid_particle_pair = self.testShell.pid_particle_pair      # the particle in the single
@@ -153,26 +150,9 @@ class NonInteractionSingle(Single):
         * Decay process of the particle
 
     """
-#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-#                 structure):
     def __init__(self, domain_id, shell_id, reactionrules):
-#        Single.__init__(self, domain_id, pid_particle_pair, reactionrules,
-#                        structure)
-
         Single.__init__(self, domain_id, shell_id, reactionrules)
 
-        # Create shell.
-#        self.shell_id = shell_id
-#        self.shell = self.create_new_shell(pid_particle_pair[1].position,
-#                                      pid_particle_pair[1].radius, domain_id)
-
-#    def get_shell_size(self):
-#        # Note: this method only means something for Protective Domains that can
-#        # only be sized in one direction
-#        # This is predominantly used when making Interaction domains
-#        return self.shell.shape.radius
-
-
     def initialize(self, t):
         # self.shell.shape.radius = self.pid_particle_pair[1].radius
         self.dt = 0.0
@@ -265,9 +245,6 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
 
 
 ### this can probably both go
-    def get_min_shell_size(self):
-        return self.pid_particle_pair[1].radius
-
     def get_max_shell_size(self, geometrycontainer, domains):
         # This calculates the maximum shell size that the single can have in the current
         # situation.
@@ -319,7 +296,6 @@ def get_max_shell_size(self, geometrycontainer, domains):
         return min(new_shell_size, geometrycontainer.get_max_shell_size())
 
 
-#class SphericalSingle(NonInteractionSingle):
 class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalShell):
     """1 Particle inside a (spherical) shell not on any surface.
 
@@ -330,30 +306,16 @@ class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalS
           theta, phi.
 
     """
-#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-#                 structure):
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
-        # This should also be moved to single, since it's the same for all NonInteractionSingles
-        # -> change constructor
-#        pid_particle_pair = testShell.pid_particle_pair
-#        structure = testShell.structure
-
         assert isinstance(testShell, SphericalSingletestShell)
 
         hasSphericalShell.__init__(self, testShell, domain_id)           # here also the shell is created
-#        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-#                                      shell_id, reactionrules, structure)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
     def greens_function(self):
         return GreensFunction3DAbsSym(self.getD(),
                                           self.get_inner_a())
 
-# this can go
-#    def create_new_shell(self, position, radius, domain_id):
-#        return SphericalShell(self.domain_id, Sphere(position, radius))
-
-# instead we have this
     # specific shell methods for the SphericalSingle
     # these return potentially corrected dimensions
     def shell_list_for_single(self):
@@ -391,7 +353,6 @@ def __str__(self):
         return 'Spherical' + Single.__str__(self)
 
 
-#class PlanarSurfaceSingle(NonInteractionSingle):
 class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a PlanarSurface. (Hockey 
     pucks).
@@ -402,39 +363,14 @@ class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylind
         * Selected randomly when drawing displacement vector: theta.
 
     """
-#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-#                 structure):
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
-#        pid_particle_pair = testShell.pid_particle_pair
-#        structure = testShell.structure
         hasCylindricalShell.__init__(self, testShell, domain_id)
-#        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-#                                      shell_id, reactionrules, structure)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
     def greens_function(self):
         return GreensFunction2DAbsSym(self.D,
                                           self.get_inner_a())
-# this can go
-#    def create_new_shell(self, position, radius, domain_id):
-#        # The half_length (thickness) of a hockey puck is not more than 
-#        # it has to be (namely the radius of the particle), so if the 
-#        # particle undergoes an unbinding reaction we still have to 
-#        # clear the target volume and the move may be rejected (NoSpace 
-#        # error).
-#
-#        # Note that the calculateion of the position of the shell needs to make sure that the
-#        # coordinates are in the surface
-#        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
-#        pos_x = self.structure.shape.unit_x * numpy.dot (position, self.structure.shape.unit_x)
-#        pos_y = self.structure.shape.unit_y * numpy.dot (position, self.structure.shape.unit_y)
-#
-#        position = self.structure.shape.position + pos_x + pos_y
-#        orientation = self.structure.shape.unit_z
-#        half_length = self.pid_particle_pair[1].radius
-#        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
-#                                                    orientation, half_length))
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
@@ -480,7 +416,6 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
-#class CylindricalSurfaceSingle(NonInteractionSingle):
 class CylindricalSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a CylindricalSurface. 
     (Rods).
@@ -490,10 +425,6 @@ class CylindricalSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasC
         * Initial position: z = 0.
         * Selected randomly when drawing displacement vector: none.
     """
-#    def __init__(self, domain_id, pid_particle_pair, shell_id, reactionrules, 
-#                 structure):
-#        NonInteractionSingle.__init__(self, domain_id, pid_particle_pair, 
-#                                      shell_id, reactionrules, structure)
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         hasCylindricalShell.__init__(self, testShell, domain_id)
@@ -503,11 +434,6 @@ def getv(self):
         return self.pid_particle_pair[1].v
     v = property(getv)
 
-#    def get_shell_size(self):
-#        # Heads up. The cylinder's *half_length*, not radius, 
-#        # determines the size in case of a cylindrical surface.
-#        return self.shell.shape.half_length
-
     def get_inner_a(self):
         # Here the free coordinate is not the radius of the domain as in the
         # PlanarSurfaceSingle and SphericalSingle, although it is treated as a
@@ -519,24 +445,6 @@ def greens_function(self):
         inner_half_length = self.get_inner_a()
         return GreensFunction1DAbsAbs(self.D, self.v, 0.0, -inner_half_length, inner_half_length)
 
-#    def create_new_shell(self, position, half_length, domain_id):
-#        # The radius of a rod is not more than it has to be (namely the 
-#        # radius of the particle), so if the particle undergoes an 
-#        # unbinding reaction we still have to clear the target volume 
-#        # and the move may be rejected.
-#
-#        # Note that the calculation of the position of the shell has to make sure that the
-#        # coordinates are in the surface
-#        unit_z = self.structure.shape.unit_z
-#        position = position - self.structure.shape.position     # TODO this can go wrong if either positions are near the boundaries
-#        pos_z = unit_z * numpy.dot (position, unit_z)
-#
-#        position = self.structure.shape.position + pos_z
-#        radius = self.pid_particle_pair[1].radius
-#        orientation = unit_z
-#        return CylindricalShell(self.domain_id, Cylinder(position, radius, 
-#                                                    orientation, half_length))
-
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
@@ -603,8 +511,6 @@ class InteractionSingle(Single, hasCylindricalShell, Others):
         * Diffusion in the direction that is normal the the direction of interaction
         * Decay of the particle into a different or no particle
     """
-#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure, shell_id,   
-#                 interactionrules, surface):
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
         hasCylindricalShell.__init__(self, testShell, domain_id)
@@ -613,7 +519,6 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
 
         Single.__init__(self, domain_id, shell_id, reactionrules)
 
-#        self.shell_id = shell_id
         self.interactionrules = interactionrules        # the surface interaction 'reactions'
         self.intrule = None
         self.interaction_ktot = self.calc_ktot(interactionrules)
@@ -643,11 +548,6 @@ def initialize(self, t):
         self.last_time = t
         self.event_type = None
 
-#        # This is defined here, but only used in the subclasses
-#    def create_new_shell(self, position, radius, orientation_vector, half_length):
-#        return CylindricalShell(self.domain_id, Cylinder(position, radius,
-#                                                    orientation_vector, half_length))
-
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
@@ -693,25 +593,17 @@ class PlanarSurfaceInteraction(InteractionSingle):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
-#                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
-#                 interactionrules, surface):
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
         # shell_orientation_vector and z0 are supplied by arguments because Domains can't do
         # spatial calculations (they don't know about the world)
         # NOTE shell_orientation_vector should be normalized and pointing from the surface to the particle!
 
-#        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
-#                                   structure, shell_id, interactionrules, surface)
         InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
         # z0 is the initial position of the particle relative to the center
         # of the shell in the direction normal to the surface (so z0 is usually negative).
         self.z0 = -self.get_inner_dz_left() + self.testShell.particle_surface_distance
 
-#        self.shell = self.create_new_shell(shell_center, shell_radius, 
-#                                           shell_orientation_vector, shell_half_length)
-
     def get_inner_dz_right(self):
         # This is the distance from the center of the shell
         # to the flat boundary away from the surface
@@ -789,14 +681,6 @@ def draw_new_position(self, dt, event_type):
 
         return newpos
 
-
-#    def get_shell_size(self):
-#        # REMOVE this method, it doesn't mean anything here.
-#        # THis method is only used for making an Interaction
-#        # Heads up. The cylinder's *half_length*, not radius, 
-#        # determines the size in case of a cylindrical surface.
-#        return self.shell.shape.radius
-
     def __str__(self):
         return ('PlanarSurfaceInteraction' + Single.__str__(self) + \
                'radius = %s, half_length = %s' %
@@ -814,14 +698,7 @@ class CylindricalSurfaceInteraction(InteractionSingle):
 
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
-#    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
-#                 shell_id, shell_center, shell_radius, shell_half_length, shell_orientation_vector, z0,
-#                 unit_r, r0, interactionrules, surface):
-
         InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
-#        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
-#                                   structure, shell_id, interactionrules, surface)
-
 
         # unit_r is the vector from the cylindrical surface to the particle
         # r0 is the distance from the center of the cylinder to the center of the particle
@@ -830,10 +707,6 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         self.r0     = self.testShell.particle_surface_distance
         self.z0     = 0.0
 
-#        self.shell = self.create_new_shell(shell_center, shell_radius,
-#                                           shell_orientation_vector, shell_half_length)
-
-
     def get_inner_dz_left(self):
         return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
@@ -909,13 +782,6 @@ def draw_new_position(self, dt, event_type):
 
         return newpos
 
-#    def get_shell_size(self):
-#        # REMOVE this method, it doesn't mean anything here.
-#        # THis method is only used for making an Interaction
-#        # Heads up. The cylinder's *half_length*, not radius, 
-#        # determines the size in case of a cylindrical surface.
-#        return self.shell.shape.half_length
-
     def __str__(self):
         return ('CylindricalSurfaceInteraction' + Single.__str__(self) + \
                'radius = %s, half_length = %s' %

From 63c456c421688d22e03f7ee7d356586f5755a234 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 5 Jan 2012 16:36:44 +0100
Subject: [PATCH 0540/1541] cleanup

---
 shells.py | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/shells.py b/shells.py
index afc91d62..89e7a8c1 100755
--- a/shells.py
+++ b/shells.py
@@ -263,9 +263,6 @@ class hasShell(object):
     def __init__(self, testShell):
         pass
 
-#    def shell_list(self):
-#            return self.shell_list
-
 #######################
 class hasSphericalShell(hasShell):
 # The testShell is now converted into smt that we can use in the domain instance
@@ -466,6 +463,7 @@ def __init__(self, cylindricaltestShell, domain_id):
         hasShell.__init__(self, cylindricaltestShell)
 
         self.testShell = cylindricaltestShell
+        # Compute origin, radius and half_length of cylinder.
         self.shell_center, self.shell_radius, self.shell_half_length = \
                     self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
                                                        self.testShell.get_orientation_vector(),
@@ -588,15 +586,6 @@ def get_radius_to_shell(self, shell, domain_to_scale, r):
         return min(r, r_new)
 
 
-class PlanarSurfaceInteraction(hasCylindricalShell, Others):
-    pass
-class CylindricalSurfaceInteraction(hasCylindricalShell, Others):
-    pass
-class MixedPair3D2D(hasCylindricalShell, Others):
-    pass
-#class MixedPair3D1D(hasCylindricalShell):
-
-
 #######################################################
 #######################################################
 class testShell(object):
@@ -667,8 +656,7 @@ def get_searchpoint(self):
     def get_searchradius(self):
         return self.geometrycontainer.get_max_shell_size()
     def get_orientation_vector(self):
-#        return unit_vector # TODO much faster and doesn't matter anyway
-        return random_vector(1.0)
+        return self.structure.unit_z #unit_vector # TODO much faster and doesn't matter anyway
 
     def get_max_radius(self):
         return self.get_searchradius()/SAFETY

From 7281126a5414a2dfb968245daf576024858f7d74 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Jan 2012 16:01:48 +0100
Subject: [PATCH 0541/1541] add comments and clarifications

---
 shells.py | 396 +++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 273 insertions(+), 123 deletions(-)

diff --git a/shells.py b/shells.py
index 89e7a8c1..7980c287 100755
--- a/shells.py
+++ b/shells.py
@@ -37,44 +37,75 @@
     'MixedPair2D3DtestShell',
     ]
 
+# These are exceptions that are raise when trying to make a new domain
 class ShellmakingError(Exception):
+    # This ShellmakingError is raised when a Spherical or Cylindrical shell could
+    # not be made, usually due to the fact that the possible shell dimensions are
+    # smaller than the minimal dimensions.
     pass
 
 class testShellError(Exception):
+    # The testShellError is raised when the testShell could not be made, usually
+    # due to a ShellmakingError
     pass
 
+####################################
+
+# To make sure that Pairs and Interaction domain keep some distance from NonInteractionSingle domains,
+# the domain that is being made asks the neighboring domains what their size is. This allows the
+# neighboring domain to change its appeared size depending on who asks.
+# To this end, the two classes below define methods that allow an existing domain to return its shell
+# dimensions dependent on the one who asks. The asker and the askee are now both a NonInteractionSingle
+# or an Other.
+# The main difference between the NonInteractionSingles and Others is that the NonInteractionSingle
+# keep the Other domains at a distance such that the probably that the Other domain get bursted is
+# minimized.
 class Others(object):
+# Subclasses of Others are: all Pair, Interaction and Multi domains.
 
     def __init__(self):
         pass    # do nothing
-    # stuff for hasShell subclasses
+
+    # The next two methods are only relevant for HASSHELL subclasses that derive from this class.
     def shell_list_for_single(self):
+        # The shell dimensions for the Other classes are unmodified, regardless of the asker.
         return self.shell_list
     def shell_list_for_other(self):
         return self.shell_list
 
-    # stuff for testShell subclasses
+
+    # The next method is only relevant for TESTSHELL subclasses that derive from this class.
     def get_neighbor_shell_list(self, neighbor):
-        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        # This gets the shells of an existing domain given that the testShell is of the type Other
         return neighbor.shell_list_for_other()
 
 class NonInteractionSingles(object):
+# Subclasses of NonInteractionSingles are: all NonInteractionSingle domains (Spherical, etc)
 
     def __init__(self):
         pass    # do nothing
-    # stuff for hasShell subclasses
+
+    # The next two methods are only relevant for HASSHELL subclasses that derive from this class.
     def shell_list_for_single(self):
-        pass    # needs to be overloaded
+        # In case the asker is also a NonInteractionSingle, the shell dimensions of the current domain
+        # is modified such that the domain is at least the size of the Multi shell.
+        pass    # needs to be specified in the subclass
     def shell_list_for_other(self):
-        pass    # needs to be overloaded
+        # In case the asker is an Other, the shell dimensions of the current NonInteractionSingle domain
+        # is modified such that the domain is at least its minimum size (SINGLE_SHELL_FACTOR).
+        # This is to reduce unnecessary bursting of the (expensive) Other domains.
+        pass    # needs to be specified in the subclass
+
 
-    # stuff for testShell subclasses
+    # The next method is only relevant for TESTSHELL subclasses that derive from this class.
     def get_neighbor_shell_list(self, neighbor):
-        # note that this returns the list of shells, NOT dr, dz_right, dz_left
+        # This gets the shells of an existing domain given that the testShell is of the type Other
         return neighbor.shell_list_for_single()
 
 ##################################
-
+# Below classes define the minimal information needed to try to make a domain of a certain type.
+# They implement the non geometric aspect of the testShells, and are inherited by the respective testShell
+# classes.
 class testSingle(object):
 
     def __init__(self, pid_particle_pair, structure):
@@ -85,16 +116,18 @@ class testNonInteractionSingle(testSingle, NonInteractionSingles):
 
     def __init__(self, pid_particle_pair, structure):
         testSingle.__init__(self, pid_particle_pair, structure)
+        # Note: for the NonInteractionSingles superclass nothing is to be initialized.
 
 class testInteractionSingle(testSingle, Others):
 
     def __init__(self, single, structure, surface):
         testSingle.__init__(self, single.pid_particle_pair, structure)
+        # Note: for the Others superclass nothing is to be initialized.
 
         self.single  = single
         self.surface = surface
 
-        ### initialize some constants that are common for the interactions
+        ### initialize some constants that are common for the testInteractionSingle domains.
 
         # calculate the Projected_point and distance to the surface
         # Cyclic transpose needed when calling surface.projected_point!
@@ -109,14 +142,15 @@ def __init__(self, single, structure, surface):
         # The reference_vector is the normalized vector from the reference_point to the particle
         self.reference_vector = normalize(pos_transposed - self.reference_point)
 
-
 ##############
 class testPair(Others):
+
     def __init__(self, single1, single2):
+        # Note: for the Others superclass nothing is to be initialized.
 
         # assert both reset
-        assert single1.dt == 0.0
-        assert single2.dt == 0.0
+        assert single1.is_reset()
+        assert single2.is_reset()
 
         self.single1 = single1
         self.single2 = single2
@@ -124,6 +158,10 @@ def __init__(self, single1, single2):
         self.pid_particle_pair2 = single2.pid_particle_pair
         self.com, self.iv = self.do_transform()
         self.r0 = length(self.iv)
+        assert self.r0 >= self.sigma, \
+            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
+            (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma))
+
 
     def get_D_tot(self):
         return self.pid_particle_pair1[1].D + \
@@ -137,12 +175,14 @@ def get_D_R(self):
     D_R = property(get_D_R)
 
     def do_transform(self):
-        pass        # overloaded later
+        # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
+        pass        # overridden in subclasses
 
 class testSimplePair(testPair):
+
     def __init__(self, single1, single2):
 
-        # simple pairs are pairs of particles on the same structure
+        # Simple pairs are pairs of particles that are on the same structure
         assert single1.structure == single2.structure
         self.structure = single1.structure
 
@@ -155,13 +195,14 @@ def get_sigma(self):
     sigma = property(get_sigma)
 
     def do_transform(self):
-    # TODO replace with get_com, get_iv methods/properties
+        # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
+
         pos1 = self.pid_particle_pair1[1].position
         pos2 = self.pid_particle_pair2[1].position
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
 
-        com = self.world.calculate_pair_CoM(pos1, pos2, D1, D2)
+        com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
         com = self.world.apply_boundary(com)
         # make sure that the com is in the structure of the particle (assume that this is done correctly in
         # calculate_pair_CoM)
@@ -172,18 +213,19 @@ def do_transform(self):
         return com, iv
 
     def get_min_pair_size(self):
-        # TODO Is this assert here ok?
-        assert self.r0 >= self.sigma, \
-            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
-            (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma))
+        # This calculates the minimal 'size' of a simple pair.
+        # Note that the 'size' is interpreted differently dependent on the type of pair. When the pair is a
+        # SphericalPair          -> size = radius
+        # PlanarSurfacePair      -> size = radius
+        # CylindricalSurfacePair -> size = half_length
 
-        D1 = self.pid_particle_pair1[1].D
-        D2 = self.pid_particle_pair2[1].D
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
 
-        dist_from_com1 = self.r0 * D1 / self.D_tot      # particle distance from CoM
-        dist_from_com2 = self.r0 * D2 / self.D_tot
+        dist_from_com1 = self.r0 * D_1 / self.D_tot      # particle distance from CoM
+        dist_from_com2 = self.r0 * D_2 / self.D_tot
         iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
         iv_shell_size2 = dist_from_com2 + radius2
 
@@ -205,8 +247,9 @@ def __init__(self, single2D, single3D):
         self.surface   = single2D.structure         # note that these need to be initialized before calling testPair.__init__
         self.structure = single3D.structure         # since then these are needed for calculating the transform
 
-        testPair.__init__(self, single2D, single3D)       # note that this makes self.single1/self.pid_particle_pair1 the 2D particle
-                                                    # and self.single2/self.pid_particle_pair2 the 3D particle
+        testPair.__init__(self, single2D, single3D) # note: this makes self.single1/self.pid_particle_pair1 the 2D particle
+                                                    #              and self.single2/self.pid_particle_pair2 the 3D particle
+
     def get_sigma(self):
         # rescale sigma to correct for the rescaling of the coordinate system
         # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
@@ -220,13 +263,14 @@ def get_sigma(self):
     sigma = property(get_sigma)
 
     def do_transform(self):
+        # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
         pos1 = self.pid_particle_pair1[1].position
         pos2 = self.pid_particle_pair2[1].position
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
         # the CoM is calculated in a similar way to a normal 3D pair
-        com = (D_2 * pos1 + D_1 * pos2) / (self.D_tot)
+        com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
 
         # and then projected onto the plane to make sure the CoM is in the surface
         com = self.world.cyclic_transpose(com, self.surface.shape.position)
@@ -240,24 +284,25 @@ def do_transform(self):
 
         # rescale the iv in the axis normal to the plane
         iv_z_component = numpy.dot (iv, self.surface.shape.unit_z)
-        iv_z = self.surface.shape.unit_z * iv_z_component
+        iv_z     = self.surface.shape.unit_z * iv_z_component
         new_iv_z = self.surface.shape.unit_z * (iv_z_component * self.get_scaling_factor())
-#        iv_z_length = abs(iv_z_component)
-#
-#        new_iv_z_length = (iv_z_length) * self.get_scaling_factor()
-#        new_iv_z = (new_iv_z_length / iv_z_length) * iv_z
 
         iv = iv - iv_z + new_iv_z
 
         return com, iv
 
     def get_scaling_factor(self):
+        # This returns the scaling factor needed to make the anisotropic diffusion problem of the IV
+        # into a isotropic one.
         D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
                                                 # normal to the plane
         return math.sqrt(self.D_r/D_2)
 
 
 ##################################
+# These classes define the geometric aspect of the existing domains. When making a domain, the domain
+# has a Shell (hence the hasShell class name).
+# They are initialized using the testShell of the appropriate type.
 class hasShell(object):
 
     def __init__(self, testShell):
@@ -265,16 +310,19 @@ def __init__(self, testShell):
 
 #######################
 class hasSphericalShell(hasShell):
-# The testShell is now converted into smt that we can use in the domain instance
+    # This class is inherited by domains that have a Spherical shell such as the SphericalSingle and a SphericalPair.
+    # The class makes the appropriate shell for the domain and allows a testShell to ask what the maximum dimensions
+    # of the testShell can be. This means, how far can the testShell be scaled according to its scaling rules before
+    # it hits THIS Spherical shell.
 
     def __init__(self, sphericaltestShell, domain_id):
-    # Note that the Multi should not call __init__ because we don't want to initialize the shell
+        # Note1: the Multi should not call __init__ because we don't want to initialize the shell
+        # Note2: the hasShell.__init__ is not called because nothing happens there
 
         assert isinstance(sphericaltestShell, SphericaltestShell)
-
-        hasShell.__init__(self, sphericaltestShell)
-
         self.testShell = sphericaltestShell
+
+        # Make the appropriate shell.
         self.shell_center = sphericaltestShell.center
         self.shell_radius = sphericaltestShell.radius
         self.shell = self.create_new_shell(self.shell_center,
@@ -284,23 +332,27 @@ def __init__(self, sphericaltestShell, domain_id):
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
 
-    # methods to size up a shell to this shell
-    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
-        # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
-        # CylindricaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
+    # methods to size up a testShell to this domain.
+    def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
+        # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
+        # using the spherical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
+        # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
+        # smaller.
 
-        assert (type(shell.shape) is Sphere)        # because the shell actually is part of the current object
+        # Note that the 'shell' is querried from this domain earlier by the testShell.
+        # -> the shell MUST be a Sphere
+        assert (type(shell.shape) is Sphere)
 
-        # Do Laurens' algorithm (part1)
+        # Laurens' algorithm (part1)
         shell_position = shell.shape.position
         shell_radius = shell.shape.radius
 
         # get the reference point and orientation of the domain to scale
-        reference_point = domain_to_scale.get_referencepoint()
-        orientation_vector = domain_to_scale.get_orientation_vector()
+        reference_point = testShell.get_referencepoint()
+        orientation_vector = testShell.get_orientation_vector()
 
         # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = domain_to_scale.world.cyclic_transpose (shell_position, reference_point)
+        shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
         ref_to_shell_vec = shell_position_t - reference_point
         ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
 
@@ -309,21 +361,21 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         if ref_to_shell_z >= 0:
             direction = 1           # improve direction specification such that following calculations still work
                                     # Otherwise problems when direction = 0
-            scale_angle = domain_to_scale.right_scalingangle
-            scale_center_r, scale_center_z = domain_to_scale.right_scalingcenter 
-            r1_function =  domain_to_scale.r_right
-            z1_function = domain_to_scale.z_right
-            z2_function = domain_to_scale.z_left
+            scale_angle = testShell.right_scalingangle
+            scale_center_r, scale_center_z = testShell.right_scalingcenter 
+            r1_function =  testShell.r_right
+            z1_function = testShell.z_right
+            z2_function = testShell.z_left
             z1 = z_right
             z2 = z_left
         # else -> use z_left
         else:
             direction = -1
-            scale_angle = domain_to_scale.left_scalingangle
-            scale_center_r, scale_center_z = domain_to_scale.left_scalingcenter 
-            r1_function =  domain_to_scale.r_left
-            z1_function = domain_to_scale.z_left
-            z2_function = domain_to_scale.z_right
+            scale_angle = testShell.left_scalingangle
+            scale_center_r, scale_center_z = testShell.left_scalingcenter 
+            r1_function =  testShell.r_left
+            z1_function = testShell.z_left
+            z2_function = testShell.z_right
             z1 = z_left
             z2 = z_right
 
@@ -337,8 +389,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         scale_center_to_shell_r = ref_to_shell_r - scale_center_r
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
-        # calculate the angle shell_angle of the vector from the scale center to the shell with the vector
-        # to the scale center (which is +- the orientation_vector)
+        # calculate the angle 'shell_angle' of the vector from the 'scale_center' to the shell with the vector
+        # from the 'reference_point' to the 'scale_center' (which is +- the orientation_vector).
         shell_angle = math.atan(scale_center_to_shell_r/scale_center_to_shell_z)
 
         if scale_center_to_shell_z < 0.0:
@@ -436,33 +488,36 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         return r, z_right, z_left
 
 
-    def get_radius_to_shell(self, shell, domain_to_scale, r):
-        # SphericaltestShell ('domain_to_scale') -> SphericalShell ('self' with 'shell_appearance')
+    def get_radius_to_shell(self, shell, testShell, r):
+        # This function returns the radius for the spherical 'testShell' using the spherical 'shell' as its closest
+        # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
+        # therefore only become smaller.
 
-        assert (type(shell.shape) is Sphere)        # because the shell actually originated here
-        # Do simple distance calculation to sphere
+        # Note that the 'shell' is querried from this domain earlier by the testShell.
+        # -> the shell MUST be a Sphere
+        assert (type(shell.shape) is Sphere)
 
-        scale_point = domain_to_scale.center
-        r_new = domain_to_scale.world.distance(shell.shape, scale_point)/SAFETY
+        # Do simple distance calculation to sphere
+        scale_point = testShell.center
+        r_new = testShell.world.distance(shell.shape, scale_point)/SAFETY
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
 
-#####
-class Multi(hasSphericalShell, Others):
-
-    pass
-
 #########################
 class hasCylindricalShell(hasShell):
+    # This class is inherited by domains that have a Cylindrical shell such as the PlanarSurfaceNonInteractionSingle
+    # and a MixedPair2D3D.
+    # The class makes the appropriate shell for the domain and allows a testShell to ask what the maximum dimensions
+    # of the testShell can be. This means, how far can the testShell be scaled according to its scaling rules before
+    # it hits THIS Cylindrical shell.
 
     def __init__(self, cylindricaltestShell, domain_id):
+        # Note: the hasShell.__init__ is not called because nothing happens there
 
         assert isinstance(cylindricaltestShell, CylindricaltestShell)
-
-        hasShell.__init__(self, cylindricaltestShell)
-
         self.testShell = cylindricaltestShell
+
         # Compute origin, radius and half_length of cylinder.
         self.shell_center, self.shell_radius, self.shell_half_length = \
                     self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
@@ -471,7 +526,7 @@ def __init__(self, cylindricaltestShell, domain_id):
                                                        self.testShell.dz_right,
                                                        self.testShell.dz_left)
         self.shell_center = self.testShell.world.apply_boundary(self.shell_center)
-
+        # Make the shell.
         self.shell = self.create_new_shell(self.shell_center,
                                            self.shell_radius,
                                            self.shell_half_length,
@@ -479,6 +534,10 @@ def __init__(self, cylindricaltestShell, domain_id):
 
     @ classmethod
     def r_zright_zleft_to_r_center_hl(cls, referencepoint, orientation_vector, dr, dz_right, dz_left):
+        # Converts the dr, dz_right and dz_left to the center, radius and half_length of the cylinder
+        # The dr, dz_right, dz_left are used to scale the cylinder, whereas the center, radius and
+        # half_length are used to use the cylinderical shell as an actual shell (and no longer as a testShell).
+
         center = referencepoint + ((dz_right - dz_left)/2.0) * orientation_vector
         radius = dr
         half_length = (dz_left + dz_right) / 2.0
@@ -488,24 +547,29 @@ def create_new_shell(self, position, radius, half_length, domain_id):
         orientation = self.testShell.get_orientation_vector()
         return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
 
-    def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_left):
-        # This will scale the 'domain_to_scale' (a cylinder) using the 'shell_appearance' as the limiting shell
-        # CylindricaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
+    # methods to size up a testShell to this domain.
+    def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
+        # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
+        # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
+        # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
+        # smaller.
 
-        assert (type(shell.shape) is Cylinder)        # because the shell actually originated here
-        # Do Laurens' algorithm (part2)
+        # Note that the 'shell' is querried from this domain earlier by the testShell.
+        # -> the shell MUST be a Cylinder.
+        assert (type(shell.shape) is Cylinder)
 
+        # Laurens' algorithm (part2)
         shell_position = shell.shape.position
         shell_radius = shell.shape.radius
         shell_half_length = shell.shape.half_length
 
 
         # get the reference point and orientation of the domain to scale
-        reference_point = domain_to_scale.get_referencepoint()
-        orientation_vector = domain_to_scale.get_orientation_vector()
+        reference_point = testShell.get_referencepoint()
+        orientation_vector = testShell.get_orientation_vector()
 
         # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = domain_to_scale.world.cyclic_transpose (shell_position, reference_point)
+        shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
         ref_to_shell_vec = shell_position_t - reference_point
         ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
 
@@ -514,21 +578,21 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
         if ref_to_shell_z >= 0:
             direction = 1           # improve direction specification such that following calculations still work
                                     # Otherwise problems when direction = 0
-            scale_angle = domain_to_scale.right_scalingangle
-            scale_center_r, scale_center_z = domain_to_scale.right_scalingcenter 
-            r1_function =  domain_to_scale.r_right
-            z1_function = domain_to_scale.z_right
-            z2_function = domain_to_scale.z_left
+            scale_angle = testShell.right_scalingangle
+            scale_center_r, scale_center_z = testShell.right_scalingcenter 
+            r1_function =  testShell.r_right
+            z1_function = testShell.z_right
+            z2_function = testShell.z_left
             z1 = z_right
             z2 = z_left
         # else -> use z_left
         else:
             direction = -1
-            scale_angle = domain_to_scale.left_scalingangle
-            scale_center_r, scale_center_z = domain_to_scale.left_scalingcenter 
-            r1_function =  domain_to_scale.r_left
-            z1_function = domain_to_scale.z_left
-            z2_function = domain_to_scale.z_right
+            scale_angle = testShell.left_scalingangle
+            scale_center_r, scale_center_z = testShell.left_scalingcenter 
+            r1_function =  testShell.r_left
+            z1_function = testShell.z_left
+            z2_function = testShell.z_right
             z1 = z_left
             z2 = z_right
 
@@ -573,14 +637,18 @@ def get_dr_dzright_dzleft_to_shell(self, shell, domain_to_scale, r, z_right, z_l
 
         return r, z_right, z_left
 
-    def get_radius_to_shell(self, shell, domain_to_scale, r):
-        # SphericaltestShell ('domain_to_scale') -> CylindricalShell ('self' with 'shell_appearance')
+    def get_radius_to_shell(self, shell, testShell, r):
+        # This function returns the radius for the spherical 'testShell' using the cylindrical 'shell' as its closest
+        # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
+        # therefore only become smaller.
 
-        assert (type(shell.shape) is Cylinder)        # because the shell actually originated here
-        # Do simple distance calculation to cylinder
+        # Note that the 'shell' is querried from this domain earlier by the testShell.
+        # -> the shell MUST be a Cylinder
+        assert (type(shell.shape) is Cylinder)
 
-        scale_point = domain_to_scale.center
-        r_new = domain_to_scale.world.distance(shell.shape, scale_point)/SAFETY
+        # Do simple distance calculation to cylinder
+        scale_point = testShell.center
+        r_new = testShell.world.distance(shell.shape, scale_point)/SAFETY
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
@@ -589,6 +657,10 @@ def get_radius_to_shell(self, shell, domain_to_scale, r):
 #######################################################
 #######################################################
 class testShell(object):
+    # The testShell represents the geometric aspect of the domain that we are trying to make
+    # A testShell can be Spherical (SphericaltestShell) or Cylindrical (CylindricaltestShell)
+    # Both have different rules for doing the nearest neighbor search and geometrically sizing up
+    #  the prospective domain
 
     def __init__(self, geometrycontainer, domains):
         self.geometrycontainer = geometrycontainer
@@ -596,6 +668,8 @@ def __init__(self, geometrycontainer, domains):
         self.domains = domains
 
     def get_neighbors(self, ignore, ignores):
+        # The get_neighbors is general to all types of testShells.
+        # It finds the neighboring domains and surfaces.
         searchpoint = self.get_searchpoint()
         radius = self.get_searchradius()
 
@@ -604,24 +678,31 @@ def get_neighbors(self, ignore, ignores):
         return neighbor_domains, neighbor_surfaces
 
     def get_orientation_vector(self):
-        pass    # overloaded later
+        # The orientation of the shell
+        pass    # overridden later
 
 ########################
 class SphericaltestShell(testShell):
+    # The SphericaltestShell is the geometric aspect of testDomains with a spherical shell.
 
     def __init__(self, geometrycontainer, domains):
         testShell.__init__(self, geometrycontainer, domains)
 
-        self.center = None          # there are the parameters that we ultimately want to know
-        self.radius = 0
+        self.center = None          # These are the parameters that define the dimensions of
+        self.radius = 0             # the spherical shell -> will be determined later.
 
     def determine_possible_shell(self, ignore, ignores):
+        # This determines the largest possible radius of the spherical testShell or throws an
+        # exception if the domain could not be made due to geometrical constraints.
+
         neighbor_domains, neighbor_surfaces = self.get_neighbors (ignore, ignores)
         min_radius = self.get_min_radius()
         max_radius = self.get_max_radius()
 
+        # initialize the radius to start the scaling of the sphere
         radius = max_radius
-        # first check the surfaces
+
+        # first check the maximum radius against the surfaces
         for surface, distance in neighbor_surfaces:
             # FIXME ugly hack to make spherical singles overlap with membranes
             if isinstance(surface, PlanarSurface) and isinstance(self, SphericalSingletestShell):
@@ -632,8 +713,10 @@ def determine_possible_shell(self, ignore, ignores):
                                        'surface = %s, distance = %s, testShell = %s' %
                                        (surface, distance, self))
 
-        # then check the domains
         # TODO first sort the neighbors -> faster to find if we fail
+
+        # then check against all the shells of the neighboring domains (remember that domains can have
+        # multiple shells).
         for neighbor, _ in neighbor_domains:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
@@ -652,13 +735,18 @@ def determine_possible_shell(self, ignore, ignores):
         return radius
 
     def get_searchpoint(self):
+        # The search point from where to search for neighboring domains.
         return self.center
     def get_searchradius(self):
+        # the search radius is the radius in which to find neighboring domains. Usually just the
+        # max shell size.
         return self.geometrycontainer.get_max_shell_size()
     def get_orientation_vector(self):
-        return self.structure.unit_z #unit_vector # TODO much faster and doesn't matter anyway
+        # The orientation of the sphere is irrelevant, but needs to be defined.
+        return self.structure.unit_z    # NOTE: Is self.structure always well defined??
 
     def get_max_radius(self):
+        # The maximum radius of the spherical testShell.
         return self.get_searchradius()/SAFETY
 
 #####
@@ -670,6 +758,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
 
         self.center = self.pid_particle_pair[1].position
         self.radius = self.pid_particle_pair[1].radius
+        # Here determine_possible_shell is not called since the NonInteractionSingle should never fail
 
     def get_min_radius(self):
         return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR / SAFETY    # the minimum radius of a NonInteractionSingle
@@ -694,21 +783,36 @@ def get_min_radius(self):
 
 ##########################
 class CylindricaltestShell(testShell):
+    # The CylindricaltestShell is the geometric aspect of testDomains with a cylindrical shell.
+    # Note that the dimensions of the cylindrical test shell are expressed in dr, dz_right and
+    # dz_left, whereas the dimensions of a 'real' cylindrical shell are expressed in center,
+    # radius and half_length.
 
     def __init__(self, geometrycontainer, domains):
         testShell.__init__(self, geometrycontainer, domains)
 
-        self.dz_right = 0
+        self.dr       = 0           # These are the parameters that define the dimensions of
+        self.dz_right = 0           # the cylindrical shell -> will be determined later.
         self.dz_left  = 0
-        self.dr       = 0
+        # dr is the radius of the cylinder.
+        # dz_right is the distance between the 'reference point' and the face of the
+        #   cylinder on the side of the 'orientation vector'.
+        # dz_left is the distance from the 'reference point' to the face of the cylinder
+        #   on the side oposite of the 'orientation vector'.
+
 
     def determine_possible_shell(self, ignore, ignores):
+        # This determines the maximum dr, dz_right, dz_left of the cylindrical testShell or
+        # throws an exception if the domain could not be made due to geometrical constraints.
+
         neighbor_domains, neighbor_surfaces = self.get_neighbors (ignore, ignores)
         min_dr, min_dz_right, min_dz_left = self.get_min_dr_dzright_dzleft()
         max_dr, max_dz_right, max_dz_left = self.get_max_dr_dzright_dzleft()
 
+        # initialize the parameters to start the scaling of the cylinder
         dr, dz_right, dz_left = max_dr, max_dz_right, max_dz_left
-        # first check the surfaces
+
+        # first check the maximum dr, dz_right, dz_left against the surfaces
 #        for surface, distance in neighbor_surfaces:
 #            radius = min(radius, distance)     # TODO
 #            if radius < min_radius:
@@ -716,8 +820,10 @@ def determine_possible_shell(self, ignore, ignores):
 #                                       'surface = %s, distance = %s, testShell = %s' %
 #                                       (surface, distance, self))
 
-        # then check the domains
-        # TODO first sort the neighbors -> faster to find if we fail
+        # TODO first sort the neighbors to distance -> faster to find if we fail
+
+        # then check against all the shells of the neighboring domains (remember that domains can have
+        # multiple shells).
         for neighbor, distance in neighbor_domains:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
@@ -737,11 +843,28 @@ def determine_possible_shell(self, ignore, ignores):
         
         return dr, dz_right, dz_left
 
+    def get_searchpoint(self):
+        # The search point from where to search for neighboring domains.
+        pass
+
     def get_searchradius(self):
+        # the search radius is the radius in which to find neighboring domains. Usually just the
+        # max shell size.
         return self.geometrycontainer.get_max_shell_size()
 
+    def get_orientation_vector(self):
+        # The orientation_vector just defines the direction of the shell. It also defines what
+        # SIDE is 'right' and what side is 'left'.
+        pass
+
+    def get_referencepoint(self):
+        # The reference point is where the 'orientation_vector' starts and defines what PART of the
+        # cylinder is 'right' and what part if 'left'.
+        pass
 
-    # default functions for evaluating z_right/z_left/r after one of parameters changed
+    # These methods are used to calculate the new r/z_right/z_left after one of the parameters 
+    # r/z_right/z_left has changed. The scaling centers (r0, z0) and scaling directions drdz
+    # are defined differently for every testShell.
     def r_right(self, z_right):
         return self.drdz_right * (z_right - self.z0_right) + self.r0_right
     def z_right(self, r_right):
@@ -752,20 +875,25 @@ def z_left(self, r_left):
         return self.dzdr_left * (r_left - self.r0_left) + self.z0_left
 
     def get_right_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
+        # Returns the location of the scaling center on the 'right side' of the cylinder in the
+        # coordinates r, z defined by the plane cutting through the axis of the cylindrical
+        # testShell and the center of the shell that is being scaled to.
+        # Note0: the 'right side' is the side of the cylinder were the 'orientation_vector' points.
+        # Note1: we assume cylindrical symmetry around the axis.
+        # Note2: the coordinates are relative to the 'side' (right/left) of the cylinder.
         return self.r0_right, self.z0_right
     right_scalingcenter = property(get_right_scalingcenter)
 
     def get_left_scalingcenter(self):
-        # returns the scaling center in the cylindrical coordinates r, z of the shell
-        # Note that we assume cylindrical symmetry
-        # Note also that it is relative to the 'side' (right/left) of the cylinder
+        # Returns the location of the scaling center on the 'left side' of the cylinder.
+        # Note: the 'left side' is the side of the cylinder opposite of were the 'orientation_vector' points.
         return self.r0_left, self.z0_left
     left_scalingcenter = property(get_left_scalingcenter)
 
     def get_right_scalingangle(self):
+        # The scaling angle is the angle with the axis of the cylinder of the cone along which the
+        # edge of the cylinder moves while scaling.
+        # Note again that 'right' is the side where the 'orientation_vector' points.
         if self.drdz_right == numpy.inf:
             right_scaling_angle = Pi/2.0       # atan(infinity) == Pi/2 -> angle is 90 degrees
         elif self.drdz_right == 0.0:
@@ -785,9 +913,14 @@ def get_left_scalingangle(self):
         return left_scaling_angle
     left_scalingangle = property(get_left_scalingangle)
 
+    def get_min_dr_dzright_dzleft(self):
+        # This defines the minimal dimensions in terms of r, z_right, z_left of the cylindrical domain
+        # that we're trying to make. The exact values vary between type of domain.
+        # If a nearby domain would make it smaller than this, an exception will be thrown.
+        pass
 
     def get_max_dr_dzright_dzleft(self):
-        pass    # todo, we should be able to derive this from the scaling parameters and searchpoint
+        pass
 
 #####
 class PlanarSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
@@ -796,7 +929,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
-        # scaling parameters
+        # initialize the scaling parameters
         self.dzdr_right = 0.0
         self.drdz_right = numpy.inf
         self.r0_right   = 0.0
@@ -810,6 +943,8 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
         self.dr       = self.pid_particle_pair[1].radius
+        # Here determine_possible_shell is not called since the making of a NonInteractionSingle
+        # should never fail
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z   # just copy from structure
@@ -842,7 +977,7 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testSimplePair.__init__(self, single1, single2)
 
-        # scaling parameters
+        # initialize the scaling parameters
         self.dzdr_right = 0.0
         self.drdz_right = numpy.inf
         self.r0_right   = 0.0
@@ -852,6 +987,9 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.z0_right
 
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
@@ -888,7 +1026,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
-        # scaling parameters
+        # initialize the scaling parameters
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
         self.r0_right   = self.pid_particle_pair[1].radius
@@ -946,6 +1084,9 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         self.r0_left    = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         self.z0_left    = 0.0
 
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
@@ -992,6 +1133,9 @@ def __init__(self, single, surface, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.pid_particle_pair[1].radius
 
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
@@ -1042,6 +1186,9 @@ def __init__(self, single, surface, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = -self.particle_surface_distance
 
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
@@ -1083,7 +1230,7 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         # initialize commonly used constants
         self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
 
-        # initialize scaling parameters
+        # initialize the scaling parameters
         self.drdz_right = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.pid_particle_pair1[1].D/self.D_tot,
                                                                               self.pid_particle_pair2[1].D/self.D_tot ))
         self.dzdr_right = 1.0/self.drdz_right
@@ -1094,6 +1241,9 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.pid_particle_pair1[1].radius
 
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],

From 981143cc558e209060947cea154eb462c27efec5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Jan 2012 16:54:40 +0100
Subject: [PATCH 0542/1541] added comments and some asserts (and stuff)

---
 single.py | 89 ++++++++++++++-----------------------------------------
 1 file changed, 22 insertions(+), 67 deletions(-)

diff --git a/single.py b/single.py
index 6def581c..e7808e03 100644
--- a/single.py
+++ b/single.py
@@ -42,10 +42,11 @@ class Single(ProtectiveDomain):
     def __init__(self, domain_id, shell_id, reactionrules):
         ProtectiveDomain.__init__(self, domain_id, shell_id)
 
+        assert self.testShell                           # make sure that the hasShell class was initialized earlier
+        assert isinstance(self.testShell, testSingle)
+
         self.multiplicity = 1                           # all singles have only one particle
 
-        assert self.testShell
-        assert isinstance(self.testShell, testSingle)
         self.pid_particle_pair = self.testShell.pid_particle_pair      # the particle in the single
         self.structure = self.testShell.structure                      # the structure in/on which the particle lives
 
@@ -137,7 +138,7 @@ def __str__(self):
                                              self.pid_particle_pair[1].position)
 
 
-class NonInteractionSingle(Single):
+class NonInteractionSingle(Single, NonInteractionSingles):
     """1 Particle inside a shell, no other particles around. 
 
     There are 3 types of NonInteractionSingles:
@@ -152,9 +153,9 @@ class NonInteractionSingle(Single):
     """
     def __init__(self, domain_id, shell_id, reactionrules):
         Single.__init__(self, domain_id, shell_id, reactionrules)
+        # Note: for the NonInteractionSingles superclass nothing is to be initialized.
 
     def initialize(self, t):
-        # self.shell.shape.radius = self.pid_particle_pair[1].radius
         self.dt = 0.0
         self.last_time = t
         self.event_type = EventType.SINGLE_ESCAPE
@@ -244,59 +245,7 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
         return shell_size
 
 
-### this can probably both go
-    def get_max_shell_size(self, geometrycontainer, domains):
-        # This calculates the maximum shell size that the single can have in the current
-        # situation.
-        # TODO This is now general for all NonInteractionSingles and should be different
-        # for the different dimensions since they have different domains (spheres vs cylinders)
-        # and scale the domains in different directions (r or z).
-
-        # 1. Calculate the maximal dimensions of the shell
-        # TODO We now just check in a sphere around the particle and size accordingly. For
-        # NonInteractionSingles on the dna and membrane this is quite inefficient-> want to
-        # size in the appropriate coordinate (r or z).
-        singlepos = self.pid_particle_pair[1].position
-#        closest, distance_to_shell = \
-#            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
-#                                              ignores=[self.structure.id])
-
-        neighbor_domains = geometrycontainer.get_neighbor_domains(singlepos, domains, ignore=[self.domain_id, ])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, ignores=[self.structure.id])
-        neighbors = neighbor_domains + neighbor_surfaces
-
-        # 2. Calculate the maximum allowed radius of the spherical domain
-        # check ALL domains, not just nearest neighbor but also next nearest etc, and get the nearest one.
-        # In case the neighbor was a NonInteractionSingle we may need to tweak the distance
-        distance_domain_closest = (numpy.inf, None)
-        for domain, distance in neighbors:
-            if isinstance(domain, NonInteractionSingle):
-                # leave at least MULTI_SHELL_FACTOR space for another NonInteractionSingle (to make sure that
-                # the other single will not have an overlapping multi shell when starting to multi
-                distance_max = geometrycontainer.world.distance(singlepos, domain.pid_particle_pair[1].position)
-                distance = min(distance, distance_max - domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR)
-                # TODO check this!
-            elif isinstance(domain, PlanarSurface):
-                distance = distance + self.pid_particle_pair[1].radius
-
-            # get the minimum of currect and previous minimum
-            distance_domain = (distance, domain)
-            distance_domain_closest = min(distance_domain_closest, distance_domain)
-
-        distance_to_shell, closest = distance_domain_closest
-
-        # 3. Apply still other rules if the nearest is another NonInteractionSingle (optimization)
-        # TODO shell size has no real meaning for cylinderical domains
-        if isinstance(closest, NonInteractionSingle):
-            new_shell_size = self.calculate_shell_size_to_single(closest, distance_to_shell,
-                                                                 geometrycontainer)
-        else:  # Pair or Multi or Surface
-            new_shell_size = distance_to_shell / SAFETY
-
-        return min(new_shell_size, geometrycontainer.get_max_shell_size())
-
-
-class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalShell):
+class SphericalSingle(NonInteractionSingle, hasSphericalShell):
     """1 Particle inside a (spherical) shell not on any surface.
 
         * Particle coordinate inside shell: r, theta, phi.
@@ -309,6 +258,7 @@ class SphericalSingle(NonInteractionSingle, NonInteractionSingles, hasSphericalS
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
         assert isinstance(testShell, SphericalSingletestShell)
 
+        assert isinstance(testShell, SphericalSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)           # here also the shell is created
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
@@ -318,12 +268,14 @@ def greens_function(self):
 
     # specific shell methods for the SphericalSingle
     # these return potentially corrected dimensions
+    # For explanation see NonInteractionSingles and Others in shells.py
     def shell_list_for_single(self):
         min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
 #        min_radius = self.testShell.get_min_radius()
         if  self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
+            # TODO maybe just returning the dimension instead of actually making the shell is cheaper.
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -338,6 +290,7 @@ def shell_list_for_other(self):
             return self.shell_list
 
     def create_updated_shell(self, position):
+        # TODO what should we do with the position now?
         try:
             radius = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
             return self.create_new_shell(position, radius, self.domain_id)
@@ -353,7 +306,7 @@ def __str__(self):
         return 'Spherical' + Single.__str__(self)
 
 
-class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylindricalShell):
+class PlanarSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a PlanarSurface. (Hockey 
     pucks).
 
@@ -365,6 +318,7 @@ class PlanarSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylind
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
+        assert isinstance(testShell, PlanarSurfaceSingletestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
@@ -373,6 +327,7 @@ def greens_function(self):
                                           self.get_inner_a())
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+    # For explanation see NonInteractionSingles and Others in shells.py
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
@@ -416,7 +371,7 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
-class CylindricalSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasCylindricalShell):
+class CylindricalSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a CylindricalSurface. 
     (Rods).
 
@@ -427,6 +382,7 @@ class CylindricalSurfaceSingle(NonInteractionSingle, NonInteractionSingles, hasC
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
+        assert isinstance(testShell, CylindricalSurfaceSingletestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
@@ -446,6 +402,7 @@ def greens_function(self):
         return GreensFunction1DAbsAbs(self.D, self.v, 0.0, -inner_half_length, inner_half_length)
 
     # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+    # For explanation see NonInteractionSingles and Others in shells.py
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
@@ -514,10 +471,8 @@ class InteractionSingle(Single, hasCylindricalShell, Others):
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
         hasCylindricalShell.__init__(self, testShell, domain_id)
-        assert self.testShell
-        assert isinstance(self.testShell, testInteractionSingle)
-
         Single.__init__(self, domain_id, shell_id, reactionrules)
+        # Note: for the Others superclass nothing is to be initialized.
 
         self.interactionrules = interactionrules        # the surface interaction 'reactions'
         self.intrule = None
@@ -598,6 +553,7 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # spatial calculations (they don't know about the world)
         # NOTE shell_orientation_vector should be normalized and pointing from the surface to the particle!
 
+        assert isinstance(testShell, PlanarSurfaceInteractiontestShell)
         InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
         # z0 is the initial position of the particle relative to the center
@@ -698,6 +654,8 @@ class CylindricalSurfaceInteraction(InteractionSingle):
 
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        assert isinstance(testShell, CylindricalSurfaceInteractiontestShell)
         InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
         # unit_r is the vector from the cylindrical surface to the particle
@@ -748,11 +706,8 @@ def draw_new_position(self, dt, event_type):
                 gf = self.greens_function()
                 z = draw_r_wrapper(gf, dt, self.get_inner_dz_left())
 
-            # Direction matters, so determine the direction of the shell relative to the surface
-            # first
-#            direction = cmp(numpy.dot(self.shell.shape.unit_z, self.structure.shape.unit_z), 0)
-            # express the z_vector into the surface unit vectors to make sure that the coordinates are in the surface
-#            z_vector = z * direction * self.structure.shape.unit_z
+            # Direction matters. We assume that the direction of the shell is equal to the direction of
+            # the surface.
             z_vector = z * self.shell.shape.unit_z
 
 

From 87f6a3c61664587095d87aef2ea2db5e35aee805 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Jan 2012 16:55:05 +0100
Subject: [PATCH 0543/1541] The Others superclass can be directly inherited in
 the Pair class (not in the subclasses)

---
 pair.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/pair.py b/pair.py
index 081d2038..ead7f4b3 100644
--- a/pair.py
+++ b/pair.py
@@ -29,7 +29,7 @@
     FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
 
 
-class Pair(ProtectiveDomain):
+class Pair(ProtectiveDomain, Others):
     """There are 3 types of pairs:
         * SphericalPair
         * PlanarSurfacePair
@@ -56,6 +56,7 @@ def __init__(self, domain_id, shell_id, rrs):
 
         self.interparticle_rrs = rrs
         self.interparticle_ktot = self.calc_ktot(rrs)
+        # copy constants from the testShell so that we don't have to recalculate them.
         self.com   = self.testShell.com
         self.iv    = self.testShell.iv
         self.r0    = self.testShell.r0
@@ -424,7 +425,7 @@ def determine_radii(self, r0, shell_size):
     def __str__(self):
         pass
 
-class SphericalPair(SimplePair, Others, hasSphericalShell):
+class SphericalPair(SimplePair, hasSphericalShell):
     """2 Particles inside a (spherical) shell not on any surface.
 
     """
@@ -524,7 +525,7 @@ def __str__(self):
         return 'Spherical' + Pair.__str__(self)
 
 
-class PlanarSurfacePair(SimplePair, Others, hasCylindricalShell):
+class PlanarSurfacePair(SimplePair, hasCylindricalShell):
     """2 Particles inside a (cylindrical) shell on a PlanarSurface. 
     (Hockey pucks).
 
@@ -614,7 +615,7 @@ def __str__(self):
         return 'PlanarSurface' + Pair.__str__(self)
 
 
-class CylindricalSurfacePair(SimplePair, Others, hasCylindricalShell):
+class CylindricalSurfacePair(SimplePair, hasCylindricalShell):
     """2 Particles inside a (cylindrical) shell on a CylindricalSurface.  
     (Rods).
 
@@ -673,7 +674,7 @@ def __str__(self):
         return 'CylindricalSurface' + Pair.__str__(self)
 
 
-class MixedPair2D3D(Pair, Others, hasCylindricalShell):
+class MixedPair2D3D(Pair, hasCylindricalShell):
 
 #    @classmethod
 #    def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):

From e9095a953266a8d130bb6aa8c06d2a7ab3b847b2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Jan 2012 17:16:25 +0100
Subject: [PATCH 0544/1541] removed old unused code. Added some asserts

---
 pair.py | 259 ++++----------------------------------------------------
 1 file changed, 17 insertions(+), 242 deletions(-)

diff --git a/pair.py b/pair.py
index ead7f4b3..2d0bb7b5 100644
--- a/pair.py
+++ b/pair.py
@@ -44,6 +44,7 @@ class Pair(ProtectiveDomain, Others):
 
     def __init__(self, domain_id, shell_id, rrs):
         ProtectiveDomain.__init__(self, domain_id, shell_id)
+        # Note: for the Others superclass nothing is to be initialized.
 
         assert self.testShell       # assume that the testShell exists
         assert isinstance(self.testShell, testPair)
@@ -193,131 +194,10 @@ def __str__(self):
 
 class SimplePair(Pair):
 
-    @classmethod
-    def get_min_shell_size(cls, single1, single2, geometrycontainer):
-        # 1. Determine min shell size for a putative SimplePair.
-        # TODO Note that the calculation is dimension independent. Also
-        # 'size' is not the right term here
-
-        assert single1.structure == single2.structure
-
-        pos1 = single1.pid_particle_pair[1].position
-        pos2 = single2.pid_particle_pair[1].position
-        radius1 = single1.pid_particle_pair[1].radius
-        radius2 = single2.pid_particle_pair[1].radius
-
-#        assert (pos1 - single1.shell.shape.position).sum() == 0        # TODO Not sure why this is here
-        sigma = radius1 + radius2
-        r0 = geometrycontainer.world.distance(pos1, pos2)
-
-        assert r0 >= sigma, \
-            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
-            (single1, single2, FORMAT_DOUBLE % (r0 - sigma))
-
-        # calculate the minimum shell size for the interparticle domain
-        D1 = single1.pid_particle_pair[1].D
-        D2 = single2.pid_particle_pair[1].D
-        D12 = D1 + D2
-        dist_from_com1 = r0 * D1 / D12                  # particle distance from CoM
-        dist_from_com2 = r0 * D2 / D12
-        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
-        iv_shell_size2 = dist_from_com2 + radius2
-
-        # also fix the minimum shellsize for the CoM domain
-        com_shell_size = max(radius1, radius2)
-
-        # calculate total radii including the margin for the burst volume for the particles
-        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * (1 - SINGLE_SHELL_FACTOR),
-                         iv_shell_size2 + com_shell_size + radius2 * (1 - SINGLE_SHELL_FACTOR))
-
-        return shell_size
-
-
-    @classmethod
-    def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, domains):
-        # returns the maximum shell size based on geometric constraints
-        # It makes sure that surrounding NonInteractionSingles have at least the
-        # 'bursting volume' of space.
-
-#        pos1 = single1.pid_particle_pair[1].position
-#        pos2 = single2.pid_particle_pair[1].position
-#        D1 = single1.pid_particle_pair[1].D
-#        D2 = single2.pid_particle_pair[1].D
-#        D12 = D1 + D2
-
-        # TODO it makes no sence to calculate the CoM in the world object
-#        com  = geometrycontainer.world.calculate_pair_CoM(pos1, pos2, D1, D2)
-#        shell_center = geometrycontainer.world.apply_boundary(com)
-
-        # TODO get_closest_obj searches the spherical surrounding although this doesn't make sence for
-        # a 2D or 1D pair
-#        closest, closest_distance = geometrycontainer.get_closest_obj(shell_center, domains, ignore=[single1.domain_id,
-#                                                                      single2.domain_id],
-#                                                                      ignores=[single1.structure.id])
-
-        neighbor_domains = geometrycontainer.get_neighbor_domains(shell_center, domains, ignore=[single1.domain_id, 
-                                                                  single2.domain_id])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, ignores=[single1.structure.id])
-        neighbors = neighbor_domains + neighbor_surfaces
-
-
-        # 3. Check if bursted Singles can still make a minimal shell.
-        # TODO this is not correct. If the closest domain is not a NonInteractionSingle
-        # we still have to make sure that the (non closest) NonInteractionSingles have
-        # the required space
-
-        max_shell_size = geometrycontainer.get_max_shell_size()
-
-        distance_domain_closest = (max_shell_size, None)
-        for domain, distance in neighbors:
-
-            if isinstance(domain, NonInteractionSingle):
-                closest_particle_distance = geometrycontainer.world.distance(
-                        shell_center, domain.pid_particle_pair[1].position)
-
-                distance = min(distance,
-                               closest_particle_distance - domain.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR)
-
-                # options for shell size:
-                # a. upto the closest shell assuming that this shell is bigger than the minimum
-                # b. The distance to a bursted single including its minimal shell
-            distance_domain = (distance, domain)    
-            distance_domain_closest = min(distance_domain_closest, distance_domain)
-
-        closest_distance, closest = distance_domain_closest
-
-#                shell_size = min(closest_distance, closest_particle_distance - closest_min_shell)
-#                assert shell_size <= closest_distance
-#
-#            else:
-#                assert isinstance(closest, (InteractionSingle, Pair, Multi, Surface, None.__class__))
-#                shell_size = closest_distance 
-
-        if __debug__:
-            log.debug('Pair closest neighbor: %s, distance: %s' % \
-                      (closest, FORMAT_DOUBLE % closest_distance))
-
-        # shortcut
-        # if closest_distance <0 then neighbor particle overlaps with center of mass ->
-        # neighboring particle is actually closer to the CoM than any of the two member particles
-        # this can happen because we also try to make pairs with the next nearest neighbor if the nearest
-        # neighbor fails
-        if closest_distance <= 0:
-            return 0
-        else:
-            # FIXME Bloody ugly tweak to make sure that in case of a cylinder the 'maximum size' (which is
-            # actually the radius) does not stick out of the maximum sphere (which is the real hard max).
-            # BLoody UGLY because it now applies to ALL SimplePairs.
-            sigma = max(single1.pid_particle_pair[1].radius, single2.pid_particle_pair[1].radius)
-            closest_distance = math.sqrt(abs(closest_distance**2 - sigma**2))
-            return closest_distance/SAFETY
-
-
     def __init__(self, domain_id, shell_id, rrs):
+
         Pair.__init__(self, domain_id, shell_id, rrs)
 
-        assert self.testShell
-        assert isinstance(self.testShell, testSimplePair)
         self.structure = self.testShell.structure              # structure on which both particles live
 
         shell_size = self.get_shell_size()                  # FIXME
@@ -430,9 +310,10 @@ class SphericalPair(SimplePair, hasSphericalShell):
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
-        hasSphericalShell.__init__(self, testShell, domain_id)
-        SimplePair.__init__(self, domain_id, shell_id, rrs) # Always initialize after hasSphericalShell
 
+        assert isinstance(testShell, SphericalPairtestShell)
+        hasSphericalShell.__init__(self, testShell, domain_id)
+        SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
 
     def com_greens_function(self):
         # Green's function for centre of mass inside absorbing sphere.
@@ -531,6 +412,8 @@ class PlanarSurfacePair(SimplePair, hasCylindricalShell):
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
+
+        assert isinstance(testShell, PlanarSurfacePairtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
@@ -621,6 +504,8 @@ class CylindricalSurfacePair(SimplePair, hasCylindricalShell):
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
+
+        assert isinstance(testShell, CylindricalSurfacePairtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
@@ -676,131 +561,17 @@ def __str__(self):
 
 class MixedPair2D3D(Pair, hasCylindricalShell):
 
-#    @classmethod
-#    def get_min_shell_dimensions(cls, single1, single2, geometrycontainer):
-#
-#        assert isinstance (single1.structure, PlanarSurface)
-#        assert isinstance (single2.structure, CuboidalRegion)
-#
-#        pos1 = single1.pid_particle_pair[1].position
-#        pos2 = single2.pid_particle_pair[1].position
-#        radius1 = single1.pid_particle_pair[1].radius
-#        radius2 = single2.pid_particle_pair[1].radius
-#        D1 = single1.pid_particle_pair[1].D
-#        D2 = single2.pid_particle_pair[1].D
-#        D12 = D1 + D2
-#        z_scaling = cls.calc_z_scaling_factor (D1, D2)
-#
-#        # calculate the interparticle vector and project it onto the coordinate system of the structure
-#        # of particle1
-#        pos2_t = geometrycontainer.world.cyclic_transpose(pos2, pos1)
-#        iv = pos2_t - pos1
-#        iv_x =     numpy.dot(iv, single1.structure.shape.unit_x)
-#        iv_y =     numpy.dot(iv, single1.structure.shape.unit_y)
-#        iv_z = abs(numpy.dot(iv, single1.structure.shape.unit_z))
-#
-#        r0 = math.sqrt( iv_x**2 + iv_y**2 + (iv_z*z_scaling)**2)
-#
-#        # calculate the minimal height z_right1 of the shell including burst radius
-#        # with the accompanying radius r1
-#        z_right1 = iv_z + radius2 * SINGLE_SHELL_FACTOR
-#        r1       = cls.r_right(single1, single2, r0, z_right1)
-#
-#        len_iv = r0
-#        iv_shell_radius1 = len_iv * D1 / D12 
-#        iv_shell_radius2 = len_iv * D2 / D12 
-#
-#        # fix the minimum shell size for the CoM domain
-#        com_shell_radius = max(radius1, radius2)
-#
-#        # calculate the minimal dimensions of the protective domain including space for the
-#        # burst volumes of the particles
-#        r2 = max(iv_shell_radius1 + com_shell_radius + radius1 * SINGLE_SHELL_FACTOR,
-#                 iv_shell_radius2 + com_shell_radius + radius2 * SINGLE_SHELL_FACTOR)
-#        z_right2 = cls.z_right(single1, single2, r0, r2)
-#
-#        # of both alternatives pick the largest one
-#        z_right, r = max((z_right1, r1),(z_right2, r2))
-#
-#        # z_left is always the same
-#        z_left = radius1
-#
-#        return r, z_left, z_right
-#
-#    @classmethod
-#    def get_max_shell_dimensions(cls, single1, single2, geometrycontainer, domains):
-#        # Properties of the MixedPair system
-#
-#        assert isinstance (single1.structure, PlanarSurface)
-#        assert isinstance (single2.structure, CuboidalRegion)
-#
-#        com, iv = cls.do_transform(single1, single2, geometrycontainer.world)
-#        reference_point = com
-#        orientation_vector = normalize(single1.structure.shape.unit_z * numpy.dot (iv, single1.structure.shape.unit_z))
-#        r0 = length(iv)
-#
-#        # Make sure the maximal cylinder fits in the maximal sphere. Matrix space
-#        # doesn't allow to check for shells outside the maximal sphere.
-#        max_cylinder_radius      = geometrycontainer.get_max_shell_size()/math.sqrt(2)
-#        max_cylinder_half_length = max_cylinder_radius
-#
-#        # set initial values of shell dimensions
-#        z_left = single1.pid_particle_pair[1].radius
-#        z_right = max_cylinder_half_length * 2 - z_left
-#        r = max_cylinder_radius
-#        
-#        # get all the domains in the neighborhood
-#        search_point = reference_point + ((z_right - z_left)/2.0) * orientation_vector
-#        search_point = geometrycontainer.world.apply_boundary(search_point)
-#        all_neighbor_ids = \
-#            geometrycontainer.get_neighbors_within_radius_no_sort(search_point,
-#                                                     geometrycontainer.get_max_shell_size(),
-#                                                     ignore=[single1.domain_id, single2.domain_id])
-#        all_neighbors = [domains[domain_id] for domain_id in all_neighbor_ids]
-#
-#        world = geometrycontainer.world
-#
-#        # adjust the maximal shell dimensions for every shell in the neighborhood
-#        for domain in all_neighbors:
-#            if isinstance(domain, Multi):
-#                for _, shell in domain.shell_list:
-#                    shell_position = shell.shape.position
-#                    shell_size = shell.shape.radius
-#                    r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, shell,
-#                                                                     reference_point, orientation_vector, r, z_left,
-#                                                                     z_right, world)
-#            else:
-#                shell_position = domain.shell.shape.position
-#                shell_size = domain.get_shell_size()
-#
-#                if domain.dt == 0.0 and domain.getD() > 0:
-#                    # This is one of the bursted singles.
-#                    # Or a particle that just escaped it's multi.
-#                    shell_size *= SINGLE_SHELL_FACTOR
-#
-#                r, z_left, z_right = cls.laurens_algorithm(single1, single2, r0, shell_position, shell_size, domain.shell,
-#                                                                 reference_point, orientation_vector, r, z_left,
-#                                                                 z_right, world)
-#
-#
-#
-#        return r, z_left, z_right
-
-    ################
-    @classmethod
-    def calc_z_scaling_factor(cls, D2d, D3d):
-        # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
-        return math.sqrt( (D2d + D3d) / D3d)
-
     def __init__(self, domain_id, shell_id, testShell, rrs):
+
+        assert isinstance(testShell, MixedPair2D3DtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         Pair.__init__(self, domain_id, shell_id, rrs)
 
-        assert self.testShell
         assert isinstance(self.testShell, testMixedPair2D3D)
         self.surface = self.testShell.surface       # the surface on which particle1 lives
         self.structure = self.testShell.structure   # structure on which both particles live
 
+        # initialize some useful constants
         self.z_scaling_factor = self.testShell.get_scaling_factor()
 
         # set the radii of the inner domains as a function of the outer protective domain
@@ -868,7 +639,6 @@ def determine_radii(self):
 
         return a_R, a_r
 
-
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
@@ -906,6 +676,11 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
 
         return pos1, pos2
 
+    @classmethod
+    def calc_z_scaling_factor(cls, D2d, D3d):
+        # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
+        return math.sqrt( (D2d + D3d) / D3d)
+
     def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
 

From 0c59d6868f18a96d035cc1308c2f15e58ac2fccf Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Jan 2012 17:24:52 +0100
Subject: [PATCH 0545/1541] Reuse the orientation of the shell from the
 testShell instead of redefining it.

---
 pair.py   | 19 +++----------------
 shells.py |  2 +-
 2 files changed, 4 insertions(+), 17 deletions(-)

diff --git a/pair.py b/pair.py
index 2d0bb7b5..6b5eb8cb 100644
--- a/pair.py
+++ b/pair.py
@@ -78,6 +78,9 @@ def get_D_R(self):
                 self.pid_particle_pair2[1].D) / self.D_tot
     D_R = property(get_D_R)
 
+    def get_shell_direction(self):
+        return self.testShell.get_orientation_vector()
+
     def initialize(self, t):
         # re-initialize the time parameters of the Domain to reuse it.
         # THIS IS PROBABLY USELESS
@@ -325,10 +328,6 @@ def iv_greens_function(self, r0):
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                               self.sigma, self.a_r)
 
-# this is a part of hasShell (see testShell.get_orientation_vector())
-    def get_shell_direction(self):
-        return random_vector(1.0)
-
     # selects between the full solution or an approximation where one of
     # the boundaries is ignored
     def choose_pair_greens_function(self, r0, t):
@@ -424,9 +423,6 @@ def iv_greens_function(self, r0):
         return GreensFunction2DRadAbs(self.D_r, self.interparticle_ktot, r0,
                                       self.sigma, self.a_r)
 
-    def get_shell_direction(self):
-        return self.shell.shape.unit_z
-
     def choose_pair_greens_function(self, r0, t):
         # selects between the full solution or an approximation where one of
         # the boundaries is ignored
@@ -530,9 +526,6 @@ def com_greens_function(self):
     def iv_greens_function(self, r0):
         return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
-    def get_shell_direction(self):
-        return self.shell.shape.unit_z
-
     def choose_pair_greens_function(self, r0, t):
         # Todo
         return self.iv_greens_function(r0)
@@ -694,9 +687,6 @@ def iv_greens_function(self, r0):
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, max(r0, self.sigma),
                                       self.sigma, self.a_r)
 
-    def get_shell_direction(self):
-        return self.shell.shape.unit_z
-
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
         # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
@@ -775,6 +765,3 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     def calc_r_scaling_factor(cls, D1, D2):
         return math.sqrt((D1 + D2)/D2)
 
-    def get_shell_direction(self):
-        return self.shell.shape.unit_z
-
diff --git a/shells.py b/shells.py
index 7980c287..9b91ab3f 100755
--- a/shells.py
+++ b/shells.py
@@ -743,7 +743,7 @@ def get_searchradius(self):
         return self.geometrycontainer.get_max_shell_size()
     def get_orientation_vector(self):
         # The orientation of the sphere is irrelevant, but needs to be defined.
-        return self.structure.unit_z    # NOTE: Is self.structure always well defined??
+        return self.structure.shape.unit_z    # NOTE: Is self.structure always well defined??
 
     def get_max_radius(self):
         # The maximum radius of the spherical testShell.

From 96b4ed0821064b789ab83a7df5ee487c0f329332 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Jan 2012 17:37:09 +0100
Subject: [PATCH 0546/1541] cleanup of some old useless code

---
 egfrd.py | 75 +++-----------------------------------------------------
 1 file changed, 3 insertions(+), 72 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7e3918ed..f08812d4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -427,8 +427,6 @@ def create_single(self, pid_particle_pair):
             single.world = self.world
         return single
 
-#    def create_interaction(self, pid_particle_pair, surface, shell_center,
-#                           shell_radius, shell_half_length, shell_unit_z):
     def create_interaction(self, testShell):
 
 ##        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
@@ -454,8 +452,6 @@ def create_interaction(self, testShell):
         interaction_rules = self.network_rules.query_reaction_rule(species_id, surface_id)
 
 
-#        particle_pos = pid_particle_pair[1].position
-
         if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
             interaction = CylindricalSurfaceInteraction(domain_id, shell_id, testShell,
                                                         reaction_rules, interaction_rules)
@@ -478,9 +474,6 @@ def create_interaction(self, testShell):
 
     def create_pair(self, testShell):
 
-#        assert single1.dt == 0.0
-#        assert single2.dt == 0.0
-
         pid_particle_pair1 = testShell.pid_particle_pair1
         pid_particle_pair2 = testShell.pid_particle_pair2
 
@@ -1715,9 +1708,7 @@ def try_interaction(self, single, surface):
                           str(e) ))
 
 
-
-#        ### 2. The shell can be made. Now do what's necessary to make it
-
+        ### 2. The shell can be made. Now do what's necessary to make it
         if testShell:
             interaction = self.create_interaction(testShell)
 
@@ -1733,72 +1724,13 @@ def try_interaction(self, single, surface):
             self.add_domain_event(interaction)
 
             if __debug__:
-                log.debug('        *Created: %s' % (interaction))
+                log.info('        *Created: %s' % (interaction))
 
             return interaction
         else:
             return None
 
 
-    def calculate_max_cylinder(self, single, surface, projected_point, 
-                                   particle_distance, orientation_vector,
-                                   dr, dz_left, dz_right):
-        # Find optimal cylinder around particle and surface, such that 
-        # it is not interfering with other shells.
-        #
-        # To determine the maximal cylindrical shell a starting cylinder is defined
-        # * The projected_point is a reference point along the axis of the cylinder,
-        #   the position, z, can be chosen freely
-        # * orientation_vector is a vector along the z-axis providing orientation
-        #   It usually points in the general direction of the particle
-        #
-        # * dr is the radius of the cylinder.
-        # * dz_right is the distance between the projected_point and the face of the
-        #   cylinder on the side of the orientation_vector 
-        # * dz_left is the distance from the projected_point to the face of the cylinder
-        #   on the side oposite of the orientation_vector
-        #
-        # * particle_distance is the distance from the center of the particle to the
-        #   projected_point
-
-        # the search point is the center of the sphere that surrounds the
-        # maximal cylinder
-        search_point = projected_point + ((dz_right - dz_left)/2.0) * orientation_vector
-        all_neighbor_ids = \
-            self.geometrycontainer.get_neighbors_within_radius_no_sort(search_point, 
-                                                     self.geometrycontainer.get_max_shell_size(),
-                                                     ignore=[single.domain_id])
-        all_neighbors = [self.domains[domain_id] for domain_id in all_neighbor_ids]
-
-            else:
-                # Get shell size, which normally is the radius of the 
-                # shell, but in case of a cylinder around the same 
-                # CylindricalSurface it should be the half_length of 
-                # the cylinder.
-                shell_position = domain.shell.shape.position
-                shell_size = domain.get_shell_size()
-
-                # Make bursted singles look bigger,
-                # because the size of their shell is only 
-                # particle.radius (not yet multiplied by 
-                # SINGLE_SHELL_FACTOR)
-                # (and no we can not do that immediately after they are 
-                # bursted, singles might start overlapping).
-                if domain.dt == 0.0 and domain.getD() > 0:
-                    # This is one of the bursted singles.
-                    # Or a particle that just escaped it's multi.
-                    shell_size *= SINGLE_SHELL_FACTOR
-
-                dr, dz_left, dz_right = \
-                    self.miedema_algorithm(shell_position, shell_size, 
-                                           projected_point, 
-                                           orientation_vector, dr, 
-                                           dz_left, dz_right, surface,
-                                           particle_distance)
-
-
-        return dr, dz_left, dz_right
-
     def try_pair(self, single1, single2):
         if __debug__:
             log.debug('trying to form Pair(%s, %s)' %
@@ -1817,12 +1749,11 @@ def try_pair(self, single1, single2):
                           str(e) ))
 
 
-
         # if a pair could be formed
         if testShell:
             pair = self.create_pair(testShell)
             if __debug__:
-                log.debug('Created: %s' % (pair))
+                log.info('Created: %s' % (pair))
 
             pair.dt, pair.event_type, pair.reactingsingle = \
             pair.determine_next_event(pair.r0)

From 7a2efc0e203bec6e09da06f3382a83950956bbce Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Jan 2012 17:38:08 +0100
Subject: [PATCH 0547/1541] moved useful formating definition to utils.py so
 everybody can access

---
 egfrd.py  | 3 ---
 pair.py   | 4 ----
 single.py | 2 +-
 utils.py  | 5 +++++
 4 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f08812d4..47438e6e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -52,9 +52,6 @@
 
 log = logging.getLogger('ecell')
 
-if __debug__:
-    PRECISION = 7
-    FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
 
 def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure, geometrycontainer, domains):
     if isinstance(structure, CuboidalRegion):
diff --git a/pair.py b/pair.py
index 6b5eb8cb..d7ec43c3 100644
--- a/pair.py
+++ b/pair.py
@@ -24,10 +24,6 @@
     'MixedPair1D3D',
     ]
 
-if __debug__:
-    PRECISION = 3
-    FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
-
 
 class Pair(ProtectiveDomain, Others):
     """There are 3 types of pairs:
diff --git a/single.py b/single.py
index e7808e03..d643be98 100644
--- a/single.py
+++ b/single.py
@@ -9,7 +9,7 @@
 from _greens_functions import *
 from greens_function_wrapper import *
 from constants import EventType
-import utils
+from utils import *
 
 from domain import (
     Domain,
diff --git a/utils.py b/utils.py
index bf0bdeeb..6fe34265 100644
--- a/utils.py
+++ b/utils.py
@@ -36,6 +36,11 @@
                                     # NonInteractionSingles to a Pair or Interaction. It also defines
                                     # the radius in which the NonInteractionSingle will burst.
 
+if __debug__:
+    PRECISION = 7
+    FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'
+
+
 # Float comparison functions.
 def feq(a, b, typical=1, tolerance=TOLERANCE):
     """Return True if a and b are equal, subject to given tolerances.  

From 873c1762d6c54748050bcef27364bca4312c35c6 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Sun, 8 Jan 2012 11:28:32 +0100
Subject: [PATCH 0548/1541] Removed multi problems with D=0 Single. Added
 uniform theta for failing drawTheta.

---
 GreensFunction2DRadAbs.cpp |  2 +-
 egfrd.py                   | 31 +++++++++++++++++--------------
 greens_function_wrapper.py |  6 +++---
 single.py                  |  3 +++
 4 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 1b3e79b5..e6c36c21 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -891,7 +891,7 @@ Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
     else
     {	
         const Real t_Rad( D / gsl_pow_2( kf/(2*M_PI*a) ) + gsl_pow_2( r0 - sigma ) / D );
-        t_guess = std::min( t_Abs, t_Rad );	// take the shortest distance to a boundary
+        t_guess = std::min( t_Abs, t_Rad );	// take the shortest time to a boundary
     }
     
     t_guess *= .1;
diff --git a/egfrd.py b/egfrd.py
index eca8a50b..dd3276d8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -152,14 +152,18 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
     def add_to_sinklist(self, sink_id):
         self.sinklist.append(sink_id)
         
-    def get_neighbor_sinks(self, position, structure_id):
+    def get_neighbor_sinks(self, position, species_id):
         sink_distance_list = []
         sinklist = self.sinklist
         
         for i in range( len( sinklist ) ):
-            sink_i = self.world.get_structure( sinklist[i] )        
-            sink_distance_list.append((sink_i, self.world.distance( position, sink_i.shape.position )))
-        
+            sink_i = self.world.get_structure( sinklist[i] )
+            interaction_rules = self.network_rules.query_reaction_rule(species_id, sink_i.sid)
+            for ir in interaction_rules:
+                if ir.k != 0:
+                    sink_distance_list.append((sink_i, self.world.distance( position, sink_i.shape.position )))
+                    break
+                    
         return sink_distance_list
 
     def get_next_time(self):
@@ -367,10 +371,9 @@ def step(self):
                 self.zero_steps += 1
                 # TODO Changed from 10 to 10000, because only a problem 
                 # when reaching certain magnitude.
+                # Ugly hack: changed exception -> print, so that is doesn't stop the simulation
                 if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
-                    raise RuntimeError('too many dt=zero steps. '
-                                       'Simulator halted?'
-                                    'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
+                    print 'too many dt=zero steps. Simulator halted? dt= %.10g-%.10g' %(self.scheduler.top[1].time, self.t)
             else:
                 self.zero_steps = 0
 
@@ -451,7 +454,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
             z0 = numpy.dot (shell_unit_z, projected_point - shell_center)
 
             #Very ugly hack to make the function converge for drawTime.
-            shell_radius = min( shell_radius, 1e-8 )
+            shell_radius = min( shell_radius, 10*pid_particle_pair[1].radius )
 
             interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
                                                         reaction_rules, structure,
@@ -1152,11 +1155,11 @@ def make_new_domain(self, single):
         # Special case: When D=0, nothing needs to change and only new event
         # time is drawn
         # TODO find nicer construction than just this if statement
-        if single.getD() == 0:
-            single.dt, single.event_type = single.determine_next_event() 
-            single.last_time = self.t
-            self.add_domain_event(single)
-            return single
+        #if single.getD() == 0:
+        #    single.dt, single.event_type = single.determine_next_event() 
+        #    single.last_time = self.t
+        #    self.add_domain_event(single)
+        #    return single
 
 
         # 0. Get generic info
@@ -1173,7 +1176,7 @@ def make_new_domain(self, single):
             
         # For a particle on a rod (1D) only consider sinks. - one rod, with one sink for now.
         if isinstance(single, CylindricalSurfaceSingle):
-            surface_distances = self.get_neighbor_sinks( single_pos, single.structure.id )
+            surface_distances = self.get_neighbor_sinks( single_pos, single.pid_particle_pair[1].sid )
 
         # Check if there are shells with the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
diff --git a/greens_function_wrapper.py b/greens_function_wrapper.py
index b975170d..1ddb7709 100644
--- a/greens_function_wrapper.py
+++ b/greens_function_wrapper.py
@@ -64,9 +64,9 @@ def draw_theta_wrapper(gf, r, dt):
     try:
         theta = gf.drawTheta(rnd, r, dt)
     except Exception, e:
-        raise Exception('gf.drawTheta() failed, '
-                        '%s, rnd = %g, r = %g, dt = %g; %s' %
-                        (str(e), rnd, r, dt, gf.dump()))
+        print 'gf.drawTheta() failed, %s, rnd = %g, r = %g, dt = %g; %s' %(str(e), rnd, r, dt, gf.dump())
+        #ugly hack: When drawTheta fails, return uniformly distributed theta.
+        theta = rnd * numpy.py
 
     # Heads up. For cylinders theta should be between [-pi, pi]. For 
     # spheres it doesn't matter.
diff --git a/single.py b/single.py
index fe9da1d3..e1315cfa 100644
--- a/single.py
+++ b/single.py
@@ -260,6 +260,9 @@ def get_max_shell_size(self, geometrycontainer, domains, ignores=[]):
         # TODO We now just check in a sphere around the particle and size accordingly. For
         # NonInteractionSingles on the dna and membrane this is quite inefficient-> want to
         # size in the appropriate coordinate (r or z).
+        if self.getD() == 0.0:
+            return self.get_min_shell_size()
+        
         singlepos = self.pid_particle_pair[1].position
 #        closest, distance_to_shell = \
 #            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],

From aaf9cb97830315e90fa4ff0253a1f8169502e640 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Sun, 8 Jan 2012 20:57:20 +0100
Subject: [PATCH 0549/1541] Changed drawR in all 1D GF's for optimal
 convergence using funcSum.

---
 GreensFunction1DAbsAbs.cpp     |  61 ++++++---------
 GreensFunction1DAbsAbs.hpp     |  18 ++++-
 GreensFunction1DAbsSinkAbs.cpp | 130 ++++++++++++++++++++++----------
 GreensFunction1DAbsSinkAbs.hpp |  34 ++++++---
 GreensFunction1DRadAbs.cpp     | 131 +++++++++++++++++++--------------
 GreensFunction1DRadAbs.hpp     |  41 ++++++-----
 6 files changed, 249 insertions(+), 166 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index eb3e6fe0..c7e7747b 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -573,7 +573,6 @@ GreensFunction1DAbsAbs::drawTime (Real rnd) const
 
 Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r, 
                                            Real const& t,
-                                           Real const& p_surv,
                                            RealVector& table) const
 {   
     const Real a( geta() );
@@ -597,15 +596,16 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
             return XI00(r, t, r0, D, v); //free particle.
         else
             //Only absorbing BCn at sigma.
-            return XI10(r - sigma, t, distTos, D, v) / p_surv; 
+            return XI10(r - sigma, t, distTos, D, v); 
     }
     else
     {
         if( distTos > maxDist )
             //Only absorbing BCn at a.
-            return XI10(a - r, t, distToa, D, -v) / p_surv;
+            return XI10(a - r, t, distToa, D, -v);
     }
 
+    Real p;
     const uint maxi( guess_maxi( t ) );
     if( table.size() < maxi )
     {
@@ -619,42 +619,29 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
         std::cerr << "L: " <<  L << " r0: " << r0 - sigma << std::endl;
     }
 
-    uint n = 0;
-    do
-    {
-        if (n >= maxi )
-        {
-            log_.info("Too many terms needed for DrawR. N: %6u", n );
-            break;
-        }
-        prev_term = term;
-        
-        S_Cn_An = table[n];
-        n_L = ((Real)(n + 1.0)) * M_PI / L;
-        if(v2D==0.0)	
-            term = S_Cn_An * ( 1.0 - cos(n_L*(r-sigma)) );
-        else		
-            term = S_Cn_An * ( exp(v2D*sigma) + exp(v2D*r)*
-                               ( v2D/n_L*sin(n_L*(r-sigma)) 
-                                 - cos(n_L*(r-sigma)) ));
-
-        // S_Cn_An contains all expon. prefactors, the 1/S(t) term and all parts
-        // of the terms that do not depend on r.
-        // In case of zero drift the terms become S_An_Cn * ( 1 - cos(nPi/L*(r-sigma)) )
-        // as it should be. The if-statement is only to avoid calculation costs.
+    p = funcSum(boost::bind(&GreensFunction1DAbsAbs::p_int_r_i, 
+                            this, _1, t, table),
+                MAX_TERMS);
 
-        sum += term;
-        n++;
-    }
-    while (fabs(term/sum) > EPSILON ||
-           fabs(prev_term/sum) > EPSILON ||
-           n < MIN_TERMS );
+    return p;
+}
 
-    return sum;
+Real p_int_r_i(uint i, Real const& t, RealVector& table) const
+{           
+    n_L = ((Real)(i + 1.0)) * M_PI / L;
+
+    if(v2D==0.0)	
+        term = 1.0 - cos(n_L*(r-sigma));
+    else		
+        term = exp(v2D*sigma) + exp(v2D*r)*
+            ( v2D/n_L*sin(n_L*(r-sigma)) 
+              - cos(n_L*(r-sigma)) );
+    
+    return term * get_p_int_r_Table_i(i ,t, table);
 }
 
 /* Fills table for p_int_r of factors independent of r. */
-void GreensFunction1DAbsAbs::createP_int_r_Table( Real const& t,
+void GreensFunction1DAbsAbs::create_p_int_r_Table( Real const& t,
                                                   uint const& maxi,
                                                   RealVector& table ) const
 {    
@@ -681,7 +668,7 @@ void GreensFunction1DAbsAbs::createP_int_r_Table( Real const& t,
 
     while( n < maxi )
     {
-        nPI = ((Real)(n+1))*M_PI;	    // note: summation starting with n=1, indexing with n=0, therefore we need n+1 here
+        nPI = ((Real)(n+1))*M_PI;
 	    
         if( v == 0.0 )
             S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
@@ -697,7 +684,7 @@ void GreensFunction1DAbsAbs::createP_int_r_Table( Real const& t,
 Real GreensFunction1DAbsAbs::drawR_f(Real r, void *p)
 {
     struct drawR_params *params = (struct drawR_params *)p;
-    return params->gf->p_int_r_table(r, params->t, params->p_surv, params->table) 
+    return params->gf->p_int_r_table(r, params->t, params->table) 
         - params->rnd;
 }
 
@@ -729,7 +716,7 @@ Real GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
     }
     
     RealVector pintTable;
-    struct drawR_params parameters = { this, t, pintTable, rnd, p_survival( t )};
+    struct drawR_params parameters = { this, t, pintTable, rnd * p_survival( t )};
     gsl_function F;
     F.function = &drawR_f;
     F.params = &parameters; 
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index f19e8345..122248cf 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -185,7 +185,6 @@ class GreensFunction1DAbsAbs: public GreensFunction
         const Real t;
         RealVector table;
         Real rnd;
-        Real p_surv;
     };
 
     uint guess_maxi(Real const& t ) const;
@@ -206,10 +205,21 @@ class GreensFunction1DAbsAbs: public GreensFunction
 
     static Real drawR_f (Real z, void* p);
 
-    Real p_int_r_table(Real const& r, Real const& t, Real const& p_surv, 
-                       RealVector& table) const;
+    Real p_int_r_table(Real const& r, Real const& t, RealVector& table) const;
 
-    void createP_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
+    Real p_int_r_i(uint i, Real const& t, RealVector& table) const;
+
+    void create_p_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
+
+    Real get_p_int_r_Table_i( uint& i, Real const& t, RealVector& table ) const
+    {
+        if( i >= table.size() )
+        {
+            create_p_int_r_Table(t, i, table);
+        }
+
+        return table[i];
+    }
 
 private:
     // The diffusion constant and drift velocity
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 9113cc99..bb32d39b 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -40,6 +40,10 @@ Real GreensFunction1DAbsSinkAbs::root_f (Real x, void *p)
 /* Calculates the first n roots of root_f */
 void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
 {
+    uint i( rootList_size() );
+    if( n <= i )
+        return;
+
     const Real Lr( getLr() );
     const Real Ll( getLl() );
     const Real L( Lr + Ll );
@@ -48,8 +52,6 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
     const Real h( getk() * L / ( 2 * getD() ) );
     
     Real root_i;
-    uint i = 0;
-
     real_pair lower_upper_pair;
 
     /* Define the root function. */
@@ -63,9 +65,7 @@ void GreensFunction1DAbsSinkAbs::calculate_n_roots(uint const& n) const
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
-    i = rootList_size();
-
-    /* Stores the last root with long or short period. */
+    /* If this is the first run, set parameters.*/
     if(i == 0)
     {
         lo_up_params.h = h;
@@ -449,22 +449,19 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
 
     Real p;  
 
-    const uint maxi( guess_maxi( t ) );
-    calculate_n_roots( maxi );
-
     /* Determine wether rr lies in the same sub-domain as r0.
        A different function is caculated when this is the case. */
     if( rr >= 0 )
     {   
-        p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_r0_i, 
-                                    this, _1, rr, t),
-                        maxi);
+        p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_r0_i, 
+                                this, _1, rr, t),
+                    MAX_TERMS);
 	}
     else
     {
-        p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_nor0_i, 
-                                    this, _1, rr, t),
-                        maxi);
+        p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_nor0_i, 
+                                this, _1, rr, t),
+                    MAX_TERMS);
     }
     
     return p;
@@ -526,11 +523,10 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
     }
 
     Real p;
-    const Real maxi( guess_maxi( t ) );
 
-    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_tot_i, 
-                                this, _1, t),
-                        maxi);
+    p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_tot_i, 
+                            this, _1, t),
+                MAX_TERMS);
 
     return D * p;
 }
@@ -553,9 +549,9 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t, uint const& maxi) const
     const Real D( getD() );
     Real p;
    
-    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Lr_i, 
-                                this, _1, t),
-                        maxi);
+    p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Lr_i, 
+                            this, _1, t),
+                MAX_TERMS);
 
     return - D * 2 * p;
 }
@@ -586,9 +582,9 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t, uint const& maxi) const
     const Real D2( gsl_pow_2( getD() ) );
     Real p;
 
-    p = funcSum_all(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Ll_i, 
-                                this, _1, t),
-                        maxi);
+    p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Ll_i, 
+                            this, _1, t),
+                MAX_TERMS);
     
     return 2 * D2 * p;
 }
@@ -635,8 +631,8 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
     const Real r0( getr0() );
     const Real L( a - sigma );
 
-    /* if the sink is impermeable (k==0) or
-       the particle is at one the absorbing boundary (sigma or a) => IV_ESCAPE event */
+    /* If the sink is impermeable (k==0) or
+       the particle is at one the absorbing boundaries (sigma or a) => IV_ESCAPE event */
     if ( k == 0 || fabs(a - r0) < EPSILON * L || fabs(sigma - r0) < EPSILON * L)
     {
 	    return IV_ESCAPE;
@@ -648,6 +644,31 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
        (2) Leave through sink - IV_REACTION
     */
 
+    /* First check if we need to compare flux ratio's. 
+       If particle is near only one boundary or sink, this is the escape event. */
+    const Real maxDist(CUTOFF_H * sqrt(2.0 * getD() * t));
+    // dist to nearest absorbing boundary.
+    const Real distToAbs( std::min(a - r0, r0 -sigma) );
+
+    if( getL0() > maxDist ) //Sink not in sight
+    {
+        if( distToAbs < maxDist )
+            return IV_ESCAPE;
+    }
+    else
+    {
+        if( distToAbs > maxDist ) //Only sink in sight.
+            return IV_REACTION;
+    }
+
+    /* Allready fill rootList with needed roots. */ 
+    const uint maxi( guess_maxi( t ) );
+
+    if( maxi == MAX_TERMS )
+        log_.info("drawEventType: maxi was cut to MAX_TERMS for t = %.16g", t);
+
+    calculate_n_roots( maxi );
+
     rnd *= flux_tot( t );
 
     const Real p_sink( flux_sink( t ) );
@@ -803,6 +824,35 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
        : rr -> -rr. */
     const Real rr( getr0() - rsink >= 0 ? r - rsink : rsink - r  );
 
+    /* First check if we need full solution. 
+       Else we use approximation. */
+    const Real maxDist(CUTOFF_H * sqrt(2.0 * D * t));
+    const Real distToa( a - r0 );
+    const Real distTos( r0 - sigma );
+
+    if( getL0() > maxDist ) //Sink not in sight
+    {
+        if( distTos > maxDist )
+        {
+            if( distToa > maxDist )
+                return XI00(r, t, r0, D, 0.0);  //Nothing in sight.
+            else
+                return XI10(a - r, t, distToa, D, 0.0); //Only a boundary in sight.
+        }
+        else
+        {
+            if( distToa > maxDist )
+                return XI10( r - sigma, t, distTos, D, 0.0 ); //Only s boundary in sight.
+        }
+    }
+    else
+    {
+        if( distToa > maxDist && distTos > maxDist ) //Only sink in sight.
+        {
+            return XI030( rr, t, getL0(), getk(), D );
+        }
+    }
+
     const uint maxi( guess_maxi(t) );
 
     if( maxi == MAX_TERMS )
@@ -812,13 +862,13 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
     if (table.size() < maxi )
     {
         calculate_n_roots( maxi );  // this updates the table
-        createP_int_r_Table( t, table );
+        create_p_int_r_Table( t, table );
     }
 
     /* Determine in which part of the domain rr lies, and
        thus which function to use. */
     Real (GreensFunction1DAbsSinkAbs::*p_int_r_i)
-    (uint, Real const&, RealVector const& table) const = NULL;
+        (uint, Real const&, Real const&, RealVector const& table) const = NULL;
 
     if( rr <= 0 )
         p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_leftdomain;
@@ -827,9 +877,9 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
         else
             p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB;
 
-    p = funcSum_all(boost::bind(p_int_r_i, 
-                                this, _1, rr, table),
-                    maxi);
+    p = funcSum(boost::bind(p_int_r_i, 
+                            this, _1, rr, t, table),
+                MAX_TERMS);
 
     return 2.0 * p;
 }
@@ -846,7 +896,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r(Real const& r,
 }
 
 
-void GreensFunction1DAbsSinkAbs::createP_int_r_Table( Real const& t, 
+void GreensFunction1DAbsSinkAbs::create_p_int_r_Table( Real const& t, 
                                                       RealVector& table ) const
 {
     const uint root_nbr( rootList_size() );
@@ -864,6 +914,7 @@ void GreensFunction1DAbsSinkAbs::createP_int_r_Table( Real const& t,
 //Integrated Greens function for rr part of [-Ll, 0]
 Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint i, 
                                                     Real const& rr,
+                                                    Real const& t,
                                                     RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
@@ -873,13 +924,14 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint i,
     const Real temp( getD() * sin( root_i * LrmL0 ) * 
                      ( cos( root_i * Llprr ) - 1.0 ) );
 
-    return table[i] * temp;
+    return get_p_int_r_Table_i(i, t, table) * temp;
 }
 
 
 //Integrated Greens function for rr part of (0, L0]
 Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(uint i, 
                                                       Real const& rr, 
+                                                      Real const& t,
                                                       RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
@@ -891,13 +943,14 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(uint i,
                      getk() / root_i * ( cos( root_i_rr ) - 1.0 ) 
                      * sin( root_i * getLl() ) );
     
-    return table[i] * sin( root_i * LrmL0 ) * temp;
+    return get_p_int_r_Table_i(i, t, table) * sin( root_i * LrmL0 ) * temp;
 }
 
 
 //Integrated Greens function for rr part of (L0, Lr]
 Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint i, 
                                                       Real const& rr, 
+                                                      Real const& t,
                                                       RealVector const& table) const
 {
     const Real root_i( get_root( i ) );
@@ -918,7 +971,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint i,
     const Real temp( getD() * term1 + 
                      getk() * sin( root_i * Ll ) * term2 / root_i );
 
-    return table[i] * temp;
+    return get_p_int_r_Table_i(i, t, table) * temp;
 }
 
 
@@ -926,7 +979,8 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint i,
 Real GreensFunction1DAbsSinkAbs::drawR_f(Real r, void *p)
 {
     struct drawR_params *params = (struct drawR_params *)p;
-    return params->gf->p_int_r_table(r, params->t, params->table) - params->rnd;
+    return params->gf->p_int_r_table(r, params->t, params->p_surv, params->table) 
+        - params->rnd;
 }
 
 
@@ -964,10 +1018,8 @@ Real GreensFunction1DAbsSinkAbs::drawR(Real rnd, Real t) const
     }
 
     // the structure to store the numbers to calculate r.
-    const Real S( p_survival( t ) );
-
     RealVector drawR_table;
-    drawR_params parameters = { this, t, drawR_table, rnd * S };
+    drawR_params parameters = { this, t, drawR_table, rnd * p_survival( t ) };
 
     // define gsl function for rootfinder
     gsl_function F;
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 1e3b9275..304e2c26 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -241,16 +241,13 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
         rootList.erase( rootList.begin() + n );
     }
 
-    /* return the n'th root */
+    /* return the n + 1'th root */
     Real get_root( uint const& n ) const
     {
-        if( n < rootList.size() )
-            return rootList[ n ];
-        else
-        {
-            calculate_n_roots( n );
-            return rootList.back();
-        }
+        if( n >= rootList.size() )
+            calculate_n_roots( n+1 );
+
+        return rootList[ n ];
     }
 
 
@@ -297,16 +294,29 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     /* functions for calculating the c.d.f. */
 
     /* i'th term of p_int_r(r') for r' in left domain */
-    Real p_int_r_leftdomain(uint i, Real const& rr, RealVector const& table) const;
+    Real p_int_r_leftdomain(uint i, Real const& rr, Real const& t, RealVector const& table) const;
 
     /* i'th term of p_int_r(r') for r' in right domain, left of r0 */
-    Real p_int_r_rightdomainA(uint i, Real const& rr, RealVector const& table) const;
+    Real p_int_r_rightdomainA(uint i, Real const& rr, Real const& t, RealVector const& table) const;
 
     /* i'th term of p_int_r(r') for r' in right domain, right of r0 */
-    Real p_int_r_rightdomainB(uint i, Real const& rr, RealVector const& table) const;
+    Real p_int_r_rightdomainB(uint i, Real const& rr, Real const& t, RealVector const& table) const;
+
+    /* Fills table with r-independent part of p_int_r_i. */
+    void create_p_int_r_Table( Real const& t, RealVector& table ) const;
 
-    void createP_int_r_Table( Real const& t, RealVector& table ) const;
+    /* Returns i'th r-independent term of p_int_r_i.
+       Term is created if not in table. */
+    Real get_p_int_r_Table_i( uint& i, Real const& t, RealVector& table) const
+    {
+        if( i >= table.size() )
+        {
+            calculate_n_roots( i+1 );
+            create_p_int_r_Table( t, table );
+        }
 
+        return table[i];
+    }
 
     /* Denominator of the Greens function */
     inline Real p_denominator_i( Real const& root_n ) const;
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 6e75a209..110b0093 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -35,13 +35,13 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
 
     if ( fabs( h_a ) < 1 )
     {
-	// h = k/D
-	return 1/tan(x) + (h_a)/x;
+        // h = k/D
+        return 1/tan(x) + (h_a)/x;
     }
     else
     {
-	// h = k/D
-	return tan(x) + x/(h_a);
+        // h = k/D
+        return tan(x) + x/(h_a);
     }
     
 }
@@ -49,13 +49,15 @@ GreensFunction1DRadAbs::tan_f (double x, void *p)
 /* Fills the rootList with all the roots of tan(x*a)=-x/h up to n */
 void GreensFunction1DRadAbs::calculate_n_roots(uint const& n) const
 {
+    uint i( rootList_size() );
+    if( n <= i )
+        return;
+
     const Real L( this->geta()-this->getsigma() );
     const Real h( (this->getk()+this->getv()/2.0) / this->getD() );
     // the drift v also comes into this constant, h=(k+v/2)/D
     Real upper, lower, root_i;
 
-    uint i( rootList_size() );
-
     //No drift, and k = 0, use reflective solution.
     if (getk() < EPSILON && fabs( getv() ) < EPSILON )
     {
@@ -507,7 +509,8 @@ const
     // if t=0 nothing has happened => no event
 
     const Real a(this->geta());
-    const Real L(this->geta()-this->getsigma());
+    const Real sigma( this->getsigma() );
+    const Real L(this->geta()-sigma);
     const Real r0(this->getr0());
 
     // if the radiative boundary is impermeable (k==0) or
@@ -517,6 +520,23 @@ const
         return IV_ESCAPE;
     }
 
+    /* First check if we need to compare flux ratio's.
+       If only one boundary is 'visible' to the particle, use this boudnary as escape.*/
+    const Real distToa( a - r0 );
+    const Real distTos( r0 - sigma );
+    const Real maxDist( CUTOFF_H * ( sqrt(2.0 * D * t) + fabs(v * t) ) );
+
+    if( distToa > maxDist ) //Absorbing boundary 'not in sight'.
+    {
+        if( distTos < maxDist ) //Only radiation boundary 'in sight'.
+            return IV_REACTION;
+    }
+    else
+    {
+        if( distTos > maxDist ) //Only absorbing boundary 'in sight'.
+            return IV_ESCAPE;
+    }
+
     // Else the event is sampled from the flux ratio
     const Real fluxratio (this->fluxRatioRadTot(t));
 
@@ -665,7 +685,6 @@ Real GreensFunction1DRadAbs::drawTime (Real rnd) const
 /* Returns c.d.f. for drawR */
 Real GreensFunction1DRadAbs::p_int_r_table(Real const& r, 
                                            Real const& t,
-                                           Real const& p_surv,
                                            RealVector& table) const
 {
     const Real a( geta() );
@@ -693,7 +712,7 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
         {
             if( k != 0.0 && v == 0.0 )
                 //Only radiation BCn.
-                return XI30(r - sigma, t, distTos, getk(), D, 0.0) / p_surv;
+                return XI30(r - sigma, t, distTos, getk(), D, 0.0);
             else if( k == 0.0 && v == 0.0 )
                 //Only reflecting BCn.
                 return XI20(r - sigma, t, distTos, D, 0.0);
@@ -703,63 +722,67 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
     {
         if( distTos > maxDist )
             //Only absorbing BCn.
-            return XI10(a - r, t, distToa, D, -v) / p_surv;
+            return XI10(a - r, t, distToa, D, -v);
     }
 
+    Real p;
     const uint maxi( guess_maxi( t ) );
-    if( table.size() < maxi )
-    {
-        createP_int_r_Table(t, maxi, table);
-    }
-    
+
+    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+    const Real prefac( 2.0*exp(vexpo) );
+
     if( maxi >= MAX_TERMS )
     {
         log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
         std::cerr << dump();
         std::cerr << "L: " <<  L << " r0: " << r0 - sigma << std::endl;
+    } 
+
+    if( table.size() < maxi )
+    {
+        calculate_n_roots( maxi );
+        create_p_int_r_Table(t, table);
     }
-  
-    Real costerm( k / D );	
-    Real sinterm( h * v2D );
 
-    Real expsigma(exp(sigma*v2D));
-    Real zs(r - sigma);
+    p = funcSum(boost::bind(&GreensFunction1DRadAbs::p_int_r_i, 
+                            this, _1, r, t, table),
+                MAX_TERMS);
 
-    Real sum = 0, term = 0, prev_term = 0;
-    Real root_n, S_Cn_root_n;
+    return prefac * p;
+}
 
-    uint n = 0;
-    do
-    {
-        if (n >= maxi )
-        {
-            log_.info("Too many terms needed for DrawR. N: %6u", n );
-            break;
-        }
-        prev_term = term;
-        
-        S_Cn_root_n = table[n];
-        root_n  = get_root( n );
+Real GreensFunction1DRadAbs::p_int_r_i(uint i, 
+                                       Real const& r, 
+                                       Real const& t, 
+                                       RealVector& table) const
+{
+    const Real sigma( getsigma() );
+    const Real D( getD() );
+    const Real k( getk() );
+    const Real v( getv() );
+    const Real h(( k + v/2.0)/ D );
+    const Real v2D( v/(2*D) );
 
-        term = S_Cn_root_n * ( expsigma*costerm - exp(v2D*r)*
-                               ( costerm*cos(root_n*zs) - 
-                                 (root_n+sinterm/root_n)*sin(root_n*zs) ));
+    const Real costerm( k / D );	
+    const Real sinterm( h * v2D );
 
-        sum += term;
-        n++;
-    }
-    while (fabs(term/sum) > EPSILON ||
-           fabs(prev_term/sum) > EPSILON ||
-           n < MIN_TERMS );
+    const Real expsigma(exp(sigma*v2D));
+    const Real zs(r - sigma);
+
+    Real root_n( get_root( n ) );
+    
+    Real term( ( expsigma*costerm - exp(v2D*r)*
+                 ( costerm*cos(root_n*zs) - 
+                   (root_n+sinterm/root_n)*sin(root_n*zs) )) );
 
-    return sum;
+    return get_p_int_r_Table_i(i, t, table) * term;
 }
 
 /* Fills table for p_int_r of factors independent of r. */
-void GreensFunction1DRadAbs::createP_int_r_Table( Real const& t,
-                                                  uint const& maxi,
-                                                  RealVector& table ) const
-{    
+void GreensFunction1DRadAbs::create_p_int_r_Table( Real const& t,
+                                                   RealVector& table ) const
+{
+    const uint root_nmbr( rootList_size() );
     uint n( table.size() );
 
     const Real sigma( getsigma() );
@@ -769,19 +792,13 @@ void GreensFunction1DRadAbs::createP_int_r_Table( Real const& t,
     const Real v( getv() );
     const Real h(( k + v/2.0)/ D );
 
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D); // exponent of the drift-prefactor, same as in survival prob.
     const Real v2D(v/2.0/D);
     const Real v2Dv2D(v2D*v2D);
 
-    Real psurv;
     Real S_Cn_root_n;
     Real root_n2, root_n_r0_s, root_n;
 
-    psurv = p_survival(t);
-    assert(psurv >= 0.0);
-    const Real S = 2.0*exp(vexpo)/psurv;
-
-    while( n < maxi )
+    while( n < root_nmbr )
     {
         root_n = get_root(n);
        	root_n2 = root_n * root_n;
@@ -800,7 +817,7 @@ void GreensFunction1DRadAbs::createP_int_r_Table( Real const& t,
 Real GreensFunction1DRadAbs::drawR_f(Real r, void *p)
 {
     struct drawR_params *params = (struct drawR_params *)p;
-    return params->gf->p_int_r_table(r, params->t, params->p_surv, params->table) 
+    return params->gf->p_int_r_table(r, params->t, params->table) 
         - params->rnd;
 }
 
@@ -828,7 +845,7 @@ Real GreensFunction1DRadAbs::drawR (Real rnd, Real t) const
 
     // the structure to store the numbers to calculate the numbers for 1-S
     RealVector pintTable;
-    struct drawR_params parameters = {this, t, pintTable, rnd, p_survival( t )};
+    struct drawR_params parameters = {this, t, pintTable, rnd * p_survival( t )};
 
     // define gsl function for rootfinder
     gsl_function F;
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 9872e769..edab39ee 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -95,12 +95,12 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     Real geta() const
     {
-	return this->a;
+        return this->a;
     }
     
     Real getsigma() const
     {
-	return this->sigma;
+        return this->sigma;
     }
 
     void setr0(Real r0)
@@ -123,17 +123,17 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     Real getr0() const
     {
-	return r0;
+        return r0;
     }
 
     Real getk() const
     {
-	return this->k;
+        return this->k;
     }
 
     Real getv() const
     {
-	return this->v;
+        return this->v;
     }
 
     // Calculates the probability density of finding the particle at 
@@ -218,7 +218,6 @@ class GreensFunction1DRadAbs: public GreensFunction
         const Real t;
         RealVector table;
         Real rnd;
-        Real p_surv;
     };
 
 
@@ -248,16 +247,13 @@ class GreensFunction1DRadAbs: public GreensFunction
         rootList.erase( rootList.begin() + n );
     }
 
-    /* return the n'th root */
+    /* return the n + 1'th root */
     Real get_root( uint const& n ) const
     {
-        if( n < rootList.size() )
-            return rootList[ n ];
-        else
-        {
-            calculate_n_roots( n );
-            return rootList.back();
-        }
+        if( n >= rootList.size() )
+            calculate_n_roots( n+1 );
+
+        return rootList[ n ];
     }
 
     /* Fills the rootList with the first n roots. */
@@ -289,11 +285,22 @@ class GreensFunction1DRadAbs: public GreensFunction
 
     static Real drawR_f (Real z, void* p);
 
-    Real p_int_r_table(Real const& r, Real const& t, Real const& p_surv, 
-                       RealVector& table) const;
+    Real p_int_r_table(Real const& r, Real const& t, RealVector& table) const;
 
-    void createP_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
+    Real p_int_r_i(uint i, Real const& r, Real const& t, RealVector& table) const;
+
+    void create_p_int_r_Table( Real const& t, RealVector& table ) const;
     
+    Real get_p_int_r_Table_i( uint& i, Real const& t, RealVector& table) const
+    {
+        if( i >= table.size() )
+        {
+            calculate_n_roots( i+1 );
+            create_p_int_r_Table(t, table);
+        }
+
+        return table[i]
+    }
 
     /* Member variables */
 

From 8605f9b9f7e50bced76bffb0ee8cf1efe0a2b6cd Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Mon, 9 Jan 2012 10:37:17 +0100
Subject: [PATCH 0550/1541] Finisched GreensFunction documentation for sink.

---
 .../greensFunction1DAbsSinkAbs.include.tex    | 76 +++++++++----------
 .../greensFunction1DInfSinkInf.include.tex    | 50 ++++++------
 2 files changed, 59 insertions(+), 67 deletions(-)

diff --git a/doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex b/doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex
index 7a0056cd..9ef89846 100644
--- a/doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex
+++ b/doc/greens_functions/tex/include/greensFunction1DAbsSinkAbs.include.tex
@@ -1,40 +1,38 @@
-
-\subsection{1D Abs Abs}
-
-\paragraph{Green's function}
-
- \begin{multline}
- p_r(x,t|x_0) = -2 \sum_{i=1}^{\infty} \, e^{- D \beta_i ^2 t} \, \mathrm{sin} \, \beta_i (L_r - x) \\ 
-\frac{D \beta_i \, \mathrm{sin} \, \beta_i (L_l + x_0) + k \, \mathrm{sin} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i x_0}{D \, (L \beta_i \mathrm{cos} \, \beta_i L + \, \mathrm{sin} \, L \beta_i ) + k \,( L_r \, \mathrm{cos} \, \beta_i L_r \,\, \mathrm{sin} \, \beta_i L_l + L_l \, \mathrm{cos} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i L_r )},
- \label{FSOL_R}
-\end{multline}
-
-\begin{multline}
- p_l(x,t,|x_0) = -\sum_{i=1}^{\infty} e^{- D \beta_i ^2 t} \, 2 D \beta_i \, \\ 
-\frac{\mathrm{sin} \, \beta_i (L_l + x) \,\, \mathrm{sin} \, \beta_i (L_r - x_0)}{D \, (L \beta_i \mathrm{cos} \, \beta_i L + \, \mathrm{sin} \, L \beta_i ) + k \,( L_r \, \mathrm{cos} \, \beta_i L_r \,\, \mathrm{sin} \, \beta_i L_l + L_l \, \mathrm{cos} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i L_r )},
-\label{FSOL_L}
-\end{multline}
-
-where $L=L_r + L_l$ in both equations. Note that when $p_r$ is evaluated for $x<x_0$, $x$ and $x_0$ have to be interchanged in equation (\ref{FSOL_R}). This is due to the absolute sign in the Ansatz (\ref{Anz_R}).
-\end{align}
-
-\paragraph{Survival probability}
-\begin{align}
-  S_z(t) = \int_0^L p dz = \frac{4}{\pi} \sum_{m=0}^{\infty} \frac{1}{2m+1}
-  e^{-D_1(2m+1)^2\pi^2t/L^2} \sin\left(\frac{(2m+1)\pi z'}{L}\right).
-\end{align}
-
-\paragraph{Propensity function}
-\begin{align}
-  q_{z=0}(t) &= \left.D_1 \pd{p}{z}\right|_{z=0} = \frac{2\pi D_1}{L^2} 
-  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n \sin\left(\frac{n\pi z'}{L}\right),\\
-  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=L} = \frac{2\pi D_1}{L^2} 
-  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n (-1)^{n+1} \sin\left(\frac{n\pi z'}{L}\right).
-\end{align}
-
-\paragraph{Cumulative Green's function}
-\begin{align}
-  P(Z,t|z',t'=0) = \int_0^Z p dz =
-  \frac{2}{\pi} \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2 t/L^2}
-      \frac{1}{n} \left[ 1 - \cos\left(\frac{n\pi Z}{L}\right) \right] \sin\left(\frac{n\pi z'}{L}\right).
+
+\subsection{1D Abs Sink Abs}
+
+\paragraph{Green's function}
+is divided into two composite domains with functions $p_l$ and $p_r$ and the sink (rate k) at the origin. The left and right domains have lengths of respectively $L_l$ and $L_r$. $x_0$ is assumed to be in the right domain.
+ \begin{multline}
+ p_r(x,t|x_0) = - \sum_{i=1}^{\infty} \, e^{- D \beta_i ^2 t} \, 2 \, \mathrm{sin} \, \beta_i (L_r - x) \, \frac{D \beta_i \, \mathrm{sin} \, \beta_i (L_l + x_0) + k \, \mathrm{sin} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i x_0}{h'( \beta_i )},
+\end{multline}
+\begin{multline}
+ p_l(x,t,|x_0) = -\sum_{i=1}^{\infty} e^{- D \beta_i ^2 t} \, 2 D \beta_i \, \frac{\mathrm{sin} \, \beta_i (L_l + x) \,\, \mathrm{sin} \, \beta_i (L_r - x_0)}{h'( \beta_i )},
+\end{multline}
+where $L=L_r + L_l$ in both equations. Note that when $p_r$ is evaluated for $x<x_0$, $x$ and $x_0$ have to be interchanged. The denominator $h'( \beta_i )$ is
+\begin{equation*}
+h'( \beta_i ) = D \, (L \beta_i \mathrm{cos} \, \beta_i L + \, \mathrm{sin} \, L \beta_i ) + k \,( L_r \, \mathrm{cos} \, \beta_i L_r \,\, \mathrm{sin} \, \beta_i L_l + L_l \, \mathrm{cos} \, \beta_i L_l \,\, \mathrm{sin} \, \beta_i L_r )
+\end{equation*}
+The $\beta_i$'s are the roots of the equation
+\begin{equation*} 
+ D\beta_i \, \mathrm{sinh} \, \beta_i (L_r + L_l) + k \, \mathrm{sinh} \, \beta_i L_l \, \mathrm{sinh} \, \beta_i L_r = 0.
+\end{equation*}
+
+\paragraph{Survival probability}
+\begin{multline}
+S(t|x_0) = \bigg( 2 D \left[ \mathrm{sin} \, q L \, - \, \mathrm{sin} \, q (L_r - x_0) \, - \, \mathrm{sin} \, q (L_l + x_0)  \right] \, + \, \\ 
+ \frac{2 k}{q} \mathrm{sin} \, q L_l \left[ \mathrm{sin} \, q L_r \, - \, \mathrm{sin} \, q x_0 \, - \, \mathrm{sin} \, q (L_r - x_0) \right] \bigg) / h'( \beta_i ),
+\end{multline}
+where $q = \beta_i / L$.
+
+\paragraph{Propensity functions}
+\begin{align}
+  q_{x=L_l}(t) = \\
+  q_{x=L_r}(t) = \\
+  q_{x=0}(t) =
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P(X,t|x_0,t'=0) =
 \end{align}
\ No newline at end of file
diff --git a/doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex b/doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex
index e5118ced..ce2834e5 100644
--- a/doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex
+++ b/doc/greens_functions/tex/include/greensFunction1DInfSinkInf.include.tex
@@ -1,29 +1,23 @@
-
-\subsection{1D Abs Abs}
-
-\paragraph{Green's function}
-\begin{align}
-  p(z,t|z',t'=0) = \frac{2}{L}\sum_{n=1}^{\infty}
-  e^{-D_1n^2\pi^2t/L^2} \sin\bigg(\frac{n\pi z}{L}\bigg) \sin\left(\frac{n\pi z'}{L}\right).
-\end{align}
-
-\paragraph{Survival probability}
-\begin{align}
-  S_z(t) = \int_0^L p dz = \frac{4}{\pi} \sum_{m=0}^{\infty} \frac{1}{2m+1}
-  e^{-D_1(2m+1)^2\pi^2t/L^2} \sin\left(\frac{(2m+1)\pi z'}{L}\right).
-\end{align}
-
-\paragraph{Propensity function}
-\begin{align}
-  q_{z=0}(t) &= \left.D_1 \pd{p}{z}\right|_{z=0} = \frac{2\pi D_1}{L^2} 
-  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n \sin\left(\frac{n\pi z'}{L}\right),\\
-  q_{z=L}(t) &= \left.- D_1 \pd{p}{z}\right|_{z=L} = \frac{2\pi D_1}{L^2} 
-  \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2t/L^2} n (-1)^{n+1} \sin\left(\frac{n\pi z'}{L}\right).
-\end{align}
-
-\paragraph{Cumulative Green's function}
-\begin{align}
-  P(Z,t|z',t'=0) = \int_0^Z p dz =
-  \frac{2}{\pi} \sum_{n=1}^{\infty} e^{-D_1n^2\pi^2 t/L^2}
-      \frac{1}{n} \left[ 1 - \cos\left(\frac{n\pi Z}{L}\right) \right] \sin\left(\frac{n\pi z'}{L}\right).
+
+\subsection{1D Inf Sink Inf}
+
+\paragraph{Green's function} of a sink at $x_s$ with rate k in an unbounded domain
+\begin{multline}
+ p(x,t,|x_0) = \frac{1}{\sqrt{4 \pi D t}}e^{\frac{-(x-x_0)^2}{4 D t}} - \frac{k}{4 D}e^{\frac{k}{2 D}(|x-x_s|+|x_s-x_0|)+\frac{k^2 t}{4 D}} \\
+\mathrm{erfc}\left( \frac{|x-x_s|+|x_s-x_0|}{\sqrt{4 D t}}+\frac{k}{2D}\sqrt{D t} \right).
+\end{multline}
+
+\paragraph{Survival probability}
+\begin{align}
+  S_z(t|x_0) = 
+\end{align}
+
+\paragraph{Propensity function}
+\begin{align}
+  q_{x=x_s}(t) =   
+\end{align}
+
+\paragraph{Cumulative Green's function}
+\begin{align}
+  P(X,t|x_0,t'=0) = 
 \end{align}
\ No newline at end of file

From 15be80376481ab53edaf93d64414f13f1e480a55 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 9 Jan 2012 12:18:51 +0100
Subject: [PATCH 0551/1541] A safety factor should also be included when sizing
 against surfaces

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 9b91ab3f..3de3c882 100755
--- a/shells.py
+++ b/shells.py
@@ -707,7 +707,7 @@ def determine_possible_shell(self, ignore, ignores):
             # FIXME ugly hack to make spherical singles overlap with membranes
             if isinstance(surface, PlanarSurface) and isinstance(self, SphericalSingletestShell):
                 distance += self.pid_particle_pair[1].radius
-            radius = min(radius, distance)
+            radius = min(radius, distance/SAFETY)
             if radius < min_radius:
                 raise ShellmakingError('Surface too close to make spherical testshell, '
                                        'surface = %s, distance = %s, testShell = %s' %

From c76fef74bb1695fb80b68df7b3ba3127da40f84e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 9 Jan 2012 13:56:51 +0100
Subject: [PATCH 0552/1541] added comments, some namechanges and small cleanup

---
 egfrd.py  | 271 +++++++++++++++++++++++++++++++-----------------------
 shells.py |   1 +
 2 files changed, 159 insertions(+), 113 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 47438e6e..24c66a24 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -52,34 +52,37 @@
 
 log = logging.getLogger('ecell')
 
-
-def create_default_single(domain_id, pid_particle_pair, shell_id, rt, structure, geometrycontainer, domains):
+### Singles
+def create_default_single(domain_id, shell_id, pid_particle_pair, structure, reaction_rules, geometrycontainer, domains):
     if isinstance(structure, CuboidalRegion):
         # first make the test shell
         testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
-        return SphericalSingle(domain_id, shell_id, testSingle, rt)
+        return SphericalSingle          (domain_id, shell_id, testSingle, reaction_rules)
     elif isinstance(structure, PlanarSurface):
         # first make the test shell
         testSingle = PlanarSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
-        return PlanarSurfaceSingle(domain_id, shell_id, testSingle, rt)
+        return PlanarSurfaceSingle      (domain_id, shell_id, testSingle, reaction_rules)
     elif isinstance(structure, CylindricalSurface):
         # first make the test shell
         testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
-        return CylindricalSurfaceSingle(domain_id, shell_id, testSingle, rt)
+        return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
 
+### Interactions
+def try_default_testinteraction(single, surface, geometrycontainer, domains):
+    if isinstance(surface, PlanarSurface):
+        return PlanarSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+    elif isinstance(surface, CylindricalSurface):
+        return CylindricalSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+    else:
+        raise testShellError('(Interaction). surface is not supported')
 
-def create_default_pair(domain_id, shell_id, testShell, rrs):
-    # Either SphericalPair, PlanarSurfacePair, or CylindricalSurfacePair.
-    if   isinstance(testShell, SphericalPairtestShell):
-        return SphericalPair          (domain_id, shell_id, testShell, rrs)
-    elif isinstance(testShell, PlanarSurfacePairtestShell):
-        return PlanarSurfacePair      (domain_id, shell_id, testShell, rrs)
-    elif isinstance(testShell, CylindricalSurfacePairtestShell):
-        return CylindricalSurfacePair (domain_id, shell_id, testShell, rrs)
-    # or MixedPair (3D/2D)
-    elif isinstance(testShell, MixedPair2D3DtestShell):
-        return MixedPair2D3D          (domain_id, shell_id, testShell, rrs)
+def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, interaction_rules):
+    if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
+        return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
+        return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
+### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
     if single1.structure == single2.structure:
         if isinstance(single1.structure, CuboidalRegion):
@@ -96,13 +99,17 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
         # a 1D/3D pair was supposed to be formed -> unsupported
         raise testShellError('(MixedPair). combination of structure not supported')
         
-def try_default_testinteraction(single, surface, geometrycontainer, domains):
-    if isinstance(surface, PlanarSurface):
-        return PlanarSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
-    elif isinstance(surface, CylindricalSurface):
-        return CylindricalSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
-    else:
-        raise testShellError('(Interaction). surface is not supported')
+def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
+    # Either SphericalPair, PlanarSurfacePair, or CylindricalSurfacePair.
+    if   isinstance(testShell, SphericalPairtestShell):
+        return SphericalPair          (domain_id, shell_id, testShell, reaction_rules)
+    elif isinstance(testShell, PlanarSurfacePairtestShell):
+        return PlanarSurfacePair      (domain_id, shell_id, testShell, reaction_rules)
+    elif isinstance(testShell, CylindricalSurfacePairtestShell):
+        return CylindricalSurfacePair (domain_id, shell_id, testShell, reaction_rules)
+    # or MixedPair (3D/2D)
+    elif isinstance(testShell, MixedPair2D3DtestShell):
+        return MixedPair2D3D          (domain_id, shell_id, testShell, reaction_rules)
 
 
 class DomainEvent(Event):
@@ -392,13 +399,17 @@ def step(self):
 
 
     def create_single(self, pid_particle_pair):
+    # Create a new single domain from a particle.
+    # The interaction can be any NonInteractionSingle (SphericalSingle, PlanarSurface or CylindricalSurface
+    # NonInteractionSingle).
 
         # 1. generate identifiers for the domain and shell. The event_id is
         # generated by the scheduler
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
-        rrs = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
+        # get unimolecular reaction rules
+        reaction_rules = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
         # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
         structure = self.world.get_structure(species.structure_id)
@@ -408,8 +419,8 @@ def create_single(self, pid_particle_pair):
         # depends on the structure (region or surface) this particle is 
         # in/on. Either SphericalSingle, PlanarSurfaceSingle, or 
         # CylindricalSurfaceSingle.
-        single = create_default_single(domain_id, pid_particle_pair, 
-                                       shell_id, rrs, structure,
+        single = create_default_single(domain_id, shell_id, pid_particle_pair, 
+                                       structure, reaction_rules,
                                        self.geometrycontainer, self.domains)
 
         assert isinstance(single, NonInteractionSingle)
@@ -422,11 +433,14 @@ def create_single(self, pid_particle_pair):
         if __debug__:
             # Used in __str__.
             single.world = self.world
+
         return single
 
     def create_interaction(self, testShell):
+    # Create a new interaction domain from a testShell.
+    # The interaction can be any interaction (PlanarSurface or CylindricalSurface). The creation of the testShell was
+    # succesful, so here we can just make the domain.
 
-##        assert single.dt == 0.0 and single.get_mobility_radius() == 0.0
 #       assert that the particle is not already associate with another domain
 
         assert isinstance(testShell, testInteractionSingle)
@@ -436,25 +450,21 @@ def create_interaction(self, testShell):
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
-        species_id = testShell.pid_particle_pair[1].sid
-        species = self.world.get_species(species_id)
-        # the structure on which the particle lives
-        structure = self.world.get_structure(species.structure_id)
-        # the surface_id if the interaction surface
-        surface_id = testShell.surface.sid
-
         # get unimolecular reaction rules
+        species_id = testShell.pid_particle_pair[1].sid
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
         # get reaction rules for interaction
+        surface_id = testShell.surface.sid
         interaction_rules = self.network_rules.query_reaction_rule(species_id, surface_id)
 
 
-        if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
-            interaction = CylindricalSurfaceInteraction(domain_id, shell_id, testShell,
-                                                        reaction_rules, interaction_rules)
-        elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
-            interaction = PlanarSurfaceInteraction(domain_id, shell_id, testShell,
-                                                   reaction_rules, interaction_rules)
+        # 2. Create and register the interaction domain.
+        # The type of the interaction that will be created 
+        # depends on the surface (planar or cylindrical) the particle is 
+        # trying to associate with. Either PlanarSurfaceInteraction or 
+        # CylindricalSurfaceInteraction.
+        interaction = create_default_interaction(domain_id, shell_id, testShell,
+                                                 reaction_rules, interaction_rules)
 
         assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
@@ -470,27 +480,24 @@ def create_interaction(self, testShell):
         return interaction
 
     def create_pair(self, testShell):
+    # Create a new pair domain from a testShell.
+    # The pair can be any pair (Simple or Mixed). The creation of the testShell was
+    # succesful, so here we can just make the domain.
 
-        pid_particle_pair1 = testShell.pid_particle_pair1
-        pid_particle_pair2 = testShell.pid_particle_pair2
+        assert isinstance(testShell, testPair)
 
         # 1. generate needed identifiers
         domain_id = self.domain_id_generator()
         shell_id = self.shell_id_generator()
 
         # Select 1 reaction type out of all possible reaction types between the two particles.
-        rrs = self.network_rules.query_reaction_rule(pid_particle_pair1[1].sid,
-                                                     pid_particle_pair2[1].sid)
+        reaction_rules = self.network_rules.query_reaction_rule(testShell.pid_particle_pair1[1].sid,
+                                                                testShell.pid_particle_pair2[1].sid)
 
-        # Get structure (region or surface) where particles live.
-        species1 = self.world.get_species(pid_particle_pair1[1].sid)
-        species2 = self.world.get_species(pid_particle_pair2[1].sid)
-        structure1 = self.world.get_structure(species1.structure_id)
-        structure2 = self.world.get_structure(species2.structure_id)
 
         # 2. Create pair. The type of the pair that will be created depends
         # on the structure (region or surface) the particles are in/on.  
-        pair = create_default_pair(domain_id, shell_id, testShell, rrs)
+        pair = create_default_pair(domain_id, shell_id, testShell, reaction_rules)
 
         assert isinstance(pair, Pair)
         pair.initialize(self.t)
@@ -502,6 +509,7 @@ def create_pair(self, testShell):
         if __debug__:
             # Used in __str__.
             pair.world = self.world
+
         return pair
 
     def create_multi(self):
@@ -520,16 +528,16 @@ def create_multi(self):
 #    def move_single(self, single, position, radius=None):
 #        single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
 #        self.update_single_shell(single, position, radius)
-
-    def update_single_shell(self, single, shell):#position, radius=None):
-        # Reuse shell_id.
-        shell_id = single.shell_id
-
-        # Replace shell.
-        shell_id_shell_pair = (shell_id, shell) 
-
-        single.shell_id_shell_pair = shell_id_shell_pair
-        self.geometrycontainer.move_shell(shell_id_shell_pair)
+#
+#    def update_single_shell(self, single, shell):#position, radius=None):
+#        # Reuse shell_id.
+#        shell_id = single.shell_id
+#
+#        # Replace shell.
+#        shell_id_shell_pair = (shell_id, shell) 
+#
+#        single.shell_id_shell_pair = shell_id_shell_pair
+#        self.geometrycontainer.move_shell(shell_id_shell_pair)
 
     def move_particle(self, pid_particle_pair, position):
         # moves a particle in world based on an existing particle
@@ -1116,6 +1124,7 @@ def make_new_domain(self, single):
 
         # can only make new domain from NonInteractionSingle
         assert isinstance(single, NonInteractionSingle)
+        assert single.is_reset()
         
         # Special case: When D=0, nothing needs to change and only new event
         # time is drawn
@@ -1258,7 +1267,6 @@ def make_new_domain(self, single):
             if closest_overlap > 0.0: 
                 # just make a normal NonInteractionSingle
                 self.update_single(single)
-                self.add_domain_event(single)
             else:
                 # An object was closer than the Multi horizon
                 # Form a multi with everything that is in the multi_horizon
@@ -1310,25 +1318,48 @@ def calculate_simplepair_shell_size(self, single1, single2):
 
 
     def update_single(self, single): 
-        assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
+    # updates a NonInteractionSingle given that the single already holds its new position
+
+        # The method only works for NonInteractionSingles
+        assert isinstance(single, NonInteractionSingle)
+
+        singlepos = single.pid_particle_pair[1].position    # TODO get the position as an argument
+
 
-        singlepos = single.pid_particle_pair[1].position
+        # create a new updated shell
         new_shell = single.create_updated_shell(singlepos)
         assert new_shell, 'single.create_updated_shell() returned None.'
 
+        # Replace shell in domain and geometrycontainer.
+        # Note: this should be done before determine_next_event.
+        # Reuse shell_id.
+        shell_id_shell_pair = (single.shell_id, new_shell) 
+        single.shell_id_shell_pair = shell_id_shell_pair
+        self.geometrycontainer.move_shell(shell_id_shell_pair)
         if __debug__:
-            log.info('update_single: single: %s, new_shell = %s' % \
+            log.info('        *Updated single: single: %s, new_shell = %s' % \
                      (single, str(new_shell)))
 
-        # Resize shell, don't change position.
-        # Note: this should be done before determine_next_event.
-        self.update_single_shell(single, new_shell)        
-
         single.dt, single.event_type = single.determine_next_event()
+        assert single.dt >= 0
+        if __debug__:
+            log.info('dt=%s' % (FORMAT_DOUBLE % single.dt)) 
+
         single.last_time = self.t
 
+        # check everything is ok
+        assert self.check_domain(single)
+        # add to scheduler
+        self.add_domain_event(single)
+
+        return single
+
 
     def process_single_event(self, single):
+    # This method handles the things that need to be done when the current event was
+    # produced by a single. The single can be a NonInteractionSingle or an InteractionSingle.
+    # Note that this method is also called when a single is bursted. This event in that
+    # case is just a BURST event.
 
         ### log Single event
         if __debug__:
@@ -1336,7 +1367,6 @@ def process_single_event(self, single):
             log.info('single = %s' % single)
 
 
-
         if single.is_reset():
         ### If no event event really happened and just need to make new domain
             domains = [self.make_new_domain(single)]
@@ -1351,6 +1381,7 @@ def process_single_event(self, single):
         else:
         ### 1. Process 'normal' event produced by the single
 
+            assert self.check_domain(single)
             # check that the event time of the single (last_time + dt) is equal to the
             # simulator time
             assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t), \
@@ -1426,39 +1457,45 @@ def process_single_event(self, single):
 
 
     def process_pair_event(self, pair):
-        assert self.check_domain(pair)
+    # This method handles the things that need to be done when the current event was
+    # produced by a pair.
+    # Note that this method is also called when a pair is bursted. This event in that
+    # case is just a BURST event.
 
         if __debug__:
             log.info('FIRE PAIR: %s' % pair.event_type)
             log.info('single1 = %s' % pair.single1)
             log.info('single2 = %s' % pair.single2)
 
+        ### 1. check that everything is ok
+        assert self.check_domain(pair)
+        assert pair.single1.domain_id not in self.domains
+        assert pair.single2.domain_id not in self.domains
+
         # check that the event time of the single (last_time + dt) is equal to the
         # simulator time
         assert (abs(pair.last_time + pair.dt - self.t) <= TIME_TOLERANCE * self.t), \
             'Timeline incorrect. pair.last_time = %s, pair.dt = %s, self.t = %s' % \
             (FORMAT_DOUBLE % pair.last_time, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % self.t)
 
-
-
+        ### 2. get some necessary information
         single1 = pair.single1
         single2 = pair.single2
-        assert single1.domain_id not in self.domains
-        assert single2.domain_id not in self.domains
-
         pid_particle_pair1 = pair.pid_particle_pair1
         pid_particle_pair2 = pair.pid_particle_pair2
-        pos1 = pid_particle_pair1[1].position
-        pos2 = pid_particle_pair2[1].position
+        oldpos1 = pid_particle_pair1[1].position
+        oldpos2 = pid_particle_pair2[1].position
+
 
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
             pair.event_type = pair.draw_iv_event_type(pair.r0)
 
-        self.pair_steps[pair.event_type] += 1
 
+        ### 3. Process the event produced by the pair
+        self.pair_steps[pair.event_type] += 1
 
-        # Get new position of particles
+        ### 3.1 Get new position of particles
         if pair.dt > 0.0:
             newpos1, newpos2 = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
             newpos1 = self.world.apply_boundary(newpos1)
@@ -1484,9 +1521,9 @@ def process_pair_event(self, pair):
 
         self.remove_domain(pair)
 
-        # If identity changing processes have taken place
-        # Four cases:
-        #  1. Single reaction
+        ### 3.2 If identity changing processes have taken place
+        #       Four cases:
+        #       1. Single reaction
         if pair.event_type == EventType.SINGLE_REACTION:
             reactingsingle = pair.reactingsingle
 
@@ -1504,7 +1541,7 @@ def process_pair_event(self, pair):
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
 
-            
+            # Make new NonInteractionSingle domains for every particle after the reaction.
             domains = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
@@ -1513,12 +1550,13 @@ def process_pair_event(self, pair):
                 domains.append(single)
 
         #
-        # 2. Pair reaction
+        #       2. Pair reaction
         #
         elif pair.event_type == EventType.IV_REACTION:
 
             particles = self.fire_pair_reaction (pair, newpos1, newpos2)
 
+            # Make new NonInteractionSingle domains for every particle after the reaction.
             domains = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
@@ -1527,8 +1565,8 @@ def process_pair_event(self, pair):
                 domains.append(single)
 
         # Just moving the particles
-        #  3a. IV escape
-        #  3b. com escape
+        #       3a. IV escape
+        #       3b. com escape
         elif(pair.event_type == EventType.IV_ESCAPE or
              pair.event_type == EventType.COM_ESCAPE or
              pair.event_type == EventType.BURST):
@@ -1536,7 +1574,7 @@ def process_pair_event(self, pair):
             particles = self.fire_move (single1, newpos1, pid_particle_pair2)
             particles.extend(self.fire_move (single2, newpos2, pid_particle_pair1))
 
-            # make new NonInteractionSingeles and reschedule domains
+            # Make new NonInteractionSingle domains for every particle after the reaction.
             domains = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
@@ -1597,9 +1635,9 @@ def process_pair_event(self, pair):
         # Log the event
         if __debug__:
             log.debug("process_pair_event: #1 { %s: %s => %s }" %
-                      (single1, str(pos1), str(newpos1)))
+                      (single1, str(oldpos1), str(newpos1)))
             log.debug("process_pair_event: #2 { %s: %s => %s }" %
-                      (single2, str(pos2), str(newpos2)))
+                      (single2, str(oldpos2), str(newpos2)))
 
         return domains
 
@@ -1684,17 +1722,15 @@ def burst_pair(self, pair):
 
 
     def try_interaction(self, single, surface):
-        # Try to form an interaction between the 'single' particle and the 'surface'.
-        assert single.is_reset()
-
-        pid_particle_pair = single.pid_particle_pair
-        particle = pid_particle_pair[1]
+    # Try to form an interaction between the 'single' particle and the 'surface'. The interaction can be a:
+    # -CylindricalSurfaceInteraction
+    # -PlanarSurfaceInteraction
 
         if __debug__:
-           log.debug('trying to form Interaction(%s, %s)' % (particle, surface))
+           log.debug('trying to form Interaction(%s, %s)' % (single.pid_particle_pair[1], surface))
 
 
-        ### 1. See if there is enough space for the shell
+        ### 1. Attempt to make a testShell. If it fails it will throw an exception.
         try:
             testShell = try_default_testinteraction(single, surface, self.geometrycontainer, self.domains)
         except testShellError as e:
@@ -1705,37 +1741,46 @@ def try_interaction(self, single, surface):
                           str(e) ))
 
 
-        ### 2. The shell can be made. Now do what's necessary to make it
+        ### 2. The testShell was made succesfully. Now make the complete domain
         if testShell:
+            # make the domain
             interaction = self.create_interaction(testShell)
+            if __debug__:
+                log.info('        *Created: %s' % (interaction))
 
+            # get the next event time
             interaction.dt, interaction.event_type, = interaction.determine_next_event()
-            assert interaction.dt > 0.0
+            assert interaction.dt >= 0.0
+            if __debug__:
+                log.info('dt=%s' % (FORMAT_DOUBLE % interaction.dt)) 
 
             self.last_time = self.t
 
             self.remove_domain(single)
             # the event associated with the single will be removed by the scheduler.
 
+            # check everything is ok
             assert self.check_domain(interaction)
+            # add to scheduler
             self.add_domain_event(interaction)
 
-            if __debug__:
-                log.info('        *Created: %s' % (interaction))
-
             return interaction
         else:
             return None
 
 
     def try_pair(self, single1, single2):
+    # Try to make a pair domain out of the two singles. A pair domain can be a:
+    # -SimplePair (both particles live on the same structure)
+    # -MixedPair (the particles live on different structures -> MixedPair2D3D)
+    # Note that single1 is always the single that initiated the creation of the pair
+    #  and is therefore no longer in the scheduler
+
         if __debug__:
             log.debug('trying to form Pair(%s, %s)' %
                 (single1.pid_particle_pair, single2.pid_particle_pair))
 
-        assert single1.is_reset()
-        assert single2.is_reset()
-
+        ### 1. Attempt to make a testShell. If it fails it will throw an exception.
         try:
             testShell = try_default_testpair(single1, single2, self.geometrycontainer, self.domains)
         except testShellError as e:
@@ -1746,31 +1791,31 @@ def try_pair(self, single1, single2):
                           str(e) ))
 
 
-        # if a pair could be formed
+        ### 2. If the testShell could be formed, make the complete domain.
         if testShell:
             pair = self.create_pair(testShell)
             if __debug__:
-                log.info('Created: %s' % (pair))
-
-            pair.dt, pair.event_type, pair.reactingsingle = \
-            pair.determine_next_event(pair.r0)
+                log.info('        *Created: %s' % (pair))
 
+            pair.dt, pair.event_type, pair.reactingsingle = pair.determine_next_event(pair.r0)
             assert pair.dt >= 0
+            if __debug__:
+                log.info('dt=%s' % (FORMAT_DOUBLE % pair.dt)) 
 
             self.last_time = self.t
 
             self.remove_domain(single1)
             self.remove_domain(single2)
 
-            # single1 will be removed by the scheduler.
+            # single1 will be removed by the scheduler, since it initiated the creation of the
+            # pair.
             self.remove_event(single2)
 
+            # check everything is ok
             assert self.check_domain(pair)
+            # add to scheduler
             self.add_domain_event(pair)
 
-            if __debug__:
-                log.info('dt=%s' % (FORMAT_DOUBLE % pair.dt)) 
-
             return pair
         else:
             return None
diff --git a/shells.py b/shells.py
index 3de3c882..2ae7ba02 100755
--- a/shells.py
+++ b/shells.py
@@ -121,6 +121,7 @@ def __init__(self, pid_particle_pair, structure):
 class testInteractionSingle(testSingle, Others):
 
     def __init__(self, single, structure, surface):
+        assert single.is_reset()
         testSingle.__init__(self, single.pid_particle_pair, structure)
         # Note: for the Others superclass nothing is to be initialized.
 

From 07ad76b139120f9829e1a48c00850f2d3c6dddb9 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Mon, 9 Jan 2012 14:14:21 +0100
Subject: [PATCH 0553/1541] Included enhanced rootfinder for Sink GFn. Included
 error message for drawTime in 2DRadAbs GFn.

---
 GreensFunction1DAbsSinkAbs.cpp | 41 ++++++++++++++++++++++++++--------
 GreensFunction2DRadAbs.cpp     | 25 +++++++++++++--------
 2 files changed, 48 insertions(+), 18 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index bb32d39b..43ddfb82 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -161,8 +161,8 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     /* f_lower must have correct sign. */
     if( f_lower * parity_op > 0 )
     {
-        log_.warn("Parity error in x_lower of root# %6u .",
-                  rootList_size() + 1);
+        log_.warn("f(lower) has wrong sign at root# %6u, for h = %.5g, Lm/L = %.5g.",
+                  rootList_size() + 1, lo_up_params.h, lo_up_params.Lm_L );
 
         log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
                   lower, f_lower, upper, f_upper);
@@ -173,23 +173,46 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     {
         int cntr = 0;
 
-        const Real delta( .1 * std::min(left_offset, right_offset) );
+        Real delta( .1 * safety * right_offset );
+        const Real save_upper( upper );
         
         cntr = 0;
-        //TODO: find out is upper is left or right from next_root.
+
+        /* Assuming the upper point has overshoot the straddle region,
+           subtract from the upper limit, until endpoits do straddle.
+         */
         while(f_upper * parity_op < 0 && cntr++ < 10 )
         {
-            //Assume overshoot for now.
+            //Correct for overshoot.
             upper -= delta;
             f_upper = root_f( upper, &p );
         }
 
+        /* If upper point still doesn't straddle the root, increase the old estimate 
+           of upper, until it does straddle*/
         if(cntr >= 10)
         {
-            log_.warn("Failed to straddle root# %6u . ",
-                      rootList_size() + 1);
-            log_.warn("f_low( %.16g ) =  %.16g , f_high( %.16g ) = %.16g",
-                  lower, f_lower, upper, f_upper);
+            cntr = 0;
+            upper = save_upper;
+            f_upper = root_f( upper, &p );
+
+            while(f_upper * parity_op < 0 && cntr++ < 10 )
+            {
+                //Correct for undershoot.
+                upper += delta;
+                f_upper = root_f( upper, &p );
+            }
+
+            // Still no straddle? => Crash is imminent.
+            if(cntr >= 10)
+            {
+                log_.warn("Failed to straddle root# %6u. ",
+                          rootList_size() + 1);
+                log_.warn("next root est. = %.16g with stepsize: %.16g, ll: %.16g, ls: %.16g.", 
+                          next_root_est, delta, lo_up_params.last_long_root, lo_up_params.last_short_root);
+                log_.warn("f_low( %.16g ) =  %.16g, f_high( %.16g ) = %.16g.",
+                          lower, f_lower, upper, f_upper);
+            }
         }
 
     }
diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 85d333c9..e6c36c21 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -770,6 +770,9 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
 	Real p;
 	const unsigned int maxi( guess_maxi( t ) );	// guess the maximum number of iterations required
             
+    if( maxi == this->MAX_ALPHA_SEQ )
+        std::cerr << " p_survival_table (used by drawTime) couldn't converge; max terms reached: " << maxi << std::endl;
+           
         if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
         {						// that the table is filled
         	IGNORE_RETURN getAlpha( 0, maxi );	// this updates the table of roots
@@ -871,26 +874,28 @@ Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
     THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
     THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
 
-    Real dist;
-
+    Real t_guess;
 
     if( r0 == a || a == sigma )		// when the particle is at the border or if the PD has no real size
     {
 	return 0.0;
     }
 
+    // get some initial guess for the time, dr=sqrt(2dDt) with d
+    // the dimensionality (2 in this case)
+    const Real t_Abs( gsl_pow_2( a - r0 ) / ( 4.0 * D ) );
     if ( kf == 0.0 )			// if there was only one absorbing boundary
     {	
-        dist = a - r0;
+        t_guess = t_Abs;
     }
     else
     {	
-        dist = std::min( a - r0, r0 - sigma );	// take the shortest distance to a boundary
+        const Real t_Rad( D / gsl_pow_2( kf/(2*M_PI*a) ) + gsl_pow_2( r0 - sigma ) / D );
+        t_guess = std::min( t_Abs, t_Rad );	// take the shortest time to a boundary
     }
-    Real t_guess = dist * dist / ( 4.0 * D );	// get some initial guess for the time, dr=sqrt(2dDt) with d
-						// the dimensionality (2 in this case)
-
-
+    
+    t_guess *= .1;
+    
 	const Real minT( std::min( sigma * sigma / D * this->MIN_T_FACTOR,
                                t_guess * 1e-7 ) );	// something with determining the lowest possible t
 
@@ -1235,7 +1240,9 @@ GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
 		m++;
 		if( m >= this->MAX_ORDER )		// If the number of terms is too large
 		{
-			std::cerr << "p_m didn't converge (m=" << m << "), continuing..." << std::endl;
+			std::cerr << "p_m didn't converge (m=" << m << "), t = " << t << " r0, r = " << getr0() << ", " << r << 
+			    " t_est = " << gsl_pow_2( r - getr0() ) / getD() << ", continuing..." << std::endl;
+    		std::cerr << dump() <<std::endl;	    
 			break;
 		}
 

From 48babc2fa3d1257995170f6e4ed8ca11ca2aac1a Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Mon, 9 Jan 2012 15:28:00 +0100
Subject: [PATCH 0554/1541] Removed bugs such that the 1D GF's compile.

---
 GreensFunction1DAbsAbs.cpp     | 44 ++++++++++++++++++----------------
 GreensFunction1DAbsAbs.hpp     |  4 ++--
 GreensFunction1DAbsSinkAbs.cpp | 12 +++++-----
 GreensFunction1DAbsSinkAbs.hpp |  6 ++---
 GreensFunction1DRadAbs.cpp     | 16 ++++++-------
 GreensFunction1DRadAbs.hpp     |  2 +-
 6 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index c7e7747b..def35c7e 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -581,10 +581,6 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
     const Real r0( getr0() );
     const Real D( getD() );
     const Real v( getv() );
-    const Real v2D( getv()/(2*D) );
-
-    Real sum = 0, term = 0, prev_term = 0;
-    Real S_Cn_An, n_L;
 
     const Real distToa( a - r0 );
     const Real distTos( r0 - sigma );
@@ -605,11 +601,15 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
             return XI10(a - r, t, distToa, D, -v);
     }
 
+
+    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
+    const Real prefac = 2.0 * exp(vexpo);
+
     Real p;
     const uint maxi( guess_maxi( t ) );
     if( table.size() < maxi )
     {
-        createP_int_r_Table(t, maxi, table);
+        create_p_int_r_Table(t, maxi, table);
     }
     
     if( maxi >= MAX_TERMS )
@@ -620,15 +620,24 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
     }
 
     p = funcSum(boost::bind(&GreensFunction1DAbsAbs::p_int_r_i, 
-                            this, _1, t, table),
+                            this, _1, r, t, table),
                 MAX_TERMS);
 
-    return p;
+    return prefac * p;
 }
 
-Real p_int_r_i(uint i, Real const& t, RealVector& table) const
+Real GreensFunction1DAbsAbs::p_int_r_i(uint i, 
+                                       Real const& r, 
+                                       Real const& t, 
+                                       RealVector& table) const
 {           
-    n_L = ((Real)(i + 1.0)) * M_PI / L;
+    const Real D( getD() );
+    const Real sigma( getsigma() );
+    const Real L( geta() - sigma );
+    const Real v2D( getv()/(2*D) );
+    const Real n_L = ((Real)(i + 1.0)) * M_PI / L;
+
+    Real term;
 
     if(v2D==0.0)	
         term = 1.0 - cos(n_L*(r-sigma));
@@ -637,7 +646,7 @@ Real p_int_r_i(uint i, Real const& t, RealVector& table) const
             ( v2D/n_L*sin(n_L*(r-sigma)) 
               - cos(n_L*(r-sigma)) );
     
-    return term * get_p_int_r_Table_i(i ,t, table);
+    return term * get_p_int_r_Table_i(i , t, table);
 }
 
 /* Fills table for p_int_r of factors independent of r. */
@@ -656,26 +665,19 @@ void GreensFunction1DAbsAbs::create_p_int_r_Table( Real const& t,
     const Real expo (-D*t/(L*L));
     const Real r0s_L((r0-sigma)/L);
     const Real Lv2D(L*v/2.0/D);
-    const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
-
-    Real S_Cn_An;
-    Real nPI;
-    Real psurv;
 
-    psurv = p_survival(t);
-    assert(psurv >= 0.0);
-    const Real S = 2.0*exp(vexpo)/psurv;
+    Real nPI, term;
 
     while( n < maxi )
     {
         nPI = ((Real)(n+1))*M_PI;
 	    
         if( v == 0.0 )
-            S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
+            term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
         else
-            S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) * nPI/(nPI*nPI + Lv2D*Lv2D);
+            term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * nPI/(nPI*nPI + Lv2D*Lv2D);
 
-        table.push_back( S_Cn_An );
+        table.push_back( term );
         n++;
     }
 }
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 122248cf..4134336d 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -207,7 +207,7 @@ class GreensFunction1DAbsAbs: public GreensFunction
 
     Real p_int_r_table(Real const& r, Real const& t, RealVector& table) const;
 
-    Real p_int_r_i(uint i, Real const& t, RealVector& table) const;
+    Real p_int_r_i(uint i, Real const& r, Real const& t, RealVector& table) const;
 
     void create_p_int_r_Table( Real const& t, uint const& maxi, RealVector& table ) const;
 
@@ -215,7 +215,7 @@ class GreensFunction1DAbsAbs: public GreensFunction
     {
         if( i >= table.size() )
         {
-            create_p_int_r_Table(t, i, table);
+            create_p_int_r_Table(t, i+1, table);
         }
 
         return table[i];
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 43ddfb82..b6fda348 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -891,7 +891,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
     /* Determine in which part of the domain rr lies, and
        thus which function to use. */
     Real (GreensFunction1DAbsSinkAbs::*p_int_r_i)
-        (uint, Real const&, Real const&, RealVector const& table) const = NULL;
+        (uint, Real const&, Real const&, RealVector& table) const = NULL;
 
     if( rr <= 0 )
         p_int_r_i = &GreensFunction1DAbsSinkAbs::p_int_r_leftdomain;
@@ -915,7 +915,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r(Real const& r,
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
 
     RealVector table;
-    return p_int_r_table(r, t, table) / p_survival( t );
+    return p_int_r_table(r, t, table);
 }
 
 
@@ -938,7 +938,7 @@ void GreensFunction1DAbsSinkAbs::create_p_int_r_Table( Real const& t,
 Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint i, 
                                                     Real const& rr,
                                                     Real const& t,
-                                                    RealVector const& table) const
+                                                    RealVector& table) const
 {
     const Real root_i( get_root( i ) );
     const Real LrmL0( getLr() - getL0() );
@@ -955,7 +955,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_leftdomain(uint i,
 Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(uint i, 
                                                       Real const& rr, 
                                                       Real const& t,
-                                                      RealVector const& table) const
+                                                      RealVector& table) const
 {
     const Real root_i( get_root( i ) );
     const Real LrmL0( getLr() - getL0() );
@@ -974,7 +974,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainA(uint i,
 Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint i, 
                                                       Real const& rr, 
                                                       Real const& t,
-                                                      RealVector const& table) const
+                                                      RealVector& table) const
 {
     const Real root_i( get_root( i ) );
     const Real Lr( getLr() );
@@ -1002,7 +1002,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_rightdomainB(uint i,
 Real GreensFunction1DAbsSinkAbs::drawR_f(Real r, void *p)
 {
     struct drawR_params *params = (struct drawR_params *)p;
-    return params->gf->p_int_r_table(r, params->t, params->p_surv, params->table) 
+    return params->gf->p_int_r_table(r, params->t, params->table) 
         - params->rnd;
 }
 
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 304e2c26..8bf0434e 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -294,13 +294,13 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     /* functions for calculating the c.d.f. */
 
     /* i'th term of p_int_r(r') for r' in left domain */
-    Real p_int_r_leftdomain(uint i, Real const& rr, Real const& t, RealVector const& table) const;
+    Real p_int_r_leftdomain(uint i, Real const& rr, Real const& t, RealVector& table) const;
 
     /* i'th term of p_int_r(r') for r' in right domain, left of r0 */
-    Real p_int_r_rightdomainA(uint i, Real const& rr, Real const& t, RealVector const& table) const;
+    Real p_int_r_rightdomainA(uint i, Real const& rr, Real const& t, RealVector& table) const;
 
     /* i'th term of p_int_r(r') for r' in right domain, right of r0 */
-    Real p_int_r_rightdomainB(uint i, Real const& rr, Real const& t, RealVector const& table) const;
+    Real p_int_r_rightdomainB(uint i, Real const& rr, Real const& t, RealVector& table) const;
 
     /* Fills table with r-independent part of p_int_r_i. */
     void create_p_int_r_Table( Real const& t, RealVector& table ) const;
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 110b0093..a9550eed 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -694,8 +694,6 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
     const Real D( getD() );
     const Real k( getk() );
     const Real v( getv() );
-    const Real h(( k + v/2.0)/ D );
-    const Real v2D( v/(2*D) );
 
     /* If not all boundaries are 'visible' to the particle,
        use approximation. */
@@ -769,12 +767,12 @@ Real GreensFunction1DRadAbs::p_int_r_i(uint i,
     const Real expsigma(exp(sigma*v2D));
     const Real zs(r - sigma);
 
-    Real root_n( get_root( n ) );
+    Real root_n( get_root( i ) );
     
     Real term( ( expsigma*costerm - exp(v2D*r)*
                  ( costerm*cos(root_n*zs) - 
                    (root_n+sinterm/root_n)*sin(root_n*zs) )) );
-
+    
     return get_p_int_r_Table_i(i, t, table) * term;
 }
 
@@ -795,7 +793,7 @@ void GreensFunction1DRadAbs::create_p_int_r_Table( Real const& t,
     const Real v2D(v/2.0/D);
     const Real v2Dv2D(v2D*v2D);
 
-    Real S_Cn_root_n;
+    Real term;
     Real root_n2, root_n_r0_s, root_n;
 
     while( n < root_nmbr )
@@ -804,11 +802,11 @@ void GreensFunction1DRadAbs::create_p_int_r_Table( Real const& t,
        	root_n2 = root_n * root_n;
        	root_n_r0_s = root_n * (r0-sigma);
 
-       	S_Cn_root_n =	S * exp(-D*root_n2*t)
-	         * (root_n*cos(root_n_r0_s) + h*sin(root_n_r0_s)) / (L*(root_n2 + h*h) + h)
-	         * root_n / (root_n2 + v2Dv2D);
+       	term = exp(-D*root_n2*t)
+            * (root_n*cos(root_n_r0_s) + h*sin(root_n_r0_s)) / (L*(root_n2 + h*h) + h)
+            * root_n / (root_n2 + v2Dv2D);
 
-        table.push_back( S_Cn_root_n );
+        table.push_back( term );
         n++;
     }
 }
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index edab39ee..11352246 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -299,7 +299,7 @@ class GreensFunction1DRadAbs: public GreensFunction
             create_p_int_r_Table(t, table);
         }
 
-        return table[i]
+        return table[i];
     }
 
     /* Member variables */

From e118131ff9af42806368f0c09720e2248c0e300b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 9 Jan 2012 18:20:11 +0100
Subject: [PATCH 0555/1541] added a missing import of a class

---
 egfrd.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 24c66a24..3eaa0d61 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -35,13 +35,14 @@
 from shellcontainer import ShellContainer
 from shells import (
     testShellError,
+    testPair,
+    testInteractionSingle,
     SphericalSingletestShell,
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
     PlanarSurfacePairtestShell,
     CylindricalSurfaceSingletestShell,
     CylindricalSurfacePairtestShell,
-    testInteractionSingle,
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     MixedPair2D3DtestShell,

From 2f27f5b2ddc63c3ef63a02d76584f7eb9ee58ac8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 9 Jan 2012 18:20:56 +0100
Subject: [PATCH 0556/1541] Changed SAFETY handling to be more specific for the
 domain. Was too general and caused NonInteractionSingles too fail because of
 too small domain.

---
 shells.py | 108 ++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 68 insertions(+), 40 deletions(-)

diff --git a/shells.py b/shells.py
index 2ae7ba02..737a0fe3 100755
--- a/shells.py
+++ b/shells.py
@@ -346,7 +346,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
         # Laurens' algorithm (part1)
         shell_position = shell.shape.position
-        shell_radius = shell.shape.radius
+        shell_radius = shell.shape.radius 
 
         # get the reference point and orientation of the domain to scale
         reference_point = testShell.get_referencepoint()
@@ -444,7 +444,7 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
         ### Get the right values for z and r for the given situation
         if situation == 1:      # the spherical shell hits cylinder on the flat side
-            z1_new = min(z1, (ref_to_shell_z - shell_radius)/SAFETY)
+            z1_new = min(z1, (ref_to_shell_z - shell_radius))
             r_new  = min(r,  r1_function(z1_new))
 
         elif situation == 2:    # shell hits sphere on the edge
@@ -462,15 +462,15 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
             if scale_angle <= Pi/4.0:
                 cos_scale_angle = math.cos(scale_angle)
-                z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist)/SAFETY)
+                z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist))
                 r_new  = min(r, r1_function(z1_new))
             else:
                 sin_scale_angle = math.sin(scale_angle)
-                r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist)/SAFETY)
+                r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist))
                 z1_new = min(z1, z1_function(r_new))
 
         elif situation == 3:    # shell hits cylinder on the round side
-            r_new = min(r, (ref_to_shell_r - shell_radius)/SAFETY)
+            r_new = min(r, (ref_to_shell_r - shell_radius))
             z1_new = min(z1, z1_function(r_new))
         else:
             raise RuntimeError('Bad situation for cylindrical shell making to sphere.')
@@ -500,7 +500,7 @@ def get_radius_to_shell(self, shell, testShell, r):
 
         # Do simple distance calculation to sphere
         scale_point = testShell.center
-        r_new = testShell.world.distance(shell.shape, scale_point)/SAFETY
+        r_new = testShell.world.distance(shell.shape, scale_point)
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
@@ -561,8 +561,8 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
         # Laurens' algorithm (part2)
         shell_position = shell.shape.position
-        shell_radius = shell.shape.radius
-        shell_half_length = shell.shape.half_length
+        shell_radius = shell.shape.radius 
+        shell_half_length = shell.shape.half_length 
 
 
         # get the reference point and orientation of the domain to scale
@@ -618,11 +618,11 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
         if to_edge_angle <= scale_angle:
             # shell hits the scaling cylinder on top
-            z1_new = min(z1, (ref_to_shell_z - shell_half_length)/SAFETY)
+            z1_new = min(z1, (ref_to_shell_z - shell_half_length))
             r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
         else:
             # shell hits the scaling cylinder on the radial side
-            r_new = min(r, (ref_to_shell_r - shell_radius)/SAFETY)
+            r_new = min(r, (ref_to_shell_r - shell_radius))
             z1_new = min(z1, z1_function(r_new))
         z2_new = min(z2, z2_function(r_new))
 
@@ -649,7 +649,7 @@ def get_radius_to_shell(self, shell, testShell, r):
 
         # Do simple distance calculation to cylinder
         scale_point = testShell.center
-        r_new = testShell.world.distance(shell.shape, scale_point)/SAFETY
+        r_new = testShell.world.distance(shell.shape, scale_point)
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
@@ -697,18 +697,19 @@ def determine_possible_shell(self, ignore, ignores):
         # exception if the domain could not be made due to geometrical constraints.
 
         neighbor_domains, neighbor_surfaces = self.get_neighbors (ignore, ignores)
-        min_radius = self.get_min_radius()
+        min_radius = self.apply_safety(self.get_min_radius())
         max_radius = self.get_max_radius()
 
         # initialize the radius to start the scaling of the sphere
-        radius = max_radius
+        radius = self.apply_safety(max_radius)
 
         # first check the maximum radius against the surfaces
         for surface, distance in neighbor_surfaces:
             # FIXME ugly hack to make spherical singles overlap with membranes
             if isinstance(surface, PlanarSurface) and isinstance(self, SphericalSingletestShell):
                 distance += self.pid_particle_pair[1].radius
-            radius = min(radius, distance/SAFETY)
+            distance = self.apply_safety(distance)
+            radius = min(radius, distance)
             if radius < min_radius:
                 raise ShellmakingError('Surface too close to make spherical testshell, '
                                        'surface = %s, distance = %s, testShell = %s' %
@@ -722,12 +723,15 @@ def determine_possible_shell(self, ignore, ignores):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                radius = neighbor.get_radius_to_shell(shell_appearance, self, radius)
+                radius_new = neighbor.get_radius_to_shell(shell_appearance, self, radius)
 
-                if radius < min_radius:
-                    raise ShellmakingError('Domain too close to make spherical testshell, '
-                                           'domain = %s, distance = %s, testShell = %s' %
-                                           (neighbor, radius, self))
+                if radius_new != radius:
+                    # A new (smaller) radius was found
+                    radius = self.apply_safety(radius_new)
+                    if radius < min_radius:
+                        raise ShellmakingError('Domain too close to make spherical testshell, '
+                                               'domain = %s, radius = %s, min_radius = %s, testShell = %s' %
+                                               (neighbor, radius, min_radius, self))
 
         # we calculated a valid radius -> suscess!
         assert radius >= min_radius, 'SphericaltestShell radius smaller than the minimum, radius = %s, min_radius = %s.' % \
@@ -748,8 +752,10 @@ def get_orientation_vector(self):
 
     def get_max_radius(self):
         # The maximum radius of the spherical testShell.
-        return self.get_searchradius()/SAFETY
+        return self.get_searchradius()
 
+    def apply_safety(self, r):
+        return r/SAFETY
 #####
 class SphericalSingletestShell(SphericaltestShell, testNonInteractionSingle):
 
@@ -762,7 +768,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         # Here determine_possible_shell is not called since the NonInteractionSingle should never fail
 
     def get_min_radius(self):
-        return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR / SAFETY    # the minimum radius of a NonInteractionSingle
+        return self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR   # the minimum radius of a NonInteractionSingle
 
 #####
 class SphericalPairtestShell(SphericaltestShell, testSimplePair):
@@ -811,7 +817,8 @@ def determine_possible_shell(self, ignore, ignores):
         max_dr, max_dz_right, max_dz_left = self.get_max_dr_dzright_dzleft()
 
         # initialize the parameters to start the scaling of the cylinder
-        dr, dz_right, dz_left = max_dr, max_dz_right, max_dz_left
+        min_dr, min_dz_right, min_dz_left = self.apply_safety(min_dr, min_dz_right, min_dz_left)
+        dr, dz_right, dz_left             = self.apply_safety(max_dr, max_dz_right, max_dz_left)
 
         # first check the maximum dr, dz_right, dz_left against the surfaces
 #        for surface, distance in neighbor_surfaces:
@@ -829,13 +836,15 @@ def determine_possible_shell(self, ignore, ignores):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                dr, dz_right, dz_left = neighbor.get_dr_dzright_dzleft_to_shell(shell_appearance, self,
-                                                                                dr, dz_right, dz_left)
-
-                if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
-                    raise ShellmakingError('Domain too close to make cylindrical testshell, '
-                                           'domain = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
-                                           (neighbor, dr, dz_right, dz_left, self))
+                dr_new, dz_right_new, dz_left_new = neighbor.get_dr_dzright_dzleft_to_shell(shell_appearance, self,
+                                                                                            dr, dz_right, dz_left)
+                if (dr_new != dr) or (dz_right_new != dz_right) or (dz_left_new != dz_left):
+                    # The dimensions were changed, reapply the safety margin
+                    dr, dz_right, dz_left = self.apply_safety(dr_new, dz_right_new, dz_left_new)
+                    if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
+                        raise ShellmakingError('Domain too close to make cylindrical testshell, '
+                                               'domain = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
+                                               (neighbor, dr, dz_right, dz_left, self))
 
         # we calculated valid dimensions -> success!
         assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
@@ -960,7 +969,7 @@ def get_min_dr_dzright_dzleft(self):
         # we need to make sure that the minimal cylinder for the Single fits inside the putative
         # spherical Multi shell.
         # NOTE the MULTI_SHELL_FACTOR should therefore be at least sqrt(2)!!
-        dr       = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
+        dr       = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
         return dr, dz_right, dz_left
@@ -968,9 +977,12 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dz_right = self.pid_particle_pair[1].radius
         dz_left = dz_right
-        dr = math.sqrt((self.get_searchradius()/SAFETY)**2 - dz_right**2) # stay within the searchradius
+        dr = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
+    def apply_safety(self, r, z_right, z_left):
+        return r/SAFETY, z_right, z_left
+
 #####
 class PlanarSurfacePairtestShell(CylindricaltestShell, testSimplePair):
 
@@ -1017,9 +1029,11 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dz_right = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         dz_left = dz_right
-        dr = math.sqrt((self.get_searchradius()/SAFETY)**2 - dz_right**2) # stay within the searchradius
+        dr = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
+    def apply_safety(self, r, z_right, z_left):
+        return r/SAFETY, z_right, z_left
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
 
@@ -1057,16 +1071,18 @@ def get_min_dr_dzright_dzleft(self):
         # spherical Multi shell.
         # NOTE the MULTI_SHELL_FACTOR should therefore be at least sqrt(2)!!
         dr       = self.pid_particle_pair[1].radius
-        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)/SAFETY
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         dz_left  = dz_right
         return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
         dr = self.pid_particle_pair[1].radius
-        dz_right = math.sqrt((self.get_searchradius()/SAFETY)**2 - dr**2) # stay within the searchradius
+        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         dz_left = dz_right
         return dr, dz_right, dz_left
 
+    def apply_safety(self, r, z_right, z_left):
+        return r, z_right/SAFETY, z_left/SAFETY
 
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, testSimplePair):
@@ -1113,10 +1129,13 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_right = math.sqrt((self.get_searchradius()/SAFETY)**2 - dr**2) # stay within the searchradius
+        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         dz_left = dz_right
         return dr, dz_right, dz_left
 
+    def apply_safety(self, r, z_right, z_left):
+        return r, z_right/SAFETY, z_left/SAFETY
+
 #####
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
@@ -1165,11 +1184,14 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved
-        dr       = (self.get_searchradius()/math.sqrt(2))/SAFETY
+        dr       = (self.get_searchradius()/math.sqrt(2))
         dz_right = dr + self.particle_surface_distance
         dz_left  = self.pid_particle_pair[1].radius
         return dr, dz_right, dz_left
 
+    def apply_safety(self, r, z_right, z_left):
+        return r/SAFETY, z_right/SAFETY, z_left
+
 #####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
@@ -1216,11 +1238,14 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         # TODO clarify
         dz_right = ((-self.particle_surface_distance + \
-                     math.sqrt(2*(self.get_searchradius()**2) - self.particle_surface_distance**2)) / 2.0)/SAFETY
+                     math.sqrt(2*(self.get_searchradius()**2) - self.particle_surface_distance**2)) / 2.0)
         dz_left  = dz_right
-        dr       = (self.particle_surface_distance + dz_right)/SAFETY
+        dr       = (self.particle_surface_distance + dz_right)
         return dr, dz_right, dz_left
 
+    def apply_safety(self, r, z_right, z_left):
+        return r/SAFETY, z_right/SAFETY, z_left/SAFETY
+
 #####
 class MixedPair2D3DtestShell(CylindricaltestShell, testMixedPair2D3D):
 
@@ -1304,9 +1329,9 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved, now the shell same height as diameter
-        dr       = self.get_searchradius()/math.sqrt(2)/SAFETY
+        dr       = self.get_searchradius()/math.sqrt(2)
         dz_left  = self.pid_particle_pair1[1].radius
-        dz_right = (dr * 2 - dz_left)/SAFETY
+        dz_right = (dr * 2 - dz_left)
 
         return dr, dz_right, dz_left
 
@@ -1345,5 +1370,8 @@ def r_right(self, z_right):
 
         return a_R + iv_max
 
+    def apply_safety(self, r, z_right, z_left):
+        return r/SAFETY, z_right/SAFETY, z_left
+
 #####
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From 2e3c677154bfe4b04456a2799643a1a867441d24 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 9 Jan 2012 18:22:15 +0100
Subject: [PATCH 0557/1541] Use minimum defined in testShell. This can be done
 because of new SAFETY handling

---
 single.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/single.py b/single.py
index d643be98..494ac580 100644
--- a/single.py
+++ b/single.py
@@ -270,8 +270,8 @@ def greens_function(self):
     # these return potentially corrected dimensions
     # For explanation see NonInteractionSingles and Others in shells.py
     def shell_list_for_single(self):
-        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-#        min_radius = self.testShell.get_min_radius()
+#        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+        min_radius = self.testShell.get_min_radius()
         if  self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
@@ -331,8 +331,8 @@ def greens_function(self):
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
-        min_radius = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
-#        min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
+#        min_radius = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             half_length = self.shell.shape.half_length
@@ -406,8 +406,8 @@ def greens_function(self):
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
-        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
-#        _, min_half_length, _ = self.testShell.get_min_dr_dzright_dzleft()
+#        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        _, min_half_length, _ = self.testShell.get_min_dr_dzright_dzleft()
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
             radius = self.shell.shape.radius

From 9a87f16012ccd1c5df4445ec2e7287d21e930b84 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 11 Jan 2012 17:53:18 +0100
Subject: [PATCH 0558/1541] Particle with D=0 should also search to make a
 Multi, not just make zero shell

---
 egfrd.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3eaa0d61..a1c6c6b2 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1130,11 +1130,11 @@ def make_new_domain(self, single):
         # Special case: When D=0, nothing needs to change and only new event
         # time is drawn
         # TODO find nicer construction than just this if statement
-        if single.getD() == 0:
-            single.dt, single.event_type = single.determine_next_event() 
-            single.last_time = self.t
-            self.add_domain_event(single)
-            return single
+#        if single.getD() == 0:
+#            single.dt, single.event_type = single.determine_next_event() 
+#            single.last_time = self.t
+#            self.add_domain_event(single)
+#            return single
 
 
         # 0. Get generic info

From 01642a9a0e010db7ba458ab1e01f9ba3a4840ffd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 11 Jan 2012 18:34:48 +0100
Subject: [PATCH 0559/1541] Added CylindricalSink domain. Copied from code from
 Joris Paijmans

---
 single.py | 91 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)

diff --git a/single.py b/single.py
index 494ac580..9a591e88 100644
--- a/single.py
+++ b/single.py
@@ -742,6 +742,97 @@ def __str__(self):
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))
 
+
+class CylindricalSurfaceSink(InteractionSingle):
+    """1 Particle inside a (Cylindrical) shell on a CylindricalSurface.
+        Inside the domain is a sink.
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+        * Selected randomly when drawing displacement vector: none.
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        assert isinstance(testShell, CylindricalSurfaceSinktestShell)
+        InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+
+        # zsink is the position of the sink relative to the center of the shell.
+        # Note that we assume that the particle is at the center of the shell, and the unit_z of the shell
+        # points from the sink to the particle.
+        self.zsink = -self.testShell.particle_surface_distance
+
+    def get_inner_a(self):
+        # This is the distance that the particle can travel from the center to one of the sides.
+        # NOTE: it is implied that the particle starts in the center of the shell.
+        # NOTE: although abstractly defined in InteractionSingle inner_dz_right/left are not
+        #       specified here.
+        return self.shell.shape.half_length - self.pid_particle_pair[1].radius
+
+    def determine_next_event(self):
+        """Return an (event_time, event_type)-tuple.
+
+        """
+        return min(self.draw_reaction_time_tuple(),
+                   self.draw_iv_event_time_tuple())
+
+    def iv_greens_function(self):
+        # The Green's function used for both ESCAPE and IV (sink) events.
+        # Particle allways starts in the middle for now.
+        inner_half_length = self.get_inner_a()
+
+        return GreensFunction1DAbsSinkAbs(self.D, self.interaction_ktot, 0.0, self.zsink,
+                                          -inner_half_length, inner_half_length)
+
+    def draw_new_position(self, dt, event_type):
+        oldpos = self.pid_particle_pair[1].position
+
+        if self.D == 0 or \
+                (event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0):
+            newpos = oldpos
+        else:
+            gf = self.iv_greens_function()
+
+            # If an IV event took place, and the event was not yet fully specified
+            if event_type == EventType.IV_EVENT:
+                self.event_type = self.draw_iv_event_type()
+                event_type = self.event_type
+
+            if event_type == EventType.IV_ESCAPE:
+                # The particle left the domain through either boundary
+
+                # Determine whether the particle escaped through the left (at s) or right (at a) boundary.
+                flux_a = abs( gf.flux_leavea( dt ) )
+                flux_s = abs( gf.flux_leaves( dt ) )
+                rnd = myrandom.uniform() * ( flux_a + flux_s )
+
+                inner_half_length = self.get_inner_a()
+
+                if( rnd < flux_a ):
+                    # The 'right' boundary (boundary to which the shell.shape.unit_z point)
+                    z = inner_half_length
+                else:
+                    # The 'left' boundary
+                    z = -inner_half_length
+
+            elif event_type == EventType.IV_INTERACTION:
+                # The particle left the domain through the sink
+                z = self.zsink
+            else:
+                # Some other event took place and the particle didn't escape
+                z = draw_r_wrapper(gf, dt, self.get_inner_a(), -self.get_inner_a())
+
+        # Add displacement to shell.shape.position, not to particle.position.
+        # The direction of the shell is leading (not direction of the structure)
+        z_vector = self.shell.shape.unit_z * z
+        newpos = self.shell.shape.position + z_vector
+
+        return newpos
+
+    def __str__(self):
+        return 'CylindricalSurfaceSink ' + Single.__str__(self)
+
+
 class DummySingle(object):
     def __init__(self):
         self.multiplicity = 1

From 7be61318f78acee76320bb018ebdb70073be6900 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 12 Jan 2012 14:01:29 +0100
Subject: [PATCH 0560/1541] added testShell for CylindricalSurfaceSink
 interaction domain

---
 shells.py | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 single.py |  1 +
 2 files changed, 61 insertions(+)

diff --git a/shells.py b/shells.py
index 737a0fe3..e87fa6be 100755
--- a/shells.py
+++ b/shells.py
@@ -34,6 +34,7 @@
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
+    'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
     ]
 
@@ -1246,6 +1247,65 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right/SAFETY, z_left/SAFETY
 
+class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
+
+    def __init__(self, single, surface, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testInteractionSingle.__init__(self, single, single.structure, surface)
+
+        # initialize scaling parameters
+        self.dzdr_right = numpy.inf
+        self.drdz_right = 0.0
+        self.r0_right   = self.pid_particle_pair[1].radius
+        self.z0_right   = 0.0
+        self.dzdr_left  = self.dzdr_right
+        self.drdz_left  = self.drdz_right
+        self.r0_left    = self.r0_right
+        self.z0_left    = self.z0_right
+
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
+        except ShellmakingError as e:
+            raise testShellError('(CylindricalSurfaceSink). %s' %
+                                 (str(e)))
+
+        # make sure the domain is symmetric around the particle
+        self.dz_right = min(self.dz_right, self.dz_left)
+        self.dz_left  = self.dz_right
+        # check if the domain is still large enough for the interaction
+        _, _, min_dz_left = self.get_min_dr_dzright_dzleft()
+        if self.dz_left < min_dz_left:
+            raise testShellError('(CylindricalSurfaceSink). Domain too small after symmetricalizing.')
+
+
+    def get_orientation_vector(self):
+        return self.reference_vector      # calculated in the __init__ of testInteractionSingle
+
+    def get_searchpoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_referencepoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_min_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = self.particle_surface_distance + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        dz_right = dz_left              # we make the domain to be symmetrical around the particle
+        return dr, dz_right, dz_left
+        
+    def get_max_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+        dz_right = dz_left
+        return dr, dz_right, dz_left
+
+    def apply_safety(self, r, z_right, z_left):
+        return r, z_right/SAFETY, z_left/SAFETY
+
 #####
 class MixedPair2D3DtestShell(CylindricaltestShell, testMixedPair2D3D):
 
diff --git a/single.py b/single.py
index 9a591e88..ffc63d0f 100644
--- a/single.py
+++ b/single.py
@@ -26,6 +26,7 @@
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'PlanarSurfaceInteraction',
+    'CylindricalSurfaceSink',
     ]
 
 

From 55640f89ee4f7b1170ea27d7adfeac5707bd787b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Thu, 12 Jan 2012 15:23:56 +0100
Subject: [PATCH 0561/1541] Changed convergence checker in funcSum, might show
 to be disaterious.

---
 funcSum.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/funcSum.cpp b/funcSum.cpp
index f39595cc..4aad19da 100644
--- a/funcSum.cpp
+++ b/funcSum.cpp
@@ -140,13 +140,12 @@ funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
         {
             ++convergenceCounter;          
         }
-        /*
         // this screws it up; why?
         else
         {
             convergenceCounter = 0;
         }
-        */
+
 
         if (convergenceCounter >= CONVERGENCE_CHECK)
         {

From 7b2ecb47adf5fb4bbb402c7537b448dc07501701 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 12 Jan 2012 15:48:43 +0100
Subject: [PATCH 0562/1541] Added new CylindricalSurfaceSink testShell and
 Domain to egfrd algorithm

---
 egfrd.py | 35 ++++++++++++++++++++++++++---------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a1c6c6b2..89672661 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -45,6 +45,7 @@
     CylindricalSurfacePairtestShell,
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
+    CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
     )
 
@@ -70,18 +71,30 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
 
 ### Interactions
 def try_default_testinteraction(single, surface, geometrycontainer, domains):
-    if isinstance(surface, PlanarSurface):
-        return PlanarSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
-    elif isinstance(surface, CylindricalSurface):
-        return CylindricalSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+    if isinstance(single.structure, CuboidalRegion):
+        if isinstance(surface, PlanarSurface):
+            return PlanarSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+        elif isinstance(surface, CylindricalSurface):
+            return CylindricalSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+        else:
+            raise testShellError('(Interaction). Combination of (3D particle, surface) is not supported')
+    elif isinstance(single.structure, PlanarSurface):
+        raise testShellError('(Interaction). Combination of (2D particle, surface) is not supported')
+    elif isinstance(single.structure, CylindricalSurface):
+        if isinstance(surface, CylindricalSurface):     # TODO differentiate between a sink and a cap
+            return CylindricalSurfaceSinktestShell (single, surface, geometrycontainer, domains)
+        else:
+            raise testShellError('(Interaction). Combination of (1D particle, surface) is not supported')
     else:
-        raise testShellError('(Interaction). surface is not supported')
+        raise testShellError('(Interaction). structure of particle was of invalid type')
 
 def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, interaction_rules):
     if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
         return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfaceSinktestShell):
+        return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
@@ -455,8 +468,8 @@ def create_interaction(self, testShell):
         species_id = testShell.pid_particle_pair[1].sid
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
         # get reaction rules for interaction
-        surface_id = testShell.surface.sid
-        interaction_rules = self.network_rules.query_reaction_rule(species_id, surface_id)
+        surfacetype_id = testShell.surface.sid
+        interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
 
 
         # 2. Create and register the interaction domain.
@@ -956,6 +969,7 @@ def fire_interaction(self, single, reactant_pos):
         # It performs the reactions:
         # A(3D) + surface -> 0
         # A(3D) + surface -> B(surface)
+        assert isinstance(single, InteractionSingle)
 
         # 0. get reactant info
         reactant        = single.pid_particle_pair
@@ -983,6 +997,9 @@ def fire_interaction(self, single, reactant_pos):
             product_species = self.world.get_species(rr.products[0])
             product_radius  = product_species.radius
             product_surface = single.surface
+            # make sure that the product species lives on the interaction surface
+            assert (single.surface == self.world.get_structure(product_species.structure_id)), \
+                   'Product particle should live on the surface of interaction after the reaction.'
 
             # 1.5 get new position of particle
             transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
@@ -1145,8 +1162,8 @@ def make_new_domain(self, single):
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
         surface_distances = []
-        if isinstance(single, SphericalSingle):
-            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, ignores=[single.structure.id])
+#        if isinstance(single, SphericalSingle):
+        surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, ignores=[single.structure.id])
 
 
         # Check if there are shells with the burst radius (reaction_threshold)

From a45aa459327086920329f28473e97cd51a774304 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 12 Jan 2012 15:49:18 +0100
Subject: [PATCH 0563/1541] small fixes

---
 single.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/single.py b/single.py
index ffc63d0f..526c3ccd 100644
--- a/single.py
+++ b/single.py
@@ -25,8 +25,8 @@
     'NonInteractionSingle',
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
-    'PlanarSurfaceInteraction',
     'CylindricalSurfaceSink',
+    'PlanarSurfaceInteraction',
     ]
 
 
@@ -442,7 +442,7 @@ def create_updated_shell(self, position):
             raise Exception('CylindricalSurfaceSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, z):
-        if utils.feq(z, self.get_inner_a()):
+        if feq(z, self.get_inner_a()):
             # Escape, can be either to the left or to the right.
             # The side of escape should be decided on by the flux through
             # both boundaries at the escape time

From d5f1ffbd38a88524fa8369e547637b4ff9409e9b Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Thu, 12 Jan 2012 15:55:04 +0100
Subject: [PATCH 0564/1541] Included changes in 1DPropegator for
 update_particle -> create_particle

---
 newBDPropagator.hpp | 48 ++++++++++-----------------------------------
 1 file changed, 10 insertions(+), 38 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b64e0ee5..c4d31303 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -276,27 +276,7 @@ class newBDPropagator
             
             j++;
         }
-        
-        
-        /*Debug overlap failed error.
-        std::cerr << " &&&& : " << pp.first << std::endl;
-        
-        j = 0;
-        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_last( 
-                    tx_.check_overlap( particle_shape_type( new_pos, 10*r0 ), 
-                            pp.first) );
-                            
-        particles_in_overlap = overlapped_last ? overlapped_last->size(): 0;
-        while(j < particles_in_overlap)
-        {
-            particle_id_pair_and_distance const& closest( overlapped_last->at(j++) );
-            const Real dist( tx_.distance( closest.first.second.position(), pp.second.position() ) );
-            std::cerr << "### pp id: " << pp.first << " ppi id: " << closest.first.first << " ipv length @ old_pos = " << dist << 
-                " dist till shell @ new_pos: " << closest.second << std::endl;
-            std::cerr << "Bounced? " << bounced << ", d (after move) = " << tx_.distance( new_pos, closest.first.second.position() ) << std::endl;
-        }
-        */
-                       
+                               
         /* If the particle did neither react, interact or bounce, update it to it's new position. */
         if(!bounced)
         {   
@@ -371,13 +351,9 @@ class newBDPropagator
                             new_pos = make_move(s0, new_pos, pp.first);
                         }
                       
-                        const particle_id_pair new_p(
-                            pp.first, particle_type(products[0],
-                                particle_shape_type(new_pos,
-                                                    s0.radius()),
-                                                    s0.D()));
+                        const particle_shape_type new_shape(new_pos, s0.radius());
                                                     
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_p.second.shape(), new_p.first));
+                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_shape, pp.first));
                         if (overlapped && overlapped->size() > 0)
                         {
                             throw propagation_error("no space due to other particle");
@@ -385,7 +361,7 @@ class newBDPropagator
 
                         if (vc_)
                         {
-                            if (!(*vc_)(new_p.second.shape(), pp.first))
+                            if (!(*vc_)(new_shape, pp.first))
                             {
                                 throw propagation_error("no space due to other particle (vc)");
                             }
@@ -403,13 +379,14 @@ class newBDPropagator
                                 throw propagation_error("no space due to near surface");
                         }
 
-                        tx_.update_particle(new_p);
+                        tx_.remove_particle(pp.first);
+                        const particle_id_pair product( tx_.new_particle(s0.id(), new_pos) );
 
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(new_p.first), pp.first));
+                                    r.id(), array_gen(product.first), pp.first));
                         }
                     }
                     break;
@@ -703,18 +680,13 @@ class newBDPropagator
                             }
                         }
 
-			            const particle_id_pair new_p(
-			              pp.first, particle_type(sp.id(),
-				            particle_shape_type(new_pos,
-					          sp.radius()),
-					            sp.D()));
-
-                        tx_.update_particle(new_p);
+                        remove_particle(pp.first);
+                        const particle_id_pair product_particle( tx_.new_particle(sp.id(), new_pos) );
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(new_p.first), pp.first));
+                                    r.id(), array_gen(product_particle.first), pp.first));
                         }
                         break;
                     }

From c00356144510f32133045d69b7821ff5f2866660 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Fri, 13 Jan 2012 10:04:43 +0100
Subject: [PATCH 0565/1541] Removed Olddefs from 1D functions.

---
 GreensFunction1DAbsAbs.cpp | 1 -
 GreensFunction1DAbsAbs.hpp | 1 -
 GreensFunction1DRadAbs.cpp | 2 +-
 GreensFunction1DRadAbs.hpp | 1 -
 greens_function_wrapper.py | 2 +-
 5 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index def35c7e..7d955c46 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -19,7 +19,6 @@
 
 #include "findRoot.hpp"
 #include "GreensFunction1DAbsAbs.hpp"
-#include "Defs.hpp"
 
 
 /* returns a guess for the number of terms needed for 
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 4134336d..602d7a4a 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -20,7 +20,6 @@
 
 #include "findRoot.hpp"
 #include "Defs.hpp"
-#include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "funcSum.hpp"
 #include "freeFunctions.hpp"
 #include "Logger.hpp"
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index a9550eed..30ef2cd2 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -196,7 +196,7 @@ const
 {
     const Real D(this->getD());
 
-    return std::exp(-D*root_n*root_n*t);
+    return exp(-D*root_n*root_n*t);
 }
 
 
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 11352246..9a4d294d 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -22,7 +22,6 @@
 #include "funcSum.hpp" 
 #include "freeFunctions.hpp"
 #include "Defs.hpp"
-#include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "GreensFunction.hpp"
 #include "Logger.hpp"
 
diff --git a/greens_function_wrapper.py b/greens_function_wrapper.py
index 1ddb7709..f892dc71 100644
--- a/greens_function_wrapper.py
+++ b/greens_function_wrapper.py
@@ -66,7 +66,7 @@ def draw_theta_wrapper(gf, r, dt):
     except Exception, e:
         print 'gf.drawTheta() failed, %s, rnd = %g, r = %g, dt = %g; %s' %(str(e), rnd, r, dt, gf.dump())
         #ugly hack: When drawTheta fails, return uniformly distributed theta.
-        theta = rnd * numpy.py
+        theta = rnd * numpy.pi
 
     # Heads up. For cylinders theta should be between [-pi, pi]. For 
     # spheres it doesn't matter.

From 0ed0f481181fb7e07912a9385e182012981b1f41 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Fri, 13 Jan 2012 10:06:30 +0100
Subject: [PATCH 0566/1541] Muther!

---
 GreensFunction1DAbsSinkAbs.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 8bf0434e..3182e5da 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -20,7 +20,6 @@
 
 #include "findRoot.hpp"
 #include "Defs.hpp"
-#include "OldDefs.hpp"			// TODO: this must be removed at some point!
 #include "GreensFunction.hpp"
 #include "funcSum.hpp"
 #include "freeFunctions.hpp"

From bb1b04f2a90113a1dc5e6b83b30bc3d6929f3191 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Fri, 13 Jan 2012 10:08:51 +0100
Subject: [PATCH 0567/1541] Removed OldDefs.hpp

---
 OldDefs.hpp | 50 --------------------------------------------------
 1 file changed, 50 deletions(-)
 delete mode 100644 OldDefs.hpp

diff --git a/OldDefs.hpp b/OldDefs.hpp
deleted file mode 100644
index fb182fb0..00000000
--- a/OldDefs.hpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#if !defined( __OLDDEFS_HPP )
-#define __OLDDEFS_HPP
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif /* HAVE_CONFIG_H */
-
-#include <vector>
-#include <boost/multi_array.hpp>
-#include <cmath>
-
-#include "Defs.hpp"
-
-// This file is needed temporarily by   GreensFunction1DAbsAbs.cpp
-// and                                  GreensFunction1DRadAbs.cpp
-//
-// At some point it should be taken out of the new code version.
-// This requires some major refurbishment of the above functions, so postponed for later.
-//
-// All passages conflicting with analogous definitions in the new Defs.hpp are taken out.
-//
-
-
-
-
-typedef std::vector< Real > RealVector;
-typedef boost::multi_array<Real, 2>
-Real2DArray;
-typedef boost::multi_array<Real, 3>
-Real3DArray;
-typedef boost::multi_array<Real, 4>
-Real4DArray;
-
-
-// stringifiers.  see preprocessor manual
-#define XSTR( S ) STR( S )
-#define STR( S ) #S
-
-#define THROW_UNLESS( CLASS, EXPRESSION )       \
-    if( ! ( EXPRESSION ) )\
-    {\
-        throw CLASS( "Check [" + std::string( STR( EXPRESSION ) ) +\
-                     "] failed." );\
-    }\
-
-
-#define IGNORE_RETURN (void)
-
-
-#endif // __OLDDEFS_HPP

From f1d5440e1271d4042b6432a7ef17b4dc6ecafb29 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Fri, 13 Jan 2012 10:32:02 +0100
Subject: [PATCH 0568/1541] Revert "Merge branch 'TheSink' of
 git@github.com:TheJoris/egfrd into 1DCleanup"

This reverts commit 570f1f0ad641f127d549b32b86dc29e699457b63, reversing
changes made to d5f1ffbd38a88524fa8369e547637b4ff9409e9b.

Conflicts:

	greens_function_wrapper.py
---
 GreensFunction1DAbsSinkAbs.cpp |   5 +-
 egfrd.py                       | 140 ++++++---------------------------
 pair.py                        |   2 +-
 shellcontainer.py              |  11 +--
 single.py                      | 106 ++-----------------------
 5 files changed, 38 insertions(+), 226 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index a04341fa..b6fda348 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -172,9 +172,12 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     if( f_upper * parity_op < 0)
     {
         int cntr = 0;
-        Real delta( .1 * safety * right_offset ); //std::min(left_offset, right_offset);
+
+        Real delta( .1 * safety * right_offset );
         const Real save_upper( upper );
         
+        cntr = 0;
+
         /* Assuming the upper point has overshoot the straddle region,
            subtract from the upper limit, until endpoits do straddle.
          */
diff --git a/egfrd.py b/egfrd.py
index dd3276d8..33ca28a6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -146,25 +146,6 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         self.reset()                            # The Simulator is only initialized at the first step, allowing
                                                 # modifications to the world to be made before simulation starts
-                                                
-        self.sinklist = []                      # Hack to keep track of sinks in the system. Contains structure_id's of the sinks
-
-    def add_to_sinklist(self, sink_id):
-        self.sinklist.append(sink_id)
-        
-    def get_neighbor_sinks(self, position, species_id):
-        sink_distance_list = []
-        sinklist = self.sinklist
-        
-        for i in range( len( sinklist ) ):
-            sink_i = self.world.get_structure( sinklist[i] )
-            interaction_rules = self.network_rules.query_reaction_rule(species_id, sink_i.sid)
-            for ir in interaction_rules:
-                if ir.k != 0:
-                    sink_distance_list.append((sink_i, self.world.distance( position, sink_i.shape.position )))
-                    break
-                    
-        return sink_distance_list
 
     def get_next_time(self):
         """ 
@@ -371,9 +352,10 @@ def step(self):
                 self.zero_steps += 1
                 # TODO Changed from 10 to 10000, because only a problem 
                 # when reaching certain magnitude.
-                # Ugly hack: changed exception -> print, so that is doesn't stop the simulation
                 if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
-                    print 'too many dt=zero steps. Simulator halted? dt= %.10g-%.10g' %(self.scheduler.top[1].time, self.t)
+                    raise RuntimeError('too many dt=zero steps. '
+                                       'Simulator halted?'
+                                    'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
             else:
                 self.zero_steps = 0
 
@@ -435,33 +417,19 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
 
 
         particle_pos = pid_particle_pair[1].position
-        if isinstance(surface, CylindricalSurface) and isinstance(structure, CylindricalSurface):
-            particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)     
-            zsink = numpy.dot( surface.shape.position - particle_pos, surface.shape.unit_z )
-
-            interaction = CylindricalSurfaceSink(domain_id, pid_particle_pair,
-                                                 reaction_rules, structure,
-                                                 shell_id, shell_center, shell_half_length, 
-                                                 zsink, interaction_rules, surface)
-                                                 
-        elif isinstance(surface, CylindricalSurface):
+
+        if isinstance(surface, CylindricalSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, surface.shape.position)
             projected_point, r0 = surface.projected_point(particle_pos)
             shell_unit_r = normalize(particle_pos - projected_point)
 
-            projected_point = self.world.cyclic_transpose(projected_point, shell_center)
-
-            z0 = numpy.dot (shell_unit_z, projected_point - shell_center)
-
-            #Very ugly hack to make the function converge for drawTime.
-            shell_radius = min( shell_radius, 10*pid_particle_pair[1].radius )
+            z0 = numpy.dot (shell_unit_z, (projected_point - shell_center))
 
             interaction = CylindricalSurfaceInteraction(domain_id, pid_particle_pair,
                                                         reaction_rules, structure,
                                                         shell_id, shell_center, shell_radius,
                                                         shell_half_length, shell_unit_z, z0,
                                                         shell_unit_r, r0, interaction_rules, surface)
-                                                        
         elif isinstance(surface, PlanarSurface):
             particle_pos = self.world.cyclic_transpose(particle_pos, shell_center)
             z0 = numpy.dot (shell_unit_z, (particle_pos - shell_center))
@@ -472,6 +440,7 @@ def create_interaction(self, pid_particle_pair, surface, shell_center,
                                                    shell_half_length, shell_unit_z,
                                                    z0, interaction_rules, surface)
 
+
         assert isinstance(interaction, InteractionSingle)
         interaction.initialize(self.t)
         self.domains[domain_id] = interaction
@@ -788,7 +757,7 @@ def fire_single_reaction(self, single, reactant_pos):
                     # exit the loop, we have found a new position
                     break
 
-                else:
+            else:
                     # 4. Process (the lack of) change
                     moved_reactant = self.move_particle(reactant, reactant_pos)
                     products = [moved_reactant]     # no change
@@ -1155,11 +1124,11 @@ def make_new_domain(self, single):
         # Special case: When D=0, nothing needs to change and only new event
         # time is drawn
         # TODO find nicer construction than just this if statement
-        #if single.getD() == 0:
-        #    single.dt, single.event_type = single.determine_next_event() 
-        #    single.last_time = self.t
-        #    self.add_domain_event(single)
-        #    return single
+        if single.getD() == 0:
+            single.dt, single.event_type = single.determine_next_event() 
+            single.last_time = self.t
+            self.add_domain_event(single)
+            return single
 
 
         # 0. Get generic info
@@ -1169,14 +1138,10 @@ def make_new_domain(self, single):
         # 1.0 Get neighboring domains and surfaces
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
-        # Here ignore the sink surfaces. Should be moved into get_neighbor_surfaces.
         surface_distances = []
         if isinstance(single, SphericalSingle):
-            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, self.sinklist )
-            
-        # For a particle on a rod (1D) only consider sinks. - one rod, with one sink for now.
-        if isinstance(single, CylindricalSurfaceSingle):
-            surface_distances = self.get_neighbor_sinks( single_pos, single.pid_particle_pair[1].sid )
+            surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, ignores=[single.structure.id])
+
 
         # Check if there are shells with the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
@@ -1224,7 +1189,7 @@ def make_new_domain(self, single):
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
-        log.debug('pair_interaction_partners: %s' %str(pair_interaction_partners))
+        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners))
 
         # For each particles/particle or particle/surface pair, check if a pair or interaction can be
         # made. Note that we check the closest one first and only check if the object are within the horizon
@@ -1235,12 +1200,8 @@ def make_new_domain(self, single):
                 # there are no more potential partners (everything is out of range)
                 # or a domain was formed successfully previously
                 break
-                            
-            if isinstance(obj, CylindricalSurface) and isinstance(single, CylindricalSurfaceSingle):
-                # try making a Interaction with a sink. (Not in try_interaction because to different/ to much hacking)
-                domain = self.try_interaction_sink(single, obj)
 
-            elif isinstance(obj, NonInteractionSingle):
+            if isinstance(obj, NonInteractionSingle):
                 # try making a Pair (can be Mixed Pair or Normal Pair)
                 domain = self.try_pair (single, obj)
 
@@ -1423,7 +1384,7 @@ def update_single(self, single):
         assert isinstance(single, NonInteractionSingle) # This only works for 'simple' Singles
 
         min_shell_size = single.get_min_shell_size()
-        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, ignores=[])
+        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains)
 
         # Make sure that the new shell size is not too small or big
         new_shell_size = max(max_shell_size, min_shell_size)
@@ -1444,6 +1405,8 @@ def process_single_event(self, single):
             log.info('FIRE SINGLE: %s' % single.event_type)
             log.info('single = %s' % single)
 
+
+
         if single.is_reset():
         ### If no event event really happened and just need to make new domain
             domains = [self.make_new_domain(single)]
@@ -1886,7 +1849,7 @@ def try_interaction(self, single, surface):
         interaction.dt, interaction.event_type, = \
             interaction.determine_next_event()
         assert interaction.dt >= 0
-        
+
         self.last_time = self.t
 
         self.remove_domain(single)
@@ -1897,64 +1860,13 @@ def try_interaction(self, single, surface):
 
         if __debug__:
             log.debug('        *create_interaction\n'
-                      '            dr = %s. dz_left = %s. dz_right = %s. dt = %s\n' %
+                      '            dr = %s. dz_left = %s. dz_right = %s.\n' %
                       (FORMAT_DOUBLE % dr, FORMAT_DOUBLE % dz_left,
-                       FORMAT_DOUBLE % dz_right, FORMAT_DOUBLE % interaction.dt))
+                       FORMAT_DOUBLE % dz_right))
 
         return interaction
 
-    def try_interaction_sink(self, single, sink):
-        # Try to form an interaction between the 'single' particle and a sink (Cyl-surface).
-
-        pid_particle_pair = single.pid_particle_pair
-        particle = pid_particle_pair[1]
-        structure = single.structure
-        
-        if __debug__:
-            log.debug('trying to form Interaction with sink(%s, %s)' % (particle, sink))
-
-
-        ### 1. See if there is enough space for the shell
-        # Uses the same methods as Update_single for finding optimal domain size.
-        min_shell_size = single.get_min_shell_size()
-        max_shell_size = single.get_max_shell_size(self.geometrycontainer, self.domains, ignores=[sink.id,])
-
-        # Make sure that the new shell size is not too small or big
-        new_shell_size = max(max_shell_size, min_shell_size)
-        
-        # Check if c.o.m. of particle can reach the sink, so that it is not blocked by
-        # it's radius hitting the boundary.
-        dist_to_sink = self.world.distance( sink.shape.position, particle.position )
-        if( new_shell_size - particle.radius - dist_to_sink < 0.0 ):
-            return None
-       
-       
-        ### 2. The shell can be made. Now do what's necessary to make it
-        # Compute origin, radius and half_length of cylinder.
-        orientation_vector = structure.shape.unit_z
-        radius = particle.radius
-        origin = particle.position
-        half_length = new_shell_size
-        
-        interaction = self.create_interaction(pid_particle_pair, sink,
-                                              origin, radius, half_length,
-                                              orientation_vector)
-
-        interaction.dt, interaction.event_type, = \
-            interaction.determine_next_event()
-        assert interaction.dt >= 0
-
-        self.last_time = self.t
-
-        self.remove_domain(single)
-        # the event associated with the single will be removed by the scheduler.
-
-        assert self.check_domain(interaction)
-        self.add_domain_event(interaction)
 
-        return interaction
-        
-        
     def calculate_max_cylinder(self, single, surface, projected_point, 
                                    particle_distance, orientation_vector,
                                    dr, dz_left, dz_right):
@@ -2444,7 +2356,6 @@ def check_domain(self, domain):
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair):
             # Ignore surface of the particle and interaction surface
             ignores = [domain.structure.id, domain.surface.id]
-            ignores.extend( self.sinklist )
         else:
             ignores = [domain.structure.id]
 
@@ -2467,14 +2378,13 @@ def check_domain(self, domain):
             # TODO maybe don't check all the shells, this takes a lot of time
 
             # testing overlap criteria
-            '''
             for neighbor, _ in neighbors:
                 for _, neighbor_shell in neighbor.shell_list:
                     overlap = self.check_shell_overlap(shell, neighbor_shell)
-                    assert overlap >= 0.0 - 1e-15, \
+                    assert overlap >= 0.0, \
                         '%s (%s) overlaps with %s (%s) by %s.' % \
                         (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
-            '''
+
 
             # checking wether the shell don't exceed the maximum size
             if (type(shell.shape) is Cylinder):
diff --git a/pair.py b/pair.py
index b81d8b39..18b2dde7 100644
--- a/pair.py
+++ b/pair.py
@@ -251,7 +251,7 @@ def get_max_shell_size(cls, shell_center, single1, single2, geometrycontainer, d
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(shell_center, domains, ignore=[single1.domain_id, 
                                                                   single2.domain_id])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, single1.structure.id, ignores=[])
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(shell_center, ignores=[single1.structure.id])
         neighbors = neighbor_domains + neighbor_surfaces
 
 
diff --git a/shellcontainer.py b/shellcontainer.py
index 1b97cc75..f583bf37 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -170,18 +170,11 @@ def filter_partners(self, neighbor_domains):
     def sort_domain_distance(self, neighbor_domains):
         return sorted(neighbor_domains, key=lambda domain_dist: domain_dist[1])
 
-    def get_neighbor_surfaces(self, position, base_structure_id, ignores=[]):
+    def get_neighbor_surfaces(self, position, ignores=[]):
         # analogous to get_neighbor domains, this returns a list of (surface, distance) tuples
-        # The base_structure_id argument is the id of the structure on which the particle lives
-        # calling this function. In the future, this function will only return surfaces a particle
-        # living on the base_structure can have interactions with.
-        
-        # We assume a particle can't have an interaction with the same surface on/in which it lives.
-        base_ignores =  [base_structure_id, ]
-        base_ignores.extend( ignores )
 
         # TODO return a list of neighboring surfaces
-        surface, distance = get_closest_surface(self.world, position, base_ignores)
+        surface, distance = get_closest_surface(self.world, position, ignores)
         if surface:
             return [(surface, distance), ]
         else:
diff --git a/single.py b/single.py
index e1315cfa..bdf4b538 100644
--- a/single.py
+++ b/single.py
@@ -17,7 +17,6 @@
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'PlanarSurfaceInteraction',
-    'CylindricalSurfaceSink',
     ]
 
 
@@ -249,7 +248,7 @@ def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycon
     def get_min_shell_size(self):
         return self.pid_particle_pair[1].radius
 
-    def get_max_shell_size(self, geometrycontainer, domains, ignores=[]):
+    def get_max_shell_size(self, geometrycontainer, domains):
         # This calculates the maximum shell size that the single can have in the current
         # situation.
         # TODO This is now general for all NonInteractionSingles and should be different
@@ -260,16 +259,13 @@ def get_max_shell_size(self, geometrycontainer, domains, ignores=[]):
         # TODO We now just check in a sphere around the particle and size accordingly. For
         # NonInteractionSingles on the dna and membrane this is quite inefficient-> want to
         # size in the appropriate coordinate (r or z).
-        if self.getD() == 0.0:
-            return self.get_min_shell_size()
-        
         singlepos = self.pid_particle_pair[1].position
 #        closest, distance_to_shell = \
 #            geometrycontainer.get_closest_obj(singlepos, domains, ignore=[self.domain_id],
 #                                              ignores=[self.structure.id])
 
         neighbor_domains = geometrycontainer.get_neighbor_domains(singlepos, domains, ignore=[self.domain_id, ])
-        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, self.structure.id, ignores)
+        neighbor_surfaces = geometrycontainer.get_neighbor_surfaces(singlepos, ignores=[self.structure.id])
         neighbors = neighbor_domains + neighbor_surfaces
 
         # 2. Calculate the maximum allowed radius of the spherical domain
@@ -289,7 +285,7 @@ def get_max_shell_size(self, geometrycontainer, domains, ignores=[]):
             distance_domain_closest = min(distance_domain_closest, distance_domain)
 
         distance_to_shell, closest = distance_domain_closest
-        
+
         # 3. Apply still other rules if the nearest is another NonInteractionSingle (optimization)
         # TODO shell size has no real meaning for cylinderical domains
         if isinstance(closest, NonInteractionSingle):
@@ -298,9 +294,7 @@ def get_max_shell_size(self, geometrycontainer, domains, ignores=[]):
         else:  # Pair or Multi or Surface
             new_shell_size = distance_to_shell / SAFETY
 
-        max_size = numpy.sqrt( geometrycontainer.get_max_shell_size()**2 - self.shell.shape.radius**2 )
-
-        return min(new_shell_size, max_size )
+        return min(new_shell_size, geometrycontainer.get_max_shell_size())
 
 
 class SphericalSingle(NonInteractionSingle):
@@ -503,7 +497,6 @@ def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
         """
-       
         return min(self.draw_escape_time_tuple(),
                    self.draw_reaction_time_tuple(),
                    self.draw_iv_event_time_tuple())     # above two events also occur in NonInteractingSingle
@@ -520,7 +513,7 @@ def draw_iv_event_time_tuple(self):
 
         """
         dt = draw_time_wrapper(self.iv_greens_function())
-        
+
         return dt, EventType.IV_EVENT
 
     def draw_iv_event_type(self):
@@ -756,94 +749,7 @@ def get_shell_size(self):
         return self.shell.shape.half_length
 
     def __str__(self):
-        return 'CylindricalSurfaceInteraction ' + Single.__str__(self)
-
-
-class CylindricalSurfaceSink(InteractionSingle):
-    """1 Particle inside a (Cylindrical) shell on a CylindricalSurface.
-        Inside the domain is a sink.
-
-        * Particle coordinates on surface: z.
-        * Domain: cartesian z.
-        * Initial position: z = 0.
-        * Selected randomly when drawing displacement vector: none.
-    """
-    def __init__(self, domain_id, pid_particle_pair, reactionrules, structure,
-                 shell_id, shell_center, shell_half_length, zsink, interactionrules, sink_surface):
-
-        InteractionSingle.__init__(self, domain_id, pid_particle_pair, reactionrules,
-                                   structure, shell_id, interactionrules, sink_surface)
-
-        # z0 is implied to be zero (the particle being in the center of the shell in the z direction)
-        self.zsink = zsink # Position of the sink, given that the particle is at the origin.
-        self.shell = self.create_new_shell(shell_center, 
-                                           pid_particle_pair[1].radius,
-                                           structure.shape.unit_z, 
-                                           shell_half_length)
-
-    def get_inner_a(self):
-        return self.shell.shape.half_length - self.pid_particle_pair[1].radius
-
-    def iv_greens_function(self):
-        # The Green's function used for both ESCAPE and IV (sink) events.
-        # Particle allways starts in the middle for now.
-        inner_half_length = self.get_inner_a()
-        
-        return GreensFunction1DAbsSinkAbs(self.D, self.interaction_ktot, 0.0, self.zsink, 
-                                          -inner_half_length, inner_half_length)
-
-    def determine_next_event(self):
-        """Return an (event_time, event_type)-tuple.
-
-        """
-        return min(self.draw_reaction_time_tuple(),
-                   self.draw_iv_event_time_tuple())
-
-    def draw_new_position(self, dt, event_type):
-        oldpos = self.pid_particle_pair[1].position
-
-        if self.D == 0 or \
-                (event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0):
-            newpos = oldpos
-        else:
-            gf = self.iv_greens_function()
-
-            if event_type == EventType.IV_EVENT:
-                self.event_type = self.draw_iv_event_type()
-                event_type = self.event_type
-
-            if event_type == EventType.IV_ESCAPE:
-                #Determine wether particle escaped at left (s) or right (a) boundary.
-                flux_a = abs( gf.flux_leavea( dt ) )
-                flux_s = abs( gf.flux_leaves( dt ) )
-                rnd = myrandom.uniform() * ( flux_a + flux_s )
-                
-                inner_half_length = self.get_inner_a()
-                
-                if( rnd < flux_a ):
-                    z = inner_half_length
-                else:
-                    z = -inner_half_length
-            elif event_type == EventType.IV_INTERACTION:
-                z = self.zsink
-            else:
-                z = draw_r_wrapper(gf, dt, self.get_inner_a(), -self.get_inner_a())
-
-        # Add displacement to shell.shape.position, not to particle.position.
-        z_vector = self.structure.shape.unit_z * z
-        newpos = self.shell.shape.position + z_vector
-
-        return newpos
-
-    def get_shell_size(self):
-        # REMOVE this method, it doesn't mean anything here.
-        # THis method is only used for making an Interaction
-        # Heads up. The cylinder's *half_length*, not radius, 
-        # determines the size in case of a cylindrical surface.
-        return self.shell.shape.half_length
-
-    def __str__(self):
-        return 'CylindricalSurfaceSink ' + Single.__str__(self)
+        return 'CylindricalSurfaceInteraction' + Single.__str__(self)
 
 class DummySingle(object):
     def __init__(self):

From d8d90ad312da46c49e46a7c690c7a836cc5c1b88 Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Fri, 13 Jan 2012 10:37:38 +0100
Subject: [PATCH 0569/1541] Everything back to normal.

---
 GreensFunction1DAbsSinkAbs.cpp | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index b6fda348..f41b8126 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -171,13 +171,11 @@ std::pair<Real, Real> GreensFunction1DAbsSinkAbs::get_lower_and_upper() const
     /* If the parity is incorrect -> correct it */
     if( f_upper * parity_op < 0)
     {
-        int cntr = 0;
+        int cntr( 0 );
 
         Real delta( .1 * safety * right_offset );
         const Real save_upper( upper );
         
-        cntr = 0;
-
         /* Assuming the upper point has overshoot the straddle region,
            subtract from the upper limit, until endpoits do straddle.
          */

From b2cabfa3864f0a434d2b6086b3d010a75e571d6d Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Fri, 13 Jan 2012 11:35:15 +0100
Subject: [PATCH 0570/1541] Especially dumper.py modification is necessary,
 because otherwise obtaining number particles if using only BDSimulator
 doesn't work. (via _get_number_of_particles_by_sid)

---
 dumper.py                     | 18 ++++++++++++------
 egfrd.py                      | 11 ++++++-----
 samples/2d/2dtest.py          |  4 ++--
 visualization/run_pipeline.py |  4 +++-
 4 files changed, 23 insertions(+), 14 deletions(-)

diff --git a/dumper.py b/dumper.py
index 7f11eab5..33c0c781 100644
--- a/dumper.py
+++ b/dumper.py
@@ -157,12 +157,18 @@ def _get_number_of_particles_by_sid(sim, sid):
     #
     #TODO: Added by wehrens@AMOLF.nl; Please revise.
 
-    if isinstance(sim, EGFRDSimulator):
-        return len(sim.world.get_particle_ids(sid))
-    else:
-        # Gillespie.
-        species_index = sim.speciesDict[sid]
-        return sim.stateArray[species_index]
+    # OLD CODE, facilitating Gillespie:
+    #    if isinstance(sim, EGFRDSimulator):
+    #        return len(sim.world.get_particle_ids(sid))
+    #    else:
+    #        if isinstance(sim, BDSimulator):
+    #            return len(sim.world.get_particle_ids(sid))    
+    #        if isinstance(sim, EGFRDSimulator):
+    #            # Gillespie.
+    #            species_index = sim.speciesDict[sid]
+    #            return sim.stateArray[species_index]
+
+    return len(sim.world.get_particle_ids(sid))
 
 def get_number_of_particles(sim, identifier=None):
     """Return the number of particles of a certain Species in the 
diff --git a/egfrd.py b/egfrd.py
index 33ca28a6..908e2012 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -350,12 +350,13 @@ def step(self):
             if self.dt == 0:
                 log.debug('dt=zero step, working in s.t >> dt~0 Python limit.')
                 self.zero_steps += 1
-                # TODO Changed from 10 to 10000, because only a problem 
-                # when reaching certain magnitude.
+                # TODO What is best solution here? Usually no prob, -> just let 
+                # user know?
                 if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
-                    raise RuntimeError('too many dt=zero steps. '
-                                       'Simulator halted?'
-                                    'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
+                    #raise RuntimeError('too many dt=zero steps. '
+                    #                   'Simulator halted?'
+                    #                'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
+                    log.warning('dt=zero step, working in s.t >> dt~0 Python limit.')
             else:
                 self.zero_steps = 0
 
diff --git a/samples/2d/2dtest.py b/samples/2d/2dtest.py
index c4735a53..57ec98f2 100755
--- a/samples/2d/2dtest.py
+++ b/samples/2d/2dtest.py
@@ -83,8 +83,8 @@
 # Reaction rules
 r1 = model.create_binding_reaction_rule(A, B, C, k)
 m.network_rules.add_reaction_rule(r1)
-r1 = model.create_unbinding_reaction_rule(C, A, B, (1/10))
-m.network_rules.add_reaction_rule(r1)
+r2 = model.create_unbinding_reaction_rule(C, A, B, (1/10))
+m.network_rules.add_reaction_rule(r2)
 
 
 # World
diff --git a/visualization/run_pipeline.py b/visualization/run_pipeline.py
index 0de8806a..fef74bd8 100644
--- a/visualization/run_pipeline.py
+++ b/visualization/run_pipeline.py
@@ -7,11 +7,13 @@
 # Root directory of the eGFRD algorithm files:
 # Use the full path (e.g. NOT a tilde)
 egfrd_directory ='/storage1/wehrens/sep2011_eGFRD'
+
 # Output directory of the VTK logger 
 # (This was defined when calling the logger in your
 # script.)
 simulation_data_directory =\
-    '/storage1/wehrens/sep2011_eGFRD/samples/2d/VTK_out' # egfrd_directory + \
+    '/storage1/wehrens/sep2011_eGFRD/samples/2d/VTK_out'
+#    '/storage1/wehrens/sep2011_eGFRD/samples/2d/VTK_out' # egfrd_directory + \
 """
 
 2. Start ParaView. Make sure you give Paraview the PYTHONPATH 

From b453f15dfe7f37fa8e2fd406dd7358a7c0cafd60 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Fri, 13 Jan 2012 14:52:41 +0100
Subject: [PATCH 0571/1541] Template update.

---
 samples/template/template.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/samples/template/template.py b/samples/template/template.py
index 3821c12e..da68ae30 100755
--- a/samples/template/template.py
+++ b/samples/template/template.py
@@ -94,6 +94,8 @@
 if (os.path.exists(vtk_output_directory)):
     print '** WARNING: VTK output directory already exists, possible '+ \
             'present old VTK files might lead to errors.'
+    logging = False
+    print "Turned logging of."            
     
 from visualization import vtklogger
 l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 

From cae40bc5465795f15aeb60522410596cb99dd54c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 13 Jan 2012 16:45:36 +0100
Subject: [PATCH 0572/1541] slightly larger MULTI_SHELL_FACTOR improves the
 performance of cylindrical shells

---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index 6fe34265..33f97b6b 100644
--- a/utils.py
+++ b/utils.py
@@ -28,7 +28,7 @@
 MINIMAL_SEPARATION_FACTOR = 1.0 + TOLERANCE
 
 
-MULTI_SHELL_FACTOR = math.sqrt(2.1) # MULTI_SHELL_FACTOR should be AT LEAST sqrt(2)
+MULTI_SHELL_FACTOR = math.sqrt(3) # MULTI_SHELL_FACTOR should be AT LEAST sqrt(2)
                                     # This stems from the fact that there vacant space in the cylinder
                                     # NonInteractionSingles to a Multi and also defines the Multi
                                     # shell size.

From 981d4b29c09a9bc6a3909799390d8d67d6363327 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 13 Jan 2012 16:46:28 +0100
Subject: [PATCH 0573/1541] Small changes to accomodate the CylindricalSink
 domain

---
 egfrd.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 89672661..a74356f9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -967,13 +967,13 @@ def fire_single_reaction(self, single, reactant_pos):
     def fire_interaction(self, single, reactant_pos):
         # This takes care of the identity change when a particle associates with a surface
         # It performs the reactions:
-        # A(3D) + surface -> 0
-        # A(3D) + surface -> B(surface)
+        # A(structure) + surface -> 0
+        # A(structure) + surface -> B(surface)
         assert isinstance(single, InteractionSingle)
 
         # 0. get reactant info
         reactant        = single.pid_particle_pair
-        reactant_radius    = reactant[1].radius
+        reactant_radius = reactant[1].radius
         rr = single.interactionrule
 
         # 1. remove the particle
@@ -997,9 +997,10 @@ def fire_interaction(self, single, reactant_pos):
             product_species = self.world.get_species(rr.products[0])
             product_radius  = product_species.radius
             product_surface = single.surface
-            # make sure that the product species lives on the interaction surface
-            assert (single.surface == self.world.get_structure(product_species.structure_id)), \
-                   'Product particle should live on the surface of interaction after the reaction.'
+            # TODO make sure that the product species lives on the same type of the interaction surface
+#            product_structure_type = self.world.get_structure(product_species.structure_id)
+#            assert (single.surface.sid == self.world.get_structure(product_species.structure_id)), \
+#                   'Product particle should live on the surface of interaction after the reaction.'
 
             # 1.5 get new position of particle
             transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)

From 15075af2bf458a54841c4ddd39f67d89cef6a1f2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 13 Jan 2012 16:47:35 +0100
Subject: [PATCH 0574/1541] small fix

---
 single.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 526c3ccd..1b765d7f 100644
--- a/single.py
+++ b/single.py
@@ -663,7 +663,7 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # r0 is the distance from the center of the cylinder to the center of the particle
         # z0 is known to be zero (the particle being in the center of the shell in the z direction)
         self.unit_r = self.testShell.reference_vector    
-        self.r0     = self.testShell.particle_surface_distance
+        self.r0     = self.testShell.particle_surface_distance + self.surface.shape.radius
         self.z0     = 0.0
 
     def get_inner_dz_left(self):

From 1a260e64af88b0c3da9bc4e0e2f814013c337ef1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 Jan 2012 13:32:15 +0100
Subject: [PATCH 0575/1541] Changing the scaling code to scale to shapes not
 shells. Also introduced Planar shape and some adjustments to accomodate
 CylindricalSurfaceSink

---
 shells.py | 119 +++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 81 insertions(+), 38 deletions(-)

diff --git a/shells.py b/shells.py
index e87fa6be..a4d2dc7c 100755
--- a/shells.py
+++ b/shells.py
@@ -7,6 +7,7 @@
     SphericalShell,
     Cylinder,
     CylindricalShell,
+    CylindricalSurface,
     PlanarSurface,
     CuboidalRegion,
     )
@@ -139,7 +140,7 @@ def __init__(self, single, structure, surface):
 
         # projection_distance can be negative in case of plane
         # note that the distance is to the center of the cylinder in case of cylinders
-        self.particle_surface_distance = abs(projection_length)
+        self.particle_surface_distance = self.world.distance(self.surface.shape, self.pid_particle_pair[1].position)
 
         # The reference_vector is the normalized vector from the reference_point to the particle
         self.reference_vector = normalize(pos_transposed - self.reference_point)
@@ -335,7 +336,8 @@ def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
 
     # methods to size up a testShell to this domain.
-    def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
+    @ classmethod
+    def get_dr_dzright_dzleft_to_shell(cls, shape, testShell, r, z_right, z_left):
         # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
         # using the spherical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
         # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
@@ -343,11 +345,11 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
         # Note that the 'shell' is querried from this domain earlier by the testShell.
         # -> the shell MUST be a Sphere
-        assert (type(shell.shape) is Sphere)
+        assert (type(shape) is Sphere)
 
         # Laurens' algorithm (part1)
-        shell_position = shell.shape.position
-        shell_radius = shell.shape.radius 
+        shell_position = shape.position
+        shell_radius = shape.radius 
 
         # get the reference point and orientation of the domain to scale
         reference_point = testShell.get_referencepoint()
@@ -490,18 +492,19 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
         return r, z_right, z_left
 
 
-    def get_radius_to_shell(self, shell, testShell, r):
+    @ classmethod
+    def get_radius_to_shell(cls, shape, testShell, r):
         # This function returns the radius for the spherical 'testShell' using the spherical 'shell' as its closest
         # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
         # therefore only become smaller.
 
         # Note that the 'shell' is querried from this domain earlier by the testShell.
         # -> the shell MUST be a Sphere
-        assert (type(shell.shape) is Sphere)
+        assert (type(shape) is Sphere)
 
         # Do simple distance calculation to sphere
         scale_point = testShell.center
-        r_new = testShell.world.distance(shell.shape, scale_point)
+        r_new = testShell.world.distance(shape, scale_point)
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
@@ -550,7 +553,8 @@ def create_new_shell(self, position, radius, half_length, domain_id):
         return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
 
     # methods to size up a testShell to this domain.
-    def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
+    @ classmethod
+    def get_dr_dzright_dzleft_to_shell(cls, shape, testShell, r, z_right, z_left):
         # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
         # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
         # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
@@ -558,12 +562,12 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
         # Note that the 'shell' is querried from this domain earlier by the testShell.
         # -> the shell MUST be a Cylinder.
-        assert (type(shell.shape) is Cylinder)
+        assert (type(shape) is Cylinder)
 
         # Laurens' algorithm (part2)
-        shell_position = shell.shape.position
-        shell_radius = shell.shape.radius 
-        shell_half_length = shell.shape.half_length 
+        shell_position = shape.position
+        shell_radius = shape.radius 
+        shell_half_length = shape.half_length 
 
 
         # get the reference point and orientation of the domain to scale
@@ -639,18 +643,41 @@ def get_dr_dzright_dzleft_to_shell(self, shell, testShell, r, z_right, z_left):
 
         return r, z_right, z_left
 
-    def get_radius_to_shell(self, shell, testShell, r):
+    @ classmethod
+    def get_radius_to_shell(cls, shape, testShell, r):
         # This function returns the radius for the spherical 'testShell' using the cylindrical 'shell' as its closest
         # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
         # therefore only become smaller.
 
         # Note that the 'shell' is querried from this domain earlier by the testShell.
         # -> the shell MUST be a Cylinder
-        assert (type(shell.shape) is Cylinder)
+        assert (type(shape) is Cylinder)
 
         # Do simple distance calculation to cylinder
         scale_point = testShell.center
-        r_new = testShell.world.distance(shell.shape, scale_point)
+        r_new = testShell.world.distance(shape, scale_point)
+
+        # if the newly calculated dimensions are smaller than the current one, use them
+        return min(r, r_new)
+
+class hasPlanarShape():
+
+    @ classmethod
+    def get_dr_dzright_dzleft_to_shell(self, shape, testShell, r, z_right, z_left):
+        assert False
+        pass
+
+    @ classmethod
+    def get_radius_to_shell(cls, shape, testShell, r):
+        # This function returns the radius for the spherical 'testShell' using the planar 'shape' as its closest
+        # neighbor. Note that it returns the minimum of the newly calculated radius and the old radius. The 'testShell' can
+        # therefore only become smaller.
+
+        assert (type(shape) is Plane)
+
+        # Do simple distance calculation to sphere
+        scale_point = testShell.center
+        r_new = testShell.world.distance(shape, scale_point)
 
         # if the newly calculated dimensions are smaller than the current one, use them
         return min(r, r_new)
@@ -724,7 +751,7 @@ def determine_possible_shell(self, ignore, ignores):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                radius_new = neighbor.get_radius_to_shell(shell_appearance, self, radius)
+                radius_new = neighbor.get_radius_to_shell(shell_appearance.shape, self, radius)
 
                 if radius_new != radius:
                     # A new (smaller) radius was found
@@ -822,12 +849,24 @@ def determine_possible_shell(self, ignore, ignores):
         dr, dz_right, dz_left             = self.apply_safety(max_dr, max_dz_right, max_dz_left)
 
         # first check the maximum dr, dz_right, dz_left against the surfaces
-#        for surface, distance in neighbor_surfaces:
-#            radius = min(radius, distance)     # TODO
-#            if radius < min_radius:
-#                raise ShellmakingError('Surface too close to make cylindrical testshell, '
-#                                       'surface = %s, distance = %s, testShell = %s' %
-#                                       (surface, distance, self))
+        # NOTE: we assume that all relevant surfaces are cylindrical and parallel to the testCylinder
+        for surface, distance in neighbor_surfaces:
+            # TODO
+            if isinstance(surface, CylindricalSurface):
+                dr_new, dz_right_new, dz_left_new = hasCylindricalShell.get_dr_dzright_dzleft_to_shell(surface.shape, self,
+                                                                                                       dr, dz_right, dz_left)
+            elif isinstance(surface, PlanarSurface):
+                dr_new, dz_right_new, dz_left_new = hasPlanarShape.get_dr_dzright_dzleft_to_shell(surface.shape, self,
+                                                                                                  dr, dz_right, dz_left)
+
+
+            if (dr_new != dr) or (dz_right_new != dz_right) or (dz_left_new != dz_left):
+                # The dimensions were changed, reapply the safety margin
+                dr, dz_right, dz_left = self.apply_safety(dr_new, dz_right_new, dz_left_new)
+                if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
+                    raise ShellmakingError('Surface too close to make cylindrical testshell, '
+                                           'surface = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
+                                           (surface, dr, dz_right, dz_left, self))
 
         # TODO first sort the neighbors to distance -> faster to find if we fail
 
@@ -837,21 +876,22 @@ def determine_possible_shell(self, ignore, ignores):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                dr_new, dz_right_new, dz_left_new = neighbor.get_dr_dzright_dzleft_to_shell(shell_appearance, self,
+                dr_new, dz_right_new, dz_left_new = neighbor.get_dr_dzright_dzleft_to_shell(shell_appearance.shape, self,
                                                                                             dr, dz_right, dz_left)
                 if (dr_new != dr) or (dz_right_new != dz_right) or (dz_left_new != dz_left):
                     # The dimensions were changed, reapply the safety margin
                     dr, dz_right, dz_left = self.apply_safety(dr_new, dz_right_new, dz_left_new)
                     if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
                         raise ShellmakingError('Domain too close to make cylindrical testshell, '
-                                               'domain = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
+                                               'domain = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' % \
                                                (neighbor, dr, dz_right, dz_left, self))
 
         # we calculated valid dimensions -> success!
         assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
-               'CylindricaltestShell dimensions smaller than the minimum, radius = %s, min_radius = %s.' % \
-                (radius, min_radius)
-        
+               'CylindricaltestShell dimensions smaller than the minimum, \
+                dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
+               (dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left)
+
         return dr, dz_right, dz_left
 
     def get_searchpoint(self):
@@ -1204,11 +1244,11 @@ def __init__(self, single, surface, geometrycontainer, domains):
         self.dzdr_right = 1.0
         self.drdz_right = 1.0
         self.r0_right   = 0.0
-        self.z0_right   = -self.particle_surface_distance   # note that this is because dzdr_right = 1.0
-        self.dzdr_left  = 1.0
-        self.drdz_left  = 1.0
-        self.r0_left    = 0.0
-        self.z0_left    = -self.particle_surface_distance
+        self.z0_right   = -(self.particle_surface_distance + self.surface.shape.radius)   # note that this is because dzdr_right = 1.0
+        self.dzdr_left  = self.dzdr_right
+        self.drdz_left  = self.drdz_right
+        self.r0_left    = self.r0_right
+        self.z0_left    = self.z0_right
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
@@ -1231,17 +1271,17 @@ def get_referencepoint(self):
         return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + self.particle_surface_distance
+        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + (self.particle_surface_distance + self.surface.shape.radius)
         dz_right = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         # TODO clarify
-        dz_right = ((-self.particle_surface_distance + \
-                     math.sqrt(2*(self.get_searchradius()**2) - self.particle_surface_distance**2)) / 2.0)
+        dz_right = ((-(self.particle_surface_distance + self.surface.shape.radius) + \
+                     math.sqrt(2*(self.get_searchradius()**2) - (self.particle_surface_distance + self.surface.shape.radius)**2)) / 2.0)
         dz_left  = dz_right
-        dr       = (self.particle_surface_distance + dz_right)
+        dr       = ((self.particle_surface_distance + self.surface.shape.radius) + dz_right)
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1283,7 +1323,10 @@ def __init__(self, single, surface, geometrycontainer, domains):
 
 
     def get_orientation_vector(self):
-        return self.reference_vector      # calculated in the __init__ of testInteractionSingle
+        pos = self.world.cyclic_transpose(self.pid_particle_pair[1].position, self.surface.shape.position)
+        orientation_vector = pos - self.surface.shape.position
+        # if the dot product is negative, then take the -unit_z, otherwise take unit_z
+        return self.surface.shape.unit_z * cmp(numpy.dot(orientation_vector, self.surface.shape.unit_z), 0)
 
     def get_searchpoint(self):
         return self.pid_particle_pair[1].position

From febfae044df11488978939e6bc353995498515e8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 Jan 2012 15:26:22 +0100
Subject: [PATCH 0576/1541] Singles return a spherical shell when really small
 to make sure there is space for a multi shell (which is spherical).

---
 shells.py | 595 +++++++++++++++++++++++++++---------------------------
 single.py |  38 ++--
 2 files changed, 324 insertions(+), 309 deletions(-)

diff --git a/shells.py b/shells.py
index a4d2dc7c..547864ec 100755
--- a/shells.py
+++ b/shells.py
@@ -335,180 +335,6 @@ def __init__(self, sphericaltestShell, domain_id):
     def create_new_shell(self, position, radius, domain_id):
         return SphericalShell(domain_id, Sphere(position, radius))
 
-    # methods to size up a testShell to this domain.
-    @ classmethod
-    def get_dr_dzright_dzleft_to_shell(cls, shape, testShell, r, z_right, z_left):
-        # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
-        # using the spherical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
-        # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
-        # smaller.
-
-        # Note that the 'shell' is querried from this domain earlier by the testShell.
-        # -> the shell MUST be a Sphere
-        assert (type(shape) is Sphere)
-
-        # Laurens' algorithm (part1)
-        shell_position = shape.position
-        shell_radius = shape.radius 
-
-        # get the reference point and orientation of the domain to scale
-        reference_point = testShell.get_referencepoint()
-        orientation_vector = testShell.get_orientation_vector()
-
-        # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
-        ref_to_shell_vec = shell_position_t - reference_point
-        ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
-
-        # if the shell is on the side of orientation_vector -> use z_right
-        # also use this one if the shell is in plane with the reference_point
-        if ref_to_shell_z >= 0:
-            direction = 1           # improve direction specification such that following calculations still work
-                                    # Otherwise problems when direction = 0
-            scale_angle = testShell.right_scalingangle
-            scale_center_r, scale_center_z = testShell.right_scalingcenter 
-            r1_function =  testShell.r_right
-            z1_function = testShell.z_right
-            z2_function = testShell.z_left
-            z1 = z_right
-            z2 = z_left
-        # else -> use z_left
-        else:
-            direction = -1
-            scale_angle = testShell.left_scalingangle
-            scale_center_r, scale_center_z = testShell.left_scalingcenter 
-            r1_function =  testShell.r_left
-            z1_function = testShell.z_left
-            z2_function = testShell.z_right
-            z1 = z_left
-            z2 = z_right
-
-        # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
-        ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
-        ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
-        ref_to_shell_r = length(ref_to_shell_r_vec)
-        ref_to_shell_z = ref_to_shell_z * direction
-
-        # calculate the distances in r/z from the scaling center to the shell
-        scale_center_to_shell_r = ref_to_shell_r - scale_center_r
-        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
-
-        # calculate the angle 'shell_angle' of the vector from the 'scale_center' to the shell with the vector
-        # from the 'reference_point' to the 'scale_center' (which is +- the orientation_vector).
-        shell_angle = math.atan(scale_center_to_shell_r/scale_center_to_shell_z)
-
-        if scale_center_to_shell_z < 0.0:
-            shell_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
-        # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
-        # otherwise: shell_angle is ok -> do nothing
-
-        ### check what situation arrises
-        # The shell can hit the cylinder on the flat side (situation 1),
-        #                                on the edge (situation 2),
-        #                                or on the round side (situation 3).
-        # I think this also works for scale_angle == 0 and scale_angle == Pi/2
-        if shell_angle <= 0.0:
-        # The midpoint of the shell lies on the axis of the cylinder
-            situation = 1
-
-        elif 0.0 < shell_angle and shell_angle < scale_angle:
-        # The spherical shell can touch the cylinder on its flat side or its edge
-
-            if scale_angle == Pi/2.0:
-                scale_center_to_shell_z_thres = 0
-            else:
-                # scale_angle == 0 should not get here
-                scale_center_to_shell_z_thres = abs(scale_center_to_shell_r)/math.tan(scale_angle)
-
-            shell_radius_thres = scale_center_to_shell_z - scale_center_to_shell_z_thres
-            if shell_radius < shell_radius_thres:
-                situation = 1
-            else:
-                situation = 2
-
-        elif scale_angle <= shell_angle and shell_angle < Pi/2.0:
-        # The (spherical) shell can touch the cylinder on its edge or its radial side
-            tan_scale_angle = math.tan(scale_angle)                             # scale_angle == Pi/2 should not get here
-            shell_radius_thres = scale_center_to_shell_r - scale_center_to_shell_z * tan_scale_angle  # TODO same here
-
-            if shell_radius > shell_radius_thres:
-                situation = 2
-            else:
-                situation = 3
-
-        elif Pi/2.0 <= shell_angle:
-        # The shell is always only on the radial side of the cylinder
-            situation = 3
-
-        else:
-        # Don't know how we would get here, but it shouldn't happen
-            raise RuntimeError('Error: shell_angle was not in valid range. shell_angle = %s, scale_angle = %s' %
-                               (FORMAT_DOUBLE % shell_angle, FORMAT_DOUBLE % scale_angle))
-
-        ### Get the right values for z and r for the given situation
-        if situation == 1:      # the spherical shell hits cylinder on the flat side
-            z1_new = min(z1, (ref_to_shell_z - shell_radius))
-            r_new  = min(r,  r1_function(z1_new))
-
-        elif situation == 2:    # shell hits sphere on the edge
-            shell_radius_sq = shell_radius*shell_radius
-
-            ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_r**2)
-            scale_center_to_shell = math.sqrt(ss_sq)
-
-            angle_diff = shell_angle - scale_angle
-            sin_angle_diff = math.sin(angle_diff)
-            cos_angle_diff = math.cos(angle_diff)
-
-            scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff - 
-                                       math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
-
-            if scale_angle <= Pi/4.0:
-                cos_scale_angle = math.cos(scale_angle)
-                z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist))
-                r_new  = min(r, r1_function(z1_new))
-            else:
-                sin_scale_angle = math.sin(scale_angle)
-                r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist))
-                z1_new = min(z1, z1_function(r_new))
-
-        elif situation == 3:    # shell hits cylinder on the round side
-            r_new = min(r, (ref_to_shell_r - shell_radius))
-            z1_new = min(z1, z1_function(r_new))
-        else:
-            raise RuntimeError('Bad situation for cylindrical shell making to sphere.')
-
-        z2_new = min(z2, z2_function(r_new))
-
-        # switch the z values in case it's necessary. r doesn't have to be switched.
-        r = r_new
-        if direction >= 0.0:
-            z_right = z1_new
-            z_left  = z2_new
-        else:
-            z_right = z2_new
-            z_left  = z1_new
-
-        return r, z_right, z_left
-
-
-    @ classmethod
-    def get_radius_to_shell(cls, shape, testShell, r):
-        # This function returns the radius for the spherical 'testShell' using the spherical 'shell' as its closest
-        # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
-        # therefore only become smaller.
-
-        # Note that the 'shell' is querried from this domain earlier by the testShell.
-        # -> the shell MUST be a Sphere
-        assert (type(shape) is Sphere)
-
-        # Do simple distance calculation to sphere
-        scale_point = testShell.center
-        r_new = testShell.world.distance(shape, scale_point)
-
-        # if the newly calculated dimensions are smaller than the current one, use them
-        return min(r, r_new)
-
 #########################
 class hasCylindricalShell(hasShell):
     # This class is inherited by domains that have a Cylindrical shell such as the PlanarSurfaceNonInteractionSingle
@@ -552,135 +378,303 @@ def create_new_shell(self, position, radius, half_length, domain_id):
         orientation = self.testShell.get_orientation_vector()
         return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
 
-    # methods to size up a testShell to this domain.
-    @ classmethod
-    def get_dr_dzright_dzleft_to_shell(cls, shape, testShell, r, z_right, z_left):
-        # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
-        # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
-        # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
-        # smaller.
-
-        # Note that the 'shell' is querried from this domain earlier by the testShell.
-        # -> the shell MUST be a Cylinder.
-        assert (type(shape) is Cylinder)
-
-        # Laurens' algorithm (part2)
-        shell_position = shape.position
-        shell_radius = shape.radius 
-        shell_half_length = shape.half_length 
-
-
-        # get the reference point and orientation of the domain to scale
-        reference_point = testShell.get_referencepoint()
-        orientation_vector = testShell.get_orientation_vector()
-
-        # determine on what side the midpoint of the shell is relative to the reference_point
-        shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
-        ref_to_shell_vec = shell_position_t - reference_point
-        ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
-
-        # if the shell is on the side of orientation_vector -> use z_right
-        # also use this one if the shell is in plane with the reference_point
-        if ref_to_shell_z >= 0:
-            direction = 1           # improve direction specification such that following calculations still work
-                                    # Otherwise problems when direction = 0
-            scale_angle = testShell.right_scalingangle
-            scale_center_r, scale_center_z = testShell.right_scalingcenter 
-            r1_function =  testShell.r_right
-            z1_function = testShell.z_right
-            z2_function = testShell.z_left
-            z1 = z_right
-            z2 = z_left
-        # else -> use z_left
+
+###########################
+# functions to size up a testShell to a spherical shape object.
+def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left):
+    # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
+    # using the spherical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
+    # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
+    # smaller.
+
+    # Note that the 'shell' is querried from this domain earlier by the testShell.
+    # -> the shell MUST be a Sphere
+    assert (type(shape) is Sphere)
+
+    # Laurens' algorithm (part1)
+    shell_position = shape.position
+    shell_radius = shape.radius 
+
+    # get the reference point and orientation of the domain to scale
+    reference_point = testShell.get_referencepoint()
+    orientation_vector = testShell.get_orientation_vector()
+
+    # determine on what side the midpoint of the shell is relative to the reference_point
+    shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
+    ref_to_shell_vec = shell_position_t - reference_point
+    ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
+
+    # if the shell is on the side of orientation_vector -> use z_right
+    # also use this one if the shell is in plane with the reference_point
+    if ref_to_shell_z >= 0:
+        direction = 1           # improve direction specification such that following calculations still work
+                                # Otherwise problems when direction = 0
+        scale_angle = testShell.right_scalingangle
+        scale_center_r, scale_center_z = testShell.right_scalingcenter 
+        r1_function =  testShell.r_right
+        z1_function = testShell.z_right
+        z2_function = testShell.z_left
+        z1 = z_right
+        z2 = z_left
+    # else -> use z_left
+    else:
+        direction = -1
+        scale_angle = testShell.left_scalingangle
+        scale_center_r, scale_center_z = testShell.left_scalingcenter 
+        r1_function =  testShell.r_left
+        z1_function = testShell.z_left
+        z2_function = testShell.z_right
+        z1 = z_left
+        z2 = z_right
+
+    # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
+    ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
+    ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
+    ref_to_shell_r = length(ref_to_shell_r_vec)
+    ref_to_shell_z = ref_to_shell_z * direction
+
+    # calculate the distances in r/z from the scaling center to the shell
+    scale_center_to_shell_r = ref_to_shell_r - scale_center_r
+    scale_center_to_shell_z = ref_to_shell_z - scale_center_z
+
+    # calculate the angle 'shell_angle' of the vector from the 'scale_center' to the shell with the vector
+    # from the 'reference_point' to the 'scale_center' (which is +- the orientation_vector).
+    shell_angle = math.atan(scale_center_to_shell_r/scale_center_to_shell_z)
+
+    if scale_center_to_shell_z < 0.0:
+        shell_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
+    # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
+    # otherwise: shell_angle is ok -> do nothing
+
+    ### check what situation arrises
+    # The shell can hit the cylinder on the flat side (situation 1),
+    #                                on the edge (situation 2),
+    #                                or on the round side (situation 3).
+    # I think this also works for scale_angle == 0 and scale_angle == Pi/2
+    if shell_angle <= 0.0:
+    # The midpoint of the shell lies on the axis of the cylinder
+        situation = 1
+
+    elif 0.0 < shell_angle and shell_angle < scale_angle:
+    # The spherical shell can touch the cylinder on its flat side or its edge
+
+        if scale_angle == Pi/2.0:
+            scale_center_to_shell_z_thres = 0
         else:
-            direction = -1
-            scale_angle = testShell.left_scalingangle
-            scale_center_r, scale_center_z = testShell.left_scalingcenter 
-            r1_function =  testShell.r_left
-            z1_function = testShell.z_left
-            z2_function = testShell.z_right
-            z1 = z_left
-            z2 = z_right
-
-        # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
-        ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
-        ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
-        ref_to_shell_r = length(ref_to_shell_r_vec)         # the radius is always positive
-        ref_to_shell_z = ref_to_shell_z * direction         # ref_to_shell_z is positive on the scaling side (right/left)
-
-
-        # calculate the distances in r/z from the scaling center to the shell
-        scale_center_to_shell_r = ref_to_shell_r - scale_center_r
-        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
-
-        # get angles
-        to_edge_angle = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
-
-        if (scale_center_to_shell_z - shell_half_length) < 0.0:
-            to_edge_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
-        # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
-        # otherwise: shell_angle is ok -> do nothing
-
-        if to_edge_angle <= scale_angle:
-            # shell hits the scaling cylinder on top
-            z1_new = min(z1, (ref_to_shell_z - shell_half_length))
-            r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
+            # scale_angle == 0 should not get here
+            scale_center_to_shell_z_thres = abs(scale_center_to_shell_r)/math.tan(scale_angle)
+
+        shell_radius_thres = scale_center_to_shell_z - scale_center_to_shell_z_thres
+        if shell_radius < shell_radius_thres:
+            situation = 1
         else:
-            # shell hits the scaling cylinder on the radial side
-            r_new = min(r, (ref_to_shell_r - shell_radius))
-            z1_new = min(z1, z1_function(r_new))
-        z2_new = min(z2, z2_function(r_new))
+            situation = 2
 
+    elif scale_angle <= shell_angle and shell_angle < Pi/2.0:
+    # The (spherical) shell can touch the cylinder on its edge or its radial side
+        tan_scale_angle = math.tan(scale_angle)                             # scale_angle == Pi/2 should not get here
+        shell_radius_thres = scale_center_to_shell_r - scale_center_to_shell_z * tan_scale_angle  # TODO same here
 
-        # switch the z values in case it's necessary. r doesn't have to be switched.
-        r = r_new
-        if direction == 1:
-            z_right = z1_new
-            z_left  = z2_new
+        if shell_radius > shell_radius_thres:
+            situation = 2
         else:
-            z_right = z2_new
-            z_left  = z1_new
+            situation = 3
 
-        return r, z_right, z_left
+    elif Pi/2.0 <= shell_angle:
+    # The shell is always only on the radial side of the cylinder
+        situation = 3
 
-    @ classmethod
-    def get_radius_to_shell(cls, shape, testShell, r):
-        # This function returns the radius for the spherical 'testShell' using the cylindrical 'shell' as its closest
-        # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
-        # therefore only become smaller.
+    else:
+    # Don't know how we would get here, but it shouldn't happen
+        raise RuntimeError('Error: shell_angle was not in valid range. shell_angle = %s, scale_angle = %s' %
+                           (FORMAT_DOUBLE % shell_angle, FORMAT_DOUBLE % scale_angle))
 
-        # Note that the 'shell' is querried from this domain earlier by the testShell.
-        # -> the shell MUST be a Cylinder
-        assert (type(shape) is Cylinder)
+    ### Get the right values for z and r for the given situation
+    if situation == 1:      # the spherical shell hits cylinder on the flat side
+        z1_new = min(z1, (ref_to_shell_z - shell_radius))
+        r_new  = min(r,  r1_function(z1_new))
 
-        # Do simple distance calculation to cylinder
-        scale_point = testShell.center
-        r_new = testShell.world.distance(shape, scale_point)
+    elif situation == 2:    # shell hits sphere on the edge
+        shell_radius_sq = shell_radius*shell_radius
 
-        # if the newly calculated dimensions are smaller than the current one, use them
-        return min(r, r_new)
+        ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_r**2)
+        scale_center_to_shell = math.sqrt(ss_sq)
 
-class hasPlanarShape():
+        angle_diff = shell_angle - scale_angle
+        sin_angle_diff = math.sin(angle_diff)
+        cos_angle_diff = math.cos(angle_diff)
 
-    @ classmethod
-    def get_dr_dzright_dzleft_to_shell(self, shape, testShell, r, z_right, z_left):
-        assert False
-        pass
+        scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff - 
+                                   math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
 
-    @ classmethod
-    def get_radius_to_shell(cls, shape, testShell, r):
-        # This function returns the radius for the spherical 'testShell' using the planar 'shape' as its closest
-        # neighbor. Note that it returns the minimum of the newly calculated radius and the old radius. The 'testShell' can
-        # therefore only become smaller.
+        if scale_angle <= Pi/4.0:
+            cos_scale_angle = math.cos(scale_angle)
+            z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist))
+            r_new  = min(r, r1_function(z1_new))
+        else:
+            sin_scale_angle = math.sin(scale_angle)
+            r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist))
+            z1_new = min(z1, z1_function(r_new))
+
+    elif situation == 3:    # shell hits cylinder on the round side
+        r_new = min(r, (ref_to_shell_r - shell_radius))
+        z1_new = min(z1, z1_function(r_new))
+    else:
+        raise RuntimeError('Bad situation for cylindrical shell making to sphere.')
+
+    z2_new = min(z2, z2_function(r_new))
+
+    # switch the z values in case it's necessary. r doesn't have to be switched.
+    r = r_new
+    if direction >= 0.0:
+        z_right = z1_new
+        z_left  = z2_new
+    else:
+        z_right = z2_new
+        z_left  = z1_new
+
+    return r, z_right, z_left
+
+
+def get_radius_to_SphericalShape(shape, testShell, r):
+    # This function returns the radius for the spherical 'testShell' using the spherical 'shell' as its closest
+    # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
+    # therefore only become smaller.
 
-        assert (type(shape) is Plane)
+    # Note that the 'shell' is querried from this domain earlier by the testShell.
+    # -> the shell MUST be a Sphere
+    assert (type(shape) is Sphere)
 
-        # Do simple distance calculation to sphere
-        scale_point = testShell.center
-        r_new = testShell.world.distance(shape, scale_point)
+    # Do simple distance calculation to sphere
+    scale_point = testShell.center
+    r_new = testShell.world.distance(shape, scale_point)
 
-        # if the newly calculated dimensions are smaller than the current one, use them
-        return min(r, r_new)
+    # if the newly calculated dimensions are smaller than the current one, use them
+    return min(r, r_new)
+
+# functions to size up a testShell to a Cylindrical shape object
+def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_left):
+    # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
+    # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
+    # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
+    # smaller.
+
+    # Note that the 'shell' is querried from this domain earlier by the testShell.
+    # -> the shell MUST be a Cylinder.
+    assert (type(shape) is Cylinder)
+
+    # Laurens' algorithm (part2)
+    shell_position = shape.position
+    shell_radius = shape.radius 
+    shell_half_length = shape.half_length 
+
+
+    # get the reference point and orientation of the domain to scale
+    reference_point = testShell.get_referencepoint()
+    orientation_vector = testShell.get_orientation_vector()
+
+    # determine on what side the midpoint of the shell is relative to the reference_point
+    shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
+    ref_to_shell_vec = shell_position_t - reference_point
+    ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
+
+    # if the shell is on the side of orientation_vector -> use z_right
+    # also use this one if the shell is in plane with the reference_point
+    if ref_to_shell_z >= 0:
+        direction = 1           # improve direction specification such that following calculations still work
+                                    # Otherwise problems when direction = 0
+        scale_angle = testShell.right_scalingangle
+        scale_center_r, scale_center_z = testShell.right_scalingcenter 
+        r1_function =  testShell.r_right
+        z1_function = testShell.z_right
+        z2_function = testShell.z_left
+        z1 = z_right
+        z2 = z_left
+    # else -> use z_left
+    else:
+        direction = -1
+        scale_angle = testShell.left_scalingangle
+        scale_center_r, scale_center_z = testShell.left_scalingcenter 
+        r1_function =  testShell.r_left
+        z1_function = testShell.z_left
+        z2_function = testShell.z_right
+        z1 = z_left
+        z2 = z_right
+
+    # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
+    ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
+    ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
+    ref_to_shell_r = length(ref_to_shell_r_vec)         # the radius is always positive
+    ref_to_shell_z = ref_to_shell_z * direction         # ref_to_shell_z is positive on the scaling side (right/left)
+
+
+    # calculate the distances in r/z from the scaling center to the shell
+    scale_center_to_shell_r = ref_to_shell_r - scale_center_r
+    scale_center_to_shell_z = ref_to_shell_z - scale_center_z
+
+    # get angles
+    to_edge_angle = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
+
+    if (scale_center_to_shell_z - shell_half_length) < 0.0:
+        to_edge_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
+    # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
+    # otherwise: shell_angle is ok -> do nothing
+
+    if to_edge_angle <= scale_angle:
+        # shell hits the scaling cylinder on top
+        z1_new = min(z1, (ref_to_shell_z - shell_half_length))
+        r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
+    else:
+        # shell hits the scaling cylinder on the radial side
+        r_new = min(r, (ref_to_shell_r - shell_radius))
+        z1_new = min(z1, z1_function(r_new))
+    z2_new = min(z2, z2_function(r_new))
+
+
+    # switch the z values in case it's necessary. r doesn't have to be switched.
+    r = r_new
+    if direction == 1:
+        z_right = z1_new
+        z_left  = z2_new
+    else:
+        z_right = z2_new
+        z_left  = z1_new
+
+    return r, z_right, z_left
+
+def get_radius_to_CylindricalShape(shape, testShell, r):
+    # This function returns the radius for the spherical 'testShell' using the cylindrical 'shell' as its closest
+    # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
+    # therefore only become smaller.
+
+    # Note that the 'shell' is querried from this domain earlier by the testShell.
+    # -> the shell MUST be a Cylinder
+    assert (type(shape) is Cylinder)
+
+    # Do simple distance calculation to cylinder
+    scale_point = testShell.center
+    r_new = testShell.world.distance(shape, scale_point)
+
+    # if the newly calculated dimensions are smaller than the current one, use them
+    return min(r, r_new)
+
+def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
+    assert False
+    pass
+
+def get_radius_to_PlanarShape(shape, testShell, r):
+    # This function returns the radius for the spherical 'testShell' using the planar 'shape' as its closest
+    # neighbor. Note that it returns the minimum of the newly calculated radius and the old radius. The 'testShell' can
+    # therefore only become smaller.
+
+    assert (type(shape) is Plane)
+
+    # Do simple distance calculation to sphere
+    scale_point = testShell.center
+    r_new = testShell.world.distance(shape, scale_point)
+
+    # if the newly calculated dimensions are smaller than the current one, use them
+    return min(r, r_new)
 
 
 #######################################################
@@ -751,7 +745,10 @@ def determine_possible_shell(self, ignore, ignores):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                radius_new = neighbor.get_radius_to_shell(shell_appearance.shape, self, radius)
+                if isinstance(shell_appearance.shape, Sphere):
+                    radius_new = get_radius_to_SphericalShape(shell_appearance.shape, self, radius)
+                elif isinstance(shell_appearance.shape, Cylinder):
+                    radius_new = get_radius_to_CylindricalShape(shell_appearance.shape, self, radius)
 
                 if radius_new != radius:
                     # A new (smaller) radius was found
@@ -853,12 +850,13 @@ def determine_possible_shell(self, ignore, ignores):
         for surface, distance in neighbor_surfaces:
             # TODO
             if isinstance(surface, CylindricalSurface):
-                dr_new, dz_right_new, dz_left_new = hasCylindricalShell.get_dr_dzright_dzleft_to_shell(surface.shape, self,
-                                                                                                       dr, dz_right, dz_left)
+                dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_CylindricalShape(surface.shape, self,
+                                                                                              dr, dz_right, dz_left)
             elif isinstance(surface, PlanarSurface):
-                dr_new, dz_right_new, dz_left_new = hasPlanarShape.get_dr_dzright_dzleft_to_shell(surface.shape, self,
-                                                                                                  dr, dz_right, dz_left)
-
+                dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_PlanarShape(surface.shape, self,
+                                                                                         dr, dz_right, dz_left)
+            else:
+                assert False, "Wrong type of surface used"
 
             if (dr_new != dr) or (dz_right_new != dz_right) or (dz_left_new != dz_left):
                 # The dimensions were changed, reapply the safety margin
@@ -876,8 +874,15 @@ def determine_possible_shell(self, ignore, ignores):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
-                dr_new, dz_right_new, dz_left_new = neighbor.get_dr_dzright_dzleft_to_shell(shell_appearance.shape, self,
-                                                                                            dr, dz_right, dz_left)
+                if isinstance(shell_appearance.shape, Sphere):
+                    dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self,
+                                                                                                dr, dz_right, dz_left)
+                elif isinstance(shell_appearance.shape, Cylinder):
+                    dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_CylindricalShape(shell_appearance.shape, self,
+                                                                                                  dr, dz_right, dz_left)
+                else:
+                    assert False, "Wrong type of shell shape"
+
                 if (dr_new != dr) or (dz_right_new != dz_right) or (dz_left_new != dz_left):
                     # The dimensions were changed, reapply the safety margin
                     dr, dz_right, dz_left = self.apply_safety(dr_new, dz_right_new, dz_left_new)
diff --git a/single.py b/single.py
index 1b765d7f..c88a86e9 100644
--- a/single.py
+++ b/single.py
@@ -271,8 +271,8 @@ def greens_function(self):
     # these return potentially corrected dimensions
     # For explanation see NonInteractionSingles and Others in shells.py
     def shell_list_for_single(self):
-#        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-        min_radius = self.testShell.get_min_radius()
+        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+#        min_radius = self.testShell.get_min_radius()
         if  self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
@@ -333,21 +333,25 @@ def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
 #        min_radius = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
-        min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
+#        min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
+        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
-            half_length = self.shell.shape.half_length
-            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+#            half_length = self.shell.shape.half_length
+#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, min_radius))
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR     # The burst radius
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
-            half_length = self.shell.shape.half_length
-            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+#            half_length = self.shell.shape.half_length
+            # keep everything at a burstradius distance
+#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, min_radius))
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -408,11 +412,14 @@ def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
 #        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
-        _, min_half_length, _ = self.testShell.get_min_dr_dzright_dzleft()
-        if self.shell.shape.half_length < min_half_length:
+#        _, min_half_length, _ = self.testShell.get_min_dr_dzright_dzleft()
+#        if self.shell.shape.half_length < min_half_length:
+        if self.is_reset():
             position = self.shell.shape.position
-            radius = self.shell.shape.radius
-            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
+#            radius = self.shell.shape.radius
+            radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+#            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
@@ -421,8 +428,11 @@ def shell_list_for_other(self):
         min_half_length = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
-            radius = self.shell.shape.radius
-            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
+#            radius = self.shell.shape.radius
+#            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
+            # Keep all the other shells outside the burst radius (which is spherical!)
+            # Note that this makes the cylindrical shell have a slightly smaller radius than the burst radius.
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, min_half_length))
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list

From 3031527299deb8a57fd08fd55c6522eee9e5274f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 Jan 2012 15:27:50 +0100
Subject: [PATCH 0577/1541] small fix. If a domain burst an other domain it's
 actually possible that the domains overlapped.

---
 egfrd.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 343d611f..d48c1cc0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1401,7 +1401,10 @@ def process_single_event(self, single):
         else:
         ### 1. Process 'normal' event produced by the single
 
-            assert self.check_domain(single)
+            if single.event_type != EventType.BURST:
+                # The burst of the domain may be caused by an overlapping domain
+                assert self.check_domain(single)
+
             # check that the event time of the single (last_time + dt) is equal to the
             # simulator time
             assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t), \

From 92884ad813aacd8433c63b3c813a91e916e1793a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 Jan 2012 19:33:38 +0100
Subject: [PATCH 0578/1541] fixed problem with minimal shell dimensions are
 their shape. Also introduced exception to catch the case in MixedPair2D3D
 where the particle are too close together. Because we rescale the inner
 boundary for the Green's function this would lead to a situation where the
 initial condition lies within the inner boundary.

---
 shells.py | 34 ++++++++++++++++++++++++++++++----
 single.py | 42 +++++++++++++++++++++++-------------------
 2 files changed, 53 insertions(+), 23 deletions(-)

diff --git a/shells.py b/shells.py
index 547864ec..956dd378 100755
--- a/shells.py
+++ b/shells.py
@@ -46,6 +46,11 @@ class ShellmakingError(Exception):
     # smaller than the minimal dimensions.
     pass
 
+class protoDomainError(Exception):
+    # The protoDomainError is raised when something in the initialization of the variables
+    # that is NOT related to the shell goes wrong. This will lead later to a testShellError
+    pass
+
 class testShellError(Exception):
     # The testShellError is raised when the testShell could not be made, usually
     # due to a ShellmakingError
@@ -91,11 +96,27 @@ def __init__(self):
     def shell_list_for_single(self):
         # In case the asker is also a NonInteractionSingle, the shell dimensions of the current domain
         # is modified such that the domain is at least the size of the Multi shell.
+
+        # NOTE: the Multi shell is spherical whereas the real shell of the NonInteractionSingle can
+        # be cylinderical. This method should therefore always return at the Multi shell.
+        # In practice it will return the multi shell when the real shell fits inside the multi shell (typically when
+        # the domain is just initialized), and will return the real shell when the domain exceeds the multi shell.
+        # This means that there may not be space for the multi shell when the domain has non-null dimensions.
+        # This should be ok, because no multi will be directly made when the domain has non-null dimensions but
+        # will only be made after first bursting nearby domains.
+
         pass    # needs to be specified in the subclass
     def shell_list_for_other(self):
         # In case the asker is an Other, the shell dimensions of the current NonInteractionSingle domain
         # is modified such that the domain is at least its minimum size (SINGLE_SHELL_FACTOR).
         # This is to reduce unnecessary bursting of the (expensive) Other domains.
+
+        # NOTE: Since the burst radius is spherical, a spherical shell of the size of the burst radius is returned
+        # when the real shell is small enough to fit inside the burst radius. When the real shell no longer fits inside
+        # the burst radius the real shell is returned.
+        # This means that more bursting will take place than necessary because cylindrical domain do not keep the domains
+        # that are out of the 'diffusion dimension' at the proper distance -> TODO
+
         pass    # needs to be specified in the subclass
 
 
@@ -161,9 +182,9 @@ def __init__(self, single1, single2):
         self.pid_particle_pair2 = single2.pid_particle_pair
         self.com, self.iv = self.do_transform()
         self.r0 = length(self.iv)
-        assert self.r0 >= self.sigma, \
-            'distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
-            (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma))
+        if self.r0 < self.sigma:
+            raise protoDomainError('distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
+                (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma)))
 
 
     def get_D_tot(self):
@@ -1359,7 +1380,12 @@ class MixedPair2D3DtestShell(CylindricaltestShell, testMixedPair2D3D):
 
     def __init__(self, single2D, single3D, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testMixedPair2D3D.__init__(self, single2D, single3D)
+        # The initialization of r0 can fail in testPair.__init__
+        try:
+            testMixedPair2D3D.__init__(self, single2D, single3D)
+        except protoDomainError as e:
+            raise testShellError('(MixedPair2D3D). %s' %
+                                 (str(e)))
 
         # initialize commonly used constants
         self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
diff --git a/single.py b/single.py
index c88a86e9..96618bf0 100644
--- a/single.py
+++ b/single.py
@@ -271,8 +271,8 @@ def greens_function(self):
     # these return potentially corrected dimensions
     # For explanation see NonInteractionSingles and Others in shells.py
     def shell_list_for_single(self):
+        # make sure that there is at least space for the multi shell
         min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-#        min_radius = self.testShell.get_min_radius()
         if  self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
@@ -282,6 +282,7 @@ def shell_list_for_single(self):
             return self.shell_list
 
     def shell_list_for_other(self):
+        # keeps all the other domains at a distance of the burst radius
         min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
@@ -331,29 +332,33 @@ def greens_function(self):
     # For explanation see NonInteractionSingles and Others in shells.py
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
-        # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
-#        min_radius = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
-#        min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
-        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+        # Note that in case of a cylindrical shell this must fit inside of the spherical multi shell because
+        # this demarks the boundary outside of which domains can be.
+        min_radius = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         if self.shell.shape.radius < min_radius:
+            # This should only happen if the domain is just initialized.
             position = self.shell.shape.position
-#            half_length = self.shell.shape.half_length
-#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
-            fake_shell = SphericalShell(self.domain_id, Sphere(position, min_radius))
+            radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+            # There should always be space to make the spherical multi shell.
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
             return [(self.shell_id, fake_shell), ]
         else:
+            # When the shell has proper dimensions -> just return the real shell.
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR     # The burst radius
+        # set the threshold below which the shell is adjusted.
+        min_radius = self.pid_particle_pair[1].radius * math.sqrt(SINGLE_SHELL_FACTOR**2 - 1.0)
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
+            radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR     # The burst radius
 #            half_length = self.shell.shape.half_length
             # keep everything at a burstradius distance
 #            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
-            fake_shell = SphericalShell(self.domain_id, Sphere(position, min_radius))
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
             return [(self.shell_id, fake_shell), ]
         else:
+            # When the shell is larger than the burst volume -> return the real shell.
             return self.shell_list
 
     def create_updated_shell(self, position):
@@ -411,30 +416,29 @@ def greens_function(self):
     def shell_list_for_single(self):
         # The shell should always be larger that the bare minimum for a test shell
         # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
-#        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
-#        _, min_half_length, _ = self.testShell.get_min_dr_dzright_dzleft()
-#        if self.shell.shape.half_length < min_half_length:
-        if self.is_reset():
+        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        if self.shell.shape.half_length < min_half_length:
+            # This should only happen if the domain is just initialized.
             position = self.shell.shape.position
-#            radius = self.shell.shape.radius
+            # There should always be space to make the spherical multi shell.
             radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-#            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
             fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
             return [(self.shell_id, fake_shell), ]
         else:
             return self.shell_list
 
     def shell_list_for_other(self):
-        min_half_length = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(SINGLE_SHELL_FACTOR**2 - 1.0)
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
-#            radius = self.shell.shape.radius
+            radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
 #            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
             # Keep all the other shells outside the burst radius (which is spherical!)
             # Note that this makes the cylindrical shell have a slightly smaller radius than the burst radius.
-            fake_shell = SphericalShell(self.domain_id, Sphere(position, min_half_length))
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
             return [(self.shell_id, fake_shell), ]
         else:
+            # When the shell is larger than the burst volume -> return the real shell.
             return self.shell_list
 
     def create_updated_shell(self, position):

From f7cb43b65c309a235c3482676eab69765238add0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 17 Jan 2012 15:21:34 +0100
Subject: [PATCH 0579/1541] added comments and error messaging

---
 shells.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 956dd378..40497556 100755
--- a/shells.py
+++ b/shells.py
@@ -93,6 +93,7 @@ def __init__(self):
         pass    # do nothing
 
     # The next two methods are only relevant for HASSHELL subclasses that derive from this class.
+    # NOTE below two methods have quite a different purpose!
     def shell_list_for_single(self):
         # In case the asker is also a NonInteractionSingle, the shell dimensions of the current domain
         # is modified such that the domain is at least the size of the Multi shell.
@@ -106,6 +107,8 @@ def shell_list_for_single(self):
         # will only be made after first bursting nearby domains.
 
         pass    # needs to be specified in the subclass
+
+
     def shell_list_for_other(self):
         # In case the asker is an Other, the shell dimensions of the current NonInteractionSingle domain
         # is modified such that the domain is at least its minimum size (SINGLE_SHELL_FACTOR).
@@ -909,8 +912,8 @@ def determine_possible_shell(self, ignore, ignores):
                     dr, dz_right, dz_left = self.apply_safety(dr_new, dz_right_new, dz_left_new)
                     if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
                         raise ShellmakingError('Domain too close to make cylindrical testshell, '
-                                               'domain = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' % \
-                                               (neighbor, dr, dz_right, dz_left, self))
+                                               'domain = %s, dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
+                                               (neighbor, dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left))
 
         # we calculated valid dimensions -> success!
         assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \

From 43769529c219e7d82f4f94be4fc9211228d474a3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 17 Jan 2012 15:33:47 +0100
Subject: [PATCH 0580/1541] prepare 'get_neighbor_surfaces' to only return
 surfaces that can be 'seen' from the 'base_structure'. The base_structure is
 here the surface where the current particle(s) are located.

---
 egfrd.py          |  2 +-
 shellcontainer.py |  9 ++++++++-
 shells.py         | 34 +++++++++++++++++-----------------
 single.py         |  6 +++---
 4 files changed, 29 insertions(+), 22 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d48c1cc0..9906d1e0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1165,7 +1165,7 @@ def make_new_domain(self, single):
         # Get also surfaces but only if the particle is in 3D
         surface_distances = []
 #        if isinstance(single, SphericalSingle):
-        surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, ignores=[single.structure.id])
+        surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
 
 
         # Check if there are shells with the burst radius (reaction_threshold)
diff --git a/shellcontainer.py b/shellcontainer.py
index f583bf37..b033c8ef 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -170,8 +170,14 @@ def filter_partners(self, neighbor_domains):
     def sort_domain_distance(self, neighbor_domains):
         return sorted(neighbor_domains, key=lambda domain_dist: domain_dist[1])
 
-    def get_neighbor_surfaces(self, position, ignores=[]):
+    def get_neighbor_surfaces(self, position, base_structure_id, ignores=[]):
         # analogous to get_neighbor domains, this returns a list of (surface, distance) tuples
+        # The base_structure_id argument is the id of the structure on which the particle lives
+        # calling this function. In the future, this function will only return surfaces a particle
+        # living on the base_structure can have interactions with.
+
+        # We assume a particle can't have an interaction with the same surface on/in which it lives.
+        ignores.append( base_structure_id )
 
         # TODO return a list of neighboring surfaces
         surface, distance = get_closest_surface(self.world, position, ignores)
@@ -180,6 +186,7 @@ def get_neighbor_surfaces(self, position, ignores=[]):
         else:
             return []
 
+
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # Get neighbor domains within given radius.
         # Note that the function returns a generator
diff --git a/shells.py b/shells.py
index 40497556..c04a4f39 100755
--- a/shells.py
+++ b/shells.py
@@ -714,14 +714,14 @@ def __init__(self, geometrycontainer, domains):
         self.world = geometrycontainer.world
         self.domains = domains
 
-    def get_neighbors(self, ignore, ignores):
+    def get_neighbors(self, base_structure_id, ignore, ignores):
         # The get_neighbors is general to all types of testShells.
         # It finds the neighboring domains and surfaces.
         searchpoint = self.get_searchpoint()
         radius = self.get_searchradius()
 
         neighbor_domains  = self.geometrycontainer.get_neighbor_domains(searchpoint, self.domains, ignore)
-        neighbor_surfaces = self.geometrycontainer.get_neighbor_surfaces(searchpoint, ignores)
+        neighbor_surfaces = self.geometrycontainer.get_neighbor_surfaces(searchpoint, base_structure_id, ignores)
         return neighbor_domains, neighbor_surfaces
 
     def get_orientation_vector(self):
@@ -738,11 +738,11 @@ def __init__(self, geometrycontainer, domains):
         self.center = None          # These are the parameters that define the dimensions of
         self.radius = 0             # the spherical shell -> will be determined later.
 
-    def determine_possible_shell(self, ignore, ignores):
+    def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # This determines the largest possible radius of the spherical testShell or throws an
         # exception if the domain could not be made due to geometrical constraints.
 
-        neighbor_domains, neighbor_surfaces = self.get_neighbors (ignore, ignores)
+        neighbor_domains, neighbor_surfaces = self.get_neighbors (base_structure_id, ignore, ignores)
         min_radius = self.apply_safety(self.get_min_radius())
         max_radius = self.get_max_radius()
 
@@ -828,8 +828,8 @@ def __init__(self, single1, single2, geometrycontainer, domains):
 
         self.center = self.com
         try:
-            self.radius = self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
-                                                        [self.structure.id])
+            self.radius = self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
+                                                        [])
         except ShellmakingError as e:
             raise testShellError('(SphericalPair). %s' %
                                  (str(e)))
@@ -857,11 +857,11 @@ def __init__(self, geometrycontainer, domains):
         #   on the side oposite of the 'orientation vector'.
 
 
-    def determine_possible_shell(self, ignore, ignores):
+    def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # This determines the maximum dr, dz_right, dz_left of the cylindrical testShell or
         # throws an exception if the domain could not be made due to geometrical constraints.
 
-        neighbor_domains, neighbor_surfaces = self.get_neighbors (ignore, ignores)
+        neighbor_domains, neighbor_surfaces = self.get_neighbors (base_structure_id, ignore, ignores)
         min_dr, min_dz_right, min_dz_left = self.get_min_dr_dzright_dzleft()
         max_dr, max_dz_right, max_dz_left = self.get_max_dr_dzright_dzleft()
 
@@ -1075,8 +1075,8 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
-                                                          [self.structure.id])
+                            self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
+                                                          [])
         except ShellmakingError as e:
             raise testShellError('(PlanarSurfacePair). %s' %
                                  (str(e)))
@@ -1176,8 +1176,8 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
-                                                          [self.structure.id])
+                            self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
+                                                          [])
         except ShellmakingError as e:
             raise testShellError('(CylindricalSurfacePair). %s' %
                                  (str(e)))
@@ -1228,7 +1228,7 @@ def __init__(self, single, surface, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
+                            self.determine_possible_shell(self.structure.id, [self.single.domain_id], [self.surface.id])
         except ShellmakingError as e:
             raise testShellError('(PlanarSurfaceInteration). %s' %
                                  (str(e)))
@@ -1284,7 +1284,7 @@ def __init__(self, single, surface, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
+                            self.determine_possible_shell(self.structure.id, [self.single.domain_id], [self.surface.id])
         except ShellmakingError as e:
             raise testShellError('(CylindricalSurfaceInteraction). %s' %
                                  (str(e)))
@@ -1337,7 +1337,7 @@ def __init__(self, single, surface, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell([self.single.domain_id], [self.structure.id, self.surface.id])
+                            self.determine_possible_shell(self.structure.id, [self.single.domain_id], [self.surface.id])
         except ShellmakingError as e:
             raise testShellError('(CylindricalSurfaceSink). %s' %
                                  (str(e)))
@@ -1409,8 +1409,8 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell([self.single1.domain_id, self.single2.domain_id],
-                                                          [self.structure.id, self.surface.id])
+                            self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
+                                                          [self.surface.id])
         except ShellmakingError as e:
             raise testShellError('(MixedPair2D3D). %s' %
                                  (str(e)))
diff --git a/single.py b/single.py
index 96618bf0..6d0aff7d 100644
--- a/single.py
+++ b/single.py
@@ -294,7 +294,7 @@ def shell_list_for_other(self):
     def create_updated_shell(self, position):
         # TODO what should we do with the position now?
         try:
-            radius = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            radius = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])
             return self.create_new_shell(position, radius, self.domain_id)
 
         except ShellmakingError as e:
@@ -364,7 +364,7 @@ def shell_list_for_other(self):
     def create_updated_shell(self, position):
         # TODO what should we do with the position now?
         try:
-            dr, dz_right, dz_left = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            dr, dz_right, dz_left = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])
             center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
                                                                              self.testShell.get_orientation_vector(),
                                                                              dr, dz_right, dz_left)            
@@ -445,7 +445,7 @@ def create_updated_shell(self, position):
         # TODO what should we do with the position now?
         # maybe update the reference_point of the shell before updating the shell
         try:
-            dr, dz_right, dz_left = self.testShell.determine_possible_shell([self.domain_id], [self.structure.id])
+            dr, dz_right, dz_left = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])
             dz_right = min(dz_right, dz_left)       # make sure the domain is symmetric around the particle
             dz_left  = dz_right                     # This is not necessary but it's assumed later
             center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),

From 0dff7fc972198476ac62f7e153c025b98243a01f Mon Sep 17 00:00:00 2001
From: Joris Paijmans <paijmans@bionet3.amolf.nl>
Date: Tue, 17 Jan 2012 15:39:13 +0100
Subject: [PATCH 0581/1541] Changed LD_MAX in pair.py to infinity for Spherical
 Pair Domains.

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 18b2dde7..12159622 100644
--- a/pair.py
+++ b/pair.py
@@ -452,7 +452,7 @@ class SphericalPair(SimplePair):
     def __init__(self, domain_id, shell_center, single1, single2, shell_id,
                  r0, shell_size, rrs, structure):
 
-        self.LD_MAX = 20
+        self.LD_MAX = numpy.inf
         SimplePair.__init__(self, domain_id, shell_center, single1, single2, shell_id,
                       r0, shell_size, rrs, structure)
 

From 6cebcca3472fb1db8406d1c8cab16b807f0101c9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 17 Jan 2012 16:51:14 +0100
Subject: [PATCH 0582/1541] finally implemented the drift correctly for
 CylindricalSurfaceSingle

---
 single.py | 35 ++++++++++++++++++++++++++---------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/single.py b/single.py
index 6d0aff7d..353bed68 100644
--- a/single.py
+++ b/single.py
@@ -122,7 +122,7 @@ def draw_escape_time_tuple(self):
         else:
             dt = draw_time_wrapper(self.greens_function())
 
-        event_type = EventType.SINGLE_ESCAPE    # TODO Event is not an ESCAPE when in 1D there is drift
+        event_type = EventType.SINGLE_ESCAPE
         return dt, event_type
 
     def check(self):
@@ -183,8 +183,6 @@ def draw_new_position(self, dt, event_type):
             # idea, because then you'd draw an unused random number.  
             # The same yields for the draw_new_com and draw_new_iv.  
 
-            # TODO Either include check for non-zero drift here, or overload
-            # this method in CylindricalSurfaceSingle to check exit interface
                 r = self.get_inner_a()
             else:
                 gf = self.greens_function()
@@ -456,14 +454,33 @@ def create_updated_shell(self, position):
             raise Exception('CylindricalSurfaceSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, z):
-        if feq(z, self.get_inner_a()):
-            # Escape, can be either to the left or to the right.
-            # The side of escape should be decided on by the flux through
-            # both boundaries at the escape time
-            # TODO, include drift
+        # 'z' can be interpreted in two different ways here, it may a coordinate in the z direction or it may
+        # be a displacement from the origin. In the first case it will already contain the drift information.
+        if self.v == 0.0:
+            # if there is no drift then we regard 'z' as a displacement from the origin. Although
+            # it actually represents a coordinate when drawR was called. It is a displacement when z=a.
+            # We randomize the direction.
             z = myrandom.choice(-1, 1) * z 
 
-        # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
+        if self.v != 0.0 and feq(z, self.get_inner_a()):
+            # When there is drift and z=a, the 'z' actually represent the displacement from the origin and a
+            # boundary must be chosen.
+
+            # The Escape can be either to the left or to the right.
+            # The side of escape should be decided on by the flux through both boundaries at the escape time
+            gf = self.greens_function()
+            event_kind = draw_event_type_wrapper(gf, self.dt)
+            if event_kind == PairEventKind.IV_REACTION:     # IV_REACTION -> ESCAPE through 'left' boundary
+                z = -z
+            elif event_kind == PairEventKind.IV_ESCAPE:     # IV_ESCAPE -> ESCAPE through 'right' boundary
+                #z = z
+                pass 
+            raise NotImplemented()
+        else:
+            # When there was drift and the particle was not at the boundary.
+            # -> In this case the 'z' actually signifies a coordinate and nothing has to be done.
+            pass
+
         return z * self.shell.shape.unit_z
 
     def __str__(self):

From 4331e1be5a72413607347b381eddd22f8b2dd6d8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 18 Jan 2012 15:44:08 +0100
Subject: [PATCH 0583/1541] Finallized imlementation of drift for 1D diffusing
 particle.

---
 binding/Particle.hpp | 14 ++++++++------
 egfrd.py             |  1 +
 pair.py              | 46 ++++++++++++++++++++++++++++++++++++++++----
 shells.py            |  2 +-
 single.py            |  7 ++++---
 5 files changed, 56 insertions(+), 14 deletions(-)

diff --git a/binding/Particle.hpp b/binding/Particle.hpp
index dfc07ef7..ec086566 100644
--- a/binding/Particle.hpp
+++ b/binding/Particle.hpp
@@ -101,10 +101,10 @@ class ParticleWrapper
         switch (PyTuple_Size(arg))
         {
         default:
-            PyErr_SetString(PyExc_TypeError, "the number of arguments must be either 0 or 4");
+            PyErr_SetString(PyExc_TypeError, "the number of arguments must be either 0 or 5");
             return NULL;
 
-        case 4:
+        case 5:
             retval = create();
             if (set_position(reinterpret_cast<ParticleWrapper*>(retval), 
                         PyTuple_GetItem(arg, 0), 0)
@@ -112,8 +112,10 @@ class ParticleWrapper
                         PyTuple_GetItem(arg, 1), 0)
                 || set_D(reinterpret_cast<ParticleWrapper*>(retval), 
                         PyTuple_GetItem(arg, 2), 0)
+                || set_v(reinterpret_cast<ParticleWrapper*>(retval), 
+                        PyTuple_GetItem(arg, 3), 0)
                 || set_sid(reinterpret_cast<ParticleWrapper*>(retval), 
-                        PyTuple_GetItem(arg, 3), 0))
+                        PyTuple_GetItem(arg, 4), 0))
             {
                 ParticleWrapper::operator delete(retval);
                 return NULL;
@@ -301,7 +303,7 @@ class ParticleWrapper
 
     static Py_ssize_t __sq_len__(PyObject *self)
     {
-        return 4;
+        return 5;           // I think this is the number of elements (and not the max index)
     }
 
     static PyObject* __sq_item__(PyObject *self, Py_ssize_t idx)
@@ -320,7 +322,7 @@ class ParticleWrapper
             return get_radius(reinterpret_cast<ParticleWrapper*>(self));
         case 2:
             return get_D(reinterpret_cast<ParticleWrapper*>(self));
-	case 3:
+    	case 3:
             return get_v(reinterpret_cast<ParticleWrapper*>(self));
         case 4:
             return get_sid(reinterpret_cast<ParticleWrapper*>(self));
@@ -344,7 +346,7 @@ class ParticleWrapper
             return set_radius(reinterpret_cast<ParticleWrapper*>(self), val, 0);
         case 2:
             return set_D(reinterpret_cast<ParticleWrapper*>(self), val, 0);
-	case 3:
+	    case 3:
             return set_v(reinterpret_cast<ParticleWrapper*>(self), val, 0);
         case 4:
             return set_sid(reinterpret_cast<ParticleWrapper*>(self), val, 0);
diff --git a/egfrd.py b/egfrd.py
index 9906d1e0..4faefc6f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -561,6 +561,7 @@ def move_particle(self, pid_particle_pair, position):
                                  Particle(position,
                                           pid_particle_pair[1].radius,
                                           pid_particle_pair[1].D,
+                                          pid_particle_pair[1].v,
                                           pid_particle_pair[1].sid))
 
         self.world.update_particle(new_pid_particle_pair)
diff --git a/pair.py b/pair.py
index d7ec43c3..be65d0ce 100644
--- a/pair.py
+++ b/pair.py
@@ -501,14 +501,24 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         hasCylindricalShell.__init__(self, testShell, domain_id)
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
+
+    def get_shell_size(self):
+        return self.shell.shape.half_length
+
     def get_v_tot(self):
-        return self.pid_particle_pair2[1].v - \
-               self.pid_particle_pair1[1].v
+        # 'direction' signifies the direction of the IV with respect to the surface unit_z
+        # (which defines the direction of positive drift)
+        direction = cmp(numpy.dot (self.iv, self.structure.shape.unit_z), 0)
+        return (self.pid_particle_pair2[1].v - \
+                self.pid_particle_pair1[1].v) * direction
+
+    # NOTE the v_tot and v_r are now positive in the direction of the IV!
     v_tot = property(get_v_tot)
     
     v_r = property(get_v_tot)
 
     def get_v_R(self):
+        # The v_R is always in the direction of the structure, no adjustment required.
         return (self.pid_particle_pair1[1].v * 
                 self.pid_particle_pair2[1].D +
                 self.pid_particle_pair2[1].v *
@@ -526,9 +536,37 @@ def choose_pair_greens_function(self, r0, t):
         # Todo
         return self.iv_greens_function(r0)
 
-    def create_com_vector(self, r):
+    def create_com_vector(self, z):
+        # 'z' can be interpreted in two different ways here, it may a coordinate in the z direction or it may
+        # be a displacement from the origin. In the first case it will already contain the drift information.
+        if self.v_R == 0.0:
+            # if there is no drift then we regard 'z' as a displacement from the origin. Although
+            # it actually represents a coordinate when drawR was called. It is a displacement when z=a.
+            # We randomize the direction.
+            z = myrandom.choice(-1, 1) * z
+
+        elif self.v_R != 0.0 and feq(z, self.a_R):
+            # When there is drift and z=a, the 'z' actually represent the displacement from the origin and a
+            # boundary must be chosen.
+
+            # The Escape can be either to the left or to the right.
+            # The side of escape should be decided on by the flux through both boundaries at the escape time
+            gf = self.com_greens_function()
+            event_kind = draw_event_type_wrapper(gf, self.dt)
+            if event_kind == PairEventKind.IV_REACTION:     # IV_REACTION -> ESCAPE through 'left' boundary
+                z = -z      # -self.a_R
+            elif event_kind == PairEventKind.IV_ESCAPE:     # IV_ESCAPE -> ESCAPE through 'right' boundary
+                #z = z      # self.a_R
+                pass
+            else:
+                raise NotImplemented()
+        else:
+            # When there was drift and the particle was not at the boundary.
+            # -> In this case the 'z' actually signifies a coordinate and nothing has to be done.
+            pass
+
         # project the com onto the surface unit vector to make sure that the coordinates are in the surface
-        return r * self.structure.shape.unit_z
+        return z * self.structure.shape.unit_z
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
         if __debug__:
diff --git a/shells.py b/shells.py
index c04a4f39..d1d8a239 100755
--- a/shells.py
+++ b/shells.py
@@ -183,7 +183,7 @@ def __init__(self, single1, single2):
         self.single2 = single2
         self.pid_particle_pair1 = single1.pid_particle_pair
         self.pid_particle_pair2 = single2.pid_particle_pair
-        self.com, self.iv = self.do_transform()
+        self.com, self.iv = self.do_transform()         # NOTE The IV always points from particle1 to particle2
         self.r0 = length(self.iv)
         if self.r0 < self.sigma:
             raise protoDomainError('distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
diff --git a/single.py b/single.py
index 353bed68..8338fa25 100644
--- a/single.py
+++ b/single.py
@@ -462,7 +462,7 @@ def create_position_vector(self, z):
             # We randomize the direction.
             z = myrandom.choice(-1, 1) * z 
 
-        if self.v != 0.0 and feq(z, self.get_inner_a()):
+        elif self.v != 0.0 and feq(z, self.get_inner_a()):
             # When there is drift and z=a, the 'z' actually represent the displacement from the origin and a
             # boundary must be chosen.
 
@@ -475,13 +475,14 @@ def create_position_vector(self, z):
             elif event_kind == PairEventKind.IV_ESCAPE:     # IV_ESCAPE -> ESCAPE through 'right' boundary
                 #z = z
                 pass 
-            raise NotImplemented()
+            else:
+                raise NotImplemented()
         else:
             # When there was drift and the particle was not at the boundary.
             # -> In this case the 'z' actually signifies a coordinate and nothing has to be done.
             pass
 
-        return z * self.shell.shape.unit_z
+        return z * self.structure.shape.unit_z
 
     def __str__(self):
         return 'CylindricalSurface' + Single.__str__(self)

From 352441ba3bd1db9b498dc10c0031fd92bb27728b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 19 Jan 2012 15:17:15 +0100
Subject: [PATCH 0584/1541] Fixed error: when stopping the simulator we burst
 all domains in scheduler but bursting also adds new events to scheduler. ->
 solved first making copy of burstable domains and by bursting domains in
 'domains' not scheduler

---
 egfrd.py | 48 ++++++++++++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 20 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4faefc6f..016cb900 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -319,24 +319,26 @@ def stop(self, t):
 
         non_single_list = []
 
+        # Burst all the domains that we know of.
         # first burst all Singles, and put Pairs and Multis in a list.
-        for id, event in self.scheduler:
-            obj = self.domains[event.data]
-            if isinstance(obj, Pair) or isinstance(obj, Multi):
-                non_single_list.append(obj)
-            elif isinstance(obj, Single):
+#        for id, event in self.scheduler:
+        for _, domain in self.domains.items():
+#            obj = self.domains[event.data]
+            if isinstance(domain, Pair) or isinstance(domain, Multi):
+                non_single_list.append(domain)
+            elif isinstance(domain, Single):
                 if __debug__:
                     log.debug('burst %s, last_time= %s' % 
-                              (obj, FORMAT_DOUBLE % obj.last_time))
-                self.burst_single(obj)
+                              (domain, FORMAT_DOUBLE % domain.last_time))
+                self.burst_single(domain)
             else:
-                assert False, 'object from scheduler was no Single, Pair or Multi'
+                assert False, 'domain from domains{} was no Single, Pair or Multi'
 
 
         # then burst all Pairs and Multis.
         if __debug__:
             log.debug('burst %s' % non_single_list)
-        self.burst_objs(non_single_list)
+        self.burst_domains(non_single_list)
 
         self.dt = 0.0
 
@@ -616,11 +618,12 @@ def burst_domain(self, domain):
         elif isinstance(domain, Pair):  # Pair
             bursted = self.burst_pair(domain)
         else:  # Multi
-#            bursted = self.burst_multi(domain)
-            bursted = self.break_up_multi(domain)       # Multi's can't really be 'bursted' since the
+            assert isinstance(domain, Multi)
+            bursted = self.burst_multi(domain)
+#            bursted = self.break_up_multi(domain)       # Multi's can't really be 'bursted' since the
                                                         # positions of the particles are known. They
                                                         # are broken up to singles with a dt=0 shell instead.
-            self.remove_event(domain)
+#            self.remove_event(domain)
 
         if __debug__:
             # After a burst, InteractionSingles should be gone.
@@ -629,7 +632,7 @@ def burst_domain(self, domain):
 
         return bursted
 
-    def burst_objs(self, domains):
+    def burst_domains(self, domains):
     # bursts all the domains that are in the list 'domains'
         bursted = []
         for domain in domains:
@@ -656,7 +659,7 @@ def burst_volume(self, pos, radius, ignore=[]):
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius,
                                                                                ignore)
         neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
-        return self.burst_objs(neighbors)
+        return self.burst_domains(neighbors)
 
     def burst_non_multis(self, domain_distances, burstradius):
         # Bursts the domains in 'domains' if within burstradius
@@ -1382,6 +1385,8 @@ def process_single_event(self, single):
     # Note that this method is also called when a single is bursted. This event in that
     # case is just a BURST event.
 
+        # TODO assert that there is no event associated with this domain in the scheduler
+
         ### log Single event
         if __debug__:
             log.info('FIRE SINGLE: %s' % single.event_type)
@@ -1495,6 +1500,7 @@ def process_pair_event(self, pair):
         assert self.check_domain(pair)
         assert pair.single1.domain_id not in self.domains
         assert pair.single2.domain_id not in self.domains
+        # TODO assert that there is no event associated with this domain in the scheduler
 
         # check that the event time of the single (last_time + dt) is equal to the
         # simulator time
@@ -1694,12 +1700,14 @@ def break_up_multi(self, multi):
         self.remove_domain(multi)
         return singles
 
-#    def burst_multi(self, multi):
-#        #multi.sim.sync()
-#        assert isinstance(multi, Multi)
-#        singles = self.break_up_multi(multi)
-#
-#        return singles
+    def burst_multi(self, multi):
+        #multi.sim.sync()
+        self.remove_event(multi)        # The old event was still in the scheduler
+
+        newsingles = self.break_up_multi(multi)
+        # Note that the multi domain is here also removed from 'domains'
+
+        return newsingles
 
     def burst_single(self, single):
         # Sets next event time of 'single' to current time and event to burst event

From c086cefe84a3de9cb2d20b38f5bd7f487a7d685b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Jan 2012 11:28:41 +0100
Subject: [PATCH 0585/1541] Multiple changes: Changed application of safety
 margins such that it is only applied at the end of the shell making routine,
 not during. -> This should fix most numerical problems with shells. Made sure
 that MixedPair2D3D shell always obeys the scaling laws (also when it is the
 maximal shell) -> Really important! Added comments

---
 shells.py | 125 +++++++++++++++++++++++++++++-------------------------
 1 file changed, 68 insertions(+), 57 deletions(-)

diff --git a/shells.py b/shells.py
index d1d8a239..d04f3721 100755
--- a/shells.py
+++ b/shells.py
@@ -454,7 +454,7 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
     ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
     ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
-    ref_to_shell_r = length(ref_to_shell_r_vec)
+    ref_to_shell_r = length(ref_to_shell_r_vec)     # FIXME length does work well when ref_to_shell_r_vec = null vector
     ref_to_shell_z = ref_to_shell_z * direction
 
     # calculate the distances in r/z from the scaling center to the shell
@@ -747,14 +747,13 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         max_radius = self.get_max_radius()
 
         # initialize the radius to start the scaling of the sphere
-        radius = self.apply_safety(max_radius)
+        radius = max_radius
 
         # first check the maximum radius against the surfaces
         for surface, distance in neighbor_surfaces:
             # FIXME ugly hack to make spherical singles overlap with membranes
             if isinstance(surface, PlanarSurface) and isinstance(self, SphericalSingletestShell):
                 distance += self.pid_particle_pair[1].radius
-            distance = self.apply_safety(distance)
             radius = min(radius, distance)
             if radius < min_radius:
                 raise ShellmakingError('Surface too close to make spherical testshell, '
@@ -770,22 +769,20 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
                 if isinstance(shell_appearance.shape, Sphere):
-                    radius_new = get_radius_to_SphericalShape(shell_appearance.shape, self, radius)
+                    radius = get_radius_to_SphericalShape(shell_appearance.shape, self, radius)
                 elif isinstance(shell_appearance.shape, Cylinder):
-                    radius_new = get_radius_to_CylindricalShape(shell_appearance.shape, self, radius)
+                    radius = get_radius_to_CylindricalShape(shell_appearance.shape, self, radius)
 
-                if radius_new != radius:
-                    # A new (smaller) radius was found
-                    radius = self.apply_safety(radius_new)
-                    if radius < min_radius:
-                        raise ShellmakingError('Domain too close to make spherical testshell, '
-                                               'domain = %s, radius = %s, min_radius = %s, testShell = %s' %
-                                               (neighbor, radius, min_radius, self))
+                if radius < min_radius:
+                    raise ShellmakingError('Domain too close to make spherical testshell, '
+                                           'domain = %s, radius = %s, min_radius = %s, testShell = %s' %
+                                           (neighbor, radius, min_radius, self))
 
         # we calculated a valid radius -> suscess!
         assert radius >= min_radius, 'SphericaltestShell radius smaller than the minimum, radius = %s, min_radius = %s.' % \
                                      (radius, min_radius)
 
+        radius = self.apply_safety(radius)
         return radius
 
     def get_searchpoint(self):
@@ -867,28 +864,25 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
 
         # initialize the parameters to start the scaling of the cylinder
         min_dr, min_dz_right, min_dz_left = self.apply_safety(min_dr, min_dz_right, min_dz_left)
-        dr, dz_right, dz_left             = self.apply_safety(max_dr, max_dz_right, max_dz_left)
-
+        dr, dz_right, dz_left             = max_dr, max_dz_right, max_dz_left
+ 
         # first check the maximum dr, dz_right, dz_left against the surfaces
         # NOTE: we assume that all relevant surfaces are cylindrical and parallel to the testCylinder
         for surface, distance in neighbor_surfaces:
             # TODO
             if isinstance(surface, CylindricalSurface):
-                dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_CylindricalShape(surface.shape, self,
+                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_CylindricalShape(surface.shape, self,
                                                                                               dr, dz_right, dz_left)
             elif isinstance(surface, PlanarSurface):
-                dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_PlanarShape(surface.shape, self,
+                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_PlanarShape(surface.shape, self,
                                                                                          dr, dz_right, dz_left)
             else:
                 assert False, "Wrong type of surface used"
 
-            if (dr_new != dr) or (dz_right_new != dz_right) or (dz_left_new != dz_left):
-                # The dimensions were changed, reapply the safety margin
-                dr, dz_right, dz_left = self.apply_safety(dr_new, dz_right_new, dz_left_new)
-                if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
-                    raise ShellmakingError('Surface too close to make cylindrical testshell, '
-                                           'surface = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
-                                           (surface, dr, dz_right, dz_left, self))
+            if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
+                raise ShellmakingError('Surface too close to make cylindrical testshell, '
+                                       'surface = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
+                                       (surface, dr, dz_right, dz_left, self))
 
         # TODO first sort the neighbors to distance -> faster to find if we fail
 
@@ -899,21 +893,18 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
                 if isinstance(shell_appearance.shape, Sphere):
-                    dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self,
+                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self,
                                                                                                 dr, dz_right, dz_left)
                 elif isinstance(shell_appearance.shape, Cylinder):
-                    dr_new, dz_right_new, dz_left_new = get_dr_dzright_dzleft_to_CylindricalShape(shell_appearance.shape, self,
+                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_CylindricalShape(shell_appearance.shape, self,
                                                                                                   dr, dz_right, dz_left)
                 else:
                     assert False, "Wrong type of shell shape"
 
-                if (dr_new != dr) or (dz_right_new != dz_right) or (dz_left_new != dz_left):
-                    # The dimensions were changed, reapply the safety margin
-                    dr, dz_right, dz_left = self.apply_safety(dr_new, dz_right_new, dz_left_new)
-                    if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
-                        raise ShellmakingError('Domain too close to make cylindrical testshell, '
-                                               'domain = %s, dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
-                                               (neighbor, dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left))
+                if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
+                    raise ShellmakingError('Domain too close to make cylindrical testshell, '
+                                           'domain = %s, dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
+                                           (neighbor, dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left))
 
         # we calculated valid dimensions -> success!
         assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
@@ -921,6 +912,9 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
                 dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
                (dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left)
 
+        # Note that dr, dz_right, dz_left can now actually be smaller than the minimum
+        dr, dz_right, dz_left = self.apply_safety(dr, dz_right, dz_left)
+
         return dr, dz_right, dz_left
 
     def get_searchpoint(self):
@@ -997,9 +991,18 @@ def get_min_dr_dzright_dzleft(self):
         # This defines the minimal dimensions in terms of r, z_right, z_left of the cylindrical domain
         # that we're trying to make. The exact values vary between type of domain.
         # If a nearby domain would make it smaller than this, an exception will be thrown.
+
+        # NOTE the minimum domain also needs to obey the scaling rules or it might be scaled down to a size
+        # smaller than the minimum
         pass
 
     def get_max_dr_dzright_dzleft(self):
+        # This defines the maximal dimensions in terms of r, z_right, z_left of the cylindrical domain.
+        # The cylindrical domain needs to fit inside the search_radius (centered around the search_point)
+        # because 'it doesn't know what is outside of the searchradius'.
+
+        # NOTE also that the maximum cylinder needs to obey the scaling rules or it might be scaled up to
+        # a size larger than the search_radius.
         pass
 
 #####
@@ -1255,8 +1258,8 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved
         dr       = (self.get_searchradius()/math.sqrt(2))
-        dz_right = dr + self.particle_surface_distance
-        dz_left  = self.pid_particle_pair[1].radius
+        dz_right = dr + self.particle_surface_distance          # Note that we assume that dr >> particle_surface_distance
+        dz_left  = self.pid_particle_pair[1].radius             # so that the cylinder always fits inside the search_radius
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1384,6 +1387,7 @@ class MixedPair2D3DtestShell(CylindricaltestShell, testMixedPair2D3D):
     def __init__(self, single2D, single3D, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         # The initialization of r0 can fail in testPair.__init__
+
         try:
             testMixedPair2D3D.__init__(self, single2D, single3D)
         except protoDomainError as e:
@@ -1398,7 +1402,7 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
                                                                               self.pid_particle_pair2[1].D/self.D_tot ))
         self.dzdr_right = 1.0/self.drdz_right
         self.r0_right   = 0.0
-        self.z0_right   = self.z_right(self.r0_right)
+        self.z0_right   = self.z_right2(self.r0_right)
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
@@ -1429,6 +1433,9 @@ def get_referencepoint(self):
         return self.com
 
     def get_min_dr_dzright_dzleft(self):
+        # defines the minimum parameters of the testShell.
+        # Note that also the minimum testShell must obey the scaling rules
+
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
         D_1 = self.pid_particle_pair1[1].D
@@ -1465,14 +1472,18 @@ def get_min_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        # TODO this can be improved, now the shell same height as diameter
+        # TODO this can be improved
         dr       = self.get_searchradius()/math.sqrt(2)
         dz_left  = self.pid_particle_pair1[1].radius
-        dz_right = (dr * 2 - dz_left)
+
+        # now adjust dz_right such that they obey the scaling laws and are still with the search_radius
+        # We assume that dz_right needs to be adjusted to dr and not the other way around since the cylinder is
+        # always a bit flatter.
+        dz_right = self.z_right(dr)
 
         return dr, dz_right, dz_left
 
-    def z_right(self, r_right):
+    def z_right2(self, r_right):
         # if the radius is known and we want to determine the height z_right
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
@@ -1487,25 +1498,25 @@ def z_right(self, r_right):
 
         return (a_r/self.get_scaling_factor()) + radius2
 
-    def r_right(self, z_right):
-        # if the z_right is known and we want to know the radius r
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
-
-        # we first calculate the a_r, since it is the only radius that depends on z_right only.
-        a_r = (z_right - radius2) * self.get_scaling_factor()
-
-        # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
-        # Note that for the IV we only take the distance to the outer boundary into account.
-        a_R = (a_r - self.r0)*self.sqrt_DRDr
-
-        # We calculate the maximum space needed for particles A and B based on maximum IV displacement
-        iv_max = max( (D_1/self.D_tot * a_r + radius1),
-                      (D_2/self.D_tot * a_r + radius2))
-
-        return a_R + iv_max
+#    def r_right(self, z_right):
+#        # if the z_right is known and we want to know the radius r
+#        radius1 = self.pid_particle_pair1[1].radius
+#        radius2 = self.pid_particle_pair2[1].radius
+#        D_1 = self.pid_particle_pair1[1].D
+#        D_2 = self.pid_particle_pair2[1].D
+#
+#        # we first calculate the a_r, since it is the only radius that depends on z_right only.
+#        a_r = (z_right - radius2) * self.get_scaling_factor()
+#
+#        # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
+#        # Note that for the IV we only take the distance to the outer boundary into account.
+#        a_R = (a_r - self.r0)*self.sqrt_DRDr
+#
+#        # We calculate the maximum space needed for particles A and B based on maximum IV displacement
+#        iv_max = max( (D_1/self.D_tot * a_r + radius1),
+#                      (D_2/self.D_tot * a_r + radius2))
+#
+#        return a_R + iv_max
 
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right/SAFETY, z_left

From 301b25ba5f2c0bffc513a605c61368f47d13d58c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Jan 2012 11:32:34 +0100
Subject: [PATCH 0586/1541] Minor fix: Return the unmodified maximal radius
 instead of including SAFETY

---
 shellcontainer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shellcontainer.py b/shellcontainer.py
index b033c8ef..910ff612 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -41,7 +41,7 @@ def get_user_max_shell_size(self):
         return self.user_max_shell_size
 
     def get_max_shell_size(self):
-        return min(self.get_matrix_cell_size() * .5 / SAFETY,
+        return min(self.get_matrix_cell_size() * .5,
                    self.user_max_shell_size)
 
     def get_container(self, shell):

From b6074b1841dde73c1fca058d32f7f3c300e75743 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Jan 2012 12:06:01 +0100
Subject: [PATCH 0587/1541] LD_MAX should defined before calling
 SimplePair.__init__ (here the determine_radii is called)

---
 pair.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pair.py b/pair.py
index 266c24a9..a5a572a1 100644
--- a/pair.py
+++ b/pair.py
@@ -312,8 +312,8 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         assert isinstance(testShell, SphericalPairtestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
         self.LD_MAX = numpy.inf
+        SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
 
     def com_greens_function(self):
         # Green's function for centre of mass inside absorbing sphere.
@@ -411,8 +411,8 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         assert isinstance(testShell, PlanarSurfacePairtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
-        SimplePair.__init__(self, domain_id, shell_id, rrs)
         self.LD_MAX = 20
+        SimplePair.__init__(self, domain_id, shell_id, rrs)
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
@@ -501,8 +501,8 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         assert isinstance(testShell, CylindricalSurfacePairtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
-        SimplePair.__init__(self, domain_id, shell_id, rrs)
         self.LD_MAX = numpy.inf
+        SimplePair.__init__(self, domain_id, shell_id, rrs)
 
 
     def get_shell_size(self):

From 074d91d6ca062bb4a89cbdd961e10f2092726ff8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Jan 2012 12:13:01 +0100
Subject: [PATCH 0588/1541] Assume planar surfaces are no problem for now

---
 shells.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index d04f3721..b18d861c 100755
--- a/shells.py
+++ b/shells.py
@@ -683,8 +683,7 @@ def get_radius_to_CylindricalShape(shape, testShell, r):
     return min(r, r_new)
 
 def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
-    assert False
-    pass
+    return r, z_right, z_left
 
 def get_radius_to_PlanarShape(shape, testShell, r):
     # This function returns the radius for the spherical 'testShell' using the planar 'shape' as its closest

From 738f64c29d6f4ac5dbb4386382809f133ca1a715 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 23 Jan 2012 14:11:07 +0100
Subject: [PATCH 0589/1541] lost of stuff to find a bug

---
 shells.py | 109 ++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 68 insertions(+), 41 deletions(-)

diff --git a/shells.py b/shells.py
index b18d861c..8a614a4d 100755
--- a/shells.py
+++ b/shells.py
@@ -1387,6 +1387,8 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         # The initialization of r0 can fail in testPair.__init__
 
+        raise testShellError('(MixedPair2D3D).')
+
         try:
             testMixedPair2D3D.__init__(self, single2D, single3D)
         except protoDomainError as e:
@@ -1397,11 +1399,19 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
 
         # initialize the scaling parameters
-        self.drdz_right = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.pid_particle_pair1[1].D/self.D_tot,
-                                                                              self.pid_particle_pair2[1].D/self.D_tot ))
+        bla = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.pid_particle_pair1[1].D/self.D_tot,
+                                                                  self.pid_particle_pair2[1].D/self.D_tot ))
+        minimum = self.r0+self.pid_particle_pair1[1].radius
+        self.drdz_right = self.r_right(minimum + 1.0) - self.r_right(minimum)
+        assert feq(bla, self.drdz_right), 'bla= %s, drdz_right=%s' % (bla, self.drdz_right)
+
+        bla2 = self.z_right(minimum + 1.0) - self.z_right(minimum)
+
+        minr, minz_right, _ = self.get_min_dr_dzright_dzleft()
         self.dzdr_right = 1.0/self.drdz_right
+        assert feq(self.dzdr_right, bla2), 'bla2= %s, dzdr_right= %s' % (bla2, self.dzdr_right)
         self.r0_right   = 0.0
-        self.z0_right   = self.z_right2(self.r0_right)
+        self.z0_right   = self.z_right(self.r0_right)
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
@@ -1448,26 +1458,29 @@ def get_min_dr_dzright_dzleft(self):
         dr_1 = self.r_right(dz_right1)
 
 
-        ### calculate the minimal radius r2 of the shell including the burst radius
-        # First calculate the minimal size of the iv shell (r0 is at outer boundary)
-        iv_shell_radius1 = self.r0 * D_1 / self.D_tot
-        iv_shell_radius2 = self.r0 * D_2 / self.D_tot
-
-        # fix the minimum shell size for the CoM domain
-        com_shell_radius = max(radius1, radius2)
-
-        # calculate the minimal dimensions of the protective domain including space for the
-        # burst volumes of the particles
-        dr_2 = max(iv_shell_radius1 + com_shell_radius + radius1 * SINGLE_SHELL_FACTOR,
-                   iv_shell_radius2 + com_shell_radius + radius2 * SINGLE_SHELL_FACTOR)
-        dz_right2 = self.z_right(dr_2)
-
-        # of both alternatives pick the largest one. Here we just compare the height, but the
-        # radius scales accordingly.
-        dz_right, dr = max((dz_right1, dr_1),(dz_right2, dr_2))
+#        ### calculate the minimal radius r2 of the shell including the burst radius
+#        # First calculate the minimal size of the iv shell (r0 is at outer boundary)
+#        iv_shell_radius1 = self.r0 * D_1 / self.D_tot
+#        iv_shell_radius2 = self.r0 * D_2 / self.D_tot
+#
+#        # fix the minimum shell size for the CoM domain
+#        com_shell_radius = max(radius1, radius2)
+#
+#        # calculate the minimal dimensions of the protective domain including space for the
+#        # burst volumes of the particles
+#        dr_2 = max(iv_shell_radius1 + com_shell_radius + radius1 * SINGLE_SHELL_FACTOR,
+#                   iv_shell_radius2 + com_shell_radius + radius2 * SINGLE_SHELL_FACTOR)
+#        dz_right2 = self.z_right(dr_2)
+#
+#        # of both alternatives pick the largest one. Here we just compare the height, but the
+#        # radius scales accordingly.
+#        dz_right, dr = max((dz_right1, dr_1),(dz_right2, dr_2))
 
+        dr = dr_1
+        dz_right = dz_right1
 
         dz_left  = self.pid_particle_pair1[1].radius
+#        print "min= ", dr, dz_right, dz_left
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
@@ -1479,10 +1492,12 @@ def get_max_dr_dzright_dzleft(self):
         # We assume that dz_right needs to be adjusted to dr and not the other way around since the cylinder is
         # always a bit flatter.
         dz_right = self.z_right(dr)
+#        print "max= ", dr, dz_right, dz_left
+        assert dr > dz_right
 
         return dr, dz_right, dz_left
 
-    def z_right2(self, r_right):
+    def z_right(self, r_right):
         # if the radius is known and we want to determine the height z_right
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
@@ -1495,27 +1510,39 @@ def z_right2(self, r_right):
         # take the smallest that, if entered in the function for r below, would lead to this z_right
         a_r = min (a_r1, a_r2)
 
-        return (a_r/self.get_scaling_factor()) + radius2
+        z_right = (a_r/self.get_scaling_factor()) + radius2
 
-#    def r_right(self, z_right):
-#        # if the z_right is known and we want to know the radius r
-#        radius1 = self.pid_particle_pair1[1].radius
-#        radius2 = self.pid_particle_pair2[1].radius
-#        D_1 = self.pid_particle_pair1[1].D
-#        D_2 = self.pid_particle_pair2[1].D
-#
-#        # we first calculate the a_r, since it is the only radius that depends on z_right only.
-#        a_r = (z_right - radius2) * self.get_scaling_factor()
-#
-#        # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
-#        # Note that for the IV we only take the distance to the outer boundary into account.
-#        a_R = (a_r - self.r0)*self.sqrt_DRDr
-#
-#        # We calculate the maximum space needed for particles A and B based on maximum IV displacement
-#        iv_max = max( (D_1/self.D_tot * a_r + radius1),
-#                      (D_2/self.D_tot * a_r + radius2))
-#
-#        return a_R + iv_max
+#        assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
+#                                                     r_right= %s, r_right(z_right)=%s ' % \
+#                                                     (r_right, self.r_right(z_right))
+
+        return z_right
+
+    def r_right(self, z_right):
+        # if the z_right is known and we want to know the radius r
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
+
+        # we first calculate the a_r, since it is the only radius that depends on z_right only.
+        a_r = (z_right - radius2) * self.get_scaling_factor()
+
+        # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
+        # Note that for the IV we only take the distance to the outer boundary into account.
+        a_R = (a_r - self.r0)*self.sqrt_DRDr
+
+        # We calculate the maximum space needed for particles A and B based on maximum IV displacement
+        iv_max = max( (D_1/self.D_tot * a_r + radius1),
+                      (D_2/self.D_tot * a_r + radius2))
+
+        r_right = a_R + iv_max
+
+        assert feq(self.z_right(r_right), z_right), 'inconsistent r_right function \
+                                                  z_right= %s, z_right(r_right)=%s ' % \
+                                                  (z_right, self.z_right(r_right))
+
+        return r_right
 
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right/SAFETY, z_left

From 57955e90ef8dfbb0fe8fa5c7795b432fa0441ed8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 23 Jan 2012 14:12:16 +0100
Subject: [PATCH 0590/1541] added some debugging messages

---
 pair.py | 49 +++++++++++++++++++++----------------------------
 1 file changed, 21 insertions(+), 28 deletions(-)

diff --git a/pair.py b/pair.py
index a5a572a1..a97e6470 100644
--- a/pair.py
+++ b/pair.py
@@ -185,11 +185,12 @@ def __str__(self):
         sid2 = self.pid_particle_pair2[1].sid
         name1 = self.world.model.get_species_type_by_id(sid1)["name"]
         name2 = self.world.model.get_species_type_by_id(sid2)["name"]
-        return 'Pair[%s: %s, %s, (%s, %s)]' % (
+        return 'Pair[%s: %s, %s, (%s, %s)] with shell: %s' % (
             self.domain_id,
             self.pid_particle_pair1[0],
             self.pid_particle_pair2[0],
-            name1, name2)
+            name1, name2,
+            self.shell)
 
 class SimplePair(Pair):
 
@@ -617,33 +618,21 @@ def determine_radii(self):
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
+        radius      = self.shell.shape.radius
         half_length = self.shell.shape.half_length
-        radius = self.shell.shape.radius
-
-        # use class methods to check dimensions of the cylinder
-        # note that we assume that only the z_right is scalable
-        r_check   = self.testShell.r_right (half_length*2 - radius1)
-        hl2_check = self.testShell.z_right (radius) + self.testShell.z_left  (radius)
-        if r_check > radius:
-            # radius should have been larger, adjust z_right instead
-            if __debug__:
-                log.debug('MixedPair2D3D: half_length was too high for radius. '
-                          'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
-                          (radius, r_check, half_length*2, hl2_check))
 
-            half_length = hl2_check/2
+        # Use class methods to check dimensions of the cylinder
+        r_check  = self.testShell.r_right (half_length*2 - radius1)
+        hl_check = (self.testShell.z_right (radius) + self.testShell.z_left (radius))/2
+        if __debug__:
+            assert feq(r_check, radius) and feq(hl_check, half_length), \
+                'MixedPair2D3D: Domain did not obey scaling relationship. ' \
+                'radius = %s, half_length = %s, radius_check = %s, half_length_check = %s' % \
+                 (FORMAT_DOUBLE % radius,  FORMAT_DOUBLE % half_length,
+                  FORMAT_DOUBLE % r_check, FORMAT_DOUBLE % hl_check)
 
-        elif hl2_check > (half_length*2):
-            # half_length should have been larger, adjust radius instead
-            if __debug__:
-                log.debug('MixedPair2D3D: radius was too high for half_length. '
-                          'radius = %.3g, r_check = %.3g, 2half_length = %.3g, 2hl_check = %.3g' %
-                          (radius, r_check, half_length*2, hl2_check))
-            radius = r_check
-        else:
-            # dimensions were ok
-            pass
 
+        # Partition the space in the protective domain over the IV and the CoM domains
         z_left  = radius1
         z_right = half_length * 2 - z_left
         a_r = (z_right - radius2) * self.z_scaling_factor
@@ -654,15 +643,19 @@ def determine_radii(self):
         a_R = radius - space_for_iv
 
 
+        # Print the domain sizes and their estimated first passage times.
         if __debug__:
             tr = ((a_r - self.r0)**2) / (6 * self.D_r)  # the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
                 tR = (a_R**2) / (4 * self.D_R)          # the expected escape time of the CoM
-            log.debug('a_r= %s, tr= %s, a_R= %s, tR= %s' % \
+            log.debug('determine_radii: a_r= %s, tr= %s, a_R= %s, tR= %s, delta_tRr= %s' % \
                       (FORMAT_DOUBLE % a_r, FORMAT_DOUBLE % tr,
-                       FORMAT_DOUBLE % a_R, FORMAT_DOUBLE % tR))
+                       FORMAT_DOUBLE % a_R, FORMAT_DOUBLE % tR,
+                       FORMAT_DOUBLE % (tr-tR) ))
+
+#        assert feq(tr, tR), 'estimate first passage times were not equal'
 
         assert (self.sigma < a_r) and (a_r < half_length*2)
         assert (0 < a_R) and (a_R < radius)
@@ -760,7 +753,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
         return new_iv
 
     def __str__(self):
-        return 'Mixed' + Pair.__str__(self)
+        return 'Mixed2D3D' + Pair.__str__(self)
 
 class MixedPair1D3D(Pair):
 

From bf2e99073f21384c8ea1be01ed7ede2a0b256cee Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 24 Jan 2012 11:39:15 +0100
Subject: [PATCH 0591/1541] added logging and comments

---
 egfrd.py | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 016cb900..cd591403 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -401,7 +401,6 @@ def step(self):
         # assert if not too many successive dt=0 steps occur.
         if __debug__:
             if self.dt == 0:
-                log.debug('dt=zero step, working in s.t >> dt~0 Python limit.')
                 self.zero_steps += 1
                 # TODO What is best solution here? Usually no prob, -> just let 
                 # user know?
@@ -677,6 +676,8 @@ def burst_non_multis(self, domain_distances, burstradius):
                 # -domain is not a multi
                 # -domain is not zero dt NonInteractionSingle
                 # -domain has time passed
+                log.debug("domain %s bursted. self.t= %s, domain.last_time= %s" % \
+                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
                 single_list = self.burst_domain(domain)
                 single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
                 domain_distances_updated.extend(single_distances)
@@ -686,6 +687,8 @@ def burst_non_multis(self, domain_distances, burstradius):
                 # -domain is a multi
                 # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
                 # -domain is domain in which no time has passed
+                log.debug("domain %s not bursted. self.t= %s, domain.last_time= %s" % \
+                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
                 domain_distances_updated.append((domain, distance))
 
         return domain_distances_updated
@@ -1387,25 +1390,31 @@ def process_single_event(self, single):
 
         # TODO assert that there is no event associated with this domain in the scheduler
 
-        ### log Single event
-        if __debug__:
-            log.info('FIRE SINGLE: %s' % single.event_type)
-            log.info('single = %s' % single)
-
 
         if single.is_reset():
         ### If no event event really happened and just need to make new domain
+            if __debug__:
+                log.info('FIRE SINGLE: make_new_domain()')
+                log.info('single = %s' % single)
             domains = [self.make_new_domain(single)]
             # domain is already scheduled in make_new_domain
 
         ### 1.1 Special cases (shortcuts)
         # In case nothing is scheduled to happen: do nothing and just reschedule
         elif single.dt == numpy.inf:
+            if __debug__:
+                log.info('FIRE SINGLE: Nothing happens-> single.dt=inf')
+                log.info('single = %s' % single)
             self.add_domain_event(single)
             domains = [single]
 
         else:
         ### 1. Process 'normal' event produced by the single
+            ### log Single event
+            if __debug__:
+                log.info('FIRE SINGLE: %s' % single.event_type)
+                log.info('single = %s' % single)
+
 
             if single.event_type != EventType.BURST:
                 # The burst of the domain may be caused by an overlapping domain
@@ -1725,6 +1734,8 @@ def burst_single(self, single):
         # Override event_type. 
         single.dt = self.t - single.last_time
         single.event_type = EventType.BURST
+        # with a burst there is always an associated event in the scheduler.
+        # to simulate the natural occurence of the event we have to remove it from the scheduler
         self.remove_event(single)
 
         newsingles = self.process_single_event(single)
@@ -1746,7 +1757,9 @@ def burst_pair(self, pair):
         # Override event time and event_type. 
         pair.dt = self.t - pair.last_time 
         pair.event_type = EventType.BURST
-        self.remove_event(pair)         # remove the event -> was still in the scheduler
+        # with a burst there is always an associated event in the scheduler.
+        # to simulate the natural occurence of the event we have to remove it from the scheduler
+        self.remove_event(pair)
 
         newsingles = self.process_pair_event(pair)
 

From 9ad5d7708abe36959d0cbb1854b181d25bf101db Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Jan 2012 12:27:07 +0100
Subject: [PATCH 0592/1541] changed the checking code such that it doesn't
 break with only a single particle in the multi

---
 multi.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/multi.py b/multi.py
index 53a4bec1..566acca8 100644
--- a/multi.py
+++ b/multi.py
@@ -151,10 +151,11 @@ def check(self):
             result = self.sphere_container.get_neighbors(shell.shape.position)
             # Check contiguity with nearest neighbor only (get_neighbors 
             # returns a sorted list).
-            nearest = result[1]
-            distance = nearest[1]
-            assert distance - shell.shape.radius < 0.0,\
-                'shells of %s are not contiguous.' % str(self)
+            if len(result) > 1:
+                nearest = result[1]
+                distance = nearest[1]
+                assert distance - shell.shape.radius < 0.0,\
+                    'shells of %s are not contiguous.' % str(self)
 
         # all particles within the shell.
         for pid_particle_pair in self.particle_container:
@@ -163,12 +164,12 @@ def check(self):
 
         main = self.main()
         for shell_id, shell in self.shell_list:
-            container = main.get_container(shell)
+            container = main.geometrycontainer.get_container(shell)
             if not container.contains(shell_id):
                 raise RuntimeError,\
                     'self.sim.main.sphere_container does not contain %s'\
                     % str(shell_id)
-        for shell_id, shell in main.containers[0]:
+        for shell_id, shell in main.geometrycontainer.containers[0]:
             if shell.did == self.domain_id:
                 if not self.sphere_container.contains(shell_id):
                     raise RuntimeError,\

From 0a9757c1876d0cf393d7bce105bf9968308c03ce Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Jan 2012 12:28:44 +0100
Subject: [PATCH 0593/1541] implemented to burst recursively when bursting.
 Also changed check_domain Check_domain needs to allow a cylindrical and
 spherical shell overlap when the shell were produced by a bursted
 MixedPair2D3D domain.

---
 egfrd.py | 58 ++++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 46 insertions(+), 12 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index cd591403..edb9c08f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -37,6 +37,8 @@
     testShellError,
     testPair,
     testInteractionSingle,
+    hasSphericalShell,
+    hasCylindricalShell,
     SphericalSingletestShell,
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
@@ -660,8 +662,8 @@ def burst_volume(self, pos, radius, ignore=[]):
         neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
         return self.burst_domains(neighbors)
 
-    def burst_non_multis(self, domain_distances, burstradius):
-        # Bursts the domains in 'domains' if within burstradius
+    def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
+        # Recursively bursts the domains in 'domains' if within burstradius
         # Returns the updated list of domains with their distances
 
         domain_distances_updated = []
@@ -679,8 +681,21 @@ def burst_non_multis(self, domain_distances, burstradius):
                 log.debug("domain %s bursted. self.t= %s, domain.last_time= %s" % \
                           (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
                 single_list = self.burst_domain(domain)
-                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
-                domain_distances_updated.extend(single_distances)
+#                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
+
+                # Also burst recursively for every single created
+                for single in single_list:
+                    # Add the single itself to the updated neighbors list
+                    domain_distances_updated.append((single, 0))
+                    ignore.append(single.domain_id)
+
+                    # For each single find the neighbors and burst them as well (if necessary/possible)
+                    single_pos = single.pid_particle_pair[1].position
+                    single_radius = single.pid_particle_pair[1].radius
+                    neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore)
+                    neighbor_distances, ignore = self.burst_non_multis(neighbors, single_radius*SINGLE_SHELL_FACTOR, ignore)
+
+                    domain_distances_updated.extend(neighbor_distances)         # TODO remove the duplicates
             else:
                 # Don't burst domain if (OR):
                 # -domain is farther than burst radius
@@ -691,7 +706,10 @@ def burst_non_multis(self, domain_distances, burstradius):
                           (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
                 domain_distances_updated.append((domain, distance))
 
-        return domain_distances_updated
+                if isinstance(domain, NonInteractionSingle) and domain.is_reset():
+                    ignore.append(domain.domain_id)
+
+        return domain_distances_updated, ignore
 
     def fire_single_reaction(self, single, reactant_pos):
         # This takes care of the identity change when a single particle decays into
@@ -1193,7 +1211,17 @@ def make_new_domain(self, single):
         # -shell is burstable (not Multi)
         # -shell is not newly made
         # -shell is not already a zero shell (just bursted)
-        neighbor_distances = self.burst_non_multis(neighbors, reaction_threshold)
+        neighbor_distances, ignore = self.burst_non_multis(neighbors, reaction_threshold, ignore=[single.domain_id, ])
+#        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
+        seen_x = set()
+        new_neighbor_distances = []
+        for x in neighbor_distances:
+            a, b = x
+            if x not in seen_x:
+                seen_x.add(x)
+                if a.domain_id != single.domain_id:
+                    new_neighbor_distances.append(x)
+        neighbor_distances = new_neighbor_distances
 
 
         # We prefer to make NonInteractionSingles for efficiency.
@@ -1952,7 +1980,7 @@ def add_to_multi_recursive(self, domain, multi):
 
             # 2. Burst the domains that interfere with making the multi shell
             burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-            neighbor_distances = self.burst_non_multis(neighbor_distances, burstradius)
+            neighbor_distances, ignore = self.burst_non_multis(neighbor_distances, burstradius, ignore=[])
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
             # shell without overlapping. 
@@ -2155,11 +2183,17 @@ def check_domain(self, domain):
 
             # testing overlap criteria
             for neighbor, _ in neighbors:
-                for _, neighbor_shell in neighbor.shell_list:
-                    overlap = self.check_shell_overlap(shell, neighbor_shell)
-                    assert overlap >= 0.0, \
-                        '%s (%s) overlaps with %s (%s) by %s.' % \
-                        (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
+                # note that the shell of a MixedPair that has have just been bursted can stick into each other.
+                if not (((isinstance(domain, hasCylindricalShell)   and isinstance(domain, NonInteractionSingle)   and domain.is_reset()) and \
+                         (isinstance(neighbor, hasSphericalShell)   and isinstance(neighbor, NonInteractionSingle) and domain.is_reset()) ) or \
+                        ((isinstance(domain, hasSphericalShell)     and isinstance(domain, NonInteractionSingle)   and domain.is_reset()) and \
+                         (isinstance(neighbor, hasCylindricalShell) and isinstance(neighbor, NonInteractionSingle) and domain.is_reset()) )):
+
+                    for _, neighbor_shell in neighbor.shell_list:
+                        overlap = self.check_shell_overlap(shell, neighbor_shell)
+                        assert overlap >= 0.0, \
+                            '%s (%s) overlaps with %s (%s) by %s.' % \
+                            (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
 
 
             # checking wether the shell don't exceed the maximum size

From cbf5bfadae7eef35caff8f845355ac47d007aa2a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Jan 2012 15:41:07 +0100
Subject: [PATCH 0594/1541] more changes in recursive bursting code

---
 egfrd.py | 84 +++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 52 insertions(+), 32 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index edb9c08f..72f282bf 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -666,9 +666,13 @@ def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
         # Recursively bursts the domains in 'domains' if within burstradius
         # Returns the updated list of domains with their distances
 
-        domain_distances_updated = []
+#        domain_distances_updated = []
+
+        log.debug("burst_non_multi")
+
+        for domain_distance in domain_distances:
+            domain, distance = domain_distance
 
-        for domain, distance in domain_distances:
             if distance <= burstradius and \
                not isinstance(domain, Multi) and \
                not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
@@ -680,22 +684,33 @@ def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
                 # -domain has time passed
                 log.debug("domain %s bursted. self.t= %s, domain.last_time= %s" % \
                           (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
+
+                # burst the domain and remove the original domain from the domain_distances list
+                domain_distances.remove(domain_distance)
                 single_list = self.burst_domain(domain)
-#                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
 
-                # Also burst recursively for every single created
-                for single in single_list:
-                    # Add the single itself to the updated neighbors list
-                    domain_distances_updated.append((single, 0))
-                    ignore.append(single.domain_id)
+                # Add the produced non-InteractionSingles to the updated list of neighbors
+                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
+                domain_distances.extend(single_distances)
+                # Make sure that all the new singles are being ignored
+#                for single in single_list:
+#                    ignore.append(single.domain_id)
 
-                    # For each single find the neighbors and burst them as well (if necessary/possible)
+                # Additionally, also burst recursively for every single created
+                for single in single_list:
                     single_pos = single.pid_particle_pair[1].position
                     single_radius = single.pid_particle_pair[1].radius
-                    neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore)
-                    neighbor_distances, ignore = self.burst_non_multis(neighbors, single_radius*SINGLE_SHELL_FACTOR, ignore)
+                    # For each single find the neighbors and (if we already knew about this neighbor) new distances
+                    neighbor_distances_single = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore)
+
+                    # make sure that there's only one occurance for each neighbor and that 'newer' copies get preference.
+                    neighbor_distances_single.extend(domain_distances)        # add old ones
+                    seen = set()
+                    seen_add = seen.add
+                    neighbor_distances = [ (x,y) for x, y in neighbor_distances_single if x not in seen and not seen_add(x)]
 
-                    domain_distances_updated.extend(neighbor_distances)         # TODO remove the duplicates
+                    # burst the neighbors with the new distances (if necessary/possible)
+                    domain_distances, ignore = self.burst_non_multis(neighbor_distances, single_radius*SINGLE_SHELL_FACTOR, ignore)
             else:
                 # Don't burst domain if (OR):
                 # -domain is farther than burst radius
@@ -704,12 +719,17 @@ def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
                 # -domain is domain in which no time has passed
                 log.debug("domain %s not bursted. self.t= %s, domain.last_time= %s" % \
                           (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
-                domain_distances_updated.append((domain, distance))
 
-                if isinstance(domain, NonInteractionSingle) and domain.is_reset():
-                    ignore.append(domain.domain_id)
+                # nothing needs to happen
+#                # just copy the domain to the new list
+#                domain_distances_updated.append(domain_distance)
+                # also, if the domain was just bursted put it on the ignore list
+                # -> also in the future nothing needs to happen.
+#                if isinstance(domain, NonInteractionSingle) and domain.is_reset():
+#                    ignore.append(domain.domain_id)
 
-        return domain_distances_updated, ignore
+        log.debug("  done..")
+        return domain_distances, ignore
 
     def fire_single_reaction(self, single, reactant_pos):
         # This takes care of the identity change when a single particle decays into
@@ -1211,23 +1231,24 @@ def make_new_domain(self, single):
         # -shell is burstable (not Multi)
         # -shell is not newly made
         # -shell is not already a zero shell (just bursted)
-        neighbor_distances, ignore = self.burst_non_multis(neighbors, reaction_threshold, ignore=[single.domain_id, ])
+        _, ignore = self.burst_non_multis(neighbors, reaction_threshold, ignore=[single.domain_id, ])
 #        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
-        seen_x = set()
-        new_neighbor_distances = []
-        for x in neighbor_distances:
-            a, b = x
-            if x not in seen_x:
-                seen_x.add(x)
-                if a.domain_id != single.domain_id:
-                    new_neighbor_distances.append(x)
-        neighbor_distances = new_neighbor_distances
+#        seen_x = set()
+#        new_neighbor_distances = []
+#        for x in neighbor_distances:
+#            a, b = x
+#            if x not in seen_x:
+#                seen_x.add(x)
+#                if a.domain_id != single.domain_id:
+#                    new_neighbor_distances.append(x)
+#        neighbor_distances = new_neighbor_distances
 
 
         # We prefer to make NonInteractionSingles for efficiency.
         # But if objects (Shells and surfaces) get close enough (closer than
         # reaction_threshold) we want to try Interaction and/or Pairs
 
+        neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # 2.3 From the updated list of neighbors, we calculate the thresholds (horizons) for trying to form
         #     the various domains. The domains can be:
         # -zero-shell NonInteractionSingle -> Pair or Multi
@@ -1417,7 +1438,7 @@ def process_single_event(self, single):
     # case is just a BURST event.
 
         # TODO assert that there is no event associated with this domain in the scheduler
-
+        assert self.check_domain(single)
 
         if single.is_reset():
         ### If no event event really happened and just need to make new domain
@@ -1444,10 +1465,6 @@ def process_single_event(self, single):
                 log.info('single = %s' % single)
 
 
-            if single.event_type != EventType.BURST:
-                # The burst of the domain may be caused by an overlapping domain
-                assert self.check_domain(single)
-
             # check that the event time of the single (last_time + dt) is equal to the
             # simulator time
             assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t), \
@@ -1980,13 +1997,16 @@ def add_to_multi_recursive(self, domain, multi):
 
             # 2. Burst the domains that interfere with making the multi shell
             burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-            neighbor_distances, ignore = self.burst_non_multis(neighbor_distances, burstradius, ignore=[])
+            neighbor_distances, ignore = self.burst_non_multis(neighbor_distances, burstradius,
+                                                               ignore=[domain.domain_id, multi.domain_id])
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
             # shell without overlapping. 
 
             # neighbor_distances has same format as before
             # It contains the updated list of domains in the neighborhood with distances
+            neighbor_distances = self.geometrycontainer.get_neighbor_domains(dompos, self.domains,
+                                                                             ignore=[domain.domain_id, multi.domain_id])
 
             # 3. add domain to the multi
             self.add_to_multi(domain, multi)

From a5603d329eb79e0032a4f4933102181d95f9fbf3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Jan 2012 18:31:06 +0100
Subject: [PATCH 0595/1541] mixed recursive bursting some more

---
 egfrd.py | 41 ++++++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 72f282bf..1190d8d6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -662,7 +662,7 @@ def burst_volume(self, pos, radius, ignore=[]):
         neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
         return self.burst_domains(neighbors)
 
-    def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
+    def burst_non_multis(self, domain_distances, burstradius, already_bursted):
         # Recursively bursts the domains in 'domains' if within burstradius
         # Returns the updated list of domains with their distances
 
@@ -672,8 +672,10 @@ def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
 
         for domain_distance in domain_distances:
             domain, distance = domain_distance
+            log.debug("%s" % str(domain))
 
             if distance <= burstradius and \
+               domain.domain_id not in already_bursted and \
                not isinstance(domain, Multi) and \
                not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
                self.t != domain.last_time:
@@ -686,31 +688,32 @@ def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
                           (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
 
                 # burst the domain and remove the original domain from the domain_distances list
-                domain_distances.remove(domain_distance)
+#                domain_distances.remove(domain_distance)
+                already_bursted.add(domain.domain_id)
                 single_list = self.burst_domain(domain)
 
-                # Add the produced non-InteractionSingles to the updated list of neighbors
-                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
-                domain_distances.extend(single_distances)
+#                # Add the produced non-InteractionSingles to the updated list of neighbors
+#                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
+#                domain_distances.extend(single_distances)
                 # Make sure that all the new singles are being ignored
-#                for single in single_list:
-#                    ignore.append(single.domain_id)
+                for single in single_list:
+                    already_bursted.add(single.domain_id)
 
                 # Additionally, also burst recursively for every single created
                 for single in single_list:
                     single_pos = single.pid_particle_pair[1].position
                     single_radius = single.pid_particle_pair[1].radius
                     # For each single find the neighbors and (if we already knew about this neighbor) new distances
-                    neighbor_distances_single = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore)
+                    neighbor_distances_single = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, list(already_bursted))
 
-                    # make sure that there's only one occurance for each neighbor and that 'newer' copies get preference.
-                    neighbor_distances_single.extend(domain_distances)        # add old ones
-                    seen = set()
-                    seen_add = seen.add
-                    neighbor_distances = [ (x,y) for x, y in neighbor_distances_single if x not in seen and not seen_add(x)]
+#                    # make sure that there's only one occurance for each neighbor and that 'newer' copies get preference.
+#                    neighbor_distances_single.extend(domain_distances)        # add old ones
+#                    seen = set()
+#                    seen_add = seen.add
+#                    neighbor_distances = [ (x,y) for x, y in neighbor_distances_single if x not in seen and not seen_add(x)]
 
                     # burst the neighbors with the new distances (if necessary/possible)
-                    domain_distances, ignore = self.burst_non_multis(neighbor_distances, single_radius*SINGLE_SHELL_FACTOR, ignore)
+                    _, already_bursted = self.burst_non_multis(neighbor_distances_single, single_radius*SINGLE_SHELL_FACTOR, already_bursted)
             else:
                 # Don't burst domain if (OR):
                 # -domain is farther than burst radius
@@ -725,11 +728,11 @@ def burst_non_multis(self, domain_distances, burstradius, ignore=[]):
 #                domain_distances_updated.append(domain_distance)
                 # also, if the domain was just bursted put it on the ignore list
                 # -> also in the future nothing needs to happen.
-#                if isinstance(domain, NonInteractionSingle) and domain.is_reset():
-#                    ignore.append(domain.domain_id)
+                if isinstance(domain, NonInteractionSingle) and domain.is_reset():
+                    already_bursted.add(domain.domain_id)
 
         log.debug("  done..")
-        return domain_distances, ignore
+        return domain_distances, already_bursted
 
     def fire_single_reaction(self, single, reactant_pos):
         # This takes care of the identity change when a single particle decays into
@@ -1231,7 +1234,7 @@ def make_new_domain(self, single):
         # -shell is burstable (not Multi)
         # -shell is not newly made
         # -shell is not already a zero shell (just bursted)
-        _, ignore = self.burst_non_multis(neighbors, reaction_threshold, ignore=[single.domain_id, ])
+        _, ignore = self.burst_non_multis(neighbors, reaction_threshold, set([single.domain_id]))
 #        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
 #        seen_x = set()
 #        new_neighbor_distances = []
@@ -1998,7 +2001,7 @@ def add_to_multi_recursive(self, domain, multi):
             # 2. Burst the domains that interfere with making the multi shell
             burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
             neighbor_distances, ignore = self.burst_non_multis(neighbor_distances, burstradius,
-                                                               ignore=[domain.domain_id, multi.domain_id])
+                                                               set([domain.domain_id, multi.domain_id]))
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
             # shell without overlapping. 

From a4d3d6e824e14a43659c9970d33b5f93a01062dc Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Jan 2012 18:36:16 +0100
Subject: [PATCH 0596/1541] removed some useless stuff

---
 egfrd.py | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1190d8d6..a6985477 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -666,8 +666,6 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
         # Recursively bursts the domains in 'domains' if within burstradius
         # Returns the updated list of domains with their distances
 
-#        domain_distances_updated = []
-
         log.debug("burst_non_multi")
 
         for domain_distance in domain_distances:
@@ -1236,16 +1234,6 @@ def make_new_domain(self, single):
         # -shell is not already a zero shell (just bursted)
         _, ignore = self.burst_non_multis(neighbors, reaction_threshold, set([single.domain_id]))
 #        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
-#        seen_x = set()
-#        new_neighbor_distances = []
-#        for x in neighbor_distances:
-#            a, b = x
-#            if x not in seen_x:
-#                seen_x.add(x)
-#                if a.domain_id != single.domain_id:
-#                    new_neighbor_distances.append(x)
-#        neighbor_distances = new_neighbor_distances
-
 
         # We prefer to make NonInteractionSingles for efficiency.
         # But if objects (Shells and surfaces) get close enough (closer than
@@ -2000,7 +1988,7 @@ def add_to_multi_recursive(self, domain, multi):
 
             # 2. Burst the domains that interfere with making the multi shell
             burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-            neighbor_distances, ignore = self.burst_non_multis(neighbor_distances, burstradius,
+            _, ignore = self.burst_non_multis(neighbor_distances, burstradius,
                                                                set([domain.domain_id, multi.domain_id]))
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi

From abea2534489ad3b776baed2d5c4f8fc05c22fde2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Jan 2012 15:01:36 +0100
Subject: [PATCH 0597/1541] added comments about checking

---
 egfrd.py | 95 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 87 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a6985477..fe14d3df 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1429,7 +1429,7 @@ def process_single_event(self, single):
     # case is just a BURST event.
 
         # TODO assert that there is no event associated with this domain in the scheduler
-        assert self.check_domain(single)
+#        assert self.check_domain(single)
 
         if single.is_reset():
         ### If no event event really happened and just need to make new domain
@@ -1455,6 +1455,9 @@ def process_single_event(self, single):
                 log.info('FIRE SINGLE: %s' % single.event_type)
                 log.info('single = %s' % single)
 
+            if single.event_type != EventType.BURST:
+                # The burst of the domain may be caused by an overlapping domain
+                assert self.check_domain(single)
 
             # check that the event time of the single (last_time + dt) is equal to the
             # simulator time
@@ -2161,6 +2164,7 @@ def print_report(self, out=None):
     def check_domain(self, domain):
         domain.check()
 
+        # construct ignore list for surfaces
         if isinstance(domain, Multi):
             # Ignore all surfaces, multi shells can overlap with 
             # surfaces.
@@ -2176,8 +2180,10 @@ def check_domain(self, domain):
 
 
 
+        ###### check shell consistency
         for shell_id, shell in domain.shell_list:
 
+            ### Check shell overlap with surfaces
             # TODO should be replace by list of surface
             surface, distance = get_closest_surface(self.world, shell.shape.position, ignores)
             if surface:
@@ -2187,14 +2193,14 @@ def check_domain(self, domain):
                         '%s (%s) overlaps with %s.' % \
                         (str(domain), str(shell), str(surface))
 
-
+            ### Check shell overlap with other shells
             neighbors = self.geometrycontainer.get_neighbor_domains(shell.shape.position,
                                                                     self.domains, ignore=[domain.domain_id])
             # TODO maybe don't check all the shells, this takes a lot of time
 
             # testing overlap criteria
             for neighbor, _ in neighbors:
-                # note that the shell of a MixedPair that has have just been bursted can stick into each other.
+                # note that the shell of a MixedPair or Multi that has have just been bursted can stick into each other.
                 if not (((isinstance(domain, hasCylindricalShell)   and isinstance(domain, NonInteractionSingle)   and domain.is_reset()) and \
                          (isinstance(neighbor, hasSphericalShell)   and isinstance(neighbor, NonInteractionSingle) and domain.is_reset()) ) or \
                         ((isinstance(domain, hasSphericalShell)     and isinstance(domain, NonInteractionSingle)   and domain.is_reset()) and \
@@ -2207,7 +2213,7 @@ def check_domain(self, domain):
                             (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
 
 
-            # checking wether the shell don't exceed the maximum size
+            ### checking if the shell don't exceed the maximum size
             if (type(shell.shape) is Cylinder):
                 # the cylinder should at least fit in the maximal sphere
                 shell_size = math.sqrt(shell.shape.radius**2 + shell.shape.half_length**2)
@@ -2227,9 +2233,7 @@ def check_domain(self, domain):
         return True
 
     def check_shell_overlap(self, shell1, shell2):
-    # Returns True if the shells DO NOT overlap
-    # Returns False if the shells DO overlap
-    # Return the amount of overlap (positive number means no overlap, negative means overlap)
+    # Return the amount of overlap between two shells (positive number means no overlap, negative means overlap)
 
         # overlap criterium when both shells are spherical
         if (type(shell1.shape) is Sphere) and (type(shell2.shape) is Sphere):
@@ -2252,7 +2256,7 @@ def check_shell_overlap(self, shell1, shell2):
             overlap_r = length(inter_pos_r) - (shell1.shape.radius + shell2.shape.radius)
             overlap_z = length(inter_pos_z) - (shell1.shape.half_length + shell2.shape.half_length)
             if (overlap_r < 0.0) and (overlap_z < 0.0):
-                return -1           # TODO: find better number for overlap measure
+                return -(overlap_r * overlap_z)           # TODO: find better number for overlap measure
             else:
                 return 1
 
@@ -2273,6 +2277,8 @@ def check_shell_overlap(self, shell1, shell2):
 
 
     def check_surface_overlap(self, shell, surface):
+    # Returns True if the shell and surface do not overlap, and False if they do overlap.
+
         if (type(shell.shape) is Sphere):
             distance = self.world.distance(surface.shape, shell.shape.position)
             return shell.shape.radius < distance
@@ -2294,6 +2300,7 @@ def check_surface_overlap(self, shell, surface):
 
 
     def check_domain_for_all(self):
+    # For every event in the scheduler, checks the consistency of the associated domain.
         for id, event in self.scheduler:
             domain = self.domains[event.data]
             self.check_domain(domain)
@@ -2335,6 +2342,78 @@ def check_shell_matrix(self):
             raise RuntimeError('num shells (%d) != matrix population (%d)' %
                                (shell_population, matrix_population))
 
+### check scheduler
+# check that every domain in domains{} has one and only one event in the scheduler
+# check that every event with domain is also in domains{}
+# check that dt, last_time of the domain is consistent with the event time on the scheduler
+# check that every event on scheduler is associated with domain or is a non domain related event
+
+# check that all the cached singles in Pairs are not in domains{}.
+
+### check shell container
+# check that shells of a domain in domains{} are once and only once in the shell matrix
+# check that all shells in the matrix are once and only once in a domain
+# total number of shells in domains==total number of shells in shell container
+# check that the shells of all the cached singles in Pairs are not in the containers
+
+### check shells of domains
+# check that shells of the domain do not overlap with shells of other domains
+# check that shells are not bigger than the allowed maximum
+# check (for Multi's only?) that the shells in a domain are connected (have consecutive overlaps)
+# check that shells of the domain don't overlap with surfaces that are not associated with the domain.
+# check that shells of the domain DO overlap with the structures that it is associated with.
+
+### check world
+# check num particles in domains is equal to num particles in the world
+# check that every particle in the world is in one and only one domain
+# check that every particle in the domains is once and only once in the world.
+# check that particles do not overlap with cylinderical surfaces unless the domain is associated with the surface
+
+### check domains
+# check that testShell is of proper type
+# check that the particles are within the shells of the domain
+# check that proper number of shells for domain, most other number of shells==1
+# check that the shell(s) of domain have the proper geometry (sphere/cylinder)
+# check that shell is within minimum and maximum
+# check that shell obeys scaling properties
+# check that the position of the shell(s) and particle(s) are within the structures that the particles live on
+# check that dt != 0 unless NonInteractionSingle.is_reset()
+# check event_type != BURST
+# check associated structures are of proper type (plane etc, but also of proper StructureTypeID)
+# check that Green's functions are defined.
+
+### check NonInteractionSingle
+# check if is_reset() then shellsize is size particle, dt==0, event_type==ESCAPE
+# check shell.unit_z == structure.unit_z
+# check drift < inf
+# check inner space < shell
+
+### check Pair
+# check number of particles==2
+# check D_R, D_r > 0
+# check r0 is between sigma and a (within bounds of greens function)
+# check sigma
+
+### check SimplePair
+# check CoM, iv lies in the structure of the particles
+# check shell.unit_z == structure.unit_z
+
+### check MixedPair
+# check CoM is in surface, IV is NOT
+
+### check Interaction
+# check shell.unit_z = +- surface.unit_z
+
+### check Multi
+# check Multi num particles >= 1
+# check number of shells==num of particles in Multi
+# Event is DIFFUSION, SINGLE_REACTION, BIMOL_REACTION, ESCAPE
+
+### check consistency of the model
+# check that the product species of an interaction lives on the interaction surface.
+# check that the product species of a bimolecular reaction lives on either structure of reactant species
+# check that the product species of a unimolecular reaction lives on structure of the reactant species or the bulk.
+
     def check_domains(self):
     # checks that the events in the scheduler are consistent with the domains
 

From 3f4d4f8fc072fe42cb0a38857b2f824064427743 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Jan 2012 18:16:29 +0100
Subject: [PATCH 0598/1541] improved checking for multis and added some
 comments Now Multis can really check if their shells are connected or not.

---
 egfrd.py  |  9 ++++-----
 multi.py  | 52 ++++++++++++++++++++++++++++++++++++++--------------
 shells.py |  3 +++
 3 files changed, 45 insertions(+), 19 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fe14d3df..5a8e836d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1963,6 +1963,9 @@ def form_multi(self, single, multi_partners):
             # In case of new multi
             self.add_domain_event(multi)
 
+        if __debug__:
+            self.check_domain(multi)
+
         return multi
 
 
@@ -2404,15 +2407,11 @@ def check_shell_matrix(self):
 ### check Interaction
 # check shell.unit_z = +- surface.unit_z
 
-### check Multi
-# check Multi num particles >= 1
-# check number of shells==num of particles in Multi
-# Event is DIFFUSION, SINGLE_REACTION, BIMOL_REACTION, ESCAPE
-
 ### check consistency of the model
 # check that the product species of an interaction lives on the interaction surface.
 # check that the product species of a bimolecular reaction lives on either structure of reactant species
 # check that the product species of a unimolecular reaction lives on structure of the reactant species or the bulk.
+# structures cannot overlap unless substructure
 
     def check_domains(self):
     # checks that the events in the scheduler are consistent with the domains
diff --git a/multi.py b/multi.py
index 566acca8..4472e47a 100644
--- a/multi.py
+++ b/multi.py
@@ -144,24 +144,45 @@ def __call__(self, shape, ignore0, ignore1=None):
         #             pid_particle_pair[1].radius, ignore=[self.domain_id, ])
 
     def check(self):
-        # shells are contiguous
-        # FIXME: this code cannot detect a pair of shells that are isolated
-        #        from others.
-        for _, shell in self.shell_list:
-            result = self.sphere_container.get_neighbors(shell.shape.position)
-            # Check contiguity with nearest neighbor only (get_neighbors 
-            # returns a sorted list).
-            if len(result) > 1:
-                nearest = result[1]
-                distance = nearest[1]
-                assert distance - shell.shape.radius < 0.0,\
-                    'shells of %s are not contiguous.' % str(self)
-
-        # all particles within the shell.
+        # check Multi num particles >= 1
+        assert self.multiplicity >= 1, 'Multi needs to have at least one particle'
+        # check number of shells==num of particles in Multi
+        assert self.multiplicity == self.num_shells, \
+            'number of particles is not equal to number of shells'
+        # Event is DIFFUSION, SINGLE_REACTION, BIMOL_REACTION, ESCAPE
+        assert self.event_Type == EventType.MULTI_DIFFUSION or \
+               self.event_Type == EventType.MULTI_ESCAPE or \
+               self.event_Type == EventType.MULTI_UNIMOLECULAR_REACTION or \
+               self.event_Type == EventType.MULTI_BIMOLECULAR_REACTION, \
+                    'event_type of Multi was not of proper type'
+
+        # check that the shells of the multi are contiguous
+        # FIXME: This can be done more efficiently because we already have an
+        #        exhaustive list of the shells to check
+        def check_connected(shell_id_shell_pair, already_checked):
+
+            shell_id, shell = shell_id_shell_pair
+            if shell_id not in already_checked:
+                already_checked.add(shell_id)
+                # TODO get only the neighbors that are not in already_checked
+                neighbor_distances = self.sphere_container.get_neighbors_within_radius(shell.shape.position, shell.shape.radius)
+                for shell_id_shell_pair, _ in neighbor_distances:
+                    already_checked = check_connected(shell_id_shell_pair, already_checked)
+
+            return already_checked
+
+        connected_shell_ids = check_connected(self.shell_list.next(), set([]))
+        assert len(connected_shell_ids) == self.num_shells, \
+            'shells of %s are not contiguous.' % str(self)
+
+
+        # check that all particles are within one of the shells.
         for pid_particle_pair in self.particle_container:
             assert self.within_shell(pid_particle_pair),\
                 'not all particles within the shell.'
 
+        # check that all the shells in the private multi shell container
+        # are also in the shell container of the Simulator
         main = self.main()
         for shell_id, shell in self.shell_list:
             container = main.geometrycontainer.get_container(shell)
@@ -169,6 +190,8 @@ def check(self):
                 raise RuntimeError,\
                     'self.sim.main.sphere_container does not contain %s'\
                     % str(shell_id)
+        # check that all the shells in the container of the Simulator that belong to this multi
+        # domain are also in the private shell container.
         for shell_id, shell in main.geometrycontainer.containers[0]:
             if shell.did == self.domain_id:
                 if not self.sphere_container.contains(shell_id):
@@ -200,5 +223,6 @@ def num_shells(self):
     num_shells = property(num_shells)    
 
     def shell_list(self):
+    # returns a list of (shell_id, shell) pairs of the Multi
         return iter(self.sphere_container)
     shell_list = property(shell_list)
diff --git a/shells.py b/shells.py
index 8a614a4d..eb885bdb 100755
--- a/shells.py
+++ b/shells.py
@@ -147,7 +147,10 @@ def __init__(self, pid_particle_pair, structure):
 class testInteractionSingle(testSingle, Others):
 
     def __init__(self, single, structure, surface):
+
+        # assert that the single is reset
         assert single.is_reset()
+
         testSingle.__init__(self, single.pid_particle_pair, structure)
         # Note: for the Others superclass nothing is to be initialized.
 

From d5dc493cbb4748ef91397b410692ed95530da418 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 27 Jan 2012 11:40:26 +0100
Subject: [PATCH 0599/1541] if debugging is off -> do less checking

---
 egfrd.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 5a8e836d..2a91038d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1414,10 +1414,11 @@ def update_single(self, single):
 
         single.last_time = self.t
 
-        # check everything is ok
-        assert self.check_domain(single)
         # add to scheduler
         self.add_domain_event(single)
+        # check everything is ok
+        if __debug__:
+            assert self.check_domain(single)
 
         return single
 
@@ -1843,10 +1844,11 @@ def try_interaction(self, single, surface):
             self.remove_domain(single)
             # the event associated with the single will be removed by the scheduler.
 
-            # check everything is ok
-            assert self.check_domain(interaction)
             # add to scheduler
             self.add_domain_event(interaction)
+            # check everything is ok
+            if __debug__:
+                assert self.check_domain(interaction)
 
             return interaction
         else:
@@ -1895,10 +1897,11 @@ def try_pair(self, single1, single2):
             # pair.
             self.remove_event(single2)
 
-            # check everything is ok
-            assert self.check_domain(pair)
             # add to scheduler
             self.add_domain_event(pair)
+            # check everything is ok
+            if __debug__:
+                assert self.check_domain(pair)
 
             return pair
         else:
@@ -1964,7 +1967,7 @@ def form_multi(self, single, multi_partners):
             self.add_domain_event(multi)
 
         if __debug__:
-            self.check_domain(multi)
+            assert self.check_domain(multi)
 
         return multi
 

From 481c9a61ee0416c214b4389930fd96820db114bc Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 27 Jan 2012 11:57:12 +0100
Subject: [PATCH 0600/1541] make sure that the shells still obey the scaling
 rules after applying the safety

---
 shells.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index eb885bdb..f45c539a 100755
--- a/shells.py
+++ b/shells.py
@@ -1187,6 +1187,10 @@ def __init__(self, single1, single2, geometrycontainer, domains):
             raise testShellError('(CylindricalSurfacePair). %s' %
                                  (str(e)))
 
+        # make sure the domain is symmetric around the CoM
+        self.dz_right = min(self.dz_right, self.dz_left)
+        self.dz_left  = self.dz_right
+
     def get_orientation_vector(self):
         return self.structure.shape.unit_z
 
@@ -1265,7 +1269,7 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
-        return r/SAFETY, z_right/SAFETY, z_left
+        return self.r_right(z_right/SAFETY), z_right/SAFETY, z_left
 
 #####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
@@ -1319,7 +1323,7 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
-        return r/SAFETY, z_right/SAFETY, z_left/SAFETY
+        return r/SAFETY, self.z_right(r/SAFETY), self.z_left(r/SAFETY)
 
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
 
@@ -1390,7 +1394,7 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         # The initialization of r0 can fail in testPair.__init__
 
-        raise testShellError('(MixedPair2D3D).')
+#        raise testShellError('(MixedPair2D3D).')
 
         try:
             testMixedPair2D3D.__init__(self, single2D, single3D)
@@ -1548,7 +1552,7 @@ def r_right(self, z_right):
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
-        return r/SAFETY, z_right/SAFETY, z_left
+        return r/SAFETY, self.z_right(r/SAFETY), z_left
 
 #####
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From c42cac2fcf767d68ed18a2cff35b736c3c5ab385 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 12:15:53 +0100
Subject: [PATCH 0601/1541] added checking, removed some logging, changed
 comments

---
 egfrd.py | 27 ++++++++++++++++-----------
 pair.py  | 20 ++++++++++++++++++++
 2 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2a91038d..914cc380 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -682,8 +682,8 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
                 # -domain is not a multi
                 # -domain is not zero dt NonInteractionSingle
                 # -domain has time passed
-                log.debug("domain %s bursted. self.t= %s, domain.last_time= %s" % \
-                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
+#                log.debug("domain %s bursted. self.t= %s, domain.last_time= %s" % \
+#                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
 
                 # burst the domain and remove the original domain from the domain_distances list
 #                domain_distances.remove(domain_distance)
@@ -718,8 +718,8 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
                 # -domain is a multi
                 # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
                 # -domain is domain in which no time has passed
-                log.debug("domain %s not bursted. self.t= %s, domain.last_time= %s" % \
-                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
+#                log.debug("domain %s not bursted. self.t= %s, domain.last_time= %s" % \
+#                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
 
                 # nothing needs to happen
 #                # just copy the domain to the new list
@@ -1966,8 +1966,8 @@ def form_multi(self, single, multi_partners):
             # In case of new multi
             self.add_domain_event(multi)
 
-        if __debug__:
-            assert self.check_domain(multi)
+#        if __debug__:
+#            assert self.check_domain(multi)
 
         return multi
 
@@ -2170,19 +2170,24 @@ def print_report(self, out=None):
     def check_domain(self, domain):
         domain.check()
 
-        # construct ignore list for surfaces
+        # construct ignore list for surfaces and the structures that the domain is associated with
         if isinstance(domain, Multi):
             # Ignore all surfaces, multi shells can overlap with 
             # surfaces.
             ignores = [s.id for s in self.world.structures]
-        elif isinstance(domain, SphericalSingle):
+            associated = []
+        elif isinstance(domain, SphericalSingle) or isinstance(domain, SphericalPair):
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
+            associated = []
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
-            ignores = [domain.structure.id, domain.surface.id]
+            ignores = []
+            associated = [domain.structure.id, domain.surface.id]
         else:
-            ignores = [domain.structure.id]
+            # Ignore the structure that the particles are associated with
+            ignores = []
+            associated = [domain.structure.id]
 
 
 
@@ -2191,7 +2196,7 @@ def check_domain(self, domain):
 
             ### Check shell overlap with surfaces
             # TODO should be replace by list of surface
-            surface, distance = get_closest_surface(self.world, shell.shape.position, ignores)
+            surface, distance = get_closest_surface(self.world, shell.shape.position, ignores + associated)
             if surface:
                 surfaces = [(surface, distance), ]
                 for surface, distance in surfaces:
diff --git a/pair.py b/pair.py
index a97e6470..642996cd 100644
--- a/pair.py
+++ b/pair.py
@@ -752,6 +752,26 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
         return new_iv
 
+    def check(self):
+    # perform internal consistency check 
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
+
+        radius      = self.shell.shape.radius
+        half_length = self.shell.shape.half_length
+
+        # check that the shell obeys the scaling rules dimensions of the cylinder
+        r_check  = self.testShell.r_right (half_length*2 - radius1)
+        hl_check = (self.testShell.z_right (radius) + self.testShell.z_left (radius))/2
+        assert feq(r_check, radius) and feq(hl_check, half_length), \
+            'MixedPair2D3D: Domain did not obey scaling relationship. '
+
+        # check that the CoM is in the surface
+        assert numpy.dot( (self.com-self.surface.shape.position), self.surface.shape.unit_z) == 0.0
+        # check that the IV is NOT in the surface
+
     def __str__(self):
         return 'Mixed2D3D' + Pair.__str__(self)
 

From 539d7e19cafe013e142401dfc5669a7f0435525d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 12:17:08 +0100
Subject: [PATCH 0602/1541] trying to fix the bloody MixedPair2D3D problem

---
 shells.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/shells.py b/shells.py
index f45c539a..4ce6b427 100755
--- a/shells.py
+++ b/shells.py
@@ -1552,6 +1552,7 @@ def r_right(self, z_right):
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
+        SAFETY = 1.1
         return r/SAFETY, self.z_right(r/SAFETY), z_left
 
 #####

From 946ef2f30a8939a4e783dd84fdc96f7923430101 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 13:41:17 +0100
Subject: [PATCH 0603/1541] new funstion for getting all the surfaces in the
 world

---
 gfrdbase.py | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 7695a4d1..c4378309 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -81,6 +81,19 @@ def p_free(r, t, D):
 
     return p * jacobian
     
+def get_surfaces(world, pos, ignore=[]):
+    
+    surface_distances = []
+
+    for surface in world.structures:
+        if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
+            pos_transposed = \
+                world.cyclic_transpose(pos, surface.shape.position)
+            distance = world.distance(surface.shape, pos_transposed)
+            surface_distances.append((surface, distance))
+
+    return surface_distances
+
 def get_closest_surface(world, pos, ignore=[]):
     """Return
       - closest surface
@@ -90,18 +103,10 @@ def get_closest_surface(world, pos, ignore=[]):
     origin of the surface would not be in the same or neighboring 
     cells as pos."""
 
-    distances_and_surfaces = []
-
-    for surface in world.structures:
-        if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
-            pos_transposed = \
-                world.cyclic_transpose(pos, surface.shape.position)
-            distance = world.distance(surface.shape, pos_transposed)
-            distances_and_surfaces.append((distance, surface))
+    surface_distances = get_surfaces(world, pos, ignore)
 
-    if distances_and_surfaces:
-        distance, surface = min(distances_and_surfaces)
-        return surface, distance
+    if surface_distances:
+        return min(surface_distances, key=lambda surface_dist: surface_dist[1])
     else:
         return None, numpy.inf
 

From 94a85fc55f78842c6e14e713dcbd13358f106f31 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 13:47:34 +0100
Subject: [PATCH 0604/1541] Used the new function 'get_surfaces' to get all the
 surfaces instead of just the nearest one.

---
 egfrd.py          | 15 ++++++---------
 gfrdbase.py       |  1 +
 shellcontainer.py | 10 ++++------
 3 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 016cb900..b775f41a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2126,20 +2126,17 @@ def check_domain(self, domain):
 
         for shell_id, shell in domain.shell_list:
 
-            # TODO should be replace by list of surface
-            surface, distance = get_closest_surface(self.world, shell.shape.position, ignores)
-            if surface:
-                surfaces = [(surface, distance), ]
-                for surface, distance in surfaces:
-                    assert self.check_surface_overlap(shell, surface), \
-                        '%s (%s) overlaps with %s.' % \
-                        (str(domain), str(shell), str(surface))
+            surfaces = get_surfaces(self.world, shell.shape.position, ignores)
+            for surface, _ in surfaces:
+                assert self.check_surface_overlap(shell, surface), \
+                    '%s (%s) overlaps with %s.' % \
+                    (str(domain), str(shell), str(surface))
 
 
             neighbors = self.geometrycontainer.get_neighbor_domains(shell.shape.position,
                                                                     self.domains, ignore=[domain.domain_id])
-            # TODO maybe don't check all the shells, this takes a lot of time
 
+            # TODO maybe don't check all the shells, this takes a lot of time
             # testing overlap criteria
             for neighbor, _ in neighbors:
                 for _, neighbor_shell in neighbor.shell_list:
diff --git a/gfrdbase.py b/gfrdbase.py
index c4378309..7c2cf88a 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -27,6 +27,7 @@
     'NoSpace',
     'create_world',
     'ParticleSimulatorBase',
+    'get_surfaces',
     'get_closest_surface',
     'create_network_rules_wrapper',
     'place_particle'
diff --git a/shellcontainer.py b/shellcontainer.py
index 910ff612..c3665958 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -12,6 +12,7 @@
 from single import NonInteractionSingle
 from multi import Multi
 from gfrdbase import (
+    get_surfaces,
     get_closest_surface
     )
 
@@ -179,12 +180,9 @@ def get_neighbor_surfaces(self, position, base_structure_id, ignores=[]):
         # We assume a particle can't have an interaction with the same surface on/in which it lives.
         ignores.append( base_structure_id )
 
-        # TODO return a list of neighboring surfaces
-        surface, distance = get_closest_surface(self.world, position, ignores)
-        if surface:
-            return [(surface, distance), ]
-        else:
-            return []
+        surface_distances = get_surfaces(self.world, position, ignores)
+
+        return surface_distances
 
 
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):

From 0ce2fd0583d4437b7b58ded4b773446dd1fe1a1c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 14:42:01 +0100
Subject: [PATCH 0605/1541] some changend comments

---
 egfrd.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 914cc380..7fa53f9a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -618,13 +618,9 @@ def burst_domain(self, domain):
             bursted = self.burst_single(domain)
         elif isinstance(domain, Pair):  # Pair
             bursted = self.burst_pair(domain)
-        else:  # Multi
+        else:                           # Multi
             assert isinstance(domain, Multi)
             bursted = self.burst_multi(domain)
-#            bursted = self.break_up_multi(domain)       # Multi's can't really be 'bursted' since the
-                                                        # positions of the particles are known. They
-                                                        # are broken up to singles with a dt=0 shell instead.
-#            self.remove_event(domain)
 
         if __debug__:
             # After a burst, InteractionSingles should be gone.
@@ -670,7 +666,7 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
 
         for domain_distance in domain_distances:
             domain, distance = domain_distance
-            log.debug("%s" % str(domain))
+#            log.debug("%s" % str(domain))
 
             if distance <= burstradius and \
                domain.domain_id not in already_bursted and \

From 2fe04fc14ce4b4ec455f707ee237897d72e7499b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 15:12:05 +0100
Subject: [PATCH 0606/1541] cleanup of burst_non_multis

---
 egfrd.py | 39 ++++++++++++++++++++++-----------------
 1 file changed, 22 insertions(+), 17 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7fa53f9a..4a96cbfb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -658,18 +658,22 @@ def burst_volume(self, pos, radius, ignore=[]):
         neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
         return self.burst_domains(neighbors)
 
-    def burst_non_multis(self, domain_distances, burstradius, already_bursted):
+    def burst_non_multis(self, pos, burstradius, already_bursted):
         # Recursively bursts the domains in 'domains' if within burstradius
         # Returns the updated list of domains with their distances
 
         log.debug("burst_non_multi")
 
-        for domain_distance in domain_distances:
-            domain, distance = domain_distance
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, burstradius, already_bursted)
+#        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+
+        for domain_id in neighbor_ids:
+            domain = self.domains[domain_id]
+#            domain, distance = domain_distance
 #            log.debug("%s" % str(domain))
 
-            if distance <= burstradius and \
-               domain.domain_id not in already_bursted and \
+#            if distance <= burstradius and \
+            if domain_id not in already_bursted and \
                not isinstance(domain, Multi) and \
                not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
                self.t != domain.last_time:
@@ -683,7 +687,7 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
 
                 # burst the domain and remove the original domain from the domain_distances list
 #                domain_distances.remove(domain_distance)
-                already_bursted.add(domain.domain_id)
+                already_bursted.add(domain_id)
                 single_list = self.burst_domain(domain)
 
 #                # Add the produced non-InteractionSingles to the updated list of neighbors
@@ -695,10 +699,10 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
 
                 # Additionally, also burst recursively for every single created
                 for single in single_list:
-                    single_pos = single.pid_particle_pair[1].position
-                    single_radius = single.pid_particle_pair[1].radius
+#                    single_pos = single.pid_particle_pair[1].position
+#                    single_radius = single.pid_particle_pair[1].radius
                     # For each single find the neighbors and (if we already knew about this neighbor) new distances
-                    neighbor_distances_single = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, list(already_bursted))
+#                    neighbor_distances_single = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, list(already_bursted))
 
 #                    # make sure that there's only one occurance for each neighbor and that 'newer' copies get preference.
 #                    neighbor_distances_single.extend(domain_distances)        # add old ones
@@ -707,7 +711,9 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
 #                    neighbor_distances = [ (x,y) for x, y in neighbor_distances_single if x not in seen and not seen_add(x)]
 
                     # burst the neighbors with the new distances (if necessary/possible)
-                    _, already_bursted = self.burst_non_multis(neighbor_distances_single, single_radius*SINGLE_SHELL_FACTOR, already_bursted)
+                    already_bursted = self.burst_non_multis(single.pid_particle_pair[1].position,
+                                                            single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                            already_bursted)
             else:
                 # Don't burst domain if (OR):
                 # -domain is farther than burst radius
@@ -723,10 +729,10 @@ def burst_non_multis(self, domain_distances, burstradius, already_bursted):
                 # also, if the domain was just bursted put it on the ignore list
                 # -> also in the future nothing needs to happen.
                 if isinstance(domain, NonInteractionSingle) and domain.is_reset():
-                    already_bursted.add(domain.domain_id)
+                    already_bursted.add(domain_id)
 
         log.debug("  done..")
-        return domain_distances, already_bursted
+        return already_bursted
 
     def fire_single_reaction(self, single, reactant_pos):
         # This takes care of the identity change when a single particle decays into
@@ -1228,7 +1234,7 @@ def make_new_domain(self, single):
         # -shell is burstable (not Multi)
         # -shell is not newly made
         # -shell is not already a zero shell (just bursted)
-        _, ignore = self.burst_non_multis(neighbors, reaction_threshold, set([single.domain_id]))
+        ignore = self.burst_non_multis(single_pos, reaction_threshold, set([single.domain_id]))
 #        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
 
         # We prefer to make NonInteractionSingles for efficiency.
@@ -1988,13 +1994,12 @@ def add_to_multi_recursive(self, domain, multi):
             
             # 1. Get the neighbors of the domain
             dompos = domain.shell.shape.position
-            neighbor_distances = self.geometrycontainer.get_neighbor_domains(dompos, self.domains,
-                                                                             ignore=[domain.domain_id, multi.domain_id])
+#            neighbor_distances = self.geometrycontainer.get_neighbor_domains(dompos, self.domains,
+#                                                                             ignore=[domain.domain_id, multi.domain_id])
 
             # 2. Burst the domains that interfere with making the multi shell
             burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-            _, ignore = self.burst_non_multis(neighbor_distances, burstradius,
-                                                               set([domain.domain_id, multi.domain_id]))
+            ignore = self.burst_non_multis(dompos, burstradius, set([domain.domain_id, multi.domain_id]))
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
             # shell without overlapping. 

From 1ea8946b7ec78cc3056665302136b6b8dd8db33a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 15:21:28 +0100
Subject: [PATCH 0607/1541] some more cleanup of burst_non_multis

---
 egfrd.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4a96cbfb..07357bac 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -687,15 +687,15 @@ def burst_non_multis(self, pos, burstradius, already_bursted):
 
                 # burst the domain and remove the original domain from the domain_distances list
 #                domain_distances.remove(domain_distance)
-                already_bursted.add(domain_id)
+                already_bursted.append(domain_id)
                 single_list = self.burst_domain(domain)
 
 #                # Add the produced non-InteractionSingles to the updated list of neighbors
 #                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
 #                domain_distances.extend(single_distances)
                 # Make sure that all the new singles are being ignored
-                for single in single_list:
-                    already_bursted.add(single.domain_id)
+#                for single in single_list:
+                already_bursted.extend(single_list)
 
                 # Additionally, also burst recursively for every single created
                 for single in single_list:
@@ -729,7 +729,7 @@ def burst_non_multis(self, pos, burstradius, already_bursted):
                 # also, if the domain was just bursted put it on the ignore list
                 # -> also in the future nothing needs to happen.
                 if isinstance(domain, NonInteractionSingle) and domain.is_reset():
-                    already_bursted.add(domain_id)
+                    already_bursted.append(domain_id)
 
         log.debug("  done..")
         return already_bursted
@@ -1234,7 +1234,7 @@ def make_new_domain(self, single):
         # -shell is burstable (not Multi)
         # -shell is not newly made
         # -shell is not already a zero shell (just bursted)
-        ignore = self.burst_non_multis(single_pos, reaction_threshold, set([single.domain_id]))
+        ignore = self.burst_non_multis(single_pos, reaction_threshold, [single.domain_id])
 #        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
 
         # We prefer to make NonInteractionSingles for efficiency.
@@ -1999,7 +1999,7 @@ def add_to_multi_recursive(self, domain, multi):
 
             # 2. Burst the domains that interfere with making the multi shell
             burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-            ignore = self.burst_non_multis(dompos, burstradius, set([domain.domain_id, multi.domain_id]))
+            ignore = self.burst_non_multis(dompos, burstradius, [domain.domain_id, multi.domain_id])
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
             # shell without overlapping. 

From ebd217f14e4a054bea2722f6bbeac87e9c45d3bf Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 15:58:33 +0100
Subject: [PATCH 0608/1541] removed some old code in burst_non_multis

---
 egfrd.py | 33 +++++----------------------------
 1 file changed, 5 insertions(+), 28 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 07357bac..85bf186e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -682,35 +682,16 @@ def burst_non_multis(self, pos, burstradius, already_bursted):
                 # -domain is not a multi
                 # -domain is not zero dt NonInteractionSingle
                 # -domain has time passed
-#                log.debug("domain %s bursted. self.t= %s, domain.last_time= %s" % \
-#                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
 
-                # burst the domain and remove the original domain from the domain_distances list
-#                domain_distances.remove(domain_distance)
-                already_bursted.append(domain_id)
+                # burst the domain and add the domain_id to the list of domains that is already bursted
                 single_list = self.burst_domain(domain)
+                already_bursted.append(domain_id)
 
-#                # Add the produced non-InteractionSingles to the updated list of neighbors
-#                single_distances = [(single, 0) for single in single_list]  # TODO? calculate real distance, now just 0
-#                domain_distances.extend(single_distances)
                 # Make sure that all the new singles are being ignored
-#                for single in single_list:
                 already_bursted.extend(single_list)
 
                 # Additionally, also burst recursively for every single created
                 for single in single_list:
-#                    single_pos = single.pid_particle_pair[1].position
-#                    single_radius = single.pid_particle_pair[1].radius
-                    # For each single find the neighbors and (if we already knew about this neighbor) new distances
-#                    neighbor_distances_single = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, list(already_bursted))
-
-#                    # make sure that there's only one occurance for each neighbor and that 'newer' copies get preference.
-#                    neighbor_distances_single.extend(domain_distances)        # add old ones
-#                    seen = set()
-#                    seen_add = seen.add
-#                    neighbor_distances = [ (x,y) for x, y in neighbor_distances_single if x not in seen and not seen_add(x)]
-
-                    # burst the neighbors with the new distances (if necessary/possible)
                     already_bursted = self.burst_non_multis(single.pid_particle_pair[1].position,
                                                             single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
                                                             already_bursted)
@@ -720,13 +701,9 @@ def burst_non_multis(self, pos, burstradius, already_bursted):
                 # -domain is a multi
                 # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
                 # -domain is domain in which no time has passed
-#                log.debug("domain %s not bursted. self.t= %s, domain.last_time= %s" % \
-#                          (str(domain), FORMAT_DOUBLE % self.t, FORMAT_DOUBLE % domain.last_time))
 
                 # nothing needs to happen
-#                # just copy the domain to the new list
-#                domain_distances_updated.append(domain_distance)
-                # also, if the domain was just bursted put it on the ignore list
+                # If the domain was just bursted put it on the ignore list
                 # -> also in the future nothing needs to happen.
                 if isinstance(domain, NonInteractionSingle) and domain.is_reset():
                     already_bursted.append(domain_id)
@@ -1968,8 +1945,8 @@ def form_multi(self, single, multi_partners):
             # In case of new multi
             self.add_domain_event(multi)
 
-#        if __debug__:
-#            assert self.check_domain(multi)
+        if __debug__:
+            assert self.check_domain(multi)
 
         return multi
 

From ada8cc846f8411571b18ac164edd48764795c286 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 18:29:08 +0100
Subject: [PATCH 0609/1541] de recursive bursting algorithm needs to take place
 after an event We can then burst for all the products of an event. This will
 mean that all NonInteractionSingles in the system after the event have
 nothing else to burst anymore. All the bursting should happen now in one
 'round' right after the event.

---
 egfrd.py | 165 ++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 97 insertions(+), 68 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 85bf186e..76723ddb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -322,8 +322,10 @@ def stop(self, t):
         non_single_list = []
 
         # Burst all the domains that we know of.
+        # TODO because of recursive bursting, domains that are still on the list may already have been bursted.
         # first burst all Singles, and put Pairs and Multis in a list.
 #        for id, event in self.scheduler:
+        ignore = []
         for _, domain in self.domains.items():
 #            obj = self.domains[event.data]
             if isinstance(domain, Pair) or isinstance(domain, Multi):
@@ -332,7 +334,7 @@ def stop(self, t):
                 if __debug__:
                     log.debug('burst %s, last_time= %s' % 
                               (domain, FORMAT_DOUBLE % domain.last_time))
-                self.burst_single(domain)
+                ignore = self.burst_single(domain, ignore)
             else:
                 assert False, 'domain from domains{} was no Single, Pair or Multi'
 
@@ -340,7 +342,7 @@ def stop(self, t):
         # then burst all Pairs and Multis.
         if __debug__:
             log.debug('burst %s' % non_single_list)
-        self.burst_domains(non_single_list)
+        self.burst_domains(non_single_list, ignore)
 
         self.dt = 0.0
 
@@ -389,7 +391,7 @@ def step(self):
         # e.g. "if class is Single, then process_single_event" ~ MW
         for klass, f in self.dispatch:
             if isinstance(domain, klass):
-                f(self, domain)         # fire the correct method for the class (e.g. fire_singel(self, Single))
+                f(self, domain, [domain.domain_id])         # fire the correct method for the class (e.g. process_single_event(self, Single))
 
         if __debug__:
             if self.scheduler.size == 0:
@@ -607,7 +609,7 @@ def update_domain_event(self, t, domain):
                      (domain.domain_id, domain.event_id, FORMAT_DOUBLE % t))
         self.scheduler.update((domain.event_id, DomainEvent(t, domain)))
 
-    def burst_domain(self, domain):
+    def burst_domain(self, domain, already_bursted):
     # Reduces and domain (Single, Pair or Multi) to Singles with the zero shell, and dt=0
     # return a list of Singles that was the result of the bursting
         if __debug__:
@@ -615,28 +617,28 @@ def burst_domain(self, domain):
 
         if isinstance(domain, Single):
             # TODO. Compare with gfrd.
-            bursted = self.burst_single(domain)
+            bursted, already_bursted = self.burst_single(domain, already_bursted)
         elif isinstance(domain, Pair):  # Pair
-            bursted = self.burst_pair(domain)
+            bursted, already_bursted = self.burst_pair(domain, already_bursted)
         else:                           # Multi
             assert isinstance(domain, Multi)
-            bursted = self.burst_multi(domain)
+            bursted, already_bursted = self.burst_multi(domain, already_bursted)
 
         if __debug__:
             # After a burst, InteractionSingles should be gone.
             assert all(not isinstance(b, InteractionSingle) for b in bursted)
             log.info('bursted = %s' % ',\n\t  '.join(str(i) for i in bursted))
 
-        return bursted
+        return bursted, already_bursted
 
-    def burst_domains(self, domains):
+    def burst_domains(self, domains, already_bursted):
     # bursts all the domains that are in the list 'domains'
         bursted = []
         for domain in domains:
-            d = self.burst_domain(domain)
+            d, already_bursted = self.burst_domain(domain, already_bursted)
             bursted.extend(d)
 
-        return bursted
+        return bursted, already_bursted
 
     def burst_volume(self, pos, radius, ignore=[]):
         """ Burst domains within a certain volume and give their ids.
@@ -656,7 +658,7 @@ def burst_volume(self, pos, radius, ignore=[]):
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius,
                                                                                ignore)
         neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
-        return self.burst_domains(neighbors)
+        return self.burst_domains(neighbors, ignore)
 
     def burst_non_multis(self, pos, burstradius, already_bursted):
         # Recursively bursts the domains in 'domains' if within burstradius
@@ -668,45 +670,45 @@ def burst_non_multis(self, pos, burstradius, already_bursted):
 #        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
         for domain_id in neighbor_ids:
-            domain = self.domains[domain_id]
 #            domain, distance = domain_distance
 #            log.debug("%s" % str(domain))
 
 #            if distance <= burstradius and \
-            if domain_id not in already_bursted and \
-               not isinstance(domain, Multi) and \
-               not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
-               self.t != domain.last_time:
-                # Burst domain only if (AND):
-                # -within radius
-                # -domain is not a multi
-                # -domain is not zero dt NonInteractionSingle
-                # -domain has time passed
-
-                # burst the domain and add the domain_id to the list of domains that is already bursted
-                single_list = self.burst_domain(domain)
-                already_bursted.append(domain_id)
-
-                # Make sure that all the new singles are being ignored
-                already_bursted.extend(single_list)
-
-                # Additionally, also burst recursively for every single created
-                for single in single_list:
-                    already_bursted = self.burst_non_multis(single.pid_particle_pair[1].position,
-                                                            single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                            already_bursted)
-            else:
-                # Don't burst domain if (OR):
-                # -domain is farther than burst radius
-                # -domain is a multi
-                # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
-                # -domain is domain in which no time has passed
-
-                # nothing needs to happen
-                # If the domain was just bursted put it on the ignore list
-                # -> also in the future nothing needs to happen.
-                if isinstance(domain, NonInteractionSingle) and domain.is_reset():
+            if domain_id not in already_bursted:
+                domain = self.domains[domain_id]
+
+                if not isinstance(domain, Multi) and \
+                   not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
+                   self.t != domain.last_time:
+                    # Burst domain only if (AND):
+                    # -within radius
+                    # -not already bursted before
+                    # -domain is not a multi
+                    # -domain is not zero dt NonInteractionSingle
+                    # -domain has time passed
+
+                    # burst the domain and add the domain_id to the list of domains that is already bursted
                     already_bursted.append(domain_id)
+                    single_list, already_bursted = self.burst_domain(domain, already_bursted)
+
+#                    # Make sure that all the new singles are being ignored
+#                    already_bursted.extend(single_list)
+#
+#                    # Additionally, also burst recursively for every single created
+#                    for single in single_list:
+#                        already_bursted = self.burst_non_multis(single.pid_particle_pair[1].position,
+#                                                                single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+#                                                                already_bursted)
+                else:
+                    # Don't burst domain if (OR):
+                    # -domain is farther than burst radius
+                    # -domain is a multi
+                    # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
+                    # -domain is domain in which no time has passed
+
+                    # If the domain was just bursted, put it on the ignore list
+                    if isinstance(domain, NonInteractionSingle) and domain.is_reset():
+                        already_bursted.append(domain_id)
 
         log.debug("  done..")
         return already_bursted
@@ -1188,7 +1190,7 @@ def make_new_domain(self, single):
         # 1.0 Get neighboring domains and surfaces
         neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
-        surface_distances = []
+#        surface_distances = []
 #        if isinstance(single, SphericalSingle):
         surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
 
@@ -1211,7 +1213,7 @@ def make_new_domain(self, single):
         # -shell is burstable (not Multi)
         # -shell is not newly made
         # -shell is not already a zero shell (just bursted)
-        ignore = self.burst_non_multis(single_pos, reaction_threshold, [single.domain_id])
+#        ignore = self.burst_non_multis(single_pos, reaction_threshold, [single.domain_id])
 #        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
 
         # We prefer to make NonInteractionSingles for efficiency.
@@ -1402,7 +1404,7 @@ def update_single(self, single):
         return single
 
 
-    def process_single_event(self, single):
+    def process_single_event(self, single, already_bursted):
     # This method handles the things that need to be done when the current event was
     # produced by a single. The single can be a NonInteractionSingle or an InteractionSingle.
     # Note that this method is also called when a single is bursted. This event in that
@@ -1493,7 +1495,12 @@ def process_single_event(self, single):
                 single = self.create_single(pid_particle_pair)  # TODO re-use NonInteractionSingle domain if possible
                 self.add_domain_event(single)                   # TODO re-use event if possible
                 domains.append(single) 
+                already_bursted.append(single.domain_id)
 
+            for new_single in domains:
+                already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
+                                                        new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                        already_bursted)
             # 6. Log change?
                 
 # NOTE Code snippets to re-use the domain/event
@@ -1510,10 +1517,12 @@ def process_single_event(self, single):
 #        particle_radius = single.pid_particle_pair[1].radius
 #        assert newsingle.shell.shape.radius == particle_radius
 
-        return domains
+        # burst around the 'newly made' NonInteractionSingles
+
+        return domains, already_bursted
 
 
-    def process_pair_event(self, pair):
+    def process_pair_event(self, pair, already_bursted):
     # This method handles the things that need to be done when the current event was
     # produced by a pair.
     # Note that this method is also called when a pair is bursted. This event in that
@@ -1697,9 +1706,17 @@ def process_pair_event(self, pair):
             log.debug("process_pair_event: #2 { %s: %s => %s }" %
                       (single2, str(oldpos2), str(newpos2)))
 
-        return domains
+        for new_single in domains:
+            already_bursted.append(new_single.domain_id)
+        # burst around the 'newly made' NonInteractionSingles
+        for new_single in domains:
+            already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
+                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                    already_bursted)
 
-    def process_multi_event(self, multi):
+        return domains, already_bursted
+
+    def process_multi_event(self, multi, already_bursted):
         self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
         multi.step()
 
@@ -1712,32 +1729,43 @@ def process_multi_event(self, multi):
             self.last_reaction = multi.last_reaction
 
         if multi.last_event is not None:                # if an event took place
-            self.break_up_multi(multi)
+            self.break_up_multi(multi, already_bursted)
             self.multi_steps[multi.last_event] += 1
         else:
             self.add_domain_event(multi)
 
-    def break_up_multi(self, multi):
-    #Dissolves a multi in singles with a zero shell (dt=0)
+    def break_up_multi(self, multi, already_bursted):
+        #Dissolves a multi in singles with a zero shell (dt=0)
         singles = []
         for pid_particle_pair in multi.particles:
             single = self.create_single(pid_particle_pair)
             self.add_domain_event(single)
             singles.append(single)
+            already_bursted.append(single.domain_id)
 
         self.remove_domain(multi)
-        return singles
 
-    def burst_multi(self, multi):
+        # burst around the 'newly made' NonInteractionSingles
+        for new_single in singles:
+            already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
+                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                    already_bursted)
+        return singles, already_bursted
+
+    def burst_multi(self, multi, already_bursted):
         #multi.sim.sync()
+
+        if __debug__:
+            log.debug('burst multi: %s', multi)
+
         self.remove_event(multi)        # The old event was still in the scheduler
 
-        newsingles = self.break_up_multi(multi)
+        newsingles, already_bursted = self.break_up_multi(multi, already_bursted)
         # Note that the multi domain is here also removed from 'domains'
 
-        return newsingles
+        return newsingles, already_bursted
 
-    def burst_single(self, single):
+    def burst_single(self, single, already_bursted):
         # Sets next event time of 'single' to current time and event to burst event
         # returns a new single that is the result of firing the old single
         # new single also has proper zero shell and is rescheduled
@@ -1757,11 +1785,11 @@ def burst_single(self, single):
         # to simulate the natural occurence of the event we have to remove it from the scheduler
         self.remove_event(single)
 
-        newsingles = self.process_single_event(single)
+        newsingles, already_bursted = self.process_single_event(single, already_bursted)
 
-        return newsingles
+        return newsingles, already_bursted
 
-    def burst_pair(self, pair):
+    def burst_pair(self, pair, already_bursted):
         # Sets next event time of 'pair' to current time and event to burst event
         # returns two new singles that are the result of firing the pair
         # new singles also have proper zero shell and are rescheduled
@@ -1780,9 +1808,9 @@ def burst_pair(self, pair):
         # to simulate the natural occurence of the event we have to remove it from the scheduler
         self.remove_event(pair)
 
-        newsingles = self.process_pair_event(pair)
+        newsingles, already_bursted = self.process_pair_event(pair, already_bursted)
 
-        return newsingles
+        return newsingles, already_bursted
 
 
     def try_interaction(self, single, surface):
@@ -1975,8 +2003,9 @@ def add_to_multi_recursive(self, domain, multi):
 #                                                                             ignore=[domain.domain_id, multi.domain_id])
 
             # 2. Burst the domains that interfere with making the multi shell
-            burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-            ignore = self.burst_non_multis(dompos, burstradius, [domain.domain_id, multi.domain_id])
+            # NOTE this should burst nothing!
+#            burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+#            ignore = self.burst_non_multis(dompos, burstradius, [domain.domain_id, multi.domain_id])
             # This bursts only domains in which time has passed, it is assumed that other domains
             # have been made 'socially', meaning that they leave enough space for this particle to make a multi
             # shell without overlapping. 

From 780c9c213ebe4d66e9083d945c9ffda79f928313 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 1 Feb 2012 18:47:07 +0100
Subject: [PATCH 0610/1541] in burst_non_multi only finds neighbors that are
 not already bursted, testing more is useless

---
 egfrd.py | 70 +++++++++++++++++++++++++++++---------------------------
 1 file changed, 36 insertions(+), 34 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 76723ddb..258a4596 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -334,6 +334,7 @@ def stop(self, t):
                 if __debug__:
                     log.debug('burst %s, last_time= %s' % 
                               (domain, FORMAT_DOUBLE % domain.last_time))
+                ignore.append(domain.domain_id)
                 ignore = self.burst_single(domain, ignore)
             else:
                 assert False, 'domain from domains{} was no Single, Pair or Multi'
@@ -635,6 +636,7 @@ def burst_domains(self, domains, already_bursted):
     # bursts all the domains that are in the list 'domains'
         bursted = []
         for domain in domains:
+            already_bursted.append(domain.domain_id)
             d, already_bursted = self.burst_domain(domain, already_bursted)
             bursted.extend(d)
 
@@ -674,41 +676,41 @@ def burst_non_multis(self, pos, burstradius, already_bursted):
 #            log.debug("%s" % str(domain))
 
 #            if distance <= burstradius and \
-            if domain_id not in already_bursted:
-                domain = self.domains[domain_id]
-
-                if not isinstance(domain, Multi) and \
-                   not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
-                   self.t != domain.last_time:
-                    # Burst domain only if (AND):
-                    # -within radius
-                    # -not already bursted before
-                    # -domain is not a multi
-                    # -domain is not zero dt NonInteractionSingle
-                    # -domain has time passed
-
-                    # burst the domain and add the domain_id to the list of domains that is already bursted
-                    already_bursted.append(domain_id)
-                    single_list, already_bursted = self.burst_domain(domain, already_bursted)
-
-#                    # Make sure that all the new singles are being ignored
-#                    already_bursted.extend(single_list)
+#            if domain_id not in already_bursted:
+            domain = self.domains[domain_id]
+
+            if not isinstance(domain, Multi) and \
+               not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
+               self.t != domain.last_time:
+                # Burst domain only if (AND):
+                # -within radius
+                # -not already bursted before
+                # -domain is not a multi
+                # -domain is not zero dt NonInteractionSingle
+                # -domain has time passed
+ 
+                # burst the domain and add the domain_id to the list of domains that is already bursted
+                already_bursted.append(domain_id)
+                single_list, already_bursted = self.burst_domain(domain, already_bursted)
+
+#                # Make sure that all the new singles are being ignored
+#                already_bursted.extend(single_list)
 #
-#                    # Additionally, also burst recursively for every single created
-#                    for single in single_list:
-#                        already_bursted = self.burst_non_multis(single.pid_particle_pair[1].position,
-#                                                                single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-#                                                                already_bursted)
-                else:
-                    # Don't burst domain if (OR):
-                    # -domain is farther than burst radius
-                    # -domain is a multi
-                    # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
-                    # -domain is domain in which no time has passed
-
-                    # If the domain was just bursted, put it on the ignore list
-                    if isinstance(domain, NonInteractionSingle) and domain.is_reset():
-                        already_bursted.append(domain_id)
+#                # Additionally, also burst recursively for every single created
+#                for single in single_list:
+#                    already_bursted = self.burst_non_multis(single.pid_particle_pair[1].position,
+#                                                            single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+#                                                            already_bursted)
+            else:
+                # Don't burst domain if (OR):
+                # -domain is farther than burst radius
+                # -domain is a multi
+                # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
+                # -domain is domain in which no time has passed
+
+                # If the domain was just bursted, put it on the ignore list
+                if isinstance(domain, NonInteractionSingle) and domain.is_reset():
+                    already_bursted.append(domain_id)
 
         log.debug("  done..")
         return already_bursted

From 4f08052fb786e669a8ee88e3a5edfaa602f6286d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 2 Feb 2012 17:24:54 +0100
Subject: [PATCH 0611/1541] changed 'None' event for Multi to MULTI_DIFFUSION
 for clarity

---
 egfrd.py | 18 ++++++++++++------
 multi.py | 18 +++++++++---------
 2 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 258a4596..713211c3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -237,7 +237,10 @@ def reset(self):
                            EventType.BURST:0}
         self.multi_steps = {EventType.MULTI_ESCAPE:0,
                             EventType.MULTI_UNIMOLECULAR_REACTION:0,
-                            EventType.MULTI_BIMOLECULAR_REACTION:0, 3:0}
+                            EventType.MULTI_BIMOLECULAR_REACTION:0,
+                            EventType.MULTI_DIFFUSION:0,
+                            EventType.BURST:0,
+                            3:0}
         self.zero_steps = 0
         self.rejected_moves = 0
         self.reaction_events = 0
@@ -1719,20 +1722,22 @@ def process_pair_event(self, pair, already_bursted):
         return domains, already_bursted
 
     def process_multi_event(self, multi, already_bursted):
-        self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
-        multi.step()
 
         if __debug__:
             log.info('FIRE MULTI: %s' % multi.last_event)
 
+        self.multi_steps[multi.last_event] += 1
+        self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
+        multi.step()
+
         if(multi.last_event == EventType.MULTI_UNIMOLECULAR_REACTION or
            multi.last_event == EventType.MULTI_BIMOLECULAR_REACTION):
             self.reaction_events += 1
             self.last_reaction = multi.last_reaction
 
-        if multi.last_event is not None:                # if an event took place
+        if multi.last_event is not EventType.MULTI_DIFFUSION:                # if an event took place
             self.break_up_multi(multi, already_bursted)
-            self.multi_steps[multi.last_event] += 1
+#            self.multi_steps[multi.last_event] += 1
         else:
             self.add_domain_event(multi)
 
@@ -2143,7 +2148,7 @@ def print_report(self, out=None):
 \tSingle:\t%d\t(escape: %d, reaction: %d, bursted: %d)
 \tInteraction: %d\t(escape: %d, interaction: %d, bursted: %d)
 \tPair:\t%d\t(escape r: %d, R: %d, reaction pair: %d, single: %d, bursted: %d)
-\tMulti:\t%d\t(escape: %d, reaction pair: %d, single: %d)
+\tMulti:\t%d\t(escape: %d, reaction pair: %d, single: %d, bursted: %d)
 total reactions = %d
 rejected moves = %d
 ''' \
@@ -2166,6 +2171,7 @@ def print_report(self, out=None):
                self.multi_steps[EventType.MULTI_ESCAPE],
                self.multi_steps[EventType.MULTI_BIMOLECULAR_REACTION],
                self.multi_steps[EventType.MULTI_UNIMOLECULAR_REACTION],
+               self.multi_steps[EventType.BURST],
                self.reaction_events,
                self.rejected_moves
                )
diff --git a/multi.py b/multi.py
index 4472e47a..b69c5152 100644
--- a/multi.py
+++ b/multi.py
@@ -19,8 +19,8 @@ def __init__(self, domain_id, main, step_size_factor):
         #       Only the methods of the hasSphericalShell class are used
 
         self.main = ref(main)
-        self.last_event = None
-        self.event_Type = EventType.MULTI_DIFFUSION
+        self.last_event = EventType.MULTI_DIFFUSION     #None
+#        self.event_type = EventType.MULTI_DIFFUSION
 
         self.sphere_container = _gfrd.SphericalShellContainer(main.world.world_size, 3)
         self.particle_container = _gfrd.MultiParticleContainer(main.world)
@@ -98,7 +98,7 @@ def __call__(self, shape, ignore0, ignore1=None):
                         shape.position, -(shape.radius + self.outer_.reaction_length) ))
                 if not within_radius:
                     main = self.outer_.main()
-                    if self.outer_.last_event == None:
+                    if self.outer_.last_event == EventType.MULTI_DIFFUSION: #None:
                         self.outer_.last_event = EventType.MULTI_ESCAPE
                     main.burst_volume(shape.position, shape.radius, 
                                       ignore=[self.outer_.domain_id, ])
@@ -117,7 +117,7 @@ def __call__(self, shape, ignore0, ignore1=None):
                      myrandom.rng, self.dt, main.dissociation_retry_moves, self.reaction_length,
                      cr, vc, [pid for pid, _ in self.particle_container])
 
-        self.last_event = None        
+        self.last_event = EventType.MULTI_DIFFUSION     #None
         while ppg():
             if cr.reactions:
                 self.last_reaction = cr.reactions[-1]
@@ -137,7 +137,7 @@ def __call__(self, shape, ignore0, ignore1=None):
         #         return
 
         #     if not self.within_shell(pid_particle_pair):
-        #         if self.last_event == None:
+        #         if self.last_event == EventType.MULTI_DIFFUSION   #None:
         #             self.last_event = EventType.MULTI_ESCAPE
         #         main.clear_volume(
         #             pid_particle_pair[1].position,
@@ -150,10 +150,10 @@ def check(self):
         assert self.multiplicity == self.num_shells, \
             'number of particles is not equal to number of shells'
         # Event is DIFFUSION, SINGLE_REACTION, BIMOL_REACTION, ESCAPE
-        assert self.event_Type == EventType.MULTI_DIFFUSION or \
-               self.event_Type == EventType.MULTI_ESCAPE or \
-               self.event_Type == EventType.MULTI_UNIMOLECULAR_REACTION or \
-               self.event_Type == EventType.MULTI_BIMOLECULAR_REACTION, \
+        assert self.last_event == EventType.MULTI_DIFFUSION or \
+               self.last_event == EventType.MULTI_ESCAPE or \
+               self.last_event == EventType.MULTI_UNIMOLECULAR_REACTION or \
+               self.last_event == EventType.MULTI_BIMOLECULAR_REACTION, \
                     'event_type of Multi was not of proper type'
 
         # check that the shells of the multi are contiguous

From 8a8a91432d88ee9881d80a9d1dd3aa0f44fac3d0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 6 Feb 2012 13:37:32 +0100
Subject: [PATCH 0612/1541] including fire_.. methods and further enhancements
 of the recursive bursting algoritm

---
 egfrd.py | 160 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 82 insertions(+), 78 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 713211c3..2f94bf22 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -346,7 +346,8 @@ def stop(self, t):
         # then burst all Pairs and Multis.
         if __debug__:
             log.debug('burst %s' % non_single_list)
-        self.burst_domains(non_single_list, ignore)
+        non_single_ids = [non_single.domain_id for non_single in non_single_list]
+        self.burst_domains(non_single_ids, ignore)
 
         self.dt = 0.0
 
@@ -635,13 +636,16 @@ def burst_domain(self, domain, already_bursted):
 
         return bursted, already_bursted
 
-    def burst_domains(self, domains, already_bursted):
+    def burst_domains(self, domain_ids, already_bursted):
     # bursts all the domains that are in the list 'domains'
         bursted = []
-        for domain in domains:
-            already_bursted.append(domain.domain_id)
-            d, already_bursted = self.burst_domain(domain, already_bursted)
-            bursted.extend(d)
+        for domain_id in domain_ids:
+            if domain_id not in already_bursted:
+                already_bursted.append(domain_id)
+
+                domain = self.domains[domain_id]
+                d, already_bursted = self.burst_domain(domain, already_bursted)
+                bursted.extend(d)
 
         return bursted, already_bursted
 
@@ -661,64 +665,55 @@ def burst_volume(self, pos, radius, ignore=[]):
         # burst in a circle, when you want to make a new shell in the membrane.
         # Then we may want to burst in a cylindrical volume, not a sphere
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius,
-                                                                               ignore)
-        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
-        return self.burst_domains(neighbors, ignore)
+                                                                                  ignore)
+#        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+        return self.burst_domains(neighbor_ids, ignore)
 
     def burst_non_multis(self, pos, burstradius, already_bursted):
         # Recursively bursts the domains in 'domains' if within burstradius
-        # Returns the updated list of domains with their distances
+        # Returns the updated list domains that are already bursted
+        new_singles = []
 
         log.debug("burst_non_multi")
 
+        # get the neighbors in the burstradius that are not already bursted.
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, burstradius, already_bursted)
-#        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
 
         for domain_id in neighbor_ids:
-#            domain, distance = domain_distance
-#            log.debug("%s" % str(domain))
-
-#            if distance <= burstradius and \
-#            if domain_id not in already_bursted:
-            domain = self.domains[domain_id]
-
-            if not isinstance(domain, Multi) and \
-               not (isinstance(domain, NonInteractionSingle) and domain.is_reset()) and \
-               self.t != domain.last_time:
-                # Burst domain only if (AND):
-                # -within radius
-                # -not already bursted before
-                # -domain is not a multi
-                # -domain is not zero dt NonInteractionSingle
-                # -domain has time passed
- 
-                # burst the domain and add the domain_id to the list of domains that is already bursted
-                already_bursted.append(domain_id)
-                single_list, already_bursted = self.burst_domain(domain, already_bursted)
+            if domain_id not in already_bursted:        # the list 'already_bursted' may have been updated in a
+                domain = self.domains[domain_id]        # previous iteration of the loop
 
-#                # Make sure that all the new singles are being ignored
-#                already_bursted.extend(single_list)
-#
-#                # Additionally, also burst recursively for every single created
-#                for single in single_list:
-#                    already_bursted = self.burst_non_multis(single.pid_particle_pair[1].position,
-#                                                            single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-#                                                            already_bursted)
-            else:
-                # Don't burst domain if (OR):
-                # -domain is farther than burst radius
-                # -domain is a multi
-                # -domain is already a burst NonInteractionSingle (zero dt NonInteractionSingle)
-                # -domain is domain in which no time has passed
-
-                # If the domain was just bursted, put it on the ignore list
                 if isinstance(domain, NonInteractionSingle) and domain.is_reset():
+                    # If the domain was already bursted, but was not on the ignore list yet, put it there.
+                    # NOTE: we assume that the domain has already bursted around it when it was made!
+                    already_bursted.append(domain_id)
+
+                elif (not isinstance(domain, Multi)) and (self.t != domain.last_time):
+                    # Burst domain only if (AND):
+                    # -within burstradius
+                    # -not already bursted before (not on 'already_bursted' list)
+                    # -domain is not zero dt NonInteractionSingle
+                    # -domain is not a multi
+                    # -domain has time passed
+ 
+                    # add the domain_id to the list of domains that is already bursted,
+                    # and burst the domain.
                     already_bursted.append(domain_id)
+                    new_singles, already_bursted = self.burst_domain(domain, already_bursted)
+                    # The list 'already_bursted' is now updated with domains that are recursively bursted
+
+                #else:
+                    # Don't burst domain if (OR):
+                    # -domain is farther than burst radius
+                    # -domain is already a burst NonInteractionSingle (is on the 'already_bursted' list)
+                    # -domain is a multi
+                    # -domain is domain in which no time has passed
+
 
         log.debug("  done..")
-        return already_bursted
+        return new_singles, already_bursted
 
-    def fire_single_reaction(self, single, reactant_pos):
+    def fire_single_reaction(self, single, reactant_pos, ignore=[]):
         # This takes care of the identity change when a single particle decays into
         # one or a number of other particles
         # It performs the reactions:
@@ -787,7 +782,7 @@ def fire_single_reaction(self, single, reactant_pos):
 
                 # 2. make space for the products.
 #                if product_pos != reactant_pos or product_radius > reactant_radius:
-                self.burst_volume(product_pos, product_radius)
+                _, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
                 # 3. check that there is space for the products 
                 if (not self.world.check_overlap((product_pos, product_radius), reactant[0])):
@@ -959,7 +954,7 @@ def fire_single_reaction(self, single, reactant_pos):
             #    calculate the sphere around the two product particles
             rad = max(product1_displacement + product1_radius,
                       product2_displacement + product2_radius)
-            self.burst_volume(reactant_pos, rad)
+            _,ignore = self.burst_volume(reactant_pos, rad, ignore)
 
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
@@ -995,9 +990,9 @@ def fire_single_reaction(self, single, reactant_pos):
         else:
             raise RuntimeError('num products >= 3 not supported.')
 
-        return products
+        return products, ignore
 
-    def fire_interaction(self, single, reactant_pos):
+    def fire_interaction(self, single, reactant_pos, ignore=[]):
         # This takes care of the identity change when a particle associates with a surface
         # It performs the reactions:
         # A(structure) + surface -> 0
@@ -1044,7 +1039,7 @@ def fire_interaction(self, single, reactant_pos):
             #    Note that an interaction domain is already sized such that it includes the
             #    reactant particle moving into the surface.
             if product_radius > reactant_radius:
-                self.burst_volume(product_pos, product_radius)
+                _, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
@@ -1071,10 +1066,10 @@ def fire_interaction(self, single, reactant_pos):
         else:
             raise RuntimeError('fire_interaction: num products > 1 not supported.')
 
-        return products
+        return products, ignore
 
 
-    def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos):
+    def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore=[]):
         # This takes care of the identity change when two particles react with each other
         # It performs the reactions:
         # A(any structure) + B(same structure) -> 0
@@ -1116,7 +1111,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos):
             # 2.  make space for products
             # 2.1 if the product particle sticks out of the shell
 #            if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_radius):
-            self.burst_volume(product_pos, product_radius)
+            _, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products ignoring the reactants
             if self.world.check_overlap((product_pos, product_radius), pid_particle_pair1[0],
@@ -1147,18 +1142,18 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos):
         else:
             raise NotImplementedError('num products >= 2 not supported.')
 
-        return products
+        return products, ignore
 
 
-    def fire_move(self, single, reactant_pos, ignore=None):
+    def fire_move(self, single, reactant_pos, ignore_p=None):
         # No reactions/Interactions have taken place -> no identity change of the particle
         # Just only move the particles
 
         reactant = single.pid_particle_pair
 
-        if ignore:
+        if ignore_p:
             if self.world.check_overlap((reactant_pos, reactant[1].radius),
-                                        reactant[0], ignore[0]):
+                                        reactant[0], ignore_p[0]):
                 raise RuntimeError('fire_move: particle overlap failed.')
         else:
             if self.world.check_overlap((reactant_pos, reactant[1].radius),
@@ -1218,7 +1213,7 @@ def make_new_domain(self, single):
         # -shell is burstable (not Multi)
         # -shell is not newly made
         # -shell is not already a zero shell (just bursted)
-#        ignore = self.burst_non_multis(single_pos, reaction_threshold, [single.domain_id])
+#       _, ignore = self.burst_non_multis(single_pos, reaction_threshold, [single.domain_id])
 #        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
 
         # We prefer to make NonInteractionSingles for efficiency.
@@ -1426,6 +1421,9 @@ def process_single_event(self, single, already_bursted):
             domains = [self.make_new_domain(single)]
             # domain is already scheduled in make_new_domain
 
+
+
+
         ### 1.1 Special cases (shortcuts)
         # In case nothing is scheduled to happen: do nothing and just reschedule
         elif single.dt == numpy.inf:
@@ -1483,11 +1481,11 @@ def process_single_event(self, single, already_bursted):
 
                 if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
-                    particles = self.fire_single_reaction(single, newpos)
+                    particles, already_bursted = self.fire_single_reaction(single, newpos, already_bursted)
 
                 else:
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
-                    particles = self.fire_interaction(single, newpos)
+                    particles, already_bursted = self.fire_interaction(single, newpos, already_bursted)
 
             else:
                 particles = self.fire_move(single, newpos)
@@ -1503,9 +1501,11 @@ def process_single_event(self, single, already_bursted):
                 already_bursted.append(single.domain_id)
 
             for new_single in domains:
-                already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
-                                                        new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                        already_bursted)
+                burst_products, already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
+                                                                        new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                                        already_bursted)
+            domains.extend(burst_products)
+
             # 6. Log change?
                 
 # NOTE Code snippets to re-use the domain/event
@@ -1604,11 +1604,13 @@ def process_pair_event(self, pair, already_bursted):
                 # first move the non-reacting particle
                 particles = self.fire_move(single2, newpos2, pid_particle_pair1)
                 # don't ignore the (moved) non-reacting particle
-                particles.extend(self.fire_single_reaction(single1, newpos1))
+                particles2, already_bursted = self.fire_single_reaction(single1, newpos1, already_bursted)
+                particles.extend(particles2)
             else:
                 theothersingle = single1
                 particles = self.fire_move(single1, newpos1, pid_particle_pair2)
-                particles.extend(self.fire_single_reaction(single2, newpos2))
+                particles2, already_bursted = self.fire_single_reaction(single2, newpos2, already_bursted)
+                particles.extend(particles2)
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
@@ -1626,7 +1628,7 @@ def process_pair_event(self, pair, already_bursted):
         #
         elif pair.event_type == EventType.IV_REACTION:
 
-            particles = self.fire_pair_reaction (pair, newpos1, newpos2)
+            particles, already_bursted = self.fire_pair_reaction (pair, newpos1, newpos2, already_bursted)
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
             domains = []
@@ -1715,9 +1717,10 @@ def process_pair_event(self, pair, already_bursted):
             already_bursted.append(new_single.domain_id)
         # burst around the 'newly made' NonInteractionSingles
         for new_single in domains:
-            already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
-                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                    already_bursted)
+            burst_products, already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
+                                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                                    already_bursted)
+        domains.extend(burst_products)
 
         return domains, already_bursted
 
@@ -1743,6 +1746,8 @@ def process_multi_event(self, multi, already_bursted):
 
     def break_up_multi(self, multi, already_bursted):
         #Dissolves a multi in singles with a zero shell (dt=0)
+        self.remove_domain(multi)
+
         singles = []
         for pid_particle_pair in multi.particles:
             single = self.create_single(pid_particle_pair)
@@ -1750,13 +1755,12 @@ def break_up_multi(self, multi, already_bursted):
             singles.append(single)
             already_bursted.append(single.domain_id)
 
-        self.remove_domain(multi)
-
         # burst around the 'newly made' NonInteractionSingles
         for new_single in singles:
-            already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
-                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                    already_bursted)
+            burst_products, already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
+                                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                                    already_bursted)
+        singles.extend(burst_products)
         return singles, already_bursted
 
     def burst_multi(self, multi, already_bursted):

From 940762f195baf1bfce53e8ad3b78449bf6955dd9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 6 Feb 2012 20:07:59 +0100
Subject: [PATCH 0613/1541] namechange: already_bursted -> ignore,
 newsingles/burst_products -> zero_singles

---
 egfrd.py | 202 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 102 insertions(+), 100 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2f94bf22..7907597d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -614,40 +614,43 @@ def update_domain_event(self, t, domain):
                      (domain.domain_id, domain.event_id, FORMAT_DOUBLE % t))
         self.scheduler.update((domain.event_id, DomainEvent(t, domain)))
 
-    def burst_domain(self, domain, already_bursted):
+    def burst_domain(self, domain, ignore):
     # Reduces and domain (Single, Pair or Multi) to Singles with the zero shell, and dt=0
     # return a list of Singles that was the result of the bursting
+
         if __debug__:
             log.info('burst_domain: %s' % domain)
 
         if isinstance(domain, Single):
             # TODO. Compare with gfrd.
-            bursted, already_bursted = self.burst_single(domain, already_bursted)
+            zero_singles, ignore = self.burst_single(domain, ignore)
         elif isinstance(domain, Pair):  # Pair
-            bursted, already_bursted = self.burst_pair(domain, already_bursted)
+            zero_singles, ignore = self.burst_pair(domain, ignore)
         else:                           # Multi
             assert isinstance(domain, Multi)
-            bursted, already_bursted = self.burst_multi(domain, already_bursted)
+            zero_singles, ignore = self.burst_multi(domain, ignore)
 
         if __debug__:
             # After a burst, InteractionSingles should be gone.
-            assert all(not isinstance(b, InteractionSingle) for b in bursted)
-            log.info('bursted = %s' % ',\n\t  '.join(str(i) for i in bursted))
+            assert all(not isinstance(b, InteractionSingle) for b in zero_singles)
+            log.info('zero_singles = %s' % ',\n\t  '.join(str(i) for i in zero_singles))
+
+        return zero_singles, ignore
 
-        return bursted, already_bursted
+    def burst_domains(self, domain_ids, ignore=[]):
+    # bursts all the domains that are in the list 'domain_ids'
+    # ignores all the domain ids on ignore
 
-    def burst_domains(self, domain_ids, already_bursted):
-    # bursts all the domains that are in the list 'domains'
-        bursted = []
+        zero_singles = []
         for domain_id in domain_ids:
-            if domain_id not in already_bursted:
-                already_bursted.append(domain_id)
+            if domain_id not in ignore:
+                ignore.append(domain_id)
 
                 domain = self.domains[domain_id]
-                d, already_bursted = self.burst_domain(domain, already_bursted)
-                bursted.extend(d)
+                zero_singles2, ignore = self.burst_domain(domain, ignore)
+                zero_singles.extend(zero_singles2)
 
-        return bursted, already_bursted
+        return zero_singles, ignore
 
     def burst_volume(self, pos, radius, ignore=[]):
         """ Burst domains within a certain volume and give their ids.
@@ -664,56 +667,53 @@ def burst_volume(self, pos, radius, ignore=[]):
         # It is inefficient to burst on the 'other' side of the membrane or to
         # burst in a circle, when you want to make a new shell in the membrane.
         # Then we may want to burst in a cylindrical volume, not a sphere
-        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius,
-                                                                                  ignore)
-#        neighbors = [self.domains[domain_id] for domain_id in neighbor_ids]
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius, ignore)
         return self.burst_domains(neighbor_ids, ignore)
 
-    def burst_non_multis(self, pos, burstradius, already_bursted):
+    def burst_non_multis(self, pos, burstradius, ignore):
         # Recursively bursts the domains in 'domains' if within burstradius
         # Returns the updated list domains that are already bursted
-        new_singles = []
-
-        log.debug("burst_non_multi")
+        zero_singles = []
 
         # get the neighbors in the burstradius that are not already bursted.
-        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, burstradius, already_bursted)
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, burstradius, ignore)
 
         for domain_id in neighbor_ids:
-            if domain_id not in already_bursted:        # the list 'already_bursted' may have been updated in a
+            if domain_id not in ignore:                 # the list 'ignore' may have been updated in a
                 domain = self.domains[domain_id]        # previous iteration of the loop
 
                 if isinstance(domain, NonInteractionSingle) and domain.is_reset():
                     # If the domain was already bursted, but was not on the ignore list yet, put it there.
                     # NOTE: we assume that the domain has already bursted around it when it was made!
-                    already_bursted.append(domain_id)
+                    ignore.append(domain_id)
 
                 elif (not isinstance(domain, Multi)) and (self.t != domain.last_time):
                     # Burst domain only if (AND):
                     # -within burstradius
-                    # -not already bursted before (not on 'already_bursted' list)
+                    # -not already bursted before (not on 'ignore' list)
                     # -domain is not zero dt NonInteractionSingle
                     # -domain is not a multi
                     # -domain has time passed
  
                     # add the domain_id to the list of domains that is already bursted,
                     # and burst the domain.
-                    already_bursted.append(domain_id)
-                    new_singles, already_bursted = self.burst_domain(domain, already_bursted)
-                    # The list 'already_bursted' is now updated with domains that are recursively bursted
+                    ignore.append(domain_id)
+                    zero_singles, ignore = self.burst_domain(domain, ignore)
+                    # The list 'ignore' is now updated with domains that are recursively bursted
 
                 #else:
                     # Don't burst domain if (OR):
                     # -domain is farther than burst radius
-                    # -domain is already a burst NonInteractionSingle (is on the 'already_bursted' list)
+                    # -domain is already a burst NonInteractionSingle (is on the 'ignore' list)
                     # -domain is a multi
                     # -domain is domain in which no time has passed
 
+                    # NOTE that the domain id is NOT added to the ignore list since it may be bursted at a later
+                    # time
 
-        log.debug("  done..")
-        return new_singles, already_bursted
+        return zero_singles, ignore
 
-    def fire_single_reaction(self, single, reactant_pos, ignore=[]):
+    def fire_single_reaction(self, single, reactant_pos, ignore):
         # This takes care of the identity change when a single particle decays into
         # one or a number of other particles
         # It performs the reactions:
@@ -767,7 +767,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore=[]):
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
                         unit_vector3D = random_unit_vector()
-                        unit_vector2D = normalize(unit_vector3D - numpy.dot(unit_vector3D, reactant_structure.shape.unit_z))
+                        unit_vector2D = normalize(unit_vector3D - 
+                                        (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
                         vector = reactant_pos + vector_length * unit_vector2D
                         product_pos_list.append(vector)
                 else:
@@ -992,7 +993,7 @@ def fire_single_reaction(self, single, reactant_pos, ignore=[]):
 
         return products, ignore
 
-    def fire_interaction(self, single, reactant_pos, ignore=[]):
+    def fire_interaction(self, single, reactant_pos, ignore):
         # This takes care of the identity change when a particle associates with a surface
         # It performs the reactions:
         # A(structure) + surface -> 0
@@ -1069,7 +1070,7 @@ def fire_interaction(self, single, reactant_pos, ignore=[]):
         return products, ignore
 
 
-    def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore=[]):
+    def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
         # This takes care of the identity change when two particles react with each other
         # It performs the reactions:
         # A(any structure) + B(same structure) -> 0
@@ -1404,7 +1405,7 @@ def update_single(self, single):
         return single
 
 
-    def process_single_event(self, single, already_bursted):
+    def process_single_event(self, single, ignore):
     # This method handles the things that need to be done when the current event was
     # produced by a single. The single can be a NonInteractionSingle or an InteractionSingle.
     # Note that this method is also called when a single is bursted. This event in that
@@ -1481,30 +1482,31 @@ def process_single_event(self, single, already_bursted):
 
                 if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
-                    particles, already_bursted = self.fire_single_reaction(single, newpos, already_bursted)
+                    particles, ignore = self.fire_single_reaction(single, newpos, ignore)
 
                 else:
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
-                    particles, already_bursted = self.fire_interaction(single, newpos, already_bursted)
+                    particles, ignore = self.fire_interaction(single, newpos, ignore)
 
             else:
                 particles = self.fire_move(single, newpos)
 
             # 5. Make a (new) domain (reuse) domain for each particle(s)
             #    (Re)schedule the (new) domain
-            domains = []
+            zero_singles = []
             for pid_particle_pair in particles:
 #               single.pid_particle_pair = pid_particle_pair    # reuse single
-                single = self.create_single(pid_particle_pair)  # TODO re-use NonInteractionSingle domain if possible
-                self.add_domain_event(single)                   # TODO re-use event if possible
-                domains.append(single) 
-                already_bursted.append(single.domain_id)
-
-            for new_single in domains:
-                burst_products, already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
-                                                                        new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                                        already_bursted)
-            domains.extend(burst_products)
+                zero_single = self.create_single(pid_particle_pair)  # TODO re-use NonInteractionSingle domain if possible
+                self.add_domain_event(zero_single)                   # TODO re-use event if possible
+                zero_singles.append(zero_single) 
+                ignore.append(zero_single.domain_id)
+
+            for zero_single in zero_singles:
+                zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
+                                                              zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                              ignore)
+            zero_singles.extend(zero_singles2)
+            domains = zero_singles
 
             # 6. Log change?
                 
@@ -1524,10 +1526,10 @@ def process_single_event(self, single, already_bursted):
 
         # burst around the 'newly made' NonInteractionSingles
 
-        return domains, already_bursted
+        return domains, ignore
 
 
-    def process_pair_event(self, pair, already_bursted):
+    def process_pair_event(self, pair, ignore):
     # This method handles the things that need to be done when the current event was
     # produced by a pair.
     # Note that this method is also called when a pair is bursted. This event in that
@@ -1604,39 +1606,39 @@ def process_pair_event(self, pair, already_bursted):
                 # first move the non-reacting particle
                 particles = self.fire_move(single2, newpos2, pid_particle_pair1)
                 # don't ignore the (moved) non-reacting particle
-                particles2, already_bursted = self.fire_single_reaction(single1, newpos1, already_bursted)
+                particles2, ignore = self.fire_single_reaction(single1, newpos1, ignore)
                 particles.extend(particles2)
             else:
                 theothersingle = single1
                 particles = self.fire_move(single1, newpos1, pid_particle_pair2)
-                particles2, already_bursted = self.fire_single_reaction(single2, newpos2, already_bursted)
+                particles2, ignore = self.fire_single_reaction(single2, newpos2, ignore)
                 particles.extend(particles2)
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
-            domains = []
+            zero_singles = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
-                single = self.create_single(pid_particle_pair)  # TODO reuse the non-reacting single domain
-                self.add_domain_event(single)
-                domains.append(single)
+                zero_single = self.create_single(pid_particle_pair)  # TODO reuse the non-reacting single domain
+                self.add_domain_event(zero_single)
+                zero_singles.append(zero_single)
 
         #
         #       2. Pair reaction
         #
         elif pair.event_type == EventType.IV_REACTION:
 
-            particles, already_bursted = self.fire_pair_reaction (pair, newpos1, newpos2, already_bursted)
+            particles, ignore = self.fire_pair_reaction (pair, newpos1, newpos2, ignore)
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
-            domains = []
+            zero_singles = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
-                single = self.create_single(pid_particle_pair)
-                self.add_domain_event(single)
-                domains.append(single)
+                zero_single = self.create_single(pid_particle_pair)
+                self.add_domain_event(zero_single)
+                zero_singles.append(zero_single)
 
         # Just moving the particles
         #       3a. IV escape
@@ -1645,16 +1647,16 @@ def process_pair_event(self, pair, already_bursted):
              pair.event_type == EventType.COM_ESCAPE or
              pair.event_type == EventType.BURST):
 
-            particles = self.fire_move (single1, newpos1, pid_particle_pair2)
+            particles      = self.fire_move (single1, newpos1, pid_particle_pair2)
             particles.extend(self.fire_move (single2, newpos2, pid_particle_pair1))
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
-            domains = []
+            zero_singles = []
             for pid_particle_pair in particles:
                 # 5. make a new single and schedule
-                single = self.create_single(pid_particle_pair)  # TODO reuse domains that were cached in the pair
-                self.add_domain_event(single)
-                domains.append(single)
+                zero_single = self.create_single(pid_particle_pair)  # TODO reuse domains that were cached in the pair
+                self.add_domain_event(zero_single)
+                zero_singles.append(zero_single)
 
         else:
             raise SystemError('process_pair_event: invalid event_type.')
@@ -1713,18 +1715,18 @@ def process_pair_event(self, pair, already_bursted):
             log.debug("process_pair_event: #2 { %s: %s => %s }" %
                       (single2, str(oldpos2), str(newpos2)))
 
-        for new_single in domains:
-            already_bursted.append(new_single.domain_id)
+        for zero_single in zero_singles:
+            ignore.append(zero_single.domain_id)
         # burst around the 'newly made' NonInteractionSingles
-        for new_single in domains:
-            burst_products, already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
-                                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                                    already_bursted)
-        domains.extend(burst_products)
+        for zero_single in zero_singles:
+            zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
+                                                          zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                          ignore)
+        zero_singles.extend(zero_singles2)
 
-        return domains, already_bursted
+        return zero_singles, ignore
 
-    def process_multi_event(self, multi, already_bursted):
+    def process_multi_event(self, multi, ignore):
 
         if __debug__:
             log.info('FIRE MULTI: %s' % multi.last_event)
@@ -1739,31 +1741,31 @@ def process_multi_event(self, multi, already_bursted):
             self.last_reaction = multi.last_reaction
 
         if multi.last_event is not EventType.MULTI_DIFFUSION:                # if an event took place
-            self.break_up_multi(multi, already_bursted)
+            self.break_up_multi(multi, ignore)
 #            self.multi_steps[multi.last_event] += 1
         else:
             self.add_domain_event(multi)
 
-    def break_up_multi(self, multi, already_bursted):
+    def break_up_multi(self, multi, ignore):
         #Dissolves a multi in singles with a zero shell (dt=0)
         self.remove_domain(multi)
 
-        singles = []
+        zero_singles = []
         for pid_particle_pair in multi.particles:
-            single = self.create_single(pid_particle_pair)
-            self.add_domain_event(single)
-            singles.append(single)
-            already_bursted.append(single.domain_id)
+            zero_single = self.create_single(pid_particle_pair)
+            self.add_domain_event(zero_single)
+            zero_singles.append(zero_single)
+            ignore.append(zero_single.domain_id)
 
         # burst around the 'newly made' NonInteractionSingles
-        for new_single in singles:
-            burst_products, already_bursted = self.burst_non_multis(new_single.pid_particle_pair[1].position,
-                                                                    new_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                                    already_bursted)
-        singles.extend(burst_products)
-        return singles, already_bursted
-
-    def burst_multi(self, multi, already_bursted):
+        for zero_single in zero_singles:
+            zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
+                                                          zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                          ignore)
+        zero_singles.extend(zero_singles2)
+        return zero_singles, ignore
+
+    def burst_multi(self, multi, ignore):
         #multi.sim.sync()
 
         if __debug__:
@@ -1771,12 +1773,12 @@ def burst_multi(self, multi, already_bursted):
 
         self.remove_event(multi)        # The old event was still in the scheduler
 
-        newsingles, already_bursted = self.break_up_multi(multi, already_bursted)
+        zero_singles, ignore = self.break_up_multi(multi, ignore)
         # Note that the multi domain is here also removed from 'domains'
 
-        return newsingles, already_bursted
+        return zero_singles, ignore
 
-    def burst_single(self, single, already_bursted):
+    def burst_single(self, single, ignore):
         # Sets next event time of 'single' to current time and event to burst event
         # returns a new single that is the result of firing the old single
         # new single also has proper zero shell and is rescheduled
@@ -1796,11 +1798,11 @@ def burst_single(self, single, already_bursted):
         # to simulate the natural occurence of the event we have to remove it from the scheduler
         self.remove_event(single)
 
-        newsingles, already_bursted = self.process_single_event(single, already_bursted)
+        zero_singles, ignore = self.process_single_event(single, ignore)
 
-        return newsingles, already_bursted
+        return zero_singles, ignore
 
-    def burst_pair(self, pair, already_bursted):
+    def burst_pair(self, pair, ignore):
         # Sets next event time of 'pair' to current time and event to burst event
         # returns two new singles that are the result of firing the pair
         # new singles also have proper zero shell and are rescheduled
@@ -1819,9 +1821,9 @@ def burst_pair(self, pair, already_bursted):
         # to simulate the natural occurence of the event we have to remove it from the scheduler
         self.remove_event(pair)
 
-        newsingles, already_bursted = self.process_pair_event(pair, already_bursted)
+        zero_singles, ignore = self.process_pair_event(pair, ignore)
 
-        return newsingles, already_bursted
+        return zero_singles, ignore
 
 
     def try_interaction(self, single, surface):

From 301470eb495e3100263fd5fb3127f2b3ae76dd44 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 6 Feb 2012 20:23:58 +0100
Subject: [PATCH 0614/1541] when debugging is off still needs some stuff

---
 egfrd.py | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7907597d..b0815066 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -455,9 +455,9 @@ def create_single(self, pid_particle_pair):
         # 3. update the proper shell container
         self.geometrycontainer.move_shell(single.shell_id_shell_pair)
 
-        if __debug__:
-            # Used in __str__.
-            single.world = self.world
+#        if __debug__:
+#            # Used in __str__.
+        single.world = self.world
 
         return single
 
@@ -498,9 +498,9 @@ def create_interaction(self, testShell):
         # 3. update the shell containers 
         self.geometrycontainer.move_shell(interaction.shell_id_shell_pair)
 
-        if __debug__:
-            # Used in __str__.
-            interaction.world = self.world
+#        if __debug__:
+#            # Used in __str__.
+        interaction.world = self.world
 
         return interaction
 
@@ -531,9 +531,9 @@ def create_pair(self, testShell):
         # 3. update the shell containers with the new shell
         self.geometrycontainer.move_shell(pair.shell_id_shell_pair)
 
-        if __debug__:
-            # Used in __str__.
-            pair.world = self.world
+#        if __debug__:
+#            # Used in __str__.
+        pair.world = self.world
 
         return pair
 
@@ -1310,7 +1310,8 @@ def make_new_domain(self, single):
                 # In case there is really nothing
                 closest_overlap = numpy.inf
 
-            log.debug('Single or Multi: closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
+            if __debug__:
+                log.debug('Single or Multi: closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
 
             # If the closest partner is within the multi horizon we do Multi, otherwise Single
             if closest_overlap > 0.0: 
@@ -1541,16 +1542,18 @@ def process_pair_event(self, pair, ignore):
             log.info('single2 = %s' % pair.single2)
 
         ### 1. check that everything is ok
-        assert self.check_domain(pair)
-        assert pair.single1.domain_id not in self.domains
-        assert pair.single2.domain_id not in self.domains
+        if __debug__:
+            assert self.check_domain(pair)
+            assert pair.single1.domain_id not in self.domains
+            assert pair.single2.domain_id not in self.domains
         # TODO assert that there is no event associated with this domain in the scheduler
 
         # check that the event time of the single (last_time + dt) is equal to the
         # simulator time
-        assert (abs(pair.last_time + pair.dt - self.t) <= TIME_TOLERANCE * self.t), \
-            'Timeline incorrect. pair.last_time = %s, pair.dt = %s, self.t = %s' % \
-            (FORMAT_DOUBLE % pair.last_time, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % self.t)
+        if __debug__:
+            assert (abs(pair.last_time + pair.dt - self.t) <= TIME_TOLERANCE * self.t), \
+                    'Timeline incorrect. pair.last_time = %s, pair.dt = %s, self.t = %s' % \
+                    (FORMAT_DOUBLE % pair.last_time, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % self.t)
 
         ### 2. get some necessary information
         single1 = pair.single1

From c65a01744aa2b0546fae660486d58072ca5baa5f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 7 Feb 2012 19:01:32 +0100
Subject: [PATCH 0615/1541] cleanup. Added/changed comments, moved some
 methods, removed redundant stuff, namechanges

---
 egfrd.py | 534 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 323 insertions(+), 211 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b0815066..44d39ed3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -322,32 +322,33 @@ def stop(self, t):
 
         self.t = t
 
-        non_single_list = []
+#        non_single_list = []
 
         # Burst all the domains that we know of.
-        # TODO because of recursive bursting, domains that are still on the list may already have been bursted.
+        self.burst_all_domains()
         # first burst all Singles, and put Pairs and Multis in a list.
 #        for id, event in self.scheduler:
-        ignore = []
-        for _, domain in self.domains.items():
-#            obj = self.domains[event.data]
-            if isinstance(domain, Pair) or isinstance(domain, Multi):
-                non_single_list.append(domain)
-            elif isinstance(domain, Single):
-                if __debug__:
-                    log.debug('burst %s, last_time= %s' % 
-                              (domain, FORMAT_DOUBLE % domain.last_time))
-                ignore.append(domain.domain_id)
-                ignore = self.burst_single(domain, ignore)
-            else:
-                assert False, 'domain from domains{} was no Single, Pair or Multi'
-
-
-        # then burst all Pairs and Multis.
-        if __debug__:
-            log.debug('burst %s' % non_single_list)
-        non_single_ids = [non_single.domain_id for non_single in non_single_list]
-        self.burst_domains(non_single_ids, ignore)
+#        ignore = []
+#        for domain_id, domain in self.domains.items():
+#            if domain_id not in ignore:
+##                domain = self.domains[event.data]
+#                if isinstance(domain, Pair) or isinstance(domain, Multi):
+#                    non_single_list.append(domain)
+#                elif isinstance(domain, Single):
+#                    if __debug__:
+#                        log.debug('burst %s, last_time= %s' % 
+#                                  (domain, FORMAT_DOUBLE % domain.last_time))
+#                    ignore.append(domain.domain_id)
+#                    ignore = self.burst_single(domain, ignore)
+#                else:
+#                    assert False, 'domain from domains{} was no Single, Pair or Multi'
+#
+#
+#        # then burst all Pairs and Multis.
+#        if __debug__:
+#            log.debug('burst %s' % non_single_list)
+#        non_single_ids = [non_single.domain_id for non_single in non_single_list]
+#        self.burst_domains(non_single_ids, ignore)
 
         self.dt = 0.0
 
@@ -614,14 +615,22 @@ def update_domain_event(self, t, domain):
                      (domain.domain_id, domain.event_id, FORMAT_DOUBLE % t))
         self.scheduler.update((domain.event_id, DomainEvent(t, domain)))
 
+
+
+
     def burst_domain(self, domain, ignore):
-    # Reduces and domain (Single, Pair or Multi) to Singles with the zero shell, and dt=0
-    # return a list of Singles that was the result of the bursting
+    # Reduces 'domain' (Single, Pair or Multi) to 'zero_singles', singles
+    # with the zero shell, and dt=0.
+    # returns:
+    # - list of zero_singles that was the result of the bursting
+    # - updated ignore list
+
+        domain_id = domain.domain_id
 
         if __debug__:
             log.info('burst_domain: %s' % domain)
 
-        if isinstance(domain, Single):
+        if isinstance(domain, Single):  # Single
             # TODO. Compare with gfrd.
             zero_singles, ignore = self.burst_single(domain, ignore)
         elif isinstance(domain, Pair):  # Pair
@@ -631,26 +640,84 @@ def burst_domain(self, domain, ignore):
             zero_singles, ignore = self.burst_multi(domain, ignore)
 
         if __debug__:
-            # After a burst, InteractionSingles should be gone.
-            assert all(not isinstance(b, InteractionSingle) for b in zero_singles)
+            # After a burst, the domain should be gone and should be on the ignore list.
+            # Also the zero_singles should only be NonInteractionSingles
+            assert domain_id not in self.domains
+            assert domain_id in ignore
+            assert all(isinstance(b, NonInteractionSingle) for b in zero_singles)
             log.info('zero_singles = %s' % ',\n\t  '.join(str(i) for i in zero_singles))
 
         return zero_singles, ignore
 
-    def burst_domains(self, domain_ids, ignore=[]):
-    # bursts all the domains that are in the list 'domain_ids'
-    # ignores all the domain ids on ignore
+    def burst_single(self, single, ignore):
+        # Bursts the 'single' domain and updates the 'ignore' list.
+        # Returns:
+        # - zero_singles that are the result of bursting the single (can be multiple
+        #   because the burst is recursive). The zero_single have zero shell and are scheduled.
+        # - the updated ignore list
 
-        zero_singles = []
-        for domain_id in domain_ids:
-            if domain_id not in ignore:
-                ignore.append(domain_id)
+        if __debug__:
+            log.debug('burst single: %s', single)
 
-                domain = self.domains[domain_id]
-                zero_singles2, ignore = self.burst_domain(domain, ignore)
-                zero_singles.extend(zero_singles2)
+        # Check correct timeline ~ MW
+        assert single.last_time <= self.t
+        assert self.t <= single.last_time + single.dt
 
-        return zero_singles, ignore
+        # Override dt, the burst happens before the single's scheduled event.
+        # Override event_type. 
+        single.dt = self.t - single.last_time
+        single.event_type = EventType.BURST
+        # with a burst there is always an associated event in the scheduler.
+        # to simulate the natural occurence of the event we have to remove it from the scheduler
+        self.remove_event(single)
+
+        return self.process_single_event(single, ignore)
+
+    def burst_pair(self, pair, ignore):
+        # Bursts the 'pair' domain and updates the 'ignore' list.
+        # Returns:
+        # - zero_singles that are the result of bursting the pair (can be more than two
+        #   since the burst is recursive). The zero_single have zero shell and are scheduled.
+        # - the updated ignore list
+
+        if __debug__:
+            log.debug('burst_pair: %s', pair)
+
+        # make sure that the current time is between the last time and the event time
+        if __debug__:
+            assert pair.last_time <= self.t
+            assert self.t <= pair.last_time + pair.dt
+
+        # Override event time and event_type. 
+        pair.dt = self.t - pair.last_time 
+        pair.event_type = EventType.BURST
+        # with a burst there is always an associated event in the scheduler.
+        # to simulate the natural occurence of the event we have to remove it from the scheduler
+        self.remove_event(pair)
+
+        return self.process_pair_event(pair, ignore)
+
+    def burst_multi(self, multi, ignore):
+        # Bursts the 'multi' domain and updates the 'ignore' list.
+        # Returns:
+        # - zero_singles that are the result of bursting the multi (note that the burst is
+        #   recursive). The zero_single have zero shell and are scheduled.
+        # - the updated ignore list
+
+        if __debug__:
+            log.debug('burst multi: %s', multi)
+
+        #multi.sim.sync()
+        # make sure that the current time is between the last time and the event time
+        if __debug__:
+            assert multi.last_time <= self.t
+            assert self.t <= multi.last_time + multi.dt
+
+        # with a burst there is always an associated event in the scheduler.
+        # to simulate the natural occurence of the event we have to remove it from the scheduler
+        self.remove_event(multi)        # The old event was still in the scheduler
+
+        return self.break_up_multi(multi, ignore)
 
     def burst_volume(self, pos, radius, ignore=[]):
         """ Burst domains within a certain volume and give their ids.
@@ -660,24 +727,62 @@ def burst_volume(self, pos, radius, ignore=[]):
 
         Arguments:
             - pos: position of area to be "bursted"
-            - radius: radius of area to be "bursted"
-            - ignore: domains that should be ignored, none by default.
+            - radius: radius of spherical area to be "bursted"
+            - ignore: ids of domains that should be ignored, none by default.
         """ # ~ MW
         # TODO burst_volume now always assumes a spherical volume to burst.
         # It is inefficient to burst on the 'other' side of the membrane or to
         # burst in a circle, when you want to make a new shell in the membrane.
-        # Then we may want to burst in a cylindrical volume, not a sphere
+        # Then we may want to burst in a cylindrical volume, not a sphere.
+
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius, ignore)
+
         return self.burst_domains(neighbor_ids, ignore)
 
-    def burst_non_multis(self, pos, burstradius, ignore):
-        # Recursively bursts the domains in 'domains' if within burstradius
-        # Returns the updated list domains that are already bursted
+    def burst_all_domains(self):
+        # Bursts all the domains in the simulator
+
+        all_domains = self.domains.items()
+        all_domain_ids =[domain_id for domain_id, _ in all_domains]
+        zero_singles, ignore = self.burst_domains(all_domain_ids, [])
+
+        # Check if the bursting procedure was correct.
+        if __debug__:
+            assert len(zero_singles) == self.world.num_particles
+            assert len(ignore) == (len(all_domains) + self.world.num_particles)
+
+    def burst_domains(self, domain_ids, ignore=[]):
+        # bursts all the domains that are in the list 'domain_ids'
+        # ignores all the domain ids on 'ignore'
+        # returns:
+        # - list of zero_singles that was the result of the bursting
+        # - updated ignore list
+
         zero_singles = []
+        for domain_id in domain_ids:
+            if domain_id not in ignore:
+                domain = self.domains[domain_id]
+
+                # add the domain_id to the list of domains that is already bursted (ignore list),
+                # and burst the domain.
+                ignore.append(domain_id)
+                zero_singles2, ignore = self.burst_domain(domain, ignore)
+                # add the resulting zero_singles from the burst to the total list of zero_singles.
+                zero_singles.extend(zero_singles2)
+
+        return zero_singles, ignore
+
+    def burst_non_multis(self, pos, radius, ignore):
+        # Recursively bursts the domains within 'radius' centered around 'pos'
+        # Similarly to burst_volume but now doesn't burst all domains.
+        # Returns:
+        # - the updated list domains that are already bursted -> ignore list
+        # - zero_singles that were the result of the burst
 
         # get the neighbors in the burstradius that are not already bursted.
-        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, burstradius, ignore)
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius, ignore)
 
+        zero_singles = []
         for domain_id in neighbor_ids:
             if domain_id not in ignore:                 # the list 'ignore' may have been updated in a
                 domain = self.domains[domain_id]        # previous iteration of the loop
@@ -689,17 +794,18 @@ def burst_non_multis(self, pos, burstradius, ignore):
 
                 elif (not isinstance(domain, Multi)) and (self.t != domain.last_time):
                     # Burst domain only if (AND):
-                    # -within burstradius
+                    # -within burst radius
                     # -not already bursted before (not on 'ignore' list)
                     # -domain is not zero dt NonInteractionSingle
                     # -domain is not a multi
                     # -domain has time passed
  
-                    # add the domain_id to the list of domains that is already bursted,
+                    # add the domain_id to the list of domains that is already bursted (ignore list),
                     # and burst the domain.
                     ignore.append(domain_id)
-                    zero_singles, ignore = self.burst_domain(domain, ignore)
-                    # The list 'ignore' is now updated with domains that are recursively bursted
+                    zero_singles2, ignore = self.burst_domain(domain, ignore)
+                    # add the resulting zero_singles from the burst to the total list of zero_singles.
+                    zero_singles.extend(zero_singles2)
 
                 #else:
                     # Don't burst domain if (OR):
@@ -713,6 +819,9 @@ def burst_non_multis(self, pos, burstradius, ignore):
 
         return zero_singles, ignore
 
+
+
+
     def fire_single_reaction(self, single, reactant_pos, ignore):
         # This takes care of the identity change when a single particle decays into
         # one or a number of other particles
@@ -729,6 +838,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
         # 1. remove the particle
 
+        zero_singles = []
+
         if len(rr.products) == 0:
             
             # 1. No products, no info
@@ -737,6 +848,7 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(reactant[0])
             products = []
+            # zero_singles/ignore is unchanged.
 
             # 5. No new single to be made
             # 6. Log the change
@@ -783,7 +895,7 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
                 # 2. make space for the products.
 #                if product_pos != reactant_pos or product_radius > reactant_radius:
-                _, ignore = self.burst_volume(product_pos, product_radius, ignore)
+                zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
                 # 3. check that there is space for the products 
                 if (not self.world.check_overlap((product_pos, product_radius), reactant[0])):
@@ -955,7 +1067,7 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             #    calculate the sphere around the two product particles
             rad = max(product1_displacement + product1_radius,
                       product2_displacement + product2_radius)
-            _,ignore = self.burst_volume(reactant_pos, rad, ignore)
+            zero_singles, ignore = self.burst_volume(reactant_pos, rad, ignore)
 
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
@@ -991,14 +1103,15 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
         else:
             raise RuntimeError('num products >= 3 not supported.')
 
-        return products, ignore
+        return products, zero_singles, ignore
 
     def fire_interaction(self, single, reactant_pos, ignore):
         # This takes care of the identity change when a particle associates with a surface
         # It performs the reactions:
         # A(structure) + surface -> 0
         # A(structure) + surface -> B(surface)
-        assert isinstance(single, InteractionSingle)
+        if __debug__:
+            assert isinstance(single, InteractionSingle)
 
         # 0. get reactant info
         reactant        = single.pid_particle_pair
@@ -1007,6 +1120,8 @@ def fire_interaction(self, single, reactant_pos, ignore):
 
         # 1. remove the particle
 
+        zero_singles = []
+
         if len(rr.products) == 0:
             
             # 1. No products, no info
@@ -1015,6 +1130,7 @@ def fire_interaction(self, single, reactant_pos, ignore):
             # 4. process the changes (remove particle, make new ones)
             self.world.remove_particle(reactant[0])
             products = []
+            # zero_singles/ignore is unchanged.
 
             # 5. No new single to be made
             # 6. Log the change
@@ -1040,7 +1156,7 @@ def fire_interaction(self, single, reactant_pos, ignore):
             #    Note that an interaction domain is already sized such that it includes the
             #    reactant particle moving into the surface.
             if product_radius > reactant_radius:
-                _, ignore = self.burst_volume(product_pos, product_radius, ignore)
+                zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
@@ -1067,7 +1183,7 @@ def fire_interaction(self, single, reactant_pos, ignore):
         else:
             raise RuntimeError('fire_interaction: num products > 1 not supported.')
 
-        return products, ignore
+        return products, zero_singles, ignore
 
 
     def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
@@ -1085,6 +1201,8 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
         rr = pair.draw_reaction_rule(pair.interparticle_rrs)
         # 1. remove the particles
 
+        zero_singles = []
+
         if len(rr.products) == 0:
 
             # 1. no product particles, no info
@@ -1094,6 +1212,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
             self.world.remove_particle(pid_particle_pair1[0])
             self.world.remove_particle(pid_particle_pair2[0])
             products = []
+            # zero_singles/ignore is unchanged.
 
             # 5. No new single to be made
             # 6. Log the change
@@ -1112,7 +1231,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
             # 2.  make space for products
             # 2.1 if the product particle sticks out of the shell
 #            if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_radius):
-            _, ignore = self.burst_volume(product_pos, product_radius, ignore)
+            zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products ignoring the reactants
             if self.world.check_overlap((product_pos, product_radius), pid_particle_pair1[0],
@@ -1143,7 +1262,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
         else:
             raise NotImplementedError('num products >= 2 not supported.')
 
-        return products, ignore
+        return products, zero_singles, ignore
 
 
     def fire_move(self, single, reactant_pos, ignore_p=None):
@@ -1187,48 +1306,27 @@ def make_new_domain(self, single):
         # 0. Get generic info
         single_pos = single.pid_particle_pair[1].position
         single_radius = single.pid_particle_pair[1].radius
+        reaction_threshold = single_radius * SINGLE_SHELL_FACTOR
 
         # 1.0 Get neighboring domains and surfaces
-        neighbors = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+        neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
 #        surface_distances = []
 #        if isinstance(single, SphericalSingle):
         surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
 
+        # 2.3 We prefer to make NonInteractionSingles for efficiency.
+        #     But if objects (Shells and surfaces) get close enough (closer than
+        #     reaction_threshold) we want to try Interaction and/or Pairs. 
 
-        # Check if there are shells with the burst radius (reaction_threshold)
-        # of the particle (intruders). Note that we approximate the reaction_volume
-        # with a sphere (should be cylinder for 2D or 1D particle)
-        reaction_threshold = single_radius * SINGLE_SHELL_FACTOR
-
-
-        # TODO redundant
-        intruders = self.geometrycontainer.filter_distance(neighbors, reaction_threshold)
-        if __debug__:
-            log.debug("intruders: %s" %
-                      (', '.join(str(i) for i in intruders)))
-
-
-        # 2.2 Burst the shells with the following conditions
-        # -shell is in the reaction_threshold (intruder)
-        # -shell is burstable (not Multi)
-        # -shell is not newly made
-        # -shell is not already a zero shell (just bursted)
-#       _, ignore = self.burst_non_multis(single_pos, reaction_threshold, [single.domain_id])
-#        neighbor_distances = [(self.domains[domain_id], 0) for domain_id in ignore if domain_id != single.domain_id]
-
-        # We prefer to make NonInteractionSingles for efficiency.
-        # But if objects (Shells and surfaces) get close enough (closer than
-        # reaction_threshold) we want to try Interaction and/or Pairs
-
-        neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
-        # 2.3 From the updated list of neighbors, we calculate the thresholds (horizons) for trying to form
+        #     From the list of neighbors, we calculate the thresholds (horizons) for trying to form
         #     the various domains. The domains can be:
-        # -zero-shell NonInteractionSingle -> Pair or Multi
-        # -Surface -> Interaction
-        # -Multi -> Multi
+        #     -zero-shell NonInteractionSingle -> Pair or Multi
+        #     -Surface -> Interaction
+        #     -Multi -> Multi
+        #
         # Note that we do not differentiate between directions. This means that we
-        # look around in a sphere, the horizons are spherical
+        # look around in a sphere, the horizons are spherical.
         pair_interaction_partners = []
         for domain, _ in neighbor_distances:
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
@@ -1409,24 +1507,32 @@ def update_single(self, single):
     def process_single_event(self, single, ignore):
     # This method handles the things that need to be done when the current event was
     # produced by a single. The single can be a NonInteractionSingle or an InteractionSingle.
-    # Note that this method is also called when a single is bursted. This event in that
-    # case is just a BURST event.
+    # Note that this method is also called when a single is bursted, in that case the event
+    # is a BURST event.
+    # Note that 'ignore' should already contain the id of 'pair'.
+    # Returns:
+    # - the 'domains' that were the results of the processing. This can be a newly made domain
+    #   (since make_new_domain is also called from here) or zero_singles that are the result of
+    #   the process. Note that these could be many since the event can induce recursive bursting.
+    # - the updated ignore list. This contains the id of the 'single' domain, ids of domains
+    #   bursted in the process and the ids of zero-dt singles.
 
-        # TODO assert that there is no event associated with this domain in the scheduler
-#        assert self.check_domain(single)
+        if __debug__:
+#            # TODO assert that there is no event associated with this domain in the scheduler
+#            assert self.check_domain(single)
+            assert (single.domain_id in ignore), \
+                   'Domain_id should already be on ignore list before processing event.'
 
+        ### SPECIAL CASE:
+        # If just need to make new domain.
         if single.is_reset():
-        ### If no event event really happened and just need to make new domain
             if __debug__:
                 log.info('FIRE SINGLE: make_new_domain()')
                 log.info('single = %s' % single)
             domains = [self.make_new_domain(single)]
             # domain is already scheduled in make_new_domain
 
-
-
-
-        ### 1.1 Special cases (shortcuts)
+        ### SPECIAL CASE:
         # In case nothing is scheduled to happen: do nothing and just reschedule
         elif single.dt == numpy.inf:
             if __debug__:
@@ -1435,24 +1541,30 @@ def process_single_event(self, single, ignore):
             self.add_domain_event(single)
             domains = [single]
 
+
+
+
+        ### NORMAL:
+        # Process 'normal' event produced by the single
         else:
-        ### 1. Process 'normal' event produced by the single
-            ### log Single event
             if __debug__:
                 log.info('FIRE SINGLE: %s' % single.event_type)
                 log.info('single = %s' % single)
 
-            if single.event_type != EventType.BURST:
-                # The burst of the domain may be caused by an overlapping domain
-                assert self.check_domain(single)
+            ### 1. check that everything is ok
+            if __debug__:
+                if single.event_type != EventType.BURST:
+                    # The burst of the domain may be caused by an overlapping domain
+                    assert self.check_domain(single)
 
-            # check that the event time of the single (last_time + dt) is equal to the
-            # simulator time
-            assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t), \
-                'Timeline incorrect. single.last_time = %s, single.dt = %s, self.t = %s' % \
-                (FORMAT_DOUBLE % single.last_time, FORMAT_DOUBLE % single.dt, FORMAT_DOUBLE % self.t)
+                # check that the event time of the single (last_time + dt) is equal to the
+                # simulator time
+                assert (abs(single.last_time + single.dt - self.t) <= TIME_TOLERANCE * self.t), \
+                       'Timeline incorrect. single.last_time = %s, single.dt = %s, self.t = %s' % \
+                        (FORMAT_DOUBLE % single.last_time, FORMAT_DOUBLE % single.dt, FORMAT_DOUBLE % self.t)
 
 
+            ### 2. get some necessary information
             pid_particle_pair = single.pid_particle_pair
             # in case of an interaction domain: determine real event before doing anything
             if single.event_type == EventType.IV_EVENT:
@@ -1483,33 +1595,44 @@ def process_single_event(self, single, ignore):
 
                 if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
-                    particles, ignore = self.fire_single_reaction(single, newpos, ignore)
+                    particles, zero_singles_b, ignore = self.fire_single_reaction(single, newpos, ignore)
+                    # The 'zero_singles_b' list now contains the resulting singles of a putative burst
+                    # that occured in fire_single_reaction
 
                 else:
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
-                    particles, ignore = self.fire_interaction(single, newpos, ignore)
+                    particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
 
             else:
                 particles = self.fire_move(single, newpos)
+                zero_singles_b = []     # no bursting takes place
+                # ignore is unchanged
+            domains = zero_singles_b
 
-            # 5. Make a (new) domain (reuse) domain for each particle(s)
-            #    (Re)schedule the (new) domain
+            ### 5. Make a (new) domain (reuse) domain for each particle(s)
+            #      (Re)schedule the (new) domain
             zero_singles = []
             for pid_particle_pair in particles:
 #               single.pid_particle_pair = pid_particle_pair    # reuse single
                 zero_single = self.create_single(pid_particle_pair)  # TODO re-use NonInteractionSingle domain if possible
                 self.add_domain_event(zero_single)                   # TODO re-use event if possible
-                zero_singles.append(zero_single) 
-                ignore.append(zero_single.domain_id)
+                zero_singles.append(zero_single)       # Add the newly made zero-dt singles to the list
+                ignore.append(zero_single.domain_id)   # Ignore these newly made singles (cannot be bursted)
+            domains.extend(zero_singles)
 
+            ### 6. Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
+            #      Add the resulting zero_singles to the already existing list.
             for zero_single in zero_singles:
                 zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
                                                               zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
                                                               ignore)
-            zero_singles.extend(zero_singles2)
-            domains = zero_singles
+                domains.extend(zero_singles2)
+
+            if __debug__:
+                # check that at least all the zero_singles are on the ignore list
+                assert all(zero_single.domain_id in ignore for zero_single in domains)
 
-            # 6. Log change?
+            ### 7. Log change?
                 
 # NOTE Code snippets to re-use the domain/event
 #
@@ -1525,16 +1648,22 @@ def process_single_event(self, single, ignore):
 #        particle_radius = single.pid_particle_pair[1].radius
 #        assert newsingle.shell.shape.radius == particle_radius
 
-        # burst around the 'newly made' NonInteractionSingles
 
         return domains, ignore
 
 
     def process_pair_event(self, pair, ignore):
     # This method handles the things that need to be done when the current event was
-    # produced by a pair.
-    # Note that this method is also called when a pair is bursted. This event in that
-    # case is just a BURST event.
+    # produced by a pair. The pair can be any type of pair (Simple or Mixed).
+    # Note that this method is also called when a pair is bursted, in that case the event
+    # is a BURST event.
+    # Note that ignore should already contain the id of 'pair'.
+    # Returns:
+    # - the 'domains' that were the results of the processing. These are zero_singles that are
+    #   the result of the process. Note that these could be many since the event can induce
+    #   recursive bursting.
+    # - the updated ignore list. This contains the id of the 'pair' domain, ids of domains
+    #   bursted in the process and the ids of zero-dt singles.
 
         if __debug__:
             log.info('FIRE PAIR: %s' % pair.event_type)
@@ -1543,14 +1672,15 @@ def process_pair_event(self, pair, ignore):
 
         ### 1. check that everything is ok
         if __debug__:
+            assert (pair.domain_id in ignore), \
+                   'Domain_id should already be on ignore list before processing event.'
             assert self.check_domain(pair)
             assert pair.single1.domain_id not in self.domains
             assert pair.single2.domain_id not in self.domains
-        # TODO assert that there is no event associated with this domain in the scheduler
+            # TODO assert that there is no event associated with this domain in the scheduler
 
-        # check that the event time of the single (last_time + dt) is equal to the
-        # simulator time
-        if __debug__:
+            # check that the event time of the pair (last_time + dt) is equal to the
+            # simulator time
             assert (abs(pair.last_time + pair.dt - self.t) <= TIME_TOLERANCE * self.t), \
                     'Timeline incorrect. pair.last_time = %s, pair.dt = %s, self.t = %s' % \
                     (FORMAT_DOUBLE % pair.last_time, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % self.t)
@@ -1609,12 +1739,12 @@ def process_pair_event(self, pair, ignore):
                 # first move the non-reacting particle
                 particles = self.fire_move(single2, newpos2, pid_particle_pair1)
                 # don't ignore the (moved) non-reacting particle
-                particles2, ignore = self.fire_single_reaction(single1, newpos1, ignore)
+                particles2, zero_singles_b, ignore = self.fire_single_reaction(single1, newpos1, ignore)
                 particles.extend(particles2)
             else:
                 theothersingle = single1
                 particles = self.fire_move(single1, newpos1, pid_particle_pair2)
-                particles2, ignore = self.fire_single_reaction(single2, newpos2, ignore)
+                particles2, zero_singles_b, ignore = self.fire_single_reaction(single2, newpos2, ignore)
                 particles.extend(particles2)
 
             if __debug__:
@@ -1633,7 +1763,7 @@ def process_pair_event(self, pair, ignore):
         #
         elif pair.event_type == EventType.IV_REACTION:
 
-            particles, ignore = self.fire_pair_reaction (pair, newpos1, newpos2, ignore)
+            particles, zero_singles_b, ignore = self.fire_pair_reaction (pair, newpos1, newpos2, ignore)
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
             zero_singles = []
@@ -1652,6 +1782,8 @@ def process_pair_event(self, pair, ignore):
 
             particles      = self.fire_move (single1, newpos1, pid_particle_pair2)
             particles.extend(self.fire_move (single2, newpos2, pid_particle_pair1))
+            zero_singles_b = []
+            # ignore is unchanged
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
             zero_singles = []
@@ -1711,29 +1843,61 @@ def process_pair_event(self, pair, ignore):
 #        # Now finally we are convinced that the singles were actually made correctly
 
 
-        # Log the event
-        if __debug__:
-            log.debug("process_pair_event: #1 { %s: %s => %s }" %
-                      (single1, str(oldpos1), str(newpos1)))
-            log.debug("process_pair_event: #2 { %s: %s => %s }" %
-                      (single2, str(oldpos2), str(newpos2)))
-
+        # Put the zero singles resulting from putative bursting in fire_... in the final list.
+        zero_singles_fin = zero_singles_b
+        # Ignore the zero singles that were made around the particles (cannot be bursted)
         for zero_single in zero_singles:
             ignore.append(zero_single.domain_id)
-        # burst around the 'newly made' NonInteractionSingles
+        zero_singles_fin.extend(zero_singles)       # Add the zero-dt singles around the particles
+
+        ### 6. Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
         for zero_single in zero_singles:
             zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
                                                           zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
                                                           ignore)
-        zero_singles.extend(zero_singles2)
+            # Also add the zero-dt singles from this bursting to the final list
+            zero_singles_fin.extend(zero_singles2)
+
+
+        # check that at least all the zero_singles are on the ignore list
+        if __debug__:
+            assert all(zero_single.domain_id in ignore for zero_single in zero_singles_fin)
+
+        ### 7. Log the event
+        if __debug__:
+            log.debug("process_pair_event: #1 { %s: %s => %s }" %
+                      (single1, str(oldpos1), str(newpos1)))
+            log.debug("process_pair_event: #2 { %s: %s => %s }" %
+                      (single2, str(oldpos2), str(newpos2)))
+
+        return zero_singles_fin, ignore
 
-        return zero_singles, ignore
 
     def process_multi_event(self, multi, ignore):
+    # This method handles the things that need to be done when the current event was
+    # produced by a multi.
+    # Returns:
+    # - Nothing if the particles were just propagated.
+    # Or:
+    # - The zero_singles that are the result when the multi was broken up due to an event.
+    #   Note that these could be many since the breakup can induce recursive bursting.
+    # - The updated ignore list in case of an event. This contains the id of the 'multi'
+    #   domain, ids of domains bursted in the process and the ids of zero-dt singles of the
+    #   particles.
 
         if __debug__:
             log.info('FIRE MULTI: %s' % multi.last_event)
 
+        if __debug__:
+            assert (multi.domain_id in ignore), \
+                   'Domain_id should already be on ignore list before processing event.'
+
+            # check that the event time of the multi (last_time + dt) is equal to the
+            # simulator time
+            assert (abs(multi.last_time + multi.dt - self.t) <= TIME_TOLERANCE * self.t), \
+                    'Timeline incorrect. multi.last_time = %s, multi.dt = %s, self.t = %s' % \
+                    (FORMAT_DOUBLE % multi.last_time, FORMAT_DOUBLE % multi.dt, FORMAT_DOUBLE % self.t)
+
         self.multi_steps[multi.last_event] += 1
         self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
         multi.step()
@@ -1744,13 +1908,23 @@ def process_multi_event(self, multi, ignore):
             self.last_reaction = multi.last_reaction
 
         if multi.last_event is not EventType.MULTI_DIFFUSION:                # if an event took place
-            self.break_up_multi(multi, ignore)
+            zero_singles, ignore = self.break_up_multi(multi, ignore)
 #            self.multi_steps[multi.last_event] += 1
         else:
+            multi.last_time = self.t
             self.add_domain_event(multi)
+            zero_singles = []
+            # ignore is unchanged
+
+        return zero_singles, ignore
 
     def break_up_multi(self, multi, ignore):
-        #Dissolves a multi in singles with a zero shell (dt=0)
+        # Dissolves 'multi' into zero_singles, single with a zero shell (dt=0)
+        # - 'ignore' contains domain ids that should be ignored
+        # returns:
+        # - updated ignore list
+        # - zero_singles that were the product of the breakup
+
         self.remove_domain(multi)
 
         zero_singles = []
@@ -1760,73 +1934,22 @@ def break_up_multi(self, multi, ignore):
             zero_singles.append(zero_single)
             ignore.append(zero_single.domain_id)
 
-        # burst around the 'newly made' NonInteractionSingles
+        zero_singles_fin = zero_singles     # Put the zero-dt singles around the particles into the final list
+
+        ### Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
         for zero_single in zero_singles:
             zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
                                                           zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
                                                           ignore)
-        zero_singles.extend(zero_singles2)
-        return zero_singles, ignore
-
-    def burst_multi(self, multi, ignore):
-        #multi.sim.sync()
+            zero_singles_fin.extend(zero_singles2)
 
+        # check that at least all the zero_singles are on the ignore list
         if __debug__:
-            log.debug('burst multi: %s', multi)
-
-        self.remove_event(multi)        # The old event was still in the scheduler
-
-        zero_singles, ignore = self.break_up_multi(multi, ignore)
-        # Note that the multi domain is here also removed from 'domains'
+            assert all(zero_single.domain_id in ignore for zero_single in zero_singles_fin)
 
-        return zero_singles, ignore
+        return zero_singles_fin, ignore
 
-    def burst_single(self, single, ignore):
-        # Sets next event time of 'single' to current time and event to burst event
-        # returns a new single that is the result of firing the old single
-        # new single also has proper zero shell and is rescheduled
 
-        if __debug__:
-            log.debug('burst single: %s', single)
-
-        # Check correct timeline ~ MW
-        assert single.last_time <= self.t
-        assert self.t <= single.last_time + single.dt
-
-        # Override dt, burst happens before single's scheduled event.
-        # Override event_type. 
-        single.dt = self.t - single.last_time
-        single.event_type = EventType.BURST
-        # with a burst there is always an associated event in the scheduler.
-        # to simulate the natural occurence of the event we have to remove it from the scheduler
-        self.remove_event(single)
-
-        zero_singles, ignore = self.process_single_event(single, ignore)
-
-        return zero_singles, ignore
-
-    def burst_pair(self, pair, ignore):
-        # Sets next event time of 'pair' to current time and event to burst event
-        # returns two new singles that are the result of firing the pair
-        # new singles also have proper zero shell and are rescheduled
-
-        if __debug__:
-            log.debug('burst_pair: %s', pair)
-
-        # make sure that the current time is between the last time and the event time
-        assert pair.last_time <= self.t
-        assert self.t <= pair.last_time + pair.dt
-
-        # Override event time and event_type. 
-        pair.dt = self.t - pair.last_time 
-        pair.event_type = EventType.BURST
-        # with a burst there is always an associated event in the scheduler.
-        # to simulate the natural occurence of the event we have to remove it from the scheduler
-        self.remove_event(pair)
-
-        zero_singles, ignore = self.process_pair_event(pair, ignore)
-
-        return zero_singles, ignore
 
 
     def try_interaction(self, single, surface):
@@ -1858,8 +1981,8 @@ def try_interaction(self, single, surface):
 
             # get the next event time
             interaction.dt, interaction.event_type, = interaction.determine_next_event()
-            assert interaction.dt >= 0.0
             if __debug__:
+                assert interaction.dt >= 0.0
                 log.info('dt=%s' % (FORMAT_DOUBLE % interaction.dt)) 
 
             self.last_time = self.t
@@ -1907,8 +2030,8 @@ def try_pair(self, single1, single2):
                 log.info('        *Created: %s' % (pair))
 
             pair.dt, pair.event_type, pair.reactingsingle = pair.determine_next_event(pair.r0)
-            assert pair.dt >= 0
             if __debug__:
+                assert pair.dt >= 0
                 log.info('dt=%s' % (FORMAT_DOUBLE % pair.dt)) 
 
             self.last_time = self.t
@@ -2012,19 +2135,8 @@ def add_to_multi_recursive(self, domain, multi):
                     log.debug('%s already in multi. skipping.' % domain)
                 return
 
-            
             # 1. Get the neighbors of the domain
             dompos = domain.shell.shape.position
-#            neighbor_distances = self.geometrycontainer.get_neighbor_domains(dompos, self.domains,
-#                                                                             ignore=[domain.domain_id, multi.domain_id])
-
-            # 2. Burst the domains that interfere with making the multi shell
-            # NOTE this should burst nothing!
-#            burstradius = domain.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-#            ignore = self.burst_non_multis(dompos, burstradius, [domain.domain_id, multi.domain_id])
-            # This bursts only domains in which time has passed, it is assumed that other domains
-            # have been made 'socially', meaning that they leave enough space for this particle to make a multi
-            # shell without overlapping. 
 
             # neighbor_distances has same format as before
             # It contains the updated list of domains in the neighborhood with distances

From 578ca770900594823c89af1fd5b3ce5d01f107cd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 7 Feb 2012 19:25:21 +0100
Subject: [PATCH 0616/1541] small fix to latest merge

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index d02d34e4..ba38eaa4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2330,7 +2330,7 @@ def check_domain(self, domain):
         ###### check shell consistency
         for shell_id, shell in domain.shell_list:
 
-            surfaces = get_surfaces(self.world, shell.shape.position, ignores)
+            surfaces = get_surfaces(self.world, shell.shape.position, ignores + associated)
             for surface, _ in surfaces:
                 assert self.check_surface_overlap(shell, surface), \
                     '%s (%s) overlaps with %s.' % \

From e6be1377f088a8145aa01dc8062b57aa5e195f98 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 7 Feb 2012 19:43:03 +0100
Subject: [PATCH 0617/1541] removed unused code snippit

---
 multi.py | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/multi.py b/multi.py
index b69c5152..e8c62101 100644
--- a/multi.py
+++ b/multi.py
@@ -53,9 +53,6 @@ def get_multiplicity(self):
         return self.particle_container.num_particles
     multiplicity = property(get_multiplicity)
 
-#    def create_new_shell(self, position, radius):
-#        return SphericalShell(self.domain_id, Sphere(position, radius))
-
     def within_shell(self, pp):
         return bool(self.sphere_container.get_neighbors_within_radius(pp[1].position, -(pp[1].radius + self.reaction_length)))
 

From c9e28c6b0194698e00a9c2d7d75b42860d51329c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 13:46:49 +0100
Subject: [PATCH 0618/1541] There can be two centers of particles inside a
 shell. Every particle just needs to be in AT LEAST one.

---
 multi.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/multi.py b/multi.py
index e8c62101..4c527629 100644
--- a/multi.py
+++ b/multi.py
@@ -54,7 +54,9 @@ def get_multiplicity(self):
     multiplicity = property(get_multiplicity)
 
     def within_shell(self, pp):
-        return bool(self.sphere_container.get_neighbors_within_radius(pp[1].position, -(pp[1].radius + self.reaction_length)))
+        # test if pid_particle_pair 'pp' is within at least one shell.
+        shells = self.sphere_container.get_neighbors_within_radius(pp[1].position, -(pp[1].radius + self.reaction_length))
+        return len(shells) >= 1
 
     def add_shell(self, shell_id_shell_pair):
         if __debug__:

From 49e3f1f428a1b04f9ebc4ecc26fc472f84be80a6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 14:17:42 +0100
Subject: [PATCH 0619/1541] new methods 'domain.get_particles()' for single,
 pair and multi to uniformly get all the particles.

---
 multi.py  | 4 ++--
 pair.py   | 4 ++++
 single.py | 4 ++++
 3 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/multi.py b/multi.py
index 4c527629..a2aa0730 100644
--- a/multi.py
+++ b/multi.py
@@ -213,9 +213,9 @@ def has_particle(self, pid):
         # except:
         #     return False
 
-    def particles(self):
+    def get_particles(self):
         return iter(self.particle_container)
-    particles = property(particles)
+    particles = property(get_particles)
 
     def num_shells(self):
         return len(self.sphere_container)
diff --git a/pair.py b/pair.py
index 642996cd..734fa740 100644
--- a/pair.py
+++ b/pair.py
@@ -176,6 +176,10 @@ def draw_new_iv(self, dt, r0, old_iv, event_type):
         # the particle leaving the structure due to numerical errors
         return self.create_interparticle_vector(gf, r, dt, r0, old_iv)
 
+    def get_particles(self):
+        return [self.pid_particle_pair1, self.pid_particle_pair2]
+    particles = property(get_particles)
+
     def check(self):
     # perform internal consistency check 
         pass
diff --git a/single.py b/single.py
index 8338fa25..9ea71de1 100644
--- a/single.py
+++ b/single.py
@@ -125,6 +125,10 @@ def draw_escape_time_tuple(self):
         event_type = EventType.SINGLE_ESCAPE
         return dt, event_type
 
+    def get_particles(self):
+        return [self.pid_particles_pair]
+    particles = property(get_particles)
+
     def check(self):
     # performs an internal consistency check
         pass

From 4cf73fa5d798b2690020217bd4f5433a2fa924b5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 15:16:17 +0100
Subject: [PATCH 0620/1541] typo

---
 single.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 9ea71de1..45eb55e1 100644
--- a/single.py
+++ b/single.py
@@ -126,7 +126,7 @@ def draw_escape_time_tuple(self):
         return dt, event_type
 
     def get_particles(self):
-        return [self.pid_particles_pair]
+        return [self.pid_particle_pair]
     particles = property(get_particles)
 
     def check(self):

From 6453ac24020df422537c9534aec2b71dcafc9825 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 15:16:42 +0100
Subject: [PATCH 0621/1541] added particles consistency check (this doesn't
 work yet)

---
 egfrd.py | 38 +++++++++++++++++++++++++++++++-------
 1 file changed, 31 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ba38eaa4..6a024109 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2449,18 +2449,44 @@ def check_domain_for_all(self):
             self.check_domain(domain)
 
     def check_event_stoichiometry(self):
-    # checks if the number of particles in the world is equal to the number
-    # of particles represented in the EGFRD simulator
+        pass
+
+    def check_particle_consistency(self):
+        ### Checks the particles consistency between the world and the domains of
+        #   the simulator
+
+        # First, check num particles in domains is equal to num particles in the world
         world_population = self.world.num_particles
         domain_population = 0
-        for id, event in self.scheduler:
-            domain = self.domains[event.data]
+        for domain in self.domains.itervalues():
             domain_population += domain.multiplicity
 
         if world_population != domain_population:
             raise RuntimeError('population %d != domain_population %d' %
                                (world_population, domain_population))
 
+#        # Next, check that every particle in the domains is once and only once in the world.
+#        already_in_domain = set()
+#        world_particles = list(self.world)
+#        for domain in self.domains.itervalues():
+#            for domain_particle in domain.particles:
+#                for world_particle in world_particles:
+#                    if domain_particle == world_particle:
+#                        break
+#                else:
+#                    raise RuntimeError('particle %s not in world' % str(domain_particle))
+#
+#                assert domain_particle not in already_in_domain, 'particle %s twice in domains' % str(domain_particle)
+#                already_in_domain.add(domain_particle)
+#
+#        # This now means that all the particles in domains are represented in the world and that
+#        # all the particles in the domains are unique (no particle is represented in two domains)
+#
+#        assert already_in_domain == len(world_particles)
+        # Since the number of particles in the domains is equal to the number of particles in the
+        # world this now also means that all the particles in the world are represented in the
+        # domains.
+
     def check_shell_matrix(self):
         did_map, shell_map = self.geometrycontainer.get_dids_shells()
 
@@ -2507,9 +2533,6 @@ def check_shell_matrix(self):
 # check that shells of the domain DO overlap with the structures that it is associated with.
 
 ### check world
-# check num particles in domains is equal to num particles in the world
-# check that every particle in the world is in one and only one domain
-# check that every particle in the domains is once and only once in the world.
 # check that particles do not overlap with cylinderical surfaces unless the domain is associated with the surface
 
 ### check domains
@@ -2619,6 +2642,7 @@ def check(self):
         self.check_shell_matrix()
         self.check_domains()
         self.check_event_stoichiometry()
+        self.check_particle_consistency()
         
         self.check_domain_for_all()
 

From a1e4b6ebda48f9d2f5c34f83b66793a8b113cf55 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 16:15:26 +0100
Subject: [PATCH 0622/1541] implemented check between scheduler and domains

---
 egfrd.py | 41 ++++++++++++++++++++++++++++++++++-------
 1 file changed, 34 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6a024109..68dcad68 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2449,7 +2449,40 @@ def check_domain_for_all(self):
             self.check_domain(domain)
 
     def check_event_stoichiometry(self):
-        pass
+        ### check scheduler
+        # -check that every event on scheduler is associated with domain or is a non domain related event
+        # -check that every event with domain is also in domains{}
+
+        SMT = 6                 # just some temporary definition to account for non-domain related events
+        self.other_objects = {} # ditto
+        for id, event in self.scheduler:
+            domain_id = event.data
+            if domain_id != SMT:
+                # in case the domain_id is not special, it needs to be in self.domains
+                assert domain_id in self.domains
+            else:
+                # if it is special in needs to be in self.other_objects
+                assert domain_id in self.other_objects
+
+
+        ### performs two checks:
+        # -check that every domain in domains{} has one and only one event in the scheduler
+        # -check that dt, last_time of the domain is consistent with the event time on the scheduler
+        already_in_scheduler = set()        # make a set of domain_ids that we found in the scheduler
+        for domain_id, domain in self.domains.iteritems():
+            # find corresponding event in the scheduler
+            for id, event in self.scheduler:
+                if event.data == domain_id:
+                    # We found the event in the scheduler that is associated with the domain
+                    assert (abs(domain.last_time + domain.dt - event.time) <= TIME_TOLERANCE * event.time)
+                    break
+            else:
+                raise RuntimeError('Event for domain_id %s could not be found in scheduler' % str(domain_id) )
+
+            # make sure that we had not already found it earlier
+            assert domain_id not in already_in_scheduler
+            already_in_scheduler.add(domain_id)
+
 
     def check_particle_consistency(self):
         ### Checks the particles consistency between the world and the domains of
@@ -2511,12 +2544,6 @@ def check_shell_matrix(self):
             raise RuntimeError('num shells (%d) != matrix population (%d)' %
                                (shell_population, matrix_population))
 
-### check scheduler
-# check that every domain in domains{} has one and only one event in the scheduler
-# check that every event with domain is also in domains{}
-# check that dt, last_time of the domain is consistent with the event time on the scheduler
-# check that every event on scheduler is associated with domain or is a non domain related event
-
 # check that all the cached singles in Pairs are not in domains{}.
 
 ### check shell container

From 79b354ef58ddf8be5534d6dc7f9972fc990ef07e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 16:42:44 +0100
Subject: [PATCH 0623/1541] Added small changes to check of shell consistency
 between domains and geometrycontainer

---
 egfrd.py | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 68dcad68..0c56b4a9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2521,13 +2521,26 @@ def check_particle_consistency(self):
         # domains.
 
     def check_shell_matrix(self):
+        ### checks the consistency between the shells in the geometry container and the domains
+        # -check that shells of a domain in domains{} are once and only once in the shell matrix
+        # -check that all shells in the matrix are once and only once in a domain
+
         did_map, shell_map = self.geometrycontainer.get_dids_shells()
 
         shell_population = 0
-        for id, event in self.scheduler:
-            domain = self.domains[event.data]
+        for domain in self.domains.itervalues():
             shell_population += domain.num_shells
+
+            # get the shells associated with the domain according to the geometrycontainer
             shell_ids = did_map[domain.domain_id]
+            for shell_id, shell in domain.shell_list:
+                # check that all shells in the domain are in the matrix and have the proper domain_id
+                assert shell_id in shell_ids
+
+            # check that the number of shells in the shell_list is equal to the number of shells the domain
+            # says it has is equal to the number of shell the geometrycontainer has registered to the domain.
+            assert domain.num_shells == len(list(domain.shell_list))
+            assert domain.num_shells == len(shell_ids)
             if len(shell_ids) != domain.num_shells:
                 diff = set(sid for (sid, _)
                                in domain.shell_list).difference(shell_ids)
@@ -2539,18 +2552,19 @@ def check_shell_matrix(self):
                                    (len(shell_ids), domain.num_shells, 
                                     domain.domain_id, diff))
 
+        # check that total number of shells in domains==total number of shells in shell container
         matrix_population = self.geometrycontainer.get_total_num_shells()
         if shell_population != matrix_population:
             raise RuntimeError('num shells (%d) != matrix population (%d)' %
                                (shell_population, matrix_population))
+        # Since the number of shells in the domains is equal to the number of shells in the
+        # geometrycontainer this now also means that all the shells in the geometrycontainer are
+        # represented in the domains.
 
-# check that all the cached singles in Pairs are not in domains{}.
+        # This now also means that the shells of all the cached singles in Pairs are not in the containers.
 
-### check shell container
-# check that shells of a domain in domains{} are once and only once in the shell matrix
-# check that all shells in the matrix are once and only once in a domain
-# total number of shells in domains==total number of shells in shell container
-# check that the shells of all the cached singles in Pairs are not in the containers
+
+# check that all the cached singles in Pairs are not in domains{}.
 
 ### check shells of domains
 # check that shells of the domain do not overlap with shells of other domains

From aac1ff3a9c3d5c7c013fae3c10dda17f39da474e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 17:00:30 +0100
Subject: [PATCH 0624/1541] added check and comments for checking shell overlap
 with other shells and surfaces

---
 egfrd.py | 27 ++++++++++++++++-----------
 1 file changed, 16 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0c56b4a9..6ee2c45c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2328,18 +2328,31 @@ def check_domain(self, domain):
 
 
         ###### check shell consistency
+        # check that shells of the domain don't overlap with surfaces that are not associated with the domain.
+        # check that shells of the domain DO overlap with the structures that it is associated with.
+        # check that shells of the domain do not overlap with shells of other domains
+        # check that shells are not bigger than the allowed maximum
+
         for shell_id, shell in domain.shell_list:
 
+            ### check that shells do not overlap with non associated surfaces
             surfaces = get_surfaces(self.world, shell.shape.position, ignores + associated)
             for surface, _ in surfaces:
                 assert self.check_surface_overlap(shell, surface), \
                     '%s (%s) overlaps with %s.' % \
                     (str(domain), str(shell), str(surface))
 
+            ### check that shells DO overlap with associated surfaces.
+            surfaces = get_surfaces(self.world, shell.shape.position, ignores)
+            for surface, _ in surfaces:
+                if surface.id in associated:
+                    assert not self.check_surface_overlap(shell, surface), \
+                    '%s (%s) should overlap with associated surface %s.' % \
+                    (str(domain), str(shell), str(surface))
+
             ### Check shell overlap with other shells
             neighbors = self.geometrycontainer.get_neighbor_domains(shell.shape.position,
                                                                     self.domains, ignore=[domain.domain_id])
-
             # TODO maybe don't check all the shells, this takes a lot of time
             # testing overlap criteria
             for neighbor, _ in neighbors:
@@ -2443,9 +2456,8 @@ def check_surface_overlap(self, shell, surface):
 
 
     def check_domain_for_all(self):
-    # For every event in the scheduler, checks the consistency of the associated domain.
-        for id, event in self.scheduler:
-            domain = self.domains[event.data]
+    # For every domain in domains, checks the consistency
+        for domain in self.domains.itervalues():
             self.check_domain(domain)
 
     def check_event_stoichiometry(self):
@@ -2566,13 +2578,6 @@ def check_shell_matrix(self):
 
 # check that all the cached singles in Pairs are not in domains{}.
 
-### check shells of domains
-# check that shells of the domain do not overlap with shells of other domains
-# check that shells are not bigger than the allowed maximum
-# check (for Multi's only?) that the shells in a domain are connected (have consecutive overlaps)
-# check that shells of the domain don't overlap with surfaces that are not associated with the domain.
-# check that shells of the domain DO overlap with the structures that it is associated with.
-
 ### check world
 # check that particles do not overlap with cylinderical surfaces unless the domain is associated with the surface
 

From 0c68e59a02f02dab673b084928e741276ed4e27f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 8 Feb 2012 18:29:56 +0100
Subject: [PATCH 0625/1541] added some domain specific checking

---
 domain.py | 13 +++++++++++++
 single.py | 51 +++++++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 60 insertions(+), 4 deletions(-)

diff --git a/domain.py b/domain.py
index 55f452f8..b5946bc3 100644
--- a/domain.py
+++ b/domain.py
@@ -4,6 +4,8 @@
 import myrandom
 import math
 
+from constants import *
+
 __all__ = [
     'Domain',
     'ProtectiveDomain',
@@ -89,3 +91,14 @@ def get_shell_list(self):
 
     def get_shell_radius(self):         # returns the radius of the shell
         return self.shell.shape.radius
+
+    def check(self):
+        ### checks some basic parameters of the Protective Domain
+
+        # check that the domain has the proper number of shells.
+        assert len(self.shell_list) == 1
+        # check event_type != BURST, note that this means that the check can't take place when the
+        # event by the domain is processed.
+        assert self.event_type != EventType.BURST
+
+        return True
diff --git a/single.py b/single.py
index 45eb55e1..0789a864 100644
--- a/single.py
+++ b/single.py
@@ -1,10 +1,11 @@
 from _gfrd import (
     SphericalShell,
     CylindricalShell,
-    Cylinder,
     Sphere,
-    CylindricalSurface,
+    Cylinder,
+    CuboidalRegion,
     PlanarSurface,
+    CylindricalSurface,
     )
 from _greens_functions import *
 from greens_function_wrapper import *
@@ -130,8 +131,9 @@ def get_particles(self):
     particles = property(get_particles)
 
     def check(self):
-    # performs an internal consistency check
-        pass
+        # performs an internal consistency check
+        assert ProtectiveDomain.check(self)
+        return True
 
     def __str__(self):
         pid = self.pid_particle_pair[0]
@@ -306,6 +308,19 @@ def create_updated_shell(self, position):
     def create_position_vector(self, r):
         return random_vector(r)
 
+    def check(self):
+        assert ProtectiveDomain.check(self)
+        assert isinstance(self.testShell, SphericalSingletestShell)
+        assert isinstance(self.shell.shape, Sphere)
+        assert self.shell.shape.radius <= self.testShell.get_max_radius()
+        if not self.is_reset():
+            assert self.shell.shape.radius >= self.testShell.get_min_radius()
+        assert self.is_reset() ^ (self.dt != 0.0)
+        assert isinstance(self.structure, CuboidalRegion)
+        assert self.greens_function
+
+        return True
+
     def __str__(self):
         return 'Spherical' + Single.__str__(self)
 
@@ -379,6 +394,20 @@ def create_position_vector(self, r):
         x, y = random_vector2D(r)
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
+    def check(self):
+        assert ProtectiveDomain.check(self)
+        assert isinstance(self.testShell, PlanarSurfaceSingletestShell)
+        assert isinstance(self.shell.shape, Cylinder)
+#        assert self.shell.shape.radius <= self.testShell.get_max_radius()
+#        if not self.is_reset():
+#            assert self.shell.shape.radius >= self.testShell.get_min_radius()
+        assert self.is_reset() ^ (self.dt != 0.0)
+        assert isinstance(self.structure, PlanarSurface)
+        assert self.greens_function
+        assert self.shell.shape.unit_z == self.structure.shape.unit_z
+
+        return True
+
     def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
@@ -488,6 +517,20 @@ def create_position_vector(self, z):
 
         return z * self.structure.shape.unit_z
 
+    def check(self):
+        assert ProtectiveDomain.check(self)
+        assert isinstance(self.testShell, CylindricalSurfaceSingletestShell)
+        assert isinstance(self.shell.shape, Cylinder)
+#        assert self.shell.shape.radius <= self.testShell.get_max_radius()
+#        if not self.is_reset():
+#            assert self.shell.shape.radius >= self.testShell.get_min_radius()
+        assert self.is_reset() ^ (self.dt != 0.0)
+        assert isinstance(self.structure, CylindricalSurface)
+        assert self.greens_function
+        assert self.shell.shape.unit_z == self.structure.shape.unit_z
+
+        return True
+
     def __str__(self):
         return 'CylindricalSurface' + Single.__str__(self)
 

From 2a34a50e8090b43b1f1e0fdf68bd40ee67fd2023 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 9 Feb 2012 19:12:19 +0100
Subject: [PATCH 0626/1541] Basic implementation of egde crossing feature for
 2D diffusion

* New single type "PlanarSurfaceEdgeSingle"
* New testshell type "PlanarSurfaceEgdeSingletestShell"
* Modifications to the switchbox for testshell construction
* Subroutines to calculate the position of a single crossing
  the edge between two planes (contained in PlanarSurfaceEdgeSingle)
* More work in egfrd.py needed to really make it running
---
 egfrd.py  |   9 ++--
 shells.py |  39 ++++++++++++++
 single.py | 155 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 200 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 016cb900..b3cbfed1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -69,7 +69,7 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
         testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
 
-### Interactions
+### Interactions (including changes from one surface to another / crossing edges)
 def try_default_testinteraction(single, surface, geometrycontainer, domains):
     if isinstance(single.structure, CuboidalRegion):
         if isinstance(surface, PlanarSurface):
@@ -79,7 +79,10 @@ def try_default_testinteraction(single, surface, geometrycontainer, domains):
         else:
             raise testShellError('(Interaction). Combination of (3D particle, surface) is not supported')
     elif isinstance(single.structure, PlanarSurface):
-        raise testShellError('(Interaction). Combination of (2D particle, surface) is not supported')
+        if isinstance(surface, PlanarSurface):
+            return PlanarSurfaceEdgeSingletestShell(single, surface, geometrycontainer, domains)
+        else:
+            raise testShellError('(Interaction). Combination of (2D particle, surface other than plane) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(surface, CylindricalSurface):     # TODO differentiate between a sink and a cap
             return CylindricalSurfaceSinktestShell (single, surface, geometrycontainer, domains)
@@ -1172,7 +1175,7 @@ def make_new_domain(self, single):
         surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
 
 
-        # Check if there are shells with the burst radius (reaction_threshold)
+        # Check if there are shells within the burst radius (reaction_threshold)
         # of the particle (intruders). Note that we approximate the reaction_volume
         # with a sphere (should be cylinder for 2D or 1D particle)
         reaction_threshold = single_radius * SINGLE_SHELL_FACTOR
diff --git a/shells.py b/shells.py
index b18d861c..c1c85eb0 100755
--- a/shells.py
+++ b/shells.py
@@ -1,4 +1,5 @@
 #!/usr/bin/python
+# -*- coding: utf-8 -*-
 
 import math
 
@@ -31,6 +32,7 @@
     'SphericalPairtestShell',
     'PlanarSurfaceSingletestShell',
     'PlanarSurfacePairtestShell',
+    'PlanarSurfaceEdgeSingletestShell',
     'CylindricalSurfaceSingletestShell',
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
@@ -1106,6 +1108,43 @@ def get_max_dr_dzright_dzleft(self):
 
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right, z_left
+
+#####
+class PlanarSurfaceEdgeSingletestShell(SphericaltestShell, testNonInteractionSingle):
+
+    def __init__(self, single, surface, geometrycontainer, domains):
+        SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        self.origin_surface = single.structure
+        self.target_surface = surface
+        assert isinstance(origin_surface, _gfrd.Surface)
+        assert isinstance(target_surface, _gfrd.Surface)
+
+        self.particle = single.pid_particle_pair[1]
+        self.single_radius = particle.radius
+        self.center = particle.position
+
+        try:
+            self.radius = self.determine_possible_shell(self.structure.id, 
+                                                        [self.single.domain_id],
+                                                        [self.origin_surface.id, self.target_surface.id]
+                                                       )
+        except ShellmakingError as e:
+            raise testShellError('(PlanarSurfaceEdgeSingle). %s' %
+                                 (str(e)))
+
+    def get_min_radius(self):
+        min_offset = single_radius*(SINGLE_SHELL_FACTOR - 1.0)
+        # The minimal shell size also deterimines the minimal radius of the later 2D domain.
+        # min_offset here is the minimal length that the circular 2D domain protrudes into
+        # the target surface. Make sure that min_offset > 0.0, because only then it is
+        # guaranteed that there is always a certain probability to cross the edge even
+        # if the shell with minimal radius is constructed
+        return self.get_distance_to_target_surface() + min_radius
+
+    def get_distance_to_target_surface(self):
+        distance = world.distance(target_surface.shape, self.center)
+        return distance
+
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
 
diff --git a/single.py b/single.py
index 8338fa25..f5a06fc7 100644
--- a/single.py
+++ b/single.py
@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 from _gfrd import (
     SphericalShell,
     CylindricalShell,
@@ -20,6 +21,7 @@
 __all__ = [
     'CylindricalSurfaceSingle',
     'PlanarSurfaceSingle',
+    'PlanarSurfaceEdgeSingle',
     'SphericalSingle',
     'Single',
     'NonInteractionSingle',
@@ -379,6 +381,159 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
+class PlanarSurfaceEdgeSingle(Single, hasSphericalShell, Others):
+    """1 Particle inside a (spherical) shell at the edge of two planar surfaces
+
+        * Particle coordinates on surface: x, y.
+        * Domain: radial r. (determines x and y together with theta).
+        * Initial position: r = 0.
+        * Selected randomly when drawing displacement vector: theta.
+
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+
+        assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
+        hasSphericalShell.__init__(self, testShell, domain_id)
+        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
+
+        self.origin_plane = testShell.origin_plane
+        self.target_plane = testShell.target_plane
+        self.origin_center = origin_plane.shape.position
+        self.target_center = target_plane.shape.position
+        self.origin_half_extent = origin_plane.shape.half_extent
+        self.target_half_extent = target_plane.shape.half_extent      
+
+        self.start_position = self.pid_particle_pair[1].postition
+        self.target_distance = testShell.get_distance_to_target_surface()
+        # Keep the order of the following!
+        # get_edge_point() needs origin_unit_perp, while get_target_unit_vectors() needs edge_point.
+        self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
+        self.edge_point = self.get_edge_point()
+        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()
+
+    # The same Greens function is used as for the normal PlanarSurfaceSingle;
+    # If the position is off the plane of origin, it will be transformed towards the target plane
+    def greens_function(self):
+        return GreensFunction2DAbsSym(self.D,
+                                          self.get_inner_a())
+
+    def draw_new_position(self, dt, event_type):
+        oldpos = self.start_position
+
+        if self.D == 0:
+            newpos = oldpos
+        elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+            newpos = oldpos
+        else:
+            # Calculate r
+            if event_type == EventType.SINGLE_ESCAPE:
+            # Moving this checks to the Green's functions is not a good 
+            # idea, because then you'd draw an unused random number.  
+            # The same yields for the draw_new_com and draw_new_iv.  
+
+                r = self.get_inner_a()
+            else:
+                gf = self.greens_function()
+                r = draw_r_wrapper(gf, dt, self.get_inner_a())
+                # Note that in case of 1D diffusion r has a direction. It is
+                # the lateral displacement and can be positive or negative. 
+                # In other cases r is always positive and denotes
+                # radial displacement from the center.
+
+            # Calculate the displacement from oldpos in the plane of origin
+            displacement = self.create_position_vector(r)
+
+            # Now check whether the new position is in the plane of origin;
+            # if not, transform it to the target plane
+            newpos = self.process_new_position_vector(oldpos, displacement)
+
+        return newpos
+
+    def create_position_vector(self, r):
+        # project the vector onto the surface unit vectors to make sure
+        # that the coordinates are in the surface
+        x, y = random_vector2D(r)
+        return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
+
+    def process_new_position_vector(self, oldpos, displacement):
+        # This routine checks whether the new position in the plane of origin
+        # reaches out of it and if necessary calculates the position in the
+        # target plane.
+        # First calculate the coordinate perpendicular to the edge
+        # in the old plane
+        newpos_in_origin = (oldpos - self.origin_center) + displacement
+        d_origin_perp = numpy.dot(newpos_in_origin, self.origin_unit_perp)
+        assert (d_origin_perp >= 0.0 )
+        # Calculate the part of it that reaches out of the plane of origin
+        d_out = d_origin_perp - self.origin_half_extent_perp
+        if d_out <= 0.0 :
+            # The new position is still in the old plane;
+            # no transform required
+            newpos = oldpos + displacement
+        else :
+            # The new position is out of the old plane;
+            # transform it to the target plane.
+            # First calculate the coordinate in the target plane
+            # that is perpendicular to the edge:
+            d_target_perp = self.target_half_extent_perp - d_out
+            # Now the same for the parallel component
+            # Take into account that the parallel unit vector in the target plane might be
+            # either parallel or antiparallel to the parallel unit vector in the origin plane
+            d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
+            d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
+            # Construct the new position using the predefined unit vectors of the target plane
+            newpos = target_center + d_target_perp * self.target_unit_perp
+                                   + d_target_par  * self.target_unit_par
+
+        return newpos        
+
+    def get_origin_unit_vectors(self):
+        # calculate the unit vector perpendicular and parallel to the edge
+        # in the plane of origin and the half_extent of this plane in the
+        # perpendicular vector direction
+        w_z = self.target_plane.shape.unit_z
+        u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
+        assert feq(sqrt(numpy.dot(u_perp, u_perp)), 1.0)
+
+        u_x = self.origin_plane.shape.unit_x
+        u_y = self.origin_plane.shape.unit_y
+        if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
+             u_par  = u_y
+             h_perp = self.origin_half_extent[0] # half_extent in u_x direction
+        else
+             u_par  = u_x
+             h_perp = self.origin_half_extent[1] # half_extent in u_y direction
+
+        return u_perp, u_par, h_perp
+
+    def get_target_unit_vectors(self):
+        # calculate the unit vector perpendicular and parallel to the edge
+        # in the target plane and the half_extent of this plane in the
+        # perpendicular vector direction        
+        w_perp_unnorm = self.edge_point - self.target_center
+        w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
+        assert feq(sqrt(numpy.dot(w_perp, w_perp)), 1.0)
+
+        w_x = self.target_plane.shape.unit_x
+        w_y = self.target_plane.shape.unit_y
+        if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
+             w_par = w_y
+             h_perp = self.origin_half_extent[0] # half_extent in w_x direction
+        else
+             w_par = w_x
+             h_perp = self.origin_half_extent[1] # half_extent in w_y direction
+
+        return w_perp, w_par, h_perp
+
+    def get_edge_point(self):
+        ep = self.start_position + (self.target_distance * self.origin_unit_perp)
+        return ep
+
+
+    def __str__(self):
+        return 'PlanarSurfaceEdge' + Single.__str__(self)
+
+
 class CylindricalSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a CylindricalSurface. 
     (Rods).

From 2f4f1ae4f6d86a7e9bc6dbab53423b7e21d03571 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 9 Feb 2012 20:00:46 +0100
Subject: [PATCH 0627/1541] Forgot to import new test shell into egfrd.py

... and fixed it.
---
 egfrd.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/egfrd.py b/egfrd.py
index 4edc4858..6eb8e800 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -43,6 +43,7 @@
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
     PlanarSurfacePairtestShell,
+    PlanarSurfaceEdgeSingletestShell
     CylindricalSurfaceSingletestShell,
     CylindricalSurfacePairtestShell,
     PlanarSurfaceInteractiontestShell,

From 2b42a0ac36808516a95a01a6a0ca233bbe27cdb1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 10 Feb 2012 15:26:45 +0100
Subject: [PATCH 0628/1541] Fixed some silly typos...

---
 egfrd.py  | 4 ++--
 single.py | 9 ++++-----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6eb8e800..be83a64d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -43,7 +43,7 @@
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
     PlanarSurfacePairtestShell,
-    PlanarSurfaceEdgeSingletestShell
+    PlanarSurfaceEdgeSingletestShell,
     CylindricalSurfaceSingletestShell,
     CylindricalSurfacePairtestShell,
     PlanarSurfaceInteractiontestShell,
@@ -471,7 +471,7 @@ def create_interaction(self, testShell):
     # The interaction can be any interaction (PlanarSurface or CylindricalSurface). The creation of the testShell was
     # succesful, so here we can just make the domain.
 
-#       assert that the particle is not already associate with another domain
+#       assert that the particle is not already associated with another domain
 
         assert isinstance(testShell, testInteractionSingle)
 
diff --git a/single.py b/single.py
index f5a06fc7..94c51e47 100644
--- a/single.py
+++ b/single.py
@@ -482,10 +482,9 @@ def process_new_position_vector(self, oldpos, displacement):
             d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
             d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
             # Construct the new position using the predefined unit vectors of the target plane
-            newpos = target_center + d_target_perp * self.target_unit_perp
-                                   + d_target_par  * self.target_unit_par
+            newpos = target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
 
-        return newpos        
+        return newpos
 
     def get_origin_unit_vectors(self):
         # calculate the unit vector perpendicular and parallel to the edge
@@ -500,7 +499,7 @@ def get_origin_unit_vectors(self):
         if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
              u_par  = u_y
              h_perp = self.origin_half_extent[0] # half_extent in u_x direction
-        else
+        else:
              u_par  = u_x
              h_perp = self.origin_half_extent[1] # half_extent in u_y direction
 
@@ -519,7 +518,7 @@ def get_target_unit_vectors(self):
         if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
              w_par = w_y
              h_perp = self.origin_half_extent[0] # half_extent in w_x direction
-        else
+        else:
              w_par = w_x
              h_perp = self.origin_half_extent[1] # half_extent in w_y direction
 

From c6e249cae78ff41d3e55ea599f4b8a766d6125a1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 10 Feb 2012 16:39:24 +0100
Subject: [PATCH 0629/1541] Some changes to make the edge crossing an
 interaction.

---
 egfrd.py  | 2 ++
 shells.py | 5 +++--
 single.py | 5 +++--
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index be83a64d..ac49b63d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -99,6 +99,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, PlanarSurfaceEdgeSingletestShell):
+        return PlanarSurfaceEdgeSingle       (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
diff --git a/shells.py b/shells.py
index 98bc2d70..a2b003fc 100755
--- a/shells.py
+++ b/shells.py
@@ -1113,11 +1113,12 @@ def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right, z_left
 
 #####
-class PlanarSurfaceEdgeSingletestShell(SphericaltestShell, testNonInteractionSingle):
+class PlanarSurfaceEdgeSingletestShell(SphericaltestShell, testInteractionSingle):
 
     def __init__(self, single, surface, geometrycontainer, domains):
         SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        self.origin_surface = single.structure
+        testInteractionSingle.__init__(self, single, single.structure, surface)
+        self.origin_surface = structure
         self.target_surface = surface
         assert isinstance(origin_surface, _gfrd.Surface)
         assert isinstance(target_surface, _gfrd.Surface)
diff --git a/single.py b/single.py
index 94c51e47..4700b533 100644
--- a/single.py
+++ b/single.py
@@ -381,7 +381,7 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
-class PlanarSurfaceEdgeSingle(Single, hasSphericalShell, Others):
+class PlanarSurfaceEdgeSingle(InteractionSingle, hasSphericalShell, Others):
     """1 Particle inside a (spherical) shell at the edge of two planar surfaces
 
         * Particle coordinates on surface: x, y.
@@ -390,7 +390,7 @@ class PlanarSurfaceEdgeSingle(Single, hasSphericalShell, Others):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
         assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
@@ -483,6 +483,7 @@ def process_new_position_vector(self, oldpos, displacement):
             d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
             # Construct the new position using the predefined unit vectors of the target plane
             newpos = target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
+            # TODO CHANGE SPECIES TO THE ONE THAT LIVES ON THE TARGET PLANE FOR THIS CASE
 
         return newpos
 

From 5171ad3d044ce2dda409692e5a3c9e140ab768ab Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 13 Feb 2012 11:43:05 +0100
Subject: [PATCH 0630/1541] added checks for NonInteractionSingles

---
 egfrd.py  |  7 ++++---
 single.py | 33 +++++++++++++++++++++++++++------
 2 files changed, 31 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6ee2c45c..56631bd0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2583,14 +2583,12 @@ def check_shell_matrix(self):
 
 ### check domains
 # check that testShell is of proper type
-# check that the particles are within the shells of the domain
-# check that proper number of shells for domain, most other number of shells==1
 # check that the shell(s) of domain have the proper geometry (sphere/cylinder)
 # check that shell is within minimum and maximum
 # check that shell obeys scaling properties
+# check that the particles are within the shells of the domain
 # check that the position of the shell(s) and particle(s) are within the structures that the particles live on
 # check that dt != 0 unless NonInteractionSingle.is_reset()
-# check event_type != BURST
 # check associated structures are of proper type (plane etc, but also of proper StructureTypeID)
 # check that Green's functions are defined.
 
@@ -2616,6 +2614,9 @@ def check_shell_matrix(self):
 ### check Interaction
 # check shell.unit_z = +- surface.unit_z
 
+
+
+
 ### check consistency of the model
 # check that the product species of an interaction lives on the interaction surface.
 # check that the product species of a bimolecular reaction lives on either structure of reactant species
diff --git a/single.py b/single.py
index 0789a864..b89164ec 100644
--- a/single.py
+++ b/single.py
@@ -310,11 +310,15 @@ def create_position_vector(self, r):
 
     def check(self):
         assert ProtectiveDomain.check(self)
+        # check shell stuff
         assert isinstance(self.testShell, SphericalSingletestShell)
         assert isinstance(self.shell.shape, Sphere)
         assert self.shell.shape.radius <= self.testShell.get_max_radius()
         if not self.is_reset():
-            assert self.shell.shape.radius >= self.testShell.get_min_radius()
+            assert self.shell.shape.radius*SAFETY >= self.testShell.get_min_radius()
+        if self.is_reset():
+            assert self.shell.shape.radius == self.pid_particle_pair[1].radius
+
         assert self.is_reset() ^ (self.dt != 0.0)
         assert isinstance(self.structure, CuboidalRegion)
         assert self.greens_function
@@ -396,15 +400,27 @@ def create_position_vector(self, r):
 
     def check(self):
         assert ProtectiveDomain.check(self)
+        # check shell stuff
         assert isinstance(self.testShell, PlanarSurfaceSingletestShell)
         assert isinstance(self.shell.shape, Cylinder)
-#        assert self.shell.shape.radius <= self.testShell.get_max_radius()
-#        if not self.is_reset():
-#            assert self.shell.shape.radius >= self.testShell.get_min_radius()
+
+        max_radius, _, _ = self.testShell.get_max_dr_dzright_dzleft()
+        assert self.shell.shape.radius <= max_radius
+        if not self.is_reset():
+            min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
+            assert self.shell.shape.radius*SAFETY >= min_radius
+        assert self.shell.shape.half_length == self.testShell.z_right(self.shell.shape.radius) 
+        assert self.shell.shape.half_length == self.testShell.z_left (self.shell.shape.radius)
+        if self.is_reset():
+            assert self.shell.shape.radius == self.pid_particle_pair[1].radius
+
         assert self.is_reset() ^ (self.dt != 0.0)
         assert isinstance(self.structure, PlanarSurface)
         assert self.greens_function
-        assert self.shell.shape.unit_z == self.structure.shape.unit_z
+        assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
+
+        assert numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,
+                         self.structure.shape.unit_z) == 0.0
 
         return True
 
@@ -519,15 +535,20 @@ def create_position_vector(self, z):
 
     def check(self):
         assert ProtectiveDomain.check(self)
+        # check shell stuff
         assert isinstance(self.testShell, CylindricalSurfaceSingletestShell)
         assert isinstance(self.shell.shape, Cylinder)
 #        assert self.shell.shape.radius <= self.testShell.get_max_radius()
 #        if not self.is_reset():
 #            assert self.shell.shape.radius >= self.testShell.get_min_radius()
+        if self.is_reset():
+            assert self.shell.shape.half_length == self.pid_particle_pair[1].radius
+
         assert self.is_reset() ^ (self.dt != 0.0)
         assert isinstance(self.structure, CylindricalSurface)
         assert self.greens_function
-        assert self.shell.shape.unit_z == self.structure.shape.unit_z
+        assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
+        assert self.v < numpy.inf
 
         return True
 

From 7ec0e5231691fa3839f7b7453eba3a03dd9e6fc3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 13 Feb 2012 18:51:27 +0100
Subject: [PATCH 0631/1541] Small fix to 1D Green's functions...

...that caused import errors in _greens_functions.so on a
cluster operating system.

Casting MIN_TERMS and MAX_TERMS to unsigned int when necessary
instead of defining them as such. They are of type int now.
---
 GreensFunction1DAbsAbs.cpp     | 24 ++++++++++++------------
 GreensFunction1DAbsAbs.hpp     |  4 ++--
 GreensFunction1DAbsSinkAbs.cpp | 22 +++++++++++-----------
 GreensFunction1DAbsSinkAbs.hpp |  4 ++--
 GreensFunction1DRadAbs.cpp     | 20 ++++++++++----------
 GreensFunction1DRadAbs.hpp     |  4 ++--
 6 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 7d955c46..0c555efb 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -42,7 +42,7 @@ uint GreensFunction1DAbsAbs::guess_maxi(Real const& t) const
 
     if (thr <= 0.0)
     {
-        return MAX_TERMS;
+        return static_cast<uint>(MAX_TERMS);
     }
 
     const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
@@ -50,10 +50,10 @@ uint GreensFunction1DAbsAbs::guess_maxi(Real const& t) const
     const uint maxi(std::max( safety + 
                               static_cast<uint>
                               (max_root * L  / M_PI),
-                              MIN_TERMS )
+                              static_cast<uint>(MIN_TERMS) )
                     );
 
-    return std::min(maxi, MAX_TERMS);
+    return std::min(maxi, static_cast<uint>(MAX_TERMS) );
 }
 
 
@@ -111,7 +111,7 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi >= MAX_TERMS )
+    if( maxi >= static_cast<uint>(MAX_TERMS) )
         log_.warn("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
     
     if (psurvTable.size() < maxi)
@@ -252,7 +252,7 @@ Real GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     uint n = 0;
     do
     {
-        if (n >= MAX_TERMS )
+        if (n >= static_cast<uint>(MAX_TERMS) )
         {
             log_.warn("Too many terms for prob_r. N: %6u", n);
             break;
@@ -267,7 +267,7 @@ Real GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < MIN_TERMS);
+           n < static_cast<uint>(MIN_TERMS) );
 
     return 2.0/L * exp(vexpo) * sum;
 }
@@ -317,7 +317,7 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     uint n = 0;
     do
     {
-        if (n >= MAX_TERMS )
+        if (n >= static_cast<uint>(MAX_TERMS) )
         {
             log_.warn("Too many terms for leaves. N: %6u", n);
             break;
@@ -331,7 +331,7 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < MIN_TERMS );
+           n < static_cast<uint>(MIN_TERMS) );
 
     return 2.0 * D_L_sq * exp( vexpo ) * sum;
 }
@@ -372,7 +372,7 @@ GreensFunction1DAbsAbs::leavea(Real t) const
     Real n = 0;
     do
      {
-         if (n >= MAX_TERMS )
+         if (n >= static_cast<uint>(MAX_TERMS) )
          {
              log_.warn("Too many terms for leavea. N: %6u ", n);
              break;
@@ -386,7 +386,7 @@ GreensFunction1DAbsAbs::leavea(Real t) const
      }
      while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
             fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-            n < MIN_TERMS );
+            n < static_cast<uint>(MIN_TERMS) );
      
      return - 2.0 * D_L_sq * exp(vexpo) * sum;
 }
@@ -611,7 +611,7 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
         create_p_int_r_Table(t, maxi, table);
     }
     
-    if( maxi >= MAX_TERMS )
+    if( maxi >= static_cast<uint>(MAX_TERMS) )
     {
         log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
         std::cerr << dump();
@@ -620,7 +620,7 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
 
     p = funcSum(boost::bind(&GreensFunction1DAbsAbs::p_int_r_i, 
                             this, _1, r, t, table),
-                MAX_TERMS);
+                static_cast<uint>(MAX_TERMS) );
 
     return prefac * p;
 }
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 602d7a4a..9e64078c 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -44,9 +44,9 @@ class GreensFunction1DAbsAbs: public GreensFunction
     //E3; Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms in the sum
-    static const uint MAX_TERMS = 500;
+    static const int MAX_TERMS = 500;
     // The minimum
-    static const uint MIN_TERMS = 20;
+    static const int MIN_TERMS = 20;
     // Cutoff distance: When H * sqrt(2Dt) < 1/2*L, use free greensfunction instead of absorbing.
     static const Real CUTOFF_H = 6.0;
 
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index f41b8126..d804e48f 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -238,7 +238,7 @@ uint GreensFunction1DAbsSinkAbs::guess_maxi(Real const& t) const
 
     if (thr <= 0.0)
     {
-        return MAX_TERMS;
+        return static_cast<uint>(MAX_TERMS);
     }
 
     const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
@@ -246,7 +246,7 @@ uint GreensFunction1DAbsSinkAbs::guess_maxi(Real const& t) const
     const uint maxi(safety + 
           static_cast<unsigned int>(max_root * ( getLr() + getLl() )  / M_PI));
 
-    return std::min(maxi, MAX_TERMS);
+    return std::min(maxi, static_cast<uint>(MAX_TERMS) );
 }
 
 
@@ -320,7 +320,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi == MAX_TERMS )
+    if( maxi == static_cast<uint>(MAX_TERMS) )
         log_.info("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
         
     if (psurvTable.size() < maxi )
@@ -476,13 +476,13 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     {   
         p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_r0_i, 
                                 this, _1, rr, t),
-                    MAX_TERMS);
+                    static_cast<uint>(MAX_TERMS) );
 	}
     else
     {
         p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_nor0_i, 
                                 this, _1, rr, t),
-                    MAX_TERMS);
+                    static_cast<uint>(MAX_TERMS) );
     }
     
     return p;
@@ -547,7 +547,7 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 
     p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_tot_i, 
                             this, _1, t),
-                MAX_TERMS);
+                static_cast<uint>(MAX_TERMS) );
 
     return D * p;
 }
@@ -572,7 +572,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t, uint const& maxi) const
    
     p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Lr_i, 
                             this, _1, t),
-                MAX_TERMS);
+                static_cast<uint>(MAX_TERMS) );
 
     return - D * 2 * p;
 }
@@ -605,7 +605,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t, uint const& maxi) const
 
     p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Ll_i, 
                             this, _1, t),
-                MAX_TERMS);
+                static_cast<uint>(MAX_TERMS));
     
     return 2 * D2 * p;
 }
@@ -685,7 +685,7 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
     /* Allready fill rootList with needed roots. */ 
     const uint maxi( guess_maxi( t ) );
 
-    if( maxi == MAX_TERMS )
+    if( maxi == static_cast<uint>(MAX_TERMS) )
         log_.info("drawEventType: maxi was cut to MAX_TERMS for t = %.16g", t);
 
     calculate_n_roots( maxi );
@@ -876,7 +876,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
 
     const uint maxi( guess_maxi(t) );
 
-    if( maxi == MAX_TERMS )
+    if( maxi == static_cast<uint>(MAX_TERMS) )
         log_.warn("p_int_r_table: maxi was cut to MAX_TERMS for t = %.16g"
                   , t);
    
@@ -900,7 +900,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
 
     p = funcSum(boost::bind(p_int_r_i, 
                             this, _1, rr, t, table),
-                MAX_TERMS);
+                static_cast<uint>(MAX_TERMS));
 
     return 2.0 * p;
 }
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 3182e5da..377f7c15 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -42,9 +42,9 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     // Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms used in calculating the sum
-    static const uint MAX_TERMS = 500;
+    static const int MAX_TERMS = 500;
     // The minimum number of terms
-    static const uint MIN_TERMS = 20;
+    static const int MIN_TERMS = 20;
     /* Cutoff distance: When H * sqrt(2Dt) < a - r0 OR ro - sigma
        use free greensfunction instead of absorbing. */
     static const Real CUTOFF_H = 6.0;
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 30ef2cd2..675f99eb 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -127,7 +127,7 @@ uint GreensFunction1DRadAbs::guess_maxi(Real const& t) const
 
     if (thr <= 0.0)
     {
-        return MAX_TERMS;
+        return static_cast<uint>(MAX_TERMS);
     }
 
     const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
@@ -135,10 +135,10 @@ uint GreensFunction1DRadAbs::guess_maxi(Real const& t) const
     const uint maxi(std::max( safety + 
                               static_cast<uint>
                               (max_root * L  / M_PI),
-                              MIN_TERMS )
+                              static_cast<uint>(MIN_TERMS) )
                     );
 
-    return std::min(maxi, MAX_TERMS);
+    return std::min(maxi, static_cast<uint>(MAX_TERMS) );
 }
 
 
@@ -255,7 +255,7 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi >= MAX_TERMS )
+    if( maxi >= static_cast<uint>(MAX_TERMS) )
         log_.warn("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
     
     if ( psurvTable.size() < maxi )
@@ -409,7 +409,7 @@ Real GreensFunction1DRadAbs::prob_r (Real r, Real t) const
     uint n = 0;
     do
     {
-        if ( n >= MAX_TERMS )
+        if ( n >= static_cast<uint>(MAX_TERMS) )
         {
             log_.warn("Too many terms needed for prob_r. N: %5u", n);
             break;
@@ -426,7 +426,7 @@ Real GreensFunction1DRadAbs::prob_r (Real r, Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < MIN_TERMS );
+           n < static_cast<uint>(MIN_TERMS) );
 
     return 2.0*exp(vexpo)*sum;
 }
@@ -460,7 +460,7 @@ Real GreensFunction1DRadAbs::flux_tot (Real t) const
     uint n = 0;
     do
     {
-        if ( n >= MAX_TERMS )
+        if ( n >= static_cast<uint>(MAX_TERMS) )
         {
             log_.warn("Too many terms needed for flux_tot. N: %5u", n );
             break;
@@ -474,7 +474,7 @@ Real GreensFunction1DRadAbs::flux_tot (Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < MIN_TERMS );
+           n < static_cast<uint>(MIN_TERMS) );
 
     return 2.0*D*exp(vexpo)*sum;
 }
@@ -729,7 +729,7 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
     const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
     const Real prefac( 2.0*exp(vexpo) );
 
-    if( maxi >= MAX_TERMS )
+    if( maxi >= static_cast<uint>(MAX_TERMS) )
     {
         log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
         std::cerr << dump();
@@ -744,7 +744,7 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
 
     p = funcSum(boost::bind(&GreensFunction1DRadAbs::p_int_r_i, 
                             this, _1, r, t, table),
-                MAX_TERMS);
+                static_cast<uint>(MAX_TERMS) );
 
     return prefac * p;
 }
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 9a4d294d..46750c88 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -41,9 +41,9 @@ class GreensFunction1DRadAbs: public GreensFunction
     // Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms used in calculating the sum
-    static const uint MAX_TERMS = 500;
+    static const int MAX_TERMS = 500;
     // The minimum number of terms
-    static const uint MIN_TERMS = 20;
+    static const int MIN_TERMS = 20;
     /* Cutoff distance: When H * sqrt(2Dt) < a - r0 OR ro - sigma
        use free greensfunction instead of absorbing. */
     static const Real CUTOFF_H = 6.0;

From 10359184b08a91afb498524d5860530c789d6e0d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 14 Feb 2012 10:42:01 +0100
Subject: [PATCH 0632/1541] added comments

---
 CylindricalSurface.hpp |  5 +++++
 Model.cpp              |  6 ++++++
 Model.hpp              | 15 +++++++++++----
 ParticleID.hpp         |  3 +++
 ParticleModel.cpp      |  1 +
 PlanarSurface.hpp      |  5 +++++
 SpeciesType.cpp        |  4 ++++
 SpeciesType.hpp        | 17 +++++++++++++----
 SpeciesTypeID.hpp      |  1 +
 World.hpp              | 32 ++++++++++++++++++++++----------
 10 files changed, 71 insertions(+), 18 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index a6fae23e..72652575 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -11,6 +11,8 @@ template<typename Ttraits_>
 class CylindricalSurface
     : public BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> >
 {
+    // The CylindricalSurface is the implementation of a Basic surface parameterized with a Cylinder
+
 public:
     typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
@@ -23,17 +25,20 @@ class CylindricalSurface
     typedef std::pair<position_type, position_type> position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
+    // Gives a random position in the cylinder (1D)
     {
         return ::random_position(base_type::shape(), boost::bind(&rng_type::uniform, rng, -1., 1.));
     }
 
     virtual position_type random_vector(length_type const& r, rng_type& rng) const
+    // Gives a random vector in the axis of the cylinder
     {
         return multiply(base_type::shape().unit_z(),
                 (rng.uniform_int(0, 1) * 2 - 1) * r);
     }
 
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
+    // BD displacement for BD on the line of the cylinder?
     {
         return multiply(base_type::shape().unit_z(), rng.normal(mean, r));
     }
diff --git a/Model.cpp b/Model.cpp
index 34e2ca33..3a8defb6 100644
--- a/Model.cpp
+++ b/Model.cpp
@@ -14,6 +14,8 @@
 #include "Model.hpp"
 
 Model::Model(): network_rules_(new BasicNetworkRulesImpl())
+// The model class is more or less an implementation of the network rules
+// The network rules define the possible reactions between species.
 {
 }
 
@@ -25,9 +27,11 @@ void Model::add_species_type(boost::shared_ptr<species_type_type> const& species
 {
     species->bind_to_model(this, species_type_id_generator_());
     species_type_map_.insert(std::make_pair(species->id(), species));
+    // the species_type_map_ is a mapping (container) between the species_id and the species object
 }
 
 boost::shared_ptr<Model::species_type_type> Model::get_species_type_by_id(species_id_type const& id) const
+// Returns the species if you give it an species 'id'
 {
     species_type_map_type::const_iterator i(species_type_map_.find(id));
     if (species_type_map_.end() == i)
@@ -39,6 +43,7 @@ boost::shared_ptr<Model::species_type_type> Model::get_species_type_by_id(specie
 }
 
 Model::species_type_range Model::get_species_types() const
+// Just gets all the species in the model
 {
     return species_type_range(
         species_type_iterator(species_type_map_.begin(), species_second_selector_type()),
@@ -46,6 +51,7 @@ Model::species_type_range Model::get_species_types() const
 }
 
 std::string const& Model::operator[](std::string const& name) const
+// Gets the name of the species? Or gets the value of an attribute by name?
 {
     string_map_type::const_iterator i(attrs_.find(name));
     if (i == attrs_.end())
diff --git a/Model.hpp b/Model.hpp
index 2e9505e0..70909114 100644
--- a/Model.hpp
+++ b/Model.hpp
@@ -38,6 +38,8 @@ class Model: private boost::noncopyable
     typedef boost::iterator_range<string_map_iterator> attributes_range;
 
 public:
+    // The model class is more or less an implementation of the network rules
+    // The network rules define the possible reactions between species.
     Model();
 
     virtual ~Model();
@@ -48,26 +50,31 @@ class Model: private boost::noncopyable
     }
 
     void add_species_type(boost::shared_ptr<species_type_type> const& species);
+    // Adds a species to the model
 
     boost::shared_ptr<species_type_type> get_species_type_by_id(species_id_type const& id) const;
+    // Gets a species by the species 'id'
 
     species_type_range get_species_types() const;
+    // Gets all the species in the model
 
     std::string const& operator[](std::string const& name) const;
 
     std::string& operator[](std::string const& name);
+    // Not sure. Get attribute by name?
 
     attributes_range attributes() const
+    // Get all the attributes
     {
         return attributes_range(attrs_.begin(), attrs_.end());
     }
 
 
 public:
-    species_type_id_generator_type species_type_id_generator_;
-    species_type_map_type species_type_map_;
-    boost::scoped_ptr<NetworkRules> network_rules_;
-    string_map_type attrs_;
+    species_type_id_generator_type species_type_id_generator_;  // The id generator which makes sure that all species have a unique id
+    species_type_map_type species_type_map_;                    // ??
+    boost::scoped_ptr<NetworkRules> network_rules_;             // The network rules in the model
+    string_map_type attrs_;                                     // All the attributes
 };
 
 
diff --git a/ParticleID.hpp b/ParticleID.hpp
index f7710041..fc28fb45 100644
--- a/ParticleID.hpp
+++ b/ParticleID.hpp
@@ -16,6 +16,7 @@
 #include "Identifier.hpp"
 
 struct ParticleID: public Identifier<ParticleID, unsigned long long, int>
+// The ParticleID is a class for the identification of particles
 {
     typedef Identifier<ParticleID, unsigned long long, int> base_type;
 
@@ -33,6 +34,7 @@ namespace boost {
 
 template<>
 struct hash<ParticleID>
+// Hashing function??
 {
     std::size_t operator()(ParticleID const& val) const
     {
@@ -51,6 +53,7 @@ struct hash<ParticleID>
 template<typename Tstrm_, typename Ttraits_>
 inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm,
         const ParticleID& v)
+// Provides a stream of characters (a string) of the 'particle id' that allows for printing.
 {
     strm << "PID(" << v().first << ":" << v().second << ")";
     return strm;
diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index 90a026d9..c66818a7 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -45,6 +45,7 @@ boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structu
 }
 
 ParticleModel::structure_type_range ParticleModel::get_structure_types() const
+// Returns all the structure types that are present in the particle model
 {
     return structure_type_range(
         structure_type_iterator(structure_type_map_.begin(), structure_second_selector_type()),
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index cfac7c3c..075c30e7 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -10,6 +10,8 @@ template<typename Ttraits_>
 class PlanarSurface
     : public BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::world_type::traits_type::length_type> >
 {
+    // The planar surface is an implementation of a Basic surface parameterized with the plane
+
 public:
     typedef BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
@@ -23,11 +25,13 @@ class PlanarSurface
     typedef std::pair<position_type, length_type> projected_type;
 
     virtual position_type random_position(rng_type& rng) const
+    // Selects a random position in the plane
     {
         return ::random_position(base_type::shape(), boost::bind(&rng_type::uniform, rng, -1., 1.));
     }
 
     virtual position_type random_vector(length_type const& r, rng_type& rng) const
+    // Provides a random vector in the plane
     {
         return multiply(
             normalize(
@@ -39,6 +43,7 @@ class PlanarSurface
     }
 
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
+    // Calculated a bd displacement for particles diffusing in the plane?
     {
         length_type const x(rng.normal(0., r)), y(rng.normal(0., r));
         return add(
diff --git a/SpeciesType.cpp b/SpeciesType.cpp
index 82fb55ad..2873b57f 100644
--- a/SpeciesType.cpp
+++ b/SpeciesType.cpp
@@ -5,6 +5,7 @@
 #include "SpeciesType.hpp"
 
 SpeciesType::identifier_type const& SpeciesType::id() const
+// Gets the id of the SpeciesType (ONLY DEFINED WHEN SpeciesType is bound to model)
 {
     if (!model_)
     {
@@ -14,6 +15,7 @@ SpeciesType::identifier_type const& SpeciesType::id() const
 }
     
 std::string const& SpeciesType::operator[](std::string const& name) const
+// Get an attribute value by name. Usage for example: a = 'species_type['name']'
 {
     string_map_type::const_iterator i(attrs_.find(name));
     if (i == attrs_.end())
@@ -22,11 +24,13 @@ std::string const& SpeciesType::operator[](std::string const& name) const
 }
 
 std::string& SpeciesType::operator[](std::string const& name)
+// Same thing as above but messier?
 {
     return attrs_[name];
 }
 
 SpeciesType::attributes_range SpeciesType::attributes() const
+// Gets all the attributes
 {
     return attributes_range(attrs_.begin(), attrs_.end());
 }
diff --git a/SpeciesType.hpp b/SpeciesType.hpp
index d0913558..c17c87f8 100644
--- a/SpeciesType.hpp
+++ b/SpeciesType.hpp
@@ -22,7 +22,7 @@ class SpeciesType
     typedef get_mapper_mf<std::string, std::string>::type string_map_type;
 
 public:
-    typedef SpeciesTypeID identifier_type;
+    typedef SpeciesTypeID identifier_type;                          // The identifier
     typedef string_map_type::const_iterator string_map_iterator;
     typedef boost::iterator_range<string_map_iterator> attributes_range;
 
@@ -36,28 +36,37 @@ class SpeciesType
     attributes_range attributes() const;
 
     Model* model() const
+    // The model with which this species type is associated?
     {
         return model_;
     }
 
     SpeciesType(): model_(0) {}
+    // The constructor initializes the model with '0'
  
 protected:
     void bind_to_model(Model* model, identifier_type const& id)
+    // Later the species type can be bound to the model.
+    // Note that also here the id is fixed -> Only when bound to a model is the id known
     {
         model_ = model; 
         id_ = id;
     }
 
+
+////////// Member variables
 private:
-    Model* model_;
-    identifier_type id_;
-    string_map_type attrs_;
+    Model* model_;              // The model to which the species type is bound
+    identifier_type id_;        // The id of the species type
+    string_map_type attrs_;     // all the attributes?
 };
 
+
 template<typename Tchar_, typename Ttraits_>
 inline std::basic_ostream<Tchar_, Ttraits_>&
 operator<<(std::basic_ostream<Tchar_, Ttraits_>& out, const SpeciesType& v)
+// Allows for printing of the object
+// -> provides a stream of 'attributename : attribute_value' pairs.
 {
     bool first = true;
     out << "SpeciesType(id=" << v.id() << ", attributes={";
diff --git a/SpeciesTypeID.hpp b/SpeciesTypeID.hpp
index 3680e481..062a4fe5 100644
--- a/SpeciesTypeID.hpp
+++ b/SpeciesTypeID.hpp
@@ -16,6 +16,7 @@
 #include "Identifier.hpp"
 
 struct SpeciesTypeID: public Identifier<SpeciesTypeID, unsigned long long, int>
+// The SpeciesTypeID is an indentifier class for species types (species?) but is also used for structure(type)s
 {
     typedef Identifier<SpeciesTypeID, unsigned long long, int> base_type;
 
diff --git a/World.hpp b/World.hpp
index 23635422..d4118580 100644
--- a/World.hpp
+++ b/World.hpp
@@ -37,11 +37,11 @@ struct WorldTraitsBase
     typedef Tlen_ length_type;
     typedef TD_ D_type;
     typedef TD_ v_type;
-    typedef ParticleID particle_id_type;
+    typedef ParticleID particle_id_type;                                    // identifier type for particles
     typedef SerialIDGenerator<particle_id_type> particle_id_generator;
-    typedef SpeciesTypeID species_id_type;
-    typedef Particle<length_type, D_type, species_id_type> particle_type;
-    typedef std::string structure_id_type;
+    typedef SpeciesTypeID species_id_type;                                  // identifier type for species and (structure types)
+    typedef Particle<length_type, D_type, species_id_type> particle_type;   // type for particles
+    typedef std::string structure_id_type;                                  // identifier type for structures
     // typedef SpeciesTypeID structure_id_type;
     typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type> species_type;
     typedef Vector3<length_type> point_type;
@@ -56,12 +56,14 @@ template<typename Tlen_, typename TD_>
 struct WorldTraits: public WorldTraitsBase<WorldTraits<Tlen_, TD_>, Tlen_, TD_>
 {
 public:
+    // This is the normal world (without periodic/cyclic boundary conditions)
     typedef WorldTraitsBase<WorldTraits<Tlen_, TD_>, Tlen_, TD_> base_type;
     typedef typename base_type::length_type length_type;
     typedef typename base_type::position_type position_type;
 
     template<typename Tval_>
     static Tval_ apply_boundary(Tval_ const& v, length_type const& world_size)
+    // apply_boundary is here defined for consistency
     {
         return v;
     }
@@ -74,6 +76,7 @@ struct WorldTraits: public WorldTraitsBase<WorldTraits<Tlen_, TD_>, Tlen_, TD_>
 
     template<typename T1_, typename T2_>
     static length_type distance(T1_ const& p0, T2_ const& p1, length_type const& world_size)
+    // The distance function
     {
         return ::distance(p0, p1);
     }
@@ -107,28 +110,34 @@ template<typename Tlen_, typename TD_>
 struct CyclicWorldTraits: public WorldTraitsBase<CyclicWorldTraits<Tlen_, TD_>, Tlen_, TD_>
 {
 public:
+    // This is the world WITH periodic/cyclic boundary conditions
     typedef WorldTraitsBase<CyclicWorldTraits<Tlen_, TD_>, Tlen_, TD_> base_type;
     typedef typename base_type::length_type length_type;
     typedef typename base_type::position_type position_type;
 
     template<typename Tval_>
     static Tval_ apply_boundary(Tval_ const& v, length_type const& world_size)
+    // This applied the periodic boundary conditions
     {
         return ::apply_boundary(v, world_size);
     }
 
     static length_type cyclic_transpose(length_type const& p0, length_type const& p1, length_type const& world_size)
+    // selects the copy of p0 (over the periodic boundaries) such that the distance between p0 and p1 is minimized over
+    // over the periodic boundary conditions.
     {
         return ::cyclic_transpose(p0, p1, world_size);
     }
 
     static position_type cyclic_transpose(position_type const& p0, position_type const& p1, length_type const& world_size)
+    // Not sure what the difference is with above method
     {
         return ::cyclic_transpose(p0, p1, world_size);
     }
 
     template<typename T1_, typename T2_>
     static length_type distance(T1_ const& p0, T2_ const& p1, length_type const& world_size)
+    // This distance function in the presence of the periodic boundary conditions
     {
         return distance_cyclic(p0, p1, world_size);
     }
@@ -205,8 +214,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         species_type const& species(get_species(sid));
         particle_id_pair retval(pidgen_(),
-            particle_type(sid, particle_shape_type(pos, species.radius()),
-                          species.D(), species.v() ));
+                                particle_type(sid, particle_shape_type(pos, species.radius()),
+                                              species.D(), species.v() ));
         update_particle(retval);
         return retval;
     }
@@ -231,6 +240,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
 
     virtual bool remove_particle(particle_id_type const& id)
+    // Removed the particle by id 'id' if present in the world.
     {
         bool found(false);
         particle_id_pair pp(get_particle(id, found));
@@ -244,7 +254,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
 
     void add_species(species_type const& species)
-// Wouldn't it make more sence to make this method part of the model class instead of the world class?
+    // Adds a species to the world.
+    // Wouldn't it make more sence to make this method part of the model class instead of the world class?
     {
         species_map_[species.id()] = species;
         particle_pool_[species.id()] = particle_id_set();
@@ -326,10 +337,11 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return (*i).second;
     }
 
+///////////// Member variables
 private:
-    particle_id_generator pidgen_;
-    species_map species_map_;
-    structure_map structure_map_;
+    particle_id_generator pidgen_;                  // generator used to produce the unique ids for the particles
+    species_map species_map_;                       // ?
+    structure_map structure_map_;                   // ?
     per_species_particle_id_set particle_pool_;
 };
 

From 67a5a76a654379fc770162ebeed9498f1047c3b8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 14 Feb 2012 12:04:19 +0100
Subject: [PATCH 0633/1541] Revert "Small fix to 1D Green's functions..."

---
 GreensFunction1DAbsAbs.cpp     | 24 ++++++++++++------------
 GreensFunction1DAbsAbs.hpp     |  4 ++--
 GreensFunction1DAbsSinkAbs.cpp | 22 +++++++++++-----------
 GreensFunction1DAbsSinkAbs.hpp |  4 ++--
 GreensFunction1DRadAbs.cpp     | 20 ++++++++++----------
 GreensFunction1DRadAbs.hpp     |  4 ++--
 6 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 0c555efb..7d955c46 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -42,7 +42,7 @@ uint GreensFunction1DAbsAbs::guess_maxi(Real const& t) const
 
     if (thr <= 0.0)
     {
-        return static_cast<uint>(MAX_TERMS);
+        return MAX_TERMS;
     }
 
     const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
@@ -50,10 +50,10 @@ uint GreensFunction1DAbsAbs::guess_maxi(Real const& t) const
     const uint maxi(std::max( safety + 
                               static_cast<uint>
                               (max_root * L  / M_PI),
-                              static_cast<uint>(MIN_TERMS) )
+                              MIN_TERMS )
                     );
 
-    return std::min(maxi, static_cast<uint>(MAX_TERMS) );
+    return std::min(maxi, MAX_TERMS);
 }
 
 
@@ -111,7 +111,7 @@ Real GreensFunction1DAbsAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi >= static_cast<uint>(MAX_TERMS) )
+    if( maxi >= MAX_TERMS )
         log_.warn("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
     
     if (psurvTable.size() < maxi)
@@ -252,7 +252,7 @@ Real GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     uint n = 0;
     do
     {
-        if (n >= static_cast<uint>(MAX_TERMS) )
+        if (n >= MAX_TERMS )
         {
             log_.warn("Too many terms for prob_r. N: %6u", n);
             break;
@@ -267,7 +267,7 @@ Real GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < static_cast<uint>(MIN_TERMS) );
+           n < MIN_TERMS);
 
     return 2.0/L * exp(vexpo) * sum;
 }
@@ -317,7 +317,7 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     uint n = 0;
     do
     {
-        if (n >= static_cast<uint>(MAX_TERMS) )
+        if (n >= MAX_TERMS )
         {
             log_.warn("Too many terms for leaves. N: %6u", n);
             break;
@@ -331,7 +331,7 @@ GreensFunction1DAbsAbs::leaves(Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < static_cast<uint>(MIN_TERMS) );
+           n < MIN_TERMS );
 
     return 2.0 * D_L_sq * exp( vexpo ) * sum;
 }
@@ -372,7 +372,7 @@ GreensFunction1DAbsAbs::leavea(Real t) const
     Real n = 0;
     do
      {
-         if (n >= static_cast<uint>(MAX_TERMS) )
+         if (n >= MAX_TERMS )
          {
              log_.warn("Too many terms for leavea. N: %6u ", n);
              break;
@@ -386,7 +386,7 @@ GreensFunction1DAbsAbs::leavea(Real t) const
      }
      while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
             fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-            n < static_cast<uint>(MIN_TERMS) );
+            n < MIN_TERMS );
      
      return - 2.0 * D_L_sq * exp(vexpo) * sum;
 }
@@ -611,7 +611,7 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
         create_p_int_r_Table(t, maxi, table);
     }
     
-    if( maxi >= static_cast<uint>(MAX_TERMS) )
+    if( maxi >= MAX_TERMS )
     {
         log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
         std::cerr << dump();
@@ -620,7 +620,7 @@ Real GreensFunction1DAbsAbs::p_int_r_table(Real const& r,
 
     p = funcSum(boost::bind(&GreensFunction1DAbsAbs::p_int_r_i, 
                             this, _1, r, t, table),
-                static_cast<uint>(MAX_TERMS) );
+                MAX_TERMS);
 
     return prefac * p;
 }
diff --git a/GreensFunction1DAbsAbs.hpp b/GreensFunction1DAbsAbs.hpp
index 9e64078c..602d7a4a 100644
--- a/GreensFunction1DAbsAbs.hpp
+++ b/GreensFunction1DAbsAbs.hpp
@@ -44,9 +44,9 @@ class GreensFunction1DAbsAbs: public GreensFunction
     //E3; Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms in the sum
-    static const int MAX_TERMS = 500;
+    static const uint MAX_TERMS = 500;
     // The minimum
-    static const int MIN_TERMS = 20;
+    static const uint MIN_TERMS = 20;
     // Cutoff distance: When H * sqrt(2Dt) < 1/2*L, use free greensfunction instead of absorbing.
     static const Real CUTOFF_H = 6.0;
 
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index d804e48f..f41b8126 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -238,7 +238,7 @@ uint GreensFunction1DAbsSinkAbs::guess_maxi(Real const& t) const
 
     if (thr <= 0.0)
     {
-        return static_cast<uint>(MAX_TERMS);
+        return MAX_TERMS;
     }
 
     const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
@@ -246,7 +246,7 @@ uint GreensFunction1DAbsSinkAbs::guess_maxi(Real const& t) const
     const uint maxi(safety + 
           static_cast<unsigned int>(max_root * ( getLr() + getLl() )  / M_PI));
 
-    return std::min(maxi, static_cast<uint>(MAX_TERMS) );
+    return std::min(maxi, MAX_TERMS);
 }
 
 
@@ -320,7 +320,7 @@ Real GreensFunction1DAbsSinkAbs::p_survival_table(Real t, RealVector& psurvTable
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi == static_cast<uint>(MAX_TERMS) )
+    if( maxi == MAX_TERMS )
         log_.info("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
         
     if (psurvTable.size() < maxi )
@@ -476,13 +476,13 @@ Real GreensFunction1DAbsSinkAbs::prob_r(Real r, Real t) const
     {   
         p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_r0_i, 
                                 this, _1, rr, t),
-                    static_cast<uint>(MAX_TERMS) );
+                    MAX_TERMS);
 	}
     else
     {
         p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::prob_r_nor0_i, 
                                 this, _1, rr, t),
-                    static_cast<uint>(MAX_TERMS) );
+                    MAX_TERMS);
     }
     
     return p;
@@ -547,7 +547,7 @@ Real GreensFunction1DAbsSinkAbs::flux_tot(Real t) const
 
     p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_tot_i, 
                             this, _1, t),
-                static_cast<uint>(MAX_TERMS) );
+                MAX_TERMS);
 
     return D * p;
 }
@@ -572,7 +572,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Lr(Real t, uint const& maxi) const
    
     p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Lr_i, 
                             this, _1, t),
-                static_cast<uint>(MAX_TERMS) );
+                MAX_TERMS);
 
     return - D * 2 * p;
 }
@@ -605,7 +605,7 @@ Real GreensFunction1DAbsSinkAbs::flux_abs_Ll(Real t, uint const& maxi) const
 
     p = funcSum(boost::bind(&GreensFunction1DAbsSinkAbs::flux_abs_Ll_i, 
                             this, _1, t),
-                static_cast<uint>(MAX_TERMS));
+                MAX_TERMS);
     
     return 2 * D2 * p;
 }
@@ -685,7 +685,7 @@ GreensFunction1DAbsSinkAbs::drawEventType( Real rnd, Real t ) const
     /* Allready fill rootList with needed roots. */ 
     const uint maxi( guess_maxi( t ) );
 
-    if( maxi == static_cast<uint>(MAX_TERMS) )
+    if( maxi == MAX_TERMS )
         log_.info("drawEventType: maxi was cut to MAX_TERMS for t = %.16g", t);
 
     calculate_n_roots( maxi );
@@ -876,7 +876,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
 
     const uint maxi( guess_maxi(t) );
 
-    if( maxi == static_cast<uint>(MAX_TERMS) )
+    if( maxi == MAX_TERMS )
         log_.warn("p_int_r_table: maxi was cut to MAX_TERMS for t = %.16g"
                   , t);
    
@@ -900,7 +900,7 @@ Real GreensFunction1DAbsSinkAbs::p_int_r_table(Real const& r,
 
     p = funcSum(boost::bind(p_int_r_i, 
                             this, _1, rr, t, table),
-                static_cast<uint>(MAX_TERMS));
+                MAX_TERMS);
 
     return 2.0 * p;
 }
diff --git a/GreensFunction1DAbsSinkAbs.hpp b/GreensFunction1DAbsSinkAbs.hpp
index 377f7c15..3182e5da 100644
--- a/GreensFunction1DAbsSinkAbs.hpp
+++ b/GreensFunction1DAbsSinkAbs.hpp
@@ -42,9 +42,9 @@ class GreensFunction1DAbsSinkAbs: public GreensFunction
     // Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms used in calculating the sum
-    static const int MAX_TERMS = 500;
+    static const uint MAX_TERMS = 500;
     // The minimum number of terms
-    static const int MIN_TERMS = 20;
+    static const uint MIN_TERMS = 20;
     /* Cutoff distance: When H * sqrt(2Dt) < a - r0 OR ro - sigma
        use free greensfunction instead of absorbing. */
     static const Real CUTOFF_H = 6.0;
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 675f99eb..30ef2cd2 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -127,7 +127,7 @@ uint GreensFunction1DRadAbs::guess_maxi(Real const& t) const
 
     if (thr <= 0.0)
     {
-        return static_cast<uint>(MAX_TERMS);
+        return MAX_TERMS;
     }
 
     const Real max_root( sqrt(root0 * root0 - log(thr) / Dt) );
@@ -135,10 +135,10 @@ uint GreensFunction1DRadAbs::guess_maxi(Real const& t) const
     const uint maxi(std::max( safety + 
                               static_cast<uint>
                               (max_root * L  / M_PI),
-                              static_cast<uint>(MIN_TERMS) )
+                              MIN_TERMS )
                     );
 
-    return std::min(maxi, static_cast<uint>(MAX_TERMS) );
+    return std::min(maxi, MAX_TERMS);
 }
 
 
@@ -255,7 +255,7 @@ Real GreensFunction1DRadAbs::p_survival_table(Real t, RealVector& psurvTable) co
 
     const uint maxi( guess_maxi(t) );
     
-    if( maxi >= static_cast<uint>(MAX_TERMS) )
+    if( maxi >= MAX_TERMS )
         log_.warn("drawT: maxi was cut to MAX_TERMS for t = %.16g", t);
     
     if ( psurvTable.size() < maxi )
@@ -409,7 +409,7 @@ Real GreensFunction1DRadAbs::prob_r (Real r, Real t) const
     uint n = 0;
     do
     {
-        if ( n >= static_cast<uint>(MAX_TERMS) )
+        if ( n >= MAX_TERMS )
         {
             log_.warn("Too many terms needed for prob_r. N: %5u", n);
             break;
@@ -426,7 +426,7 @@ Real GreensFunction1DRadAbs::prob_r (Real r, Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL || 
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < static_cast<uint>(MIN_TERMS) );
+           n < MIN_TERMS );
 
     return 2.0*exp(vexpo)*sum;
 }
@@ -460,7 +460,7 @@ Real GreensFunction1DRadAbs::flux_tot (Real t) const
     uint n = 0;
     do
     {
-        if ( n >= static_cast<uint>(MAX_TERMS) )
+        if ( n >= MAX_TERMS )
         {
             log_.warn("Too many terms needed for flux_tot. N: %5u", n );
             break;
@@ -474,7 +474,7 @@ Real GreensFunction1DRadAbs::flux_tot (Real t) const
     }
     while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
            fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
-           n < static_cast<uint>(MIN_TERMS) );
+           n < MIN_TERMS );
 
     return 2.0*D*exp(vexpo)*sum;
 }
@@ -729,7 +729,7 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
     const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
     const Real prefac( 2.0*exp(vexpo) );
 
-    if( maxi >= static_cast<uint>(MAX_TERMS) )
+    if( maxi >= MAX_TERMS )
     {
         log_.warn("drawR: maxi was cut to MAX_TERMS for t = %.16g", t);
         std::cerr << dump();
@@ -744,7 +744,7 @@ Real GreensFunction1DRadAbs::p_int_r_table(Real const& r,
 
     p = funcSum(boost::bind(&GreensFunction1DRadAbs::p_int_r_i, 
                             this, _1, r, t, table),
-                static_cast<uint>(MAX_TERMS) );
+                MAX_TERMS);
 
     return prefac * p;
 }
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 46750c88..9a4d294d 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -41,9 +41,9 @@ class GreensFunction1DRadAbs: public GreensFunction
     // Is 1E3 a good measure for the probability density?!
     static const Real PDENS_TYPICAL = 1;
     // The maximum number of terms used in calculating the sum
-    static const int MAX_TERMS = 500;
+    static const uint MAX_TERMS = 500;
     // The minimum number of terms
-    static const int MIN_TERMS = 20;
+    static const uint MIN_TERMS = 20;
     /* Cutoff distance: When H * sqrt(2Dt) < a - r0 OR ro - sigma
        use free greensfunction instead of absorbing. */
     static const Real CUTOFF_H = 6.0;

From 2fa7a4b423379db21422f5d315b0b233c6649492 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 14 Feb 2012 12:08:27 +0100
Subject: [PATCH 0634/1541] Replacement fix to avoid problems with BOOST

---
 GreensFunction1DAbsAbs.cpp     | 2 ++
 GreensFunction1DAbsSinkAbs.cpp | 3 +++
 GreensFunction1DRadAbs.cpp     | 3 +++
 3 files changed, 8 insertions(+)

diff --git a/GreensFunction1DAbsAbs.cpp b/GreensFunction1DAbsAbs.cpp
index 7d955c46..5549f4b1 100644
--- a/GreensFunction1DAbsAbs.cpp
+++ b/GreensFunction1DAbsAbs.cpp
@@ -20,6 +20,8 @@
 #include "findRoot.hpp"
 #include "GreensFunction1DAbsAbs.hpp"
 
+const unsigned int GreensFunction1DAbsAbs::MAX_TERMS;
+const unsigned int GreensFunction1DAbsAbs::MIN_TERMS;
 
 /* returns a guess for the number of terms needed for 
    the greensfunction to converge at time t */
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index f41b8126..1f70b330 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -19,6 +19,9 @@
 #include "findRoot.hpp"
 #include "GreensFunction1DAbsSinkAbs.hpp"
 
+const unsigned int GreensFunction1DAbsSinkAbs::MAX_TERMS;
+const unsigned int GreensFunction1DAbsSinkAbs::MIN_TERMS;
+
 /* This is the appropriate definition of the function defining
    the roots of our Green's functions in GSL.
    Later needed by the rootfinder. */
diff --git a/GreensFunction1DRadAbs.cpp b/GreensFunction1DRadAbs.cpp
index 30ef2cd2..01f9ead4 100644
--- a/GreensFunction1DRadAbs.cpp
+++ b/GreensFunction1DRadAbs.cpp
@@ -19,6 +19,9 @@
 #include "findRoot.hpp"
 #include "GreensFunction1DRadAbs.hpp"
 
+const unsigned int GreensFunction1DRadAbs::MAX_TERMS;
+const unsigned int GreensFunction1DRadAbs::MIN_TERMS;
+
 // This is the appropriate definition of the function defining
 // the roots of our Green's functions in GSL.
 // Later needed by the rootfinder.

From 05a50eb2a2870ba676f08f92060cb9a1c1599802 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Tue, 14 Feb 2012 15:21:42 +0100
Subject: [PATCH 0635/1541] Commented out some Gillespie code.

---
 dumper.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/dumper.py b/dumper.py
index 33c0c781..3d9ba629 100644
--- a/dumper.py
+++ b/dumper.py
@@ -2,7 +2,7 @@
 from pair import Pair
 from multi import Multi
 from egfrd import EGFRDSimulator
-from gillespie import GillespieSimulator
+#from gillespie import GillespieSimulator
 import _gfrd
 
 # get methods return an iterator, dump methods return a string.
@@ -116,9 +116,10 @@ def get_particles(sim, identifier=None):
             all (particle identifier, particle)-pairs will be returned.
 
     """
-    if isinstance(sim, GillespieSimulator):
-        raise RuntimeError('GillespieSimulator does not keep track '
-                           'of individual particles.')
+# TODO: Gillespie simulator should be legacy; remove
+#    if isinstance(sim, GillespieSimulator):
+#        raise RuntimeError('GillespieSimulator does not keep track '
+#                           'of individual particles.')
 
     if identifier == None:
         return sim.world

From fd508b60ed110b3a5c35509b660863826bb7537f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 14 Feb 2012 18:19:59 +0100
Subject: [PATCH 0636/1541] Revert previous commit and introduce "Transitions"

* Make PlanarSurfaceEdgeSingle a NonInteractionSingle again (for now)
* Introduce new class of domains = "Transitions"
* Copy basic structure of Interaction domain making
  for Transition domain making
* New switchboxes try_default_testtransition and create_default_transition
* New methods try_transition and create_transition
* Basic implementation of structre_id change in case of successful
  transition (waiting for changes necessary to make particles remember
  their structres)
---
 egfrd.py  | 119 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 shells.py |   5 +--
 single.py |  16 +++++---
 3 files changed, 127 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ac49b63d..e8c834e3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1,4 +1,5 @@
 #!/usr/env python
+# -*- coding: utf-8 -*-
 
 from weakref import ref
 import math
@@ -99,11 +100,27 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, PlanarSurfaceEdgeSingletestShell):
-        return PlanarSurfaceEdgeSingle       (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
+### Transitions
+def try_default_testtransition(single, surface, geometrycontainer, domains):
+    if isinstance(single.structure, CuboidalRegion):        
+            raise testShellError('(Transition). Combination of (3D particle, surface) is not supported')
+    elif isinstance(single.structure, PlanarSurface):
+        if isinstance(surface, PlanarSurface):
+            return PlanarSurfaceEdgeSingletestShell(single, surface, geometrycontainer, domains)
+        else:
+            raise testShellError('(Transition). Combination of (2D particle, surface other than plane) is not supported')
+    elif isinstance(single.structure, CylindricalSurface):        
+            raise testShellError('(Transition). Combination of (1D particle, surface) is not supported')
+    else:
+        raise testShellError('(Transition). structure of particle was of invalid type')
+
+def create_default_transition(domain_id, shell_id, testShell, reaction_rules):    
+    if isinstance(testShell, PlanarSurfaceEdgeSingletestShell):
+        return PlanarSurfaceEdgeSingle       (domain_id, shell_id, testShell, reaction_rules)
+    
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
     if single1.structure == single2.structure:
@@ -489,7 +506,6 @@ def create_interaction(self, testShell):
         surfacetype_id = testShell.surface.sid
         interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
 
-
         # 2. Create and register the interaction domain.
         # The type of the interaction that will be created 
         # depends on the surface (planar or cylindrical) the particle is 
@@ -511,6 +527,48 @@ def create_interaction(self, testShell):
 
         return interaction
 
+
+    def create_transition(self, testShell):
+    # Create a new transition domain from a testShell.
+    # Currently only plane-plane transitions are supported.
+    # We assume here that the testShell was successfully created.
+
+        assert isinstance(testShell, testSingle)  # TODO Possibly introduce masterclass testTransitionSingle
+
+        # 1. generate identifiers for the domain and shell. event_id is generated by
+        # the scheduler
+        domain_id = self.domain_id_generator()
+        shell_id = self.shell_id_generator()
+
+        # get unimolecular reaction rules
+        species_id = testShell.pid_particle_pair[1].sid    
+        reaction_rules = self.network_rules.query_reaction_rule(species_id)
+        # TODO !!! care for structure change once particles can remember them !!!
+
+        # OLD STUFF, PROB. NOT NEEDED                
+        #surfacetype_id = testShell.surface.sid
+        #interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
+
+        # 2. Create and register the interaction domain.
+        # The type of the interaction that will be created 
+        # depends on the surface (planar or cylindrical) the particle is 
+        # trying to associate with. Either PlanarSurfaceInteraction or 
+        # CylindricalSurfaceInteraction.
+        transition = create_default_transition(domain_id, shell_id, testShell, reaction_rules)
+
+        assert isinstance(transition, Single)
+        transition.initialize(self.t)
+        self.domains[domain_id] = transition
+
+        # 3. update the shell containers 
+        self.geometrycontainer.move_shell(transition.shell_id_shell_pair)
+        # TODO What precisely happens here?
+
+        transition.world = self.world
+
+        return transition
+
+
     def create_pair(self, testShell):
     # Create a new pair domain from a testShell.
     # The pair can be any pair (Simple or Mixed). The creation of the testShell was
@@ -1367,10 +1425,14 @@ def make_new_domain(self, single):
             if isinstance(obj, NonInteractionSingle):
                 # try making a Pair (can be Mixed Pair or Normal Pair)
                 domain = self.try_pair (single, obj)
+                # TODO: Include formation of "PlanarSurfaceEdgePair"
 
             elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
+                # if this fails try a Transition between two surfaces
+                if not domain:
+                    domain = self.try_transition (single, obj)
 
 
         if not domain:
@@ -1956,8 +2018,6 @@ def break_up_multi(self, multi, ignore):
         return zero_singles_fin, ignore
 
 
-
-
     def try_interaction(self, single, surface):
     # Try to form an interaction between the 'single' particle and the 'surface'. The interaction can be a:
     # -CylindricalSurfaceInteraction
@@ -2007,6 +2067,55 @@ def try_interaction(self, single, surface):
             return None
 
 
+    def try_transition(self, single, surface):
+    # Try to form a transition between the 'single' particle on a surface and another 'surface'.
+    # This is called after an interaction trial has failed.
+    # Currently only transitions between two planar surfaces are supported.
+
+        if __debug__:
+           log.debug('trying to form Transition(%s, %s)' % (single.pid_particle_pair[1], surface))
+
+
+        ### 1. Attempt to make a testShell. If it fails it will throw an exception.
+        try:
+            testShell = try_default_testtransition(single, surface, self.geometrycontainer, self.domains)
+        except testShellError as e:
+            testShell = None
+            if __debug__:
+                log.debug('%s not formed %s' % \
+                          ('Transition(%s, %s)' % (single.pid_particle_pair[0], surface),
+                          str(e) ))
+
+
+        ### 2. The testShell was made succesfully. Now make the complete domain
+        if testShell:
+            # make the domain
+            transition = self.create_transition(testShell)
+            if __debug__:
+                log.info('        *Created: %s' % (interaction))
+
+            # get the next event time
+            transition.dt, transition.event_type, = transition.determine_next_event()
+            if __debug__:
+                assert transition.dt >= 0.0
+                log.info('dt=%s' % (FORMAT_DOUBLE % transition.dt)) 
+
+            self.last_time = self.t
+
+            self.remove_domain(single)
+            # the event associated with the single will be removed by the scheduler.
+
+            # add to scheduler
+            self.add_domain_event(transition)
+            # check everything is ok
+            if __debug__:
+                assert self.check_domain(transition)
+
+            return transition
+        else:
+            return None
+
+
     def try_pair(self, single1, single2):
     # Try to make a pair domain out of the two singles. A pair domain can be a:
     # -SimplePair (both particles live on the same structure)
diff --git a/shells.py b/shells.py
index a2b003fc..98bc2d70 100755
--- a/shells.py
+++ b/shells.py
@@ -1113,12 +1113,11 @@ def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right, z_left
 
 #####
-class PlanarSurfaceEdgeSingletestShell(SphericaltestShell, testInteractionSingle):
+class PlanarSurfaceEdgeSingletestShell(SphericaltestShell, testNonInteractionSingle):
 
     def __init__(self, single, surface, geometrycontainer, domains):
         SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testInteractionSingle.__init__(self, single, single.structure, surface)
-        self.origin_surface = structure
+        self.origin_surface = single.structure
         self.target_surface = surface
         assert isinstance(origin_surface, _gfrd.Surface)
         assert isinstance(target_surface, _gfrd.Surface)
diff --git a/single.py b/single.py
index 4700b533..5b6a525f 100644
--- a/single.py
+++ b/single.py
@@ -381,7 +381,7 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
-class PlanarSurfaceEdgeSingle(InteractionSingle, hasSphericalShell, Others):
+class PlanarSurfaceEdgeSingle(Single, hasSphericalShell, Others):
     """1 Particle inside a (spherical) shell at the edge of two planar surfaces
 
         * Particle coordinates on surface: x, y.
@@ -390,14 +390,14 @@ class PlanarSurfaceEdgeSingle(InteractionSingle, hasSphericalShell, Others):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
-        self.origin_plane = testShell.origin_plane
-        self.target_plane = testShell.target_plane
+        self.origin_plane  = testShell.origin_plane
+        self.target_plane  = testShell.target_plane
         self.origin_center = origin_plane.shape.position
         self.target_center = target_plane.shape.position
         self.origin_half_extent = origin_plane.shape.half_extent
@@ -483,7 +483,7 @@ def process_new_position_vector(self, oldpos, displacement):
             d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
             # Construct the new position using the predefined unit vectors of the target plane
             newpos = target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            # TODO CHANGE SPECIES TO THE ONE THAT LIVES ON THE TARGET PLANE FOR THIS CASE
+            change_particle_structure(self.pid_particle_pair, target_plane)
 
         return newpos
 
@@ -529,6 +529,12 @@ def get_edge_point(self):
         ep = self.start_position + (self.target_distance * self.origin_unit_perp)
         return ep
 
+    def change_particle_surface(pid_particle_pair, new_structure):
+        #pid_particle_pair[1].structure_id = new_structure.id
+        # TODO !!! This will only work once particles can remember their structure !!!
+        # for now...
+        pass
+
 
     def __str__(self):
         return 'PlanarSurfaceEdge' + Single.__str__(self)

From e3c0a6de1d73bb81e92fc60761f7340d1fbef196 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 14 Feb 2012 19:06:31 +0100
Subject: [PATCH 0637/1541] more comments and some outlining of code for
 clarity

---
 Cylinder.hpp               |   9 ++-
 Model.hpp                  |  36 +++++-----
 Particle.hpp               |  22 ++++--
 ParticleContainer.hpp      |   2 +
 ParticleContainerBase.hpp  |  16 ++++-
 ParticleModel.hpp          |  10 ++-
 SpeciesInfo.hpp            |  59 ++++++++++------
 SpeciesType.hpp            |   9 +--
 SpeciesTypeID.hpp          |  11 ++-
 StructureType.hpp          |  13 ++--
 World.hpp                  | 140 +++++++++++++++++++++++--------------
 binding/binding_common.hpp |  38 +++++-----
 12 files changed, 236 insertions(+), 129 deletions(-)

diff --git a/Cylinder.hpp b/Cylinder.hpp
index 434ed4fc..bed133a4 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -16,6 +16,7 @@ class Cylinder
     typedef T_ length_type;
 
 public:
+    // constructors
     Cylinder()
         : position_(), radius_(0), unit_z_(), half_length_(0) {}
 
@@ -24,6 +25,7 @@ class Cylinder
         : position_(position), radius_(radius), unit_z_(unit_z),
           half_length_(half_length) {}
 
+    
     bool operator==(const Cylinder& rhs) const
     {
         return position_ == rhs.position() && radius_ == rhs.radius() && unit_z_ == rhs.unit_z() && half_length_ == rhs.half_length();
@@ -82,13 +84,16 @@ class Cylinder
         return strm.str();
     }
 
+/////// Member variables
 private:
-    position_type position_; // centre.
+    position_type position_;    // centre.
     length_type radius_;
-    position_type unit_z_; // Z-unit_z. should be normalized.
+    position_type unit_z_;      // Z-unit_z. should be normalized.
     length_type half_length_;
 };
 
+
+//////// Inline functions
 template<typename Tstrm_, typename T_>
 inline std::basic_ostream<Tstrm_>& operator<<(std::basic_ostream<Tstrm_>& strm,
         const Cylinder<T_>& v)
diff --git a/Model.hpp b/Model.hpp
index 70909114..9c96a61a 100644
--- a/Model.hpp
+++ b/Model.hpp
@@ -19,23 +19,23 @@ class NetworkRules;
 class Model: private boost::noncopyable
 {
 public:
-    typedef SpeciesType species_type_type;
-    typedef species_type_type::identifier_type species_id_type;
+    typedef SpeciesType                         species_type_type;
+    typedef species_type_type::identifier_type  species_id_type;
 
 private:
-    typedef SerialIDGenerator<species_id_type> species_type_id_generator_type;
-    typedef std::map<species_id_type, boost::shared_ptr<species_type_type> > species_type_map_type;
-    typedef select_second<species_type_map_type::value_type> species_second_selector_type;
+    typedef SerialIDGenerator<species_id_type>                                  species_type_id_generator_type;
+    typedef std::map<species_id_type, boost::shared_ptr<species_type_type> >    species_type_map_type;
+    typedef select_second<species_type_map_type::value_type>                    species_second_selector_type;
 
-    typedef get_mapper_mf<std::string, std::string>::type string_map_type;
+    typedef get_mapper_mf<std::string, std::string>::type                       string_map_type;
 
 public:
     typedef boost::transform_iterator<species_second_selector_type,
-            species_type_map_type::const_iterator> species_type_iterator;
-    typedef boost::iterator_range<species_type_iterator> species_type_range;
-    typedef NetworkRules network_rules_type;
-    typedef string_map_type::const_iterator string_map_iterator;
-    typedef boost::iterator_range<string_map_iterator> attributes_range;
+            species_type_map_type::const_iterator>                  species_type_iterator;
+    typedef boost::iterator_range<species_type_iterator>            species_type_range;
+    typedef NetworkRules                                            network_rules_type;
+    typedef string_map_type::const_iterator                         string_map_iterator;
+    typedef boost::iterator_range<string_map_iterator>              attributes_range;
 
 public:
     // The model class is more or less an implementation of the network rules
@@ -49,32 +49,32 @@ class Model: private boost::noncopyable
         return *network_rules_;
     }
 
+    // Add a species to the model
     void add_species_type(boost::shared_ptr<species_type_type> const& species);
-    // Adds a species to the model
 
+    // Get a species by the species 'id'
     boost::shared_ptr<species_type_type> get_species_type_by_id(species_id_type const& id) const;
-    // Gets a species by the species 'id'
 
+    // Get all the species in the model
     species_type_range get_species_types() const;
-    // Gets all the species in the model
 
     std::string const& operator[](std::string const& name) const;
 
     std::string& operator[](std::string const& name);
     // Not sure. Get attribute by name?
 
-    attributes_range attributes() const
     // Get all the attributes
+    attributes_range attributes() const
     {
         return attributes_range(attrs_.begin(), attrs_.end());
     }
 
 
 public:
-    species_type_id_generator_type species_type_id_generator_;  // The id generator which makes sure that all species have a unique id
-    species_type_map_type species_type_map_;                    // ??
+    species_type_id_generator_type  species_type_id_generator_; // The id generator which makes sure that all species have a unique id
+    species_type_map_type           species_type_map_;          // ??
     boost::scoped_ptr<NetworkRules> network_rules_;             // The network rules in the model
-    string_map_type attrs_;                                     // All the attributes
+    string_map_type                 attrs_;                     // All the attributes
 };
 
 
diff --git a/Particle.hpp b/Particle.hpp
index 1ab25273..dba3751c 100644
--- a/Particle.hpp
+++ b/Particle.hpp
@@ -16,13 +16,16 @@
 template<typename T_, typename Td_, typename Tsid_>
 struct Particle
 {
-    typedef Sphere<T_> shape_type;
-    typedef Td_ D_type;
-    typedef Td_ v_type;	// the drift v has the same type as diffusion constant D for now, may be generalized at a later stage
-    typedef Tsid_ species_id_type;
-    typedef typename shape_type::position_type position_type;
-    typedef typename shape_type::length_type length_type;
-
+    // defining shorthands for used types
+    typedef Sphere<T_>                          shape_type;
+    typedef Td_                                 D_type;
+    // the drift v has the same type as diffusion constant D for now, may be generalized at a later stage
+    typedef Td_                                 v_type;
+    typedef Tsid_                               species_id_type;
+    typedef typename shape_type::position_type  position_type;
+    typedef typename shape_type::length_type    length_type;
+
+    // constructors
     Particle(): shape_(), species_id_(), D_(0.), v_(0.) {}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
@@ -111,6 +114,7 @@ struct Particle
         return strm.str();
     }
 
+////// Member variables
 private:
     shape_type shape_;
     species_id_type species_id_;
@@ -118,6 +122,8 @@ struct Particle
     v_type v_;
 };
 
+
+///// Inline functions
 template<typename Tstrm_, typename Ttraits_, typename T_, typename Td_, typename Tsid_>
 inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm, const Particle<T_, Td_, Tsid_>& p)
 {
@@ -125,6 +131,8 @@ inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm
     return strm;
 }
 
+
+
 #if defined(HAVE_TR1_FUNCTIONAL)
 namespace std { namespace tr1 {
 #elif defined(HAVE_STD_HASH)
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 650d4fe7..352dc894 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -13,6 +13,8 @@ class Transaction;
 template<typename Ttraits_>
 class ParticleContainer
 {
+// This class just defines the properties that the ParticleContainer should have.
+// The ParticleContainerBase implements some of them.
 public:
     typedef Ttraits_ traits_type;
     typedef typename traits_type::particle_type particle_type;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 04f998aa..bc8f494a 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -77,10 +77,13 @@ template<typename Tderived_, typename Ttraits_ = typename Tderived_::traits_type
 class ParticleContainerBase
     : public ParticleContainer<Ttraits_>
 {
+// This inherits from the ParticleContainer class which is just an abstract data type.
+// Here most of the methods of the ParticleContainer are actually implemented.
 public:
     typedef ParticleContainerUtils<Ttraits_> utils;
     typedef ParticleContainer<Ttraits_> base_type;
     typedef Ttraits_ traits_type;
+    // define some shorthands for all the types from the traits that we use.
     typedef typename traits_type::length_type length_type;
     typedef typename traits_type::species_type species_type;
     typedef typename traits_type::position_type position_type;
@@ -103,9 +106,11 @@ class ParticleContainerBase
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
 protected:
+// Implementation of the methods.
 public:
     ParticleContainerBase(length_type world_size, size_type size)
         : pmat_(world_size, size) {}
+    // constructor
 
     virtual size_type num_particles() const
     {
@@ -159,6 +164,7 @@ class ParticleContainerBase
         return traits_type::cyclic_transpose(p0, p1, world_size());
     }
 
+    // THIS SEEMS STRANGE TO PUT THIS HERE. 
     template<typename T1_>
     T1_ calculate_pair_CoM(
         T1_ const& p1, T1_ const& p2, 
@@ -237,7 +243,7 @@ class ParticleContainerBase
         return pmat_.end() != pmat_.find(id);
     }
 
-    virtual transaction_type* create_transaction();
+    virtual transaction_type* create_transaction();     // The implementation is below as an inline function?
 
     virtual particle_id_pair_generator* get_particles() const
     {
@@ -259,10 +265,16 @@ class ParticleContainerBase
         return pmat_.erase(id);
     }
 
+
+
+///////// Member variables
 protected:
-    particle_matrix_type pmat_;
+    particle_matrix_type pmat_;         // just the structure containing the particles.
 };
 
+
+
+//////// Inline methods are defined separately
 template<typename Tderived_, typename Ttraits_>
 inline Transaction<Ttraits_>*
 ParticleContainerBase<Tderived_, Ttraits_>::create_transaction()
diff --git a/ParticleModel.hpp b/ParticleModel.hpp
index 03421079..c2a26b05 100644
--- a/ParticleModel.hpp
+++ b/ParticleModel.hpp
@@ -6,11 +6,14 @@
 #include "StructureType.hpp"
 
 class ParticleModel: public Model
+// The ParticleModel class add spatial properties (e.g. particles) to the model. The model by itself could
+// namely also just model well mixed systems.
 {
 public:
-    typedef Model base_type;
-    typedef StructureType structure_type_type;
-    typedef structure_type_type::identifier_type structure_id_type;
+    // defining shorthands for the used types
+    typedef Model                                   base_type;
+    typedef StructureType                           structure_type_type;
+    typedef structure_type_type::identifier_type    structure_id_type;
 
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type_type> > structure_type_map_type;
 
@@ -32,6 +35,7 @@ class ParticleModel: public Model
 
     structure_type_range get_structure_types() const;
 
+/////// Member variables
 public:
     structure_type_map_type structure_type_map_;
 };
diff --git a/SpeciesInfo.hpp b/SpeciesInfo.hpp
index 167e7f35..208bc742 100644
--- a/SpeciesInfo.hpp
+++ b/SpeciesInfo.hpp
@@ -8,18 +8,32 @@
 
 template<typename Tid_, typename TD_, typename Tlen_, typename Tstructure_id_>
 struct SpeciesInfo
+// Unclear if SpeciesInfo replaces the Species when using a World or not
+// (Species itself holds very little information, SpeciesInfo hold info that is relevant in a spatial system)
 {
-    typedef Tid_ identifier_type;
-    typedef TD_ D_type;
-    typedef TD_ v_type;
-    typedef Tlen_ length_type;
-    typedef Tstructure_id_ structure_id_type;
+    // defining shorthands for used types
+    typedef Tid_            identifier_type;        // This is the SpeciesTypeID
+    typedef TD_             D_type;
+    typedef TD_             v_type;
+    typedef Tlen_           length_type;
+    typedef Tstructure_id_  structure_id_type;      // TODO should be structure_type_id_type
+
+    // constructors
+    SpeciesInfo() {}
+
+    SpeciesInfo(identifier_type const& id, D_type const& D = 0., 
+                length_type const& r = 0., structure_id_type const& s = "", v_type const& v = 0.) 
+        : id_(id), diffusion_coef_(D), drift_velocity_(v), radius_(r), structure_id_(s) {}
+
 
+
+    // Get the id
     identifier_type const& id() const
     {
         return id_;
     }
 
+    // Get the particle radius
     length_type const& radius() const
     {
         return radius_;
@@ -30,6 +44,7 @@ struct SpeciesInfo
         return radius_;
     }
 
+    // Get the id of the structure type it lives on
     structure_id_type const& structure_id() const
     {
         return structure_id_;
@@ -40,6 +55,7 @@ struct SpeciesInfo
         return structure_id_;
     }
 
+    // Get the diffusion constant
     D_type const& D() const
     {
         return diffusion_coef_;
@@ -49,7 +65,8 @@ struct SpeciesInfo
     {
         return diffusion_coef_;
     }
-    
+
+    // Get the drift
     v_type const& v() const
     {
         return drift_velocity_;
@@ -60,10 +77,14 @@ struct SpeciesInfo
         return drift_velocity_;
     }
 
+    // Check equality/inequality
     bool operator==(SpeciesInfo const& rhs) const
     {
-        return id_ == rhs.id() && diffusion_coef_ == rhs.D() && drift_velocity_ == rhs.v() &&
-                radius_ == rhs.radius() && structure_id_ == rhs.structure_id();
+        return id_ == rhs.id() && 
+               diffusion_coef_ == rhs.D() &&
+               drift_velocity_ == rhs.v() &&
+               radius_ == rhs.radius() &&
+               structure_id_ == rhs.structure_id();
     }
 
     bool operator!=(SpeciesInfo const& rhs) const
@@ -71,24 +92,22 @@ struct SpeciesInfo
         return !operator==(rhs);
     }
 
-    SpeciesInfo() {}
-
-    SpeciesInfo(identifier_type const& id, D_type const& D = 0., 
-                length_type const& r = 0., structure_id_type const& s = "", v_type const& v = 0.) 
-        : id_(id), diffusion_coef_(D), drift_velocity_(v), radius_(r), structure_id_(s) {}
-  
-
+/////// Member variables
 private:
-    identifier_type id_;
-    D_type diffusion_coef_;
-    v_type drift_velocity_;
-    length_type radius_;
-    structure_id_type structure_id_;
+    identifier_type     id_;
+    D_type              diffusion_coef_;
+    v_type              drift_velocity_;
+    length_type         radius_;
+    structure_id_type   structure_id_;      // The structure type that the particle lives on
 };
 
+
+//////// Inline functions
 template<typename Tchar_, typename Ttraits_, typename Tid_, typename TD_, typename Tlen_, typename Tstructure_id_>
 inline std::basic_ostream<Tchar_, Ttraits_>&
 operator<<(std::basic_ostream<Tchar_, Ttraits_>& strm, const SpeciesInfo<Tid_, TD_, Tlen_, Tstructure_id_>& s)
+// Allows for printing of the object
+// -> provides a stream of 'attributename : attribute_value' pairs.
 {
     strm << "SpeciesInfo(id=" << s.id() << ", D=" << s.D() << ", v=" << s.v() << ", radius=" << s.radius() << ", surface=" << s.structure_id() << ")";
     return strm;
diff --git a/SpeciesType.hpp b/SpeciesType.hpp
index c17c87f8..a3208d6c 100644
--- a/SpeciesType.hpp
+++ b/SpeciesType.hpp
@@ -22,9 +22,9 @@ class SpeciesType
     typedef get_mapper_mf<std::string, std::string>::type string_map_type;
 
 public:
-    typedef SpeciesTypeID identifier_type;                          // The identifier
-    typedef string_map_type::const_iterator string_map_iterator;
-    typedef boost::iterator_range<string_map_iterator> attributes_range;
+    typedef SpeciesTypeID                               identifier_type;    // The identifier. Note that we also use this for structures.
+    typedef string_map_type::const_iterator             string_map_iterator;
+    typedef boost::iterator_range<string_map_iterator>  attributes_range;
 
 public:
     identifier_type const& id() const;
@@ -54,7 +54,7 @@ class SpeciesType
     }
 
 
-////////// Member variables
+//////// Member variables
 private:
     Model* model_;              // The model to which the species type is bound
     identifier_type id_;        // The id of the species type
@@ -62,6 +62,7 @@ class SpeciesType
 };
 
 
+//////// Inline functions
 template<typename Tchar_, typename Ttraits_>
 inline std::basic_ostream<Tchar_, Ttraits_>&
 operator<<(std::basic_ostream<Tchar_, Ttraits_>& out, const SpeciesType& v)
diff --git a/SpeciesTypeID.hpp b/SpeciesTypeID.hpp
index 062a4fe5..c7722424 100644
--- a/SpeciesTypeID.hpp
+++ b/SpeciesTypeID.hpp
@@ -16,14 +16,20 @@
 #include "Identifier.hpp"
 
 struct SpeciesTypeID: public Identifier<SpeciesTypeID, unsigned long long, int>
-// The SpeciesTypeID is an indentifier class for species types (species?) but is also used for structure(type)s
+// The SpeciesTypeID is an indentifier structure (same as class) for species types (species) but is also used for structure types
+// NOTE The superclass is parameterized with the SpeciesTypeID class itself.
 {
+    // shorthand name for the super class
     typedef Identifier<SpeciesTypeID, unsigned long long, int> base_type;
 
+    // The constructor
     SpeciesTypeID(value_type const& value = value_type(0, 0))
         : base_type(value) {}
 };
 
+
+
+
 #if defined(HAVE_TR1_FUNCTIONAL)
 namespace std { namespace tr1 {
 #elif defined(HAVE_STD_HASH)
@@ -49,6 +55,9 @@ struct hash<SpeciesTypeID>
 } // namespace boost
 #endif
 
+
+
+///////// Inline functions
 template<typename Tstrm_, typename Ttraits_>
 inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm,
         const SpeciesTypeID& v)
diff --git a/StructureType.hpp b/StructureType.hpp
index ad81d673..c6097183 100644
--- a/StructureType.hpp
+++ b/StructureType.hpp
@@ -22,9 +22,9 @@ class StructureType
 
 public:
     // typedef std::string identifier_type;
-    typedef SpeciesTypeID identifier_type;
-    typedef string_map_type::const_iterator string_map_iterator;
-    typedef boost::iterator_range<string_map_iterator> attributes_range;
+    typedef SpeciesTypeID                               identifier_type;    // NOTE: we use the same identifier as for the species!
+    typedef string_map_type::const_iterator             string_map_iterator;
+    typedef boost::iterator_range<string_map_iterator>  attributes_range;
 
 public:
     identifier_type const& id() const;
@@ -49,12 +49,15 @@ class StructureType
         id_ = id;
     }
 
+
+//////// Member variables
 private:
-    ParticleModel* model_;
-    identifier_type id_;
+    ParticleModel* model_;          // to what model is it associated
+    identifier_type id_;            // identifier Note that these are only defined if the object is bound to a model.
     string_map_type attrs_;
 };
 
+/////// Inline functions
 template<typename Tchar_, typename Ttraits_>
 inline std::basic_ostream<Tchar_, Ttraits_>&
 operator<<(std::basic_ostream<Tchar_, Ttraits_>& out, const StructureType& v)
diff --git a/World.hpp b/World.hpp
index d4118580..d0f52975 100644
--- a/World.hpp
+++ b/World.hpp
@@ -32,29 +32,39 @@
 
 template<typename Tderived_, typename Tlen_, typename TD_>
 struct WorldTraitsBase
+// Just defines some basic properties of a world. Basically just types and one constant.
+// Tderived_ is the class/structure that inherits from this struct (subclass) -> WorldTraits and CyclicWorldTraits
 {
-    typedef std::size_t size_type;
-    typedef Tlen_ length_type;
-    typedef TD_ D_type;
-    typedef TD_ v_type;
-    typedef ParticleID particle_id_type;                                    // identifier type for particles
-    typedef SerialIDGenerator<particle_id_type> particle_id_generator;
-    typedef SpeciesTypeID species_id_type;                                  // identifier type for species and (structure types)
-    typedef Particle<length_type, D_type, species_id_type> particle_type;   // type for particles
-    typedef std::string structure_id_type;                                  // identifier type for structures
-    // typedef SpeciesTypeID structure_id_type;
-    typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type> species_type;
-    typedef Vector3<length_type> point_type;
-    typedef typename particle_type::shape_type::position_type position_type;
-    typedef GSLRandomNumberGenerator rng_type;
-    typedef Structure<Tderived_> structure_type;
-
-    static const Real TOLERANCE = 1e-7;
+    typedef std::size_t                                     size_type;
+    typedef Tlen_                                           length_type;
+    typedef TD_                                             D_type;
+    typedef TD_                                             v_type;
+    typedef ParticleID                                      particle_id_type;   // identifier type for particles
+    typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
+    typedef SpeciesTypeID                                   species_id_type;    // identifier type for species and (structure types)
+    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
+    typedef std::string                                     structure_id_type;  // identifier type for structures
+    // typedef SpeciesTypeID                                   structure_id_type;
+
+    typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type>    species_type;  // information associated with the species
+    typedef Vector3<length_type>                                                    point_type;
+    typedef typename particle_type::shape_type::position_type                       position_type;
+    typedef GSLRandomNumberGenerator                                                rng_type;
+    typedef Structure<Tderived_>                                                    structure_type; // The structure_type is parameterized with the subclass??
+
+    static const Real TOLERANCE = 1e-7;         // tolerance of what?
 };
 
+
+
 template<typename Tlen_, typename TD_>
 struct WorldTraits: public WorldTraitsBase<WorldTraits<Tlen_, TD_>, Tlen_, TD_>
 {
+// This defines a structure (like a class) with some rudimentairy properties of the world
+// It inherits from WorldTraitsBase which is parameterized with the fully defined WorldTraits class/structure.
+//
+// Implements mostly boundaryconditions related stuff (distance, apply_boundary, cyclic_transpose)
+
 public:
     // This is the normal world (without periodic/cyclic boundary conditions)
     typedef WorldTraitsBase<WorldTraits<Tlen_, TD_>, Tlen_, TD_> base_type;
@@ -70,6 +80,7 @@ struct WorldTraits: public WorldTraitsBase<WorldTraits<Tlen_, TD_>, Tlen_, TD_>
 
     template<typename Tval_>
     static Tval_ cyclic_transpose(Tval_ const& p0, Tval_ const& p1, length_type const& world_size)
+    // ditto
     {
         return p0;
     }
@@ -109,15 +120,17 @@ struct WorldTraits: public WorldTraitsBase<WorldTraits<Tlen_, TD_>, Tlen_, TD_>
 template<typename Tlen_, typename TD_>
 struct CyclicWorldTraits: public WorldTraitsBase<CyclicWorldTraits<Tlen_, TD_>, Tlen_, TD_>
 {
+// Use these world traits for a world WITH periodic/cyclic boundary conditions
+
 public:
-    // This is the world WITH periodic/cyclic boundary conditions
+    // Specify the types being used.
     typedef WorldTraitsBase<CyclicWorldTraits<Tlen_, TD_>, Tlen_, TD_> base_type;
-    typedef typename base_type::length_type length_type;
-    typedef typename base_type::position_type position_type;
+    typedef typename base_type::length_type                            length_type;
+    typedef typename base_type::position_type                          position_type;
 
     template<typename Tval_>
     static Tval_ apply_boundary(Tval_ const& v, length_type const& world_size)
-    // This applied the periodic boundary conditions
+    // This applied the periodic boundary conditions, unclear what kind of type 'Tval_' is.
     {
         return ::apply_boundary(v, world_size);
     }
@@ -125,12 +138,13 @@ struct CyclicWorldTraits: public WorldTraitsBase<CyclicWorldTraits<Tlen_, TD_>,
     static length_type cyclic_transpose(length_type const& p0, length_type const& p1, length_type const& world_size)
     // selects the copy of p0 (over the periodic boundaries) such that the distance between p0 and p1 is minimized over
     // over the periodic boundary conditions.
+    // This is the length_type version
     {
         return ::cyclic_transpose(p0, p1, world_size);
     }
 
     static position_type cyclic_transpose(position_type const& p0, position_type const& p1, length_type const& world_size)
-    // Not sure what the difference is with above method
+    // This is the position_type version
     {
         return ::cyclic_transpose(p0, p1, world_size);
     }
@@ -170,45 +184,55 @@ struct CyclicWorldTraits: public WorldTraitsBase<CyclicWorldTraits<Tlen_, TD_>,
 template<typename Ttraits_>
 class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 {
+// The world 'is a' ParticleContainerBase which is parameterize with the same World class
+// (I think the concrete implementation of it, not just the template)
+// The world is a template that is parametrized with the traits (these define a number of datatypes used in the definition of
+// the world?)
 public:
-    typedef Ttraits_ traits_type;
-    typedef ParticleContainerBase<World> base_type;
-    typedef ParticleContainer<traits_type> particle_container_type;
-    typedef typename traits_type::length_type length_type;
-    typedef typename traits_type::species_type species_type;
-    typedef typename traits_type::position_type position_type;
-    typedef typename traits_type::particle_type particle_type;
-    typedef typename traits_type::particle_id_type particle_id_type;
-    typedef typename traits_type::particle_id_generator particle_id_generator;
-    typedef typename traits_type::species_id_type species_id_type;
+    typedef Ttraits_                        traits_type;                // Needs to be of WorldTraits type???
+    typedef ParticleContainerBase<World>    base_type;                  // the class from which is inherited -> base class
+    typedef ParticleContainer<traits_type>  particle_container_type;    // ParticleContainer is again the superclass of ParticleContainerBase
+
+    // define some short hand names for all the properties (traits) of the world
+    typedef typename traits_type::length_type               length_type;
+    typedef typename traits_type::species_type              species_type;
+    typedef typename traits_type::position_type             position_type;
+    typedef typename traits_type::particle_type             particle_type;
+    typedef typename traits_type::particle_id_type          particle_id_type;
+    typedef typename traits_type::particle_id_generator     particle_id_generator;
+    typedef typename traits_type::species_id_type           species_id_type;        // Note that this is also the structure_type_id_type
     typedef typename traits_type::particle_type::shape_type particle_shape_type;
-    typedef typename traits_type::size_type size_type;
-    typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type structure_type;
-    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<position_type, length_type> projected_type;
-    typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
+    typedef typename traits_type::size_type                 size_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_type            structure_type;
+
+    //
+    typedef std::pair<const particle_id_type, particle_type>                    particle_id_pair;      // defines the pid_particle_pair tuple
+    typedef std::pair<position_type, length_type>                               projected_type;
+    typedef typename particle_container_type::structure_id_and_distance_pair    structure_id_and_distance_pair;
 
 protected:
-    typedef std::map<species_id_type, species_type> species_map;
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
-    typedef std::set<particle_id_type> particle_id_set;
-    typedef std::map<species_id_type, particle_id_set> per_species_particle_id_set;
-    typedef select_second<typename species_map::value_type> species_second_selector_type;
-    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+    typedef std::map<species_id_type, species_type>                         species_map;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
+    typedef std::set<particle_id_type>                                      particle_id_set;
+    typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
+    typedef select_second<typename species_map::value_type>                 species_second_selector_type;   // not sure what this does.
+    typedef select_second<typename structure_map::value_type>               surface_second_selector_type;
 
 public:
     typedef boost::transform_iterator<species_second_selector_type,
-            typename species_map::const_iterator> species_iterator;
+            typename species_map::const_iterator>                   species_iterator;
     typedef boost::transform_iterator<surface_second_selector_type,
-            typename structure_map::const_iterator> surface_iterator;
-    typedef sized_iterator_range<species_iterator> species_range;
-    typedef sized_iterator_range<surface_iterator> structures_range;
+            typename structure_map::const_iterator>                 surface_iterator;
+    typedef sized_iterator_range<species_iterator>                  species_range;
+    typedef sized_iterator_range<surface_iterator>                  structures_range;
 
 public:
+    // The constructor
     World(length_type world_size = 1., size_type size = 1)
         : base_type(world_size, size) {}
 
+    // To add new particles
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
     {
@@ -220,6 +244,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return retval;
     }
 
+    // To update particles
     virtual bool update_particle(particle_id_pair const& pi_pair)
     {
         typename base_type::particle_matrix_type::iterator i(
@@ -239,8 +264,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return true;
     }
 
+    // Remove the particle by id 'id' if present in the world.
     virtual bool remove_particle(particle_id_type const& id)
-    // Removed the particle by id 'id' if present in the world.
     {
         bool found(false);
         particle_id_pair pp(get_particle(id, found));
@@ -253,14 +278,15 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return true;
     }
 
-    void add_species(species_type const& species)
     // Adds a species to the world.
-    // Wouldn't it make more sence to make this method part of the model class instead of the world class?
+    void add_species(species_type const& species)
+        // Wouldn't it make more sence to make this method part of the model class instead of the world class?
     {
         species_map_[species.id()] = species;
         particle_pool_[species.id()] = particle_id_set();
     }
 
+    // Get the species in the world by id
     virtual species_type const& get_species(species_id_type const& id) const
     {
         typename species_map::const_iterator i(species_map_.find(id));
@@ -271,6 +297,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return (*i).second;
     }
 
+    // Get all the species
     species_range get_species() const
     {
         return species_range(
@@ -279,11 +306,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             species_map_.size());
     }
 
+    // Add a structure 
     bool add_structure(boost::shared_ptr<structure_type> surface)
     {
         return structure_map_.insert(std::make_pair(surface->id(), surface)).second;
     }
 
+    // Get a structure by id
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
@@ -294,6 +323,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return (*i).second;
     }
 
+    // Get all the structures
     virtual structures_range get_structures() const
     {
         return structures_range(
@@ -301,7 +331,14 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             surface_iterator(structure_map_.end(), surface_second_selector_type()),
             structure_map_.size());
     }
+
+    // TODO
+    // Add structureType
+    // update structure
+    // remove structure
+    // Get structures by structure type
     
+    // FIXME This is probably not very usefull any more.
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {       
         length_type const world_size( base_type::world_size() );
@@ -326,6 +363,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return structure_id_and_distance_pair( ret_id , ret_dist );
     }
    
+    // Get all the particle ids by species
     particle_id_set get_particle_ids(species_id_type const& sid) const
     {
         typename per_species_particle_id_set::const_iterator i(
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index e52da3a3..dcb414e6 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -45,7 +45,7 @@ typedef ::not_found NotFound;
 typedef ::already_exists AlreadyExists;
 typedef ::illegal_state IllegalState;
 typedef ::GSLRandomNumberGenerator GSLRandomNumberGenerator;
-typedef ::CyclicWorldTraits<Real, Real> WorldTraits;
+typedef ::CyclicWorldTraits<Real, Real> WorldTraits;            // parameterize the World traits here -> determines many types!!
 typedef WorldTraits::particle_type Particle;
 typedef WorldTraits::structure_id_type StructureID;
 typedef WorldTraits::species_id_type SpeciesID;
@@ -54,11 +54,13 @@ typedef WorldTraits::structure_type Structure;
 typedef StructureType::identifier_type StructureTypeID;
 typedef WorldTraits::length_type Length;
 typedef WorldTraits::position_type Position;
-typedef ::World<WorldTraits> World;
-typedef ::Model Model;
-typedef ::ParticleModel ParticleModel;
-typedef ::NetworkRules NetworkRules;
-typedef NetworkRules::reaction_rule_generator ReactionRuleGenerator;
+typedef ::World<WorldTraits> World;                             // plug in the WorldTraits type to get a fully specified World type.
+
+typedef ::Model                                 Model;
+typedef ::ParticleModel                         ParticleModel;
+typedef ::NetworkRules                          NetworkRules;
+typedef NetworkRules::reaction_rule_generator   ReactionRuleGenerator;
+
 typedef World::transaction_type Transaction;
 typedef World::base_type::base_type ParticleContainer; 
 typedef ::TransactionImpl<ParticleContainer> TransactionImpl;
@@ -67,10 +69,12 @@ typedef ::ParticleSimulator<EGFRDSimulatorTraits> ParticleSimulator;
 typedef ::BDSimulator<EGFRDSimulatorTraits> BDSimulator;
 typedef ::EGFRDSimulator<EGFRDSimulatorTraits> EGFRDSimulator;
 typedef ::MultiParticleContainer<EGFRDSimulatorTraits> MultiParticleContainer;
-typedef EGFRDSimulator::box_type Box;
-typedef EGFRDSimulator::sphere_type Sphere;
-typedef EGFRDSimulator::cylinder_type Cylinder;
-typedef EGFRDSimulator::plane_type Plane;
+
+typedef EGFRDSimulator::box_type        Box;
+typedef EGFRDSimulator::sphere_type     Sphere;
+typedef EGFRDSimulator::cylinder_type   Cylinder;
+typedef EGFRDSimulator::plane_type      Plane;
+
 typedef ::BDPropagator<EGFRDSimulatorTraits> BDPropagator;
 typedef ::newBDPropagator<EGFRDSimulatorTraits> newBDPropagator;
 typedef EGFRDSimulatorTraits::shell_id_type ShellID;
@@ -92,12 +96,14 @@ typedef ::MatrixSpace<SphericalShell, ShellID> SphericalShellContainer;
 typedef ::MatrixSpace<CylindricalShell, ShellID> CylindricalShellContainer;
 typedef ::StructureUtils<EGFRDSimulator> StructureUtils;
 typedef EGFRDSimulator::particle_simulation_structure_type ParticleSimulationStructure;
-typedef EGFRDSimulator::surface_type Surface;
-typedef EGFRDSimulator::region_type Region;
-typedef EGFRDSimulator::planar_surface_type PlanarSurface;
-typedef EGFRDSimulator::spherical_surface_type SphericalSurface;
-typedef EGFRDSimulator::cylindrical_surface_type CylindricalSurface;
-typedef EGFRDSimulator::cuboidal_region_type CuboidalRegion;
+
+typedef EGFRDSimulator::surface_type                Surface;
+typedef EGFRDSimulator::region_type                 Region;
+typedef EGFRDSimulator::planar_surface_type         PlanarSurface;
+typedef EGFRDSimulator::spherical_surface_type      SphericalSurface;
+typedef EGFRDSimulator::cylindrical_surface_type    CylindricalSurface;
+typedef EGFRDSimulator::cuboidal_region_type        CuboidalRegion;
+
 typedef EGFRDSimulatorTraits::reaction_record_type ReactionRecord;
 typedef EGFRDSimulatorTraits::reaction_recorder_type ReactionRecorder;
 typedef EGFRDSimulatorTraits::volume_clearer_type VolumeClearer;

From 2ddaf6f64012730dae8e7790cc8ef440311fc05c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 15 Feb 2012 14:08:57 +0100
Subject: [PATCH 0638/1541] added comments and TODO on what to change

---
 Model.hpp         |  4 +++-
 Particle.hpp      | 13 ++++++++++---
 ParticleModel.cpp |  8 +++++++-
 ParticleModel.hpp | 11 ++++++++---
 Structure.hpp     | 23 +++++++++++++----------
 StructureType.hpp | 10 +++++++---
 World.hpp         | 10 ++++++----
 gfrdbase.py       |  2 +-
 8 files changed, 55 insertions(+), 26 deletions(-)

diff --git a/Model.hpp b/Model.hpp
index 9c96a61a..991734d3 100644
--- a/Model.hpp
+++ b/Model.hpp
@@ -40,6 +40,8 @@ class Model: private boost::noncopyable
 public:
     // The model class is more or less an implementation of the network rules
     // The network rules define the possible reactions between species.
+
+    // Constructor
     Model();
 
     virtual ~Model();
@@ -69,7 +71,7 @@ class Model: private boost::noncopyable
         return attributes_range(attrs_.begin(), attrs_.end());
     }
 
-
+//////// Member variables (why are they public?)
 public:
     species_type_id_generator_type  species_type_id_generator_; // The id generator which makes sure that all species have a unique id
     species_type_map_type           species_type_map_;          // ??
diff --git a/Particle.hpp b/Particle.hpp
index dba3751c..4058682b 100644
--- a/Particle.hpp
+++ b/Particle.hpp
@@ -15,6 +15,7 @@
 
 template<typename T_, typename Td_, typename Tsid_>
 struct Particle
+// T_ is a length_type
 {
     // defining shorthands for used types
     typedef Sphere<T_>                          shape_type;
@@ -24,8 +25,10 @@ struct Particle
     typedef Tsid_                               species_id_type;
     typedef typename shape_type::position_type  position_type;
     typedef typename shape_type::length_type    length_type;
+    // TODO typedef Tstructure_id_              structure_id_type    // The structure (not structure_type) on which the particle currently lives.
 
     // constructors
+    // TODO change constructors, structure_id should be mandatory (?)
     Particle(): shape_(), species_id_(), D_(0.), v_(0.) {}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
@@ -96,6 +99,8 @@ struct Particle
         return species_id_;
     }
 
+    // TODO add methods to get the id of the structure that the particle lives on.
+
     bool operator==(Particle const& rhs) const
     {
         return species_id_ == rhs.sid() && shape_ == rhs.shape();
@@ -116,10 +121,11 @@ struct Particle
 
 ////// Member variables
 private:
-    shape_type shape_;
+    shape_type      shape_;
     species_id_type species_id_;
-    D_type D_;
-    v_type v_;
+    D_type          D_;
+    v_type          v_;
+    // TODO structure_id_type   structure_id_
 };
 
 
@@ -128,6 +134,7 @@ template<typename Tstrm_, typename Ttraits_, typename T_, typename Td_, typename
 inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm, const Particle<T_, Td_, Tsid_>& p)
 {
     strm << "Particle(" << p.shape() << ", D=" << p.D() << ", v=" << p.v() << ", " << p.sid() << ")";
+    // TODO add id of the structure on which the particle lives.
     return strm;
 }
 
diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index c66818a7..4f5e1a82 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -10,14 +10,19 @@
 
 #include "ParticleModel.hpp"
 
+// Constructor
 ParticleModel::ParticleModel()
 {
+    // TODO add default structure_type for the bulk?
 }
 
 ParticleModel::~ParticleModel()
 {
 }
 
+// TODO Get default structure type?
+
+// Add a structure type to the model
 void ParticleModel::add_structure_type(boost::shared_ptr<structure_type_type> const& structure)
 {
     // std::pair<structure_type_map_type::iterator, bool> r(
@@ -33,6 +38,7 @@ void ParticleModel::add_structure_type(boost::shared_ptr<structure_type_type> co
     structure_type_map_.insert(std::make_pair(structure->id(), structure));
 }
 
+// Get a structure type from the model
 boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structure_type_by_id(structure_id_type const& id) const
 {
     structure_type_map_type::const_iterator i(structure_type_map_.find(id));
@@ -44,8 +50,8 @@ boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structu
     return (*i).second;
 }
 
+// Get all the structure types that are present in the particle model
 ParticleModel::structure_type_range ParticleModel::get_structure_types() const
-// Returns all the structure types that are present in the particle model
 {
     return structure_type_range(
         structure_type_iterator(structure_type_map_.begin(), structure_second_selector_type()),
diff --git a/ParticleModel.hpp b/ParticleModel.hpp
index c2a26b05..015eb222 100644
--- a/ParticleModel.hpp
+++ b/ParticleModel.hpp
@@ -14,6 +14,7 @@ class ParticleModel: public Model
     typedef Model                                   base_type;
     typedef StructureType                           structure_type_type;
     typedef structure_type_type::identifier_type    structure_id_type;
+    // TODO change to structure_type_id_type
 
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type_type> > structure_type_map_type;
 
@@ -21,23 +22,27 @@ class ParticleModel: public Model
 
 public:
     typedef boost::transform_iterator<structure_second_selector_type,
-            structure_type_map_type::const_iterator> structure_type_iterator;
-    typedef boost::iterator_range<structure_type_iterator> structure_type_range;
+            structure_type_map_type::const_iterator>            structure_type_iterator;
+    typedef boost::iterator_range<structure_type_iterator>      structure_type_range;
 
 public:
+    // Constructor
     ParticleModel();
 
     virtual ~ParticleModel();
 
+    // Gets a structure type
     boost::shared_ptr<structure_type_type> get_structure_type_by_id(structure_id_type const& id) const;
 
+    // Add a structure type
     void add_structure_type(boost::shared_ptr<structure_type_type> const& structure);
 
+    // Get all structure types in the model
     structure_type_range get_structure_types() const;
 
 /////// Member variables
 public:
-    structure_type_map_type structure_type_map_;
+    structure_type_map_type structure_type_map_;    // mapping: structure_type_id -> structure_type
 };
 
 
diff --git a/Structure.hpp b/Structure.hpp
index 69e91bc8..d657d5c4 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -20,14 +20,15 @@ class Structure
 {
 public:
     typedef Ttraits_ traits_type;
-    typedef typename traits_type::rng_type rng_type;
-    typedef typename traits_type::structure_id_type identifier_type;
-    typedef typename traits_type::length_type length_type;
-    typedef typename traits_type::position_type position_type;
-    typedef typename traits_type::base_type::species_type species_type;
-    typedef SpeciesTypeID species_id_type;
-    typedef std::pair<position_type, length_type> projected_type;
-    typedef std::pair<position_type, position_type> position_pair_type;
+    // shorthands for types that we use
+    typedef typename traits_type::rng_type                  rng_type;
+    typedef typename traits_type::structure_id_type         identifier_type;
+    typedef typename traits_type::length_type               length_type;
+    typedef typename traits_type::position_type             position_type;
+    typedef typename traits_type::base_type::species_type   species_type;
+    typedef SpeciesTypeID                                   species_id_type;
+    typedef std::pair<position_type, length_type>           projected_type;
+    typedef std::pair<position_type, position_type>         position_pair_type;
 
 public:
     virtual ~Structure() {}
@@ -37,6 +38,7 @@ class Structure
         return id_;
     }
 
+    // Get the StructureType of the structure
     species_id_type const& sid() const
     {
         if (!sid_)
@@ -121,9 +123,10 @@ class Structure
     Structure(identifier_type const& id)
         : id_(id) {}
 
+////// Member variables
 protected:
-    identifier_type id_;
-    species_id_type sid_;
+    identifier_type id_;        // id of the structure
+    species_id_type sid_;       // id of the structure_type of the structure
 };
 
 template<typename Tstrm, typename Ttraits, typename T_traits>
diff --git a/StructureType.hpp b/StructureType.hpp
index c6097183..87698ba6 100644
--- a/StructureType.hpp
+++ b/StructureType.hpp
@@ -27,21 +27,25 @@ class StructureType
     typedef boost::iterator_range<string_map_iterator>  attributes_range;
 
 public:
+    // Constructor
+    StructureType(): model_(0) {}
+ 
+    // Get the id
     identifier_type const& id() const;
 
     std::string const& operator[](std::string const& name) const;
 
     std::string& operator[](std::string const& name);
 
+    // Get all the attributes
     attributes_range attributes() const;
 
+    // Get the particle model to which the structuretype is associated
     ParticleModel* model() const
     {
         return model_;
     }
 
-    StructureType(): model_(0) {}
- 
 protected:
     void bind_to_model(ParticleModel* model, identifier_type const& id)
     {
@@ -52,7 +56,7 @@ class StructureType
 
 //////// Member variables
 private:
-    ParticleModel* model_;          // to what model is it associated
+    ParticleModel*  model_;         // to what model is it associated
     identifier_type id_;            // identifier Note that these are only defined if the object is bound to a model.
     string_map_type attrs_;
 };
diff --git a/World.hpp b/World.hpp
index d0f52975..c8108bef 100644
--- a/World.hpp
+++ b/World.hpp
@@ -42,6 +42,7 @@ struct WorldTraitsBase
     typedef ParticleID                                      particle_id_type;   // identifier type for particles
     typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
     typedef SpeciesTypeID                                   species_id_type;    // identifier type for species and (structure types)
+    // TODO add structure_type_id_type?
     typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
     typedef std::string                                     structure_id_type;  // identifier type for structures
     // typedef SpeciesTypeID                                   structure_id_type;
@@ -231,6 +232,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // The constructor
     World(length_type world_size = 1., size_type size = 1)
         : base_type(world_size, size) {}
+    // TODO Add the default structure of the default structure_type here?
 
     // To add new particles
     virtual particle_id_pair new_particle(species_id_type const& sid,
@@ -336,7 +338,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // Add structureType
     // update structure
     // remove structure
-    // Get structures by structure type
+    // Get structure ids by structure type
     
     // FIXME This is probably not very usefull any more.
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
@@ -377,9 +379,9 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
 ///////////// Member variables
 private:
-    particle_id_generator pidgen_;                  // generator used to produce the unique ids for the particles
-    species_map species_map_;                       // ?
-    structure_map structure_map_;                   // ?
+    particle_id_generator       pidgen_;            // generator used to produce the unique ids for the particles
+    species_map                 species_map_;       // ?
+    structure_map               structure_map_;     // ?
     per_species_particle_id_set particle_pool_;
 };
 
diff --git a/gfrdbase.py b/gfrdbase.py
index 7c2cf88a..aebbec4e 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -170,7 +170,7 @@ def create_world(m, matrix_size=10):
                               float(st["v"])))
 
     for r in m.structures.itervalues():
-        world.add_structure(r)
+        world.add_structure(r)      # TODO change to add_structure_type
 
     world.model = m
     return world

From a72430ae97d8bfaf7a1171596cd0b5aaf8edbe5c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 15 Feb 2012 14:29:27 +0100
Subject: [PATCH 0639/1541] new class StructureID to make ids for structures

---
 Makefile.am     |  1 +
 StructureID.hpp | 62 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 StructureID.hpp

diff --git a/Makefile.am b/Makefile.am
index 55f84d22..29abf30e 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -117,6 +117,7 @@ noinst_HEADERS = \
 	SphericalBesselGenerator.hpp\
 	SphericalBesselTable.hpp\
 	Structure.hpp\
+    StructureID.hpp\
 	StructureUtils.hpp\
 	StructureType.hpp\
 	Surface.hpp\
diff --git a/StructureID.hpp b/StructureID.hpp
new file mode 100644
index 00000000..2b3221de
--- /dev/null
+++ b/StructureID.hpp
@@ -0,0 +1,62 @@
+#ifndef STRUCTURE_ID_HPP
+#define STRUCTURE_ID_HPP
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <ostream>
+#if defined(HAVE_TR1_FUNCTIONAL)
+#include <tr1/functional>
+#elif defined(HAVE_STD_HASH)
+#include <functional>
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+#include <boost/functional/hash.hpp>
+#endif
+#include "Identifier.hpp"
+
+struct StructureID: public Identifier<StructureID, unsigned long long, int>
+// The StructureID is a class for the identification of structures
+{
+    typedef Identifier<StructureID, unsigned long long, int> base_type;
+
+    StructureID(value_type const& value = value_type(0, 0))
+        : base_type(value) {}
+};
+
+#if defined(HAVE_TR1_FUNCTIONAL)
+namespace std { namespace tr1 {
+#elif defined(HAVE_STD_HASH)
+namespace std {
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+namespace boost {
+#endif
+
+template<>
+struct hash<StructureID>
+// Hashing function??
+{
+    std::size_t operator()(StructureID const& val) const
+    {
+        return static_cast<std::size_t>(val().first ^ val().second);
+    }
+};
+
+#if defined(HAVE_TR1_FUNCTIONAL)
+} } // namespace std::tr1
+#elif defined(HAVE_STD_HASH)
+} // namespace std
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+} // namespace boost
+#endif
+
+template<typename Tstrm_, typename Ttraits_>
+inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm,
+        const StructureID& v)
+// Provides a stream of characters (a string) of the 'particle id' that allows for printing.
+{
+    strm << "StructureID(" << v().first << ":" << v().second << ")";
+    return strm;
+}
+
+#endif /* STRUCTURE_ID_HPP */

From b0cf2eb0f35bf6339dc7e653174f5ec466b68e6d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 15 Feb 2012 18:13:27 +0100
Subject: [PATCH 0640/1541] Small fix to try_transition()

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 5a659626..3f01760b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2092,7 +2092,7 @@ def try_transition(self, single, surface):
             # make the domain
             transition = self.create_transition(testShell)
             if __debug__:
-                log.info('        *Created: %s' % (interaction))
+                log.info('        *Created: %s' % (transition))
 
             # get the next event time
             transition.dt, transition.event_type, = transition.determine_next_event()

From a05e798b847bb5d784c6aea114b06f5c5c324bcf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 15 Feb 2012 18:11:39 +0100
Subject: [PATCH 0641/1541] Introduces a hack that hijacks fire_interaction to
 change the surface

---
 egfrd.py  | 22 +++++++++++++---------
 single.py |  9 ++++++---
 2 files changed, 19 insertions(+), 12 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3f01760b..49292dc3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -117,9 +117,9 @@ def try_default_testtransition(single, surface, geometrycontainer, domains):
     else:
         raise testShellError('(Transition). structure of particle was of invalid type')
 
-def create_default_transition(domain_id, shell_id, testShell, reaction_rules):    
+def create_default_transition(domain_id, shell_id, testShell, reaction_rules, interaction_rules): # HACK
     if isinstance(testShell, PlanarSurfaceEdgeSingletestShell):
-        return PlanarSurfaceEdgeSingle       (domain_id, shell_id, testShell, reaction_rules)
+        return PlanarSurfaceEdgeSingle       (domain_id, shell_id, testShell, reaction_rules, interaction_rules) # HACK
     
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
@@ -546,15 +546,15 @@ def create_transition(self, testShell):
         # TODO !!! care for structure change once particles can remember them !!!
 
         # OLD STUFF, PROB. NOT NEEDED                
-        #surfacetype_id = testShell.surface.sid
-        #interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
+        surfacetype_id = testShell.target_surface.sid
+        interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
 
         # 2. Create and register the interaction domain.
         # The type of the interaction that will be created 
         # depends on the surface (planar or cylindrical) the particle is 
         # trying to associate with. Either PlanarSurfaceInteraction or 
         # CylindricalSurfaceInteraction.
-        transition = create_default_transition(domain_id, shell_id, testShell, reaction_rules)
+        transition = create_default_transition(domain_id, shell_id, testShell, reaction_rules, interaction_rules) # HACK
 
         assert isinstance(transition, Single)
         transition.initialize(self.t)
@@ -1175,7 +1175,8 @@ def fire_interaction(self, single, reactant_pos, ignore):
         # A(structure) + surface -> 0
         # A(structure) + surface -> B(surface)
         if __debug__:
-            assert isinstance(single, InteractionSingle)
+            #assert isinstance(single, InteractionSingle)
+            assert isinstance(single, Single) # HACK
 
         # 0. get reactant info
         reactant        = single.pid_particle_pair
@@ -1212,9 +1213,10 @@ def fire_interaction(self, single, reactant_pos, ignore):
 #                   'Product particle should live on the surface of interaction after the reaction.'
 
             # 1.5 get new position of particle
-            transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
-            product_pos, _ = product_surface.projected_point(transposed_pos)
-            product_pos = self.world.apply_boundary(product_pos)        # not sure this is still necessary
+            #transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
+            #product_pos, _ = product_surface.projected_point(transposed_pos)
+            #product_pos = self.world.apply_boundary(product_pos)        # not sure this is still necessary
+            product_pos = reactant_pos; # HACK
 
             # 2. burst the volume that will contain the products.
             #    Note that an interaction domain is already sized such that it includes the
@@ -1671,6 +1673,8 @@ def process_single_event(self, single, ignore):
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
 
+            else if isinstance(single, PlanarSurfaceEdgeSingle) and single.changes_structures : # HACK
+                    particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
             else:
                 particles = self.fire_move(single, newpos)
                 zero_singles_b = []     # no bursting takes place
diff --git a/single.py b/single.py
index d04de694..d31aceb3 100644
--- a/single.py
+++ b/single.py
@@ -430,7 +430,7 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
-class PlanarSurfaceEdgeSingle(Single, hasSphericalShell, Others):
+class PlanarSurfaceEdgeSingle(InteractionSingle, hasSphericalShell, Others): # HACK
     """1 Particle inside a (spherical) shell at the edge of two planar surfaces
 
         * Particle coordinates on surface: x, y.
@@ -439,11 +439,11 @@ class PlanarSurfaceEdgeSingle(Single, hasSphericalShell, Others):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules): # HACK
 
         assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
+        InteractionSingle.__init__(self, domain_id, shell_id, reactionrules, interactionrules) # HACK
 
         self.origin_plane  = testShell.origin_plane
         self.target_plane  = testShell.target_plane
@@ -460,6 +460,8 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         self.edge_point = self.get_edge_point()
         self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()
 
+        self.changes_structures = 0
+
     # The same Greens function is used as for the normal PlanarSurfaceSingle;
     # If the position is off the plane of origin, it will be transformed towards the target plane
     def greens_function(self):
@@ -533,6 +535,7 @@ def process_new_position_vector(self, oldpos, displacement):
             # Construct the new position using the predefined unit vectors of the target plane
             newpos = target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
             change_particle_structure(self.pid_particle_pair, target_plane)
+            self.changes_structures = 1
 
         return newpos
 

From a8ad5a5332986f6f38e01a0a14bd9520819e63c6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 15 Feb 2012 18:22:06 +0100
Subject: [PATCH 0642/1541] Small testscript to test transfers between two
 planes

---
 samples/finite_planes_hack/finite_planes.py | 116 ++++++++++++++++++++
 1 file changed, 116 insertions(+)
 create mode 100755 samples/finite_planes_hack/finite_planes.py

diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
new file mode 100755
index 00000000..2a5098df
--- /dev/null
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -0,0 +1,116 @@
+#!/usr/bin/python
+
+# Small script to test transfers between planes
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+
+# Modules
+# ===============================
+import sys
+import os
+import datetime
+
+from egfrd import *
+from visualization import vtklogger
+
+import model
+import gfrdbase
+import _gfrd
+
+
+# Unique seed
+# ===============================
+currenttime = (long(
+datetime.datetime.now().month*30.5*24*3600*1e6+
+datetime.datetime.now().day*24*3600*1e6+datetime.datetime.now().hour*3600*1e6+
+datetime.datetime.now().minute*60*1e6+datetime.datetime.now().second*1e6+
+datetime.datetime.now().microsecond))
+myrandom.seed(currenttime)
+print "(Seed " + str(currenttime) + ")"
+ 
+
+# Constants
+# ===============================
+logging = False
+sigma = 1e-9        # Diameter particle
+D = 1e-13           # Diffusion constant
+N = 20000           # Number of steps simulation will last
+world_size = 1e-6   # Lengths of simulation box
+NParticles = 1     # Number of particles in the simulation
+k = 2e-14           # Reaction constant
+
+# VTK Logger
+# ===============================
+if (logging == True):
+    vtk_output_directory = 'VTK_out'
+    if (os.path.exists(vtk_output_directory)):
+        print '** WARNING: VTK output directory already exists, possible '+ \
+                'present old VTK files might lead to errors.'
+
+
+# Basic set up simulator
+# ===============================
+# Model
+m = model.ParticleModel(world_size)
+
+# Planes ("membranes")
+plane1 = _gfrd.create_planar_surface('plane1', 
+    [world_size/2,0,0], [0,0,1], [0,1,0], 
+    world_size, world_size)
+plane2 = _gfrd.create_planar_surface('plane2', 
+    [world_size/2,0,0], [1,0,0], [0,1,0], 
+    world_size, world_size)
+m.add_structure(plane1)
+m.add_structure(plane2)
+
+# Species
+A = model.Species('A', D, sigma, 'plane1')                                   
+m.add_species_type(A)
+B = model.Species('B', D, 2*sigma, 'plane2')                                   
+m.add_species_type(B)
+
+# Reaction rules
+r1 = model.create_binding_reaction_rule(A, plane2, B, k)
+m.network_rules.add_reaction_rule(r1)
+r2 = model.create_unbinding_reaction_rule(B, plane1, A, k)
+m.network_rules.add_reaction_rule(r2)
+
+
+# World
+w = gfrdbase.create_world(m, 3)
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
+
+# Set up logger
+if (logging == True):
+    l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+
+# Throw in particles
+throw_in_particles(w, A, Nparticles)
+#throw_in_particles(w, B, Nparticles)
+
+# Running 2
+# ===============================
+for t in range(N):
+
+    # if logging, log and also use "try statement"
+    if (logging == True): 
+        # take a step (but ignore errors)
+        try:
+            s.step()
+        except:
+            print "Broken (run with logging=False for errormessage)!"
+            break
+        # log the step
+        l.log()
+    # otherwise just make steps.
+    else:
+        s.step()
+
+s.stop(s.t)
+
+if (logging == True):
+    l.stop()
+

From e70ba5b461ce660282a94d8d42f87956a653e430 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 16 Feb 2012 15:30:56 +0100
Subject: [PATCH 0643/1541] added option to the logger to NOT draw the
 simulation box

---
 visualization/vtklogger.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 25610abd..2f58f5a9 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -11,7 +11,7 @@ class VTKLogger:
     """
     """
     def __init__(self, sim, dir='vtkdata', buffer_size=None, show_shells=True, 
-                 extra_particle_step=True, color_dict=None):
+                 extra_particle_step=True, color_dict=None, draw_simulation_box=True):
         """Create a new VTKLogger to visualize a simulation with 
         VTK/ParaView.
 
@@ -62,6 +62,7 @@ def __init__(self, sim, dir='vtkdata', buffer_size=None, show_shells=True,
         self.show_shells = show_shells
         self.extra_particle_step = extra_particle_step
         self.color_dict = color_dict
+        self.draw_simulation_box = draw_simulation_box
 
         self.vtk_writer = VTK_XML_Serial_Unstructured()
 
@@ -270,8 +271,9 @@ def stop(self):
                            self.get_cylindrical_surface_data())
         self.make_snapshot('planar_surfaces',
                            self.get_planar_surface_data())
-        self.make_snapshot('cuboidal_regions', 
-                           self.get_cuboidal_region_data())
+        if self.draw_simulation_box:
+            self.make_snapshot('cuboidal_regions', 
+                               self.get_cuboidal_region_data())
 
         # Finally, write PVD files.
         self.vtk_writer.write_pvd(self.dir + '/' + 'files.pvd', 

From acd36a944e465e5784ef72d277125569f5ff232f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 16 Feb 2012 18:30:23 +0100
Subject: [PATCH 0644/1541] dirty hack (temporary) to make shells less greedy.

---
 shells.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/shells.py b/shells.py
index 4ce6b427..c8131537 100755
--- a/shells.py
+++ b/shells.py
@@ -426,6 +426,9 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     reference_point = testShell.get_referencepoint()
     orientation_vector = testShell.get_orientation_vector()
 
+    # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
+    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
+
     # determine on what side the midpoint of the shell is relative to the reference_point
     shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
     ref_to_shell_vec = shell_position_t - reference_point
@@ -576,6 +579,9 @@ def get_radius_to_SphericalShape(shape, testShell, r):
     scale_point = testShell.center
     r_new = testShell.world.distance(shape, scale_point)
 
+    # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
+    r_new = min(r_new, testShell.world.distance(shape.position, scale_point)/2)
+
     # if the newly calculated dimensions are smaller than the current one, use them
     return min(r, r_new)
 
@@ -600,6 +606,9 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     reference_point = testShell.get_referencepoint()
     orientation_vector = testShell.get_orientation_vector()
 
+    # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
+    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
+
     # determine on what side the midpoint of the shell is relative to the reference_point
     shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
     ref_to_shell_vec = shell_position_t - reference_point

From 21b05d64696a053c3757e8e296836da1ba3716ff Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 16 Feb 2012 18:40:05 +0100
Subject: [PATCH 0645/1541] General debugging and some changes to the
 testscript

---
 egfrd.py                                    |  28 +-
 samples/finite_planes_hack/finite_planes.py | 137 ++++++--
 shells.py                                   |  23 +-
 single.py                                   | 361 +++++++++++---------
 4 files changed, 344 insertions(+), 205 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 49292dc3..6e94501c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -83,10 +83,7 @@ def try_default_testinteraction(single, surface, geometrycontainer, domains):
         else:
             raise testShellError('(Interaction). Combination of (3D particle, surface) is not supported')
     elif isinstance(single.structure, PlanarSurface):
-        if isinstance(surface, PlanarSurface):
-            return PlanarSurfaceEdgeSingletestShell(single, surface, geometrycontainer, domains)
-        else:
-            raise testShellError('(Interaction). Combination of (2D particle, surface other than plane) is not supported')
+            raise testShellError('(Interaction). Combination of (2D particle, surface) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(surface, CylindricalSurface):     # TODO differentiate between a sink and a cap
             return CylindricalSurfaceSinktestShell (single, surface, geometrycontainer, domains)
@@ -533,7 +530,7 @@ def create_transition(self, testShell):
     # Currently only plane-plane transitions are supported.
     # We assume here that the testShell was successfully created.
 
-        assert isinstance(testShell, testSingle)  # TODO Possibly introduce masterclass testTransitionSingle
+        assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)  # TODO Possibly introduce masterclass testTransitionSingle
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
         # the scheduler
@@ -541,11 +538,12 @@ def create_transition(self, testShell):
         shell_id = self.shell_id_generator()
 
         # get unimolecular reaction rules
-        species_id = testShell.pid_particle_pair[1].sid    
+        species_id = testShell.single.pid_particle_pair[1].sid    
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
         # TODO !!! care for structure change once particles can remember them !!!
 
-        # OLD STUFF, PROB. NOT NEEDED                
+        # OLD STUFF, PROB. NOT NEEDED
+        #print(testShell.target_surface.id)
         surfacetype_id = testShell.target_surface.sid
         interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
 
@@ -631,6 +629,7 @@ def create_multi(self):
 
     def move_particle(self, pid_particle_pair, position):
         # moves a particle in world based on an existing particle
+        p = Particle(position, pid_particle_pair[1].radius, pid_particle_pair[1].D, pid_particle_pair[1].v, pid_particle_pair[1].sid)
 
         new_pid_particle_pair = (pid_particle_pair[0],
                                  Particle(position,
@@ -1569,7 +1568,8 @@ def update_single(self, single):
         self.add_domain_event(single)
         # check everything is ok
         if __debug__:
-            assert self.check_domain(single)
+            #assert self.check_domain(single) # HACK
+            pass
 
         return single
 
@@ -1625,7 +1625,8 @@ def process_single_event(self, single, ignore):
             if __debug__:
                 if single.event_type != EventType.BURST:
                     # The burst of the domain may be caused by an overlapping domain
-                    assert self.check_domain(single)
+                    #assert self.check_domain(single) # HACK
+                    pass
 
                 # check that the event time of the single (last_time + dt) is equal to the
                 # simulator time
@@ -1673,7 +1674,7 @@ def process_single_event(self, single, ignore):
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
 
-            else if isinstance(single, PlanarSurfaceEdgeSingle) and single.changes_structures : # HACK
+            elif isinstance(single, PlanarSurfaceEdgeSingle) and single.changes_structures : # HACK
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
             else:
                 particles = self.fire_move(single, newpos)
@@ -2113,7 +2114,8 @@ def try_transition(self, single, surface):
             self.add_domain_event(transition)
             # check everything is ok
             if __debug__:
-                assert self.check_domain(transition)
+                #assert self.check_domain(transition) # HACK
+                pass
 
             return transition
         else:
@@ -2439,6 +2441,10 @@ def check_domain(self, domain):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.structure.id, domain.surface.id]
+        elif isinstance(domain, PlanarSurfaceEdgeSingle):
+            # Ignore surface of the particle and interaction surface
+            ignores = []
+            associated = [domain.structure.id, domain.surface.id]
         else:
             # Ignore the structure that the particles are associated with
             ignores = []
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index 2a5098df..f7fe175c 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -1,6 +1,6 @@
 #!/usr/bin/python
 
-# Small script to test transfers between planes
+# Small script to test transfers between membranes
 #
 # Make sure that the egfrd system is added to your PYTHONPATH
 # This means, in bash for example:
@@ -33,12 +33,13 @@
 
 # Constants
 # ===============================
-logging = False
+#logging = False
+logging = True
 sigma = 1e-9        # Diameter particle
-D = 1e-13           # Diffusion constant
+DC = 1e-13           # Diffusion constant
 N = 20000           # Number of steps simulation will last
 world_size = 1e-6   # Lengths of simulation box
-NParticles = 1     # Number of particles in the simulation
+Nparticles = 1     # Number of particles in the simulation
 k = 2e-14           # Reaction constant
 
 # VTK Logger
@@ -53,29 +54,124 @@
 # Basic set up simulator
 # ===============================
 # Model
-m = model.ParticleModel(world_size)
+m = model.ParticleModel(2*world_size)
 
 # Planes ("membranes")
-plane1 = _gfrd.create_planar_surface('plane1', 
-    [world_size/2,0,0], [0,0,1], [0,1,0], 
-    world_size, world_size)
-plane2 = _gfrd.create_planar_surface('plane2', 
-    [world_size/2,0,0], [1,0,0], [0,1,0], 
-    world_size, world_size)
-m.add_structure(plane1)
-m.add_structure(plane2)
+membrane1_type = _gfrd.StructureType()
+membrane1_type['name'] = 'membrane1_type'
+membrane2_type = _gfrd.StructureType()
+membrane2_type['name'] = 'membrane2_type'
+membrane3_type = _gfrd.StructureType()
+membrane3_type['name'] = 'membrane3_type'
+membrane4_type = _gfrd.StructureType()
+membrane4_type['name'] = 'membrane4_type'
+membrane5_type = _gfrd.StructureType()
+membrane5_type['name'] = 'membrane5_type'
+membrane6_type = _gfrd.StructureType()
+membrane6_type['name'] = 'membrane6_type'
+
+m.add_structure_type(membrane1_type)
+m.add_structure_type(membrane2_type)
+m.add_structure_type(membrane3_type)
+m.add_structure_type(membrane4_type)
+m.add_structure_type(membrane5_type)
+m.add_structure_type(membrane6_type)
 
 # Species
-A = model.Species('A', D, sigma, 'plane1')                                   
+A = model.Species('A', DC, sigma, membrane1_type['name'])
 m.add_species_type(A)
-B = model.Species('B', D, 2*sigma, 'plane2')                                   
+B = model.Species('B', DC, sigma, membrane2_type['name'])
 m.add_species_type(B)
+C = model.Species('C', DC, sigma, membrane3_type['name'])
+m.add_species_type(C)
+D = model.Species('D', DC, sigma, membrane4_type['name'])
+m.add_species_type(D)
+E = model.Species('E', DC, sigma, membrane5_type['name'])
+m.add_species_type(E)
+F = model.Species('F', DC, sigma, membrane6_type['name'])
+m.add_species_type(F)
 
 # Reaction rules
-r1 = model.create_binding_reaction_rule(A, plane2, B, k)
-m.network_rules.add_reaction_rule(r1)
-r2 = model.create_unbinding_reaction_rule(B, plane1, A, k)
-m.network_rules.add_reaction_rule(r2)
+rAB = model.create_binding_reaction_rule(A, membrane2_type, B, k)
+m.network_rules.add_reaction_rule(rAB)
+rBA = model.create_unbinding_reaction_rule(B, membrane1_type, A, k)
+m.network_rules.add_reaction_rule(rBA)
+
+rBC = model.create_binding_reaction_rule(B, membrane3_type, C, k)
+m.network_rules.add_reaction_rule(rBC)
+rCB = model.create_unbinding_reaction_rule(C, membrane2_type, B, k)
+m.network_rules.add_reaction_rule(rCB)
+
+rCD = model.create_binding_reaction_rule(C, membrane4_type, D, k)
+m.network_rules.add_reaction_rule(rCD)
+rDC = model.create_unbinding_reaction_rule(D, membrane3_type, C, k)
+m.network_rules.add_reaction_rule(rDC)
+
+rAD = model.create_binding_reaction_rule(A, membrane4_type, D, k)
+m.network_rules.add_reaction_rule(rAD)
+rDA = model.create_unbinding_reaction_rule(D, membrane1_type, A, k)
+m.network_rules.add_reaction_rule(rDA)
+
+rAE = model.create_binding_reaction_rule(A, membrane5_type, E, k)
+m.network_rules.add_reaction_rule(rAE)
+rEA = model.create_unbinding_reaction_rule(E, membrane1_type, A, k)
+m.network_rules.add_reaction_rule(rEA)
+
+rBE = model.create_binding_reaction_rule(B, membrane5_type, E, k)
+m.network_rules.add_reaction_rule(rBE)
+rEB = model.create_unbinding_reaction_rule(E, membrane2_type, B, k)
+m.network_rules.add_reaction_rule(rEB)
+
+rCE = model.create_binding_reaction_rule(C, membrane5_type, E, k)
+m.network_rules.add_reaction_rule(rCE)
+rEC = model.create_unbinding_reaction_rule(E, membrane3_type, C, k)
+m.network_rules.add_reaction_rule(rEC)
+
+rDE = model.create_binding_reaction_rule(D, membrane5_type, E, k)
+m.network_rules.add_reaction_rule(rDE)
+rED = model.create_unbinding_reaction_rule(E, membrane4_type, D, k)
+m.network_rules.add_reaction_rule(rED)
+
+rAF = model.create_binding_reaction_rule(A, membrane6_type, F, k)
+m.network_rules.add_reaction_rule(rAF)
+rFA = model.create_unbinding_reaction_rule(F, membrane1_type, A, k)
+m.network_rules.add_reaction_rule(rFA)
+
+rBF = model.create_binding_reaction_rule(B, membrane6_type, F, k)
+m.network_rules.add_reaction_rule(rBF)
+rFB = model.create_unbinding_reaction_rule(F, membrane2_type, B, k)
+m.network_rules.add_reaction_rule(rFB)
+
+rCF = model.create_binding_reaction_rule(C, membrane6_type, F, k)
+m.network_rules.add_reaction_rule(rCF)
+rFC = model.create_unbinding_reaction_rule(F, membrane3_type, C, k)
+m.network_rules.add_reaction_rule(rFC)
+
+rDF = model.create_binding_reaction_rule(D, membrane6_type, F, k)
+m.network_rules.add_reaction_rule(rDF)
+rFD = model.create_unbinding_reaction_rule(F, membrane4_type, D, k)
+m.network_rules.add_reaction_rule(rFD)
+
+
+# Create instances of membrane types
+membraneA = _gfrd.create_planar_surface(membrane1_type['name'], [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
+membraneA.sid = membrane1_type.id
+m.add_structure(membraneA)
+membraneB = _gfrd.create_planar_surface(membrane2_type['name'], [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
+membraneB.sid = membrane2_type.id
+m.add_structure(membraneB)
+membraneC = _gfrd.create_planar_surface(membrane3_type['name'], [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
+membraneC.sid = membrane3_type.id
+m.add_structure(membraneC)
+membraneD = _gfrd.create_planar_surface(membrane4_type['name'], [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
+membraneD.sid = membrane4_type.id
+m.add_structure(membraneD)
+membraneE = _gfrd.create_planar_surface(membrane5_type['name'], [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
+membraneE.sid = membrane5_type.id
+m.add_structure(membraneE)
+membraneF = _gfrd.create_planar_surface(membrane6_type['name'], [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
+membraneF.sid = membrane6_type.id
+m.add_structure(membraneF)
 
 
 # World
@@ -88,7 +184,8 @@
     l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
 
 # Throw in particles
-throw_in_particles(w, A, Nparticles)
+place_particle(w, A, [world_size/2, world_size/2, 0])  # place one particle on membraneA
+#throw_in_particles(w, A, Nparticles) # THIS DOES NOT WORK BECAUSE PARTICLES INTERSECT WITH PLANES YET!
 #throw_in_particles(w, B, Nparticles)
 
 # Running 2
diff --git a/shells.py b/shells.py
index 98bc2d70..e8a500a9 100755
--- a/shells.py
+++ b/shells.py
@@ -357,7 +357,7 @@ def __init__(self, sphericaltestShell, domain_id):
         # Make the appropriate shell.
         self.shell_center = sphericaltestShell.center
         self.shell_radius = sphericaltestShell.radius
-        self.shell = self.create_new_shell(self.shell_center,
+        self.shell = self.create_new_shell(self.shell_center,     # HACK! Why did it work without first arg. before?!
                                            self.shell_radius,
                                            domain_id)
 
@@ -1117,17 +1117,22 @@ class PlanarSurfaceEdgeSingletestShell(SphericaltestShell, testNonInteractionSin
 
     def __init__(self, single, surface, geometrycontainer, domains):
         SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        self.single = single
+        self.structure = single.structure
+        self.surface = surface
+
         self.origin_surface = single.structure
         self.target_surface = surface
-        assert isinstance(origin_surface, _gfrd.Surface)
-        assert isinstance(target_surface, _gfrd.Surface)
+        assert isinstance(self.origin_surface, PlanarSurface)
+        assert isinstance(self.target_surface, PlanarSurface)
 
+        self.pid_particle_pair = single.pid_particle_pair
         self.particle = single.pid_particle_pair[1]
-        self.single_radius = particle.radius
-        self.center = particle.position
+        self.single_radius = self.particle.radius
+        self.center = self.particle.position
 
         try:
-            self.radius = self.determine_possible_shell(self.structure.id, 
+            self.radius = self.determine_possible_shell(self.origin_surface.id, 
                                                         [self.single.domain_id],
                                                         [self.origin_surface.id, self.target_surface.id]
                                                        )
@@ -1136,16 +1141,16 @@ def __init__(self, single, surface, geometrycontainer, domains):
                                  (str(e)))
 
     def get_min_radius(self):
-        min_offset = single_radius*(SINGLE_SHELL_FACTOR - 1.0)
+        min_offset = self.single_radius#*(SINGLE_SHELL_FACTOR - 1.0)
         # The minimal shell size also deterimines the minimal radius of the later 2D domain.
         # min_offset here is the minimal length that the circular 2D domain protrudes into
         # the target surface. Make sure that min_offset > 0.0, because only then it is
         # guaranteed that there is always a certain probability to cross the edge even
         # if the shell with minimal radius is constructed
-        return self.get_distance_to_target_surface() + min_radius
+        return self.get_distance_to_target_surface() + min_offset
 
     def get_distance_to_target_surface(self):
-        distance = world.distance(target_surface.shape, self.center)
+        distance = self.world.distance(self.target_surface.shape, self.center)
         return distance
 
 #####
diff --git a/single.py b/single.py
index d31aceb3..babb4765 100644
--- a/single.py
+++ b/single.py
@@ -297,7 +297,7 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-    def create_updated_shell(self, position):
+    #def create_updated_shell(self, position):
         # TODO what should we do with the position now?
         try:
             radius = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])
@@ -421,8 +421,8 @@ def check(self):
         assert self.greens_function
         assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
 
-        assert numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,
-                         self.structure.shape.unit_z) == 0.0
+        assert feq(numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,
+                         self.structure.shape.unit_z), 0.0)
 
         return True
 
@@ -430,168 +430,6 @@ def __str__(self):
         return 'PlanarSurface' + Single.__str__(self)
 
 
-class PlanarSurfaceEdgeSingle(InteractionSingle, hasSphericalShell, Others): # HACK
-    """1 Particle inside a (spherical) shell at the edge of two planar surfaces
-
-        * Particle coordinates on surface: x, y.
-        * Domain: radial r. (determines x and y together with theta).
-        * Initial position: r = 0.
-        * Selected randomly when drawing displacement vector: theta.
-
-    """
-    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules): # HACK
-
-        assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
-        hasSphericalShell.__init__(self, testShell, domain_id)
-        InteractionSingle.__init__(self, domain_id, shell_id, reactionrules, interactionrules) # HACK
-
-        self.origin_plane  = testShell.origin_plane
-        self.target_plane  = testShell.target_plane
-        self.origin_center = origin_plane.shape.position
-        self.target_center = target_plane.shape.position
-        self.origin_half_extent = origin_plane.shape.half_extent
-        self.target_half_extent = target_plane.shape.half_extent      
-
-        self.start_position = self.pid_particle_pair[1].postition
-        self.target_distance = testShell.get_distance_to_target_surface()
-        # Keep the order of the following!
-        # get_edge_point() needs origin_unit_perp, while get_target_unit_vectors() needs edge_point.
-        self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
-        self.edge_point = self.get_edge_point()
-        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()
-
-        self.changes_structures = 0
-
-    # The same Greens function is used as for the normal PlanarSurfaceSingle;
-    # If the position is off the plane of origin, it will be transformed towards the target plane
-    def greens_function(self):
-        return GreensFunction2DAbsSym(self.D,
-                                          self.get_inner_a())
-
-    def draw_new_position(self, dt, event_type):
-        oldpos = self.start_position
-
-        if self.D == 0:
-            newpos = oldpos
-        elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
-            newpos = oldpos
-        else:
-            # Calculate r
-            if event_type == EventType.SINGLE_ESCAPE:
-            # Moving this checks to the Green's functions is not a good 
-            # idea, because then you'd draw an unused random number.  
-            # The same yields for the draw_new_com and draw_new_iv.  
-
-                r = self.get_inner_a()
-            else:
-                gf = self.greens_function()
-                r = draw_r_wrapper(gf, dt, self.get_inner_a())
-                # Note that in case of 1D diffusion r has a direction. It is
-                # the lateral displacement and can be positive or negative. 
-                # In other cases r is always positive and denotes
-                # radial displacement from the center.
-
-            # Calculate the displacement from oldpos in the plane of origin
-            displacement = self.create_position_vector(r)
-
-            # Now check whether the new position is in the plane of origin;
-            # if not, transform it to the target plane
-            newpos = self.process_new_position_vector(oldpos, displacement)
-
-        return newpos
-
-    def create_position_vector(self, r):
-        # project the vector onto the surface unit vectors to make sure
-        # that the coordinates are in the surface
-        x, y = random_vector2D(r)
-        return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
-
-    def process_new_position_vector(self, oldpos, displacement):
-        # This routine checks whether the new position in the plane of origin
-        # reaches out of it and if necessary calculates the position in the
-        # target plane.
-        # First calculate the coordinate perpendicular to the edge
-        # in the old plane
-        newpos_in_origin = (oldpos - self.origin_center) + displacement
-        d_origin_perp = numpy.dot(newpos_in_origin, self.origin_unit_perp)
-        assert (d_origin_perp >= 0.0 )
-        # Calculate the part of it that reaches out of the plane of origin
-        d_out = d_origin_perp - self.origin_half_extent_perp
-        if d_out <= 0.0 :
-            # The new position is still in the old plane;
-            # no transform required
-            newpos = oldpos + displacement
-        else :
-            # The new position is out of the old plane;
-            # transform it to the target plane.
-            # First calculate the coordinate in the target plane
-            # that is perpendicular to the edge:
-            d_target_perp = self.target_half_extent_perp - d_out
-            # Now the same for the parallel component
-            # Take into account that the parallel unit vector in the target plane might be
-            # either parallel or antiparallel to the parallel unit vector in the origin plane
-            d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
-            d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
-            # Construct the new position using the predefined unit vectors of the target plane
-            newpos = target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            change_particle_structure(self.pid_particle_pair, target_plane)
-            self.changes_structures = 1
-
-        return newpos
-
-    def get_origin_unit_vectors(self):
-        # calculate the unit vector perpendicular and parallel to the edge
-        # in the plane of origin and the half_extent of this plane in the
-        # perpendicular vector direction
-        w_z = self.target_plane.shape.unit_z
-        u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
-        assert feq(sqrt(numpy.dot(u_perp, u_perp)), 1.0)
-
-        u_x = self.origin_plane.shape.unit_x
-        u_y = self.origin_plane.shape.unit_y
-        if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
-             u_par  = u_y
-             h_perp = self.origin_half_extent[0] # half_extent in u_x direction
-        else:
-             u_par  = u_x
-             h_perp = self.origin_half_extent[1] # half_extent in u_y direction
-
-        return u_perp, u_par, h_perp
-
-    def get_target_unit_vectors(self):
-        # calculate the unit vector perpendicular and parallel to the edge
-        # in the target plane and the half_extent of this plane in the
-        # perpendicular vector direction        
-        w_perp_unnorm = self.edge_point - self.target_center
-        w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
-        assert feq(sqrt(numpy.dot(w_perp, w_perp)), 1.0)
-
-        w_x = self.target_plane.shape.unit_x
-        w_y = self.target_plane.shape.unit_y
-        if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
-             w_par = w_y
-             h_perp = self.origin_half_extent[0] # half_extent in w_x direction
-        else:
-             w_par = w_x
-             h_perp = self.origin_half_extent[1] # half_extent in w_y direction
-
-        return w_perp, w_par, h_perp
-
-    def get_edge_point(self):
-        ep = self.start_position + (self.target_distance * self.origin_unit_perp)
-        return ep
-
-    def change_particle_surface(pid_particle_pair, new_structure):
-        #pid_particle_pair[1].structure_id = new_structure.id
-        # TODO !!! This will only work once particles can remember their structure !!!
-        # for now...
-        pass
-
-
-    def __str__(self):
-        return 'PlanarSurfaceEdge' + Single.__str__(self)
-
-
 class CylindricalSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
     """1 Particle inside a (cylindrical) shell on a CylindricalSurface. 
     (Rods).
@@ -1098,6 +936,199 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
+class PlanarSurfaceEdgeSingle(NonInteractionSingle, hasSphericalShell, Others): # HACK
+    """1 Particle inside a (spherical) shell at the edge of two planar surfaces
+
+        * Particle coordinates on surface: x, y.
+        * Domain: radial r. (determines x and y together with theta).
+        * Initial position: r = 0.
+        * Selected randomly when drawing displacement vector: theta.
+
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules): # HACK
+
+        assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
+        hasSphericalShell.__init__(self, testShell, domain_id)
+#        Single.__init__(self, domain_id, shell_id, reactionrules)
+        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
+        # Note: for the Others superclass nothing is to be initialized.
+
+        self.pid_particle_pair = testShell.single.pid_particle_pair
+        # The following is copied from InteractionSingle
+        self.interactionrules = interactionrules        # the surface interaction 'reactions'
+        self.intrule = None
+        self.interaction_ktot = self.calc_ktot(interactionrules)
+
+        # Used internally
+        self.origin_surface  = testShell.origin_surface
+        self.target_surface  = testShell.target_surface
+        self.origin_center = self.origin_surface.shape.position
+        self.target_center = self.target_surface.shape.position
+        self.origin_half_extent = self.origin_surface.shape.half_extent
+        self.target_half_extent = self.target_surface.shape.half_extent
+
+        # This has to be set because external functions will use it
+        self.structure = self.origin_surface
+        self.surface = self.target_surface
+
+        self.start_position = self.pid_particle_pair[1].position
+        self.target_distance = testShell.get_distance_to_target_surface()
+        # Keep the order of the following!
+        # get_edge_point() needs origin_unit_perp, while get_target_unit_vectors() needs edge_point.
+        self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
+        self.edge_point = self.get_edge_point()
+        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()
+
+        self.changes_structures = 0
+
+    # The same Greens function is used as for the normal PlanarSurfaceSingle;
+    # If the position is off the surface of origin, it will be transformed towards the target surface
+    def greens_function(self):
+        return GreensFunction2DAbsSym(self.D,
+                                          self.get_inner_a())
+
+    def draw_new_position(self, dt, event_type):
+        oldpos = self.start_position
+
+        if self.D == 0:
+            newpos = oldpos
+        elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+            newpos = oldpos
+        else:
+            # Calculate r
+            if event_type == EventType.SINGLE_ESCAPE:
+            # Moving this checks to the Green's functions is not a good 
+            # idea, because then you'd draw an unused random number.  
+            # The same yields for the draw_new_com and draw_new_iv.  
+
+                r = self.get_inner_a()
+            else:
+                gf = self.greens_function()
+                r = draw_r_wrapper(gf, dt, self.get_inner_a())
+                # Note that in case of 1D diffusion r has a direction. It is
+                # the lateral displacement and can be positive or negative. 
+                # In other cases r is always positive and denotes
+                # radial displacement from the center.
+
+            # Calculate the displacement from oldpos in the surface of origin
+            displacement = self.create_position_vector(r)
+
+            # Now check whether the new position is in the surface of origin;
+            # if not, transform it to the target surface
+            newpos = self.process_new_position_vector(oldpos, displacement)
+
+        return newpos
+
+    def create_position_vector(self, r):
+        # project the vector onto the surface unit vectors to make sure
+        # that the coordinates are in the surface
+        x, y = random_vector2D(r)
+        return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
+
+    def process_new_position_vector(self, oldpos, displacement):
+        # This routine checks whether the new position in the surface of origin
+        # reaches out of it and if necessary calculates the position in the
+        # target surface.
+        # First calculate the coordinate perpendicular to the edge
+        # in the old surface
+        newpos_in_origin = (oldpos - self.origin_center) + displacement
+        d_origin_perp = numpy.dot(newpos_in_origin, self.origin_unit_perp)
+        assert (d_origin_perp >= 0.0 )
+        # Calculate the part of it that reaches out of the surface of origin
+        d_out = d_origin_perp - self.origin_half_extent_perp
+        if d_out <= 0.0 :
+            # The new position is still in the old surface;
+            # no transform required
+            newpos = oldpos + displacement
+        else :
+            # The new position is out of the old surface;
+            # transform it to the target surface.
+            # First calculate the coordinate in the target surface
+            # that is perpendicular to the edge:
+            d_target_perp = self.target_half_extent_perp - d_out
+            # Now the same for the parallel component
+            # Take into account that the parallel unit vector in the target surface might be
+            # either parallel or antiparallel to the parallel unit vector in the origin surface
+            d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
+            d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
+            # Construct the new position using the predefined unit vectors of the target surface
+            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
+            self.change_particle_structure(self.pid_particle_pair, self.target_surface)
+            self.changes_structures = 1
+
+        return newpos
+
+    def get_origin_unit_vectors(self):
+        # calculate the unit vector perpendicular and parallel to the edge
+        # in the surface of origin and the half_extent of this surface in the
+        # perpendicular vector direction
+        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
+        print(self.target_surface.id)
+        w_z = self.target_surface.shape.unit_z
+        u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
+        if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
+            print(self.target_distance)
+            print(self.target_center)
+            print(self.start_position)
+            print(self.target_center - self.start_position)
+            print(w_z)
+            print( u_perp)
+            
+            
+        assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
+
+        u_x = self.origin_surface.shape.unit_x
+        u_y = self.origin_surface.shape.unit_y
+        if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
+             u_par  = u_y
+             h_perp = self.origin_half_extent[0] # half_extent in u_x direction
+        else:
+             u_par  = u_x
+             h_perp = self.origin_half_extent[1] # half_extent in u_y direction
+
+        return u_perp, u_par, h_perp
+
+    def get_target_unit_vectors(self):
+        # calculate the unit vector perpendicular and parallel to the edge
+        # in the target surface and the half_extent of this surface in the
+        # perpendicular vector direction
+        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
+        w_perp_unnorm = self.edge_point - self.target_center
+        w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
+        assert feq(numpy.sqrt(numpy.dot(w_perp, w_perp)), 1.0)
+
+        w_x = self.target_surface.shape.unit_x
+        w_y = self.target_surface.shape.unit_y
+        if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
+             w_par = w_y
+             h_perp = self.origin_half_extent[0] # half_extent in w_x direction
+        else:
+             w_par = w_x
+             h_perp = self.origin_half_extent[1] # half_extent in w_y direction
+
+        return w_perp, w_par, h_perp
+
+    def get_edge_point(self):
+        ep = self.start_position + (self.target_distance * self.origin_unit_perp)
+        return ep
+
+    def change_particle_structure(self, id_particle_pair, new_structure):
+        #pid_particle_pair[1].structure_id = new_structure.id
+        # TODO !!! This will only work once particles can remember their structure !!!
+        # for now...
+        pass
+
+    def get_interaction_rule(self): # HACK
+        if self.intrule == None:
+            self.intrule = self.draw_reaction_rule(self.interactionrules)
+        return self.intrule
+    interactionrule = property(get_interaction_rule)
+
+
+    def __str__(self):
+        return 'PlanarSurfaceEdge' + Single.__str__(self)
+
+
 class DummySingle(object):
     def __init__(self):
         self.multiplicity = 1

From c194812c7ab748353862edba57a7f511db28b110 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Feb 2012 19:22:43 +0100
Subject: [PATCH 0646/1541] Implemented rudimentary plane collision detection
 in 2D...

... and some other hacks + changes to the testscript
which actually make the edge crossing scheme work!
---
 egfrd.py                                    |  2 +-
 samples/finite_planes_hack/finite_planes.py | 44 ++++++++++++++-------
 shells.py                                   | 26 +++++++++++-
 single.py                                   |  1 -
 4 files changed, 55 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6e94501c..4fef8e58 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1403,7 +1403,7 @@ def make_new_domain(self, single):
         for surface, surface_distance in surface_distances:
             if isinstance(surface, PlanarSurface):
                 # with a planar surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 20  # HACK!!! The * 20 factor is added manually! REMOVE THIS!
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index f7fe175c..abb2af9b 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -27,7 +27,9 @@
 datetime.datetime.now().day*24*3600*1e6+datetime.datetime.now().hour*3600*1e6+
 datetime.datetime.now().minute*60*1e6+datetime.datetime.now().second*1e6+
 datetime.datetime.now().microsecond))
-myrandom.seed(currenttime)
+#myrandom.seed(currenttime)
+
+myrandom.seed(323)
 print "(Seed " + str(currenttime) + ")"
  
 
@@ -37,7 +39,7 @@
 logging = True
 sigma = 1e-9        # Diameter particle
 DC = 1e-13           # Diffusion constant
-N = 20000           # Number of steps simulation will last
+N = 500           # Number of steps simulation will last
 world_size = 1e-6   # Lengths of simulation box
 Nparticles = 1     # Number of particles in the simulation
 k = 2e-14           # Reaction constant
@@ -54,7 +56,7 @@
 # Basic set up simulator
 # ===============================
 # Model
-m = model.ParticleModel(2*world_size)
+m = model.ParticleModel(1.2*world_size)
 
 # Planes ("membranes")
 membrane1_type = _gfrd.StructureType()
@@ -94,64 +96,69 @@
 # Reaction rules
 rAB = model.create_binding_reaction_rule(A, membrane2_type, B, k)
 m.network_rules.add_reaction_rule(rAB)
-rBA = model.create_unbinding_reaction_rule(B, membrane1_type, A, k)
+rBA = model.create_binding_reaction_rule(B, membrane1_type, A, k)
 m.network_rules.add_reaction_rule(rBA)
 
 rBC = model.create_binding_reaction_rule(B, membrane3_type, C, k)
 m.network_rules.add_reaction_rule(rBC)
-rCB = model.create_unbinding_reaction_rule(C, membrane2_type, B, k)
+rCB = model.create_binding_reaction_rule(C, membrane2_type, B, k)
 m.network_rules.add_reaction_rule(rCB)
 
 rCD = model.create_binding_reaction_rule(C, membrane4_type, D, k)
 m.network_rules.add_reaction_rule(rCD)
-rDC = model.create_unbinding_reaction_rule(D, membrane3_type, C, k)
+rDC = model.create_binding_reaction_rule(D, membrane3_type, C, k)
 m.network_rules.add_reaction_rule(rDC)
 
 rAD = model.create_binding_reaction_rule(A, membrane4_type, D, k)
 m.network_rules.add_reaction_rule(rAD)
-rDA = model.create_unbinding_reaction_rule(D, membrane1_type, A, k)
+rDA = model.create_binding_reaction_rule(D, membrane1_type, A, k)
 m.network_rules.add_reaction_rule(rDA)
 
 rAE = model.create_binding_reaction_rule(A, membrane5_type, E, k)
 m.network_rules.add_reaction_rule(rAE)
-rEA = model.create_unbinding_reaction_rule(E, membrane1_type, A, k)
+rEA = model.create_binding_reaction_rule(E, membrane1_type, A, k)
 m.network_rules.add_reaction_rule(rEA)
 
 rBE = model.create_binding_reaction_rule(B, membrane5_type, E, k)
 m.network_rules.add_reaction_rule(rBE)
-rEB = model.create_unbinding_reaction_rule(E, membrane2_type, B, k)
+rEB = model.create_binding_reaction_rule(E, membrane2_type, B, k)
 m.network_rules.add_reaction_rule(rEB)
 
 rCE = model.create_binding_reaction_rule(C, membrane5_type, E, k)
 m.network_rules.add_reaction_rule(rCE)
-rEC = model.create_unbinding_reaction_rule(E, membrane3_type, C, k)
+rEC = model.create_binding_reaction_rule(E, membrane3_type, C, k)
 m.network_rules.add_reaction_rule(rEC)
 
 rDE = model.create_binding_reaction_rule(D, membrane5_type, E, k)
 m.network_rules.add_reaction_rule(rDE)
-rED = model.create_unbinding_reaction_rule(E, membrane4_type, D, k)
+rED = model.create_binding_reaction_rule(E, membrane4_type, D, k)
 m.network_rules.add_reaction_rule(rED)
 
 rAF = model.create_binding_reaction_rule(A, membrane6_type, F, k)
 m.network_rules.add_reaction_rule(rAF)
-rFA = model.create_unbinding_reaction_rule(F, membrane1_type, A, k)
+rFA = model.create_binding_reaction_rule(F, membrane1_type, A, k)
 m.network_rules.add_reaction_rule(rFA)
 
 rBF = model.create_binding_reaction_rule(B, membrane6_type, F, k)
 m.network_rules.add_reaction_rule(rBF)
-rFB = model.create_unbinding_reaction_rule(F, membrane2_type, B, k)
+rFB = model.create_binding_reaction_rule(F, membrane2_type, B, k)
 m.network_rules.add_reaction_rule(rFB)
 
 rCF = model.create_binding_reaction_rule(C, membrane6_type, F, k)
 m.network_rules.add_reaction_rule(rCF)
-rFC = model.create_unbinding_reaction_rule(F, membrane3_type, C, k)
+rFC = model.create_binding_reaction_rule(F, membrane3_type, C, k)
 m.network_rules.add_reaction_rule(rFC)
 
 rDF = model.create_binding_reaction_rule(D, membrane6_type, F, k)
 m.network_rules.add_reaction_rule(rDF)
-rFD = model.create_unbinding_reaction_rule(F, membrane4_type, D, k)
+rFD = model.create_binding_reaction_rule(F, membrane4_type, D, k)
 m.network_rules.add_reaction_rule(rFD)
 
+rEF = model.create_binding_reaction_rule(E, membrane6_type, F, k)
+m.network_rules.add_reaction_rule(rEF)
+rFE = model.create_binding_reaction_rule(F, membrane5_type, E, k)
+m.network_rules.add_reaction_rule(rFE)
+
 
 # Create instances of membrane types
 membraneA = _gfrd.create_planar_surface(membrane1_type['name'], [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
@@ -173,6 +180,13 @@
 membraneF.sid = membrane6_type.id
 m.add_structure(membraneF)
 
+print("Membrane A : unit_z = " + str(membraneA.shape.unit_z))
+print("Membrane B : unit_z = " + str(membraneB.shape.unit_z))
+print("Membrane C : unit_z = " + str(membraneC.shape.unit_z))
+print("Membrane D : unit_z = " + str(membraneD.shape.unit_z))
+print("Membrane E : unit_z = " + str(membraneE.shape.unit_z))
+print("Membrane F : unit_z = " + str(membraneF.shape.unit_z))
+
 
 # World
 w = gfrdbase.create_world(m, 3)
diff --git a/shells.py b/shells.py
index e8a500a9..8cb6be16 100755
--- a/shells.py
+++ b/shells.py
@@ -9,6 +9,7 @@
     Cylinder,
     CylindricalShell,
     CylindricalSurface,
+    Plane,
     PlanarSurface,
     CuboidalRegion,
     )
@@ -688,7 +689,20 @@ def get_radius_to_CylindricalShape(shape, testShell, r):
     return min(r, r_new)
 
 def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
-    return r, z_right, z_left
+    # TODO / HACK : This will work only for PlanarSurfaceSingles for now!
+    assert (type(shape) is Plane)
+    assert isinstance(testShell, PlanarSurfaceSingletestShell)
+
+    scale_point = testShell.get_searchpoint()
+    r_new = testShell.world.distance(shape, scale_point)
+    # HACK for debugging:
+    #print(scale_point)
+    #print(shape.position)
+    #print(shape.unit_z)
+    #print(testShell.structure.shape.unit_z)
+    #print(testShell.world.distance(shape, scale_point))
+
+    return min(r, r_new), z_right, z_left
 
 def get_radius_to_PlanarShape(shape, testShell, r):
     # This function returns the radius for the spherical 'testShell' using the planar 'shape' as its closest
@@ -1032,6 +1046,16 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.dr       = self.pid_particle_pair[1].radius
         # Here determine_possible_shell is not called since the making of a NonInteractionSingle
         # should never fail
+        # HACK:
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell(self.structure.id, [], [])
+            
+            print("PlanarSurfaceSingletestShell:   Determined possible shellsize: dr = %s" % self.dr)
+
+        except ShellmakingError as e:
+            raise testShellError('(PlanarSurfaceSingle). %s' %
+                                 (str(e)))
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z   # just copy from structure
diff --git a/single.py b/single.py
index babb4765..60b90793 100644
--- a/single.py
+++ b/single.py
@@ -1063,7 +1063,6 @@ def get_origin_unit_vectors(self):
         # in the surface of origin and the half_extent of this surface in the
         # perpendicular vector direction
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
-        print(self.target_surface.id)
         w_z = self.target_surface.shape.unit_z
         u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
         if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):

From b1075984b09e2984e8ab3523798a250efa641131 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 21 Feb 2012 18:30:48 +0100
Subject: [PATCH 0647/1541] bugfix in single/pair particle decay reaction and
 draw_new_position with sink

---
 egfrd.py  | 3 +++
 single.py | 8 ++++----
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 56631bd0..ca30e02a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -852,6 +852,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
             # 5. No new single to be made
             # 6. Log the change
+            self.reaction_events += 1
+            self.last_reaction = (rr, (reactant[1], None), products)
 
             
         elif len(rr.products) == 1:
@@ -1216,6 +1218,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
 
             # 5. No new single to be made
             # 6. Log the change
+            self.reaction_events += 1
             self.last_reaction = (rr, (pid_particle_pair1[1], pid_particle_pair2[1]), products)
 
         elif len(rr.products) == 1:
diff --git a/single.py b/single.py
index b89164ec..ca1602e6 100644
--- a/single.py
+++ b/single.py
@@ -923,10 +923,10 @@ def draw_new_position(self, dt, event_type):
                 # Some other event took place and the particle didn't escape
                 z = draw_r_wrapper(gf, dt, self.get_inner_a(), -self.get_inner_a())
 
-        # Add displacement to shell.shape.position, not to particle.position.
-        # The direction of the shell is leading (not direction of the structure)
-        z_vector = self.shell.shape.unit_z * z
-        newpos = self.shell.shape.position + z_vector
+            # Add displacement to shell.shape.position, not to particle.position.
+            # The direction of the shell is leading (not direction of the structure)
+            z_vector = self.shell.shape.unit_z * z
+            newpos = self.shell.shape.position + z_vector
 
         return newpos
 

From 1bf872cfc280dec088e507bece7c0b0b21f3422a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 22 Feb 2012 17:10:01 +0100
Subject: [PATCH 0648/1541] registering new StructureID class and adding to
 compile process.

---
 StructureID.hpp                |  2 +-
 World.hpp                      |  1 +
 binding/Makefile.am            |  2 ++
 binding/binding_common.hpp     |  2 +-
 binding/structure_id_class.cpp | 18 ++++++++++++++++++
 binding/structure_id_class.hpp | 10 ++++++++++
 pyGFRD.cpp                     |  2 ++
 7 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100644 binding/structure_id_class.cpp
 create mode 100644 binding/structure_id_class.hpp

diff --git a/StructureID.hpp b/StructureID.hpp
index 2b3221de..e819d45f 100644
--- a/StructureID.hpp
+++ b/StructureID.hpp
@@ -53,7 +53,7 @@ struct hash<StructureID>
 template<typename Tstrm_, typename Ttraits_>
 inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm,
         const StructureID& v)
-// Provides a stream of characters (a string) of the 'particle id' that allows for printing.
+// Provides a stream of characters (a string) of the 'structure_id' that allows for printing.
 {
     strm << "StructureID(" << v().first << ":" << v().second << ")";
     return strm;
diff --git a/World.hpp b/World.hpp
index c8108bef..c63f39e9 100644
--- a/World.hpp
+++ b/World.hpp
@@ -22,6 +22,7 @@
 #include "SerialIDGenerator.hpp"
 #include "Transaction.hpp"
 #include "Structure.hpp"
+#include "StructureID.hpp"
 #include "Surface.hpp"
 #include "Region.hpp"
 #include "geometry.hpp"
diff --git a/binding/Makefile.am b/binding/Makefile.am
index 2e55dd26..79bc6ed8 100644
--- a/binding/Makefile.am
+++ b/binding/Makefile.am
@@ -83,6 +83,7 @@ noinst_HEADERS = \
 	Sphere.hpp \
 	SphericalSurface.hpp \
 	structure_classes.hpp \
+	structure_id_class.hpp \
 	structure_type_class.hpp \
 	StructureType.hpp \
 	transaction_classes.hpp \
@@ -130,6 +131,7 @@ libbinding_utils_la_SOURCES = \
 	species_type_class.cpp \
 	sphere_class.cpp \
 	structure_classes.cpp \
+	structure_id_class.cpp \
 	structure_type_class.cpp \
 	transaction_classes.cpp \
 	world_class.cpp
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index dcb414e6..c5190e12 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -47,7 +47,7 @@ typedef ::illegal_state IllegalState;
 typedef ::GSLRandomNumberGenerator GSLRandomNumberGenerator;
 typedef ::CyclicWorldTraits<Real, Real> WorldTraits;            // parameterize the World traits here -> determines many types!!
 typedef WorldTraits::particle_type Particle;
-typedef WorldTraits::structure_id_type StructureID;
+//typedef WorldTraits::structure_id_type StructureID;
 typedef WorldTraits::species_id_type SpeciesID;
 typedef WorldTraits::species_type SpeciesInfo;
 typedef WorldTraits::structure_type Structure;
diff --git a/binding/structure_id_class.cpp b/binding/structure_id_class.cpp
new file mode 100644
index 00000000..45a92d2e
--- /dev/null
+++ b/binding/structure_id_class.cpp
@@ -0,0 +1,18 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include "Identifier.hpp"
+#include "SerialIDGenerator.hpp"
+#include "binding_common.hpp"
+#include "peer/utils.hpp"
+
+namespace binding {
+
+void register_structure_id_class()
+{
+    IdentifierWrapper<StructureID>::__register_class("StructureID");
+    register_serial_id_generator_class<StructureID>("StructureIDGenerator");
+}
+
+} // namespace binding
diff --git a/binding/structure_id_class.hpp b/binding/structure_id_class.hpp
new file mode 100644
index 00000000..fac97283
--- /dev/null
+++ b/binding/structure_id_class.hpp
@@ -0,0 +1,10 @@
+#ifndef BINDING_STRUCTURE_ID_CLASS_HPP
+#define BINDING_STRUCTURE_ID_CLASS_HPP
+
+namespace binding {
+
+void register_structure_id_class();
+
+} // namespace binding
+
+#endif /* BINDING_STRUCTURE_ID_CLASS_HPP */
diff --git a/pyGFRD.cpp b/pyGFRD.cpp
index 782285e6..e5371679 100644
--- a/pyGFRD.cpp
+++ b/pyGFRD.cpp
@@ -63,6 +63,7 @@
 #include "binding/sphere_class.hpp"
 #include "binding/structure_classes.hpp"
 #include "binding/structure_type_class.hpp"
+#include "binding/structure_id_class.hpp"
 #include "binding/transaction_classes.hpp"
 #include "binding/world_class.hpp"
 
@@ -114,6 +115,7 @@ BOOST_PYTHON_MODULE(_gfrd)
     b::register_transaction_classes();
     b::register_world_class();
     b::register_structure_classes();
+    b::register_structure_id_class();
     b::register_structure_type_class();
     b::register_module_functions();
     b::register_volume_clearer_classes();

From 20dcd780774f944b54ed0553140fe4d65d6ed68a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 15 Feb 2012 14:29:27 +0100
Subject: [PATCH 0649/1541] new class StructureID to make ids for structures

---
 Makefile.am     |  1 +
 StructureID.hpp | 62 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)
 create mode 100644 StructureID.hpp

diff --git a/Makefile.am b/Makefile.am
index 55f84d22..29abf30e 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -117,6 +117,7 @@ noinst_HEADERS = \
 	SphericalBesselGenerator.hpp\
 	SphericalBesselTable.hpp\
 	Structure.hpp\
+    StructureID.hpp\
 	StructureUtils.hpp\
 	StructureType.hpp\
 	Surface.hpp\
diff --git a/StructureID.hpp b/StructureID.hpp
new file mode 100644
index 00000000..2b3221de
--- /dev/null
+++ b/StructureID.hpp
@@ -0,0 +1,62 @@
+#ifndef STRUCTURE_ID_HPP
+#define STRUCTURE_ID_HPP
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include <ostream>
+#if defined(HAVE_TR1_FUNCTIONAL)
+#include <tr1/functional>
+#elif defined(HAVE_STD_HASH)
+#include <functional>
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+#include <boost/functional/hash.hpp>
+#endif
+#include "Identifier.hpp"
+
+struct StructureID: public Identifier<StructureID, unsigned long long, int>
+// The StructureID is a class for the identification of structures
+{
+    typedef Identifier<StructureID, unsigned long long, int> base_type;
+
+    StructureID(value_type const& value = value_type(0, 0))
+        : base_type(value) {}
+};
+
+#if defined(HAVE_TR1_FUNCTIONAL)
+namespace std { namespace tr1 {
+#elif defined(HAVE_STD_HASH)
+namespace std {
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+namespace boost {
+#endif
+
+template<>
+struct hash<StructureID>
+// Hashing function??
+{
+    std::size_t operator()(StructureID const& val) const
+    {
+        return static_cast<std::size_t>(val().first ^ val().second);
+    }
+};
+
+#if defined(HAVE_TR1_FUNCTIONAL)
+} } // namespace std::tr1
+#elif defined(HAVE_STD_HASH)
+} // namespace std
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+} // namespace boost
+#endif
+
+template<typename Tstrm_, typename Ttraits_>
+inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm,
+        const StructureID& v)
+// Provides a stream of characters (a string) of the 'particle id' that allows for printing.
+{
+    strm << "StructureID(" << v().first << ":" << v().second << ")";
+    return strm;
+}
+
+#endif /* STRUCTURE_ID_HPP */

From b5488dfb0d5192ef3cf2bf14daac5d987f7e9e19 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 22 Feb 2012 17:10:01 +0100
Subject: [PATCH 0650/1541] registering new StructureID class and adding to
 compile process.

---
 StructureID.hpp                |  2 +-
 World.hpp                      |  1 +
 binding/Makefile.am            |  2 ++
 binding/binding_common.hpp     |  2 +-
 binding/structure_id_class.cpp | 18 ++++++++++++++++++
 binding/structure_id_class.hpp | 10 ++++++++++
 pyGFRD.cpp                     |  2 ++
 7 files changed, 35 insertions(+), 2 deletions(-)
 create mode 100644 binding/structure_id_class.cpp
 create mode 100644 binding/structure_id_class.hpp

diff --git a/StructureID.hpp b/StructureID.hpp
index 2b3221de..e819d45f 100644
--- a/StructureID.hpp
+++ b/StructureID.hpp
@@ -53,7 +53,7 @@ struct hash<StructureID>
 template<typename Tstrm_, typename Ttraits_>
 inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm,
         const StructureID& v)
-// Provides a stream of characters (a string) of the 'particle id' that allows for printing.
+// Provides a stream of characters (a string) of the 'structure_id' that allows for printing.
 {
     strm << "StructureID(" << v().first << ":" << v().second << ")";
     return strm;
diff --git a/World.hpp b/World.hpp
index c8108bef..c63f39e9 100644
--- a/World.hpp
+++ b/World.hpp
@@ -22,6 +22,7 @@
 #include "SerialIDGenerator.hpp"
 #include "Transaction.hpp"
 #include "Structure.hpp"
+#include "StructureID.hpp"
 #include "Surface.hpp"
 #include "Region.hpp"
 #include "geometry.hpp"
diff --git a/binding/Makefile.am b/binding/Makefile.am
index 2e55dd26..79bc6ed8 100644
--- a/binding/Makefile.am
+++ b/binding/Makefile.am
@@ -83,6 +83,7 @@ noinst_HEADERS = \
 	Sphere.hpp \
 	SphericalSurface.hpp \
 	structure_classes.hpp \
+	structure_id_class.hpp \
 	structure_type_class.hpp \
 	StructureType.hpp \
 	transaction_classes.hpp \
@@ -130,6 +131,7 @@ libbinding_utils_la_SOURCES = \
 	species_type_class.cpp \
 	sphere_class.cpp \
 	structure_classes.cpp \
+	structure_id_class.cpp \
 	structure_type_class.cpp \
 	transaction_classes.cpp \
 	world_class.cpp
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index dcb414e6..c5190e12 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -47,7 +47,7 @@ typedef ::illegal_state IllegalState;
 typedef ::GSLRandomNumberGenerator GSLRandomNumberGenerator;
 typedef ::CyclicWorldTraits<Real, Real> WorldTraits;            // parameterize the World traits here -> determines many types!!
 typedef WorldTraits::particle_type Particle;
-typedef WorldTraits::structure_id_type StructureID;
+//typedef WorldTraits::structure_id_type StructureID;
 typedef WorldTraits::species_id_type SpeciesID;
 typedef WorldTraits::species_type SpeciesInfo;
 typedef WorldTraits::structure_type Structure;
diff --git a/binding/structure_id_class.cpp b/binding/structure_id_class.cpp
new file mode 100644
index 00000000..45a92d2e
--- /dev/null
+++ b/binding/structure_id_class.cpp
@@ -0,0 +1,18 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include "Identifier.hpp"
+#include "SerialIDGenerator.hpp"
+#include "binding_common.hpp"
+#include "peer/utils.hpp"
+
+namespace binding {
+
+void register_structure_id_class()
+{
+    IdentifierWrapper<StructureID>::__register_class("StructureID");
+    register_serial_id_generator_class<StructureID>("StructureIDGenerator");
+}
+
+} // namespace binding
diff --git a/binding/structure_id_class.hpp b/binding/structure_id_class.hpp
new file mode 100644
index 00000000..fac97283
--- /dev/null
+++ b/binding/structure_id_class.hpp
@@ -0,0 +1,10 @@
+#ifndef BINDING_STRUCTURE_ID_CLASS_HPP
+#define BINDING_STRUCTURE_ID_CLASS_HPP
+
+namespace binding {
+
+void register_structure_id_class();
+
+} // namespace binding
+
+#endif /* BINDING_STRUCTURE_ID_CLASS_HPP */
diff --git a/pyGFRD.cpp b/pyGFRD.cpp
index 782285e6..e5371679 100644
--- a/pyGFRD.cpp
+++ b/pyGFRD.cpp
@@ -63,6 +63,7 @@
 #include "binding/sphere_class.hpp"
 #include "binding/structure_classes.hpp"
 #include "binding/structure_type_class.hpp"
+#include "binding/structure_id_class.hpp"
 #include "binding/transaction_classes.hpp"
 #include "binding/world_class.hpp"
 
@@ -114,6 +115,7 @@ BOOST_PYTHON_MODULE(_gfrd)
     b::register_transaction_classes();
     b::register_world_class();
     b::register_structure_classes();
+    b::register_structure_id_class();
     b::register_structure_type_class();
     b::register_module_functions();
     b::register_volume_clearer_classes();

From b428bcb6d05c9fcd1e21ad7e9b89b2d4b5d32b69 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 15 Feb 2012 16:35:05 +0100
Subject: [PATCH 0651/1541] Add structure_id as a property to a particle. This
 allows us to keep track of the structure that a particle lives on. The
 structure can only be of the structure type that is associated with the
 species of the particle.

---
 Particle.hpp               | 56 ++++++++++++++++++++++++--------------
 binding/Particle.hpp       | 53 +++++++++++++++++++++++++++++++-----
 binding/particle_class.cpp |  1 +
 egfrd.py                   |  3 +-
 4 files changed, 85 insertions(+), 28 deletions(-)

diff --git a/Particle.hpp b/Particle.hpp
index 4058682b..ea938f05 100644
--- a/Particle.hpp
+++ b/Particle.hpp
@@ -13,7 +13,7 @@
 #include "Sphere.hpp"
 #include "Shape.hpp"
 
-template<typename T_, typename Td_, typename Tsid_>
+template<typename T_, typename Td_, typename Tsid_, typename Tstructure_id_>
 struct Particle
 // T_ is a length_type
 {
@@ -25,20 +25,22 @@ struct Particle
     typedef Tsid_                               species_id_type;
     typedef typename shape_type::position_type  position_type;
     typedef typename shape_type::length_type    length_type;
-    // TODO typedef Tstructure_id_              structure_id_type    // The structure (not structure_type) on which the particle currently lives.
+    typedef Tstructure_id_                      structure_id_type    // The structure (not structure_type) on which the particle currently lives.
 
     // constructors
-    // TODO change constructors, structure_id should be mandatory (?)
-    Particle(): shape_(), species_id_(), D_(0.), v_(0.) {}
+    // Note that the structure_id is mandatory (?)
+    Particle(): shape_(), species_id_(), structure_id_(), D_(0.), v_(0.) {}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
-             D_type const& D)
-        : shape_(shape), species_id_(species_id), D_(D), v_(0.){}
+             structure_id_type const& structure_id, D_type const& D)
+        : shape_(shape), species_id_(species_id), structure_id_(structure_id), D_(D), v_(0.){}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
-             D_type const& D, v_type const& v)
-        : shape_(shape), species_id_(species_id), D_(D), v_(v) {}
+             structure_id_type const& structure_id, D_type const& D, v_type const& v)
+        : shape_(shape), species_id_(species_id), structure_id_(structure_id), D_(D), v_(v) {}
+
 
+    // Get basic properties such as position, radius, D, v (drift)
     position_type& position()
     {
         return shape_.position();
@@ -79,6 +81,7 @@ struct Particle
         return v_;
     }
 
+    // Get the shape of the particle (Sphere)
     shape_type& shape()
     {
         return shape_;
@@ -89,6 +92,7 @@ struct Particle
         return shape_;
     }
 
+    // Get the species_id
     species_id_type const& sid() const
     {
         return species_id_;
@@ -99,11 +103,23 @@ struct Particle
         return species_id_;
     }
 
-    // TODO add methods to get the id of the structure that the particle lives on.
+    // Get the id of the structure that the particle lives on.
+    structure_id_type const& structure_id() const
+    {
+        return structure_id_;
+    }
+
+    structure_id_type& structure_id()
+    {
+        return structure_id_;
+    }
 
+    // Check equality/inequality
     bool operator==(Particle const& rhs) const
     {
-        return species_id_ == rhs.sid() && shape_ == rhs.shape();
+        return species_id_ == rhs.sid() &&
+               shape_ == rhs.shape() &&
+               structure_id_ == rhs.structure_id();
     }
 
     bool operator!=(Particle const& rhs) const
@@ -121,11 +137,11 @@ struct Particle
 
 ////// Member variables
 private:
-    shape_type      shape_;
-    species_id_type species_id_;
-    D_type          D_;
-    v_type          v_;
-    // TODO structure_id_type   structure_id_
+    shape_type          shape_;
+    species_id_type     species_id_;
+    D_type              D_;
+    v_type              v_;
+    structure_id_type   structure_id_
 };
 
 
@@ -133,8 +149,7 @@ struct Particle
 template<typename Tstrm_, typename Ttraits_, typename T_, typename Td_, typename Tsid_>
 inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm, const Particle<T_, Td_, Tsid_>& p)
 {
-    strm << "Particle(" << p.shape() << ", D=" << p.D() << ", v=" << p.v() << ", " << p.sid() << ")";
-    // TODO add id of the structure on which the particle lives.
+    strm << "Particle(" << p.shape() << ", D=" << p.D() << ", v=" << p.v() << ", " << p.sid() << ", " << p.structure_id() << ")";
     return strm;
 }
 
@@ -156,9 +171,10 @@ struct hash<Particle<T_, Td_, Tsid_> >
     std::size_t operator()(argument_type const& val)
     {
         return hash<typename argument_type::position_type>()(val.position()) ^
-            hash<typename argument_type::length_type>()(val.radius()) ^
-            hash<typename argument_type::D_type>()(val.D()) ^
-            hash<typename argument_type::species_id_type>()(val.sid());
+               hash<typename argument_type::length_type>()(val.radius()) ^
+               hash<typename argument_type::D_type>()(val.D()) ^
+               hash<typename argument_type::species_id_type>()(val.sid()) ^
+               hash<typename argument_type::structure_id_type>()(val.structure_id());
     }
 };
 
diff --git a/binding/Particle.hpp b/binding/Particle.hpp
index ec086566..93f5042f 100644
--- a/binding/Particle.hpp
+++ b/binding/Particle.hpp
@@ -35,6 +35,9 @@ namespace binding {
 template<typename Timpl_>
 class ParticleWrapper
 {
+// This is a class that wraps Timpl (the Particle class) such that Python can handle it.
+// Timpl_ is the implemented class (Particle in this case)
+
 public:
     struct to_python_converter
     {
@@ -95,16 +98,17 @@ class ParticleWrapper
         return reinterpret_cast<PyObject*>(new ParticleWrapper(impl));
     }
 
+    // Python constructor method?
     static PyObject* __new__(PyTypeObject* klass, PyObject* arg, PyObject* kwarg)
     {
         PyObject* retval = NULL;
         switch (PyTuple_Size(arg))
         {
         default:
-            PyErr_SetString(PyExc_TypeError, "the number of arguments must be either 0 or 5");
+            PyErr_SetString(PyExc_TypeError, "the number of arguments must be either 0 or 6");
             return NULL;
 
-        case 5:
+        case 6:
             retval = create();
             if (set_position(reinterpret_cast<ParticleWrapper*>(retval), 
                         PyTuple_GetItem(arg, 0), 0)
@@ -115,7 +119,9 @@ class ParticleWrapper
                 || set_v(reinterpret_cast<ParticleWrapper*>(retval), 
                         PyTuple_GetItem(arg, 3), 0)
                 || set_sid(reinterpret_cast<ParticleWrapper*>(retval), 
-                        PyTuple_GetItem(arg, 4), 0))
+                        PyTuple_GetItem(arg, 4), 0)
+                || set_structure_id(reinterpret_cast<ParticleWrapper*>(retval), 
+                        PyTuple_GetItem(arg, 5), 0))
             {
                 ParticleWrapper::operator delete(retval);
                 return NULL;
@@ -146,11 +152,13 @@ class ParticleWrapper
         return __str__(self);
     }
 
+    // Python destructor method?
     static void __dealloc__(ParticleWrapper* self)
     {
         delete self;
     }
 
+    // Methods used to implement the getters/setters for Python (I think)
     static PyObject* get_position(ParticleWrapper* self)
     {
         typename Timpl_::position_type const& pos(self->impl_.position());
@@ -265,12 +273,31 @@ class ParticleWrapper
         return -1;
     }
 
+    // Getter and setter for the structure_id, the id of the structure that the particle lives on.
+    static PyObject* get_structure_id(ParticleWrapper* self)
+    {
+        return boost::python::incref(
+            boost::python::object(self->impl_.structure_id()).ptr());
+    }
+
+    static int set_structure_id(ParticleWrapper* self, PyObject* val, void *)
+    try
+    {
+        self->impl_.structure_id() = boost::python::extract<typename Timpl_::structure_id_type>(val);
+        return 0;
+    }
+    catch (boost::python::error_already_set const&)
+    {
+        return -1;
+    }
+
+
     static PyObject* __getstate__(ParticleWrapper* self)
     try
     {
         return boost::python::incref(
             boost::python::make_tuple(
-                boost::python::borrowed(get_position(self)),
+                boost::python::borrowed(get_position(self)),        // why here only position, radius and sid??
                 boost::python::borrowed(get_radius(self)),
                 boost::python::borrowed(get_sid(self))).ptr());
     }
@@ -302,13 +329,14 @@ class ParticleWrapper
     }
 
     static Py_ssize_t __sq_len__(PyObject *self)
+    // Give the size of the object (6 fields/properties)
     {
-        return 5;           // I think this is the number of elements (and not the max index)
+        return 6;           // I think this is the number of elements (and not the max index)
     }
 
     static PyObject* __sq_item__(PyObject *self, Py_ssize_t idx)
     {
-        if (idx < 0 || idx >= 5)
+        if (idx < 0 || idx >= 6)
         {
             PyErr_SetString(PyExc_IndexError, "index out of range");
             return NULL;
@@ -326,13 +354,15 @@ class ParticleWrapper
             return get_v(reinterpret_cast<ParticleWrapper*>(self));
         case 4:
             return get_sid(reinterpret_cast<ParticleWrapper*>(self));
+        case 5:
+            return get_structure_id(reinterpret_cast<ParticleWrapper*>(self));
         }
         return NULL; // never get here
     }
 
     static int __sq_ass_item__(PyObject *self, Py_ssize_t idx, PyObject *val)
     {
-        if (idx < 0 || idx >= 5)
+        if (idx < 0 || idx >= 6)
         {
             PyErr_SetString(PyExc_IndexError, "index out of range");
             return -1;
@@ -350,6 +380,8 @@ class ParticleWrapper
             return set_v(reinterpret_cast<ParticleWrapper*>(self), val, 0);
         case 4:
             return set_sid(reinterpret_cast<ParticleWrapper*>(self), val, 0);
+        case 5:
+            return set_structure_id(reinterpret_cast<ParticleWrapper*>(self), val, 0);
         }
 
         return -1; // never get here
@@ -425,6 +457,7 @@ PyMethodDef ParticleWrapper<Timpl_>::__methods__[] = {
 
 template<typename Timpl_>
 PyGetSetDef ParticleWrapper<Timpl_>::__getsets__[] = {
+// Defines the list of getters and setters for Python?
     {
         const_cast<char*>("position"),
         (getter)ParticleWrapper::get_position,
@@ -461,6 +494,12 @@ PyGetSetDef ParticleWrapper<Timpl_>::__getsets__[] = {
         (setter)ParticleWrapper::set_sid,
         const_cast<char*>("")
     },
+    {
+        const_cast<char*>("structure_id"),
+        (getter)ParticleWrapper::get_structure_id,
+        (setter)ParticleWrapper::set_structure_id,
+        const_cast<char*>("")
+    },
     { NULL }
 };
 
diff --git a/binding/particle_class.cpp b/binding/particle_class.cpp
index a4dac2b8..b4d97707 100644
--- a/binding/particle_class.cpp
+++ b/binding/particle_class.cpp
@@ -8,6 +8,7 @@
 namespace binding {
 
 void register_particle_class()
+// Parameterize the particle wrapper with the correct Particle class and registers it
 {
     ParticleWrapper<Particle>::__register_class("Particle");
 }
diff --git a/egfrd.py b/egfrd.py
index 56631bd0..202d871e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -573,7 +573,8 @@ def move_particle(self, pid_particle_pair, position):
                                           pid_particle_pair[1].radius,
                                           pid_particle_pair[1].D,
                                           pid_particle_pair[1].v,
-                                          pid_particle_pair[1].sid))
+                                          pid_particle_pair[1].sid,
+                                          pid_particle_pair[1].structure_id))
 
         self.world.update_particle(new_pid_particle_pair)
 

From e54aab1113e88c5f48b90fe1854cc34084bc9bad Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 23 Feb 2012 18:41:46 +0100
Subject: [PATCH 0652/1541] Added constructors for backward compatibility. Also
 fixed number of typos.

---
 Particle.hpp | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/Particle.hpp b/Particle.hpp
index ea938f05..033a18b8 100644
--- a/Particle.hpp
+++ b/Particle.hpp
@@ -25,11 +25,19 @@ struct Particle
     typedef Tsid_                               species_id_type;
     typedef typename shape_type::position_type  position_type;
     typedef typename shape_type::length_type    length_type;
-    typedef Tstructure_id_                      structure_id_type    // The structure (not structure_type) on which the particle currently lives.
+    typedef Tstructure_id_                      structure_id_type;    // The structure (not structure_type) on which the particle currently lives.
 
     // constructors
     // Note that the structure_id is mandatory (?)
-    Particle(): shape_(), species_id_(), structure_id_(), D_(0.), v_(0.) {}
+    Particle(): shape_(), species_id_(), structure_id_("World"), D_(0.), v_(0.) {}
+
+    Particle(species_id_type const& species_id, shape_type const& shape,
+             D_type const& D)
+        : shape_(shape), species_id_(species_id), structure_id_("World"), D_(D), v_(0.){}
+
+    Particle(species_id_type const& species_id, shape_type const& shape,
+             D_type const& D, v_type const& v)
+        : shape_(shape), species_id_(species_id), structure_id_("World"), D_(D), v_(v) {}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
              structure_id_type const& structure_id, D_type const& D)
@@ -141,13 +149,13 @@ struct Particle
     species_id_type     species_id_;
     D_type              D_;
     v_type              v_;
-    structure_id_type   structure_id_
+    structure_id_type   structure_id_;
 };
 
 
 ///// Inline functions
-template<typename Tstrm_, typename Ttraits_, typename T_, typename Td_, typename Tsid_>
-inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm, const Particle<T_, Td_, Tsid_>& p)
+template<typename Tstrm_, typename Ttraits_, typename T_, typename Td_, typename Tsid_, typename Tstructure_id_>
+inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm_, Ttraits_>& strm, const Particle<T_, Td_, Tsid_, Tstructure_id_>& p)
 {
     strm << "Particle(" << p.shape() << ", D=" << p.D() << ", v=" << p.v() << ", " << p.sid() << ", " << p.structure_id() << ")";
     return strm;
@@ -163,10 +171,10 @@ namespace std {
 namespace boost {
 #endif
 
-template<typename T_, typename Td_, typename Tsid_>
-struct hash<Particle<T_, Td_, Tsid_> >
+template<typename T_, typename Td_, typename Tsid_, typename Tstructure_id_>
+struct hash<Particle<T_, Td_, Tsid_, Tstructure_id_> >
 {
-    typedef Particle<T_, Td_, Tsid_> argument_type;
+    typedef Particle<T_, Td_, Tsid_, Tstructure_id_> argument_type;
 
     std::size_t operator()(argument_type const& val)
     {

From 2f066e245fc10197ce79245df9882751627428ea Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 23 Feb 2012 18:43:38 +0100
Subject: [PATCH 0653/1541] Adjust the World(.hpp) to use the extended particle
 definition.

---
 World.hpp | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/World.hpp b/World.hpp
index c63f39e9..701b1c24 100644
--- a/World.hpp
+++ b/World.hpp
@@ -44,9 +44,11 @@ struct WorldTraitsBase
     typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
     typedef SpeciesTypeID                                   species_id_type;    // identifier type for species and (structure types)
     // TODO add structure_type_id_type?
-    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
+//    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
     typedef std::string                                     structure_id_type;  // identifier type for structures
     // typedef SpeciesTypeID                                   structure_id_type;
+    typedef Particle<length_type, D_type, species_id_type,
+                     structure_id_type>                     particle_type;      // type for particles, NOTE why is there no v_type here?
 
     typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type>    species_type;  // information associated with the species
     typedef Vector3<length_type>                                                    point_type;
@@ -241,8 +243,11 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         species_type const& species(get_species(sid));
         particle_id_pair retval(pidgen_(),
+//                                particle_type(sid, particle_shape_type(pos, species.radius()),
+//                                              species.D(), species.v() ));
                                 particle_type(sid, particle_shape_type(pos, species.radius()),
-                                              species.D(), species.v() ));
+                                              "World", species.D(), species.v() ));
+
         update_particle(retval);
         return retval;
     }

From 90ef7bd663fb3db2298e26e919c3c3bb9008452a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Feb 2012 14:10:34 +0100
Subject: [PATCH 0654/1541] Removed distance check for
 PlanarSurfaceSingletestShell construction

... and other debugging stuff.
---
 egfrd.py                                    |  6 ++--
 samples/finite_planes_hack/finite_planes.py | 12 ++++---
 shells.py                                   | 36 ++++++++++-----------
 single.py                                   | 32 ++++++++++++++++--
 4 files changed, 58 insertions(+), 28 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4fef8e58..648f6be3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1393,6 +1393,7 @@ def make_new_domain(self, single):
         # Note that we do not differentiate between directions. This means that we
         # look around in a sphere, the horizons are spherical.
         pair_interaction_partners = []
+        pair_interaction_partners_ids = [] # HACK
         for domain, _ in neighbor_distances:
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
@@ -1403,15 +1404,16 @@ def make_new_domain(self, single):
         for surface, surface_distance in surface_distances:
             if isinstance(surface, PlanarSurface):
                 # with a planar surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 20  # HACK!!! The * 20 factor is added manually! REMOVE THIS!
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 2.0  # HACK!!! The * 2 factor is added manually! REMOVE THIS!
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
+            pair_interaction_partners_ids.append((surface.id, surface_distance)) # HACK
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
-        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners))
+        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners_ids)) # HACK
 
         # For each particles/particle or particle/surface pair, check if a pair or interaction can be
         # made. Note that we check the closest one first and only check if the object are within the horizon
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index abb2af9b..36c03250 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -35,11 +35,11 @@
 
 # Constants
 # ===============================
-#logging = False
-logging = True
-sigma = 1e-9        # Diameter particle
+logging = False
+#logging = True
+sigma = 1e-8        # Diameter particle
 DC = 1e-13           # Diffusion constant
-N = 500           # Number of steps simulation will last
+N = 1000           # Number of steps simulation will last
 world_size = 1e-6   # Lengths of simulation box
 Nparticles = 1     # Number of particles in the simulation
 k = 2e-14           # Reaction constant
@@ -56,7 +56,7 @@
 # Basic set up simulator
 # ===============================
 # Model
-m = model.ParticleModel(1.2*world_size)
+m = model.ParticleModel(2.01*world_size)
 
 # Planes ("membranes")
 membrane1_type = _gfrd.StructureType()
@@ -199,6 +199,8 @@
 
 # Throw in particles
 place_particle(w, A, [world_size/2, world_size/2, 0])  # place one particle on membraneA
+place_particle(w, A, [world_size/4, world_size/4, 0])  # place one particle on membraneA
+place_particle(w, A, [3*world_size/4, 3*world_size/4, 0])  # place one particle on membraneA
 #throw_in_particles(w, A, Nparticles) # THIS DOES NOT WORK BECAUSE PARTICLES INTERSECT WITH PLANES YET!
 #throw_in_particles(w, B, Nparticles)
 
diff --git a/shells.py b/shells.py
index 8cb6be16..d66f54ed 100755
--- a/shells.py
+++ b/shells.py
@@ -693,8 +693,15 @@ def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
     assert (type(shape) is Plane)
     assert isinstance(testShell, PlanarSurfaceSingletestShell)
 
-    scale_point = testShell.get_searchpoint()
-    r_new = testShell.world.distance(shape, scale_point)
+    if( feq(numpy.dot(shape.unit_z, testShell.get_orientation_vector()), 0.0) ) :
+    #if(True) :
+        # only check distance to perpendicular surfaces for the radius
+        scale_point = testShell.get_searchpoint()
+        r_new = testShell.world.distance(shape, scale_point)
+        r_ret = min(r, r_new)
+    else :
+        r_ret = r
+
     # HACK for debugging:
     #print(scale_point)
     #print(shape.position)
@@ -702,7 +709,7 @@ def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
     #print(testShell.structure.shape.unit_z)
     #print(testShell.world.distance(shape, scale_point))
 
-    return min(r, r_new), z_right, z_left
+    return r_ret, z_right, z_left
 
 def get_radius_to_PlanarShape(shape, testShell, r):
     # This function returns the radius for the spherical 'testShell' using the planar 'shape' as its closest
@@ -886,6 +893,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
  
         # first check the maximum dr, dz_right, dz_left against the surfaces
         # NOTE: we assume that all relevant surfaces are cylindrical and parallel to the testCylinder
+        # or planar surfaces and parallel to the testCylinder axis
         for surface, distance in neighbor_surfaces:
             # TODO
             if isinstance(surface, CylindricalSurface):
@@ -899,9 +907,8 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
 
             if (dr < min_dr) or (dz_right < min_dz_right) or (dz_left < min_dz_left):
                 raise ShellmakingError('Surface too close to make cylindrical testshell, '
-                                       'surface = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s' %
-                                       (surface, dr, dz_right, dz_left, self))
-
+                                       'surface = %s, dr = %s, dz_right = %s, dz_left = %s, testShell = %s, min_dr = %s' %
+                                       (surface, dr, dz_right, dz_left, self, min_dr))
         # TODO first sort the neighbors to distance -> faster to find if we fail
 
         # then check against all the shells of the neighboring domains (remember that domains can have
@@ -909,6 +916,9 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         for neighbor, distance in neighbor_domains:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
+            # FIXME: This gives an error 'NoneType' object is not iterable if neighbours are present
+            # Probably sth. about get_neighbor_shell_list not returning the right type
+            print shell_list # HACK
             for _, shell_appearance in shell_list:
                 if isinstance(shell_appearance.shape, Sphere):
                     dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self,
@@ -930,7 +940,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
                 dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
                (dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left)
 
-        # Note that dr, dz_right, dz_left can now actually be smaller than the minimum
+        # Note that dr, dz_right, dz_left can now actually be smaller than the minimum        
         dr, dz_right, dz_left = self.apply_safety(dr, dz_right, dz_left)
 
         return dr, dz_right, dz_left
@@ -1045,17 +1055,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.dz_left  = self.pid_particle_pair[1].radius
         self.dr       = self.pid_particle_pair[1].radius
         # Here determine_possible_shell is not called since the making of a NonInteractionSingle
-        # should never fail
-        # HACK:
-        try:
-            self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure.id, [], [])
-            
-            print("PlanarSurfaceSingletestShell:   Determined possible shellsize: dr = %s" % self.dr)
-
-        except ShellmakingError as e:
-            raise testShellError('(PlanarSurfaceSingle). %s' %
-                                 (str(e)))
+        # should never fail        
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z   # just copy from structure
diff --git a/single.py b/single.py
index 60b90793..5f9abb14 100644
--- a/single.py
+++ b/single.py
@@ -387,10 +387,12 @@ def shell_list_for_other(self):
     def create_updated_shell(self, position):
         # TODO what should we do with the position now?
         try:
+
             dr, dz_right, dz_left = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])
             center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
                                                                              self.testShell.get_orientation_vector(),
-                                                                             dr, dz_right, dz_left)            
+                                                                             dr, dz_right, dz_left) 
+            
             return self.create_new_shell(center, radius, half_length, self.domain_id)
         except ShellmakingError as e:
             raise Exception('PlanarSurfaceSingle, create_updated_shell failed: %s' % str(e) )
@@ -1051,6 +1053,20 @@ def process_new_position_vector(self, oldpos, displacement):
             # either parallel or antiparallel to the parallel unit vector in the origin surface
             d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
             d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
+            # DEBUG
+            print("process_new_position_vector")
+            print(self.origin_surface.id)
+            print(self.origin_unit_par)
+            print(self.origin_unit_perp)
+            print(self.target_surface.id)
+            print(self.target_unit_par)
+            print(self.target_unit_perp)
+            print(self.target_surface.shape.unit_x)
+            print(self.target_surface.shape.unit_y)
+            print(self.target_surface.shape.unit_z)
+            print(d_origin_perp)
+            print(d_origin_par)
+            print(d_target_par)
             # Construct the new position using the predefined unit vectors of the target surface
             newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
             self.change_particle_structure(self.pid_particle_pair, self.target_surface)
@@ -1065,13 +1081,15 @@ def get_origin_unit_vectors(self):
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
         w_z = self.target_surface.shape.unit_z
         u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
+        # DEBUG
         if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
+            print("get_origin_unit_vectors")
             print(self.target_distance)
             print(self.target_center)
             print(self.start_position)
             print(self.target_center - self.start_position)
             print(w_z)
-            print( u_perp)
+            print(u_perp)
             
             
         assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
@@ -1092,7 +1110,7 @@ def get_target_unit_vectors(self):
         # in the target surface and the half_extent of this surface in the
         # perpendicular vector direction
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
-        w_perp_unnorm = self.edge_point - self.target_center
+        w_perp_unnorm = (self.origin_center - self.target_center) + self.origin_half_extent_perp * self.origin_unit_perp
         w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
         assert feq(numpy.sqrt(numpy.dot(w_perp, w_perp)), 1.0)
 
@@ -1105,6 +1123,14 @@ def get_target_unit_vectors(self):
              w_par = w_x
              h_perp = self.origin_half_extent[1] # half_extent in w_y direction
 
+        # DEBUG
+        print("get_target_unit_vectors")
+        print(self.edge_point)
+        print(self.target_center)
+        print(w_perp_unnorm)
+        print(w_perp)
+        print(w_par)
+
         return w_perp, w_par, h_perp
 
     def get_edge_point(self):

From 2aabcc85597efb64d0397c8dd5297f679d17d800 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 5 Mar 2012 14:18:34 +0100
Subject: [PATCH 0655/1541] Changed StructureID as the type of the structure_id
 property of the particle, was string previously. Also the world now has a
 default structure_id Note that the structure_id property of a particle is
 still optional.

---
 Particle.hpp |  8 ++++----
 World.hpp    | 15 ++++++++++-----
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/Particle.hpp b/Particle.hpp
index 033a18b8..f17d47ae 100644
--- a/Particle.hpp
+++ b/Particle.hpp
@@ -29,15 +29,15 @@ struct Particle
 
     // constructors
     // Note that the structure_id is mandatory (?)
-    Particle(): shape_(), species_id_(), structure_id_("World"), D_(0.), v_(0.) {}
+    Particle(): shape_(), species_id_(), structure_id_(), D_(0.), v_(0.) {}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
              D_type const& D)
-        : shape_(shape), species_id_(species_id), structure_id_("World"), D_(D), v_(0.){}
+        : shape_(shape), species_id_(species_id), structure_id_(), D_(D), v_(0.){}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
              D_type const& D, v_type const& v)
-        : shape_(shape), species_id_(species_id), structure_id_("World"), D_(D), v_(v) {}
+        : shape_(shape), species_id_(species_id), structure_id_(), D_(D), v_(v) {}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
              structure_id_type const& structure_id, D_type const& D)
@@ -147,9 +147,9 @@ struct Particle
 private:
     shape_type          shape_;
     species_id_type     species_id_;
+    structure_id_type   structure_id_;
     D_type              D_;
     v_type              v_;
-    structure_id_type   structure_id_;
 };
 
 
diff --git a/World.hpp b/World.hpp
index 701b1c24..7ac10906 100644
--- a/World.hpp
+++ b/World.hpp
@@ -46,9 +46,10 @@ struct WorldTraitsBase
     // TODO add structure_type_id_type?
 //    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
     typedef std::string                                     structure_id_type;  // identifier type for structures
+    typedef SerialIDGenerator<StructureID>            structure_id_generator;
     // typedef SpeciesTypeID                                   structure_id_type;
     typedef Particle<length_type, D_type, species_id_type,
-                     structure_id_type>                     particle_type;      // type for particles, NOTE why is there no v_type here?
+                     StructureID>                     particle_type;      // type for particles, NOTE why is there no v_type here?
 
     typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type>    species_type;  // information associated with the species
     typedef Vector3<length_type>                                                    point_type;
@@ -208,6 +209,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::particle_type::shape_type particle_shape_type;
     typedef typename traits_type::size_type                 size_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_id_generator    structure_id_generator;
     typedef typename traits_type::structure_type            structure_type;
 
     //
@@ -234,7 +236,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 public:
     // The constructor
     World(length_type world_size = 1., size_type size = 1)
-        : base_type(world_size, size) {}
+        : base_type(world_size, size)
+    {
+        default_structure_id_ = structidgen_();
+    }
     // TODO Add the default structure of the default structure_type here?
 
     // To add new particles
@@ -243,10 +248,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         species_type const& species(get_species(sid));
         particle_id_pair retval(pidgen_(),
-//                                particle_type(sid, particle_shape_type(pos, species.radius()),
-//                                              species.D(), species.v() ));
                                 particle_type(sid, particle_shape_type(pos, species.radius()),
-                                              "World", species.D(), species.v() ));
+                                              default_structure_id_, species.D(), species.v() ));
 
         update_particle(retval);
         return retval;
@@ -389,6 +392,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     species_map                 species_map_;       // ?
     structure_map               structure_map_;     // ?
     per_species_particle_id_set particle_pool_;
+    structure_id_generator      structidgen_;
+    StructureID                 default_structure_id_;
 };
 
 #endif /* WORLD_HPP */

From c213f15560d08b64d72c27b2d922aae839aaec25 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 21 Feb 2012 11:46:21 +0100
Subject: [PATCH 0656/1541] Added comments and clarifications, changed layout
 to improve readability

---
 Multi.hpp                  | 37 +++++++++++++++++--------------
 ParticleContainer.hpp      | 29 +++++++++++++-----------
 ParticleContainerBase.hpp  | 45 ++++++++++++++++++++++----------------
 Structure.hpp              |  4 +++-
 StructureUtils.hpp         | 29 ++++++++++++------------
 binding/binding_common.hpp | 15 ++++++-------
 6 files changed, 88 insertions(+), 71 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 1a0363de..6c800d53 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -363,6 +363,7 @@ class MultiParticleContainer
         return real_pair(dt, step_size_factor * r_min);
     }
 
+    // The constructor
     MultiParticleContainer(world_type& world): world_(world) {}
 
 private:
@@ -371,6 +372,10 @@ class MultiParticleContainer
     species_map species_;
 };
 
+
+
+
+////////////////////////
 template<typename Tsim_>
 class Multi: public Domain<typename Tsim_::traits_type>
 {
@@ -378,23 +383,23 @@ class Multi: public Domain<typename Tsim_::traits_type>
     typedef Tsim_ simulator_type;
     typedef typename simulator_type::traits_type traits_type;
     typedef Domain<traits_type> base_type;
-    typedef typename traits_type::world_type::particle_type particle_type;
-    typedef typename particle_type::shape_type particle_shape_type;
-    typedef typename traits_type::world_type::species_type species_type;
-    typedef typename traits_type::world_type::species_id_type species_id_type;
-    typedef typename traits_type::world_type::position_type position_type;
-    typedef typename traits_type::world_type::particle_id_type particle_id_type;
-    typedef typename traits_type::world_type::length_type length_type;
-    typedef typename traits_type::world_type::size_type size_type;
-    typedef typename traits_type::world_type::structure_type structure_type;
-    typedef typename traits_type::world_type::particle_id_pair particle_id_pair;
-    typedef typename traits_type::network_rules_type network_rules_type;
-    typedef typename traits_type::reaction_rule_type reaction_rule_type;
-    typedef typename network_rules_type::reaction_rules reaction_rules;   
-    typedef typename traits_type::shell_id_type shell_id_type;
-    typedef typename traits_type::domain_id_type identifier_type;
+    typedef typename traits_type::world_type::particle_type         particle_type;
+    typedef typename particle_type::shape_type                      particle_shape_type;
+    typedef typename traits_type::world_type::species_type          species_type;
+    typedef typename traits_type::world_type::species_id_type       species_id_type;
+    typedef typename traits_type::world_type::position_type         position_type;
+    typedef typename traits_type::world_type::particle_id_type      particle_id_type;
+    typedef typename traits_type::world_type::length_type           length_type;
+    typedef typename traits_type::world_type::size_type             size_type;
+    typedef typename traits_type::world_type::structure_type        structure_type;
+    typedef typename traits_type::world_type::particle_id_pair      particle_id_pair;
+    typedef typename traits_type::network_rules_type        network_rules_type;
+    typedef typename traits_type::reaction_rule_type        reaction_rule_type;
+    typedef typename network_rules_type::reaction_rules     reaction_rules;   
+    typedef typename traits_type::shell_id_type             shell_id_type;
+    typedef typename traits_type::domain_id_type            identifier_type;
     typedef typename traits_type::template shell_generator<
-        typename simulator_type::sphere_type>::type spherical_shell_type;
+        typename simulator_type::sphere_type>::type         spherical_shell_type;
     typedef std::pair<const typename traits_type::shell_id_type, spherical_shell_type> spherical_shell_id_pair;
     typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 352dc894..7a0a2018 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -17,21 +17,22 @@ class ParticleContainer
 // The ParticleContainerBase implements some of them.
 public:
     typedef Ttraits_ traits_type;
-    typedef typename traits_type::particle_type particle_type;
-    typedef typename particle_type::shape_type particle_shape_type;
-    typedef typename traits_type::species_type species_type;
-    typedef typename traits_type::species_id_type species_id_type;
-    typedef typename traits_type::position_type position_type;
-    typedef typename traits_type::particle_id_type particle_id_type;
-    typedef typename traits_type::length_type length_type;
-    typedef typename traits_type::size_type size_type;
+    typedef typename traits_type::particle_type     particle_type;
+    typedef typename particle_type::shape_type      particle_shape_type;
+    typedef typename traits_type::species_type      species_type;
+    typedef typename traits_type::species_id_type   species_id_type;
+    typedef typename traits_type::position_type     position_type;
+    typedef typename traits_type::particle_id_type  particle_id_type;
+    typedef typename traits_type::length_type       length_type;
+    typedef typename traits_type::size_type         size_type;
     typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type structure_type;
-    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<structure_id_type, length_type> structure_id_and_distance_pair;
+    typedef typename traits_type::structure_type    structure_type;
+
+    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
+    typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
     typedef Transaction<traits_type> transaction_type;
-    typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
+    typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
 private:
@@ -51,12 +52,14 @@ class ParticleContainer
 
     virtual species_type const& get_species(species_id_type const& id) const = 0;
 
+    // Structure stuff
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
     virtual structures_range get_structures() const = 0;
     
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
 
+    // Particle stuff
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos) = 0;
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index bc8f494a..53adf981 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -13,12 +13,14 @@
 template<typename Ttraits_>
 struct ParticleContainerUtils
 {
+    // The structure is parameterized with the traits of the world
     typedef Ttraits_ traits_type;
-    typedef typename traits_type::length_type length_type;
-    typedef typename traits_type::particle_type particle_type;
-    typedef typename traits_type::particle_id_type particle_id_type;
-    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
+    // shorthand names for all the types that we use
+    typedef typename traits_type::length_type                   length_type;
+    typedef typename traits_type::particle_type                 particle_type;
+    typedef typename traits_type::particle_id_type              particle_id_type;
+    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
+    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
     struct distance_comparator:
@@ -39,9 +41,12 @@ struct ParticleContainerUtils
         const_caster c_;
     };
 
+
+
     template<typename Tset_>
     struct overlap_checker
     {
+        // The constructor
         overlap_checker(Tset_ const& ignore = Tset_()): ignore_(ignore), result_(0) {}
 
         template<typename Titer_>
@@ -73,6 +78,7 @@ struct ParticleContainerUtils
     };
 };
 
+
 template<typename Tderived_, typename Ttraits_ = typename Tderived_::traits_type>
 class ParticleContainerBase
     : public ParticleContainer<Ttraits_>
@@ -83,24 +89,25 @@ class ParticleContainerBase
     typedef ParticleContainerUtils<Ttraits_> utils;
     typedef ParticleContainer<Ttraits_> base_type;
     typedef Ttraits_ traits_type;
+
     // define some shorthands for all the types from the traits that we use.
-    typedef typename traits_type::length_type length_type;
-    typedef typename traits_type::species_type species_type;
-    typedef typename traits_type::position_type position_type;
-    typedef typename traits_type::particle_type particle_type;
-    typedef typename traits_type::particle_id_type particle_id_type;
-    typedef typename traits_type::particle_id_generator particle_id_generator;
-    typedef typename traits_type::species_id_type species_id_type;
+    typedef typename traits_type::length_type               length_type;
+    typedef typename traits_type::species_type              species_type;
+    typedef typename traits_type::position_type             position_type;
+    typedef typename traits_type::particle_type             particle_type;
+    typedef typename traits_type::particle_id_type          particle_id_type;
+    typedef typename traits_type::particle_id_generator     particle_id_generator;
+    typedef typename traits_type::species_id_type           species_id_type;
     typedef typename traits_type::particle_type::shape_type particle_shape_type;
-    typedef typename traits_type::size_type size_type;
-    typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type structure_type;
+    typedef typename traits_type::size_type                 size_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_type            structure_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef Transaction<traits_type> transaction_type;
+    typedef Transaction<traits_type>                        transaction_type;
 
     typedef MatrixSpace<particle_type, particle_id_type, get_mapper_mf> particle_matrix_type;
-    typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
+    typedef abstract_limited_generator<particle_id_pair>                particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>                    particle_id_pair_and_distance;
     typedef sized_iterator_range<typename particle_matrix_type::const_iterator> particle_id_pair_range;
 
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
@@ -269,7 +276,7 @@ class ParticleContainerBase
 
 ///////// Member variables
 protected:
-    particle_matrix_type pmat_;         // just the structure containing the particles.
+    particle_matrix_type pmat_;         // just the structure (MatrixSpace) containing the particles.
 };
 
 
diff --git a/Structure.hpp b/Structure.hpp
index d657d5c4..f61cbb49 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -43,7 +43,7 @@ class Structure
     {
         if (!sid_)
         {
-            throw illegal_state("not bound to SpeciesType");
+            throw illegal_state("not bound to StructureType");
         }
         return sid_;
     }
@@ -129,6 +129,8 @@ class Structure
     species_id_type sid_;       // id of the structure_type of the structure
 };
 
+
+//////// Inline functions
 template<typename Tstrm, typename Ttraits, typename T_traits>
 inline std::basic_ostream<Tstrm, Ttraits>& operator<<(std::basic_ostream<Tstrm, Ttraits>& strm, const Structure<T_traits>& v)
 {
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index ab847e0d..c4ec7f35 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -14,20 +14,21 @@ struct StructureUtils
 {
     typedef Tsim_ simulator_type;
     typedef typename simulator_type::traits_type traits_type;
-    typedef typename traits_type::world_type::position_type position_type;
-    typedef typename traits_type::world_type::length_type length_type;
-    typedef typename traits_type::world_type::structure_id_type structure_id_type;
-    typedef typename traits_type::world_type::structure_type structure_type;
-    typedef typename simulator_type::surface_type surface_type;
-    typedef typename simulator_type::region_type region_type;
-    typedef typename simulator_type::sphere_type sphere_type;
-    typedef typename simulator_type::cylinder_type cylinder_type;
-    typedef typename simulator_type::box_type box_type;
-    typedef typename simulator_type::plane_type plane_type;
-    typedef typename simulator_type::spherical_surface_type spherical_surface_type;
-    typedef typename simulator_type::cylindrical_surface_type cylindrical_surface_type;
-    typedef typename simulator_type::planar_surface_type planar_surface_type;
-    typedef typename simulator_type::cuboidal_region_type cuboidal_region_type;
+    typedef typename traits_type::world_type::position_type             position_type;
+    typedef typename traits_type::world_type::length_type               length_type;
+    typedef typename traits_type::world_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::world_type::structure_type            structure_type;
+    typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
+    typedef typename simulator_type::surface_type               surface_type;
+    typedef typename simulator_type::region_type                region_type;
+    typedef typename simulator_type::sphere_type                sphere_type;
+    typedef typename simulator_type::cylinder_type              cylinder_type;
+    typedef typename simulator_type::box_type                   box_type;
+    typedef typename simulator_type::plane_type                 plane_type;
+    typedef typename simulator_type::spherical_surface_type     spherical_surface_type;
+    typedef typename simulator_type::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename simulator_type::planar_surface_type        planar_surface_type;
+    typedef typename simulator_type::cuboidal_region_type       cuboidal_region_type;
     typedef typename simulator_type::world_type::traits_type::rng_type rng_type;
  
     static planar_surface_type* create_planar_surface(
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index c5190e12..729c8d53 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -46,14 +46,13 @@ typedef ::already_exists AlreadyExists;
 typedef ::illegal_state IllegalState;
 typedef ::GSLRandomNumberGenerator GSLRandomNumberGenerator;
 typedef ::CyclicWorldTraits<Real, Real> WorldTraits;            // parameterize the World traits here -> determines many types!!
-typedef WorldTraits::particle_type Particle;
-//typedef WorldTraits::structure_id_type StructureID;
-typedef WorldTraits::species_id_type SpeciesID;
-typedef WorldTraits::species_type SpeciesInfo;
-typedef WorldTraits::structure_type Structure;
-typedef StructureType::identifier_type StructureTypeID;
-typedef WorldTraits::length_type Length;
-typedef WorldTraits::position_type Position;
+//typedef WorldTraits::structure_id_type  StructureID;
+typedef WorldTraits::species_id_type    SpeciesID;
+typedef WorldTraits::species_type       SpeciesInfo;
+typedef WorldTraits::structure_type     Structure;
+typedef StructureType::identifier_type  StructureTypeID;
+typedef WorldTraits::length_type        Length;
+typedef WorldTraits::position_type      Position;
 typedef ::World<WorldTraits> World;                             // plug in the WorldTraits type to get a fully specified World type.
 
 typedef ::Model                                 Model;

From e4acbfdcbd189d0f5eff9c10e99dd29b73a9cd22 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 21 Feb 2012 12:16:40 +0100
Subject: [PATCH 0657/1541] The structures now have a reference to the
 corresponding structure type This replaces the 'name' of the surface as an
 identifier.

---
 StructureUtils.hpp | 18 +++++++++---------
 model.py           | 20 ++++++++++----------
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index c4ec7f35..0772ec46 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -16,7 +16,7 @@ struct StructureUtils
     typedef typename simulator_type::traits_type traits_type;
     typedef typename traits_type::world_type::position_type             position_type;
     typedef typename traits_type::world_type::length_type               length_type;
-    typedef typename traits_type::world_type::structure_id_type         structure_id_type;
+//    typedef typename traits_type::world_type::structure_id_type         structure_id_type;
     typedef typename traits_type::world_type::structure_type            structure_type;
     typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
     typedef typename simulator_type::surface_type               surface_type;
@@ -32,7 +32,7 @@ struct StructureUtils
     typedef typename simulator_type::world_type::traits_type::rng_type rng_type;
  
     static planar_surface_type* create_planar_surface(
-            structure_id_type const& id,
+            structure_type_id_type const& sid,          // This refers to the structure type of the planar surface
             position_type const& corner,
             position_type const& unit_x,
             position_type const& unit_y,
@@ -52,21 +52,21 @@ struct StructureUtils
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
                                                 multiply(unit_y, half_ly)));
 
-        return new planar_surface_type(id,
+        return new planar_surface_type(sid,
                                        plane_type(pos, unit_x, unit_y,
                                                   half_lx, half_ly));
     }
 
     static spherical_surface_type* create_spherical_surface(
-            structure_id_type const& id,
+            structure_type_id_type const& sid,
             position_type const& pos,
             length_type const& radius)
     {
-        return new spherical_surface_type(id, sphere_type(pos, radius));
+        return new spherical_surface_type(sid, sphere_type(pos, radius));
     }
 
     static cylindrical_surface_type* create_cylindrical_surface(
-            structure_id_type const& id,
+            structure_type_id_type const& sid,
             position_type const& corner,
             length_type const& radius,
             position_type const& unit_z,
@@ -77,17 +77,17 @@ struct StructureUtils
         const length_type half_length(length / 2);
         const position_type pos(add(corner, multiply(unit_z, half_length)));
 
-        return new cylindrical_surface_type(id,
+        return new cylindrical_surface_type(sid,
                 cylinder_type(pos, radius, unit_z, half_length));
     }
 
     static cuboidal_region_type* create_cuboidal_region(
-            structure_id_type const& id,
+            structure_type_id_type const& sid,
             position_type const& corner,
             boost::array<length_type, 3> const& extent)
     {
         const boost::array<length_type, 3> half_extent(divide(extent, 2));
-        return new cuboidal_region_type(id,
+        return new cuboidal_region_type(sid,
                 box_type(add(corner, half_extent),
                          create_vector<position_type>(1, 0, 0),
                          create_vector<position_type>(0, 1, 0),
diff --git a/model.py b/model.py
index ad7964c0..47516c7d 100644
--- a/model.py
+++ b/model.py
@@ -24,13 +24,13 @@
 
 # Define _gfrd docstrings here, much easier to format than in C++.
 _gfrd.create_cuboidal_region.__doc__ = \
-"""create_cuboidal_region(id, corner, diagonal)
+"""create_cuboidal_region(sid, corner, diagonal)
 
 Create and return a new cuboidal Region.
 
 Arguments:
-    - id
-        a descriptive name.
+    - sid
+        the structure type of the cuboidal region.
     - corner
         the point [x, y, z] of the cuboidal Region closest to
         [0, 0, 0]. Units: [meters, meters, meters]
@@ -42,13 +42,13 @@
 """
 
 _gfrd.create_cylindrical_surface.__doc__ = \
-"""create_cylindrical_surface(id, corner, radius, orientation, length)
+"""create_cylindrical_surface(sid, corner, radius, orientation, length)
 
 Create and return a new cylindrical Surface.
 
 Arguments:
-    - id
-        a descriptive name.
+    - sid
+        the structure type of the cylindrical surface.
     - corner
         the point [x, y, z] on the axis of the cylinder closest to 
         [0, 0, 0]. Units: [meters, meters, meters]
@@ -66,13 +66,13 @@
 """
 
 _gfrd.create_planar_surface.__doc__ = \
-"""create_planar_surface(id, corner, unit_x, unit_y, length_x, length_y)
+"""create_planar_surface(sid, corner, unit_x, unit_y, length_x, length_y)
 
 Create and return a new planar Surface.
 
 Arguments:
-    - id
-        a descriptive name.
+    - sid
+        the structure type of the planar surface.
     - corner
         the point [x, y, z] on the plane closest to [0, 0, 0]. Units: 
         [meters, meters, meters]
@@ -89,7 +89,7 @@
         the length of the plane along the unit vector unit_y. Should be 
         equal to the world_size. Units: meters.
 
-Surfaces are not allowed to touch or overlap.
+Surfaces are not allowed to overlap.
 
 Todo: allow the user to specify the position of a planar surface 
 relative to a region.

From dcd8d75cc0ec299cf4ea60810c97fbf32ca171cf Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 21 Feb 2012 17:19:48 +0100
Subject: [PATCH 0658/1541] removed old typedef for structure_id

---
 StructureUtils.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index 0772ec46..3cae81ac 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -16,7 +16,6 @@ struct StructureUtils
     typedef typename simulator_type::traits_type traits_type;
     typedef typename traits_type::world_type::position_type             position_type;
     typedef typename traits_type::world_type::length_type               length_type;
-//    typedef typename traits_type::world_type::structure_id_type         structure_id_type;
     typedef typename traits_type::world_type::structure_type            structure_type;
     typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
     typedef typename simulator_type::surface_type               surface_type;

From 909e216a672e6fd6703556743b0c8852f26b954c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 5 Mar 2012 15:47:48 +0100
Subject: [PATCH 0659/1541] added structure_type_id_type

---
 World.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/World.hpp b/World.hpp
index 7ac10906..3ddc4235 100644
--- a/World.hpp
+++ b/World.hpp
@@ -43,13 +43,14 @@ struct WorldTraitsBase
     typedef ParticleID                                      particle_id_type;   // identifier type for particles
     typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
     typedef SpeciesTypeID                                   species_id_type;    // identifier type for species and (structure types)
+    typedef SpeciesTypeID                                   structure_type_id_type;
     // TODO add structure_type_id_type?
 //    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
     typedef std::string                                     structure_id_type;  // identifier type for structures
-    typedef SerialIDGenerator<StructureID>            structure_id_generator;
+    typedef SerialIDGenerator<StructureID>                  structure_id_generator;
     // typedef SpeciesTypeID                                   structure_id_type;
     typedef Particle<length_type, D_type, species_id_type,
-                     StructureID>                     particle_type;      // type for particles, NOTE why is there no v_type here?
+                     StructureID>                           particle_type;      // type for particles, NOTE why is there no v_type here?
 
     typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type>    species_type;  // information associated with the species
     typedef Vector3<length_type>                                                    point_type;
@@ -211,6 +212,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_id_generator    structure_id_generator;
     typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     //
     typedef std::pair<const particle_id_type, particle_type>                    particle_id_pair;      // defines the pid_particle_pair tuple

From dd2ee9e84f474cfcf74bc65c9b8b2b0c0470fd48 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 6 Mar 2012 17:33:02 +0100
Subject: [PATCH 0660/1541] Added StructureType as a property of a structure.
 The default StructureType can be queried from the model.

---
 CuboidalRegion.hpp              |  9 +++++---
 CylindricalSurface.hpp          |  7 +++---
 EGFRDSimulatorFactory.hpp       |  2 +-
 ParticleModel.cpp               |  9 +++++++-
 ParticleModel.hpp               | 11 ++++++----
 ParticleSimulationStructure.hpp |  7 ++++--
 PlanarSurface.hpp               |  7 +++---
 Region.hpp                      | 26 +++++++++++++++-------
 SphericalSurface.hpp            |  8 ++++---
 Structure.hpp                   | 23 +++++++++++---------
 StructureUtils.hpp              | 13 +++++++----
 Surface.hpp                     | 38 ++++++++++++++++++++++-----------
 World.hpp                       |  6 +++++-
 binding/CuboidalRegion.hpp      |  1 +
 binding/CylindricalSurface.hpp  |  1 +
 binding/ParticleModel.hpp       |  1 +
 binding/PlanarSurface.hpp       |  1 +
 binding/SphericalSurface.hpp    |  1 +
 binding/Structure.hpp           |  4 ++--
 19 files changed, 118 insertions(+), 57 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 560e7747..91d62818 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -13,7 +13,8 @@ class CuboidalRegion
 public:
     typedef BasicRegionImpl<Ttraits_, Box<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type identifier_type;
+    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type shape_type;
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
@@ -21,6 +22,7 @@ class CuboidalRegion
     typedef typename Ttraits_::world_type::species_type species_type;
     typedef std::pair<position_type, position_type> position_pair_type;
 
+    // TODO why is this here? This the same as the method in the superclass 'Structure'
     identifier_type const& id() const
     {
         return base_type::id_;
@@ -144,8 +146,9 @@ class CuboidalRegion
         visitor(*this);
     }
 
-    CuboidalRegion(identifier_type const& id, shape_type const& shape)
-        : base_type(id, shape) {}
+    // Constructor
+    CuboidalRegion(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(id, sid, shape) {}
 };
 
 #endif /* CUBOIDAL_REGION_HPP */
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 72652575..af699c4c 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -16,7 +16,8 @@ class CylindricalSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type identifier_type;
+    typedef typename base_type::identifier_type         identifier_type;        // THis is just the name of the structure
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type shape_type;
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
@@ -225,8 +226,8 @@ class CylindricalSurface
         visitor(*this);
     }
 
-    CylindricalSurface(identifier_type const& id, shape_type const& shape)
-        : base_type(id, shape) {}
+    CylindricalSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(id, sid, shape) {}
 };
 
 #endif /* CYLINDRICAL_SURFACE_HPP */
diff --git a/EGFRDSimulatorFactory.hpp b/EGFRDSimulatorFactory.hpp
index 88cffb1b..625b692c 100644
--- a/EGFRDSimulatorFactory.hpp
+++ b/EGFRDSimulatorFactory.hpp
@@ -50,7 +50,7 @@ class EGFRDSimulatorFactory: public ParticleSimulatorFactory<Ttraits_>
         world->add_structure(
             boost::shared_ptr<cuboidal_region_type>(
                 new cuboidal_region_type(
-                    "world",
+                    "world", model.get_def_structure_type(),
                     typename cuboidal_region_type::shape_type(x, x))));
 
         BOOST_FOREACH (boost::shared_ptr<StructureType> st,
diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index 4f5e1a82..c677528c 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -39,7 +39,7 @@ void ParticleModel::add_structure_type(boost::shared_ptr<structure_type_type> co
 }
 
 // Get a structure type from the model
-boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structure_type_by_id(structure_id_type const& id) const
+boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structure_type_by_id(structure_type_id_type const& id) const
 {
     structure_type_map_type::const_iterator i(structure_type_map_.find(id));
     if (structure_type_map_.end() == i)
@@ -57,3 +57,10 @@ ParticleModel::structure_type_range ParticleModel::get_structure_types() const
         structure_type_iterator(structure_type_map_.begin(), structure_second_selector_type()),
         structure_type_iterator(structure_type_map_.end(), structure_second_selector_type()));
 }
+
+ParticleModel::structure_type_id_type ParticleModel::get_def_structure_type() const
+{
+//    return boost::shared_ptr<ParticleModel::structure_type_id_type>(default_structure_type_);
+    return default_structure_type_;
+}
+
diff --git a/ParticleModel.hpp b/ParticleModel.hpp
index 015eb222..2ada939c 100644
--- a/ParticleModel.hpp
+++ b/ParticleModel.hpp
@@ -13,10 +13,9 @@ class ParticleModel: public Model
     // defining shorthands for the used types
     typedef Model                                   base_type;
     typedef StructureType                           structure_type_type;
-    typedef structure_type_type::identifier_type    structure_id_type;
-    // TODO change to structure_type_id_type
+    typedef structure_type_type::identifier_type    structure_type_id_type;
 
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type_type> > structure_type_map_type;
+    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> > structure_type_map_type;
 
     typedef select_second<structure_type_map_type::value_type> structure_second_selector_type;
 
@@ -32,7 +31,7 @@ class ParticleModel: public Model
     virtual ~ParticleModel();
 
     // Gets a structure type
-    boost::shared_ptr<structure_type_type> get_structure_type_by_id(structure_id_type const& id) const;
+    boost::shared_ptr<structure_type_type> get_structure_type_by_id(structure_type_id_type const& id) const;
 
     // Add a structure type
     void add_structure_type(boost::shared_ptr<structure_type_type> const& structure);
@@ -40,9 +39,13 @@ class ParticleModel: public Model
     // Get all structure types in the model
     structure_type_range get_structure_types() const;
 
+    // Gets and sets the default structure_type
+    structure_type_id_type get_def_structure_type() const;
+
 /////// Member variables
 public:
     structure_type_map_type structure_type_map_;    // mapping: structure_type_id -> structure_type
+    structure_type_id_type  default_structure_type_;    // The id of the default structure_type ("world")
 };
 
 
diff --git a/ParticleSimulationStructure.hpp b/ParticleSimulationStructure.hpp
index 0fccbd33..0e40a08d 100644
--- a/ParticleSimulationStructure.hpp
+++ b/ParticleSimulationStructure.hpp
@@ -14,7 +14,9 @@ struct ParticleSimulationStructure: public Structure<typename Ttraits_::world_ty
 {
     typedef Ttraits_ traits_type;
     typedef Structure<typename traits_type::world_type::traits_type> base_type;
-    typedef typename base_type::identifier_type identifier_type;
+
+    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
 
     virtual ~ParticleSimulationStructure() {}
 
@@ -22,7 +24,8 @@ struct ParticleSimulationStructure: public Structure<typename Ttraits_::world_ty
 
     virtual void accept(MutativeStructureVisitor<traits_type> const&) = 0;
 
-    ParticleSimulationStructure(identifier_type const& id): base_type(id) {}
+    // Constructor
+    ParticleSimulationStructure(identifier_type const& id, structure_type_id_type const& sid): base_type(id, sid) {}
 };
 
 #endif /* PARTICLE_SIMULATION_STRUCTURE_HPP */
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 075c30e7..6077e303 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -15,7 +15,8 @@ class PlanarSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type identifier_type;
+    typedef typename base_type::identifier_type         identifier_type;        // This is just the name of the structure
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type shape_type;
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
@@ -214,8 +215,8 @@ class PlanarSurface
         visitor(*this);
     }
 
-    PlanarSurface(identifier_type const& id, shape_type const& shape)
-        : base_type(id, shape) {}
+    PlanarSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(id, sid, shape) {}
 };
 
 
diff --git a/Region.hpp b/Region.hpp
index 3c8acdde..32329ad2 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -18,22 +18,27 @@ template<typename Ttraits_>
 class Region: public ParticleSimulationStructure<Ttraits_>
 {
 public:
-    typedef ParticleSimulationStructure<Ttraits_> base_type;
-    typedef typename base_type::identifier_type identifier_type;
+    typedef ParticleSimulationStructure<Ttraits_>       base_type;
+    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
 
 public:
     virtual ~Region() {}
 
-    Region(identifier_type const& id): base_type(id) {}
+    // Constructor
+    Region(identifier_type const& id, structure_type_id_type const& sid): base_type(id, sid) {}
 };
 
+
+
 template<typename Ttraits_, typename Tshape_>
 class BasicRegionImpl: public Region<Ttraits_>
 {
 public:
     typedef Region<Ttraits_> base_type;
     typedef Tshape_ shape_type;
-    typedef typename base_type::identifier_type identifier_type;
+    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::length_type length_type;
     typedef typename base_type::position_type position_type;
 
@@ -53,7 +58,10 @@ class BasicRegionImpl: public Region<Ttraits_>
     virtual bool operator==(Structure<typename Ttraits_::world_type::traits_type> const& rhs) const
     {
         BasicRegionImpl const* _rhs(dynamic_cast<BasicRegionImpl const*>(&rhs));
-        return _rhs && base_type::id_ == rhs.id() && shape_ == _rhs->shape();
+        return _rhs &&
+               base_type::id_ == rhs.id() &&
+               base_type::sid_ == rhs.sid() &&
+               shape_ == _rhs->shape();
     }
 
     virtual std::size_t hash() const
@@ -65,7 +73,9 @@ class BasicRegionImpl: public Region<Ttraits_>
 #elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
         using boost::hash;
 #endif
-        return hash<identifier_type>()(base_type::id_) ^ hash<shape_type>()(shape());
+        return hash<identifier_type>()(base_type::id_) ^
+               hash<structure_type_id_type>()(base_type::sid_) ^
+               hash<shape_type>()(shape());
     }
 
     virtual std::string as_string() const
@@ -95,8 +105,8 @@ class BasicRegionImpl: public Region<Ttraits_>
         return shape_.position();
     }
 
-    BasicRegionImpl(identifier_type const& id, shape_type const& shape)
-        : base_type(id), shape_(shape) {}
+    BasicRegionImpl(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(id, sid), shape_(shape) {}
 
 protected:
     shape_type shape_;
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 5d60711e..23173e19 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -12,7 +12,8 @@ class SphericalSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type identifier_type;
+    typedef typename base_type::identifier_type         identifier_type;        // THis is just the name of the structure
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type shape_type;
     typedef typename base_type::rng_type rng_type;
     typedef typename base_type::position_type position_type;
@@ -113,8 +114,9 @@ class SphericalSurface
         visitor(*this);
     }
 
-    SphericalSurface(identifier_type const& id, shape_type const& shape)
-        : base_type(id, shape) {}
+    // The Constructor
+    SphericalSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(id, sid, shape) {}
 };
 
 #endif /* SPHERICAL_SURFACE_HPP */
diff --git a/Structure.hpp b/Structure.hpp
index f61cbb49..99b9881b 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -26,7 +26,8 @@ class Structure
     typedef typename traits_type::length_type               length_type;
     typedef typename traits_type::position_type             position_type;
     typedef typename traits_type::base_type::species_type   species_type;
-    typedef SpeciesTypeID                                   species_id_type;
+//    typedef SpeciesTypeID                                   species_id_type;
+    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
     typedef std::pair<position_type, length_type>           projected_type;
     typedef std::pair<position_type, position_type>         position_pair_type;
 
@@ -39,7 +40,7 @@ class Structure
     }
 
     // Get the StructureType of the structure
-    species_id_type const& sid() const
+    structure_type_id_type const& sid() const
     {
         if (!sid_)
         {
@@ -48,14 +49,14 @@ class Structure
         return sid_;
     }
 
-    species_id_type& sid()
+    structure_type_id_type& sid()
     {
         return sid_;
     }
 
     virtual bool operator==(Structure const& rhs) const
     {
-        return id_ == rhs.id();
+        return id_ == rhs.id() && sid_ == rhs.sid();
     }
 
     bool operator!=(Structure const& rhs) const
@@ -110,23 +111,25 @@ class Structure
 #elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
         using boost::hash;
 #endif
-        return hash<identifier_type>()(id_);
+        return hash<identifier_type>()(id_) ^
+               hash<structure_type_id_type>()(sid_);
     }
 
     virtual std::string as_string() const
     {
         std::ostringstream out;
-        out << "Structure(" << id() << ")";
+        out << "Structure(" << id() << ", " << sid() << ")";
         return out.str();
     }
 
-    Structure(identifier_type const& id)
-        : id_(id) {}
+    // Constructor
+    Structure(identifier_type const& id, structure_type_id_type const& sid)
+        : id_(id), sid_(sid) {}
 
 ////// Member variables
 protected:
-    identifier_type id_;        // id of the structure
-    species_id_type sid_;       // id of the structure_type of the structure
+    identifier_type         id_;        // id of the structure
+    structure_type_id_type  sid_;       // id of the structure_type of the structure
 };
 
 
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index 3cae81ac..f96d4078 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -16,6 +16,7 @@ struct StructureUtils
     typedef typename simulator_type::traits_type traits_type;
     typedef typename traits_type::world_type::position_type             position_type;
     typedef typename traits_type::world_type::length_type               length_type;
+    typedef typename traits_type::world_type::structure_id_type         structure_id_type;
     typedef typename traits_type::world_type::structure_type            structure_type;
     typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
     typedef typename simulator_type::surface_type               surface_type;
@@ -32,6 +33,7 @@ struct StructureUtils
  
     static planar_surface_type* create_planar_surface(
             structure_type_id_type const& sid,          // This refers to the structure type of the planar surface
+            structure_id_type   const& id,
             position_type const& corner,
             position_type const& unit_x,
             position_type const& unit_y,
@@ -51,21 +53,23 @@ struct StructureUtils
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
                                                 multiply(unit_y, half_ly)));
 
-        return new planar_surface_type(sid,
+        return new planar_surface_type(id, sid,
                                        plane_type(pos, unit_x, unit_y,
                                                   half_lx, half_ly));
     }
 
     static spherical_surface_type* create_spherical_surface(
             structure_type_id_type const& sid,
+            structure_id_type const& id,
             position_type const& pos,
             length_type const& radius)
     {
-        return new spherical_surface_type(sid, sphere_type(pos, radius));
+        return new spherical_surface_type(id, sid, sphere_type(pos, radius));
     }
 
     static cylindrical_surface_type* create_cylindrical_surface(
             structure_type_id_type const& sid,
+            structure_id_type const& id,
             position_type const& corner,
             length_type const& radius,
             position_type const& unit_z,
@@ -76,17 +80,18 @@ struct StructureUtils
         const length_type half_length(length / 2);
         const position_type pos(add(corner, multiply(unit_z, half_length)));
 
-        return new cylindrical_surface_type(sid,
+        return new cylindrical_surface_type(id, sid,
                 cylinder_type(pos, radius, unit_z, half_length));
     }
 
     static cuboidal_region_type* create_cuboidal_region(
             structure_type_id_type const& sid,
+            structure_id_type const& id,
             position_type const& corner,
             boost::array<length_type, 3> const& extent)
     {
         const boost::array<length_type, 3> half_extent(divide(extent, 2));
-        return new cuboidal_region_type(sid,
+        return new cuboidal_region_type(id, sid,
                 box_type(add(corner, half_extent),
                          create_vector<position_type>(1, 0, 0),
                          create_vector<position_type>(0, 1, 0),
diff --git a/Surface.hpp b/Surface.hpp
index 786629d5..08bd0db4 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -20,28 +20,36 @@ template<typename Ttraits_>
 class Surface: public ParticleSimulationStructure<Ttraits_>
 {
 public:
-    typedef ParticleSimulationStructure<Ttraits_> base_type;
-    typedef typename base_type::identifier_type identifier_type;
-    typedef typename base_type::length_type length_type;
+    typedef ParticleSimulationStructure<Ttraits_>       base_type;
+    typedef typename base_type::identifier_type         identifier_type;    // This is just a string
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
+    typedef typename base_type::length_type             length_type;
 
 public:
     virtual ~Surface() {}
 
-    Surface(identifier_type const& id): base_type(id) {}
+    // Constructor
+    Surface(identifier_type const& id, structure_type_id_type const& sid): base_type(id, sid) {}
 
     virtual length_type minimal_distance(length_type const& radius) const = 0;
 };
 
+
+
+
+
 template<typename Ttraits_, typename Tshape_>
 class BasicSurfaceImpl: public Surface<Ttraits_>
 {
 public:
     typedef Surface<Ttraits_> base_type;
     typedef Tshape_ shape_type;
-    typedef typename base_type::identifier_type identifier_type;
-    typedef typename base_type::length_type length_type;
-    typedef typename base_type::position_type position_type;
-    typedef std::pair<position_type, length_type> projected_type;
+
+    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
+    typedef typename base_type::length_type             length_type;
+    typedef typename base_type::position_type           position_type;
+    typedef std::pair<position_type, length_type>       projected_type;
 
 public:
     virtual ~BasicSurfaceImpl() {}
@@ -59,7 +67,10 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     virtual bool operator==(Structure<typename Ttraits_::world_type::traits_type> const& rhs) const
     {
         BasicSurfaceImpl const* _rhs(dynamic_cast<BasicSurfaceImpl const*>(&rhs));
-        return _rhs && base_type::id_ == rhs.id() && shape_ == _rhs->shape();
+        return _rhs &&
+               base_type::id_ == rhs.id() &&
+               base_type::sid_ == rhs.sid() &&
+               shape_ == _rhs->shape();
     }
     
     virtual std::size_t hash() const
@@ -71,7 +82,9 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
 #elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
         using boost::hash;
 #endif
-        return hash<identifier_type>()(base_type::id_) ^ hash<shape_type>()(shape());
+        return hash<identifier_type>()(base_type::id_) ^
+               hash<structure_type_id_type>()(base_type::sid_) ^
+               hash<shape_type>()(shape());
     }
 
     virtual std::string as_string() const
@@ -101,8 +114,9 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return shape_.position();
     }
 
-    BasicSurfaceImpl(identifier_type const& id, shape_type const& shape)
-        : base_type(id), shape_(shape) {}
+    // Constructor
+    BasicSurfaceImpl(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(id, sid), shape_(shape) {}
 
 protected:
     shape_type shape_;
diff --git a/World.hpp b/World.hpp
index 3ddc4235..f35508cb 100644
--- a/World.hpp
+++ b/World.hpp
@@ -47,8 +47,8 @@ struct WorldTraitsBase
     // TODO add structure_type_id_type?
 //    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
     typedef std::string                                     structure_id_type;  // identifier type for structures
+//    typedef StructureID                                     structure_id_type;
     typedef SerialIDGenerator<StructureID>                  structure_id_generator;
-    // typedef SpeciesTypeID                                   structure_id_type;
     typedef Particle<length_type, D_type, species_id_type,
                      StructureID>                           particle_type;      // type for particles, NOTE why is there no v_type here?
 
@@ -244,6 +244,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
     // TODO Add the default structure of the default structure_type here?
 
+    virtual structure_id_type get_def_structure_id() const
+    {   return default_structure_id_;
+    }
+
     // To add new particles
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
diff --git a/binding/CuboidalRegion.hpp b/binding/CuboidalRegion.hpp
index 01cd19ea..6a03414a 100644
--- a/binding/CuboidalRegion.hpp
+++ b/binding/CuboidalRegion.hpp
@@ -14,6 +14,7 @@ inline boost::python::objects::class_base register_cuboidal_region_class(char co
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::identifier_type,
+                       typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape,
diff --git a/binding/CylindricalSurface.hpp b/binding/CylindricalSurface.hpp
index 77a2eb2d..0909037d 100644
--- a/binding/CylindricalSurface.hpp
+++ b/binding/CylindricalSurface.hpp
@@ -14,6 +14,7 @@ inline boost::python::objects::class_base register_cylindrical_surface_class(cha
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::identifier_type,
+                       typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
diff --git a/binding/ParticleModel.hpp b/binding/ParticleModel.hpp
index 1cd4b9b3..9484d90b 100644
--- a/binding/ParticleModel.hpp
+++ b/binding/ParticleModel.hpp
@@ -15,6 +15,7 @@ inline void register_particle_model_class(char const* name)
     class_<impl_type, bases<typename impl_type::base_type>, boost::noncopyable>(name)
         .def("add_structure_type", &impl_type::add_structure_type)
         .def("get_structure_type_by_id", &impl_type::get_structure_type_by_id)
+        .def("get_def_structure_type", &impl_type::get_def_structure_type)
         .add_property("structure_types",
                 peer::util::range_from_range<
                     typename impl_type::structure_type_range,
diff --git a/binding/PlanarSurface.hpp b/binding/PlanarSurface.hpp
index 1a3b1fc3..4c6ec6af 100644
--- a/binding/PlanarSurface.hpp
+++ b/binding/PlanarSurface.hpp
@@ -14,6 +14,7 @@ inline boost::python::objects::class_base register_planar_surface_class(char con
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::identifier_type,
+                       typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
diff --git a/binding/SphericalSurface.hpp b/binding/SphericalSurface.hpp
index 14e41adf..6b20ee20 100644
--- a/binding/SphericalSurface.hpp
+++ b/binding/SphericalSurface.hpp
@@ -14,6 +14,7 @@ inline boost::python::objects::class_base register_spherical_surface_class(char
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::identifier_type,
+                       typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 6b3238f8..bafd2a10 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -23,12 +23,12 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .add_property("sid",
             make_function(
                 &peer::util::reference_accessor_wrapper<
-                    impl_type, typename impl_type::species_id_type,
+                    impl_type, typename impl_type::structure_type_id_type,
                     &impl_type::sid,
                     &impl_type::sid>::get,
                 return_value_policy<return_by_value>()),
             &peer::util::reference_accessor_wrapper<
-                impl_type, typename impl_type::species_id_type,
+                impl_type, typename impl_type::structure_type_id_type,
                 &impl_type::sid,
                 &impl_type::sid>::set)
         .def("random_position", &impl_type::random_position)

From ae3c9062f527258397523b614649f870ffc7cd04 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 6 Mar 2012 19:24:42 +0100
Subject: [PATCH 0661/1541] Oops. Particle should of course be defined here.

---
 binding/binding_common.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index 729c8d53..ec9e2a07 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -46,6 +46,7 @@ typedef ::already_exists AlreadyExists;
 typedef ::illegal_state IllegalState;
 typedef ::GSLRandomNumberGenerator GSLRandomNumberGenerator;
 typedef ::CyclicWorldTraits<Real, Real> WorldTraits;            // parameterize the World traits here -> determines many types!!
+typedef WorldTraits::particle_type      Particle;
 //typedef WorldTraits::structure_id_type  StructureID;
 typedef WorldTraits::species_id_type    SpeciesID;
 typedef WorldTraits::species_type       SpeciesInfo;

From 98a7b4812bb38a99a23d80f8506eaff9a85b3d81 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 6 Mar 2012 19:25:03 +0100
Subject: [PATCH 0662/1541] temp fix as long as id of structure is a string

---
 World.hpp |  3 ++-
 model.py  | 16 +++++++++++-----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/World.hpp b/World.hpp
index f35508cb..aae28856 100644
--- a/World.hpp
+++ b/World.hpp
@@ -245,7 +245,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // TODO Add the default structure of the default structure_type here?
 
     virtual structure_id_type get_def_structure_id() const
-    {   return default_structure_id_;
+    {   //   return default_structure_id_;
+        return "world";
     }
 
     // To add new particles
diff --git a/model.py b/model.py
index 47516c7d..941e3b5e 100644
--- a/model.py
+++ b/model.py
@@ -24,13 +24,15 @@
 
 # Define _gfrd docstrings here, much easier to format than in C++.
 _gfrd.create_cuboidal_region.__doc__ = \
-"""create_cuboidal_region(sid, corner, diagonal)
+"""create_cuboidal_region(sid, id, corner, diagonal)
 
 Create and return a new cuboidal Region.
 
 Arguments:
     - sid
         the structure type of the cuboidal region.
+    - id
+        the name of the structure
     - corner
         the point [x, y, z] of the cuboidal Region closest to
         [0, 0, 0]. Units: [meters, meters, meters]
@@ -42,13 +44,15 @@
 """
 
 _gfrd.create_cylindrical_surface.__doc__ = \
-"""create_cylindrical_surface(sid, corner, radius, orientation, length)
+"""create_cylindrical_surface(sid, id, corner, radius, orientation, length)
 
 Create and return a new cylindrical Surface.
 
 Arguments:
     - sid
         the structure type of the cylindrical surface.
+    - id
+        the name of the structure
     - corner
         the point [x, y, z] on the axis of the cylinder closest to 
         [0, 0, 0]. Units: [meters, meters, meters]
@@ -66,13 +70,15 @@
 """
 
 _gfrd.create_planar_surface.__doc__ = \
-"""create_planar_surface(sid, corner, unit_x, unit_y, length_x, length_y)
+"""create_planar_surface(sid, id, corner, unit_x, unit_y, length_x, length_y)
 
 Create and return a new planar Surface.
 
 Arguments:
     - sid
         the structure type of the planar surface.
+    - id
+        the name of the structure
     - corner
         the point [x, y, z] on the plane closest to [0, 0, 0]. Units: 
         [meters, meters, meters]
@@ -174,8 +180,8 @@ def __init__(self, world_size):
         _gfrd.ParticleModel.add_structure_type(self, structure_type)
         
         x = numpy.repeat(world_size / 2, 3)
-        region = _gfrd.CuboidalRegion('world', _gfrd.Box(x, x))
-        region.sid = structure_type.id
+        region = _gfrd.CuboidalRegion('world', structure_type, _gfrd.Box(x, x))
+#        region.sid = structure_type.id
         
         self.add_structure(region)
 

From 2ccf9c95671f6446869d77f3a034d1d62884cb5b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 7 Mar 2012 12:21:16 +0100
Subject: [PATCH 0663/1541] namechange in ParticleModel for clarity

---
 EGFRDSimulatorFactory.hpp |  2 +-
 ParticleModel.cpp         | 18 ++++++++----------
 ParticleModel.hpp         |  4 ++--
 binding/ParticleModel.hpp |  2 +-
 4 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/EGFRDSimulatorFactory.hpp b/EGFRDSimulatorFactory.hpp
index 625b692c..ef3933e8 100644
--- a/EGFRDSimulatorFactory.hpp
+++ b/EGFRDSimulatorFactory.hpp
@@ -50,7 +50,7 @@ class EGFRDSimulatorFactory: public ParticleSimulatorFactory<Ttraits_>
         world->add_structure(
             boost::shared_ptr<cuboidal_region_type>(
                 new cuboidal_region_type(
-                    "world", model.get_def_structure_type(),
+                    "world", model.get_def_structure_type_id(),
                     typename cuboidal_region_type::shape_type(x, x))));
 
         BOOST_FOREACH (boost::shared_ptr<StructureType> st,
diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index c677528c..70982ef6 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -20,22 +20,20 @@ ParticleModel::~ParticleModel()
 {
 }
 
-// TODO Get default structure type?
-
 // Add a structure type to the model
-void ParticleModel::add_structure_type(boost::shared_ptr<structure_type_type> const& structure)
+void ParticleModel::add_structure_type(boost::shared_ptr<structure_type_type> const& structure_type)
 {
     // std::pair<structure_type_map_type::iterator, bool> r(
-    //     structure_type_map_.insert(std::make_pair(structure->id(), structure)));
+    //     structure_type_map_.insert(std::make_pair(structure_type->id(), structure_type)));
     // if (!r.second)
     // {
     //     throw already_exists(
-    //         (boost::format("structure id \"%s\" is already used by %s") %
-    //             structure->id() %
+    //         (boost::format("structure_type id \"%s\" is already used by %s") %
+    //             structure_type->id() %
     //             boost::lexical_cast<std::string>(*(*(r.first)).second)).str());
     // }
-    structure->bind_to_model(this, species_type_id_generator_());
-    structure_type_map_.insert(std::make_pair(structure->id(), structure));
+    structure_type->bind_to_model(this, species_type_id_generator_());
+    structure_type_map_.insert(std::make_pair(structure_type->id(), structure_type));
 }
 
 // Get a structure type from the model
@@ -58,9 +56,9 @@ ParticleModel::structure_type_range ParticleModel::get_structure_types() const
         structure_type_iterator(structure_type_map_.end(), structure_second_selector_type()));
 }
 
-ParticleModel::structure_type_id_type ParticleModel::get_def_structure_type() const
+ParticleModel::structure_type_id_type ParticleModel::get_def_structure_type_id() const
 {
 //    return boost::shared_ptr<ParticleModel::structure_type_id_type>(default_structure_type_);
-    return default_structure_type_;
+    return default_structure_type_id_;
 }
 
diff --git a/ParticleModel.hpp b/ParticleModel.hpp
index 2ada939c..a72c1bdc 100644
--- a/ParticleModel.hpp
+++ b/ParticleModel.hpp
@@ -40,12 +40,12 @@ class ParticleModel: public Model
     structure_type_range get_structure_types() const;
 
     // Gets and sets the default structure_type
-    structure_type_id_type get_def_structure_type() const;
+    structure_type_id_type get_def_structure_type_id() const;
 
 /////// Member variables
 public:
     structure_type_map_type structure_type_map_;    // mapping: structure_type_id -> structure_type
-    structure_type_id_type  default_structure_type_;    // The id of the default structure_type ("world")
+    structure_type_id_type  default_structure_type_id_;    // The id of the default structure_type ("world")
 };
 
 
diff --git a/binding/ParticleModel.hpp b/binding/ParticleModel.hpp
index 9484d90b..43f247d8 100644
--- a/binding/ParticleModel.hpp
+++ b/binding/ParticleModel.hpp
@@ -15,7 +15,7 @@ inline void register_particle_model_class(char const* name)
     class_<impl_type, bases<typename impl_type::base_type>, boost::noncopyable>(name)
         .def("add_structure_type", &impl_type::add_structure_type)
         .def("get_structure_type_by_id", &impl_type::get_structure_type_by_id)
-        .def("get_def_structure_type", &impl_type::get_def_structure_type)
+        .def("get_def_structure_type_id", &impl_type::get_def_structure_type_id)
         .add_property("structure_types",
                 peer::util::range_from_range<
                     typename impl_type::structure_type_range,

From 65fde1bdc69145934f87c7d1129938cc1c3ba4d6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 7 Mar 2012 14:04:53 +0100
Subject: [PATCH 0664/1541] Make the default structureType in the C++
 constructor of the ParticleModel instead of python part.

---
 ParticleModel.cpp |  3 +++
 model.py          | 14 ++++++++------
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index 70982ef6..9aee3a03 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -14,6 +14,9 @@
 ParticleModel::ParticleModel()
 {
     // TODO add default structure_type for the bulk?
+    boost::shared_ptr<ParticleModel::structure_type_type> default_structure_type(new StructureType());
+    add_structure_type(default_structure_type);
+    default_structure_type_id_ = default_structure_type->id();
 }
 
 ParticleModel::~ParticleModel()
diff --git a/model.py b/model.py
index 941e3b5e..ef7a62c6 100644
--- a/model.py
+++ b/model.py
@@ -175,14 +175,16 @@ def __init__(self, world_size):
         # Particles of a Species whose Surface is not specified will be 
         # added to the "world". Dimensions don't matter, except for 
         # visualization.
-        structure_type = _gfrd.StructureType()
-        structure_type['name'] = 'world'
-        _gfrd.ParticleModel.add_structure_type(self, structure_type)
-        
+#        structure_type = _gfrd.StructureType()
+#        structure_type['name'] = 'world'
+#        _gfrd.ParticleModel.add_structure_type(self, structure_type)
+
+        def_structure_type_id = _gfrd.ParticleModel.get_def_structure_type_id(self)
+        structure_type        = _gfrd.ParticleModel.get_structure_type_by_id(self, def_structure_type_id)
         x = numpy.repeat(world_size / 2, 3)
+
         region = _gfrd.CuboidalRegion('world', structure_type, _gfrd.Box(x, x))
-#        region.sid = structure_type.id
-        
+#        region.sid = structure_type.id       
         self.add_structure(region)
 
     def add_structure(self, structure):

From b75c22eb7110ffd3ddf3db781125f080696f040e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 7 Mar 2012 14:44:56 +0100
Subject: [PATCH 0665/1541] Changed error message in ParticleModel

---
 ParticleModel.cpp | 2 +-
 ParticleModel.hpp | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index 9aee3a03..8f8342e4 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -45,7 +45,7 @@ boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structu
     structure_type_map_type::const_iterator i(structure_type_map_.find(id));
     if (structure_type_map_.end() == i)
     {
-        throw not_found(boost::lexical_cast<std::string>(id));
+        throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(id) + ")");
     }
 
     return (*i).second;
diff --git a/ParticleModel.hpp b/ParticleModel.hpp
index a72c1bdc..9afd4023 100644
--- a/ParticleModel.hpp
+++ b/ParticleModel.hpp
@@ -34,7 +34,7 @@ class ParticleModel: public Model
     boost::shared_ptr<structure_type_type> get_structure_type_by_id(structure_type_id_type const& id) const;
 
     // Add a structure type
-    void add_structure_type(boost::shared_ptr<structure_type_type> const& structure);
+    void add_structure_type(boost::shared_ptr<structure_type_type> const& structure_type);
 
     // Get all structure types in the model
     structure_type_range get_structure_types() const;
@@ -44,8 +44,8 @@ class ParticleModel: public Model
 
 /////// Member variables
 public:
-    structure_type_map_type structure_type_map_;    // mapping: structure_type_id -> structure_type
-    structure_type_id_type  default_structure_type_id_;    // The id of the default structure_type ("world")
+    structure_type_map_type structure_type_map_;            // mapping: structure_type_id -> structure_type
+    structure_type_id_type  default_structure_type_id_;     // The id of the default structure_type ("world")
 };
 
 

From 0bda36ffd5f365d540af44e32975acef6c0dce93 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 15 Feb 2012 15:11:09 +0100
Subject: [PATCH 0666/1541] changed SpeciesInfo to hold a structure_type_id
 instead of a structure_id

---
 SpeciesInfo.hpp             | 42 ++++++++++++++++++-------------------
 World.hpp                   |  9 +++++++-
 binding/SpeciesInfo.hpp     | 16 +++++++-------
 doc/interface_functions.tex | 16 +++++++-------
 gfrdbase.py                 | 15 +++++++++++--
 model.py                    |  4 ++--
 6 files changed, 60 insertions(+), 42 deletions(-)

diff --git a/SpeciesInfo.hpp b/SpeciesInfo.hpp
index 208bc742..b0382bb5 100644
--- a/SpeciesInfo.hpp
+++ b/SpeciesInfo.hpp
@@ -6,24 +6,24 @@
 #include <ostream>
 #include "Defs.hpp"
 
-template<typename Tid_, typename TD_, typename Tlen_, typename Tstructure_id_>
+template<typename Tid_, typename TD_, typename Tlen_, typename Tstructure_type_id_>
 struct SpeciesInfo
 // Unclear if SpeciesInfo replaces the Species when using a World or not
 // (Species itself holds very little information, SpeciesInfo hold info that is relevant in a spatial system)
 {
     // defining shorthands for used types
-    typedef Tid_            identifier_type;        // This is the SpeciesTypeID
-    typedef TD_             D_type;
-    typedef TD_             v_type;
-    typedef Tlen_           length_type;
-    typedef Tstructure_id_  structure_id_type;      // TODO should be structure_type_id_type
+    typedef Tid_                identifier_type;        // This is the SpeciesTypeID
+    typedef TD_                 D_type;
+    typedef TD_                 v_type;
+    typedef Tlen_               length_type;
+    typedef Tstructure_type_id_ structure_type_id_type; // The structure type that the species lives on
 
     // constructors
     SpeciesInfo() {}
 
     SpeciesInfo(identifier_type const& id, D_type const& D = 0., 
-                length_type const& r = 0., structure_id_type const& s = "", v_type const& v = 0.) 
-        : id_(id), diffusion_coef_(D), drift_velocity_(v), radius_(r), structure_id_(s) {}
+                length_type const& r = 0., structure_type_id_type const& s = NULL, v_type const& v = 0.) 
+        : id_(id), diffusion_coef_(D), drift_velocity_(v), radius_(r), structure_type_id_(s) {}
 
 
 
@@ -45,14 +45,14 @@ struct SpeciesInfo
     }
 
     // Get the id of the structure type it lives on
-    structure_id_type const& structure_id() const
+    structure_type_id_type const& structure_type_id() const
     {
-        return structure_id_;
+        return structure_type_id_;
     }
 
-    structure_id_type& structure_id()
+    structure_type_id_type& structure_type_id()
     {
-        return structure_id_;
+        return structure_type_id_;
     }
 
     // Get the diffusion constant
@@ -84,7 +84,7 @@ struct SpeciesInfo
                diffusion_coef_ == rhs.D() &&
                drift_velocity_ == rhs.v() &&
                radius_ == rhs.radius() &&
-               structure_id_ == rhs.structure_id();
+               structure_type_id_ == rhs.structure_type_id();
     }
 
     bool operator!=(SpeciesInfo const& rhs) const
@@ -94,22 +94,22 @@ struct SpeciesInfo
 
 /////// Member variables
 private:
-    identifier_type     id_;
-    D_type              diffusion_coef_;
-    v_type              drift_velocity_;
-    length_type         radius_;
-    structure_id_type   structure_id_;      // The structure type that the particle lives on
+    identifier_type         id_;
+    D_type                  diffusion_coef_;
+    v_type                  drift_velocity_;
+    length_type             radius_;
+    structure_type_id_type  structure_type_id_;      // The structure type that the particle lives on
 };
 
 
 //////// Inline functions
-template<typename Tchar_, typename Ttraits_, typename Tid_, typename TD_, typename Tlen_, typename Tstructure_id_>
+template<typename Tchar_, typename Ttraits_, typename Tid_, typename TD_, typename Tlen_, typename Tstructure_type_id_>
 inline std::basic_ostream<Tchar_, Ttraits_>&
-operator<<(std::basic_ostream<Tchar_, Ttraits_>& strm, const SpeciesInfo<Tid_, TD_, Tlen_, Tstructure_id_>& s)
+operator<<(std::basic_ostream<Tchar_, Ttraits_>& strm, const SpeciesInfo<Tid_, TD_, Tlen_, Tstructure_type_id_>& s)
 // Allows for printing of the object
 // -> provides a stream of 'attributename : attribute_value' pairs.
 {
-    strm << "SpeciesInfo(id=" << s.id() << ", D=" << s.D() << ", v=" << s.v() << ", radius=" << s.radius() << ", surface=" << s.structure_id() << ")";
+    strm << "SpeciesInfo(id=" << s.id() << ", D=" << s.D() << ", v=" << s.v() << ", radius=" << s.radius() << ", structure_type=" << s.structure_type_id() << ")";
     return strm;
 }
 
diff --git a/World.hpp b/World.hpp
index aae28856..b0e9bbad 100644
--- a/World.hpp
+++ b/World.hpp
@@ -52,7 +52,8 @@ struct WorldTraitsBase
     typedef Particle<length_type, D_type, species_id_type,
                      StructureID>                           particle_type;      // type for particles, NOTE why is there no v_type here?
 
-    typedef SpeciesInfo<species_id_type, D_type, length_type, structure_id_type>    species_type;  // information associated with the species
+    typedef SpeciesInfo<species_id_type, D_type,
+                        length_type, structure_type_id_type>    species_type;  // information associated with the species
     typedef Vector3<length_type>                                                    point_type;
     typedef typename particle_type::shape_type::position_type                       position_type;
     typedef GSLRandomNumberGenerator                                                rng_type;
@@ -249,6 +250,11 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return "world";
     }
 
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return default_structure_type_id_;
+    }
+
     // To add new particles
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
@@ -401,6 +407,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     per_species_particle_id_set particle_pool_;
     structure_id_generator      structidgen_;
     StructureID                 default_structure_id_;
+    structure_type_id_type      default_structure_type_id_;
 };
 
 #endif /* WORLD_HPP */
diff --git a/binding/SpeciesInfo.hpp b/binding/SpeciesInfo.hpp
index 64a342f9..f11b882d 100644
--- a/binding/SpeciesInfo.hpp
+++ b/binding/SpeciesInfo.hpp
@@ -15,7 +15,7 @@ inline boost::python::objects::class_base register_species_info_class(
 
     return class_<impl_type>("SpeciesInfo",
             init<>() )
-        .def(init<typename impl_type::identifier_type, typename impl_type::length_type, typename impl_type::D_type, typename impl_type::structure_id_type, typename impl_type::v_type>())
+        .def(init<typename impl_type::identifier_type, typename impl_type::length_type, typename impl_type::D_type, typename impl_type::structure_type_id_type, typename impl_type::v_type>())
         .add_property("id",
             make_function(&impl_type::id,
                 return_value_policy<return_by_value>()))
@@ -30,17 +30,17 @@ inline boost::python::objects::class_base register_species_info_class(
                 impl_type, typename impl_type::length_type,
                 &impl_type::radius,
                 &impl_type::radius>::set)
-        .add_property("structure_id",
+        .add_property("structure_type_id",
             make_function(
                 &peer::util::reference_accessor_wrapper<
-                    impl_type, typename impl_type::structure_id_type,
-                    &impl_type::structure_id,
-                    &impl_type::structure_id>::get,
+                    impl_type, typename impl_type::structure_type_id_type,
+                    &impl_type::structure_type_id,
+                    &impl_type::structure_type_id>::get,
                 return_value_policy<return_by_value>()),
             &peer::util::reference_accessor_wrapper<
-                impl_type, typename impl_type::structure_id_type,
-                &impl_type::structure_id,
-                &impl_type::structure_id>::set)
+                impl_type, typename impl_type::structure_type_id_type,
+                &impl_type::structure_type_id,
+                &impl_type::structure_type_id>::set)
         .add_property("D",
             make_function(
                 &peer::util::reference_accessor_wrapper<
diff --git a/doc/interface_functions.tex b/doc/interface_functions.tex
index 985ec279..c9335ed0 100644
--- a/doc/interface_functions.tex
+++ b/doc/interface_functions.tex
@@ -453,7 +453,7 @@ \subsubsection{Obtaining information about particles and species}
               to the user:
                    * SpeciesInfo.id
                    * SpeciesInfo.radius
-                   * SpeciesInfo.structure_id
+                   * SpeciesInfo.structure_type_id
                    * SpeciesInfo.D
                    * SpeciesInfo.v
                 
@@ -1224,28 +1224,28 @@ \subsection{SpeciesInfo}
 typedef TD_ 	D_type
 typedef TD_ 	v_type
 typedef Tlen_ 	length_type
-typedef Tstructure_id_ 	structure_id_type
+typedef Tstructure_type_id_ 	structure_type_id_type
 
 Public Member Functions
 identifier_type const & 	id () const
 length_type const & 	radius () const
 length_type & 	radius ()
-structure_id_type const & 	structure_id () const
-structure_id_type & 	structure_id ()
+structure_type_id_type const & 	structure_type_id () const
+structure_type_id_type & 	structure_type_id ()
 D_type const & 	D () const
 D_type & 	D ()
 v_type const & 	v () const
 v_type & 	v ()
 bool 	operator== (SpeciesInfo const &rhs) const
 bool 	operator!= (SpeciesInfo const &rhs) const
- 	SpeciesInfo (identifier_type const &id, D_type const &D=0., length_type const &r=0., structure_id_type const &s="", v_type const &v=0.)
+ 	SpeciesInfo (identifier_type const &id, D_type const &D=0., length_type const &r=0., structure_type_id_type const &s= NULL, v_type const &v=0.)
 
-template<typename Tid_, typename TD_, typename Tlen_, typename Tstructure_id_>
-struct SpeciesInfo< Tid_, TD_, Tlen_, Tstructure_id_ >
+template<typename Tid_, typename TD_, typename Tlen_, typename Tstructure_type_id_>
+struct SpeciesInfo< Tid_, TD_, Tlen_, Tstructure_type_id_ >
 \end{verbatim}
 
 \subsection{Particle}
 
 The particle information is held by a class in the C++ code. A single particle is 
 
-\end{document}
\ No newline at end of file
+\end{document}
diff --git a/gfrdbase.py b/gfrdbase.py
index aebbec4e..7505f308 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -157,9 +157,20 @@ def create_world(m, matrix_size=10):
 
     world = _gfrd.World(world_size, matrix_size)
 
+#    for st in m.structure_types:
+#        try:
+#            structure = st["structure"]
+#        except _gfrd.NotFound:
+#            structure = "world"
+#        world.add_structure_type(
+#            _gfrd.SpeciesInfo(st.id, 
+#                              float(st["D"]), 
+#                              float(st["radius"]), 
+#                              structure,
+#                              float(st["v"])))
     for st in m.species_types:
         try:
-            structure = st["structure"]
+            structure = st["structure_type"]     # FIXME
         except _gfrd.NotFound:
             structure = "world"
         world.add_species(
@@ -320,7 +331,7 @@ def get_species(self):
               to the user:
                    * SpeciesInfo.id
                    * SpeciesInfo.radius
-                   * SpeciesInfo.structure_id
+                   * SpeciesInfo.structure_type_id
                    * SpeciesInfo.D
                    * SpeciesInfo.v
                 
diff --git a/model.py b/model.py
index ef7a62c6..55522d2f 100644
--- a/model.py
+++ b/model.py
@@ -115,7 +115,7 @@
 
 # Species is just a function, not a class. It seems to be a frontend to the
 # constructor of _gfrd.SpeciesType
-def Species(name, D, radius=0, structure="world", drift=0):
+def Species(name, D, radius=0, structure_type="world", drift=0):
     """Define a new Species (in/on a specific Region or Surface).
 
     Arguments:
@@ -147,7 +147,7 @@ def Species(name, D, radius=0, structure="world", drift=0):
     st["D"] = str(D)
     st["v"] = str(drift)
     st["radius"] = str(radius)
-    st["structure"] = structure
+    st["structure_type"] = structure_type
     return st
 
 

From 01f1ca05436b73c401285d3cf9a9ad38a27be587 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Fri, 9 Mar 2012 11:01:47 +0100
Subject: [PATCH 0667/1541] Fixed "administrative" bug in
 GreensFunction2DRadAbs which made it function incorrectly.

Had to do with bookkeeping of the location of the last root.
Scanning for the roots makes it impossible to calculate the xth
root without knowing all previous roots i<x.
The algorithm previously incorrectly did assume that this was
possible. Now fixed.

When root table is expanded, all roots are calculated for the
length of the table. This perhaps leaves room for optimization,
because roots are sometimes calculated based upon estimated #
terms necessary.

MW.
---
 GreensFunction2DRadAbs.cpp | 178 +++++++++++++++++++++++++------------
 GreensFunction2DRadAbs.hpp |   4 +-
 greens_functions.cpp       |   3 +-
 shells.py                  |   5 +-
 4 files changed, 130 insertions(+), 60 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 15fae625..ed3900e2 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -379,6 +379,11 @@ GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
 // Root finding algorithm for alpha function. 
 // Roots (y=0) are necessary to calculate 
 // Modified by wehrens@amolf.nl. nov, 2011
+//
+// Note mar 2012:
+// The modified root finding algorithm can only work if the roots are calculated
+// in a "chronological" sequence (i.e. i = 0, i = 1, i = 2 etc). Therefore roots
+// are now all calculated immediately when the roots-table is expanded.
 // =============================================================================
 
 // Scans for next interval where a sign change is observed, and thus where a 
@@ -616,60 +621,82 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
     
     // # "Administration"
 
-    // Gets the line of table that corresponds to order (n),     
+    // Equals reading/writing to/from alphaTable to reading/writing from/to to 
+    // this->alphaTable[n]; n being the order of the Bessel function. 
+    // (Funky pointer operations.)
     RealVector& alphaTable( this->alphaTable[n] );		        
     
     // Gets it's size 
     const RealVector::size_type oldSize( alphaTable.size() );	
+
+    // # Expansion of root table
     
-    // Resizes and fills with zeroes if the vector is too small
+    // If doesn't contain requested value, expand table until value
     if( i >= oldSize )
     {
+        // Expand the table, temporarily fill with zeroes
         alphaTable.resize( i+1, 0 );	
-    }
-
-    // # Calculating the root
 
-    // Only calculates the root is this has not been done already
-    if (alphaTable[i] == 0)		
-    {        
+        // # Calculating the necessary roots to expand the table
+        for(unsigned int j = oldSize; j <= i; j++)
+        {
+            std::cerr << "\n\nSearching for j="<<j<<",n="<<n<<".\n";
+            if (alphaTable[j] != 0)		
+            {
+                std::cerr << "Error: tried accessing root that's not 0. Didn't search.. \n";
+                std::cerr << "       i = " << i << ", oldSize = " << oldSize << ", j = " << j << " \n";                
+            }  else   
+            {
+                // Method 1. SCANNING. If the roots are not expected to lie close enough 
+                // to the estimate, use the "scanning" procedure to find an interval 
+                // that contains a root. (More robust method.)
+                //      If it is established that we can use method 2, 
+                // alpha_x_scan_table_[n] will contain a value < 0.
+                if (alpha_x_scan_table_[n] >= 0)
+                {		        
+                    std::cerr << "Scanning.\n";
+                
+                    // ### Gets estimate of interval by sign-change-searching
+                    //      high and low are the return-values of GiveRootInterval.
+                    GiveRootInterval(low, high, n);	        
+
+                    std::cerr << "Called getAlphaRoot(low="<<low<<",high="<< high<<",n="<< n<<").\n";
+                    
+                    // ### Finds the root using the GSL rootfinder
+                    current_root_ = getAlphaRoot(low, high, n);
+                    
+                    // ### Puts the found root in the table.
+	                alphaTable[j]= current_root_;
+	                		    
+	                // Check if we can use method 2 for next roots
+	                decideOnMethod2(n, j);		    
+                }
+                // Method 2. ASSUMING ROOTS AT ~FIXED INTERVAL. If next root is expected 
+                // to lie at distance close enough to estimated distance the root finder 
+                // can be called using a simple estimated interval.
+                else 
+                {
+                    std::cerr << "Estimating.\n";                
+                
+                    // ### Get interval by simple extrapolation
+                    GiveRootIntervalSimple(low, high, n, j);	        
+                
+                    std::cerr << "Called getAlphaRoot(low="<<low<<",high="<< high<<",n="<< n<<").\n";
+                
+                    // ### Finds the root using the GSL rootfinder
+                    current_root_ = getAlphaRoot(low, high, n);
+
+                    // ### Puts the found root in the table.
+	                alphaTable[j] = current_root_;		    
+                }
+                std::cerr << "Found root:" << current_root_ << "\n";
+            }
+        }
     
-        // Method 1. SCANNING. If the roots are not expected to lie close enough 
-        // to the estimate, use the "scanning" procedure to find an interval 
-        // that contains a root. (More robust method.)
-        //      If it is established that we can use method 2, 
-        // alpha_x_scan_table_[n] will contain a value < 0.
-	    if (alpha_x_scan_table_[n] >= 0)
-	    {		        
-	        // ### Gets estimate of interval by sign-change-searching
-	        //      high and low are the return-values of GiveRootInterval.
-	        GiveRootInterval(low, high, n);	        
-	        
-	        // ### Finds the root using the GSL rootfinder
-            current_root_ = getAlphaRoot(low, high, n);
-            
-            // ### Puts the found root in the table.
-		    alphaTable[i]= current_root_;
-		    		    
-		    // Check if we can use method 2 for next roots
-		    decideOnMethod2(n, i);		    
-	    }
-	    // Method 2. ASSUMING ROOTS AT ~FIXED INTERVAL. If next root is expected 
-	    // to lie at distance close enough to estimated distance the root finder 
-	    // can be called using a simple estimated interval.
-	    else 
-	    {
-            // ### Get interval by simple extrapolation
-	        GiveRootIntervalSimple(low, high, n, i);	        
-	    
-	        // ### Finds the root using the GSL rootfinder
-            current_root_ = getAlphaRoot(low, high, n);
-
-            // ### Puts the found root in the table.
-		    alphaTable[i] = current_root_;		    
-	    }
     }
     
+    std::cerr << "Return root (n,i) = " << alphaTable[i] << "(n=" << n << ",i=" << i << ")\n";   
+    
     return alphaTable[i];
 
 }
@@ -784,21 +811,27 @@ GreensFunction2DRadAbs::p_survival_table( const Real t,
 {
 	Real p;
 	const unsigned int maxi( guess_maxi( t ) );	// guess the maximum number of iterations required
+//	const unsigned int maxi( 500 );	// THIS LEADS TO BIZARRE RESULTS
             
+    // If the estimated # terms needed for convergence is bigger than number
+    // of terms summed over (MAX_ALPHA_SEQ), give error.
     if( maxi == this->MAX_ALPHA_SEQ )
         std::cerr << " p_survival_table (used by drawTime) couldn't converge; max terms reached: " << maxi << std::endl;
            
-        if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
-        {						// that the table is filled
-        	IGNORE_RETURN getAlpha( 0, maxi );	// this updates the table of roots
-                this->createPsurvTable( psurvTable);	// then the table is filled with data
-        }
-        p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
-                                          this,
-                                          _1, t, psurvTable ),
-                         maxi );	// calculate the sum at time t
+    if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
+    {						// that the table is filled
+    	IGNORE_RETURN getAlpha( 0, maxi );	// this updates the table of roots
+            this->createPsurvTable( psurvTable);	// then the table is filled with data
+    }
+    // A sum over terms is performed, where convergence is assumed. It is not 
+    // clear if this is a just assumption.
+    // TODO!
+    p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
+                                      this,
+                                      _1, t, psurvTable ),
+                     maxi );	// calculate the sum at time t
 
-        return p*M_PI*M_PI_2;
+    return p*M_PI*M_PI_2;
 }
 
 // calculates the flux leaving through the inner interface at a given moment
@@ -1041,7 +1074,8 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
 // This draws a radius R at a given time, provided that the particle was at r0 at t=0
 Real GreensFunction2DRadAbs::drawR( const Real rnd, 
 						  const Real t ) const
-{
+{     
+    // Diffusion constant, inner boundary, outer boundary, starting r.
     const Real D( this->getD() );
     const Real sigma( getSigma() );
     const Real a( this->geta() );
@@ -1130,7 +1164,6 @@ Real GreensFunction2DRadAbs::drawR( const Real rnd,
 
 
     // root finding by iteration.
-
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
     const Real r( findRoot( F, solver, low, high,		// find the intersection between the random
@@ -1494,7 +1527,7 @@ GreensFunction2DRadAbs::drawTheta( const Real rnd,
 
 	// making the tables with constants
 
-	RealVector p_mTable;			// a table with constants to make calculations much faster
+	RealVector p_mTable;			// a table with constants to make calculationdraws much faster
 	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
 	{
 		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
@@ -1551,7 +1584,7 @@ std::string GreensFunction2DRadAbs::dump() const
 // Directly outputs probability distribution function value of leaving angle
 // for given theta, r and t.
 Real 
-GreensFunction2DRadAbs::givePDF( const Real theta,
+GreensFunction2DRadAbs::givePDFTheta( const Real theta,
 					   const Real r, 
 					   const Real t ) const
 {
@@ -1583,6 +1616,39 @@ GreensFunction2DRadAbs::givePDF( const Real theta,
 	
 }
 
+// Output the PDF of r, given time t has passed.
+Real GreensFunction2DRadAbs::givePDFR( const Real r, const Real t ) const
+{
+    const Real D( this->getD() );
+    const Real sigma( getSigma() );
+    const Real a( this->geta() );
+    const Real r0( this->getr0() );
+
+    if( t == 0.0 )		// if no time has passed
+    {
+	return r0;
+    }
+
+    const Real psurv( p_survival( t ) );	// calculate the survival probability at this time
+						// this is used as the normalization factor
+						// BEWARE!!! This also produces the roots An and therefore
+						// SETS THE HIGHEST INDEX -> side effect
+						// VERY BAD PROGRAMMING PRACTICE!!
+
+    RealVector Y0_aAnTable;
+    RealVector J0_aAnTable;
+    RealVector Y0J1J0Y1Table;
+    createY0J0Tables( Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, t);
+
+    // Create a struct params with the corrects vars.
+    p_int_r_params params = { this, t, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, 0.0 };
+
+    // Calculate PDF(r) with these vars,
+    Real PDF (p_int_r_F( r, &params ));
+
+    return PDF;
+}
+
 // It is used by the drawTheta method
 // It uses the p_nTable for it to speed things up
 /*
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index b39da7d0..26beea2c 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -189,9 +189,11 @@ class GreensFunction2DRadAbs
 
 //    const Real getAlpha0( const RealVector::size_type i ) const;
 
-    virtual Real givePDF( const Real theta,
+    Real givePDFTheta( const Real theta,
 					   const Real r, 
 					   const Real t ) const;    
+					   
+    Real givePDFR( const Real r, const Real t ) const;
 
 protected:
 
diff --git a/greens_functions.cpp b/greens_functions.cpp
index fa17e15f..9db699d6 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -156,7 +156,8 @@ BOOST_PYTHON_MODULE( _greens_functions )
 	.def( "leavea", &GreensFunction2DRadAbs::leavea )
     .def( "dump", &GreensFunction2DRadAbs::dump )
     // DEBUG: TODO REMOVE?
-    .def( "givePDF", &GreensFunction2DRadAbs::givePDF )    
+    .def( "givePDFR", &GreensFunction2DRadAbs::givePDFR )    
+    .def( "givePDFTheta", &GreensFunction2DRadAbs::givePDFTheta )        
 	;
     
     class_<GreensFunction3DSym>("GreensFunction3DSym", init<Real>())
diff --git a/shells.py b/shells.py
index 4ce6b427..07db163a 100755
--- a/shells.py
+++ b/shells.py
@@ -272,8 +272,9 @@ class testMixedPair2D3D(testPair):
 
     def __init__(self, single2D, single3D):
 
-        assert isinstance(single2D.structure, PlanarSurface) 
-        assert isinstance(single3D.structure, CuboidalRegion) 
+        if __debug__: 
+		assert isinstance(single2D.structure, PlanarSurface) 
+        	assert isinstance(single3D.structure, CuboidalRegion) 
         self.surface   = single2D.structure         # note that these need to be initialized before calling testPair.__init__
         self.structure = single3D.structure         # since then these are needed for calculating the transform
 

From ce93f5e603e6eb57dbb7acad379983769c1a7ab2 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Fri, 9 Mar 2012 11:17:33 +0100
Subject: [PATCH 0668/1541] Removed unnecessary printing to std::cerr.

---
 GreensFunction2DRadAbs.cpp | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index ed3900e2..99698bb3 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -640,7 +640,6 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
         // # Calculating the necessary roots to expand the table
         for(unsigned int j = oldSize; j <= i; j++)
         {
-            std::cerr << "\n\nSearching for j="<<j<<",n="<<n<<".\n";
             if (alphaTable[j] != 0)		
             {
                 std::cerr << "Error: tried accessing root that's not 0. Didn't search.. \n";
@@ -653,15 +652,11 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                 //      If it is established that we can use method 2, 
                 // alpha_x_scan_table_[n] will contain a value < 0.
                 if (alpha_x_scan_table_[n] >= 0)
-                {		        
-                    std::cerr << "Scanning.\n";
-                
+                {		                        
                     // ### Gets estimate of interval by sign-change-searching
                     //      high and low are the return-values of GiveRootInterval.
                     GiveRootInterval(low, high, n);	        
 
-                    std::cerr << "Called getAlphaRoot(low="<<low<<",high="<< high<<",n="<< n<<").\n";
-                    
                     // ### Finds the root using the GSL rootfinder
                     current_root_ = getAlphaRoot(low, high, n);
                     
@@ -676,27 +671,20 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                 // can be called using a simple estimated interval.
                 else 
                 {
-                    std::cerr << "Estimating.\n";                
-                
                     // ### Get interval by simple extrapolation
                     GiveRootIntervalSimple(low, high, n, j);	        
                 
-                    std::cerr << "Called getAlphaRoot(low="<<low<<",high="<< high<<",n="<< n<<").\n";
-                
                     // ### Finds the root using the GSL rootfinder
                     current_root_ = getAlphaRoot(low, high, n);
 
                     // ### Puts the found root in the table.
 	                alphaTable[j] = current_root_;		    
                 }
-                std::cerr << "Found root:" << current_root_ << "\n";
             }
         }
     
     }
     
-    std::cerr << "Return root (n,i) = " << alphaTable[i] << "(n=" << n << ",i=" << i << ")\n";   
-    
     return alphaTable[i];
 
 }

From be847a80692a912643779339742e0d951da8de54 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Mar 2012 10:54:40 +0100
Subject: [PATCH 0669/1541] Changed the order of parameters in the constructor
 of SpeciesInfo

---
 SpeciesInfo.hpp         |  4 ++--
 binding/SpeciesInfo.hpp | 25 +++++++++++++------------
 gfrdbase.py             |  2 +-
 3 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/SpeciesInfo.hpp b/SpeciesInfo.hpp
index b0382bb5..36e5fb0f 100644
--- a/SpeciesInfo.hpp
+++ b/SpeciesInfo.hpp
@@ -21,8 +21,8 @@ struct SpeciesInfo
     // constructors
     SpeciesInfo() {}
 
-    SpeciesInfo(identifier_type const& id, D_type const& D = 0., 
-                length_type const& r = 0., structure_type_id_type const& s = NULL, v_type const& v = 0.) 
+    SpeciesInfo(identifier_type const& id, structure_type_id_type const& s, D_type const& D = 0., 
+                length_type const& r = 0., v_type const& v = 0.) 
         : id_(id), diffusion_coef_(D), drift_velocity_(v), radius_(r), structure_type_id_(s) {}
 
 
diff --git a/binding/SpeciesInfo.hpp b/binding/SpeciesInfo.hpp
index f11b882d..217a28e6 100644
--- a/binding/SpeciesInfo.hpp
+++ b/binding/SpeciesInfo.hpp
@@ -15,21 +15,11 @@ inline boost::python::objects::class_base register_species_info_class(
 
     return class_<impl_type>("SpeciesInfo",
             init<>() )
-        .def(init<typename impl_type::identifier_type, typename impl_type::length_type, typename impl_type::D_type, typename impl_type::structure_type_id_type, typename impl_type::v_type>())
+        .def(init<typename impl_type::identifier_type, typename impl_type::structure_type_id_type,
+                  typename impl_type::length_type, typename impl_type::D_type, typename impl_type::v_type>())
         .add_property("id",
             make_function(&impl_type::id,
                 return_value_policy<return_by_value>()))
-        .add_property("radius",
-            make_function(
-                &peer::util::reference_accessor_wrapper<
-                    impl_type, typename impl_type::length_type,
-                    &impl_type::radius,
-                    &impl_type::radius>::get,
-                return_value_policy<return_by_value>()),
-            &peer::util::reference_accessor_wrapper<
-                impl_type, typename impl_type::length_type,
-                &impl_type::radius,
-                &impl_type::radius>::set)
         .add_property("structure_type_id",
             make_function(
                 &peer::util::reference_accessor_wrapper<
@@ -41,6 +31,17 @@ inline boost::python::objects::class_base register_species_info_class(
                 impl_type, typename impl_type::structure_type_id_type,
                 &impl_type::structure_type_id,
                 &impl_type::structure_type_id>::set)
+        .add_property("radius",
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type, typename impl_type::length_type,
+                    &impl_type::radius,
+                    &impl_type::radius>::get,
+                return_value_policy<return_by_value>()),
+            &peer::util::reference_accessor_wrapper<
+                impl_type, typename impl_type::length_type,
+                &impl_type::radius,
+                &impl_type::radius>::set)
         .add_property("D",
             make_function(
                 &peer::util::reference_accessor_wrapper<
diff --git a/gfrdbase.py b/gfrdbase.py
index 7505f308..8e1c3500 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -175,9 +175,9 @@ def create_world(m, matrix_size=10):
             structure = "world"
         world.add_species(
             _gfrd.SpeciesInfo(st.id, 
+                              structure,
                               float(st["D"]), 
                               float(st["radius"]), 
-                              structure,
                               float(st["v"])))
 
     for r in m.structures.itervalues():

From ea0abd5b6ceb0b3d5cec80db9a758adb2d985d73 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 7 Mar 2012 17:54:15 +0100
Subject: [PATCH 0670/1541] adding the methods get_def_structure_type_id and
 get_def_structure_id to the particlecontainer

---
 ParticleContainer.hpp |  5 +++++
 Transaction.hpp       | 10 ++++++++++
 2 files changed, 15 insertions(+)

diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 7a0a2018..f341e983 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -27,6 +27,7 @@ class ParticleContainer
     typedef typename traits_type::size_type         size_type;
     typedef typename traits_type::structure_id_type structure_id_type;
     typedef typename traits_type::structure_type    structure_type;
+    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
@@ -56,6 +57,10 @@ class ParticleContainer
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
     virtual structures_range get_structures() const = 0;
+
+    virtual structure_type_id_type get_def_structure_type_id() const = 0;
+
+    virtual structure_id_type get_def_structure_id() const = 0;
     
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
 
diff --git a/Transaction.hpp b/Transaction.hpp
index 614be9dc..50d7f910 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -167,6 +167,16 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_structures();
     }    
+
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return pc_.get_def_structure_type_id();
+    }    
+        
+    virtual structure_id_type get_def_structure_id() const
+    {
+        return pc_.get_def_structure_id();
+    }    
         
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {

From 4221dc4278883e38000cf37f313200fab807e5e1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Mar 2012 10:41:29 +0100
Subject: [PATCH 0671/1541] add get_structure_type to particlecontainer

---
 ParticleContainer.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index f341e983..8d206fbb 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -25,8 +25,9 @@ class ParticleContainer
     typedef typename traits_type::particle_id_type  particle_id_type;
     typedef typename traits_type::length_type       length_type;
     typedef typename traits_type::size_type         size_type;
-    typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type    structure_type;
+    typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
@@ -60,8 +61,10 @@ class ParticleContainer
 
     virtual structure_type_id_type get_def_structure_type_id() const = 0;
 
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const = 0;
+
     virtual structure_id_type get_def_structure_id() const = 0;
-    
+
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
 
     // Particle stuff

From 845e9a29a66ca726b54ce7560ee521aa0b3028f0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Mar 2012 10:42:38 +0100
Subject: [PATCH 0672/1541] adding the method get_structure_type to transaction

---
 Transaction.hpp | 65 +++++++++++++++++++++++++++++--------------------
 1 file changed, 39 insertions(+), 26 deletions(-)

diff --git a/Transaction.hpp b/Transaction.hpp
index 50d7f910..f5172f28 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -14,22 +14,25 @@
 
 template<typename Ttraits_>
 class Transaction: public ParticleContainer<Ttraits_>
+// A transaction 'is a' ParticleContainer that makes it possible to revert the moves of the particles
+// The Transaction is actually just an abstract datatype, not a class from which can be instantiated.
 {
 public:
     typedef Ttraits_ traits_type;
-    typedef typename traits_type::particle_type particle_type;
-    typedef typename particle_type::shape_type particle_shape_type;
-    typedef typename traits_type::species_type species_type;
-    typedef typename traits_type::species_id_type species_id_type;
-    typedef typename traits_type::position_type position_type;
-    typedef typename traits_type::particle_id_type particle_id_type;
-    typedef typename traits_type::size_type size_type;
-    typedef typename traits_type::length_type length_type;
+    // useful shorthands for types that we are using.
+    typedef typename traits_type::particle_type     particle_type;
+    typedef typename particle_type::shape_type      particle_shape_type;
+    typedef typename traits_type::species_type      species_type;
+    typedef typename traits_type::species_id_type   species_id_type;
+    typedef typename traits_type::position_type     position_type;
+    typedef typename traits_type::particle_id_type  particle_id_type;
+    typedef typename traits_type::size_type         size_type;
+    typedef typename traits_type::length_type       length_type;
     typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type structure_type;
-    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
+    typedef typename traits_type::structure_type    structure_type;
+    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
+    typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
     virtual ~Transaction() {}
@@ -48,21 +51,23 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
 {
 public:
     typedef Tpc_ particle_container_type;
-    typedef typename particle_container_type::traits_type traits_type;
-    typedef typename traits_type::particle_type particle_type;
-    typedef typename particle_type::shape_type particle_shape_type;
-    typedef typename traits_type::species_type species_type;
-    typedef typename traits_type::species_id_type species_id_type;
-    typedef typename traits_type::position_type position_type;
-    typedef typename traits_type::particle_id_type particle_id_type;
-    typedef typename traits_type::size_type size_type;
-    typedef typename traits_type::length_type length_type;
-    typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type structure_type;
+    typedef typename particle_container_type::traits_type   traits_type;
+    typedef typename traits_type::particle_type             particle_type;
+    typedef typename particle_type::shape_type              particle_shape_type;
+    typedef typename traits_type::species_type              species_type;
+    typedef typename traits_type::species_id_type           species_id_type;
+    typedef typename traits_type::position_type             position_type;
+    typedef typename traits_type::particle_id_type          particle_id_type;
+    typedef typename traits_type::size_type                 size_type;
+    typedef typename traits_type::length_type               length_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_type_type       structure_type_type;
+    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<structure_id_type, length_type> structure_id_and_distance_pair;
-    typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
+    typedef std::pair<structure_id_type, length_type>       structure_id_and_distance_pair;
+    typedef abstract_limited_generator<particle_id_pair>    particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>        particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
 private:
@@ -158,6 +163,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return new TransactionImpl<particle_container_type>(*this);
     }
 
+    // Start Structure stuff
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         return pc_.get_structure(id);
@@ -173,6 +179,11 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.get_def_structure_type_id();
     }    
         
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    {
+        return pc_.get_structure_type(sid);
+    }
+
     virtual structure_id_type get_def_structure_id() const
     {
         return pc_.get_def_structure_id();
@@ -182,6 +193,8 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_closest_surface( pos, ignore );
     }
+    // End structure stuff
+
 
     virtual species_type const& get_species(species_id_type const& id) const
     {

From b67a110929802a5c97e16b9a9300e5aad16df225 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Tue, 13 Mar 2012 13:49:15 +0100
Subject: [PATCH 0673/1541] Some additional debugging. (Mainly generate extra
 output).

---
 GreensFunction2DRadAbs.cpp | 34 ++++++++++++++++++++++++++++++----
 GreensFunction2DRadAbs.hpp |  4 +++-
 greens_functions.cpp       |  1 +
 3 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 99698bb3..b9b35e00 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -110,12 +110,14 @@ void GreensFunction2DRadAbs::clearAlphaTable() const
 const Real 
 GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 {
+
 	const Real a( this->geta() );
 	const Real sigma( getSigma() );
 	const Real h( this->geth() );
 	const Real s_An( sigma * alpha );
 	const Real a_An( a * alpha );
-//	const Real h_s( h * sigma);
+	// Needed? TODO
+	const Real h_s( h * sigma);
 
 	const double J0_s_An (gsl_sf_bessel_J0(s_An));
 	const double J1_s_An (gsl_sf_bessel_J1(s_An));
@@ -125,15 +127,24 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
 	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));	
 
-//  const double rho1 ( ( (h_s * J0_s_An) + (s_An * J1_s_An) ) * Y0_a_An );
+//    const double rho1 ( ( (h_s * J0_s_An) + (s_An * J1_s_An) ) * Y0_a_An );
 //	const double rho2 ( ( (h_s * Y0_s_An) + (s_An * Y1_s_An) ) * J0_a_An );
 //	return (rho1 - rho2); 
+
 //
 //  Sigma can be divided out, roots will remain same:
-
+// TODO, WILL THEY? ????? YUP
 	const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
 	const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
+	
+//    std::cerr << "Term 1 (" << (h * J0_s_An) ; 
+//    std::cerr << ") plus term 2 (" << (alpha * J1_s_An) << ").\n" ;
+
+//    std::cerr << "ALT 1 (" << (h_s * J0_s_An) ; 
+//    std::cerr << ") plus ALT 2 (" << (s_An * J1_s_An) << ").\n" ;
+	
 	return rho1 - rho2;
+
 }
 
 
@@ -513,7 +524,8 @@ GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
 		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRoot0" ) );
     gsl_root_fsolver_free( solver );
     
-    return alpha;
+    const Real sigma(getSigma());
+    return alpha; 
 }    
 
 // This function calls the GSL root finder, for roots for which n > 0. (n = 0 is
@@ -1637,6 +1649,20 @@ Real GreensFunction2DRadAbs::givePDFR( const Real r, const Real t ) const
     return PDF;
 }
 
+void GreensFunction2DRadAbs::dumpRoots( int n )
+{
+//        return this->alphaTable[n];
+      std::cout << "Roots are: {";
+      
+      const int size( alphaTable.size() );
+      RealVector& alphaTable( this->alphaTable[n] );
+      
+      for (int i = 0; i < size; i++) {
+          std::cout << alphaTable[i] << ",";          	
+      }
+      std::cout << "}.\n";
+}
+
 // It is used by the drawTheta method
 // It uses the p_nTable for it to speed things up
 /*
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 26beea2c..2a98cce5 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -57,7 +57,7 @@ class GreensFunction2DRadAbs
     // Left boundary of 1st search interval 1st root
     static const Real SCAN_START = 0.001;     
     // Length of the scanning interval relative to estimated interval
-    static const Real FRACTION_SCAN_INTERVAL = .5;
+    static const Real FRACTION_SCAN_INTERVAL = .5; // TODO CHANGED THIS FROM .5 to .2
     
     // Other paramters
     // After CONVERGENCE_ASSUMED subsequent roots that lay within +/- 
@@ -194,6 +194,8 @@ class GreensFunction2DRadAbs
 					   const Real t ) const;    
 					   
     Real givePDFR( const Real r, const Real t ) const;
+    
+    void dumpRoots( int n );
 
 protected:
 
diff --git a/greens_functions.cpp b/greens_functions.cpp
index 9db699d6..3f31cde5 100644
--- a/greens_functions.cpp
+++ b/greens_functions.cpp
@@ -158,6 +158,7 @@ BOOST_PYTHON_MODULE( _greens_functions )
     // DEBUG: TODO REMOVE?
     .def( "givePDFR", &GreensFunction2DRadAbs::givePDFR )    
     .def( "givePDFTheta", &GreensFunction2DRadAbs::givePDFTheta )        
+    .def( "dumpRoots", &GreensFunction2DRadAbs::dumpRoots )
 	;
     
     class_<GreensFunction3DSym>("GreensFunction3DSym", init<Real>())

From fe87b6e67de0171af9a5ff9597f86969ad3c8a8b Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Tue, 13 Mar 2012 13:56:36 +0100
Subject: [PATCH 0674/1541] drawTime function now agrees with Mathematica Beck
 solution.

TODO: Check for error message when (not) overwriting root=0. (line 651)
---
 GreensFunction2DRadAbs.cpp | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index b9b35e00..fe9f40e2 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -127,22 +127,15 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
 	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));	
 
-//    const double rho1 ( ( (h_s * J0_s_An) + (s_An * J1_s_An) ) * Y0_a_An );
+//  const double rho1 ( ( (h_s * J0_s_An) + (s_An * J1_s_An) ) * Y0_a_An );
 //	const double rho2 ( ( (h_s * Y0_s_An) + (s_An * Y1_s_An) ) * J0_a_An );
 //	return (rho1 - rho2); 
 
-//
 //  Sigma can be divided out, roots will remain same:
-// TODO, WILL THEY? ????? YUP
+//  (Note: actually double checked this).
 	const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
 	const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
-	
-//    std::cerr << "Term 1 (" << (h * J0_s_An) ; 
-//    std::cerr << ") plus term 2 (" << (alpha * J1_s_An) << ").\n" ;
 
-//    std::cerr << "ALT 1 (" << (h_s * J0_s_An) ; 
-//    std::cerr << ") plus ALT 2 (" << (s_An * J1_s_An) << ").\n" ;
-	
 	return rho1 - rho2;
 
 }
@@ -175,6 +168,7 @@ const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 	const Real s_An( sigma * alpha );
 	const Real a_An( a * alpha );	
     const Real realn( static_cast<Real>( n ) );
+    const Real h_sigma( h * sigma);
 
 	const double Jn_s_An (gsl_sf_bessel_Jn(n,s_An));
 	const double Jn1_s_An (gsl_sf_bessel_Jn(n+1,s_An));
@@ -184,8 +178,8 @@ const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
 	const double Yn1_s_An (gsl_sf_bessel_Yn(n+1,s_An));
 	const double Yn_a_An (gsl_sf_bessel_Yn(n,a_An));
 
-    const double rho1 ( ( (h*sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
-	const double rho2 ( ( (h*sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
+    const double rho1 ( ( (h_sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
+	const double rho2 ( ( (h_sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
 	return (rho1 - rho2); 
 
 //  Or..? -:	

From 127bfe9f974ff1b187ccab548b357271f67873e8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Mar 2012 10:43:58 +0100
Subject: [PATCH 0675/1541] adding getters for structure_type and
 structure_type_id to Multi and World Also already changed the type for the
 identifier of structures.

---
 Multi.hpp | 79 +++++++++++++++++++++++++++++++++++--------------------
 World.hpp | 36 +++++++++++++++----------
 2 files changed, 73 insertions(+), 42 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 6c800d53..4ec701bc 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -28,26 +28,32 @@ class MultiParticleContainer
     typedef ParticleContainerUtils<typename Ttraits_::world_type::traits_type> utils;
     typedef typename Ttraits_::world_type world_type;
     typedef typename world_type::traits_type traits_type;
-    typedef typename traits_type::particle_type particle_type;
-    typedef typename particle_type::shape_type particle_shape_type;
-    typedef typename traits_type::species_type species_type;
-    typedef typename traits_type::species_id_type species_id_type;
-    typedef typename traits_type::position_type position_type;
-    typedef typename traits_type::particle_id_type particle_id_type;
-    typedef typename traits_type::length_type length_type;
-    typedef typename traits_type::size_type size_type;
-    typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type structure_type;
-    typedef typename Ttraits_::network_rules_type network_rules_type;
-    typedef typename Ttraits_::reaction_rule_type reaction_rule_type;
+    // shorthands for used types
+    typedef typename traits_type::particle_type     particle_type;
+    typedef typename particle_type::shape_type      particle_shape_type;
+    typedef typename traits_type::species_type      species_type;
+    typedef typename traits_type::species_id_type   species_id_type;
+    typedef typename traits_type::position_type     position_type;
+    typedef typename traits_type::particle_id_type  particle_id_type;
+    typedef typename traits_type::length_type       length_type;
+    typedef typename traits_type::size_type         size_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_type_type       structure_type_type;
+    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
+
+    typedef typename Ttraits_::network_rules_type   network_rules_type;
+    typedef typename Ttraits_::reaction_rule_type   reaction_rule_type;
     typedef typename network_rules_type::reaction_rules reaction_rules;      
+
     typedef typename Ttraits_::world_type::particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
-    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef Transaction<traits_type> transaction_type;
-    typedef abstract_limited_generator<particle_id_pair> particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
-    typedef std::map<particle_id_type, particle_type> particle_map;
+    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
+    typedef Transaction<traits_type>                            transaction_type;
+    typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
+    typedef unassignable_adapter<particle_id_pair_and_distance,
+                                 get_default_impl::std::vector> particle_id_pair_and_distance_list;
+    typedef std::map<particle_id_type, particle_type>           particle_map;
     typedef sized_iterator_range<typename particle_map::const_iterator> particle_id_pair_range;
     typedef std::pair<const Real, const Real> real_pair;
 
@@ -83,6 +89,7 @@ class MultiParticleContainer
         return world_.get_species(id);
     }
 
+    // Start structure stuff
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         return world_.get_structure(id);
@@ -93,10 +100,26 @@ class MultiParticleContainer
         return world_.get_structures();
     }
     
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return world_.get_def_structure_type_id();
+    }
+
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    {
+        return world_.get_structure_type(sid);
+    }
+
+    virtual structure_id_type get_def_structure_id() const
+    {
+        return world_.get_def_structure_id();
+    }
+
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {        
         return world_.get_closest_surface( pos, ignore );
     }
+    // End structure stuff
         
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
@@ -263,13 +286,13 @@ class MultiParticleContainer
         
         BOOST_FOREACH(particle_id_pair pp, get_particles_range())
         {
-            species_type const s( pp.second.sid() );
+            species_type const s( get_species(pp.second.sid()) );
             structure_id_and_distance_pair const strc_id_and_dist( 
-                get_closest_surface( pp.second.position(), s.structure_id() ) );
+                get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
                 
-            if( strc_id_and_dist.second < 2.0 * s.radius() && s.structure_id() == "world" )
+            if( strc_id_and_dist.second < 2.0 * s.radius() && s.structure_type_id() == get_def_structure_type_id() )
             {
-                species_id_type const strc_sid( get_structure( strc_id_and_dist.first )->sid() );
+                structure_type_id_type const strc_sid( get_structure( strc_id_and_dist.first )->sid() );
                 reaction_rules const& rrules(rules.query_reaction_rule( s.id(), strc_sid ));
                 if (::size(rrules) == 0)
                     continue;
@@ -307,16 +330,16 @@ class MultiParticleContainer
                     const length_type r01( s0.radius() + s1.radius() );
                     Real k;
                     
-                    if(s0.structure_id() != s1.structure_id())
+                    if(s0.structure_type_id() != s1.structure_type_id())
                     {
-                        if(s0.structure_id() == "world")
-                            k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+                        if(s0.structure_type_id() == get_def_structure_type_id())
+                            k = 0.001;  // TODO k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                         else
-                            k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+                            k = 0.001;  // TODO k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                     }
                     else
                     {
-                        k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
+                        k = 0.001;      // TODO k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
                     }
                 
                     if ( k_max < k )
@@ -338,7 +361,7 @@ class MultiParticleContainer
        (3) particles escape the multi with a maximum step size in the order of the 
            reaction length. (Dmax * dt ~ (ssf * r_min)**2 ).
        
-       TODO:This function should be a method of the Multi Class, but I put it in the mpc such that we can use it in python.
+       TODO:This function should be a method of the Multi Class, but I put it in the mpc (multi particle container) such that we can use it in python.
        
        PROBLEM: for certain parameters (large k) dt can be very small and the simulation will slow down.
     */    
diff --git a/World.hpp b/World.hpp
index b0e9bbad..6d87f7fd 100644
--- a/World.hpp
+++ b/World.hpp
@@ -22,6 +22,7 @@
 #include "SerialIDGenerator.hpp"
 #include "Transaction.hpp"
 #include "Structure.hpp"
+#include "StructureType.hpp"
 #include "StructureID.hpp"
 #include "Surface.hpp"
 #include "Region.hpp"
@@ -44,16 +45,17 @@ struct WorldTraitsBase
     typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
     typedef SpeciesTypeID                                   species_id_type;    // identifier type for species and (structure types)
     typedef SpeciesTypeID                                   structure_type_id_type;
+    typedef StructureType                                   structure_type_type;
     // TODO add structure_type_id_type?
 //    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
-    typedef std::string                                     structure_id_type;  // identifier type for structures
-//    typedef StructureID                                     structure_id_type;
+//    typedef std::string                                     structure_id_type;  // identifier type for structures
+    typedef StructureID                                     structure_id_type;
     typedef SerialIDGenerator<StructureID>                  structure_id_generator;
     typedef Particle<length_type, D_type, species_id_type,
-                     StructureID>                           particle_type;      // type for particles, NOTE why is there no v_type here?
+                     structure_id_type>                     particle_type;      // type for particles, NOTE why is there no v_type here?
 
     typedef SpeciesInfo<species_id_type, D_type,
-                        length_type, structure_type_id_type>    species_type;  // information associated with the species
+                        length_type, structure_type_id_type>species_type;       // information associated with the species
     typedef Vector3<length_type>                                                    point_type;
     typedef typename particle_type::shape_type::position_type                       position_type;
     typedef GSLRandomNumberGenerator                                                rng_type;
@@ -213,6 +215,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_id_generator    structure_id_generator;
     typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     //
@@ -245,16 +248,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
     // TODO Add the default structure of the default structure_type here?
 
-    virtual structure_id_type get_def_structure_id() const
-    {   //   return default_structure_id_;
-        return "world";
-    }
-
-    virtual structure_type_id_type get_def_structure_type_id() const
-    {
-        return default_structure_type_id_;
-    }
-
     // To add new particles
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
@@ -356,6 +349,20 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             structure_map_.size());
     }
 
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return default_structure_type_id_;
+    }
+
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    {
+        return default_structure_; // TODO
+    }
+
+    virtual structure_id_type get_def_structure_id() const
+    {   return default_structure_id_;
+    }
+
     // TODO
     // Add structureType
     // update structure
@@ -408,6 +415,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     structure_id_generator      structidgen_;
     StructureID                 default_structure_id_;
     structure_type_id_type      default_structure_type_id_;
+    structure_type_type         default_structure_; // TODO remove later again.
 };
 
 #endif /* WORLD_HPP */

From 7a84b5adca71ac70265239cad2b144e2decd943f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Mar 2012 14:48:24 +0100
Subject: [PATCH 0676/1541] Adding getters and setter also to the
 ParticleContainerWrapper.

---
 binding/ParticleContainer.hpp | 50 +++++++++++++++++++++++++----------
 1 file changed, 36 insertions(+), 14 deletions(-)

diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index e0169c40..9baa6f86 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -179,20 +179,22 @@ class ParticleContainerWrapper
 public:
     typedef boost::python::wrapper<Tbase_> py_wrapper_type;
     typedef Tbase_ wrapped_type;
-    typedef typename wrapped_type::size_type size_type;
-    typedef typename wrapped_type::length_type length_type;
-    typedef typename wrapped_type::particle_id_type particle_id_type;
-    typedef typename wrapped_type::particle_shape_type particle_shape_type;
-    typedef typename wrapped_type::position_type position_type;
-    typedef typename wrapped_type::species_id_type species_id_type;
-    typedef typename wrapped_type::species_type species_type;
-    typedef typename wrapped_type::structure_id_type structure_id_type;
-    typedef typename wrapped_type::structure_type structure_type;
-    typedef typename wrapped_type::particle_id_pair particle_id_pair;
-    typedef typename wrapped_type::transaction_type transaction_type;
-    typedef typename wrapped_type::particle_id_pair_generator particle_id_pair_generator;
-    typedef typename wrapped_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
-    typedef typename wrapped_type::structure_id_and_distance_pair structure_id_and_distance_pair;
+    typedef typename wrapped_type::size_type            size_type;
+    typedef typename wrapped_type::length_type          length_type;
+    typedef typename wrapped_type::particle_id_type     particle_id_type;
+    typedef typename wrapped_type::particle_shape_type  particle_shape_type;
+    typedef typename wrapped_type::position_type        position_type;
+    typedef typename wrapped_type::species_id_type      species_id_type;
+    typedef typename wrapped_type::species_type         species_type;
+    typedef typename wrapped_type::structure_id_type    structure_id_type;
+    typedef typename wrapped_type::structure_type       structure_type;
+    typedef typename wrapped_type::structure_type_type  structure_type_type;
+    typedef typename wrapped_type::structure_type_id_type   structure_type_id_type;
+    typedef typename wrapped_type::particle_id_pair     particle_id_pair;
+    typedef typename wrapped_type::transaction_type     transaction_type;
+    typedef typename wrapped_type::particle_id_pair_generator           particle_id_pair_generator;
+    typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
+    typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
 
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
@@ -230,6 +232,7 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_species")(id).template unchecked<species_type const&>();
     }
 
+    // structure stuff
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         return py_wrapper_type::get_override("get_structure")(id);
@@ -240,10 +243,26 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_structures")();
     }
 
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return py_wrapper_type::get_override("get_def_structure_type_id")();
+    }
+
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    {
+        return py_wrapper_type::get_override("get_structure_type")(sid);
+    }
+
+    virtual structure_id_type get_def_structure_id() const
+    {
+        return py_wrapper_type::get_override("get_def_structure_id")();
+    }
+
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {
         return py_wrapper_type::get_override("get_closest_surface")(pos, ignore);
     }
+    // end structure stuff
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
@@ -359,6 +378,9 @@ inline boost::python::objects::class_base register_particle_container_class(
             return_internal_reference<>())
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
+        .def("get_def_structure_type_id", pure_virtual(&impl_type::get_def_structure_type_id))
+        .def("get_structure_type", pure_virtual(&impl_type::get_structure_type))
+        .def("get_def_structure_id", pure_virtual(&impl_type::get_def_structure_id))
         .def("get_closest_surface", pure_virtual(&impl_type::get_closest_surface))
         .def("new_particle", pure_virtual(&impl_type::new_particle))
         .def("update_particle", pure_virtual(&impl_type::update_particle))

From 8e3e6815c231fbdb274dfece0a862126ab1388bd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Mar 2012 10:51:46 +0100
Subject: [PATCH 0677/1541] Changing the BDPropagators and Simulator to reflect
 that: -The default structure is no longer "world" but must be queried
 throught the get_def_structure_id method -The information of the structure
 that a particles live on is stored in the structure and is mandatory -To get
 a structure you have to get this information through the particle and no
 longer through the species.

---
 BDPropagator.hpp          | 19 ++++++---
 BDSimulator.hpp           | 24 +++++------
 EGFRDSimulator.hpp        | 43 +++++++++++++------
 EGFRDSimulatorFactory.hpp |  7 +--
 newBDPropagator.hpp       | 90 ++++++++++++++++++++++-----------------
 5 files changed, 108 insertions(+), 75 deletions(-)

diff --git a/BDPropagator.hpp b/BDPropagator.hpp
index 15a99358..46cb68e4 100644
--- a/BDPropagator.hpp
+++ b/BDPropagator.hpp
@@ -98,7 +98,7 @@ class BDPropagator
         if (species.D() == 0.)
             return true;
 
-        position_type const displacement(drawR_free(species));
+        position_type const displacement(drawR_free(pp));
         position_type const new_pos(
             tx_.apply_boundary(
                 add(pp.second.position(), displacement)));
@@ -106,7 +106,7 @@ class BDPropagator
         particle_id_pair particle_to_update(
                 pp.first, particle_type(species.id(),
                     particle_shape_type(new_pos, species.radius()),
-                    species.D()));
+                    pp.second.structure_id(), species.D()));
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
             tx_.check_overlap(particle_to_update.second.shape(),
                               particle_to_update.first));
@@ -159,9 +159,10 @@ class BDPropagator
     }
 
 private:
-    position_type drawR_free(species_type const& species)
+    position_type drawR_free(particle_id_pair const& pp)
     {
-        return tx_.get_structure(species.structure_id())->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_);
+        species_type const species(tx_.get_species( pp.second.sid()) );
+        return tx_.get_structure(pp.second.structure_id())->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_);
     }
 
     bool attempt_reaction(particle_id_pair const& pp)
@@ -197,6 +198,7 @@ class BDPropagator
                             pp.first, particle_type(products[0],
                                 particle_shape_type(pp.second.position(),
                                                     s0.radius()),
+                                                    pp.second.structure_id(),
                                                     s0.D()));
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_p.second.shape(), new_p.first));
                         if (overlapped && overlapped->size() > 0)
@@ -240,7 +242,7 @@ class BDPropagator
                             }
 
                             boost::shared_ptr<structure_type> pp_structure( 
-                                tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id()) );  
+                                tx_.get_structure( pp.second.structure_id()) );  
                
                             position_type m( pp_structure->
                                         dissociation_vector( rng_, r01, dt_, D01, s0.v() - s1.v() ) );
@@ -303,7 +305,7 @@ class BDPropagator
         }
 
         const species_type s0(tx_.get_species(pp0.second.sid())),
-                s1(tx_.get_species(pp1.second.sid()));
+                           s1(tx_.get_species(pp1.second.sid()));
         length_type r01(s0.radius() + s1.radius());
 
         const Real rnd(rng_());
@@ -315,7 +317,7 @@ class BDPropagator
             reaction_rule_type const& r(*i);
 
             boost::shared_ptr<structure_type> pp_structure( 
-               tx_.get_structure( tx_.get_species( pp0.second.sid() ).structure_id()) );  
+               tx_.get_structure( pp0.second.structure_id()) );  // we assume that both particles live on the same surface
 
             const Real p(pp_structure->p_acceptance( r.k(), dt_, r01, subtract( pp1.second.position(), 
                                                 pp0.second.position() ), s0.D(), s1.D(), s0.v(), s1.v() ));
@@ -339,6 +341,7 @@ class BDPropagator
                 switch (::size(products))
                 {
                 case 1:
+                // If the number or product of the reaction is one.
                     {
                         const species_id_type product(products[0]);
                         const species_type sp(tx_.get_species(product));
@@ -351,6 +354,7 @@ class BDPropagator
                                             pp1.second.position(),
                                             pp0.second.position()), s0.D())),
                                     (s0.D() + s1.D()))));
+
                         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                             tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
                                               pp0.first, pp1.first));
@@ -381,6 +385,7 @@ class BDPropagator
                         break;
                     }
                 case 0:
+                // If the two particles annihilate eachother. Just remove the particles.
                     remove_particle(pp0.first);
                     remove_particle(pp1.first);
                     break;
diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index 514d0800..da73cf12 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -151,7 +151,7 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
 
         BOOST_FOREACH(species_type s, base_type::world_->get_species())
         {
-            if( s.structure_id() != "world" )
+            if( s.structure_type_id() != base_type::world_->get_def_structure_type_id() )
                 continue;
 
             BOOST_FOREACH(boost::shared_ptr<structure_type> structure, base_type::world_->get_structures())
@@ -192,19 +192,19 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
-                    const length_type r01( s0.radius() + s1.radius() );
+//                    const length_type r01( s0.radius() + s1.radius() ); // TODO
                     Real k;
                     
-                    if(s0.structure_id() != s1.structure_id())
+                    if(s0.structure_type_id() != s1.structure_type_id())
                     {
-                        if(s0.structure_id() == "world")
-                            k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+                        if(s0.structure_type_id() == base_type::world_->get_def_structure_type_id())
+                            k = 0.001; //TODO k = base_type::world_->get_structure( s0.structure_type_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                         else
-                            k = base_type::world_->get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+                            k = 0.001; //TODO k = base_type::world_->get_structure( s1.structure_type_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                     }
                     else
                     {
-                        k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
+                        k = 0.001;     //TODO k = base_type::world_->get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
                     }
                 
                     if ( k_max < k )
@@ -251,11 +251,11 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     }
 
 private:
-    Real dt_factor_;
-    int const num_retries_;
-    length_type reaction_length_factor_;
-    length_type reaction_length_;
-    static Logger& log_;
+    Real            dt_factor_;
+    int const       num_retries_;
+    length_type     reaction_length_factor_;
+    length_type     reaction_length_;
+    static Logger&  log_;
 };
 
 template<typename Ttraits_>
diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index 8e6d5127..bd12cae9 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -571,11 +571,15 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
         position_type draw_com(cylindrical_pair_type const& domain,
                                time_type dt) const
         {
-            boost::shared_ptr<structure_type> const _structure(
+/*            boost::shared_ptr<structure_type> const _structure(
                 world_.get_structure(
                     world_.get_species(
                         domain.particles()[0].second.sid())
                     .structure_id()));
+*/
+            boost::shared_ptr<structure_type> const _structure(
+                world_.get_structure(
+                    domain.particles()[0].second.structure_id()));
             
             cylindrical_surface_type const* const structure(
                 dynamic_cast<cylindrical_surface_type*>(_structure.get()));
@@ -634,11 +638,15 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
         position_type draw_com(cylindrical_pair_type const& domain,
                                time_type dt) const
         {
-            boost::shared_ptr<structure_type> const _structure(
+/*            boost::shared_ptr<structure_type> const _structure(
                 world_.get_species(
                     domain.particles()[0].second.sid())
-                .structure_id());
-            
+                .structure_type_id());
+*/            
+            boost::shared_ptr<structure_type> const _structure(
+                world_.get_structure(
+                    domain.particles()[0].second.structure_id()));
+
             cylindrical_surface_type const* const structure(
                 dynamic_cast<cylindrical_surface_type*>(_structure.get()));
 
@@ -703,11 +711,15 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
         position_type draw_com(cylindrical_pair_type const& domain,
                                time_type dt)
         {
-            boost::shared_ptr<structure_type> const _structure(
+/*            boost::shared_ptr<structure_type> const _structure(
                 world_.get_structure(
                     world_.get_species(
                         domain.particles()[0].second.sid())
                     .structure_id()));
+*/
+            boost::shared_ptr<structure_type> const _structure(
+                world_.get_structure(
+                    domain.particles()[0].second.structure_id()));
             
             cylindrical_surface_type const* const structure(
                 dynamic_cast<cylindrical_surface_type*>(_structure.get()));
@@ -772,8 +784,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
         {
             boost::shared_ptr<structure_type> const _structure(
                 world_.get_structure(
-                    world_.get_species(
-                        domain.particles()[0].second.sid()).structure_id()));
+                    domain.particles()[0].second.structure_id()));
             
             cylindrical_surface_type const* const structure(
                 dynamic_cast<cylindrical_surface_type*>(_structure.get()));
@@ -837,11 +848,15 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
         position_type draw_com(cylindrical_pair_type const& domain,
                                time_type dt)
         {
-            boost::shared_ptr<structure_type> const _structure(
+/*            boost::shared_ptr<structure_type> const _structure(
                 world_.get_structure(
                     world_.get_species(
                         domain.particles()[0].second.sid())
                     .structure_id()));
+*/
+            boost::shared_ptr<structure_type> const _structure(
+                world_.get_structure(
+                    domain.particles()[0].second.structure_id()));
 
             cylindrical_surface_type const* const structure(
                 dynamic_cast<cylindrical_surface_type*>(_structure.get()));
@@ -1488,8 +1503,8 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
             domain_kind& kind;
         };
 
-        species_type const& species((*base_type::world_).get_species(p.second.sid()));
-        dynamic_cast<particle_simulation_structure_type const&>(*(*base_type::world_).get_structure(species.structure_id())).accept(factory(this, p, did, new_single, kind));
+//        species_type const& species((*base_type::world_).get_species(p.second.sid()));
+        dynamic_cast<particle_simulation_structure_type const&>(*(*base_type::world_).get_structure(p.second.structure_id())).accept(factory(this, p, did, new_single, kind));
         boost::shared_ptr<domain_type> const retval(new_single);
         domains_.insert(std::make_pair(did, retval));
         BOOST_ASSERT(kind != NONE);
@@ -1584,8 +1599,8 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
             domain_kind& kind;
         };
 
-        species_type const& species((*base_type::world_).get_species(p0.second.sid()));
-        dynamic_cast<particle_simulation_structure_type&>(*(*base_type::world_).get_structure(species.structure_id())).accept(factory(this, p0, p1, com, iv, shell_size, did, new_pair, kind));
+//        species_type const& species((*base_type::world_).get_species(p0.second.sid()));
+        dynamic_cast<particle_simulation_structure_type&>(*(*base_type::world_).get_structure(p0.second.structure_id())).accept(factory(this, p0, p1, com, iv, shell_size, did, new_pair, kind));
 
         boost::shared_ptr<domain_type> const retval(new_pair);
         domains_.insert(std::make_pair(did, retval));
@@ -1826,7 +1841,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
 
         particle_type const& old(domain.particle().second);
         domain.particle().second = particle_type(old.sid(),
-                particle_shape_type(new_pos, old.radius()), old.D());
+                particle_shape_type(new_pos, old.radius()), old.structure_id(), old.D());
         (*base_type::world_).update_particle(domain.particle());
 
         domain.position() = new_pos;
@@ -2119,7 +2134,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
                 {
                     boost::shared_ptr<structure_type> structure(
                         (*base_type::world_).get_structure(
-                            reactant_species.structure_id()));
+                            reactant.second.structure_id()));
                     position_type vector(
                         structure->random_vector(
                             r01 * traits_type::MINIMAL_SEPARATION_FACTOR,
diff --git a/EGFRDSimulatorFactory.hpp b/EGFRDSimulatorFactory.hpp
index ef3933e8..b28a87b1 100644
--- a/EGFRDSimulatorFactory.hpp
+++ b/EGFRDSimulatorFactory.hpp
@@ -60,18 +60,19 @@ class EGFRDSimulatorFactory: public ParticleSimulatorFactory<Ttraits_>
             // TODO: add surfaces to world
         }
 
+        // Making sure that all the species have a structure_type defined?
         BOOST_FOREACH (boost::shared_ptr<SpeciesType> st,
                        model.get_species_types())
         {
-            std::string const& structure_id((*st)["structure"]);
+            structure_type_id_type const& structure_type_id((*st)["structure_type"]);
             world->add_species(
                 typename world_traits_type::species_type(
                     st->id(),
                     boost::lexical_cast<typename world_traits_type::D_type>(
                         (*st)["D"]),
                     boost::lexical_cast<length_type>((*st)["radius"]),
-                    boost::lexical_cast<typename world_traits_type::structure_id_type>(
-                        structure_id.empty() ? "world": structure_id)
+                    boost::lexical_cast<typename world_traits_type::structure_type_id_type>(
+                        structure_type_id.empty() ? model.get_def_structure_type_id(): structure_type_id)
                     ));
         }
 
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index c4d31303..d9ff34d9 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -106,7 +106,7 @@ class newBDPropagator
         species_type const pp_species(tx_.get_species(pp.second.sid()));
         length_type const r0( pp_species.radius() );
         position_type const old_pos( pp.second.position() );
-        boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( pp_species.structure_id() ) );
+        boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( pp.second.structure_id() ) );
         
         structure_id_and_distance_pair struct_id_distance_pair;
         length_type particle_surface_distance = 0;
@@ -142,7 +142,7 @@ class newBDPropagator
         
         /* If the particle has not bounced with another particle and lives in the bulk: 
            check for core overlap with a surface. */
-        if(!bounced && pp_structure->id() == "world")
+        if(!bounced && pp_structure->id() == tx_.get_def_structure_id())
         {
             struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
             particle_surface_distance = struct_id_distance_pair.second;
@@ -167,7 +167,7 @@ class newBDPropagator
                                             
             particles_in_overlap = overlapped ? overlapped->size(): 0; 
             
-            if(pp_structure->id() == "world")
+            if(pp_structure->id() == tx_.get_def_structure_id())
             {
                 struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
                 particle_surface_distance = struct_id_distance_pair.second;  
@@ -180,7 +180,7 @@ class newBDPropagator
         Real const rnd( rng_() );
         
         /* First, if a surface is inside the reaction volume, attempt an interaction. */
-        if( pp_structure->id() == "world" )
+        if( pp_structure->id() == tx_.get_def_structure_id())
         {
             if( tx_.get_structure( struct_id_distance_pair.first )->
                 in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
@@ -227,22 +227,23 @@ class newBDPropagator
         {
             particle_id_pair_and_distance const& closest( overlapped->at(j) );
 
-            species_type s0(pp_species),s1(tx_.get_species(closest.first.second.sid()));
+            species_type s0(pp_species),
+                         s1(tx_.get_species(closest.first.second.sid()));
                 
             /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
                and we let this be s1, the particle from the surface is named s0. */
-            if(s0.structure_id() != s1.structure_id())
+            if(s0.structure_type_id() != s1.structure_type_id())
             {
-                if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
+                if( !(s0.structure_type_id() == tx_.get_def_structure_type_id() || s1.structure_type_id() == tx_.get_def_structure_type_id())  )
                 {
                     log_.warn("A surface particle overlapped with a particle living on a different surface. No reaction implemented.");
                     continue;
                 }
-                if(s0.structure_id() == "world")
+                if(s0.structure_type_id() == tx_.get_def_structure_type_id())
                     std::swap(s0,s1);
             }
             
-            boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id()) );
+            boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( closest.first.second.structure_id()) );
             const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
             accumulated_prob += k_total(s0.id(), s1.id()) * dt_ / ( 2. * reaction_volume ); 
             
@@ -281,7 +282,7 @@ class newBDPropagator
         if(!bounced)
         {   
             particle_id_pair particle_to_update( pp.first, 
-                        particle_type(pp_species.id(), particle_shape_type(new_pos, r0), pp_species.D()) );
+                        particle_type(pp_species.id(), particle_shape_type(new_pos, r0), pp.second.structure_id(), pp_species.D()) );
                 
             if (vc_)
             {
@@ -334,13 +335,13 @@ class newBDPropagator
                 case 1:
                     {
                         const species_type s0(tx_.get_species(products[0]));
-                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species(pp.second.sid()).structure_id() ) );
+                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure(pp.second.structure_id()) );
                         position_type new_pos = pp.second.position();
                         
-                        /* If the product particle does NOT live of the same structure as the reactant => surface -> bulk dissociation. */
-                        if( s0.structure_id() != pp_struct->id() )
+                        /* If the product particle does NOT live on the same structure type as the reactant => surface -> bulk dissociation. */
+                        if( s0.structure_type_id() != pp_struct->sid() )
                         {
-                            if( s0.structure_id() != "world" )
+                            if( s0.structure_type_id() != tx_.get_def_structure_type_id() )
                                 throw not_implemented("No surface -> surface dissociation allowed");
                         
                             position_type const displacement( pp_struct->surface_dissociation_vector(rng_, s0.radius(), reaction_length_ ) );
@@ -367,9 +368,9 @@ class newBDPropagator
                             }
                         }
 
-                        if( s0.structure_id() == "world" && pp_struct->id() == "world" )
+                        if( s0.structure_type_id() == tx_.get_def_structure_type_id() && pp_struct->id() == tx_.get_def_structure_id() )
                         {
-                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id()) );
+                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, pp_struct->id()) );
                             
                             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
@@ -394,11 +395,11 @@ class newBDPropagator
                 case 2:
                     {
                         species_type s0(tx_.get_species(products[0])),
-                                s1(tx_.get_species(products[1]));
+                                     s1(tx_.get_species(products[1]));
                         int i = max_retry_count_;
                         position_pair_type pp01;
 
-                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( tx_.get_species( pp.second.sid() ).structure_id() ) );
+                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( pp.second.structure_id() ) );
                         
                         /* Create positions (np0, np1) for the reaction products. 
                         The ipv between the products lies within the reation volume. */
@@ -414,12 +415,12 @@ class newBDPropagator
                                => standard geminate dissociation. 
                                
                                We set: species 0 lives on the surface; species 1 lives in the bulk. */
-                            if( s0.structure_id() != s1.structure_id() )
+                            if( s0.structure_type_id() != s1.structure_type_id() )
                             {
-                                if( !(s0.structure_id() == "world" || s1.structure_id() == "world")  )
+                                if( !(s0.structure_type_id() == tx_.get_def_structure_type_id() || s1.structure_type_id() == tx_.get_def_structure_type_id())  )
                                     throw not_implemented("No surface -> surface + surface - dissociation allowed");
                                                  
-                                if(s0.structure_id() == "world")    
+                                if(s0.structure_type_id() == tx_.get_def_structure_type_id())    
                                      std::swap(s0,s1);
 
                                 pp01 = pp_struct->
@@ -446,21 +447,21 @@ class newBDPropagator
                             /* Only when both products live in the bulk, check for possible overlap with a surface. */
                             bool surface_bounce0( false );
                             bool surface_bounce1( false );
-                            if( s0.structure_id() == "world" && s1.structure_id() == "world" )
+                            if( s0.structure_type_id() == tx_.get_def_structure_type_id() && s1.structure_type_id() == tx_.get_def_structure_type_id() )
                             {
-                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, s0.structure_id() ) );
+                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, tx_.get_def_structure_id() ) );
                                 boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
                                 surface_bounce0 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->structure_position() ), 
-                                                                          tx_.cyclic_transpose( pp01.first, closest_struct->structure_position() ), 
-                                                                          struct_id_distance_pair.second, s0.radius() );
+                                                                           tx_.cyclic_transpose( pp01.first, closest_struct->structure_position() ), 
+                                                                           struct_id_distance_pair.second, s0.radius() );
 
-                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second, s1.structure_id() );
+                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second, tx_.get_def_structure_id() );
                                 closest_struct = tx_.get_structure( struct_id_distance_pair.first );
 
                                 surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->structure_position() ), 
-                                                                          tx_.cyclic_transpose( pp01.second, closest_struct->structure_position() ), 
-                                                                          struct_id_distance_pair.second, s1.radius() );
+                                                                           tx_.cyclic_transpose( pp01.second, closest_struct->structure_position() ), 
+                                                                           struct_id_distance_pair.second, s1.radius() );
                             }
                                     
                             if ( !(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0) 
@@ -524,12 +525,13 @@ class newBDPropagator
     
     
     bool fire_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1, species_type const& s0, species_type const& s1)
+    // unclear what the convention for pp0, pp1 and s0,s1 is with regard to being in 3D/2D.
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
         if(::size(rules) == 0)
             throw propagation_error("trying to fire a reaction between non-reactive particles");
         
-        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
+//        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( pp1.structure_id() ) );
         
         const Real k_tot( k_total(pp0.second.sid(), pp1.second.sid()) );
         const Real rnd( k_tot * rng_() );
@@ -561,9 +563,18 @@ class newBDPropagator
                                         (s0.D() + s1.D()))) );
 
                         //For unequal structures, project new_pos on surface.
-                        if(sp.structure_id() != s1.structure_id())
+                        if(sp.structure_type_id() != s1.structure_type_id())
                         {
-                            boost::shared_ptr<structure_type> sp_struct( tx_.get_structure( sp.structure_id() ) );
+                            // make sure that pp1 is the particle that is in 3D.
+                            // FIXME Ugly!!
+                            boost::shared_ptr<structure_type> sp_struct;
+                            if(pp0.second.structure_id() == tx_.get_def_structure_id())
+                            {   sp_struct = tx_.get_structure( pp1.second.structure_id() );
+                            }
+                            else
+                            {   sp_struct = tx_.get_structure( pp0.second.structure_id() );
+                            }
+
                             projected_type const position_on_surface( sp_struct->
                                                                       projected_point( tx_.cyclic_transpose( new_pos, 
                                                                                                              sp_struct->structure_position() ) ) );
@@ -589,9 +600,9 @@ class newBDPropagator
                             }
                         }
                         
-                        if( sp.structure_id() == "world" )
+                        if( sp.structure_type_id() == tx_.get_def_structure_type_id() )
                         {
-                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, sp.structure_id() ) );
+                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_def_structure_id() ) );
                             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
                             if( closest_struct->bounced( tx_.cyclic_transpose( pp0.second.position(), closest_struct->structure_position() ), 
@@ -711,10 +722,10 @@ class newBDPropagator
     /* Given a position pair and two species, the function generates two new 
        positions based on two moves drawn from the free propegator. */
     position_pair_type const make_pair_move(species_type const& s0, species_type const& s1, position_pair_type const& pp01, 
-                                                particle_id_type const& ignore)
+                                            particle_id_type const& ignore)
     {
-        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
-        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
+//        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+//        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
 
         length_type const r01( s0.radius() + s1.radius() );
         
@@ -743,11 +754,12 @@ class newBDPropagator
     }
 
     position_type const make_move(species_type const& s0, position_type const& old_pos, particle_id_type const& ignore)
+    // generates a move for a particle.
     {
         if(s0.D() == 0)
             return old_pos;
     
-        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
+        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( tx_.get_particle(ignore).second.structure_id() ) );
 
         position_type displacement( s0_struct->
                                     bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
@@ -762,9 +774,9 @@ class newBDPropagator
         if ( (overlapped && overlapped->size() > 0) )
             return old_pos;
         
-        if(s0.structure_id() == "world")
+        if(s0.structure_type_id() == tx_.get_def_structure_type_id())
         {
-            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, s0.structure_id() ) );
+            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_particle(ignore).second.structure_id() ) );
             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
             if( closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->structure_position() ), 

From d37f75cb66b0ef724277bc17f2583ee7b7f897f5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Mar 2012 14:29:08 +0100
Subject: [PATCH 0678/1541] removed old constructors

---
 Particle.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Particle.hpp b/Particle.hpp
index f17d47ae..72217197 100644
--- a/Particle.hpp
+++ b/Particle.hpp
@@ -31,14 +31,14 @@ struct Particle
     // Note that the structure_id is mandatory (?)
     Particle(): shape_(), species_id_(), structure_id_(), D_(0.), v_(0.) {}
 
-    Particle(species_id_type const& species_id, shape_type const& shape,
+/*    Particle(species_id_type const& species_id, shape_type const& shape,
              D_type const& D)
         : shape_(shape), species_id_(species_id), structure_id_(), D_(D), v_(0.){}
 
     Particle(species_id_type const& species_id, shape_type const& shape,
              D_type const& D, v_type const& v)
         : shape_(shape), species_id_(species_id), structure_id_(), D_(D), v_(v) {}
-
+*/
     Particle(species_id_type const& species_id, shape_type const& shape,
              structure_id_type const& structure_id, D_type const& D)
         : shape_(shape), species_id_(species_id), structure_id_(structure_id), D_(D), v_(0.){}

From f5b1ab5178eb23ac414267e0f5e3e1c28d964a46 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Mar 2012 11:56:16 +0100
Subject: [PATCH 0679/1541] cleanup of some typedefs

---
 World.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/World.hpp b/World.hpp
index 6d87f7fd..b09d3f4f 100644
--- a/World.hpp
+++ b/World.hpp
@@ -46,11 +46,10 @@ struct WorldTraitsBase
     typedef SpeciesTypeID                                   species_id_type;    // identifier type for species and (structure types)
     typedef SpeciesTypeID                                   structure_type_id_type;
     typedef StructureType                                   structure_type_type;
-    // TODO add structure_type_id_type?
 //    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
 //    typedef std::string                                     structure_id_type;  // identifier type for structures
     typedef StructureID                                     structure_id_type;
-    typedef SerialIDGenerator<StructureID>                  structure_id_generator;
+    typedef SerialIDGenerator<structure_id_type>            structure_id_generator;
     typedef Particle<length_type, D_type, species_id_type,
                      structure_id_type>                     particle_type;      // type for particles, NOTE why is there no v_type here?
 

From c6d6f6c0bd943cfc18153e85c823a60f3ca31345 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 9 Mar 2012 11:56:56 +0100
Subject: [PATCH 0680/1541] StructureID should also be declared in the bindings

---
 binding/binding_common.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index ec9e2a07..b1762cce 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -47,7 +47,7 @@ typedef ::illegal_state IllegalState;
 typedef ::GSLRandomNumberGenerator GSLRandomNumberGenerator;
 typedef ::CyclicWorldTraits<Real, Real> WorldTraits;            // parameterize the World traits here -> determines many types!!
 typedef WorldTraits::particle_type      Particle;
-//typedef WorldTraits::structure_id_type  StructureID;
+typedef WorldTraits::structure_id_type  StructureID;
 typedef WorldTraits::species_id_type    SpeciesID;
 typedef WorldTraits::species_type       SpeciesInfo;
 typedef WorldTraits::structure_type     Structure;

From 5badd60e42c9f4f0aa2733d1a8a2299677272cc0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Mar 2012 14:49:46 +0100
Subject: [PATCH 0681/1541] Added some comments and cleaned-up some typedefs.

---
 CylindricalSurface.hpp | 12 ++++++------
 Structure.hpp          |  1 -
 Transaction.hpp        | 19 +++++++++++--------
 3 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index af699c4c..3b43ba24 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -16,14 +16,14 @@ class CylindricalSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type         identifier_type;        // THis is just the name of the structure
+    typedef typename base_type::identifier_type         identifier_type;        // This is just the name of the structure
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::shape_type shape_type;
-    typedef typename base_type::rng_type rng_type;
-    typedef typename base_type::position_type position_type;
-    typedef typename base_type::length_type length_type;
+    typedef typename base_type::shape_type              shape_type;
+    typedef typename base_type::rng_type                rng_type;
+    typedef typename base_type::position_type           position_type;
+    typedef typename base_type::length_type             length_type;
     typedef typename Ttraits_::world_type::species_type species_type;
-    typedef std::pair<position_type, position_type> position_pair_type;
+    typedef std::pair<position_type, position_type>     position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     // Gives a random position in the cylinder (1D)
diff --git a/Structure.hpp b/Structure.hpp
index 99b9881b..1cb6dd39 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -26,7 +26,6 @@ class Structure
     typedef typename traits_type::length_type               length_type;
     typedef typename traits_type::position_type             position_type;
     typedef typename traits_type::base_type::species_type   species_type;
-//    typedef SpeciesTypeID                                   species_id_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
     typedef std::pair<position_type, length_type>           projected_type;
     typedef std::pair<position_type, position_type>         position_pair_type;
diff --git a/Transaction.hpp b/Transaction.hpp
index f5172f28..6da08aae 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -28,8 +28,6 @@ class Transaction: public ParticleContainer<Ttraits_>
     typedef typename traits_type::particle_id_type  particle_id_type;
     typedef typename traits_type::size_type         size_type;
     typedef typename traits_type::length_type       length_type;
-    typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::structure_type    structure_type;
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
@@ -48,10 +46,12 @@ class Transaction: public ParticleContainer<Ttraits_>
 
 template<typename Tpc_>
 class TransactionImpl: public Transaction<typename Tpc_::traits_type>
+// Tpc_ is the 'particlecontainer_type'
 {
 public:
     typedef Tpc_ particle_container_type;
-    typedef typename particle_container_type::traits_type   traits_type;
+    typedef typename particle_container_type::traits_type   traits_type;        // get the traits that are passed on from the particlecontainer.
+    // define shorthands to the types that we are using here.
     typedef typename traits_type::particle_type             particle_type;
     typedef typename particle_type::shape_type              particle_shape_type;
     typedef typename traits_type::species_type              species_type;
@@ -216,6 +216,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.get_particles();
     }
 
+    // Begin Transaction methods. The following methods are prototyped in the base class Transaction (see above)
     virtual particle_id_pair_generator* get_added_particles() const
     {
         return make_range_generator<true>(
@@ -258,6 +259,8 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         removed_particles_.clear();
         orig_particles_.clear();
     }
+    // end Transaction methods.
+
 
     virtual length_type distance(position_type const& lhs,
                                  position_type const& rhs) const
@@ -302,11 +305,11 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     }
 
 private:
-    particle_container_type& pc_;
-    particle_id_list_type added_particles_;
-    particle_id_list_type modified_particles_;
-    particle_id_pair_set_type orig_particles_;
-    particle_id_list_type removed_particles_;
+    particle_container_type&    pc_;        // the particle container
+    particle_id_list_type       added_particles_;
+    particle_id_list_type       modified_particles_;
+    particle_id_pair_set_type   orig_particles_;
+    particle_id_list_type       removed_particles_;
 };
 
 #endif /* TRANSACTION_HPP */

From 15072b16628ade2e89493dfd381be089193de8ee Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Mar 2012 16:05:56 +0100
Subject: [PATCH 0682/1541] Added typedefs, datastructures and methods for
 structures and structure_types in the World

---
 World.hpp | 137 ++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 103 insertions(+), 34 deletions(-)

diff --git a/World.hpp b/World.hpp
index b09d3f4f..3500e6ce 100644
--- a/World.hpp
+++ b/World.hpp
@@ -41,11 +41,11 @@ struct WorldTraitsBase
     typedef Tlen_                                           length_type;
     typedef TD_                                             D_type;
     typedef TD_                                             v_type;
-    typedef ParticleID                                      particle_id_type;   // identifier type for particles
+    typedef ParticleID                                      particle_id_type;       // identifier type for particles
     typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
-    typedef SpeciesTypeID                                   species_id_type;    // identifier type for species and (structure types)
+    typedef SpeciesTypeID                                   species_id_type;        // identifier type for species and (structure types)
     typedef SpeciesTypeID                                   structure_type_id_type;
-    typedef StructureType                                   structure_type_type;
+    typedef StructureType                                   structure_type_type;    // definition of what class to use for structure_type
 //    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
 //    typedef std::string                                     structure_id_type;  // identifier type for structures
     typedef StructureID                                     structure_id_type;
@@ -54,7 +54,7 @@ struct WorldTraitsBase
                      structure_id_type>                     particle_type;      // type for particles, NOTE why is there no v_type here?
 
     typedef SpeciesInfo<species_id_type, D_type,
-                        length_type, structure_type_id_type>species_type;       // information associated with the species
+                        length_type, structure_type_id_type>species_type;       // This is the definition of the species in the presence of a World
     typedef Vector3<length_type>                                                    point_type;
     typedef typename particle_type::shape_type::position_type                       position_type;
     typedef GSLRandomNumberGenerator                                                rng_type;
@@ -219,24 +219,33 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     //
     typedef std::pair<const particle_id_type, particle_type>                    particle_id_pair;      // defines the pid_particle_pair tuple
+    typedef std::pair<const structure_id_type, structure_type>                  structure_id_pair;
     typedef std::pair<position_type, length_type>                               projected_type;
     typedef typename particle_container_type::structure_id_and_distance_pair    structure_id_and_distance_pair;
 
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
     typedef std::set<particle_id_type>                                      particle_id_set;
     typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
     typedef select_second<typename species_map::value_type>                 species_second_selector_type;   // not sure what this does.
-    typedef select_second<typename structure_map::value_type>               surface_second_selector_type;
+
+    typedef std::map<structure_type_id_type, structure_type_type>           structure_type_map;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
+    typedef std::set<structure_id_type>                                     structure_id_set;
+    typedef std::map<structure_type_id_type, structure_id_set>              per_structure_type_structure_id_set;
+    typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
+    typedef select_second<typename structure_type_map::value_type>          structure_types_second_selector_type;
 
 public:
     typedef boost::transform_iterator<species_second_selector_type,
-            typename species_map::const_iterator>                   species_iterator;
-    typedef boost::transform_iterator<surface_second_selector_type,
-            typename structure_map::const_iterator>                 surface_iterator;
-    typedef sized_iterator_range<species_iterator>                  species_range;
-    typedef sized_iterator_range<surface_iterator>                  structures_range;
+            typename species_map::const_iterator>                           species_iterator;
+    typedef boost::transform_iterator<structures_second_selector_type,
+            typename structure_map::const_iterator>                         structure_iterator;
+    typedef boost::transform_iterator<structure_types_second_selector_type,
+            typename structure_type_map::const_iterator>                    structure_type_iterator;
+    typedef sized_iterator_range<species_iterator>                          species_range;
+    typedef sized_iterator_range<structure_iterator>                        structures_range;
+    typedef sized_iterator_range<structure_type_iterator>                   structure_types_range;
 
 public:
     // The constructor
@@ -247,7 +256,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
     // TODO Add the default structure of the default structure_type here?
 
-    // To add new particles
+    // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
     {
@@ -259,7 +268,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         update_particle(retval);
         return retval;
     }
-
     // To update particles
     virtual bool update_particle(particle_id_pair const& pi_pair)
     {
@@ -268,6 +276,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         if (i != base_type::pmat_.end())
         {
             if ((*i).second.sid() != pi_pair.second.sid())
+            // If the species changed we need to erase it from the 'species_id -> particle ids' mapping
             {
                 particle_pool_[(*i).second.sid()].erase((*i).first);
                 particle_pool_[pi_pair.second.sid()].insert(pi_pair.first);
@@ -279,7 +288,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         particle_pool_[pi_pair.second.sid()].insert(pi_pair.first);
         return true;
     }
-
     // Remove the particle by id 'id' if present in the world.
     virtual bool remove_particle(particle_id_type const& id)
     {
@@ -296,12 +304,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     // Adds a species to the world.
     void add_species(species_type const& species)
-        // Wouldn't it make more sence to make this method part of the model class instead of the world class?
     {
         species_map_[species.id()] = species;
         particle_pool_[species.id()] = particle_id_set();
     }
-
     // Get the species in the world by id
     virtual species_type const& get_species(species_id_type const& id) const
     {
@@ -312,7 +318,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         return (*i).second;
     }
-
     // Get all the species
     species_range get_species() const
     {
@@ -322,31 +327,73 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             species_map_.size());
     }
 
+    // TODO
+    // remove structure
     // Add a structure 
-    bool add_structure(boost::shared_ptr<structure_type> surface)
+    bool add_structure(boost::shared_ptr<structure_type> structure)
     {
-        return structure_map_.insert(std::make_pair(surface->id(), surface)).second;
+//        return structure_map_.insert(std::make_pair(structure->id(), structure)).second;
+        // FIXME check that the structure_type that is defined in the structure exists!
+        // TODO add mapping from structure id -> set of particles
+        return update_structure(std::make_pair(structidgen_(), structure))
     }
 
+
+    // update structure
+    // FIXME what to do when the structure has particles and moves or changes structure_type?!?!
+    virtual bool update_structure(structure_id_pair const& structid_pair)
+    {
+        typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
+        if (i != structure_map_.end())
+        // The item was already found in the map
+        {
+            if ((*i).second.sid() != structid_pair.second.sid())
+            // If the structuretype changed we need to update the 'structure_type_id -> structure ids' mapping
+            {
+                structure_pool_[(*i).second.sid()].erase((*i).first);
+                structure_pool_[structid_pair.second.sid()].insert(structid_pair.first);
+            }
+            structure_map_.update(i, structid_pair);
+            return false;
+        }
+
+        // create a new item in the structure mapping
+        structure_map_[structid_pair.first] = structid_pair.second;
+        // update the mapping 'structure_type_id -> set of structure ids'
+        structure_pool_[structid_pair.second.sid()].insert(structid_pair.first);
+        return true;
+    }
     // Get a structure by id
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
         if (structure_map_.end() == i)
         {
-            throw not_found(std::string("Unknown surface (id=") + boost::lexical_cast<std::string>(id) + ")");
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
         }
         return (*i).second;
     }
-
     // Get all the structures
     virtual structures_range get_structures() const
     {
         return structures_range(
-            surface_iterator(structure_map_.begin(), surface_second_selector_type()),
-            surface_iterator(structure_map_.end(), surface_second_selector_type()),
+            structure_iterator(structure_map_.begin(), structures_second_selector_type()),
+            structure_iterator(structure_map_.end(),   structures_second_selector_type()),
             structure_map_.size());
     }
+    // Get all the structure ids by structure_type id
+    structure_id_set get_structure_ids(structure_type_id_type const& sid) const
+    {
+        typename per_structure_type_structure_id_set::const_iterator i(
+            structure_pool_.find(sid));
+        if (i == structure_pool_.end())
+        {
+            throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(sid) + ")");
+        }
+        return (*i).second;
+    }
+
+
 
     virtual structure_type_id_type get_def_structure_type_id() const
     {
@@ -364,11 +411,31 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     // TODO
     // Add structureType
-    // update structure
-    // remove structure
-    // Get structure ids by structure type
-    
-    // FIXME This is probably not very usefull any more.
+    void add_structure_type(structure_type_type const& structure_type)
+    {
+        structure_type_map_[structure_type.id()] = structure_type;
+        structure_pool_[structure_type.id()] = structure_id_set();
+    }
+    // Get structureType by id
+    virtual structure_type_type const& get_structure_type(structure_type_id_type const& id) const
+    {
+        typename structure_type_map::const_iterator i(structure_type_map_.find(id));
+        if (structure_type_map_.end() == i)
+        {
+            throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
+    // Get all structureTypes in the world
+    structure_types_range get_structure_types() const
+    {
+        return structure_types_range(
+            structure_type_iterator(structure_type_map_.begin(), structure_types_second_selector_type()),
+            structure_type_iterator(structure_type_map_.end(), structure_types_second_selector_type()),
+            structure_type_map_.size());
+    }
+
+    // Get the closest surface
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {       
         length_type const world_size( base_type::world_size() );
@@ -407,14 +474,16 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
 ///////////// Member variables
 private:
-    particle_id_generator       pidgen_;            // generator used to produce the unique ids for the particles
-    species_map                 species_map_;       // ?
-    structure_map               structure_map_;     // ?
-    per_species_particle_id_set particle_pool_;
-    structure_id_generator      structidgen_;
-    StructureID                 default_structure_id_;
+    Structure_id_type           default_structure_id_;
     structure_type_id_type      default_structure_type_id_;
     structure_type_type         default_structure_; // TODO remove later again.
+    particle_id_generator               pidgen_;            // generator used to produce the unique ids for the particles
+    structure_id_generator              structidgen_;
+    species_map                         species_map_;       // mapping: species_id -> species
+    structure_type_map                  structure_type_map_;// mapping: structure_type_id -> structure_type
+    structure_map                       structure_map_;     // mapping: structure_id -> structure
+    per_structure_type_structure_id_set structure_pool_;    // mapping: structure_type_id -> set of structure ids of that structure type
+    per_species_particle_id_set         particle_pool_;     // mapping: species_id -> set of particle ids of that species
 };
 
 #endif /* WORLD_HPP */

From 0c6e72d62cd42b1e6fc326c49029972a5f74e750 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Mar 2012 16:07:38 +0100
Subject: [PATCH 0683/1541] Number of changes to world to make mapping
 species/particles/structure_types/structures more complete added comments.
 added map from structure -> particle IDs added method to get particles on a
 structure added check that structure_type exist when adding a species (every
 species has a structure_type on which to live)

---
 World.hpp | 75 ++++++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 58 insertions(+), 17 deletions(-)

diff --git a/World.hpp b/World.hpp
index 3500e6ce..8ee06011 100644
--- a/World.hpp
+++ b/World.hpp
@@ -233,6 +233,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
     typedef std::set<structure_id_type>                                     structure_id_set;
     typedef std::map<structure_type_id_type, structure_id_set>              per_structure_type_structure_id_set;
+    typedef std::map<structure_id_type, particle_id_set>                    per_structure_particle_id_set;
     typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
     typedef select_second<typename structure_type_map::value_type>          structure_types_second_selector_type;
 
@@ -257,10 +258,15 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // TODO Add the default structure of the default structure_type here?
 
     // To create new particles
-    virtual particle_id_pair new_particle(species_id_type const& sid,
+    virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos)
     {
         species_type const& species(get_species(sid));
+//        structure_type const& structure(get_structure(structure_id));
+        boost::shared_ptr<structure_type> structure(get_structure(structure_id));
+        // assert that the structure is of the type denoted by the species of the particle.
+        BOOST_ASSERT(structure.sid == species.structure_type_id)
+
         particle_id_pair retval(pidgen_(),
                                 particle_type(sid, particle_shape_type(pos, species.radius()),
                                               default_structure_id_, species.D(), species.v() ));
@@ -274,18 +280,28 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         typename base_type::particle_matrix_type::iterator i(
                 base_type::pmat_.find(pi_pair.first));
         if (i != base_type::pmat_.end())
+        // The particle was already in the matrix
         {
             if ((*i).second.sid() != pi_pair.second.sid())
-            // If the species changed we need to erase it from the 'species_id -> particle ids' mapping
+            // If the species changed we need to change the 'species_id -> particle ids' mapping
             {
                 particle_pool_[(*i).second.sid()].erase((*i).first);
                 particle_pool_[pi_pair.second.sid()].insert(pi_pair.first);
             }
+            if ((*i).second.structure_id() != pi_pair.second.structure_id())
+            // If the structure changed we need to change the 'structure_id -> particle ids' mapping
+            {
+                particleonstruct_pool_[(*i).second.structure_id()].erase((*i).first);
+                particleonstruct_pool_[pi_pair.second.structure_id()].insert(pi_pair.first);
+            }
             base_type::pmat_.update(i, pi_pair);
             return false;
         }
-        BOOST_ASSERT(base_type::update_particle(pi_pair));
-        particle_pool_[pi_pair.second.sid()].insert(pi_pair.first);
+
+        // The particle didn't exist yet
+        BOOST_ASSERT(base_type::update_particle(pi_pair));                              // update particle
+        particle_pool_[pi_pair.second.sid()].insert(pi_pair.first);                     // update species->particles map
+        particleonstruct_pool_[pi_pair.second.structure_id()].insert(pi_pair.first);    // update structure->particles map
         return true;
     }
     // Remove the particle by id 'id' if present in the world.
@@ -297,18 +313,22 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         {
             return false;
         }
-        particle_pool_[pp.second.sid()].erase(id);
-        base_type::remove_particle(id);
+        particle_pool_[pp.second.sid()].erase(id);                  // remove particle from species->particles
+        particleonstruct_pool_[pp.second.structure_id()].erase(id); // remove particle from structure->particles
+        base_type::remove_particle(id);                             // remove particle
         return true;
     }
 
     // Adds a species to the world.
     void add_species(species_type const& species)
     {
+        // make sure that the structure_type defined in the species exists
+        structure_type_type const& structure_type(get_structure_type(species.structure_type_id()));
+
         species_map_[species.id()] = species;
         particle_pool_[species.id()] = particle_id_set();
     }
-    // Get the species in the world by id
+    // Get a species in the world by id
     virtual species_type const& get_species(species_id_type const& id) const
     {
         typename species_map::const_iterator i(species_map_.find(id));
@@ -329,38 +349,46 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     // TODO
     // remove structure
+    //  get all particles on structure
+    //  only remove if no particles
+
     // Add a structure 
     bool add_structure(boost::shared_ptr<structure_type> structure)
     {
-//        return structure_map_.insert(std::make_pair(structure->id(), structure)).second;
-        // FIXME check that the structure_type that is defined in the structure exists!
-        // TODO add mapping from structure id -> set of particles
+        // check that the structure_type that is defined in the structure exists!
+        structure_type_type const& structure_type(get_structure_type(structure.sid))
+
         return update_structure(std::make_pair(structidgen_(), structure))
     }
-
-
     // update structure
-    // FIXME what to do when the structure has particles and moves or changes structure_type?!?!
     virtual bool update_structure(structure_id_pair const& structid_pair)
     {
         typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
         if (i != structure_map_.end())
         // The item was already found in the map
         {
-            if ((*i).second.sid() != structid_pair.second.sid())
-            // If the structuretype changed we need to update the 'structure_type_id -> structure ids' mapping
+            // FIXME what to do when the structure has particles and moves or changes structure_type?!?!
+            //  get all particles on the structure
+            //  assert that no particles if structure type changes.
+
+
+            if ((*i).second.sid != structid_pair.second.sid)
+            // If the structuretype changed we need to update the 'structure_type_id->structure ids' mapping
             {
-                structure_pool_[(*i).second.sid()].erase((*i).first);
-                structure_pool_[structid_pair.second.sid()].insert(structid_pair.first);
+                structure_pool_[(*i).second.sid].erase((*i).first);
+                structure_pool_[structid_pair.second.sid].insert(structid_pair.first);
             }
             structure_map_.update(i, structid_pair);
             return false;
         }
 
+        // The structure was not yet in the world.
         // create a new item in the structure mapping
         structure_map_[structid_pair.first] = structid_pair.second;
         // update the mapping 'structure_type_id -> set of structure ids'
         structure_pool_[structid_pair.second.sid()].insert(structid_pair.first);
+        // create a new mapping from structure id -> set of particles
+        particleonstruct_pool_[structid_pair.first] = particle_id_set();
         return true;
     }
     // Get a structure by id
@@ -471,6 +499,18 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         return (*i).second;
     }
+    // Get all the particle ids of the particles on a structure
+    particle_id_set get_particle_ids_on_struct(structure_id_type const& struct_id) const
+    {
+        typename per_structure_particle_id_set::const_iterator i(
+            particleonstruct_pool_.find(struct_id));
+        if (i == particleonstruct_pool_.end())
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(sid) + ")");
+        }
+        return (*i).second;
+    }
+
 
 ///////////// Member variables
 private:
@@ -484,6 +524,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     structure_map                       structure_map_;     // mapping: structure_id -> structure
     per_structure_type_structure_id_set structure_pool_;    // mapping: structure_type_id -> set of structure ids of that structure type
     per_species_particle_id_set         particle_pool_;     // mapping: species_id -> set of particle ids of that species
+    per_structure_particle_id_set       particleonstruct_pool_;
 };
 
 #endif /* WORLD_HPP */

From b1251aa5bd4a7dd99f53a87970404f25fc442338 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Mar 2012 18:17:54 +0100
Subject: [PATCH 0684/1541] Some cleanup and additions to World.hpp

---
 World.hpp | 133 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 68 insertions(+), 65 deletions(-)

diff --git a/World.hpp b/World.hpp
index 8ee06011..a44cad2b 100644
--- a/World.hpp
+++ b/World.hpp
@@ -37,28 +37,33 @@ struct WorldTraitsBase
 // Just defines some basic properties of a world. Basically just types and one constant.
 // Tderived_ is the class/structure that inherits from this struct (subclass) -> WorldTraits and CyclicWorldTraits
 {
+    // General
     typedef std::size_t                                     size_type;
     typedef Tlen_                                           length_type;
     typedef TD_                                             D_type;
     typedef TD_                                             v_type;
-    typedef ParticleID                                      particle_id_type;       // identifier type for particles
-    typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
-    typedef SpeciesTypeID                                   species_id_type;        // identifier type for species and (structure types)
-    typedef SpeciesTypeID                                   structure_type_id_type;
+
+    // Structure types
     typedef StructureType                                   structure_type_type;    // definition of what class to use for structure_type
-//    typedef Particle<length_type, D_type, species_id_type>  particle_type;      // type for particles, NOTE why is there no v_type here?
-//    typedef std::string                                     structure_id_type;  // identifier type for structures
-    typedef StructureID                                     structure_id_type;
+    typedef SpeciesTypeID                                   structure_type_id_type;
+    // Structures
+    typedef Structure<Tderived_>                            structure_type;         // The structure_type is parameterized with the subclass??
+    typedef StructureID                                     structure_id_type;      // identifier type for structures
     typedef SerialIDGenerator<structure_id_type>            structure_id_generator;
+//    typedef std::string                                     structure_name_type;
+    // Species
+    typedef SpeciesTypeID                                   species_id_type;        // identifier type for species
+    typedef SpeciesInfo<species_id_type, D_type,
+                        length_type, structure_type_id_type>species_type;           // This is the definition of the species in the presence of a World
+    // Particles
     typedef Particle<length_type, D_type, species_id_type,
-                     structure_id_type>                     particle_type;      // type for particles, NOTE why is there no v_type here?
+                     structure_id_type>                     particle_type;          // type for particles, NOTE why is there no v_type here?
+    typedef ParticleID                                      particle_id_type;       // identifier type for particles
+    typedef SerialIDGenerator<particle_id_type>             particle_id_generator;
 
-    typedef SpeciesInfo<species_id_type, D_type,
-                        length_type, structure_type_id_type>species_type;       // This is the definition of the species in the presence of a World
-    typedef Vector3<length_type>                                                    point_type;
-    typedef typename particle_type::shape_type::position_type                       position_type;
-    typedef GSLRandomNumberGenerator                                                rng_type;
-    typedef Structure<Tderived_>                                                    structure_type; // The structure_type is parameterized with the subclass??
+    typedef Vector3<length_type>                                point_type;
+    typedef typename particle_type::shape_type::position_type   position_type;
+    typedef GSLRandomNumberGenerator                            rng_type;
 
     static const Real TOLERANCE = 1e-7;         // tolerance of what?
 };
@@ -211,29 +216,28 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::species_id_type           species_id_type;        // Note that this is also the structure_type_id_type
     typedef typename traits_type::particle_type::shape_type particle_shape_type;
     typedef typename traits_type::size_type                 size_type;
+    typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_id_generator    structure_id_generator;
-    typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     //
-    typedef std::pair<const particle_id_type, particle_type>                    particle_id_pair;      // defines the pid_particle_pair tuple
-    typedef std::pair<const structure_id_type, structure_type>                  structure_id_pair;
-    typedef std::pair<position_type, length_type>                               projected_type;
-    typedef typename particle_container_type::structure_id_and_distance_pair    structure_id_and_distance_pair;
+    typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;      // defines the pid_particle_pair tuple
+    typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
+    typedef std::pair<position_type, length_type>                                   projected_type;
+    typedef typename particle_container_type::structure_id_and_distance_pair        structure_id_and_distance_pair;
 
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
-    typedef std::set<particle_id_type>                                      particle_id_set;
-    typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
-    typedef select_second<typename species_map::value_type>                 species_second_selector_type;   // not sure what this does.
-
-    typedef std::map<structure_type_id_type, structure_type_type>           structure_type_map;
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
+    typedef std::map<structure_type_id_type, structure_type_type>           structure_type_map;
+    typedef std::set<particle_id_type>                                      particle_id_set;
     typedef std::set<structure_id_type>                                     structure_id_set;
+    typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
     typedef std::map<structure_type_id_type, structure_id_set>              per_structure_type_structure_id_set;
     typedef std::map<structure_id_type, particle_id_set>                    per_structure_particle_id_set;
+    typedef select_second<typename species_map::value_type>                 species_second_selector_type;   // not sure what this does.
     typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
     typedef select_second<typename structure_type_map::value_type>          structure_types_second_selector_type;
 
@@ -253,23 +257,27 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     World(length_type world_size = 1., size_type size = 1)
         : base_type(world_size, size)
     {
+        // TODO Add the default structure of the default structure_type here?
         default_structure_id_ = structidgen_();
     }
-    // TODO Add the default structure of the default structure_type here?
 
+    // Old method is case no structure_id is supplied.
+    virtual particle_id_pair new_particle(species_id_type const& sid, position_type const& pos)
+    {
+        return new_particle(sid, default_structure_id_, pos);
+    }
     // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos)
     {
         species_type const& species(get_species(sid));
-//        structure_type const& structure(get_structure(structure_id));
         boost::shared_ptr<structure_type> structure(get_structure(structure_id));
         // assert that the structure is of the type denoted by the species of the particle.
-        BOOST_ASSERT(structure.sid == species.structure_type_id)
+        BOOST_ASSERT(structure->sid() == species.structure_type_id());
 
         particle_id_pair retval(pidgen_(),
                                 particle_type(sid, particle_shape_type(pos, species.radius()),
-                                              default_structure_id_, species.D(), species.v() ));
+                                              structure_id, species.D(), species.v() ));
 
         update_particle(retval);
         return retval;
@@ -308,7 +316,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     virtual bool remove_particle(particle_id_type const& id)
     {
         bool found(false);
-        particle_id_pair pp(get_particle(id, found));
+        particle_id_pair pp(get_particle(id, found));               // call method in ParticleContainerBase
         if (!found)
         {
             return false;
@@ -343,22 +351,17 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         return species_range(
             species_iterator(species_map_.begin(), species_second_selector_type()),
-            species_iterator(species_map_.end(), species_second_selector_type()),
+            species_iterator(species_map_.end(),   species_second_selector_type()),
             species_map_.size());
     }
 
-    // TODO
-    // remove structure
-    //  get all particles on structure
-    //  only remove if no particles
-
     // Add a structure 
     bool add_structure(boost::shared_ptr<structure_type> structure)
     {
         // check that the structure_type that is defined in the structure exists!
-        structure_type_type const& structure_type(get_structure_type(structure.sid))
+        structure_type_type const& structure_type(get_structure_type(structure->sid()));
 
-        return update_structure(std::make_pair(structidgen_(), structure))
+        return update_structure(std::make_pair(structidgen_(), structure));
     }
     // update structure
     virtual bool update_structure(structure_id_pair const& structid_pair)
@@ -372,13 +375,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             //  assert that no particles if structure type changes.
 
 
-            if ((*i).second.sid != structid_pair.second.sid)
+            if ((*i).second->sid() != structid_pair.second->sid())
             // If the structuretype changed we need to update the 'structure_type_id->structure ids' mapping
             {
-                structure_pool_[(*i).second.sid].erase((*i).first);
-                structure_pool_[structid_pair.second.sid].insert(structid_pair.first);
+                structure_pool_[(*i).second->sid()].erase((*i).first);
+                structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
             }
-            structure_map_.update(i, structid_pair);
+            structure_map_[(*i).first] = structid_pair.second;
             return false;
         }
 
@@ -386,11 +389,19 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         // create a new item in the structure mapping
         structure_map_[structid_pair.first] = structid_pair.second;
         // update the mapping 'structure_type_id -> set of structure ids'
-        structure_pool_[structid_pair.second.sid()].insert(structid_pair.first);
+        structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
         // create a new mapping from structure id -> set of particles
         particleonstruct_pool_[structid_pair.first] = particle_id_set();
         return true;
     }
+    // remove structure
+    virtual bool remove_structure(structure_id_type const& id)
+    {
+        // TODO
+        //  -get all particles on structure
+        //  -only remove if no particles
+        return false;
+    }
     // Get a structure by id
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
@@ -420,21 +431,9 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         return (*i).second;
     }
-
-
-
-    virtual structure_type_id_type get_def_structure_type_id() const
-    {
-        return default_structure_type_id_;
-    }
-
-    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
-    {
-        return default_structure_; // TODO
-    }
-
     virtual structure_id_type get_def_structure_id() const
-    {   return default_structure_id_;
+    {
+        return default_structure_id_;
     }
 
     // TODO
@@ -445,12 +444,12 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         structure_pool_[structure_type.id()] = structure_id_set();
     }
     // Get structureType by id
-    virtual structure_type_type const& get_structure_type(structure_type_id_type const& id) const
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
     {
-        typename structure_type_map::const_iterator i(structure_type_map_.find(id));
+        typename structure_type_map::const_iterator i(structure_type_map_.find(sid));
         if (structure_type_map_.end() == i)
         {
-            throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(id) + ")");
+            throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(sid) + ")");
         }
         return (*i).second;
     }
@@ -462,8 +461,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             structure_type_iterator(structure_type_map_.end(), structure_types_second_selector_type()),
             structure_type_map_.size());
     }
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return default_structure_type_id_;
+    }
 
-    // Get the closest surface
+
+    // Get the closest surface(surface is a subclass of structures)
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {       
         length_type const world_size( base_type::world_size() );
@@ -506,17 +510,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             particleonstruct_pool_.find(struct_id));
         if (i == particleonstruct_pool_.end())
         {
-            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(sid) + ")");
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(struct_id) + ")");
         }
         return (*i).second;
     }
 
-
 ///////////// Member variables
 private:
-    Structure_id_type           default_structure_id_;
-    structure_type_id_type      default_structure_type_id_;
-    structure_type_type         default_structure_; // TODO remove later again.
     particle_id_generator               pidgen_;            // generator used to produce the unique ids for the particles
     structure_id_generator              structidgen_;
     species_map                         species_map_;       // mapping: species_id -> species
@@ -525,6 +525,9 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     per_structure_type_structure_id_set structure_pool_;    // mapping: structure_type_id -> set of structure ids of that structure type
     per_species_particle_id_set         particle_pool_;     // mapping: species_id -> set of particle ids of that species
     per_structure_particle_id_set       particleonstruct_pool_;
+
+    structure_id_type                   default_structure_id_;
+    structure_type_id_type              default_structure_type_id_;
 };
 
 #endif /* WORLD_HPP */

From a63fa5e1f934f6b968b097c38f7eb9f20225bc0a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 12 Mar 2012 18:18:31 +0100
Subject: [PATCH 0685/1541] some reordering of methods.

---
 ParticleContainer.hpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 8d206fbb..6914412f 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -52,17 +52,19 @@ class ParticleContainer
 
     virtual length_type world_size() const = 0;
 
+    // Species stuff
     virtual species_type const& get_species(species_id_type const& id) const = 0;
 
+    // StructureType stuff
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const = 0;
+
+    virtual structure_type_id_type get_def_structure_type_id() const = 0;
+
     // Structure stuff
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
     virtual structures_range get_structures() const = 0;
 
-    virtual structure_type_id_type get_def_structure_type_id() const = 0;
-
-    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const = 0;
-
     virtual structure_id_type get_def_structure_id() const = 0;
 
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;

From ce42e9b5ceebcb9d76dc60bf78fe018eea30ed2f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Mar 2012 16:02:52 +0100
Subject: [PATCH 0686/1541] Introduced setters for default_structure and
 default_structure_type This to avoid having to create the default structure
 when creating the world. This causes complications and can better be done
 outside the class. To accomodate this mechanism, the 'add_structure' method
 now return the used ID.

---
 World.hpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/World.hpp b/World.hpp
index a44cad2b..6542d483 100644
--- a/World.hpp
+++ b/World.hpp
@@ -258,7 +258,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         : base_type(world_size, size)
     {
         // TODO Add the default structure of the default structure_type here?
-        default_structure_id_ = structidgen_();
+//        default_structure_id_ = structidgen_();
     }
 
     // Old method is case no structure_id is supplied.
@@ -361,7 +361,9 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         // check that the structure_type that is defined in the structure exists!
         structure_type_type const& structure_type(get_structure_type(structure->sid()));
 
-        return update_structure(std::make_pair(structidgen_(), structure));
+        structure_id_type structure_id(structidgen_());
+        if (update_structure(std::make_pair(structure_id, structure)))
+            return structure_id;
     }
     // update structure
     virtual bool update_structure(structure_id_pair const& structid_pair)
@@ -435,6 +437,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         return default_structure_id_;
     }
+    void set_def_structure_id(structure_id_type const& id)
+    {
+        default_structure_id_ = id;
+    }
 
     // TODO
     // Add structureType
@@ -465,6 +471,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         return default_structure_type_id_;
     }
+    void set_def_structure_type_id(structure_type_id_type const& sid)
+    {
+        default_structure_type_id_ = sid;
+    }
 
 
     // Get the closest surface(surface is a subclass of structures)

From fdcb9977acc2a416c7ece52c9164b7e1bf54178f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Mar 2012 17:57:28 +0100
Subject: [PATCH 0687/1541] Making sure that we don't use the ID that is stored
 in the structure Because in the future this information will be removed. The
 ID is instead taken from the Particle.

---
 newBDPropagator.hpp | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index d9ff34d9..f45fb2bf 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -44,7 +44,7 @@ class newBDPropagator
     typedef typename particle_container_type::particle_id_pair_and_distance particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
     typedef typename particle_container_type::structure_type structure_type;
-    typedef typename particle_container_type::structure_id_type structure_id_type;    
+//    typedef typename particle_container_type::structure_id_type structure_id_type;    
     typedef typename traits_type::world_type::traits_type::rng_type rng_type;
     typedef typename traits_type::time_type time_type;
     typedef typename traits_type::network_rules_type network_rules_type;
@@ -142,9 +142,9 @@ class newBDPropagator
         
         /* If the particle has not bounced with another particle and lives in the bulk: 
            check for core overlap with a surface. */
-        if(!bounced && pp_structure->id() == tx_.get_def_structure_id())
+        if(!bounced && pp.second.structure_id() == tx_.get_def_structure_id())
         {
-            struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
+            struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp.second.structure_id());
             particle_surface_distance = struct_id_distance_pair.second;
 
             /* Check for overlap with nearest surface. */
@@ -167,9 +167,9 @@ class newBDPropagator
                                             
             particles_in_overlap = overlapped ? overlapped->size(): 0; 
             
-            if(pp_structure->id() == tx_.get_def_structure_id())
+            if(pp.second.structure_id() == tx_.get_def_structure_id())
             {
-                struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp_structure->id() );
+                struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp.second.structure_id() );
                 particle_surface_distance = struct_id_distance_pair.second;  
             }
         }
@@ -180,7 +180,7 @@ class newBDPropagator
         Real const rnd( rng_() );
         
         /* First, if a surface is inside the reaction volume, attempt an interaction. */
-        if( pp_structure->id() == tx_.get_def_structure_id())
+        if( pp.second.structure_id() == tx_.get_def_structure_id())
         {
             if( tx_.get_structure( struct_id_distance_pair.first )->
                 in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
@@ -368,9 +368,9 @@ class newBDPropagator
                             }
                         }
 
-                        if( s0.structure_type_id() == tx_.get_def_structure_type_id() && pp_struct->id() == tx_.get_def_structure_id() )
+                        if( s0.structure_type_id() == tx_.get_def_structure_type_id() && pp.second.structure_id() == tx_.get_def_structure_id() )
                         {
-                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, pp_struct->id()) );
+                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, pp.second.structure_id()) );
                             
                             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 

From 601f7c2c2e1011f83e987a5f718236e2be138a36 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Mar 2012 18:01:33 +0100
Subject: [PATCH 0688/1541] Changed the old 'id' of a Structure to be just the
 name and introduced a 'real_id' The real_id is gotten from the World when
 adding the structure to the world.

---
 Region.hpp            |  4 ++--
 Structure.hpp         | 26 +++++++++++++++++++++-----
 StructureUtils.hpp    |  2 +-
 Surface.hpp           |  4 ++--
 World.hpp             |  8 +++++---
 binding/Structure.hpp |  2 +-
 newBDPropagator.hpp   |  2 +-
 7 files changed, 33 insertions(+), 15 deletions(-)

diff --git a/Region.hpp b/Region.hpp
index 32329ad2..0da4ae0d 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -59,7 +59,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     {
         BasicRegionImpl const* _rhs(dynamic_cast<BasicRegionImpl const*>(&rhs));
         return _rhs &&
-               base_type::id_ == rhs.id() &&
+               base_type::real_id_ == rhs.real_id() &&
                base_type::sid_ == rhs.sid() &&
                shape_ == _rhs->shape();
     }
@@ -81,7 +81,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     virtual std::string as_string() const
     {
         std::ostringstream out;
-        out << "Region(" << base_type::id_ << ":" << shape() << ")";
+        out << "Region(" << base_type::real_id_ << ":" << shape() << ")";
         return out.str();
     }
 
diff --git a/Structure.hpp b/Structure.hpp
index 1cb6dd39..60da0e2c 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -22,7 +22,8 @@ class Structure
     typedef Ttraits_ traits_type;
     // shorthands for types that we use
     typedef typename traits_type::rng_type                  rng_type;
-    typedef typename traits_type::structure_id_type         identifier_type;
+    typedef typename traits_type::structure_name_type       identifier_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::length_type               length_type;
     typedef typename traits_type::position_type             position_type;
     typedef typename traits_type::base_type::species_type   species_type;
@@ -33,11 +34,25 @@ class Structure
 public:
     virtual ~Structure() {}
 
-    identifier_type const& id() const
+    identifier_type const& name()
     {
         return id_;
     }
 
+    structure_id_type const& real_id() const
+    {
+        if (!real_id_)
+        {
+            throw illegal_state("ID for structure not defined");
+        }
+        return real_id_;
+    }
+
+    void set_id(structure_id_type const& id)
+    {
+        real_id_ = id;
+    }
+
     // Get the StructureType of the structure
     structure_type_id_type const& sid() const
     {
@@ -55,7 +70,7 @@ class Structure
 
     virtual bool operator==(Structure const& rhs) const
     {
-        return id_ == rhs.id() && sid_ == rhs.sid();
+        return real_id_ == rhs.real_id() && sid_ == rhs.sid();
     }
 
     bool operator!=(Structure const& rhs) const
@@ -117,7 +132,7 @@ class Structure
     virtual std::string as_string() const
     {
         std::ostringstream out;
-        out << "Structure(" << id() << ", " << sid() << ")";
+        out << "Structure(" << real_id() << ", " << sid() << ")";
         return out.str();
     }
 
@@ -127,7 +142,8 @@ class Structure
 
 ////// Member variables
 protected:
-    identifier_type         id_;        // id of the structure
+    structure_id_type       real_id_;   // id of the structure
+    identifier_type         id_;        // This is now just the name
     structure_type_id_type  sid_;       // id of the structure_type of the structure
 };
 
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index f96d4078..3a718381 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -16,7 +16,7 @@ struct StructureUtils
     typedef typename simulator_type::traits_type traits_type;
     typedef typename traits_type::world_type::position_type             position_type;
     typedef typename traits_type::world_type::length_type               length_type;
-    typedef typename traits_type::world_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::world_type::structure_name_type       structure_id_type;
     typedef typename traits_type::world_type::structure_type            structure_type;
     typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
     typedef typename simulator_type::surface_type               surface_type;
diff --git a/Surface.hpp b/Surface.hpp
index 08bd0db4..25c258f0 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -68,7 +68,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     {
         BasicSurfaceImpl const* _rhs(dynamic_cast<BasicSurfaceImpl const*>(&rhs));
         return _rhs &&
-               base_type::id_ == rhs.id() &&
+               base_type::real_id_ == rhs.real_id() &&
                base_type::sid_ == rhs.sid() &&
                shape_ == _rhs->shape();
     }
@@ -90,7 +90,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     virtual std::string as_string() const
     {
         std::ostringstream out;
-        out << "Surface(" << base_type::id_ << ":" << shape() << ")";
+        out << "Surface(" << base_type::real_id_ << ":" << shape() << ")";
         return out.str();
     }
 
diff --git a/World.hpp b/World.hpp
index 6542d483..1ca26510 100644
--- a/World.hpp
+++ b/World.hpp
@@ -50,7 +50,7 @@ struct WorldTraitsBase
     typedef Structure<Tderived_>                            structure_type;         // The structure_type is parameterized with the subclass??
     typedef StructureID                                     structure_id_type;      // identifier type for structures
     typedef SerialIDGenerator<structure_id_type>            structure_id_generator;
-//    typedef std::string                                     structure_name_type;
+    typedef std::string                                     structure_name_type;
     // Species
     typedef SpeciesTypeID                                   species_id_type;        // identifier type for species
     typedef SpeciesInfo<species_id_type, D_type,
@@ -218,6 +218,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::size_type                 size_type;
     typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_name_type       structure_name_type;
     typedef typename traits_type::structure_id_generator    structure_id_generator;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
@@ -362,6 +363,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         structure_type_type const& structure_type(get_structure_type(structure->sid()));
 
         structure_id_type structure_id(structidgen_());
+        structure->set_id(structure_id);
         if (update_structure(std::make_pair(structure_id, structure)))
             return structure_id;
     }
@@ -486,7 +488,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
         BOOST_FOREACH(boost::shared_ptr<structure_type> const structure, get_structures())
         {
-            if( structure->id() == ignore )
+            if( structure->real_id() == ignore)
                 continue;
             
             position_type const cyc_pos(cyclic_transpose(pos, structure->structure_position(), world_size));
@@ -495,7 +497,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             if( dist < ret_dist )
             {
                 ret_dist = dist;
-                ret_id = structure->id();
+                ret_id = structure->real_id();
             }  
         }
         
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index bafd2a10..ddce42a0 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -18,7 +18,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
     return class_<impl_type, boost::shared_ptr<impl_type>,
                   boost::noncopyable>(name, no_init)
         .add_property("id", 
-            make_function(&impl_type::id,
+            make_function(&impl_type::real_id,
                           return_value_policy<return_by_value>()))
         .add_property("sid",
             make_function(
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index f45fb2bf..a6cafaca 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -214,7 +214,7 @@ class newBDPropagator
                 else                
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
-                               boost::lexical_cast<std::string>(closest_surf->id()).c_str()));
+                               boost::lexical_cast<std::string>(closest_surf->real_id()).c_str()));
                     ++rejected_move_count_;
                 }
             }

From ed0e283248d12881d45e058b4d7afe2c615aeea1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Mar 2012 18:56:03 +0100
Subject: [PATCH 0689/1541] Some necessary changes to shellmaking stuff

- PlanarSurfaceEdgeSingle had not shell_list_for_single and
  shell_list_for_others; copied from SphericalSingle for now
- Extended test distance calculation for PlanarSingles to PlanarPairs
---
 shells.py |   8 +--
 single.py | 166 ++++++++++--------------------------------------------
 2 files changed, 33 insertions(+), 141 deletions(-)

diff --git a/shells.py b/shells.py
index d66f54ed..10361908 100755
--- a/shells.py
+++ b/shells.py
@@ -68,7 +68,7 @@ class testShellError(Exception):
 # dimensions dependent on the one who asks. The asker and the askee are now both a NonInteractionSingle
 # or an Other.
 # The main difference between the NonInteractionSingles and Others is that the NonInteractionSingle
-# keep the Other domains at a distance such that the probably that the Other domain get bursted is
+# keep the Other domains at a distance such that the probability that the Other domain get bursted is
 # minimized.
 class Others(object):
 # Subclasses of Others are: all Pair, Interaction and Multi domains.
@@ -689,9 +689,9 @@ def get_radius_to_CylindricalShape(shape, testShell, r):
     return min(r, r_new)
 
 def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
-    # TODO / HACK : This will work only for PlanarSurfaceSingles for now!
+    # TODO / HACK : This will work only for PlanarSurface shells for now!
     assert (type(shape) is Plane)
-    assert isinstance(testShell, PlanarSurfaceSingletestShell)
+    assert isinstance(testShell, PlanarSurfaceSingletestShell) or isinstance(testShell, PlanarSurfacePairtestShell)
 
     if( feq(numpy.dot(shape.unit_z, testShell.get_orientation_vector()), 0.0) ) :
     #if(True) :
@@ -917,7 +917,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             # FIXME: This gives an error 'NoneType' object is not iterable if neighbours are present
-            # Probably sth. about get_neighbor_shell_list not returning the right type
+            # This is because get_neighbor_shell_list_for_single is not implemented in PlanarSurfaceEdgeSingle yet! TODO!
             print shell_list # HACK
             for _, shell_appearance in shell_list:
                 if isinstance(shell_appearance.shape, Sphere):
diff --git a/single.py b/single.py
index 5f9abb14..98557c09 100644
--- a/single.py
+++ b/single.py
@@ -12,6 +12,7 @@
 from greens_function_wrapper import *
 from constants import EventType
 from utils import *
+from edgetools import *
 
 from domain import (
     Domain,
@@ -938,7 +939,7 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
-class PlanarSurfaceEdgeSingle(NonInteractionSingle, hasSphericalShell, Others): # HACK
+class PlanarSurfaceEdgeSingle(NonInteractionSingle, hasSphericalShell, EdgeTools, Others): # HACK
     """1 Particle inside a (spherical) shell at the edge of two planar surfaces
 
         * Particle coordinates on surface: x, y.
@@ -951,8 +952,8 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
 
         assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-#        Single.__init__(self, domain_id, shell_id, reactionrules)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
+        EdgeTools.__init__(self, testShell, self.pid_particle_pair[1].position)
         # Note: for the Others superclass nothing is to be initialized.
 
         self.pid_particle_pair = testShell.single.pid_particle_pair
@@ -961,28 +962,11 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         self.intrule = None
         self.interaction_ktot = self.calc_ktot(interactionrules)
 
-        # Used internally
-        self.origin_surface  = testShell.origin_surface
-        self.target_surface  = testShell.target_surface
-        self.origin_center = self.origin_surface.shape.position
-        self.target_center = self.target_surface.shape.position
-        self.origin_half_extent = self.origin_surface.shape.half_extent
-        self.target_half_extent = self.target_surface.shape.half_extent
-
         # This has to be set because external functions will use it
+        # origin_surface and target_surface etc. are inherited from EdgeTools
         self.structure = self.origin_surface
         self.surface = self.target_surface
 
-        self.start_position = self.pid_particle_pair[1].position
-        self.target_distance = testShell.get_distance_to_target_surface()
-        # Keep the order of the following!
-        # get_edge_point() needs origin_unit_perp, while get_target_unit_vectors() needs edge_point.
-        self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
-        self.edge_point = self.get_edge_point()
-        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()
-
-        self.changes_structures = 0
-
     # The same Greens function is used as for the normal PlanarSurfaceSingle;
     # If the position is off the surface of origin, it will be transformed towards the target surface
     def greens_function(self):
@@ -1016,7 +1000,7 @@ def draw_new_position(self, dt, event_type):
             displacement = self.create_position_vector(r)
 
             # Now check whether the new position is in the surface of origin;
-            # if not, transform it to the target surface
+            # if not, transform it to the target surface (function inherited from EdgeTools)
             newpos = self.process_new_position_vector(oldpos, displacement)
 
         return newpos
@@ -1027,128 +1011,36 @@ def create_position_vector(self, r):
         x, y = random_vector2D(r)
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
-    def process_new_position_vector(self, oldpos, displacement):
-        # This routine checks whether the new position in the surface of origin
-        # reaches out of it and if necessary calculates the position in the
-        # target surface.
-        # First calculate the coordinate perpendicular to the edge
-        # in the old surface
-        newpos_in_origin = (oldpos - self.origin_center) + displacement
-        d_origin_perp = numpy.dot(newpos_in_origin, self.origin_unit_perp)
-        assert (d_origin_perp >= 0.0 )
-        # Calculate the part of it that reaches out of the surface of origin
-        d_out = d_origin_perp - self.origin_half_extent_perp
-        if d_out <= 0.0 :
-            # The new position is still in the old surface;
-            # no transform required
-            newpos = oldpos + displacement
-        else :
-            # The new position is out of the old surface;
-            # transform it to the target surface.
-            # First calculate the coordinate in the target surface
-            # that is perpendicular to the edge:
-            d_target_perp = self.target_half_extent_perp - d_out
-            # Now the same for the parallel component
-            # Take into account that the parallel unit vector in the target surface might be
-            # either parallel or antiparallel to the parallel unit vector in the origin surface
-            d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
-            d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
-            # DEBUG
-            print("process_new_position_vector")
-            print(self.origin_surface.id)
-            print(self.origin_unit_par)
-            print(self.origin_unit_perp)
-            print(self.target_surface.id)
-            print(self.target_unit_par)
-            print(self.target_unit_perp)
-            print(self.target_surface.shape.unit_x)
-            print(self.target_surface.shape.unit_y)
-            print(self.target_surface.shape.unit_z)
-            print(d_origin_perp)
-            print(d_origin_par)
-            print(d_target_par)
-            # Construct the new position using the predefined unit vectors of the target surface
-            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            self.change_particle_structure(self.pid_particle_pair, self.target_surface)
-            self.changes_structures = 1
-
-        return newpos
-
-    def get_origin_unit_vectors(self):
-        # calculate the unit vector perpendicular and parallel to the edge
-        # in the surface of origin and the half_extent of this surface in the
-        # perpendicular vector direction
-        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
-        w_z = self.target_surface.shape.unit_z
-        u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
-        # DEBUG
-        if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
-            print("get_origin_unit_vectors")
-            print(self.target_distance)
-            print(self.target_center)
-            print(self.start_position)
-            print(self.target_center - self.start_position)
-            print(w_z)
-            print(u_perp)
-            
-            
-        assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
-
-        u_x = self.origin_surface.shape.unit_x
-        u_y = self.origin_surface.shape.unit_y
-        if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
-             u_par  = u_y
-             h_perp = self.origin_half_extent[0] # half_extent in u_x direction
-        else:
-             u_par  = u_x
-             h_perp = self.origin_half_extent[1] # half_extent in u_y direction
-
-        return u_perp, u_par, h_perp
-
-    def get_target_unit_vectors(self):
-        # calculate the unit vector perpendicular and parallel to the edge
-        # in the target surface and the half_extent of this surface in the
-        # perpendicular vector direction
-        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
-        w_perp_unnorm = (self.origin_center - self.target_center) + self.origin_half_extent_perp * self.origin_unit_perp
-        w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
-        assert feq(numpy.sqrt(numpy.dot(w_perp, w_perp)), 1.0)
-
-        w_x = self.target_surface.shape.unit_x
-        w_y = self.target_surface.shape.unit_y
-        if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
-             w_par = w_y
-             h_perp = self.origin_half_extent[0] # half_extent in w_x direction
-        else:
-             w_par = w_x
-             h_perp = self.origin_half_extent[1] # half_extent in w_y direction
-
-        # DEBUG
-        print("get_target_unit_vectors")
-        print(self.edge_point)
-        print(self.target_center)
-        print(w_perp_unnorm)
-        print(w_perp)
-        print(w_par)
-
-        return w_perp, w_par, h_perp
-
-    def get_edge_point(self):
-        ep = self.start_position + (self.target_distance * self.origin_unit_perp)
-        return ep
-
-    def change_particle_structure(self, id_particle_pair, new_structure):
-        #pid_particle_pair[1].structure_id = new_structure.id
-        # TODO !!! This will only work once particles can remember their structure !!!
-        # for now...
-        pass
-
     def get_interaction_rule(self): # HACK
         if self.intrule == None:
             self.intrule = self.draw_reaction_rule(self.interactionrules)
         return self.intrule
     interactionrule = property(get_interaction_rule)
 
+    # copied from SphericalSingle
+    # these return potentially corrected dimensions
+    # For explanation see NonInteractionSingles and Others in shells.py
+    def shell_list_for_single(self):
+        # make sure that there is at least space for the multi shell
+        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+        if  self.shell.shape.radius < min_radius:
+            position = self.shell.shape.position
+            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
+            # TODO maybe just returning the dimension instead of actually making the shell is cheaper.
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
+
+    def shell_list_for_other(self):
+        # keeps all the other domains at a distance of the burst radius
+        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        if self.shell.shape.radius < min_radius:
+            position = self.shell.shape.position
+            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
+
 
     def __str__(self):
         return 'PlanarSurfaceEdge' + Single.__str__(self)

From f5f6d81907e09482acae2275f4e8e70f768d882c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 22 Feb 2012 12:01:24 +0100
Subject: [PATCH 0690/1541] name change and added comments

---
 Model.hpp       | 2 +-
 SpeciesInfo.hpp | 5 +++--
 model.py        | 4 ++--
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/Model.hpp b/Model.hpp
index 991734d3..c3df14e2 100644
--- a/Model.hpp
+++ b/Model.hpp
@@ -74,7 +74,7 @@ class Model: private boost::noncopyable
 //////// Member variables (why are they public?)
 public:
     species_type_id_generator_type  species_type_id_generator_; // The id generator which makes sure that all species have a unique id
-    species_type_map_type           species_type_map_;          // ??
+    species_type_map_type           species_type_map_;          // mapping: species_type_id->species_type
     boost::scoped_ptr<NetworkRules> network_rules_;             // The network rules in the model
     string_map_type                 attrs_;                     // All the attributes
 };
diff --git a/SpeciesInfo.hpp b/SpeciesInfo.hpp
index 36e5fb0f..152c1298 100644
--- a/SpeciesInfo.hpp
+++ b/SpeciesInfo.hpp
@@ -8,8 +8,9 @@
 
 template<typename Tid_, typename TD_, typename Tlen_, typename Tstructure_type_id_>
 struct SpeciesInfo
-// Unclear if SpeciesInfo replaces the Species when using a World or not
-// (Species itself holds very little information, SpeciesInfo hold info that is relevant in a spatial system)
+// SpeciesInfo seems to extend the SpeciesType with extra information which is relevant for spatial simulations.
+// A Species itself holds very little information.
+// Note that the id is the same id as the SpeciesType and can be used to refer to the SpeciesType.
 {
     // defining shorthands for used types
     typedef Tid_                identifier_type;        // This is the SpeciesTypeID
diff --git a/model.py b/model.py
index 55522d2f..3190648a 100644
--- a/model.py
+++ b/model.py
@@ -115,7 +115,7 @@
 
 # Species is just a function, not a class. It seems to be a frontend to the
 # constructor of _gfrd.SpeciesType
-def Species(name, D, radius=0, structure_type="world", drift=0):
+def Species(name, D, radius=0, structure_type=None, drift=0):
     """Define a new Species (in/on a specific Region or Surface).
 
     Arguments:
@@ -127,7 +127,7 @@ def Species(name, D, radius=0, structure_type="world", drift=0):
         - radius
             the radius for this Species in/on this Region or Surface. 
             Units: meters.
-        - structure
+        - structure_type
             the Region or Surface in/on which this Species can exist.  
             Optional. If you do not specify a Structure the Species is 
             added to the "world".

From 25426dd40c177c5e6d7cd17db93cb576a55d1ba1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 22 Feb 2012 13:49:23 +0100
Subject: [PATCH 0691/1541] comments

---
 SpeciesInfo.hpp | 2 +-
 World.hpp       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/SpeciesInfo.hpp b/SpeciesInfo.hpp
index 152c1298..a3aedb5d 100644
--- a/SpeciesInfo.hpp
+++ b/SpeciesInfo.hpp
@@ -45,7 +45,7 @@ struct SpeciesInfo
         return radius_;
     }
 
-    // Get the id of the structure type it lives on
+    // Get the id of the structure type the species lives on
     structure_type_id_type const& structure_type_id() const
     {
         return structure_type_id_;
diff --git a/World.hpp b/World.hpp
index 1ca26510..ecabf13a 100644
--- a/World.hpp
+++ b/World.hpp
@@ -54,7 +54,7 @@ struct WorldTraitsBase
     // Species
     typedef SpeciesTypeID                                   species_id_type;        // identifier type for species
     typedef SpeciesInfo<species_id_type, D_type,
-                        length_type, structure_type_id_type>species_type;           // This is the definition of the species in the presence of a World
+                        length_type, structure_type_id_type>species_type;           // This is ADDITIONAL species information for use in a (spatial) world.
     // Particles
     typedef Particle<length_type, D_type, species_id_type,
                      structure_id_type>                     particle_type;          // type for particles, NOTE why is there no v_type here?

From ef2f0c96897a1d74199e4ae6ff32e9fadf57074e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 22 Feb 2012 14:35:53 +0100
Subject: [PATCH 0692/1541] comments and changed indentation to improve
 readability

---
 CuboidalRegion.hpp      | 13 ++++++++-----
 binding/world_class.cpp |  2 +-
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 91d62818..821540cd 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -13,14 +13,17 @@ class CuboidalRegion
 public:
     typedef BasicRegionImpl<Ttraits_, Box<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
+
+    // name shorthands of types that we use.
     typedef typename base_type::identifier_type         identifier_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::shape_type shape_type;
-    typedef typename base_type::rng_type rng_type;
-    typedef typename base_type::position_type position_type;
-    typedef typename base_type::length_type length_type;
+    typedef typename base_type::shape_type              shape_type;
+    typedef typename base_type::rng_type                rng_type;
+    typedef typename base_type::position_type           position_type;
+    typedef typename base_type::length_type             length_type;
     typedef typename Ttraits_::world_type::species_type species_type;
-    typedef std::pair<position_type, position_type> position_pair_type;
+    typedef std::pair<position_type, position_type>     position_pair_type;
+
 
     // TODO why is this here? This the same as the method in the superclass 'Structure'
     identifier_type const& id() const
diff --git a/binding/world_class.cpp b/binding/world_class.cpp
index 87098e96..98b316ad 100644
--- a/binding/world_class.cpp
+++ b/binding/world_class.cpp
@@ -124,4 +124,4 @@ void register_world_class()
     peer::converters::register_iterable_to_range_converter<twofold_container<ParticleID> >();
 }
 
-} // namesapce binding
+} // namespace binding

From 62f491a7406c5637904eda85f5f28f6ef99657b9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 21 Feb 2012 19:43:08 +0100
Subject: [PATCH 0693/1541] changes to model.py and world.py to reflect
 structure_types(in model) and structures(in world) model.py initializes the
 default structure_type world.py initializes the default structure Also
 initialize structure_types before defining species in world

---
 gfrdbase.py | 60 +++++++++++++++++++++++++++--------------------------
 model.py    | 53 +++++++++++++++++++++++++---------------------
 2 files changed, 60 insertions(+), 53 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 8e1c3500..24910c60 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -145,34 +145,34 @@ def create_world(m, matrix_size=10):
 
     """
     m.set_all_repulsive()
-    world_region = m.get_structure("world")
-    if not isinstance(world_region, _gfrd.CuboidalRegion):
-        raise TypeError("the world should be a CuboidalRegion")
-
-    if not numpy.all(world_region.shape.half_extent ==
-                     world_region.shape.half_extent[0]):
-        raise NotImplementedError("non-cuboidal world is not supported")
-
-    world_size = world_region.shape.half_extent[0] * 2
-
-    world = _gfrd.World(world_size, matrix_size)
-
-#    for st in m.structure_types:
-#        try:
-#            structure = st["structure"]
-#        except _gfrd.NotFound:
-#            structure = "world"
-#        world.add_structure_type(
-#            _gfrd.SpeciesInfo(st.id, 
-#                              float(st["D"]), 
-#                              float(st["radius"]), 
-#                              structure,
-#                              float(st["v"])))
+#    world_region = m.get_structure("world")
+#    if not isinstance(world_region, _gfrd.CuboidalRegion):
+#        raise TypeError("the world should be a CuboidalRegion")
+#
+#    if not numpy.all(world_region.shape.half_extent ==
+#                     world_region.shape.half_extent[0]):
+#        raise NotImplementedError("non-cuboidal world is not supported")
+#
+#    world_size = world_region.shape.half_extent[0] * 2
+
+    # make the world
+    world = _gfrd.World(m.world_size, matrix_size)
+
+    for st in m.structure_types:
+        world.add_structure_type(st)
+
+    # make the default structure: A cuboidal region of the default structure_type
+    # This needs to be done after making the structure_types or add_structure can't
+    # find the proper structure_type.
+    world_structure_type = m.get_def_structure_type()
+    x = numpy.repeat(m.world_size / 2, 3)
+    region = _gfrd.CuboidalRegion(world_structure_type, _gfrd.Box(x, x))
+    world.add_structure(region)
+
     for st in m.species_types:
-        try:
-            structure = st["structure_type"]     # FIXME
-        except _gfrd.NotFound:
-            structure = "world"
+        structure = st["structure"]
+        if not structure:
+            structure = region.id
         world.add_species(
             _gfrd.SpeciesInfo(st.id, 
                               structure,
@@ -180,8 +180,8 @@ def create_world(m, matrix_size=10):
                               float(st["radius"]), 
                               float(st["v"])))
 
-    for r in m.structures.itervalues():
-        world.add_structure(r)      # TODO change to add_structure_type
+#    for r in m.structures.itervalues():
+#        world.add_structure(r)
 
     world.model = m
     return world
@@ -286,6 +286,8 @@ def place_particle(world, sid, position):
     particle = world.new_particle(sid, position)
     return particle
 
+
+
 class ParticleSimulatorBase(object):
     def __init__(self, world, rng, network_rules):
         self.world = world
diff --git a/model.py b/model.py
index 3190648a..4606d392 100644
--- a/model.py
+++ b/model.py
@@ -170,7 +170,7 @@ def __init__(self, world_size):
         """
         _gfrd.ParticleModel.__init__(self)
         self.world_size = world_size
-        self.structures = {}
+#        self.structures = {}
 
         # Particles of a Species whose Surface is not specified will be 
         # added to the "world". Dimensions don't matter, except for 
@@ -179,29 +179,34 @@ def __init__(self, world_size):
 #        structure_type['name'] = 'world'
 #        _gfrd.ParticleModel.add_structure_type(self, structure_type)
 
-        def_structure_type_id = _gfrd.ParticleModel.get_def_structure_type_id(self)
-        structure_type        = _gfrd.ParticleModel.get_structure_type_by_id(self, def_structure_type_id)
-        x = numpy.repeat(world_size / 2, 3)
-
-        region = _gfrd.CuboidalRegion('world', structure_type, _gfrd.Box(x, x))
-#        region.sid = structure_type.id       
-        self.add_structure(region)
-
-    def add_structure(self, structure):
-        """Add a Structure (Region or Surface) to the ParticleModel.
-
-        Arguments:
-            - structure
-              a Region or Surface created with one of the functions
-              model.create_<>_region or model.create_<>_surface.
-
-        """
-        assert isinstance(structure, _gfrd.Structure)
-        self.structures[structure.id] = structure
-        return structure
-
-    def get_structure(self, id): 
-        return self.structures[id]
+#        def_structure_type_id = _gfrd.ParticleModel.get_def_structure_type_id(self)
+#        structure_type        = _gfrd.ParticleModel.get_structure_type_by_id(self, def_structure_type_id)
+#        x = numpy.repeat(world_size / 2, 3)
+
+#        region = _gfrd.CuboidalRegion('world', structure_type, _gfrd.Box(x, x))
+#        self.add_structure(region)
+
+        structure_type = _gfrd.StructureType()
+        structure_type['name'] = 'world'
+        _gfrd.ParticleModel.add_structure_type(self, structure_type)
+        _gfrd.ParticleModel.set_def_structure_type(self, structure_type.id)
+        
+### TODO change to add_structure_type
+#    def add_structure(self, structure):
+#        """Add a Structure (Region or Surface) to the ParticleModel.
+#
+#        Arguments:
+#            - structure
+#              a Region or Surface created with one of the functions
+#              model.create_<>_region or model.create_<>_surface.
+#
+#        """
+#        assert isinstance(structure, _gfrd.Structure)
+#        self.structures[structure.id] = structure
+#        return structure
+#
+#    def get_structure(self, id): 
+#        return self.structures[id]
 
     def add_reaction_rule(self, reaction_rule):
         """Add a ReactionRule to the ParticleModel.

From e381065a44e28cd442a86f36852a52b4c8d96714 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 22 Feb 2012 13:51:43 +0100
Subject: [PATCH 0694/1541] name_change in create_world:
 structure->structure_type

---
 gfrdbase.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 24910c60..7b703262 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -169,13 +169,17 @@ def create_world(m, matrix_size=10):
     region = _gfrd.CuboidalRegion(world_structure_type, _gfrd.Box(x, x))
     world.add_structure(region)
 
+    # The model (a ParticleModel) now only holds SpeciesTypes
+    # The SpeciesTYpes hold the information that is required for spatial simulations
+    # in auxiliairy string fields. This information is here converted to the right
+    # SpeciesInfo object and added to the world. Not sure this works -> TODO
     for st in m.species_types:
-        structure = st["structure"]
-        if not structure:
-            structure = region.id
+        structure_type = st["structure_type"]
+        if structure_type == None:
+            structure_type = world_structure_type    #structure = region.id
         world.add_species(
             _gfrd.SpeciesInfo(st.id, 
-                              structure,
+                              structure_type,          # FIXME not sure this works
                               float(st["D"]), 
                               float(st["radius"]), 
                               float(st["v"])))

From 9424d079254dda3fe36cf2ca7ff611e97d295aa2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 22 Feb 2012 14:39:17 +0100
Subject: [PATCH 0695/1541] comments in model.py

---
 gfrdbase.py | 2 +-
 model.py    | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 7b703262..6d1ac73b 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -166,7 +166,7 @@ def create_world(m, matrix_size=10):
     # find the proper structure_type.
     world_structure_type = m.get_def_structure_type()
     x = numpy.repeat(m.world_size / 2, 3)
-    region = _gfrd.CuboidalRegion(world_structure_type, _gfrd.Box(x, x))
+    region = _gfrd.CuboidalRegion(world_structure_type.id, _gfrd.Box(x, x))
     world.add_structure(region)
 
     # The model (a ParticleModel) now only holds SpeciesTypes
diff --git a/model.py b/model.py
index 4606d392..451811ac 100644
--- a/model.py
+++ b/model.py
@@ -142,6 +142,10 @@ def Species(name, D, radius=0, structure_type=None, drift=0):
     without an explicit Structure argument.
 
     """
+    # The SpeciesType actually only holds the information needed for a general species
+    # The information needed for spatial simulations (D, r, v etc) is stored in SpeciesInfo
+    # Here it is stored temporarily in string fields and only when the world in create
+    # put in the SpeciesInfo -> TODO SpeciesInfo should be in the ParticleModel
     st = _gfrd.SpeciesType()
     st["name"] = str(name)
     st["D"] = str(D)

From 28086c2361b47b3e757d6bceceb69332a3a0bd15 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 13 Mar 2012 19:26:45 +0100
Subject: [PATCH 0696/1541] small fixes

---
 gfrdbase.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 6d1ac73b..74af7a76 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -164,9 +164,9 @@ def create_world(m, matrix_size=10):
     # make the default structure: A cuboidal region of the default structure_type
     # This needs to be done after making the structure_types or add_structure can't
     # find the proper structure_type.
-    world_structure_type = m.get_def_structure_type()
+    world_structure_type = m.get_def_structure_type_id()
     x = numpy.repeat(m.world_size / 2, 3)
-    region = _gfrd.CuboidalRegion(world_structure_type.id, _gfrd.Box(x, x))
+    region = _gfrd.CuboidalRegion("world", world_structure_type, _gfrd.Box(x, x))
     world.add_structure(region)
 
     # The model (a ParticleModel) now only holds SpeciesTypes

From 3128a146c4a51f33c9b58c2bf44d46c9af8fea3d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 14 Mar 2012 13:53:27 +0100
Subject: [PATCH 0697/1541] Changed gfrdbase and model to reflect that Model
 has StructureTypes and World has Structures.

---
 gfrdbase.py | 45 ++++++++++++++++++++++-----------------------
 model.py    | 44 +++++++++++++++++++++++---------------------
 2 files changed, 45 insertions(+), 44 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 74af7a76..38543d57 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -145,47 +145,46 @@ def create_world(m, matrix_size=10):
 
     """
     m.set_all_repulsive()
-#    world_region = m.get_structure("world")
-#    if not isinstance(world_region, _gfrd.CuboidalRegion):
-#        raise TypeError("the world should be a CuboidalRegion")
-#
-#    if not numpy.all(world_region.shape.half_extent ==
-#                     world_region.shape.half_extent[0]):
-#        raise NotImplementedError("non-cuboidal world is not supported")
-#
-#    world_size = world_region.shape.half_extent[0] * 2
 
     # make the world
     world = _gfrd.World(m.world_size, matrix_size)
 
+    # copy all structure_types to the world (including the default one) and set the default id.
     for st in m.structure_types:
         world.add_structure_type(st)
-
-    # make the default structure: A cuboidal region of the default structure_type
-    # This needs to be done after making the structure_types or add_structure can't
-    # find the proper structure_type.
-    world_structure_type = m.get_def_structure_type_id()
-    x = numpy.repeat(m.world_size / 2, 3)
-    region = _gfrd.CuboidalRegion("world", world_structure_type, _gfrd.Box(x, x))
-    world.add_structure(region)
+    world_structure_type_id = m.get_def_structure_type_id(self)
+    world.set_def_structure_type_id(world_structure_type_id)
 
     # The model (a ParticleModel) now only holds SpeciesTypes
     # The SpeciesTYpes hold the information that is required for spatial simulations
     # in auxiliairy string fields. This information is here converted to the right
     # SpeciesInfo object and added to the world. Not sure this works -> TODO
     for st in m.species_types:
-        structure_type = st["structure_type"]
-        if structure_type == None:
-            structure_type = world_structure_type    #structure = region.id
+        if st["structure_type"] == "world":
+            # The default structure_type
+            structure_type_id = world_structure_type_id
+        else:
+            # Find the corresponding structure_type between all the structure_types known
+            for stt in m.structure_types:
+                if st["structure_type"] == stt['name']:
+                    structure_type_id = stt.id
+                    break
+            else:
+                raise RuntimeError("StructureType used in Species not found in Model when initializing World.")
+
         world.add_species(
             _gfrd.SpeciesInfo(st.id, 
-                              structure_type,          # FIXME not sure this works
+                              structure_type_id,    # FIXME not sure this works
                               float(st["D"]), 
                               float(st["radius"]), 
                               float(st["v"])))
 
-#    for r in m.structures.itervalues():
-#        world.add_structure(r)
+    # make the default structure: A cuboidal region of the default structure_type
+    # This needs to be done after making the structure_types or add_structure can't
+    # find the proper structure_type.
+    x = numpy.repeat(m.world_size / 2, 3)
+    region = _gfrd.CuboidalRegion("world", world_structure_type_id, _gfrd.Box(x, x))
+    world.add_structure(region)
 
     world.model = m
     return world
diff --git a/model.py b/model.py
index 451811ac..12b72dde 100644
--- a/model.py
+++ b/model.py
@@ -15,7 +15,7 @@
     'create_surface_binding_reaction_rule',
     'create_surface_unbinding_reaction_rule',
 
-    # From _gfrd. Should be part of the model class.
+    # From _gfrd. Should be part of the world class.
     'create_cuboidal_region',
     'create_cylindrical_surface',
     'create_planar_surface',
@@ -23,6 +23,8 @@
 
 
 # Define _gfrd docstrings here, much easier to format than in C++.
+# TODO These functions should be moved to gfrdbase.py because structures are no longer a part of the model,
+# but part of the world instead.
 _gfrd.create_cuboidal_region.__doc__ = \
 """create_cuboidal_region(sid, id, corner, diagonal)
 
@@ -151,7 +153,19 @@ def Species(name, D, radius=0, structure_type=None, drift=0):
     st["D"] = str(D)
     st["v"] = str(drift)
     st["radius"] = str(radius)
-    st["structure_type"] = structure_type
+#    st["structure_type"] = str(id(structure_type))  # The most ugly way of getting the reference in there.
+
+    # Particles of a Species whose Surface is not specified will be 
+    # added to the "world". 
+    if structure_type:
+        st["structure_type"] = structure_type['name']  # The most ugly way of getting the reference in there.
+    else:
+        st["structure_type"] = "world"
+
+#    # create the associated SpeciesInfo
+#    si = _gfrd.SpeciesInfo(st.id, structure_type.id,
+#                           D, radius, v)
+
     return st
 
 
@@ -173,28 +187,16 @@ def __init__(self, world_size):
 
         """
         _gfrd.ParticleModel.__init__(self)
+        # Note that in _gfrd.ParticleModel the default structure_type is
+        # created and added to the model.
+
         self.world_size = world_size
+        # Dimensions don't matter, except for 
+        # visualization.
+
 #        self.structures = {}
 
-        # Particles of a Species whose Surface is not specified will be 
-        # added to the "world". Dimensions don't matter, except for 
-        # visualization.
-#        structure_type = _gfrd.StructureType()
-#        structure_type['name'] = 'world'
-#        _gfrd.ParticleModel.add_structure_type(self, structure_type)
-
-#        def_structure_type_id = _gfrd.ParticleModel.get_def_structure_type_id(self)
-#        structure_type        = _gfrd.ParticleModel.get_structure_type_by_id(self, def_structure_type_id)
-#        x = numpy.repeat(world_size / 2, 3)
-
-#        region = _gfrd.CuboidalRegion('world', structure_type, _gfrd.Box(x, x))
-#        self.add_structure(region)
-
-        structure_type = _gfrd.StructureType()
-        structure_type['name'] = 'world'
-        _gfrd.ParticleModel.add_structure_type(self, structure_type)
-        _gfrd.ParticleModel.set_def_structure_type(self, structure_type.id)
-        
+
 ### TODO change to add_structure_type
 #    def add_structure(self, structure):
 #        """Add a Structure (Region or Surface) to the ParticleModel.

From 4916404908c1a7367d3e90e547d951ecee35e71f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Mar 2012 18:37:19 +0100
Subject: [PATCH 0698/1541] Changes to gfrdbase: create_world (bugfix),
 throw_in_particles (preliminaries)

---
 gfrdbase.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 38543d57..20c38eb1 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -152,7 +152,7 @@ def create_world(m, matrix_size=10):
     # copy all structure_types to the world (including the default one) and set the default id.
     for st in m.structure_types:
         world.add_structure_type(st)
-    world_structure_type_id = m.get_def_structure_type_id(self)
+    world_structure_type_id = m.get_def_structure_type_id()
     world.set_def_structure_type_id(world_structure_type_id)
 
     # The model (a ParticleModel) now only holds SpeciesTypes
@@ -207,7 +207,8 @@ def throw_in_particles(world, sid, n):
 
     """
     species = world.get_species(sid)
-    structure = world.get_structure(species.structure_id)
+    structure_type = world.get_structure_type(species.structure_type_id)
+    structures = [world.get_structure(structure_id) for structure_id in world.get_structure_ids(structure_type)]
 
     if __debug__:
         name = world.model.get_species_type_by_id(sid)["name"]

From 99de56aa9ccc9968d53ea9848976b25fa0b4c707 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 14 Mar 2012 17:33:31 +0100
Subject: [PATCH 0699/1541] Added get_structure_types and
 set_def_structure_type_id ot ParticleContainer and friends.

---
 Multi.hpp             | 51 +++++++++++++++++++++++---------------
 ParticleContainer.hpp | 35 ++++++++++++++++----------
 Transaction.hpp       | 57 ++++++++++++++++++++++++++-----------------
 World.hpp             |  4 +--
 4 files changed, 89 insertions(+), 58 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 4ec701bc..d758db9c 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -59,17 +59,22 @@ class MultiParticleContainer
 
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
-    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
-    typedef std::map<species_id_type, species_type> species_map;
-    typedef select_second<typename species_map::value_type> species_second_selector_type;
+    typedef select_second<typename structure_map::value_type>               structure_second_selector_type;
+    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> > structure_type_map;
+    typedef select_second<typename structure_type_map::value_type>          structure_type_second_selector_type;
+    typedef std::map<species_id_type, species_type>                         species_map;
+    typedef select_second<typename species_map::value_type>                 species_second_selector_type;
 
 public:    
-    typedef boost::transform_iterator<surface_second_selector_type,
-            typename structure_map::const_iterator> surface_iterator;
-    typedef sized_iterator_range<surface_iterator> structures_range;
+    typedef boost::transform_iterator<structure_second_selector_type,
+            typename structure_map::const_iterator>             structure_iterator;
+    typedef sized_iterator_range<structure_iterator>            structures_range;
+    typedef boost::transform_iterator<structure_type_second_selector_type,
+            typename structure_type_map::const_iterator>        structure_type_iterator;
+    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
     typedef boost::transform_iterator<species_second_selector_type,
-        typename species_map::const_iterator> species_iterator;
-    typedef sized_iterator_range<species_iterator> species_range;
+        typename species_map::const_iterator>                   species_iterator;
+    typedef sized_iterator_range<species_iterator>              species_range;
 
 
     virtual ~MultiParticleContainer() {}
@@ -94,32 +99,38 @@ class MultiParticleContainer
     {
         return world_.get_structure(id);
     }
-    
     virtual structures_range get_structures() const
     {
         return world_.get_structures();
     }
-    
-    virtual structure_type_id_type get_def_structure_type_id() const
+    virtual structure_id_type get_def_structure_id() const
     {
-        return world_.get_def_structure_type_id();
+        return world_.get_def_structure_id();
     }
+    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
+    {        
+        return world_.get_closest_surface( pos, ignore );
+    }
+    // End structure stuff
 
+    // StructureType stuff
     virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
     {
         return world_.get_structure_type(sid);
     }
-
-    virtual structure_id_type get_def_structure_id() const
+    virtual structure_types_range get_structure_types() const
     {
-        return world_.get_def_structure_id();
+        return world_.get_structure_types();
     }
-
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
-    {        
-        return world_.get_closest_surface( pos, ignore );
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return world_.get_def_structure_type_id();
     }
-    // End structure stuff
+    virtual void set_def_structure_type_id(structure_type_id_type const& sid) const
+    {
+        return world_.set_def_structure_type_id(sid);
+    }
+
         
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 6914412f..f72cb176 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -17,14 +17,14 @@ class ParticleContainer
 // The ParticleContainerBase implements some of them.
 public:
     typedef Ttraits_ traits_type;
-    typedef typename traits_type::particle_type     particle_type;
-    typedef typename particle_type::shape_type      particle_shape_type;
-    typedef typename traits_type::species_type      species_type;
-    typedef typename traits_type::species_id_type   species_id_type;
-    typedef typename traits_type::position_type     position_type;
-    typedef typename traits_type::particle_id_type  particle_id_type;
-    typedef typename traits_type::length_type       length_type;
-    typedef typename traits_type::size_type         size_type;
+    typedef typename traits_type::particle_type         particle_type;
+    typedef typename particle_type::shape_type          particle_shape_type;
+    typedef typename traits_type::species_type          species_type;
+    typedef typename traits_type::species_id_type       species_id_type;
+    typedef typename traits_type::position_type         position_type;
+    typedef typename traits_type::particle_id_type      particle_id_type;
+    typedef typename traits_type::length_type           length_type;
+    typedef typename traits_type::size_type             size_type;
     typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
@@ -38,13 +38,18 @@ class ParticleContainer
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
 private:
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
-    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
+    typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
+    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> >   structure_type_map;
+    typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
 
 public:    
-    typedef boost::transform_iterator<surface_second_selector_type,
-            typename structure_map::const_iterator> surface_iterator;
-    typedef sized_iterator_range<surface_iterator> structures_range;
+    typedef boost::transform_iterator<structure_second_selector_type,
+            typename structure_map::const_iterator>                 structure_iterator;
+    typedef sized_iterator_range<structure_iterator>                structures_range;
+    typedef boost::transform_iterator<structure_type_second_selector_type,
+            typename structure_type_map::const_iterator>            structure_type_iterator;
+    typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
 
     virtual ~ParticleContainer() {};
 
@@ -58,8 +63,12 @@ class ParticleContainer
     // StructureType stuff
     virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const = 0;
 
+    virtual structure_types_range get_structure_types() const = 0;
+
     virtual structure_type_id_type get_def_structure_type_id() const = 0;
 
+    virtual void set_def_structure_type_id(structure_type_id_type const& sid) = 0;
+
     // Structure stuff
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
diff --git a/Transaction.hpp b/Transaction.hpp
index 6da08aae..9cc561e5 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -74,13 +74,18 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef std::map<typename particle_id_pair::first_type,
             typename particle_id_pair::second_type> particle_id_pair_set_type;
     typedef sorted_list<std::vector<particle_id_type> > particle_id_list_type;
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
-    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
+    typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
+    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> >   structure_type_map;
+    typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
 
 public:    
-    typedef boost::transform_iterator<surface_second_selector_type,
-            typename structure_map::const_iterator> surface_iterator;
-    typedef sized_iterator_range<surface_iterator> structures_range;
+    typedef boost::transform_iterator<structure_second_selector_type,
+            typename structure_map::const_iterator>                 structure_iterator;
+    typedef sized_iterator_range<structure_iterator>                structures_range;
+    typedef boost::transform_iterator<structure_type_second_selector_type,
+            typename structure_type_map::const_iterator>            structure_type_iterator;
+    typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
 
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
@@ -163,32 +168,43 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return new TransactionImpl<particle_container_type>(*this);
     }
 
-    // Start Structure stuff
-    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
+    // Species stuff
+    virtual species_type const& get_species(species_id_type const& id) const
     {
-        return pc_.get_structure(id);
+        return pc_.get_species(id);
     }
-    
-    virtual structures_range get_structures() const
-    {
-        return pc_.get_structures();
-    }    
 
+    // StructureType stuff
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    {
+        return pc_.get_structure_type(sid);
+    }
+    virtual structure_types_range get_structure_types() const
+    {
+        return pc_.get_structure_types();
+    }
     virtual structure_type_id_type get_def_structure_type_id() const
     {
         return pc_.get_def_structure_type_id();
     }    
-        
-    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    virtual void set_def_structure_type_id(structure_type_id_type const& sid) const
     {
-        return pc_.get_structure_type(sid);
-    }
+        return pc_.set_def_structure_type_id(sid);
+    }    
 
+    // Start Structure stuff
+    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
+    {
+        return pc_.get_structure(id);
+    }
+    virtual structures_range get_structures() const
+    {
+        return pc_.get_structures();
+    }    
     virtual structure_id_type get_def_structure_id() const
     {
         return pc_.get_def_structure_id();
     }    
-        
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {
         return pc_.get_closest_surface( pos, ignore );
@@ -196,11 +212,6 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     // End structure stuff
 
 
-    virtual species_type const& get_species(species_id_type const& id) const
-    {
-        return pc_.get_species(id);
-    }
-
     virtual size_type num_particles() const
     {
         return pc_.num_particles();
diff --git a/World.hpp b/World.hpp
index ecabf13a..b2c89a94 100644
--- a/World.hpp
+++ b/World.hpp
@@ -462,7 +462,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return (*i).second;
     }
     // Get all structureTypes in the world
-    structure_types_range get_structure_types() const
+    virtual structure_types_range get_structure_types() const
     {
         return structure_types_range(
             structure_type_iterator(structure_type_map_.begin(), structure_types_second_selector_type()),
@@ -473,7 +473,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         return default_structure_type_id_;
     }
-    void set_def_structure_type_id(structure_type_id_type const& sid)
+    virtual void set_def_structure_type_id(structure_type_id_type const& sid)
     {
         default_structure_type_id_ = sid;
     }

From 9c7e99b96d70e94ead43811a150007ff8df047fe Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 14 Mar 2012 19:14:36 +0100
Subject: [PATCH 0700/1541] Cleanup of methods in World, ParticleContainer en
 Multi

---
 Multi.hpp                     | 44 +++++++++++---------
 ParticleContainer.hpp         |  9 ++++-
 Transaction.hpp               | 17 +++++---
 World.hpp                     |  6 ++-
 binding/ParticleContainer.hpp | 75 +++++++++++++++++++++++------------
 binding/World.hpp             | 14 ++++++-
 6 files changed, 110 insertions(+), 55 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index d758db9c..ac9598ea 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -41,6 +41,9 @@ class MultiParticleContainer
     typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
+    typedef typename world_type::structure_types_range      structure_types_range;
+    typedef typename world_type::structures_range           structures_range;
+    typedef typename world_type::structure_id_set           structure_id_set;
 
     typedef typename Ttraits_::network_rules_type   network_rules_type;
     typedef typename Ttraits_::reaction_rule_type   reaction_rule_type;
@@ -58,20 +61,20 @@ class MultiParticleContainer
     typedef std::pair<const Real, const Real> real_pair;
 
 private:
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
-    typedef select_second<typename structure_map::value_type>               structure_second_selector_type;
-    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> > structure_type_map;
-    typedef select_second<typename structure_type_map::value_type>          structure_type_second_selector_type;
+//    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
+//    typedef select_second<typename structure_map::value_type>               structure_second_selector_type;
+//    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> > structure_type_map;
+//    typedef select_second<typename structure_type_map::value_type>          structure_type_second_selector_type;
     typedef std::map<species_id_type, species_type>                         species_map;
     typedef select_second<typename species_map::value_type>                 species_second_selector_type;
 
 public:    
-    typedef boost::transform_iterator<structure_second_selector_type,
-            typename structure_map::const_iterator>             structure_iterator;
-    typedef sized_iterator_range<structure_iterator>            structures_range;
-    typedef boost::transform_iterator<structure_type_second_selector_type,
-            typename structure_type_map::const_iterator>        structure_type_iterator;
-    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
+//    typedef boost::transform_iterator<structure_second_selector_type,
+//            typename structure_map::const_iterator>             structure_iterator;
+//    typedef sized_iterator_range<structure_iterator>            structures_range;
+//    typedef boost::transform_iterator<structure_type_second_selector_type,
+//            typename structure_type_map::const_iterator>        structure_type_iterator;
+//    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
     typedef boost::transform_iterator<species_second_selector_type,
         typename species_map::const_iterator>                   species_iterator;
     typedef sized_iterator_range<species_iterator>              species_range;
@@ -89,6 +92,7 @@ class MultiParticleContainer
         return world_.world_size();
     }
     
+    // Species stuff
     virtual species_type const& get_species(species_id_type const& id) const
     {
         return world_.get_species(id);
@@ -101,34 +105,36 @@ class MultiParticleContainer
     }
     virtual structures_range get_structures() const
     {
-        return world_.get_structures();
+        return world_.get_structures();     // TODO now gets all structures in world, -> make structure local to Multi
     }
+    virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const
+    {
+        return world_.get_structure_ids(sid);
+    }
+    // virtual bool add_structure(structure_type const& structure); // TODO add structure from the world to multi
     virtual structure_id_type get_def_structure_id() const
     {
         return world_.get_def_structure_id();
     }
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {        
-        return world_.get_closest_surface( pos, ignore );
+        return world_.get_closest_surface( pos, ignore );   // TODO loop only over 'local' surfaces
     }
     // End structure stuff
 
     // StructureType stuff
+    // virtual bool add_structure_type(structure_type_type const& structure_type); // TODO add structure_type from the world to multi
     virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
     {
-        return world_.get_structure_type(sid);
+        return world_.get_structure_type(sid);      // TODO make local just like structures.
     }
     virtual structure_types_range get_structure_types() const
     {
-        return world_.get_structure_types();
+        return world_.get_structure_types();        // TODO ditto
     }
     virtual structure_type_id_type get_def_structure_type_id() const
     {
-        return world_.get_def_structure_type_id();
-    }
-    virtual void set_def_structure_type_id(structure_type_id_type const& sid) const
-    {
-        return world_.set_def_structure_type_id(sid);
+        return world_.get_def_structure_type_id();  // This information stays in the world.
     }
 
         
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index f72cb176..5d3913bd 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -50,6 +50,7 @@ class ParticleContainer
     typedef boost::transform_iterator<structure_type_second_selector_type,
             typename structure_type_map::const_iterator>            structure_type_iterator;
     typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
+    typedef std::set<structure_id_type>                             structure_id_set;
 
     virtual ~ParticleContainer() {};
 
@@ -61,19 +62,23 @@ class ParticleContainer
     virtual species_type const& get_species(species_id_type const& id) const = 0;
 
     // StructureType stuff
+//    virtual bool add_structure_type(structure_type_type const& structure_type) = 0;   // TODO
+
     virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const = 0;
 
     virtual structure_types_range get_structure_types() const = 0;
 
     virtual structure_type_id_type get_def_structure_type_id() const = 0;
 
-    virtual void set_def_structure_type_id(structure_type_id_type const& sid) = 0;
-
     // Structure stuff
+//    virtual bool add_structure(structure_type const& structure) = 0;   // TODO
+
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
     virtual structures_range get_structures() const = 0;
 
+    virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const = 0;
+
     virtual structure_id_type get_def_structure_id() const = 0;
 
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
diff --git a/Transaction.hpp b/Transaction.hpp
index 9cc561e5..d0625559 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -85,7 +85,10 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef sized_iterator_range<structure_iterator>                structures_range;
     typedef boost::transform_iterator<structure_type_second_selector_type,
             typename structure_type_map::const_iterator>            structure_type_iterator;
-    typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
+//    typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
+    typedef typename particle_container_type::structure_types_range         structure_types_range;
+    typedef typename particle_container_type::structure_id_set              structure_id_set;
+
 
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
@@ -175,6 +178,8 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     }
 
     // StructureType stuff
+//    virtual bool add_structure_type(structure_type_type const& structure_type);   // TODO
+
     virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
     {
         return pc_.get_structure_type(sid);
@@ -187,12 +192,10 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_def_structure_type_id();
     }    
-    virtual void set_def_structure_type_id(structure_type_id_type const& sid) const
-    {
-        return pc_.set_def_structure_type_id(sid);
-    }    
 
     // Start Structure stuff
+//    virtual bool add_structure(structure_type const& structure);   // TODO
+
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         return pc_.get_structure(id);
@@ -201,6 +204,10 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_structures();
     }    
+    virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const
+    {
+        return pc_.get_structure_ids(sid);
+    }
     virtual structure_id_type get_def_structure_id() const
     {
         return pc_.get_def_structure_id();
diff --git a/World.hpp b/World.hpp
index b2c89a94..ed11bf42 100644
--- a/World.hpp
+++ b/World.hpp
@@ -228,13 +228,15 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
     typedef std::pair<position_type, length_type>                                   projected_type;
     typedef typename particle_container_type::structure_id_and_distance_pair        structure_id_and_distance_pair;
+//    typedef typename particle_container_type::structure_types_range         structure_types_range;
+    typedef typename particle_container_type::structure_id_set              structure_id_set;
 
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
     typedef std::map<structure_type_id_type, structure_type_type>           structure_type_map;
     typedef std::set<particle_id_type>                                      particle_id_set;
-    typedef std::set<structure_id_type>                                     structure_id_set;
+//    typedef std::set<structure_id_type>                                     structure_id_set;
     typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
     typedef std::map<structure_type_id_type, structure_id_set>              per_structure_type_structure_id_set;
     typedef std::map<structure_id_type, particle_id_set>                    per_structure_particle_id_set;
@@ -473,7 +475,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         return default_structure_type_id_;
     }
-    virtual void set_def_structure_type_id(structure_type_id_type const& sid)
+    void set_def_structure_type_id(structure_type_id_type const& sid)
     {
         default_structure_type_id_ = sid;
     }
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 9baa6f86..d4969e0f 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -179,31 +179,36 @@ class ParticleContainerWrapper
 public:
     typedef boost::python::wrapper<Tbase_> py_wrapper_type;
     typedef Tbase_ wrapped_type;
-    typedef typename wrapped_type::size_type            size_type;
-    typedef typename wrapped_type::length_type          length_type;
-    typedef typename wrapped_type::particle_id_type     particle_id_type;
-    typedef typename wrapped_type::particle_shape_type  particle_shape_type;
-    typedef typename wrapped_type::position_type        position_type;
-    typedef typename wrapped_type::species_id_type      species_id_type;
-    typedef typename wrapped_type::species_type         species_type;
-    typedef typename wrapped_type::structure_id_type    structure_id_type;
-    typedef typename wrapped_type::structure_type       structure_type;
-    typedef typename wrapped_type::structure_type_type  structure_type_type;
+    typedef typename wrapped_type::size_type                size_type;
+    typedef typename wrapped_type::length_type              length_type;
+    typedef typename wrapped_type::particle_id_type         particle_id_type;
+    typedef typename wrapped_type::particle_shape_type      particle_shape_type;
+    typedef typename wrapped_type::position_type            position_type;
+    typedef typename wrapped_type::species_id_type          species_id_type;
+    typedef typename wrapped_type::species_type             species_type;
+    typedef typename wrapped_type::structure_id_type        structure_id_type;
+    typedef typename wrapped_type::structure_type           structure_type;
+    typedef typename wrapped_type::structure_type_type      structure_type_type;
     typedef typename wrapped_type::structure_type_id_type   structure_type_id_type;
-    typedef typename wrapped_type::particle_id_pair     particle_id_pair;
-    typedef typename wrapped_type::transaction_type     transaction_type;
+    typedef typename wrapped_type::particle_id_pair         particle_id_pair;
+    typedef typename wrapped_type::transaction_type         transaction_type;
     typedef typename wrapped_type::particle_id_pair_generator           particle_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
 
 private:
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
-    typedef select_second<typename structure_map::value_type> surface_second_selector_type;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
+    typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
+    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> >   structure_type_map;
+    typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
 
 public:    
-    typedef boost::transform_iterator<surface_second_selector_type,
-            typename structure_map::const_iterator> surface_iterator;
-    typedef sized_iterator_range<surface_iterator> structures_range;
+    typedef boost::transform_iterator<structure_second_selector_type,
+            typename structure_map::const_iterator>             structure_iterator;
+    typedef sized_iterator_range<structure_iterator>            structures_range;
+    typedef boost::transform_iterator<structure_type_second_selector_type,
+            typename structure_type_map::const_iterator>        structure_type_iterator;
+    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
 
     virtual ~ParticleContainerWrapper() {}
 
@@ -243,14 +248,9 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_structures")();
     }
 
-    virtual structure_type_id_type get_def_structure_type_id() const
-    {
-        return py_wrapper_type::get_override("get_def_structure_type_id")();
-    }
-
-    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const
     {
-        return py_wrapper_type::get_override("get_structure_type")(sid);
+        return py_wrapper_type::get_override("get_structure_ids")(sid);
     }
 
     virtual structure_id_type get_def_structure_id() const
@@ -264,6 +264,23 @@ class ParticleContainerWrapper
     }
     // end structure stuff
 
+    // Begin StructureType stuff
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    {
+        return py_wrapper_type::get_override("get_structure_type")(sid);
+    }
+
+    virtual structure_types_range get_structure_types() const
+    {
+        return py_wrapper_type::get_override("get_structure_types")();
+    }
+
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        return py_wrapper_type::get_override("get_def_structure_type_id")();
+    }
+    // end StructureType stuff
+
     virtual particle_id_pair new_particle(species_id_type const& sid,
             position_type const& pos)
     {
@@ -373,15 +390,21 @@ inline boost::python::objects::class_base register_particle_container_class(
     return class_<ParticleContainerWrapper<impl_type>, boost::noncopyable>(name)
         .add_property("num_particles", &impl_type::num_particles)
         .add_property("world_size", &impl_type::world_size)
+        // Species stuff
         .def("get_species",
             pure_virtual((typename impl_type::species_type const&(impl_type::*)(typename impl_type::species_id_type const&) const)&impl_type::get_species),
             return_internal_reference<>())
+        // StructureType stuff
+        .def("get_structure_type", pure_virtual(&impl_type::get_structure_type))
+        .def("get_structure_types", pure_virtual(&impl_type::get_structure_types))
+        .def("get_def_structure_type_id", pure_virtual(&impl_type::get_def_structure_type_id))
+        // Structure stuff
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
-        .def("get_def_structure_type_id", pure_virtual(&impl_type::get_def_structure_type_id))
-        .def("get_structure_type", pure_virtual(&impl_type::get_structure_type))
+        .def("get_structure_ids", pure_virtual(&impl_type::get_structure_ids))
         .def("get_def_structure_id", pure_virtual(&impl_type::get_def_structure_id))
         .def("get_closest_surface", pure_virtual(&impl_type::get_closest_surface))
+        // Particle stuff
         .def("new_particle", pure_virtual(&impl_type::new_particle))
         .def("update_particle", pure_virtual(&impl_type::update_particle))
         .def("remove_particle", pure_virtual(&impl_type::remove_particle))
diff --git a/binding/World.hpp b/binding/World.hpp
index 9fa39efa..7d3b0ff4 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -268,10 +268,22 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .add_property("structures",
             make_function(
                 (typename impl_type::structures_range(impl_type::*)() const)&impl_type::get_structures, structures_range_converter_type()))
+//        .add_property("structure_types",
+//            make_function(
+//                (typename impl_type::structure_types_range(impl_type::*)() const)&impl_type::get_structure_types,
+//                 structure_types_range_converter_type()))
         .add_property("particle_ids", &World_get_particle_ids<impl_type>)
+        .def("get_particle_ids", &impl_type::get_particle_ids)
+        .def("get_particle_ids_on_struct", &impl_type::get_particle_ids_on_struct)
         .def("add_species", &impl_type::add_species)
+        // Structure stuff
         .def("add_structure", &impl_type::add_structure)
-        .def("get_particle_ids", &impl_type::get_particle_ids)
+        .def("update_structure", &impl_type::update_structure)      // Not sure if this should be here or in ParticleContainer.hpp
+//        .def("remove_structure", &impl_type::remove_structure)
+        .def("set_def_structure_id", &impl_type::set_def_structure_id)
+        // StructureType stuff
+        .def("add_structure_type", &impl_type::add_structure_type)
+        .def("set_def_structure_type_id", &impl_type::set_def_structure_type_id)
         .def("distance", &impl_type::template distance<typename impl_type::position_type>)
         .def("distance", &impl_type::template distance<typename Tsim::sphere_type>)
         .def("distance", &impl_type::template distance<typename Tsim::cylinder_type>)

From ae301ba535216bb9a32fa7a9fce90e3ba6aa297c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Mar 2012 14:55:44 +0100
Subject: [PATCH 0701/1541] increasing the typdef disaster.

---
 Multi.hpp                     |  8 ++++----
 ParticleContainer.hpp         | 16 ++++++++++------
 ParticleContainerBase.hpp     |  2 ++
 Transaction.hpp               |  2 +-
 World.hpp                     |  7 +++----
 binding/ParticleContainer.hpp |  6 ++++--
 6 files changed, 24 insertions(+), 17 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index ac9598ea..05f3dccd 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -37,13 +37,13 @@ class MultiParticleContainer
     typedef typename traits_type::particle_id_type  particle_id_type;
     typedef typename traits_type::length_type       length_type;
     typedef typename traits_type::size_type         size_type;
-    typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
-    typedef typename world_type::structure_types_range      structure_types_range;
-    typedef typename world_type::structures_range           structures_range;
-    typedef typename world_type::structure_id_set           structure_id_set;
+    typedef typename world_type::particle_container_type::structure_types_range      structure_types_range;
+    typedef typename world_type::particle_container_type::structures_range           structures_range;
+    typedef typename world_type::particle_container_type::structure_id_set           structure_id_set;
 
     typedef typename Ttraits_::network_rules_type   network_rules_type;
     typedef typename Ttraits_::reaction_rule_type   reaction_rule_type;
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 5d3913bd..90a0b272 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -17,6 +17,7 @@ class ParticleContainer
 // The ParticleContainerBase implements some of them.
 public:
     typedef Ttraits_ traits_type;
+
     typedef typename traits_type::particle_type         particle_type;
     typedef typename particle_type::shape_type          particle_shape_type;
     typedef typename traits_type::species_type          species_type;
@@ -32,7 +33,7 @@ class ParticleContainer
 
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
-    typedef Transaction<traits_type> transaction_type;
+    typedef Transaction<traits_type>                            transaction_type;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
@@ -40,18 +41,21 @@ class ParticleContainer
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
     typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
-    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> >   structure_type_map;
+    typedef std::map<structure_type_id_type, structure_type_type >                      structure_type_map;
     typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
+    typedef boost::transform_iterator<structure_second_selector_type,
+            typename structure_map::const_iterator>                         structure_iterator;
+    typedef boost::transform_iterator<structure_type_second_selector_type,
+            typename structure_type_map::const_iterator>                    structure_type_iterator;
 
 public:    
-    typedef boost::transform_iterator<structure_second_selector_type,
-            typename structure_map::const_iterator>                 structure_iterator;
     typedef sized_iterator_range<structure_iterator>                structures_range;
-    typedef boost::transform_iterator<structure_type_second_selector_type,
-            typename structure_type_map::const_iterator>            structure_type_iterator;
     typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
+    typedef std::set<particle_id_type>                              particle_id_set;
     typedef std::set<structure_id_type>                             structure_id_set;
 
+
+
     virtual ~ParticleContainer() {};
 
     virtual size_type num_particles() const = 0;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 53adf981..44f3252c 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -102,6 +102,8 @@ class ParticleContainerBase
     typedef typename traits_type::size_type                 size_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type            structure_type;
+    typedef typename base_type::particle_id_set             particle_id_set;
+    typedef typename base_type::structure_id_set            structure_id_set;
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
     typedef Transaction<traits_type>                        transaction_type;
 
diff --git a/Transaction.hpp b/Transaction.hpp
index d0625559..942ac844 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -76,7 +76,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef sorted_list<std::vector<particle_id_type> > particle_id_list_type;
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
     typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
-    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> >   structure_type_map;
+    typedef std::map<structure_type_id_type, structure_type_type >                      structure_type_map;
     typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
 
 public:    
diff --git a/World.hpp b/World.hpp
index ed11bf42..35e9f315 100644
--- a/World.hpp
+++ b/World.hpp
@@ -228,15 +228,14 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
     typedef std::pair<position_type, length_type>                                   projected_type;
     typedef typename particle_container_type::structure_id_and_distance_pair        structure_id_and_distance_pair;
-//    typedef typename particle_container_type::structure_types_range         structure_types_range;
-    typedef typename particle_container_type::structure_id_set              structure_id_set;
+
+    typedef typename base_type::particle_id_set                             particle_id_set;
+    typedef typename base_type::structure_id_set                            structure_id_set;
 
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
     typedef std::map<structure_type_id_type, structure_type_type>           structure_type_map;
-    typedef std::set<particle_id_type>                                      particle_id_set;
-//    typedef std::set<structure_id_type>                                     structure_id_set;
     typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
     typedef std::map<structure_type_id_type, structure_id_set>              per_structure_type_structure_id_set;
     typedef std::map<structure_id_type, particle_id_set>                    per_structure_particle_id_set;
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index d4969e0f..5e4bc261 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -186,8 +186,8 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::position_type            position_type;
     typedef typename wrapped_type::species_id_type          species_id_type;
     typedef typename wrapped_type::species_type             species_type;
-    typedef typename wrapped_type::structure_id_type        structure_id_type;
     typedef typename wrapped_type::structure_type           structure_type;
+    typedef typename wrapped_type::structure_id_type        structure_id_type;
     typedef typename wrapped_type::structure_type_type      structure_type_type;
     typedef typename wrapped_type::structure_type_id_type   structure_type_id_type;
     typedef typename wrapped_type::particle_id_pair         particle_id_pair;
@@ -195,11 +195,12 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::particle_id_pair_generator           particle_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
+    typedef typename wrapped_type::structure_id_set                     structure_id_set;
 
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
     typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
-    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> >   structure_type_map;
+    typedef std::map<structure_type_id_type, structure_type_type >                      structure_type_map;
     typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
 
 public:    
@@ -384,6 +385,7 @@ inline boost::python::objects::class_base register_particle_container_class(
     peer::converters::register_tuple_converter<typename impl_type::structure_id_and_distance_pair>();
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair_and_distance>();
 
+    // register the converters (not sure what this does)
     particle_id_pair_and_distance_list_converter<typename impl_type::particle_id_pair_and_distance_list>::__register();
     particle_id_pair_generator_converter<typename impl_type::particle_id_pair_generator>::__register();
 

From a8815c77cb6e5276328b3be624bb2a44fa9ce1ca Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Mar 2012 15:51:13 +0100
Subject: [PATCH 0702/1541] Introducing the structure_id-structure pair and
 make it available in Python

---
 Multi.hpp                     |  4 +++-
 ParticleContainer.hpp         |  6 +++--
 ParticleContainerBase.hpp     |  4 +++-
 World.hpp                     |  6 +++--
 binding/ParticleContainer.hpp | 44 +++++++++++++++++++++++++++++++++++
 5 files changed, 58 insertions(+), 6 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 05f3dccd..da232f93 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -44,13 +44,15 @@ class MultiParticleContainer
     typedef typename world_type::particle_container_type::structure_types_range      structure_types_range;
     typedef typename world_type::particle_container_type::structures_range           structures_range;
     typedef typename world_type::particle_container_type::structure_id_set           structure_id_set;
+    typedef typename world_type::particle_container_type::structure_id_pair          structure_id_pair;
+    typedef typename world_type::particle_container_type::particle_id_pair           particle_id_pair;
 
     typedef typename Ttraits_::network_rules_type   network_rules_type;
     typedef typename Ttraits_::reaction_rule_type   reaction_rule_type;
     typedef typename network_rules_type::reaction_rules reaction_rules;      
 
     typedef typename Ttraits_::world_type::particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
-    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
+//    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef Transaction<traits_type>                            transaction_type;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 90a0b272..c3a55a52 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -31,10 +31,12 @@ class ParticleContainer
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
-    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
-    typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
+    typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;
+    typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
+    typedef std::pair<structure_id_type, length_type>                               structure_id_and_distance_pair;
     typedef Transaction<traits_type>                            transaction_type;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
+    typedef abstract_limited_generator<structure_id_pair>       structure_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 44f3252c..c3c9dc9a 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -104,7 +104,9 @@ class ParticleContainerBase
     typedef typename traits_type::structure_type            structure_type;
     typedef typename base_type::particle_id_set             particle_id_set;
     typedef typename base_type::structure_id_set            structure_id_set;
-    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
+    typedef typename base_type::structure_id_pair           structure_id_pair;
+//    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
+    typedef typename base_type::particle_id_pair            particle_id_pair;
     typedef Transaction<traits_type>                        transaction_type;
 
     typedef MatrixSpace<particle_type, particle_id_type, get_mapper_mf> particle_matrix_type;
diff --git a/World.hpp b/World.hpp
index 35e9f315..b3c80b65 100644
--- a/World.hpp
+++ b/World.hpp
@@ -224,8 +224,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     //
-    typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;      // defines the pid_particle_pair tuple
-    typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
+//    typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;      // defines the pid_particle_pair tuple
+//    typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
+    typedef typename base_type::particle_id_pair                particle_id_pair;
+    typedef typename base_type::structure_id_pair               structure_id_pair;
     typedef std::pair<position_type, length_type>                                   projected_type;
     typedef typename particle_container_type::structure_id_and_distance_pair        structure_id_and_distance_pair;
 
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 5e4bc261..8659232d 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -67,6 +67,46 @@ struct particle_id_pair_generator_converter
     }
 };
 
+template<typename Timpl_>
+struct structure_id_pair_generator_converter
+{
+    typedef Timpl_ native_type;
+
+    struct to_native_converter
+    {
+        static void* convert(PyObject* ptr)
+        {
+            boost::python::handle<> iter(
+                boost::python::allow_null(PyObject_GetIter(ptr)));
+            if (!iter)
+            {
+                boost::python::throw_error_already_set();
+            }
+            return new peer::wrappers::pyiterator_generator<
+                    typename native_type::result_type>(iter);
+        }
+
+        static PyTypeObject const* expected_pytype()
+        {
+            return &PyBaseObject_Type;
+        }
+    };
+
+    static void __register()
+    {
+        peer::wrappers::generator_wrapper<
+                ptr_generator<native_type, std::auto_ptr<native_type> > >
+                ::__register_class("StructureIDPairGenerator");
+        boost::python::to_python_converter<
+                native_type*,
+                peer::converters::ptr_generator_to_pyiterator_converter<
+                    native_type, std::auto_ptr<native_type> > >();
+                    
+
+        peer::util::to_native_lvalue_converter<native_type, to_native_converter>();
+    }
+};
+
 template<typename Timpl_>
 struct particle_id_pair_and_distance_list_converter
 {
@@ -191,8 +231,10 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::structure_type_type      structure_type_type;
     typedef typename wrapped_type::structure_type_id_type   structure_type_id_type;
     typedef typename wrapped_type::particle_id_pair         particle_id_pair;
+    typedef typename wrapped_type::structure_id_pair        structure_id_pair;
     typedef typename wrapped_type::transaction_type         transaction_type;
     typedef typename wrapped_type::particle_id_pair_generator           particle_id_pair_generator;
+    typedef typename wrapped_type::structure_id_pair_generator          structure_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
     typedef typename wrapped_type::structure_id_set                     structure_id_set;
@@ -382,12 +424,14 @@ inline boost::python::objects::class_base register_particle_container_class(
     using namespace boost::python;
     typedef Timpl impl_type;
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair>();
+    peer::converters::register_tuple_converter<typename impl_type::structure_id_pair>();
     peer::converters::register_tuple_converter<typename impl_type::structure_id_and_distance_pair>();
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair_and_distance>();
 
     // register the converters (not sure what this does)
     particle_id_pair_and_distance_list_converter<typename impl_type::particle_id_pair_and_distance_list>::__register();
     particle_id_pair_generator_converter<typename impl_type::particle_id_pair_generator>::__register();
+    structure_id_pair_generator_converter<typename impl_type::structure_id_pair_generator>::__register();
 
     return class_<ParticleContainerWrapper<impl_type>, boost::noncopyable>(name)
         .add_property("num_particles", &impl_type::num_particles)

From a3345f2ff622ee7c1ca12fe01d472365b2a60637 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 16 Mar 2012 15:32:33 +0100
Subject: [PATCH 0703/1541] Added edgetools.py

This is only temporary anyhow.
Because we want to make all this C++ soon.
---
 edgetools.py                                | 164 ++++++++++++++++++++
 samples/finite_planes_hack/finite_planes.py |  18 ++-
 2 files changed, 181 insertions(+), 1 deletion(-)
 create mode 100644 edgetools.py

diff --git a/edgetools.py b/edgetools.py
new file mode 100644
index 00000000..a289dd31
--- /dev/null
+++ b/edgetools.py
@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+
+from _gfrd import (
+    SphericalShell,
+    CylindricalShell,
+    Sphere,
+    Cylinder,
+    CuboidalRegion,
+    PlanarSurface,
+    CylindricalSurface,
+    )
+
+from utils import *
+
+from domain import (
+    Domain,
+    ProtectiveDomain)
+
+from shells import *
+
+__all__ = [
+    'EdgeTools'
+    ]
+
+
+class EdgeTools :
+
+    def __init__(self, testShell, start_position):
+
+        # Might be used internally by classes inheriting from here
+        self.origin_surface  = testShell.origin_surface
+        self.target_surface  = testShell.target_surface
+
+        self.origin_center = self.origin_surface.shape.position
+        self.target_center = self.target_surface.shape.position
+        self.origin_half_extent = self.origin_surface.shape.half_extent
+        self.target_half_extent = self.target_surface.shape.half_extent
+
+        self.start_position  = start_position
+        self.target_distance = testShell.get_distance_to_target_surface()
+
+        self.changes_structures = 0
+
+        self.edge_point = self.get_edge_point()
+        self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
+        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()
+        
+
+    def process_new_position_vector(self, oldpos, displacement):
+        # This routine checks whether the new position in the surface of origin
+        # reaches out of it and if necessary calculates the position in the
+        # target surface.
+        # First calculate the coordinate perpendicular to the edge
+        # in the old surface
+        newpos_in_origin = (oldpos - self.origin_center) + displacement
+        d_origin_perp = numpy.dot(newpos_in_origin, self.origin_unit_perp)
+        assert (d_origin_perp >= 0.0 )
+        # Calculate the part of it that reaches out of the surface of origin
+        d_out = d_origin_perp - self.origin_half_extent_perp
+        if d_out <= 0.0 :
+            # The new position is still in the old surface;
+            # no transform required
+            newpos = oldpos + displacement
+        else :
+            # The new position is out of the old surface;
+            # transform it to the target surface.
+            # First calculate the coordinate in the target surface
+            # that is perpendicular to the edge:
+            d_target_perp = self.target_half_extent_perp - d_out
+            # Now the same for the parallel component
+            # Take into account that the parallel unit vector in the target surface might be
+            # either parallel or antiparallel to the parallel unit vector in the origin surface
+            d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
+            d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
+            # TODO: Remove this temporary debug stuff
+            print("process_new_position_vector")
+            print(self.origin_surface.id)
+            print(self.origin_unit_par)
+            print(self.origin_unit_perp)
+            print(self.target_surface.id)
+            print(self.target_unit_par)
+            print(self.target_unit_perp)
+            print(self.target_surface.shape.unit_x)
+            print(self.target_surface.shape.unit_y)
+            print(self.target_surface.shape.unit_z)
+            print(d_origin_perp)
+            print(d_origin_par)
+            print(d_target_par)
+            # Construct the new position using the predefined unit vectors of the target surface
+            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
+            self.change_particle_structure(self.pid_particle_pair, self.target_surface)
+            self.changes_structures = 1
+
+        return newpos
+
+    def get_origin_unit_vectors(self):
+        # calculate the unit vector perpendicular and parallel to the edge
+        # in the surface of origin and the half_extent of this surface in the
+        # perpendicular vector direction
+        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
+        w_z = self.target_surface.shape.unit_z
+        u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
+        # TODO: DEBUG output, to be removed
+        if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
+            print("get_origin_unit_vectors")
+            print(self.target_distance)
+            print(self.target_center)
+            print(self.start_position)
+            print(self.target_center - self.start_position)
+            print(w_z)
+            print(u_perp)
+            
+            
+        assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
+
+        u_x = self.origin_surface.shape.unit_x
+        u_y = self.origin_surface.shape.unit_y
+        if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
+             u_par  = u_y
+             h_perp = self.origin_half_extent[0] # half_extent in u_x direction
+        else:
+             u_par  = u_x
+             h_perp = self.origin_half_extent[1] # half_extent in u_y direction
+
+        return u_perp, u_par, h_perp
+
+    def get_target_unit_vectors(self):
+        # calculate the unit vector perpendicular and parallel to the edge
+        # in the target surface and the half_extent of this surface in the
+        # perpendicular vector direction
+        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
+        w_perp_unnorm = (self.origin_center - self.target_center) + self.origin_half_extent_perp * self.origin_unit_perp
+        w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
+        assert feq(numpy.sqrt(numpy.dot(w_perp, w_perp)), 1.0)
+
+        w_x = self.target_surface.shape.unit_x
+        w_y = self.target_surface.shape.unit_y
+        if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
+             w_par = w_y
+             h_perp = self.origin_half_extent[0] # half_extent in w_x direction
+        else:
+             w_par = w_x
+             h_perp = self.origin_half_extent[1] # half_extent in w_y direction
+
+        # TODO: DEBUG output, to be removed
+        print("get_target_unit_vectors")
+        print(self.target_center)
+        print(w_perp_unnorm)
+        print(w_perp)
+        print(w_par)
+
+        return w_perp, w_par, h_perp
+
+    def get_edge_point(self):
+        self.origin_unit_perp, _, _ = self.get_origin_unit_vectors()
+        ep = self.start_position + (self.target_distance * self.origin_unit_perp)
+        return ep
+
+    def change_particle_structure(self, pid_particle_pair, new_structure):
+        #pid_particle_pair[1].structure_id = new_structure.id
+        # TODO !!! This will only work once particles can remember their structure !!!
+        # => for now just...
+        pass
+
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index 36c03250..1f1b19e6 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -29,7 +29,7 @@
 datetime.datetime.now().microsecond))
 #myrandom.seed(currenttime)
 
-myrandom.seed(323)
+myrandom.seed(323) # 323 for 3 part., 523 for one is good
 print "(Seed " + str(currenttime) + ")"
  
 
@@ -93,6 +93,9 @@
 F = model.Species('F', DC, sigma, membrane6_type['name'])
 m.add_species_type(F)
 
+Statist = model.Species('Statist', 0.0, 10.0*sigma)
+m.add_species_type(Statist)
+
 # Reaction rules
 rAB = model.create_binding_reaction_rule(A, membrane2_type, B, k)
 m.network_rules.add_reaction_rule(rAB)
@@ -201,6 +204,19 @@
 place_particle(w, A, [world_size/2, world_size/2, 0])  # place one particle on membraneA
 place_particle(w, A, [world_size/4, world_size/4, 0])  # place one particle on membraneA
 place_particle(w, A, [3*world_size/4, 3*world_size/4, 0])  # place one particle on membraneA
+
+# Statist particles in the corners of the system
+# does not really work because they intersect with membranes...
+#place_particle(w, Statist, [0, 0, 0])
+#place_particle(w, Statist, [world_size, 0, 0])
+#place_particle(w, Statist, [0, world_size, 0])
+#place_particle(w, Statist, [0, 0, world_size])
+#place_particle(w, Statist, [0, world_size, world_size])
+#place_particle(w, Statist, [world_size, 0, world_size])
+#place_particle(w, Statist, [world_size, world_size, 0])
+#place_particle(w, Statist, [world_size, world_size, world_size])
+
+
 #throw_in_particles(w, A, Nparticles) # THIS DOES NOT WORK BECAUSE PARTICLES INTERSECT WITH PLANES YET!
 #throw_in_particles(w, B, Nparticles)
 

From d74f7552af306d4a78ae7e8015a8be9d9bc0d5ba Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Mar 2012 14:26:45 +0100
Subject: [PATCH 0704/1541] Exposing the 'set of StructureIDs' to python

---
 binding/World.hpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/binding/World.hpp b/binding/World.hpp
index 7d3b0ff4..dada1ff4 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -246,17 +246,24 @@ template<typename Timpl_, typename Tbase_, typename Tsim>
 inline boost::python::objects::class_base register_world_class(char const* name)
 {
     using namespace boost::python;
-    typedef Timpl_ impl_type;
+    typedef Timpl_ impl_type;       // The class World that is being wrapped.
+
     typedef species_range_converter<typename impl_type::species_range> species_range_converter_type;
+//    typedef structure_types_range_converter<typename impl_type::structure_types_range> structure_types_range_converter_type;
     typedef structures_range_converter<typename impl_type::structures_range> structures_range_converter_type;
 
     species_range_converter_type::__register();
+//    structure_types_range_converter_type::__register();
     structures_range_converter_type::__register();
 
     class_<std::set<typename impl_type::particle_id_type> >("ParticleIDSet")
         .def(peer::util::set_indexing_suite<std::set<typename impl_type::particle_id_type> >())
         ;
 
+    class_<std::set<typename impl_type::structure_id_type> >("StructureIDSet")
+        .def(peer::util::set_indexing_suite<std::set<typename impl_type::structure_id_type> >())
+        ;
+
     return class_<impl_type, bases<Tbase_>,
                   boost::shared_ptr<impl_type> >(
         "World", init<typename impl_type::length_type, typename impl_type::size_type>())

From b4e187f259e3e36f1743a325631a304ba76c5f14 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Mar 2012 18:30:37 +0100
Subject: [PATCH 0705/1541] Some comments and cleanup in typedefs.

---
 ParticleContainerBase.hpp     | 1 +
 World.hpp                     | 3 ++-
 binding/ParticleContainer.hpp | 7 ++++++-
 binding/Structure.hpp         | 2 ++
 4 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index c3c9dc9a..7569623b 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -105,6 +105,7 @@ class ParticleContainerBase
     typedef typename base_type::particle_id_set             particle_id_set;
     typedef typename base_type::structure_id_set            structure_id_set;
     typedef typename base_type::structure_id_pair           structure_id_pair;
+    typedef typename base_type::structure_types_range       structure_types_range;
 //    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
     typedef typename base_type::particle_id_pair            particle_id_pair;
     typedef Transaction<traits_type>                        transaction_type;
diff --git a/World.hpp b/World.hpp
index b3c80b65..f0cc876a 100644
--- a/World.hpp
+++ b/World.hpp
@@ -233,6 +233,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     typedef typename base_type::particle_id_set                             particle_id_set;
     typedef typename base_type::structure_id_set                            structure_id_set;
+    typedef typename base_type::structure_types_range                       structure_types_range;
 
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
@@ -254,7 +255,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             typename structure_type_map::const_iterator>                    structure_type_iterator;
     typedef sized_iterator_range<species_iterator>                          species_range;
     typedef sized_iterator_range<structure_iterator>                        structures_range;
-    typedef sized_iterator_range<structure_type_iterator>                   structure_types_range;
+//    typedef sized_iterator_range<structure_type_iterator>                   structure_types_range;
 
 public:
     // The constructor
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 8659232d..7f6620ef 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -27,6 +27,8 @@
 
 namespace binding {
 
+
+// Converters. These convert C++ types to something that Python can handle.
 template<typename Timpl_>
 struct particle_id_pair_generator_converter
 {
@@ -212,6 +214,8 @@ struct particle_id_pair_and_distance_list_converter
     }
 };
 
+
+// ParticleContainer wrapper class
 template<typename Tbase_>
 class ParticleContainerWrapper
     : public Tbase_, public boost::python::wrapper<Tbase_>
@@ -238,6 +242,7 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
     typedef typename wrapped_type::structure_id_set                     structure_id_set;
+    typedef typename wrapped_type::structure_types_range    structure_types_range;
 
 private:
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
@@ -251,7 +256,7 @@ class ParticleContainerWrapper
     typedef sized_iterator_range<structure_iterator>            structures_range;
     typedef boost::transform_iterator<structure_type_second_selector_type,
             typename structure_type_map::const_iterator>        structure_type_iterator;
-    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
+//    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
 
     virtual ~ParticleContainerWrapper() {}
 
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index ddce42a0..53130014 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -12,9 +12,11 @@ inline boost::python::objects::class_base register_structure_class(char const *n
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // registers the projected_point/projected_distance tuple defined in ../Structure.hpp
     peer::converters::register_tuple_converter<
             typename impl_type::projected_type>();
 
+    // TODO add name and change id->real_id
     return class_<impl_type, boost::shared_ptr<impl_type>,
                   boost::noncopyable>(name, no_init)
         .add_property("id", 

From 1e7ea22a02bd951502ee594a8bdcde1b4f1bf985 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 15 Mar 2012 18:46:37 +0100
Subject: [PATCH 0706/1541] namechange for consistency in ParticleModel

---
 ParticleModel.cpp         | 10 +++++-----
 ParticleModel.hpp         | 18 +++++++++---------
 binding/ParticleModel.hpp |  2 +-
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index 8f8342e4..799d9183 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -42,7 +42,7 @@ void ParticleModel::add_structure_type(boost::shared_ptr<structure_type_type> co
 // Get a structure type from the model
 boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structure_type_by_id(structure_type_id_type const& id) const
 {
-    structure_type_map_type::const_iterator i(structure_type_map_.find(id));
+    structure_type_map::const_iterator i(structure_type_map_.find(id));
     if (structure_type_map_.end() == i)
     {
         throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(id) + ")");
@@ -52,11 +52,11 @@ boost::shared_ptr<ParticleModel::structure_type_type> ParticleModel::get_structu
 }
 
 // Get all the structure types that are present in the particle model
-ParticleModel::structure_type_range ParticleModel::get_structure_types() const
+ParticleModel::structure_types_range ParticleModel::get_structure_types() const
 {
-    return structure_type_range(
-        structure_type_iterator(structure_type_map_.begin(), structure_second_selector_type()),
-        structure_type_iterator(structure_type_map_.end(), structure_second_selector_type()));
+    return structure_types_range(
+        structure_type_iterator(structure_type_map_.begin(), structure_type_second_selector_type()),
+        structure_type_iterator(structure_type_map_.end(), structure_type_second_selector_type()));
 }
 
 ParticleModel::structure_type_id_type ParticleModel::get_def_structure_type_id() const
diff --git a/ParticleModel.hpp b/ParticleModel.hpp
index 9afd4023..37dd43cf 100644
--- a/ParticleModel.hpp
+++ b/ParticleModel.hpp
@@ -12,17 +12,17 @@ class ParticleModel: public Model
 public:
     // defining shorthands for the used types
     typedef Model                                   base_type;
-    typedef StructureType                           structure_type_type;
-    typedef structure_type_type::identifier_type    structure_type_id_type;
 
-    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> > structure_type_map_type;
+    typedef StructureType                                           structure_type_type;
+    typedef structure_type_type::identifier_type                    structure_type_id_type;
 
-    typedef select_second<structure_type_map_type::value_type> structure_second_selector_type;
+    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> >   structure_type_map;
+    typedef select_second<structure_type_map::value_type>                               structure_type_second_selector_type;
 
 public:
-    typedef boost::transform_iterator<structure_second_selector_type,
-            structure_type_map_type::const_iterator>            structure_type_iterator;
-    typedef boost::iterator_range<structure_type_iterator>      structure_type_range;
+    typedef boost::transform_iterator<structure_type_second_selector_type,
+            structure_type_map::const_iterator>                                         structure_type_iterator;
+    typedef boost::iterator_range<structure_type_iterator>                               structure_types_range;
 
 public:
     // Constructor
@@ -37,14 +37,14 @@ class ParticleModel: public Model
     void add_structure_type(boost::shared_ptr<structure_type_type> const& structure_type);
 
     // Get all structure types in the model
-    structure_type_range get_structure_types() const;
+    structure_types_range get_structure_types() const;
 
     // Gets and sets the default structure_type
     structure_type_id_type get_def_structure_type_id() const;
 
 /////// Member variables
 public:
-    structure_type_map_type structure_type_map_;            // mapping: structure_type_id -> structure_type
+    structure_type_map      structure_type_map_;            // mapping: structure_type_id -> structure_type
     structure_type_id_type  default_structure_type_id_;     // The id of the default structure_type ("world")
 };
 
diff --git a/binding/ParticleModel.hpp b/binding/ParticleModel.hpp
index 43f247d8..6d053a06 100644
--- a/binding/ParticleModel.hpp
+++ b/binding/ParticleModel.hpp
@@ -18,7 +18,7 @@ inline void register_particle_model_class(char const* name)
         .def("get_def_structure_type_id", &impl_type::get_def_structure_type_id)
         .add_property("structure_types",
                 peer::util::range_from_range<
-                    typename impl_type::structure_type_range,
+                    typename impl_type::structure_types_range,
                     impl_type, &impl_type::get_structure_types>())
         ;
 }

From 2e765313bdc8b5595a15f60fb9f8702a5322e15c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Mar 2012 11:34:34 +0100
Subject: [PATCH 0707/1541] replaced 'new_particle' method with version that
 demands the structure_id that the particle lives on. Previously both with and
 without the structure_id argument was possible, not structure_id is
 mandatory.

---
 BDPropagator.hpp              |  6 ++--
 EGFRDSimulator.hpp            |  8 ++---
 Multi.hpp                     |  4 +--
 ParticleContainer.hpp         |  2 +-
 Transaction.hpp               |  4 +--
 World.hpp                     |  8 ++---
 binding/ParticleContainer.hpp |  4 +--
 gfrdbase.py                   |  5 +--
 newBDPropagator.hpp           | 64 +++++++++++++++++++++--------------
 9 files changed, 59 insertions(+), 46 deletions(-)

diff --git a/BDPropagator.hpp b/BDPropagator.hpp
index 46cb68e4..d86d984a 100644
--- a/BDPropagator.hpp
+++ b/BDPropagator.hpp
@@ -274,8 +274,8 @@ class BDPropagator
 
                         tx_.remove_particle(pp.first);
                         const particle_id_pair
-                            npp0(tx_.new_particle(s0.id(), np0)),
-                            npp1(tx_.new_particle(s1.id(), np1));
+                            npp0(tx_.new_particle(s0.id(), pp.second.structure_id(), np0)),
+                            npp1(tx_.new_particle(s1.id(), pp.second.structure_id(), np1));
 
                         if (rrec_)
                         {
@@ -375,7 +375,7 @@ class BDPropagator
 
                         remove_particle(pp0.first);
                         remove_particle(pp1.first);
-                        particle_id_pair npp(tx_.new_particle(product, new_pos));
+                        particle_id_pair npp(tx_.new_particle(product, pp0.second.structure_id(), new_pos));
                         if (rrec_)
                         {
                             (*rrec_)(
diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index bd12cae9..cfb2888f 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -2103,7 +2103,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
                 (*base_type::world_).remove_particle(reactant.first);
                 particle_id_pair product(
                     (*base_type::world_).new_particle(
-                        product_species.id(), reactant.second.position()));
+                        product_species.id(), reactant.second.structure_id(), reactant.second.position()));
                 boost::shared_ptr<single_type> new_domain(create_single(product));
                 add_event(*new_domain, SINGLE_EVENT_ESCAPE);
                 if (base_type::rrec_)
@@ -2182,9 +2182,9 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
 
                 particle_id_pair const pp[] = {
                     (*base_type::world_).new_particle(
-                        product_species[0]->id(), new_particles[0].position()),
+                        product_species[0]->id(), reactant.second.structure_id(), new_particles[0].position()),
                     (*base_type::world_).new_particle(
-                        product_species[1]->id(), new_particles[1].position())
+                        product_species[1]->id(), reactant.second.structure_id(), new_particles[1].position())
                 };
                 // create domains for two particles and add them to
                 // the event queue
@@ -3267,7 +3267,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
 
                         particle_id_pair const new_particle(
                             (*base_type::world_).new_particle(
-                                new_species.id(), new_com));
+                                new_species.id(), domain.particles()[0].second.structure_id(), new_com));
                         boost::shared_ptr<single_type> new_single(
                             create_single(new_particle));
                         add_event(*new_single, SINGLE_EVENT_ESCAPE);
diff --git a/Multi.hpp b/Multi.hpp
index da232f93..a44b8f17 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -140,10 +140,10 @@ class MultiParticleContainer
     }
 
         
-    virtual particle_id_pair new_particle(species_id_type const& sid,
+    virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos)
     {
-        particle_id_pair const retval(world_.new_particle(sid, pos));
+        particle_id_pair const retval(world_.new_particle(sid, structure_id, pos));
         particles_.insert(retval);
 	    add_species_to_multi(sid);
         return retval;
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index c3a55a52..49ada780 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -90,7 +90,7 @@ class ParticleContainer
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
 
     // Particle stuff
-    virtual particle_id_pair new_particle(species_id_type const& sid,
+    virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos) = 0;
 
     virtual bool update_particle(particle_id_pair const& pi_pair) = 0;
diff --git a/Transaction.hpp b/Transaction.hpp
index 942ac844..38580459 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -91,10 +91,10 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
 
 
 
-    virtual particle_id_pair new_particle(species_id_type const& sid,
+    virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos)
     {
-        particle_id_pair retval(pc_.new_particle(sid, pos));
+        particle_id_pair retval(pc_.new_particle(sid, structure_id, pos));
         const bool result(added_particles_.push_no_duplicate(retval.first));
         BOOST_ASSERT(result);
         return retval;
diff --git a/World.hpp b/World.hpp
index f0cc876a..682aaf5e 100644
--- a/World.hpp
+++ b/World.hpp
@@ -267,10 +267,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
 
     // Old method is case no structure_id is supplied.
-    virtual particle_id_pair new_particle(species_id_type const& sid, position_type const& pos)
-    {
-        return new_particle(sid, default_structure_id_, pos);
-    }
+//    virtual particle_id_pair new_particle(species_id_type const& sid, position_type const& pos)
+//    {
+//        return new_particle(sid, default_structure_id_, pos);
+//    }
     // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos)
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 7f6620ef..32672d41 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -330,9 +330,9 @@ class ParticleContainerWrapper
     // end StructureType stuff
 
     virtual particle_id_pair new_particle(species_id_type const& sid,
-            position_type const& pos)
+            structure_id_type const& structure_id, position_type const& pos)
     {
-        return py_wrapper_type::get_override("new_particle")(sid, pos);
+        return py_wrapper_type::get_override("new_particle")(sid, structure_id, pos);
     }
 
     virtual bool update_particle(particle_id_pair const& pi_pair)
diff --git a/gfrdbase.py b/gfrdbase.py
index 20c38eb1..cd991a39 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -14,6 +14,7 @@
 import logging
 import logging.handlers
 
+import random
 import myrandom
 
 import model
@@ -208,7 +209,7 @@ def throw_in_particles(world, sid, n):
     """
     species = world.get_species(sid)
     structure_type = world.get_structure_type(species.structure_type_id)
-    structures = [world.get_structure(structure_id) for structure_id in world.get_structure_ids(structure_type)]
+    structure = world.get_structure(random.choice(list(world.get_structure_ids(structure_type))))
 
     if __debug__:
         name = world.model.get_species_type_by_id(sid)["name"]
@@ -239,7 +240,7 @@ def throw_in_particles(world, sid, n):
                     create = False
             if create:
                 # All checks passed. Create particle.
-                p = world.new_particle(sid, position)
+                p = world.new_particle(sid, structure.id, position)
                 i += 1
                 if __debug__:
                     log.info('(%s,\n %s' % (p[0], p[1]))
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index a6cafaca..069b917e 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -27,29 +27,29 @@ class newBDPropagator
 {
 public:
     typedef Ttraits_ traits_type;
-    typedef typename Ttraits_::world_type::particle_container_type particle_container_type;
-    typedef typename particle_container_type::species_id_type species_id_type;
-    typedef typename particle_container_type::position_type position_type;
-    typedef typename particle_container_type::particle_shape_type particle_shape_type;
-    typedef typename particle_container_type::species_type species_type;
-    typedef typename particle_container_type::length_type length_type;
-    typedef typename particle_container_type::particle_id_type particle_id_type;
-    typedef typename particle_container_type::particle_type particle_type;
-    typedef typename particle_container_type::particle_id_pair particle_id_pair;
+    typedef typename Ttraits_::world_type::particle_container_type  particle_container_type;
+    typedef typename particle_container_type::species_id_type       species_id_type;
+    typedef typename particle_container_type::position_type         position_type;
+    typedef typename particle_container_type::particle_shape_type   particle_shape_type;
+    typedef typename particle_container_type::species_type          species_type;
+    typedef typename particle_container_type::length_type           length_type;
+    typedef typename particle_container_type::particle_id_type      particle_id_type;
+    typedef typename particle_container_type::particle_type         particle_type;
+    typedef typename particle_container_type::particle_id_pair      particle_id_pair;
     typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
-    typedef std::vector<particle_id_type> particle_id_vector_type;
-    typedef std::pair<position_type, position_type> position_pair_type;
-    typedef std::pair<position_type, length_type> projected_type;
+    typedef std::vector<particle_id_type>                           particle_id_vector_type;
+    typedef std::pair<position_type, position_type>                 position_pair_type;
+    typedef std::pair<position_type, length_type>                   projected_type;
     typedef typename particle_container_type::particle_id_pair_generator particle_id_pair_generator;
     typedef typename particle_container_type::particle_id_pair_and_distance particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
-    typedef typename particle_container_type::structure_type structure_type;
-//    typedef typename particle_container_type::structure_id_type structure_id_type;    
+    typedef typename particle_container_type::structure_type        structure_type;
+    typedef typename particle_container_type::structure_id_type     structure_id_type;    
     typedef typename traits_type::world_type::traits_type::rng_type rng_type;
-    typedef typename traits_type::time_type time_type;
-    typedef typename traits_type::network_rules_type network_rules_type;
-    typedef typename network_rules_type::reaction_rules reaction_rules;
-    typedef typename network_rules_type::reaction_rule_type reaction_rule_type;
+    typedef typename traits_type::time_type                         time_type;
+    typedef typename traits_type::network_rules_type                network_rules_type;
+    typedef typename network_rules_type::reaction_rules             reaction_rules;
+    typedef typename network_rules_type::reaction_rule_type         reaction_rule_type;
     typedef typename traits_type::reaction_record_type reaction_record_type;
     typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
     typedef typename traits_type::volume_clearer_type volume_clearer_type;
@@ -337,6 +337,7 @@ class newBDPropagator
                         const species_type s0(tx_.get_species(products[0]));
                         boost::shared_ptr<structure_type> pp_struct( tx_.get_structure(pp.second.structure_id()) );
                         position_type new_pos = pp.second.position();
+                        structure_id_type new_structure_id(pp.second.structure_id());
                         
                         /* If the product particle does NOT live on the same structure type as the reactant => surface -> bulk dissociation. */
                         if( s0.structure_type_id() != pp_struct->sid() )
@@ -350,6 +351,7 @@ class newBDPropagator
                             
                             //Particle is allowed to move after dissociation from surface.
                             new_pos = make_move(s0, new_pos, pp.first);
+                            new_structure_id = tx_.get_def_structure_id();
                         }
                       
                         const particle_shape_type new_shape(new_pos, s0.radius());
@@ -381,7 +383,7 @@ class newBDPropagator
                         }
 
                         tx_.remove_particle(pp.first);
-                        const particle_id_pair product( tx_.new_particle(s0.id(), new_pos) );
+                        const particle_id_pair product( tx_.new_particle(s0.id(), new_structure_id, new_pos) );
 
                         if (rrec_)
                         {
@@ -398,6 +400,8 @@ class newBDPropagator
                                      s1(tx_.get_species(products[1]));
                         int i = max_retry_count_;
                         position_pair_type pp01;
+                        structure_id_type new_structure_id0;
+                        structure_id_type new_structure_id1;
 
                         boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( pp.second.structure_id() ) );
                         
@@ -425,11 +429,15 @@ class newBDPropagator
 
                                 pp01 = pp_struct->
                                         special_geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ );
+                                new_structure_id0 = pp.second.structure_id();
+                                new_structure_id1 = tx_.get_def_structure_id();
                             }
                             else
                             {
                                 pp01 = pp_struct->
                                         geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ );
+                                new_structure_id0 = pp.second.structure_id();
+                                new_structure_id1 = pp.second.structure_id();
                             }
                             
                             pp01.first = tx_.apply_boundary( pp01.first );
@@ -482,8 +490,8 @@ class newBDPropagator
 
                         tx_.remove_particle(pp.first);
                         const particle_id_pair
-                            npp0(tx_.new_particle(s0.id(), pp01.first)),
-                            npp1(tx_.new_particle(s1.id(), pp01.second));
+                            npp0(tx_.new_particle(s0.id(), new_structure_id0, pp01.first)),
+                            npp1(tx_.new_particle(s1.id(), new_structure_id1, pp01.second));
 
                         if (rrec_)
                         {
@@ -561,6 +569,7 @@ class newBDPropagator
                                                 pp1.second.position(),
                                                 pp0.second.position()), s0.D())),
                                         (s0.D() + s1.D()))) );
+                        structure_id_type new_structure_id;
 
                         //For unequal structures, project new_pos on surface.
                         if(sp.structure_type_id() != s1.structure_type_id())
@@ -569,12 +578,14 @@ class newBDPropagator
                             // FIXME Ugly!!
                             boost::shared_ptr<structure_type> sp_struct;
                             if(pp0.second.structure_id() == tx_.get_def_structure_id())
-                            {   sp_struct = tx_.get_structure( pp1.second.structure_id() );
+                            {
+                                new_structure_id = pp1.second.structure_id();
                             }
                             else
-                            {   sp_struct = tx_.get_structure( pp0.second.structure_id() );
+                            {
+                                new_structure_id = pp0.second.structure_id();
                             }
-
+                            sp_struct = tx_.get_structure( new_structure_id );
                             projected_type const position_on_surface( sp_struct->
                                                                       projected_point( tx_.cyclic_transpose( new_pos, 
                                                                                                              sp_struct->structure_position() ) ) );
@@ -600,6 +611,7 @@ class newBDPropagator
                             }
                         }
                         
+                        // If the product lives in the bulk
                         if( sp.structure_type_id() == tx_.get_def_structure_type_id() )
                         {
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_def_structure_id() ) );
@@ -613,7 +625,7 @@ class newBDPropagator
 
                         remove_particle(pp0.first);
                         remove_particle(pp1.first);
-                        particle_id_pair npp(tx_.new_particle(product, new_pos));
+                        particle_id_pair npp(tx_.new_particle(product, new_structure_id, new_pos));
                         if (rrec_)
                         {
                             (*rrec_)(
@@ -692,7 +704,7 @@ class newBDPropagator
                         }
 
                         remove_particle(pp.first);
-                        const particle_id_pair product_particle( tx_.new_particle(sp.id(), new_pos) );
+                        const particle_id_pair product_particle( tx_.new_particle(sp.id(), surface->real_id(), new_pos) );
                         if (rrec_)
                         {
                             (*rrec_)(

From 048a38f86c799913fca66718815489cf6077b6cd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Mar 2012 14:27:56 +0100
Subject: [PATCH 0708/1541] fix: return_type of add_structure must be id, not
 bool

---
 Multi.hpp             | 2 +-
 ParticleContainer.hpp | 2 +-
 Transaction.hpp       | 2 +-
 World.hpp             | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index a44b8f17..31a815a5 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -113,7 +113,7 @@ class MultiParticleContainer
     {
         return world_.get_structure_ids(sid);
     }
-    // virtual bool add_structure(structure_type const& structure); // TODO add structure from the world to multi
+    // virtual structure_id_type add_structure(structure_type const& structure); // TODO add structure from the world to multi
     virtual structure_id_type get_def_structure_id() const
     {
         return world_.get_def_structure_id();
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 49ada780..26a4bf13 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -77,7 +77,7 @@ class ParticleContainer
     virtual structure_type_id_type get_def_structure_type_id() const = 0;
 
     // Structure stuff
-//    virtual bool add_structure(structure_type const& structure) = 0;   // TODO
+//    virtual structure_id_type add_structure(structure_type const& structure) = 0;   // TODO
 
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
diff --git a/Transaction.hpp b/Transaction.hpp
index 38580459..efa61ba0 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -194,7 +194,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     }    
 
     // Start Structure stuff
-//    virtual bool add_structure(structure_type const& structure);   // TODO
+//    virtual structure_id_type add_structure(structure_type const& structure);   // TODO
 
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
diff --git a/World.hpp b/World.hpp
index 682aaf5e..32448174 100644
--- a/World.hpp
+++ b/World.hpp
@@ -361,7 +361,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
 
     // Add a structure 
-    bool add_structure(boost::shared_ptr<structure_type> structure)
+    virtual structure_id_type add_structure(boost::shared_ptr<structure_type> structure)
     {
         // check that the structure_type that is defined in the structure exists!
         structure_type_type const& structure_type(get_structure_type(structure->sid()));

From dbdce60344329a6b332a741a5016cebc23510a8c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Mar 2012 14:30:02 +0100
Subject: [PATCH 0709/1541] Making egfrd code work with structure_id being in
 particle instead of species. Also getting the structure_type information from
 species (was not available before).

---
 egfrd.py                   | 60 ++++++++++++++++++++++++++------------
 gfrdbase.py                |  4 ++-
 visualization/vtklogger.py |  6 ++--
 3 files changed, 47 insertions(+), 23 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 202d871e..ea307d43 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -438,7 +438,7 @@ def create_single(self, pid_particle_pair):
         reaction_rules = self.network_rules.query_reaction_rule(pid_particle_pair[1].sid)
         # Get structure (region or surface) where the particle lives.
         species = self.world.get_species(pid_particle_pair[1].sid)
-        structure = self.world.get_structure(species.structure_id)
+        structure = self.world.get_structure(pid_particle_pair[1].structure_id)
 
         # 2. Create and register the single domain.
         # The type of the single that will be created 
@@ -835,6 +835,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
         reactant           = single.pid_particle_pair
         reactant_radius    = reactant[1].radius
         reactant_structure = single.structure
+        species = self.world.get_species(reactant[1].sid)
+        reactant_structure_type_id = species.structure_type_id
         rr = single.reactionrule
 
         # 1. remove the particle
@@ -858,14 +860,16 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
         elif len(rr.products) == 1:
             
             # 1. get product info
-            product_species = self.world.get_species(rr.products[0])
-            product_radius  = product_species.radius
-            product_structure = self.world.get_structure(product_species.structure_id) 
+            product_species           = self.world.get_species(rr.products[0])
+            product_radius            = product_species.radius
+            product_structure_type_id = product_species.structure_type_id
 
             # 1.5 produce a number of new possible positions for the product particle
             # TODO make these generators for efficiency
-            if product_structure != reactant_structure:
-                assert isinstance(product_structure, CuboidalRegion)
+            if product_structure_type_id != reactant_structure_type_id:
+                assert (product_structure_type_id == self.world.get_def_structure_type_id())
+
+                product_structure_id = self.world.get_def_structure_id()
 
                 if isinstance(reactant_structure, PlanarSurface):
                     a = myrandom.choice(-1, 1)
@@ -888,9 +892,9 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
             else:
+                product_structure_id = reactant_structure.id
                 product_pos_list = [reactant_pos]               # no change of position is required if structure doesn't change
 
-
             for product_pos in product_pos_list:
                 product_pos = self.world.apply_boundary(product_pos)
 
@@ -903,7 +907,7 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
                     # 4. process the changes (remove particle, make new ones)
                     self.world.remove_particle(reactant[0])
-                    newparticle = self.world.new_particle(product_species.id, product_pos)
+                    newparticle = self.world.new_particle(product_species.id, product_structure_id, product_pos)
                     products = [newparticle]
 
                     # 5. update counters
@@ -934,8 +938,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             # 1. get product info
             product1_species = self.world.get_species(rr.products[0])
             product2_species = self.world.get_species(rr.products[1])
-            product1_structure = self.world.get_structure(product1_species.structure_id) 
-            product2_structure = self.world.get_structure(product2_species.structure_id) 
+            product1_structure_type_id = product1_species.structure_type_id 
+            product2_structure_type_id = product2_species.structure_type_id 
             
             D1 = product1_species.D
             D2 = product2_species.D
@@ -959,15 +963,18 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             product2_displacement *= MINIMAL_SEPARATION_FACTOR
 
 
-            if product1_structure != product2_structure:
+            if product1_structure_type_id != product2_structure_type_id:
                 # make sure that the reactant was on a 2D or 1D surface
                 assert not isinstance(reactant_structure, CuboidalRegion)
                 # make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
-                assert (isinstance(product1_structure, CuboidalRegion) ^ isinstance(product2_structure, CuboidalRegion))
+                assert ((product1_structure_type_id == self.world.get_def_structure_type_id()) ^ \
+                        (product2_structure_type_id == self.world.get_def_structure_type_id()))
 
                 # figure out which product stays in the surface and which one goes to 3D
-                if isinstance(product2_structure, CuboidalRegion):
-                    # product2 goes to 3D and is now particleB (product1 is particleA)
+                if (product2_structure_type_id == self.get_def_structure_type_id()):
+                    # product2 goes to 3D and is now particleB (product1 is particleA and is on the surface)
+                    product1_structure_id = reactant_structure.id
+                    product2_structure_id = self.world.get_def_structure_id()
                     productA_radius = product1_radius
                     productB_radius = product2_radius
                     DA = D1
@@ -975,6 +982,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                     default = True      # we like to think of this as the default
                 else:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
+                    product2_structure_id = reactant_structure.id
+                    product1_structure_id = self.world.get_def_structure_id()
                     productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2
@@ -1045,7 +1054,9 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
             else:
-                # The two particles stay on the same structure.
+                # The two particles stay on the same structure as the reactant.
+                product1_structure_id = reactant_structure.id
+                product2_structure_id = reactant_structure.id
 
                 # generate new positions in the structure
                 # TODO Make this into a generator
@@ -1080,8 +1091,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                     
                     # 4. process the changes (remove particle, make new ones)
                     self.world.remove_particle(reactant[0])
-                    product1_pair = self.world.new_particle(product1_species.id, newpos1)
-                    product2_pair = self.world.new_particle(product2_species.id, newpos2)
+                    product1_pair = self.world.new_particle(product1_species.id, product1_structure_id, newpos1)
+                    product2_pair = self.world.new_particle(product2_species.id, product2_structure_id, newpos2)
                     products = [product1_pair, product2_pair]
 
                     # 5. update counters
@@ -1143,6 +1154,7 @@ def fire_interaction(self, single, reactant_pos, ignore):
             product_species = self.world.get_species(rr.products[0])
             product_radius  = product_species.radius
             product_surface = single.surface
+            product_structure_id = single.surface.id
             # TODO make sure that the product species lives on the same type of the interaction surface
 #            product_structure_type = self.world.get_structure(product_species.structure_id)
 #            assert (single.surface.sid == self.world.get_structure(product_species.structure_id)), \
@@ -1170,7 +1182,7 @@ def fire_interaction(self, single, reactant_pos, ignore):
             else:
                 # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(reactant[0])
-                newparticle = self.world.new_particle(product_species.id, product_pos)
+                newparticle = self.world.new_particle(product_species.id, product_structure_id, product_pos)
                 products = [newparticle]
 
                 # 5. update counters
@@ -1198,6 +1210,8 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
         pid_particle_pair2 = pair.pid_particle_pair2
         reactant1_species_id = pid_particle_pair1[1].sid
         reactant2_species_id = pid_particle_pair2[1].sid
+        reactant1_structure_id = pid_particle_pair1[1].structure_id
+        reactant2_structure_id = pid_particle_pair2[1].structure_id
 
         rr = pair.draw_reaction_rule(pair.interparticle_rrs)
         # 1. remove the particles
@@ -1225,6 +1239,14 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
             product_species = self.world.get_species(rr.products[0])
             product_radius  = product_species.radius
 
+            # select the proper structure_id for the product particle to live on.
+            product_structure_ids = self.world.get_structure_ids(self.world.get_structure_type(product_species.structure_type_id))
+            if reactant1_structure_id in product_structure_ids:
+                product_structure_id = reactant1_structure_id
+            elif reactant2_structure_id in product_structure_ids:
+                product_structure_id = reactant2_structure_id
+
+
             # 1.5 get new position for product particle
             product_pos = pair.draw_new_com (pair.dt, pair.event_type)
             product_pos = self.world.apply_boundary(product_pos)
@@ -1248,7 +1270,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
                 # 4. process the changes (remove particle, make new ones)
                 self.world.remove_particle(pid_particle_pair1[0])
                 self.world.remove_particle(pid_particle_pair2[0])
-                newparticle = self.world.new_particle(product_species.id, product_pos)
+                newparticle = self.world.new_particle(product_species.id, product_structure_id, product_pos)
                 products = [newparticle]
 
                 # 5. update counters
diff --git a/gfrdbase.py b/gfrdbase.py
index cd991a39..f61b7cd2 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -185,7 +185,8 @@ def create_world(m, matrix_size=10):
     # find the proper structure_type.
     x = numpy.repeat(m.world_size / 2, 3)
     region = _gfrd.CuboidalRegion("world", world_structure_type_id, _gfrd.Box(x, x))
-    world.add_structure(region)
+    world_structure_id = world.add_structure(region)
+    world.set_def_structure_id(world_structure_id)
 
     world.model = m
     return world
@@ -262,6 +263,7 @@ def place_particle(world, sid, position):
     model.ParticleModel.add_species_type.
 
     """
+    # TODO make sure that placed particle lives on the right structure.
     species = world.get_species(sid)
     structure = world.get_structure(species.structure_id)
     radius = species.radius
diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 2f58f5a9..020a227d 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -344,16 +344,16 @@ def get_sphere_and_cylinder_data(self):
                self.process_cylinders(cylinders, cylinder_colors)
 
     def get_cuboidal_region_data(self):
-        boxes = [self.sim.world.get_structure("world").shape]
+        boxes = [self.sim.world.get_structure(self.sim.world.get_def_structure_id()).shape]
 
         return self.process_boxes(boxes)
 
     def get_planar_surface_data(self):
-        world = self.sim.world.get_structure("world")
+        world_id = self.sim.world.get_def_structure_id()
         boxes = [surface.shape for surface
                                in self.sim.world.structures
                                if isinstance(surface.shape, Plane)
-                               and not surface == world]
+                               and not surface.id == world_id]  # why this here? The world is not a plane!
     
         return self.process_boxes(boxes)
 

From 0e31797399b6429e325721004280e2544b07327b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Mar 2012 15:49:57 +0100
Subject: [PATCH 0710/1541] small numerical fix

---
 single.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/single.py b/single.py
index b89164ec..7010a1d8 100644
--- a/single.py
+++ b/single.py
@@ -419,8 +419,8 @@ def check(self):
         assert self.greens_function
         assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
 
-        assert numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,
-                         self.structure.shape.unit_z) == 0.0
+        assert feq(numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,
+                             self.structure.shape.unit_z), 0.0, typical=self.shell.shape.half_length)
 
         return True
 

From b9f2a310e5604f5d035e9463a7cc54cd62a1f8c3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 16 Mar 2012 16:28:02 +0100
Subject: [PATCH 0711/1541] cleanup of some unused code, added comments and
 outlining.

---
 Multi.hpp             |  55 ++++++++---------
 ParticleContainer.hpp |  37 ++++++------
 Transaction.hpp       |  43 ++++++-------
 World.hpp             | 136 +++++++++++++++++++++---------------------
 4 files changed, 133 insertions(+), 138 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 31a815a5..71c76470 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -28,19 +28,20 @@ class MultiParticleContainer
     typedef ParticleContainerUtils<typename Ttraits_::world_type::traits_type> utils;
     typedef typename Ttraits_::world_type world_type;
     typedef typename world_type::traits_type traits_type;
-    // shorthands for used types
-    typedef typename traits_type::particle_type     particle_type;
-    typedef typename particle_type::shape_type      particle_shape_type;
-    typedef typename traits_type::species_type      species_type;
-    typedef typename traits_type::species_id_type   species_id_type;
-    typedef typename traits_type::position_type     position_type;
-    typedef typename traits_type::particle_id_type  particle_id_type;
-    typedef typename traits_type::length_type       length_type;
-    typedef typename traits_type::size_type         size_type;
+    // shorthands types for used types
+    typedef typename traits_type::particle_type             particle_type;
+    typedef typename particle_type::shape_type              particle_shape_type;
+    typedef typename traits_type::species_type              species_type;
+    typedef typename traits_type::species_id_type           species_id_type;
+    typedef typename traits_type::position_type             position_type;
+    typedef typename traits_type::particle_id_type          particle_id_type;
+    typedef typename traits_type::length_type               length_type;
+    typedef typename traits_type::size_type                 size_type;
     typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
+    // types inherited from the ParticleContainerBase class
     typedef typename world_type::particle_container_type::structure_types_range      structure_types_range;
     typedef typename world_type::particle_container_type::structures_range           structures_range;
     typedef typename world_type::particle_container_type::structure_id_set           structure_id_set;
@@ -52,36 +53,27 @@ class MultiParticleContainer
     typedef typename network_rules_type::reaction_rules reaction_rules;      
 
     typedef typename Ttraits_::world_type::particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
-//    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
-    typedef Transaction<traits_type>                            transaction_type;
-    typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
+    typedef Transaction<traits_type>                                        transaction_type;
+    typedef abstract_limited_generator<particle_id_pair>                    particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>                        particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance,
-                                 get_default_impl::std::vector> particle_id_pair_and_distance_list;
-    typedef std::map<particle_id_type, particle_type>           particle_map;
-    typedef sized_iterator_range<typename particle_map::const_iterator> particle_id_pair_range;
+                                 get_default_impl::std::vector>             particle_id_pair_and_distance_list;
+    typedef std::map<particle_id_type, particle_type>                       particle_map;
+    typedef sized_iterator_range<typename particle_map::const_iterator>     particle_id_pair_range;
     typedef std::pair<const Real, const Real> real_pair;
 
 private:
-//    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
-//    typedef select_second<typename structure_map::value_type>               structure_second_selector_type;
-//    typedef std::map<structure_type_id_type, boost::shared_ptr<structure_type_type> > structure_type_map;
-//    typedef select_second<typename structure_type_map::value_type>          structure_type_second_selector_type;
     typedef std::map<species_id_type, species_type>                         species_map;
     typedef select_second<typename species_map::value_type>                 species_second_selector_type;
 
 public:    
-//    typedef boost::transform_iterator<structure_second_selector_type,
-//            typename structure_map::const_iterator>             structure_iterator;
-//    typedef sized_iterator_range<structure_iterator>            structures_range;
-//    typedef boost::transform_iterator<structure_type_second_selector_type,
-//            typename structure_type_map::const_iterator>        structure_type_iterator;
-//    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
     typedef boost::transform_iterator<species_second_selector_type,
-        typename species_map::const_iterator>                   species_iterator;
-    typedef sized_iterator_range<species_iterator>              species_range;
+        typename species_map::const_iterator>                               species_iterator;
+    typedef sized_iterator_range<species_iterator>                          species_range;
 
 
+
+    //
     virtual ~MultiParticleContainer() {}
 
     virtual size_type num_particles() const
@@ -408,10 +400,11 @@ class MultiParticleContainer
     // The constructor
     MultiParticleContainer(world_type& world): world_(world) {}
 
+////// Member variables
 private:
-    world_type& world_;
-    particle_map particles_;
-    species_map species_;
+    world_type&         world_;     // reference to the world. The MultiParticleContainer reflects a part of the World(ParticleContainer)
+    particle_map        particles_; // local copy of the particles (the particles in the Multi are a subset of the particles in the world)
+    species_map         species_;   // local copy of the species
 };
 
 
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 26a4bf13..89c385ef 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -18,18 +18,19 @@ class ParticleContainer
 public:
     typedef Ttraits_ traits_type;
 
-    typedef typename traits_type::particle_type         particle_type;
-    typedef typename particle_type::shape_type          particle_shape_type;
-    typedef typename traits_type::species_type          species_type;
-    typedef typename traits_type::species_id_type       species_id_type;
-    typedef typename traits_type::position_type         position_type;
-    typedef typename traits_type::particle_id_type      particle_id_type;
-    typedef typename traits_type::length_type           length_type;
-    typedef typename traits_type::size_type             size_type;
-    typedef typename traits_type::structure_type            structure_type;
-    typedef typename traits_type::structure_id_type         structure_id_type;
-    typedef typename traits_type::structure_type_type       structure_type_type;
-    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
+    // some shorthand typename inherited from the traits
+    typedef typename traits_type::particle_type                 particle_type;
+    typedef typename particle_type::shape_type                  particle_shape_type;
+    typedef typename traits_type::species_type                  species_type;
+    typedef typename traits_type::species_id_type               species_id_type;
+    typedef typename traits_type::position_type                 position_type;
+    typedef typename traits_type::particle_id_type              particle_id_type;
+    typedef typename traits_type::length_type                   length_type;
+    typedef typename traits_type::size_type                     size_type;
+    typedef typename traits_type::structure_type                structure_type;
+    typedef typename traits_type::structure_id_type             structure_id_type;
+    typedef typename traits_type::structure_type_type           structure_type_type;
+    typedef typename traits_type::structure_type_id_type        structure_type_id_type;
 
     typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
@@ -41,14 +42,14 @@ class ParticleContainer
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
 private:
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
-    typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
-    typedef std::map<structure_type_id_type, structure_type_type >                      structure_type_map;
-    typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >         structure_map;
+    typedef select_second<typename structure_map::value_type>                       structure_second_selector_type;
+    typedef std::map<structure_type_id_type, structure_type_type >                  structure_type_map;
+    typedef select_second<typename structure_type_map::value_type>                  structure_type_second_selector_type;
     typedef boost::transform_iterator<structure_second_selector_type,
-            typename structure_map::const_iterator>                         structure_iterator;
+            typename structure_map::const_iterator>                                 structure_iterator;
     typedef boost::transform_iterator<structure_type_second_selector_type,
-            typename structure_type_map::const_iterator>                    structure_type_iterator;
+            typename structure_type_map::const_iterator>                            structure_type_iterator;
 
 public:    
     typedef sized_iterator_range<structure_iterator>                structures_range;
diff --git a/Transaction.hpp b/Transaction.hpp
index efa61ba0..595d439b 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -20,14 +20,15 @@ class Transaction: public ParticleContainer<Ttraits_>
 public:
     typedef Ttraits_ traits_type;
     // useful shorthands for types that we are using.
-    typedef typename traits_type::particle_type     particle_type;
-    typedef typename particle_type::shape_type      particle_shape_type;
-    typedef typename traits_type::species_type      species_type;
-    typedef typename traits_type::species_id_type   species_id_type;
-    typedef typename traits_type::position_type     position_type;
-    typedef typename traits_type::particle_id_type  particle_id_type;
-    typedef typename traits_type::size_type         size_type;
-    typedef typename traits_type::length_type       length_type;
+    typedef typename traits_type::particle_type                 particle_type;
+    typedef typename particle_type::shape_type                  particle_shape_type;
+    typedef typename traits_type::species_type                  species_type;
+    typedef typename traits_type::species_id_type               species_id_type;
+    typedef typename traits_type::position_type                 position_type;
+    typedef typename traits_type::particle_id_type              particle_id_type;
+    typedef typename traits_type::size_type                     size_type;
+    typedef typename traits_type::length_type                   length_type;
+
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
@@ -64,6 +65,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
+
     typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
     typedef std::pair<structure_id_type, length_type>       structure_id_and_distance_pair;
     typedef abstract_limited_generator<particle_id_pair>    particle_id_pair_generator;
@@ -72,25 +74,24 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
 
 private:
     typedef std::map<typename particle_id_pair::first_type,
-            typename particle_id_pair::second_type> particle_id_pair_set_type;
-    typedef sorted_list<std::vector<particle_id_type> > particle_id_list_type;
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
-    typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
-    typedef std::map<structure_type_id_type, structure_type_type >                      structure_type_map;
-    typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
+            typename particle_id_pair::second_type>                         particle_id_pair_set_type;
+    typedef sorted_list<std::vector<particle_id_type> >                     particle_id_list_type;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;
+    typedef select_second<typename structure_map::value_type>               structure_second_selector_type;
+    typedef std::map<structure_type_id_type, structure_type_type >          structure_type_map;
+    typedef select_second<typename structure_type_map::value_type>          structure_type_second_selector_type;
 
 public:    
     typedef boost::transform_iterator<structure_second_selector_type,
-            typename structure_map::const_iterator>                 structure_iterator;
-    typedef sized_iterator_range<structure_iterator>                structures_range;
+            typename structure_map::const_iterator>                         structure_iterator;
+    typedef sized_iterator_range<structure_iterator>                        structures_range;
     typedef boost::transform_iterator<structure_type_second_selector_type,
-            typename structure_type_map::const_iterator>            structure_type_iterator;
-//    typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
+            typename structure_type_map::const_iterator>                    structure_type_iterator;
     typedef typename particle_container_type::structure_types_range         structure_types_range;
     typedef typename particle_container_type::structure_id_set              structure_id_set;
 
 
-
+    // Particle Stuff
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos)
     {
@@ -171,6 +172,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return new TransactionImpl<particle_container_type>(*this);
     }
 
+    ///// All the other methods are passed on to the associated ParticleContainer.
     // Species stuff
     virtual species_type const& get_species(species_id_type const& id) const
     {
@@ -322,8 +324,9 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return *i;
     }
 
+//////// Member variables.
 private:
-    particle_container_type&    pc_;        // the particle container
+    particle_container_type&    pc_;                    // the associated particle container
     particle_id_list_type       added_particles_;
     particle_id_list_type       modified_particles_;
     particle_id_pair_set_type   orig_particles_;
diff --git a/World.hpp b/World.hpp
index 32448174..141d4342 100644
--- a/World.hpp
+++ b/World.hpp
@@ -198,9 +198,8 @@ template<typename Ttraits_>
 class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 {
 // The world 'is a' ParticleContainerBase which is parameterize with the same World class
-// (I think the concrete implementation of it, not just the template)
 // The world is a template that is parametrized with the traits (these define a number of datatypes used in the definition of
-// the world?)
+// the world)
 public:
     typedef Ttraits_                        traits_type;                // Needs to be of WorldTraits type???
     typedef ParticleContainerBase<World>    base_type;                  // the class from which is inherited -> base class
@@ -224,12 +223,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     //
-//    typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;      // defines the pid_particle_pair tuple
-//    typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
-    typedef typename base_type::particle_id_pair                particle_id_pair;
-    typedef typename base_type::structure_id_pair               structure_id_pair;
-    typedef std::pair<position_type, length_type>                                   projected_type;
-    typedef typename particle_container_type::structure_id_and_distance_pair        structure_id_and_distance_pair;
+    typedef typename base_type::particle_id_pair                            particle_id_pair;      // defines the pid_particle_pair tuple
+    typedef typename base_type::structure_id_pair                           structure_id_pair;
+    typedef std::pair<position_type, length_type>                           projected_type;
+    typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
 
     typedef typename base_type::particle_id_set                             particle_id_set;
     typedef typename base_type::structure_id_set                            structure_id_set;
@@ -255,22 +252,12 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             typename structure_type_map::const_iterator>                    structure_type_iterator;
     typedef sized_iterator_range<species_iterator>                          species_range;
     typedef sized_iterator_range<structure_iterator>                        structures_range;
-//    typedef sized_iterator_range<structure_type_iterator>                   structure_types_range;
 
 public:
     // The constructor
     World(length_type world_size = 1., size_type size = 1)
-        : base_type(world_size, size)
-    {
-        // TODO Add the default structure of the default structure_type here?
-//        default_structure_id_ = structidgen_();
-    }
+        : base_type(world_size, size) {}
 
-    // Old method is case no structure_id is supplied.
-//    virtual particle_id_pair new_particle(species_id_type const& sid, position_type const& pos)
-//    {
-//        return new_particle(sid, default_structure_id_, pos);
-//    }
     // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos)
@@ -332,6 +319,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return true;
     }
 
+    ////// Species stuff
     // Adds a species to the world.
     void add_species(species_type const& species)
     {
@@ -359,7 +347,19 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             species_iterator(species_map_.end(),   species_second_selector_type()),
             species_map_.size());
     }
+    // Get all the particle ids by species
+    particle_id_set get_particle_ids(species_id_type const& sid) const
+    {
+        typename per_species_particle_id_set::const_iterator i(
+            particle_pool_.find(sid));
+        if (i == particle_pool_.end())
+        {
+            throw not_found(std::string("Unknown species (id=") + boost::lexical_cast<std::string>(sid) + ")");
+        }
+        return (*i).second;
+    }
 
+    ////// Structure stuff
     // Add a structure 
     virtual structure_id_type add_structure(boost::shared_ptr<structure_type> structure)
     {
@@ -439,50 +439,19 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         return (*i).second;
     }
+    // Get and set the default structure of the World
     virtual structure_id_type get_def_structure_id() const
     {
+        if (!default_structure_id_)
+        {
+            throw not_found("Default structure is not defined.");
+        }
         return default_structure_id_;
     }
     void set_def_structure_id(structure_id_type const& id)
     {
         default_structure_id_ = id;
     }
-
-    // TODO
-    // Add structureType
-    void add_structure_type(structure_type_type const& structure_type)
-    {
-        structure_type_map_[structure_type.id()] = structure_type;
-        structure_pool_[structure_type.id()] = structure_id_set();
-    }
-    // Get structureType by id
-    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
-    {
-        typename structure_type_map::const_iterator i(structure_type_map_.find(sid));
-        if (structure_type_map_.end() == i)
-        {
-            throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(sid) + ")");
-        }
-        return (*i).second;
-    }
-    // Get all structureTypes in the world
-    virtual structure_types_range get_structure_types() const
-    {
-        return structure_types_range(
-            structure_type_iterator(structure_type_map_.begin(), structure_types_second_selector_type()),
-            structure_type_iterator(structure_type_map_.end(), structure_types_second_selector_type()),
-            structure_type_map_.size());
-    }
-    virtual structure_type_id_type get_def_structure_type_id() const
-    {
-        return default_structure_type_id_;
-    }
-    void set_def_structure_type_id(structure_type_id_type const& sid)
-    {
-        default_structure_type_id_ = sid;
-    }
-
-
     // Get the closest surface(surface is a subclass of structures)
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {       
@@ -507,18 +476,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         
         return structure_id_and_distance_pair( ret_id , ret_dist );
     }
-   
-    // Get all the particle ids by species
-    particle_id_set get_particle_ids(species_id_type const& sid) const
-    {
-        typename per_species_particle_id_set::const_iterator i(
-            particle_pool_.find(sid));
-        if (i == particle_pool_.end())
-        {
-            throw not_found(std::string("Unknown species (id=") + boost::lexical_cast<std::string>(sid) + ")");
-        }
-        return (*i).second;
-    }
     // Get all the particle ids of the particles on a structure
     particle_id_set get_particle_ids_on_struct(structure_id_type const& struct_id) const
     {
@@ -531,6 +488,47 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return (*i).second;
     }
 
+
+    ////// StructureType stuff
+    // Add structureType
+    void add_structure_type(structure_type_type const& structure_type)
+    {
+        structure_type_map_[structure_type.id()] = structure_type;
+        structure_pool_[structure_type.id()] = structure_id_set();
+    }
+    // Get structureType by id
+    virtual structure_type_type get_structure_type(structure_type_id_type const& sid) const
+    {
+        typename structure_type_map::const_iterator i(structure_type_map_.find(sid));
+        if (structure_type_map_.end() == i)
+        {
+            throw not_found(std::string("Unknown structure_type (id=") + boost::lexical_cast<std::string>(sid) + ")");
+        }
+        return (*i).second;
+    }
+    // Get all structureTypes in the world
+    virtual structure_types_range get_structure_types() const
+    {
+        return structure_types_range(
+            structure_type_iterator(structure_type_map_.begin(), structure_types_second_selector_type()),
+            structure_type_iterator(structure_type_map_.end(), structure_types_second_selector_type()),
+            structure_type_map_.size());
+    }
+    // Get and set the default structure_type of the world
+    virtual structure_type_id_type get_def_structure_type_id() const
+    {
+        if (!default_structure_type_id_)
+        {
+            throw not_found("Default structure_type is not defined.");
+        }
+        return default_structure_type_id_;
+    }
+    void set_def_structure_type_id(structure_type_id_type const& sid)
+    {
+        default_structure_type_id_ = sid;
+    }
+
+
 ///////////// Member variables
 private:
     particle_id_generator               pidgen_;            // generator used to produce the unique ids for the particles
@@ -542,8 +540,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     per_species_particle_id_set         particle_pool_;     // mapping: species_id -> set of particle ids of that species
     per_structure_particle_id_set       particleonstruct_pool_;
 
-    structure_id_type                   default_structure_id_;
-    structure_type_id_type              default_structure_type_id_;
+    structure_id_type                   default_structure_id_;      // The default structure of the World (is a CuboidalRegion of the size of the world)
+    structure_type_id_type              default_structure_type_id_; // The default structure_type of the World (every structure must have a StructureType)
 };
 
 #endif /* WORLD_HPP */

From e0c448251bda5eacdd779d6fc471fd758920f62e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Mar 2012 13:45:20 +0100
Subject: [PATCH 0712/1541] Added comments to clearup the structure of the
 binding between C++ and Python

---
 binding/BDPropagator.hpp                | 24 ++++++----
 binding/BDSimulator.hpp                 |  3 ++
 binding/Box.hpp                         |  5 +++
 binding/ConsoleAppender.cpp             |  2 +
 binding/CuboidalRegion.hpp              |  2 +
 binding/Cylinder.hpp                    |  3 ++
 binding/CylindricalPair.hpp             |  2 +
 binding/CylindricalSingle.hpp           |  2 +
 binding/CylindricalSurface.hpp          |  2 +
 binding/Domain.hpp                      |  2 +
 binding/EGFRDSimulator.hpp              | 10 +++++
 binding/Event.hpp                       |  2 +
 binding/EventScheduler.hpp              |  4 ++
 binding/LogAppender.cpp                 |  3 ++
 binding/Logger.cpp                      |  3 ++
 binding/LoggerManager.cpp               |  4 ++
 binding/MatrixSpace.hpp                 |  6 +++
 binding/Model.hpp                       |  3 ++
 binding/Multi.hpp                       |  2 +
 binding/MultiParticleContainer.hpp      |  4 ++
 binding/NetworkRules.hpp                |  2 +
 binding/NetworkRulesWrapper.hpp         |  1 +
 binding/Pair.hpp                        |  4 ++
 binding/ParticleContainer.hpp           | 58 +++++++++++++------------
 binding/ParticleModel.hpp               |  3 ++
 binding/ParticleSimulationStructure.hpp |  3 ++
 binding/ParticleSimulator.hpp           |  3 ++
 binding/PlanarSurface.hpp               |  3 ++
 binding/Plane.hpp                       |  4 ++
 binding/PythonEvent.hpp                 |  3 ++
 binding/RandomNumberGenerator.hpp       |  2 +
 binding/ReactionRecord.hpp              |  4 ++
 binding/ReactionRule.hpp                |  9 ++++
 binding/ReactionRuleInfo.hpp            | 10 +++--
 binding/Region.hpp                      |  2 +
 binding/SerialIDGenerator.hpp           |  3 ++
 binding/ShapedDomain.hpp                |  2 +
 binding/Single.hpp                      |  6 +++
 binding/SpeciesInfo.hpp                 |  3 ++
 binding/SpeciesType.hpp                 |  4 ++
 binding/Sphere.hpp                      |  4 ++
 binding/SphericalPair.hpp               |  3 ++
 binding/SphericalSingle.hpp             |  3 ++
 binding/SphericalSurface.hpp            |  3 ++
 binding/Structure.hpp                   |  4 ++
 binding/StructureType.hpp               |  5 +++
 binding/Surface.hpp                     |  3 ++
 binding/World.hpp                       | 11 +++++
 binding/newBDPropagator.hpp             | 28 +++++++-----
 binding/position_converters.cpp         |  7 +++
 binding/volume_clearer_converter.hpp    |  3 ++
 binding/world_class.cpp                 |  2 +
 pyGFRD.cpp                              | 15 +++++++
 53 files changed, 257 insertions(+), 51 deletions(-)

diff --git a/binding/BDPropagator.hpp b/binding/BDPropagator.hpp
index 9dc027f9..6a68c2e5 100644
--- a/binding/BDPropagator.hpp
+++ b/binding/BDPropagator.hpp
@@ -9,28 +9,34 @@
 
 namespace binding {
 
+// Not sure what this does
 template<typename Timpl_>
 static void BDPropagator_propagate_all(Timpl_& self)
 {
     while (self());
 }
 
+
+////// Registering master function
 template<typename Timpl_>
 inline boost::python::objects::class_base register_bd_propagator_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl_ impl_type;
-    typedef typename impl_type::traits_type simulator_traits_type;
-    typedef typename simulator_traits_type::world_type world_type;
-    typedef typename world_type::particle_id_type particle_id_type;
-    typedef typename simulator_traits_type::network_rules_type network_rules_type;
-    typedef typename world_type::traits_type::rng_type rng_type;
-    typedef typename simulator_traits_type::time_type time_type;
-    typedef typename world_type::particle_container_type particle_container_type;
-    typedef typename impl_type::reaction_recorder_type reaction_recorder_type;
-    typedef typename impl_type::volume_clearer_type volume_clearer_type;
 
+    typedef typename impl_type::traits_type                     simulator_traits_type;
+    typedef typename impl_type::reaction_recorder_type          reaction_recorder_type;
+    typedef typename impl_type::volume_clearer_type             volume_clearer_type;
+    typedef typename simulator_traits_type::world_type          world_type;
+    typedef typename simulator_traits_type::network_rules_type  network_rules_type;
+    typedef typename simulator_traits_type::time_type           time_type;
+    typedef typename world_type::particle_id_type               particle_id_type;
+    typedef typename world_type::particle_container_type        particle_container_type;
+    typedef typename world_type::traits_type::rng_type          rng_type;
+
+    // registering range converter from standard boost template
     peer::converters::register_pyiterable_range_converter<particle_id_type>();
+
     return class_<impl_type, boost::noncopyable>(
         name, init<
             particle_container_type&, network_rules_type const&, rng_type&,
diff --git a/binding/BDSimulator.hpp b/binding/BDSimulator.hpp
index 10561d83..c61fbd8e 100644
--- a/binding/BDSimulator.hpp
+++ b/binding/BDSimulator.hpp
@@ -10,12 +10,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 void register_bd_simulator_class(char const* name)
 {
     using namespace boost::python;
     using boost::shared_ptr;
     typedef Timpl impl_type;
+
     class_<impl_type, bases<typename impl_type::base_type>, boost::noncopyable>(
             name,
             init<boost::shared_ptr<typename impl_type::world_type>,
diff --git a/binding/Box.hpp b/binding/Box.hpp
index 07a635d1..28757597 100644
--- a/binding/Box.hpp
+++ b/binding/Box.hpp
@@ -8,24 +8,29 @@
 
 namespace binding {
 
+// Not sure
 template<typename Timpl_>
 static std::string Box___str__(Timpl_* impl)
 {
     return boost::lexical_cast<std::string>(*impl);
 }
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_box_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // registering converters from standard boost templates
     to_python_converter<boost::array<typename impl_type::length_type, 3>,
             peer::util::detail::to_ndarray_converter<
                 boost::array<typename impl_type::length_type, 3> > >();
     peer::converters::register_iterable_to_ra_container_converter<
             boost::array<typename impl_type::length_type, 3>, 3>();
 
+    // defining the python class
     return class_<impl_type>(name)
         .def(init<typename impl_type::position_type, 
                   typename impl_type::position_type, 
diff --git a/binding/ConsoleAppender.cpp b/binding/ConsoleAppender.cpp
index 895e2aed..901d530a 100644
--- a/binding/ConsoleAppender.cpp
+++ b/binding/ConsoleAppender.cpp
@@ -9,6 +9,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 boost::python::objects::class_base
 register_console_appender_class(char const* name)
 {
diff --git a/binding/CuboidalRegion.hpp b/binding/CuboidalRegion.hpp
index 6a03414a..5bfdb6d7 100644
--- a/binding/CuboidalRegion.hpp
+++ b/binding/CuboidalRegion.hpp
@@ -5,6 +5,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_cuboidal_region_class(char const *name)
 {
diff --git a/binding/Cylinder.hpp b/binding/Cylinder.hpp
index ca92bdd0..6572331d 100644
--- a/binding/Cylinder.hpp
+++ b/binding/Cylinder.hpp
@@ -6,12 +6,15 @@
 
 namespace binding {
 
+// A template to perform string conversions?
 template<typename Timpl_>
 static std::string Cylinder___str__(Timpl_* impl)
 {
     return boost::lexical_cast<std::string>(*impl);
 }
 
+
+////// Registering master function
 template<typename Timpl_>
 inline boost::python::objects::class_base register_cylinder_class(char const* name)
 {
diff --git a/binding/CylindricalPair.hpp b/binding/CylindricalPair.hpp
index b9169cf1..a378d0c9 100644
--- a/binding/CylindricalPair.hpp
+++ b/binding/CylindricalPair.hpp
@@ -6,6 +6,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_cylindrical_pair_class(char const* name)
 {
diff --git a/binding/CylindricalSingle.hpp b/binding/CylindricalSingle.hpp
index 3c35bd3a..be8702ac 100644
--- a/binding/CylindricalSingle.hpp
+++ b/binding/CylindricalSingle.hpp
@@ -7,6 +7,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_cylindrical_single_class(char const* name)
 {
diff --git a/binding/CylindricalSurface.hpp b/binding/CylindricalSurface.hpp
index 0909037d..fac1cc7b 100644
--- a/binding/CylindricalSurface.hpp
+++ b/binding/CylindricalSurface.hpp
@@ -5,6 +5,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_cylindrical_surface_class(char const *name)
 {
diff --git a/binding/Domain.hpp b/binding/Domain.hpp
index 71fa9020..6b565f45 100644
--- a/binding/Domain.hpp
+++ b/binding/Domain.hpp
@@ -6,6 +6,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_domain_class(char const* name)
 {
diff --git a/binding/EGFRDSimulator.hpp b/binding/EGFRDSimulator.hpp
index 2357316f..45c6e855 100644
--- a/binding/EGFRDSimulator.hpp
+++ b/binding/EGFRDSimulator.hpp
@@ -10,6 +10,9 @@
 
 namespace binding {
 
+//// Converters. These convert C++ types to something that Python can handle.
+
+//
 template<typename Timpl_>
 struct shell_variant_converter
 {
@@ -41,16 +44,20 @@ struct shell_variant_converter
         return boost::python::incref(boost::apply_visitor(visitor(), val).ptr());
     }
 
+    // Also need to register the converter.
     static void __register()
     {
         boost::python::to_python_converter<native_type, shell_variant_converter>();
     }
 };
 
+
+////// Registering master function
 template<typename Timpl>
 void register_egfrd_simulator_class(char const* name)
 {
     using namespace boost::python;
+    // typedefs
     typedef Timpl impl_type;
     typedef std::pair<typename impl_type::shell_id_type, typename impl_type::shell_variant_type> get_shell_result_type;
     enum_<typename impl_type::domain_kind>("DomainKind")
@@ -78,6 +85,8 @@ void register_egfrd_simulator_class(char const* name)
         .value("ESCAPE", impl_type::multi_type::ESCAPE)
         .value("REACTION", impl_type::multi_type::REACTION)
         ;
+
+    // defining the python class
     class_<impl_type, bases<typename impl_type::base_type>, boost::noncopyable>(
             name,
             init<boost::shared_ptr<typename impl_type::world_type>,
@@ -105,6 +114,7 @@ void register_egfrd_simulator_class(char const* name)
                 return_value_policy<return_by_value>())
         ;
 
+    // register wrappers and converters
     peer::wrappers::generator_wrapper<
         ptr_generator<typename impl_type::domain_id_pair_generator,
                       std::auto_ptr<
diff --git a/binding/Event.hpp b/binding/Event.hpp
index 51128497..d7fd55a0 100644
--- a/binding/Event.hpp
+++ b/binding/Event.hpp
@@ -5,6 +5,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::object register_event_class(char const* name)
 {
diff --git a/binding/EventScheduler.hpp b/binding/EventScheduler.hpp
index c0e92088..a85e7e8d 100644
--- a/binding/EventScheduler.hpp
+++ b/binding/EventScheduler.hpp
@@ -7,6 +7,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base
 register_event_scheduler_class(char const* name)
@@ -14,6 +16,7 @@ register_event_scheduler_class(char const* name)
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // registering converters
     peer::converters::register_tuple_converter<
             typename impl_type::value_type>();
 
@@ -23,6 +26,7 @@ register_event_scheduler_class(char const* name)
     peer::converters::register_tuple_converter<
             typename impl_type::value_type>();
 
+    // defining the python class
     return class_<impl_type, boost::noncopyable>(name)
         .add_property("time", &impl_type::time)
         .add_property("top",
diff --git a/binding/LogAppender.cpp b/binding/LogAppender.cpp
index a980ac17..18bee108 100644
--- a/binding/LogAppender.cpp
+++ b/binding/LogAppender.cpp
@@ -33,12 +33,15 @@ static void log_appender_call(Timpl& self, enum Logger::level lv,
     self(lv, name, &chunks.front());
 }
 
+
+////// Registering master function
 boost::python::objects::class_base
 register_log_appender_class(char const* name)
 {
     using namespace boost::python;
     typedef LogAppender impl_type;
 
+    // defining the python class
     return class_<impl_type, boost::shared_ptr<impl_type>, boost::noncopyable>(name, no_init)
         .def("flush", &impl_type::flush)
         .def("__call__", &log_appender_call<impl_type>)
diff --git a/binding/Logger.cpp b/binding/Logger.cpp
index 792acbb2..d88f1fc7 100644
--- a/binding/Logger.cpp
+++ b/binding/Logger.cpp
@@ -8,12 +8,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 boost::python::objects::class_base
 register_logger_class(char const* name)
 {
     using namespace boost::python;
     typedef Logger impl_type;
 
+    // defining the python class
     return class_<impl_type, boost::noncopyable>(name, no_init)
         .add_property("level",
             static_cast<enum impl_type::level(impl_type::*)() const>(
diff --git a/binding/LoggerManager.cpp b/binding/LoggerManager.cpp
index 70b75d8c..921fc19f 100644
--- a/binding/LoggerManager.cpp
+++ b/binding/LoggerManager.cpp
@@ -8,6 +8,7 @@
 
 namespace binding {
 
+// defining the loglevel
 boost::python::objects::enum_base
 register_logger_level_enum(char const* name)
 {
@@ -22,6 +23,8 @@ register_logger_level_enum(char const* name)
         ;
 }
 
+
+////// Registering master function
 boost::python::objects::class_base
 register_logger_manager_class(char const* name)
 {
@@ -31,6 +34,7 @@ register_logger_manager_class(char const* name)
     peer::converters::register_range_to_tuple_converter<
         std::vector<boost::shared_ptr<LogAppender> > >();
 
+    // defining the python class
     return class_<impl_type, boost::shared_ptr<impl_type>, boost::noncopyable>(name, no_init)
         .add_property("level",
             static_cast<enum Logger::level(impl_type::*)() const>(&impl_type::level),
diff --git a/binding/MatrixSpace.hpp b/binding/MatrixSpace.hpp
index 3df6894d..04052603 100644
--- a/binding/MatrixSpace.hpp
+++ b/binding/MatrixSpace.hpp
@@ -41,6 +41,8 @@
 
 namespace binding {
 
+
+
 struct MatrixSpaceExtrasBase
 {
     template<typename T_, typename Tref_>
@@ -427,6 +429,8 @@ class MatrixSpaceExtras: public MatrixSpaceExtrasBase
     }
 };
 
+
+////// Registering master function
 template<typename Timpl_>
 inline void register_matrix_space_class(char const* class_name)
 {
@@ -434,6 +438,7 @@ inline void register_matrix_space_class(char const* class_name)
     typedef MatrixSpaceExtras<impl_type> extras_type;
     using namespace boost::python;
 
+    // register converters from standard boost templates
     extras_type::Builders::__register_converter();
 
     std::string const _class_name(class_name);
@@ -446,6 +451,7 @@ inline void register_matrix_space_class(char const* class_name)
             typename extras_type::key_iterator,
             boost::python::object>::__class_init__((_class_name + ".keyiterator").c_str());
 
+    // defining the python class for the matrix space
     class_<impl_type>(class_name,
             init<typename impl_type::length_type,
                  typename impl_type::size_type>())
diff --git a/binding/Model.hpp b/binding/Model.hpp
index 7de293f4..5e659e5b 100644
--- a/binding/Model.hpp
+++ b/binding/Model.hpp
@@ -13,6 +13,8 @@ static void Model___setitem__(Timpl* model, std::string const& key, std::string
     (*model)[key] = value;
 }
 
+
+////// Registering master function
 template<typename Tmodel_>
 inline void register_model_class(char const* name)
 {
@@ -22,6 +24,7 @@ inline void register_model_class(char const* name)
     docstring_options doc_options;
     doc_options.disable_signatures();
 
+    // defining the python class
     class_<impl_type, boost::noncopyable>(name)
         .add_property("network_rules",
             make_function(&impl_type::network_rules,
diff --git a/binding/Multi.hpp b/binding/Multi.hpp
index 0914c9fb..33216bc4 100644
--- a/binding/Multi.hpp
+++ b/binding/Multi.hpp
@@ -7,6 +7,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_multi_class(char const* name)
 {
diff --git a/binding/MultiParticleContainer.hpp b/binding/MultiParticleContainer.hpp
index bcf59647..f04ee4c6 100644
--- a/binding/MultiParticleContainer.hpp
+++ b/binding/MultiParticleContainer.hpp
@@ -8,14 +8,18 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl, typename Tworld>
 boost::python::objects::class_base register_multi_particle_container_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // registering converters from standard boost templates
     peer::converters::register_tuple_converter<typename impl_type::real_pair>();
 
+    // defining the python class
     return class_<impl_type, bases<typename Tworld::particle_container_type>,
            boost::noncopyable>(name, init<Tworld&>())
         .def("determine_dt_and_reaction_length",&impl_type::determine_dt_and_reaction_length)
diff --git a/binding/NetworkRules.hpp b/binding/NetworkRules.hpp
index 43850619..ae33810a 100644
--- a/binding/NetworkRules.hpp
+++ b/binding/NetworkRules.hpp
@@ -5,6 +5,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl_>
 boost::python::objects::class_base register_network_rules_class(char const* name)
 {
diff --git a/binding/NetworkRulesWrapper.hpp b/binding/NetworkRulesWrapper.hpp
index 83768423..84114349 100644
--- a/binding/NetworkRulesWrapper.hpp
+++ b/binding/NetworkRulesWrapper.hpp
@@ -10,6 +10,7 @@
 
 namespace binding {
 
+////// Registering master function
 template<typename Timpl>
 boost::python::objects::class_base register_network_rules_wrapper_class(char const* name)
 {
diff --git a/binding/Pair.hpp b/binding/Pair.hpp
index d594ebee..9e8c859b 100644
--- a/binding/Pair.hpp
+++ b/binding/Pair.hpp
@@ -6,15 +6,19 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_pair_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // converters from standard boost templates.
     peer::converters::register_range_to_tuple_converter<
             typename impl_type::particle_array_type>();
 
+    // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(name, no_init)
         .add_property("particles",
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 32672d41..48622a9a 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -27,8 +27,9 @@
 
 namespace binding {
 
+//// Converters. These convert C++ types to something that Python can handle.
 
-// Converters. These convert C++ types to something that Python can handle.
+// 
 template<typename Timpl_>
 struct particle_id_pair_generator_converter
 {
@@ -54,6 +55,7 @@ struct particle_id_pair_generator_converter
         }
     };
 
+    // Also need to register the converter.
     static void __register()
     {
         peer::wrappers::generator_wrapper<
@@ -69,6 +71,7 @@ struct particle_id_pair_generator_converter
     }
 };
 
+// Not sure if this should be defined here or in binding/World.hpp
 template<typename Timpl_>
 struct structure_id_pair_generator_converter
 {
@@ -94,6 +97,7 @@ struct structure_id_pair_generator_converter
         }
     };
 
+    // Also need to register the converter.
     static void __register()
     {
         peer::wrappers::generator_wrapper<
@@ -206,6 +210,7 @@ struct particle_id_pair_and_distance_list_converter
         }
     };
 
+    // Also need to register the converter.
     static void __register()
     {
         to_python_converter::wrapper_type::__class_init__("ParticleIDAndDistanceVector", boost::python::scope().ptr());
@@ -223,41 +228,34 @@ class ParticleContainerWrapper
 public:
     typedef boost::python::wrapper<Tbase_> py_wrapper_type;
     typedef Tbase_ wrapped_type;
-    typedef typename wrapped_type::size_type                size_type;
-    typedef typename wrapped_type::length_type              length_type;
-    typedef typename wrapped_type::particle_id_type         particle_id_type;
-    typedef typename wrapped_type::particle_shape_type      particle_shape_type;
-    typedef typename wrapped_type::position_type            position_type;
-    typedef typename wrapped_type::species_id_type          species_id_type;
-    typedef typename wrapped_type::species_type             species_type;
-    typedef typename wrapped_type::structure_type           structure_type;
-    typedef typename wrapped_type::structure_id_type        structure_id_type;
-    typedef typename wrapped_type::structure_type_type      structure_type_type;
-    typedef typename wrapped_type::structure_type_id_type   structure_type_id_type;
-    typedef typename wrapped_type::particle_id_pair         particle_id_pair;
-    typedef typename wrapped_type::structure_id_pair        structure_id_pair;
-    typedef typename wrapped_type::transaction_type         transaction_type;
+    // Get types that are defined in the ParticleContainer class that we are wrapping.
+    typedef typename wrapped_type::size_type                            size_type;
+    typedef typename wrapped_type::length_type                          length_type;
+    typedef typename wrapped_type::particle_id_type                     particle_id_type;
+    typedef typename wrapped_type::particle_shape_type                  particle_shape_type;
+    typedef typename wrapped_type::position_type                        position_type;
+    typedef typename wrapped_type::species_type                         species_type;
+    typedef typename wrapped_type::species_id_type                      species_id_type;
+    typedef typename wrapped_type::structure_type                       structure_type;
+    typedef typename wrapped_type::structure_id_type                    structure_id_type;
+    typedef typename wrapped_type::structure_type_type                  structure_type_type;
+    typedef typename wrapped_type::structure_type_id_type               structure_type_id_type;
+
+    typedef typename wrapped_type::particle_id_pair                     particle_id_pair;
+    typedef typename wrapped_type::structure_id_pair                    structure_id_pair;
     typedef typename wrapped_type::particle_id_pair_generator           particle_id_pair_generator;
     typedef typename wrapped_type::structure_id_pair_generator          structure_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
     typedef typename wrapped_type::structure_id_set                     structure_id_set;
-    typedef typename wrapped_type::structure_types_range    structure_types_range;
+    typedef typename wrapped_type::structures_range                     structures_range;
+    typedef typename wrapped_type::structure_types_range                structure_types_range;
 
-private:
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >             structure_map;
-    typedef select_second<typename structure_map::value_type>                           structure_second_selector_type;
-    typedef std::map<structure_type_id_type, structure_type_type >                      structure_type_map;
-    typedef select_second<typename structure_type_map::value_type>                      structure_type_second_selector_type;
+    typedef typename wrapped_type::transaction_type                     transaction_type;
 
 public:    
-    typedef boost::transform_iterator<structure_second_selector_type,
-            typename structure_map::const_iterator>             structure_iterator;
-    typedef sized_iterator_range<structure_iterator>            structures_range;
-    typedef boost::transform_iterator<structure_type_second_selector_type,
-            typename structure_type_map::const_iterator>        structure_type_iterator;
-//    typedef sized_iterator_range<structure_type_iterator>       structure_types_range;
 
+    //
     virtual ~ParticleContainerWrapper() {}
 
     virtual size_type num_particles() const
@@ -422,22 +420,26 @@ class ParticleContainerWrapper
 };
 
 
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_particle_container_class(
         char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
+
+    // registering converters from standard boost templates.
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair>();
     peer::converters::register_tuple_converter<typename impl_type::structure_id_pair>();
     peer::converters::register_tuple_converter<typename impl_type::structure_id_and_distance_pair>();
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair_and_distance>();
 
-    // register the converters (not sure what this does)
+    // register the converters that are defined above (not sure what this does)
     particle_id_pair_and_distance_list_converter<typename impl_type::particle_id_pair_and_distance_list>::__register();
     particle_id_pair_generator_converter<typename impl_type::particle_id_pair_generator>::__register();
     structure_id_pair_generator_converter<typename impl_type::structure_id_pair_generator>::__register();
 
+    // defining the python class
     return class_<ParticleContainerWrapper<impl_type>, boost::noncopyable>(name)
         .add_property("num_particles", &impl_type::num_particles)
         .add_property("world_size", &impl_type::world_size)
diff --git a/binding/ParticleModel.hpp b/binding/ParticleModel.hpp
index 6d053a06..78f5f9ed 100644
--- a/binding/ParticleModel.hpp
+++ b/binding/ParticleModel.hpp
@@ -6,12 +6,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Tparticle_model_>
 inline void register_particle_model_class(char const* name)
 {
     using namespace boost::python;
     typedef Tparticle_model_ impl_type;
 
+    // defining the python class
     class_<impl_type, bases<typename impl_type::base_type>, boost::noncopyable>(name)
         .def("add_structure_type", &impl_type::add_structure_type)
         .def("get_structure_type_by_id", &impl_type::get_structure_type_by_id)
diff --git a/binding/ParticleSimulationStructure.hpp b/binding/ParticleSimulationStructure.hpp
index 5c7b61b2..aa722877 100644
--- a/binding/ParticleSimulationStructure.hpp
+++ b/binding/ParticleSimulationStructure.hpp
@@ -5,12 +5,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_particle_simulation_structure_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class (kinda empty)
     return class_<impl_type, bases<typename impl_type::base_type>,
                   boost::shared_ptr<impl_type>,
                   boost::noncopyable>(name, no_init)
diff --git a/binding/ParticleSimulator.hpp b/binding/ParticleSimulator.hpp
index 7e08e959..cbd63190 100644
--- a/binding/ParticleSimulator.hpp
+++ b/binding/ParticleSimulator.hpp
@@ -9,12 +9,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 void register_particle_simulator_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     class_<impl_type, boost::noncopyable>(name, no_init)
         .add_property("world",
             make_function(
diff --git a/binding/PlanarSurface.hpp b/binding/PlanarSurface.hpp
index 4c6ec6af..7ef7e688 100644
--- a/binding/PlanarSurface.hpp
+++ b/binding/PlanarSurface.hpp
@@ -5,12 +5,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_planar_surface_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::identifier_type,
diff --git a/binding/Plane.hpp b/binding/Plane.hpp
index 23ab2342..c341e5c3 100644
--- a/binding/Plane.hpp
+++ b/binding/Plane.hpp
@@ -8,18 +8,22 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_plane_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // registering converters from standard boost templates.
     to_python_converter<boost::array<typename impl_type::length_type, 2>,
             peer::util::detail::to_ndarray_converter<
                 boost::array<typename impl_type::length_type, 2> > >();
     peer::converters::register_iterable_to_ra_container_converter<
             boost::array<typename impl_type::length_type, 2>, 2>();
 
+    // defining the python class
     return class_<impl_type>(name)
         .def(init<typename impl_type::position_type, 
                   typename impl_type::position_type, 
diff --git a/binding/PythonEvent.hpp b/binding/PythonEvent.hpp
index c5f8cec1..01f34421 100644
--- a/binding/PythonEvent.hpp
+++ b/binding/PythonEvent.hpp
@@ -5,11 +5,14 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::object register_python_event_class(char const* name)
 {
     using namespace boost::python;
 
+    // defining the python class
     return class_<Timpl, bases<typename Timpl::base_type>, boost::shared_ptr<Timpl>, boost::noncopyable>(name, init<typename Timpl::time_type>())
         .def(init<typename Timpl::time_type, boost::python::object const&>())
         .add_property("data",
diff --git a/binding/RandomNumberGenerator.hpp b/binding/RandomNumberGenerator.hpp
index 328f9c39..beb9d4c0 100644
--- a/binding/RandomNumberGenerator.hpp
+++ b/binding/RandomNumberGenerator.hpp
@@ -65,6 +65,8 @@ static PyObject* RandomNumberGenerator_normal(Timpl_& impl, Real loc, Real scale
     }
 }
 
+
+////// Registering master function
 template<typename Timpl_>
 static void register_random_number_generator_class(char const* name)
 {
diff --git a/binding/ReactionRecord.hpp b/binding/ReactionRecord.hpp
index 3ab4b001..277a67af 100644
--- a/binding/ReactionRecord.hpp
+++ b/binding/ReactionRecord.hpp
@@ -6,16 +6,20 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl_>
 boost::python::objects::class_base register_reaction_record_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl_ impl_type;
 
+    // registering converters from standard boost templates
     peer::converters::register_range_to_tuple_converter<typename impl_type::reactants_type>();
     peer::converters::register_range_to_tuple_converter<typename impl_type::products_type>();
     peer::converters::register_pyiterable_range_converter<typename impl_type::particle_id_type>();
 
+    // defining the python class
     return class_<impl_type>(name, init<>())
         .def(init<typename impl_type::reaction_rule_id_type const&,
                   peer::wrappers::pyiterable_range<
diff --git a/binding/ReactionRule.hpp b/binding/ReactionRule.hpp
index 73e222a7..7ea15904 100644
--- a/binding/ReactionRule.hpp
+++ b/binding/ReactionRule.hpp
@@ -15,6 +15,9 @@
 
 namespace binding {
 
+//// Converters. These convert C++ types to something that Python can handle.
+
+// 
 template<typename Trr_>
 struct seq_to_reactants_converter
 {
@@ -62,6 +65,8 @@ struct seq_to_reactants_converter
     }
 };
 
+//////
+// structure defining some helper functions.
 template<typename Timpl_>
 struct ReactionRuleExtras
 {
@@ -104,6 +109,8 @@ struct ReactionRuleExtras
     }
 };
 
+
+////// Registering master function
 template<typename Trr_>
 inline void register_reaction_rule_class(const char* name)
 {
@@ -111,6 +118,7 @@ inline void register_reaction_rule_class(const char* name)
     typedef Trr_ impl_type;
     typedef ReactionRuleExtras<impl_type> extras_type;
 
+    // registering the converters from templates defined above.
     typedef std::vector<typename impl_type::species_type_id_type> species_type_id_vector;
     peer::util::to_native_converter<
             typename impl_type::Reactants,
@@ -120,6 +128,7 @@ inline void register_reaction_rule_class(const char* name)
     peer::converters::register_iterable_to_range_converter<
             species_type_id_vector>();
 
+    // defining the class
     class_<impl_type>(name,
             init<typename impl_type::Reactants const&, species_type_id_vector>())
         .add_property("reactants",  
diff --git a/binding/ReactionRuleInfo.hpp b/binding/ReactionRuleInfo.hpp
index 886b959a..4dea0abd 100644
--- a/binding/ReactionRuleInfo.hpp
+++ b/binding/ReactionRuleInfo.hpp
@@ -7,12 +7,19 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline void register_reaction_rule_info_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // registering converters from standard boost templates.
+    peer::converters::register_range_to_tuple_converter<typename impl_type::species_id_range>();
+    peer::converters::register_iterable_to_range_converter<typename impl_type::species_id_range>();
+
+    // defining the python class
     class_<impl_type>(name,
         init<typename impl_type::identifier_type,
              typename impl_type::rate_type,
@@ -29,9 +36,6 @@ inline void register_reaction_rule_info_class(char const *name)
             make_function(&impl_type::get_reactants,
                           return_value_policy<return_by_value>()));
 
-    peer::converters::register_range_to_tuple_converter<typename impl_type::species_id_range>();
-
-    peer::converters::register_iterable_to_range_converter<typename impl_type::species_id_range>();
 }
 
 } // namespace binding
diff --git a/binding/Region.hpp b/binding/Region.hpp
index f43c13f1..ef92bc58 100644
--- a/binding/Region.hpp
+++ b/binding/Region.hpp
@@ -5,12 +5,14 @@
 
 namespace binding {
 
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_region_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class (kinda empty)
     return class_<impl_type, bases<typename impl_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, no_init);
diff --git a/binding/SerialIDGenerator.hpp b/binding/SerialIDGenerator.hpp
index d5e0f012..31aef59e 100644
--- a/binding/SerialIDGenerator.hpp
+++ b/binding/SerialIDGenerator.hpp
@@ -4,11 +4,14 @@
 #include <boost/python.hpp>
 #include "../SerialIDGenerator.hpp"
 
+
+////// Registering master function
 template<typename T>
 inline void register_serial_id_generator_class(char const* class_name)
 {
     using namespace boost::python;
 
+    // defining the python class
     class_<SerialIDGenerator<T> >(class_name, init<int>())
         .def("__call__", &SerialIDGenerator<T>::operator())
         ;
diff --git a/binding/ShapedDomain.hpp b/binding/ShapedDomain.hpp
index 2293f9aa..6af44019 100644
--- a/binding/ShapedDomain.hpp
+++ b/binding/ShapedDomain.hpp
@@ -6,12 +6,14 @@
 
 namespace binding {
 
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_shaped_domain_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     return class_<impl_type, boost::shared_ptr<impl_type>,
                   boost::noncopyable>(name, no_init)
         .add_property("position", 
diff --git a/binding/Single.hpp b/binding/Single.hpp
index 287d6ba6..8e590d13 100644
--- a/binding/Single.hpp
+++ b/binding/Single.hpp
@@ -5,6 +5,9 @@
 
 namespace binding {
 
+////// Helper functions
+
+// makes a set consisting of a single particle?
 template<typename Timpl>
 static void single_set_particle(Timpl& impl, typename Timpl::particle_id_pair const& pair)
 {
@@ -12,12 +15,15 @@ static void single_set_particle(Timpl& impl, typename Timpl::particle_id_pair co
     impl.particle().second = pair.second;
 }
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_single_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(name, no_init)
         .add_property("particle",
diff --git a/binding/SpeciesInfo.hpp b/binding/SpeciesInfo.hpp
index 217a28e6..59d9feda 100644
--- a/binding/SpeciesInfo.hpp
+++ b/binding/SpeciesInfo.hpp
@@ -6,6 +6,8 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl_>
 inline boost::python::objects::class_base register_species_info_class(
         char const* name)
@@ -13,6 +15,7 @@ inline boost::python::objects::class_base register_species_info_class(
     using namespace boost::python;
     typedef Timpl_ impl_type;
 
+    // defining the python class
     return class_<impl_type>("SpeciesInfo",
             init<>() )
         .def(init<typename impl_type::identifier_type, typename impl_type::structure_type_id_type,
diff --git a/binding/SpeciesType.hpp b/binding/SpeciesType.hpp
index 64bae5de..f3f79864 100644
--- a/binding/SpeciesType.hpp
+++ b/binding/SpeciesType.hpp
@@ -14,6 +14,7 @@
 
 namespace binding {
 
+// Defining a structure with some helper functions.
 template<typename Timpl_>
 struct SpeciesTypeExtras
 {
@@ -35,6 +36,8 @@ struct SpeciesTypeExtras
     }
 };
 
+
+////// Registering master function
 template<typename Timpl_>
 static boost::python::objects::class_base register_species_type_class(
         char const* name)
@@ -43,6 +46,7 @@ static boost::python::objects::class_base register_species_type_class(
     typedef Timpl_ impl_type;
     typedef SpeciesTypeExtras<impl_type> extras_type;
 
+    // defining the python class
     return class_<impl_type, boost::shared_ptr<impl_type> >(name, init<>())
         .add_property("id",
                 make_function((typename impl_type::identifier_type const&(impl_type::*)() const)&impl_type::id,
diff --git a/binding/Sphere.hpp b/binding/Sphere.hpp
index f889e238..1046e247 100644
--- a/binding/Sphere.hpp
+++ b/binding/Sphere.hpp
@@ -6,6 +6,7 @@
 
 namespace binding {
 
+////// Some helper functions (why are these templater, why here and not downstairs?)
 template<typename Timpl_>
 static boost::python::object Sphere___getitem__(Timpl_ const& obj, int index)
 {
@@ -30,12 +31,15 @@ static std::string Sphere___str__(Timpl_* impl)
     return boost::lexical_cast<std::string>(*impl);
 }
 
+
+////// Registering master function
 template<typename Timpl_>
 inline boost::python::objects::class_base register_sphere_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl_ impl_type;
 
+    // defining the python class
     return class_<impl_type>(name)
         .def(init<typename impl_type::position_type, 
                   typename impl_type::length_type>())
diff --git a/binding/SphericalPair.hpp b/binding/SphericalPair.hpp
index fd1fa013..bcf44f61 100644
--- a/binding/SphericalPair.hpp
+++ b/binding/SphericalPair.hpp
@@ -6,12 +6,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_spherical_pair_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(name,
         init<typename impl_type::identifier_type,
diff --git a/binding/SphericalSingle.hpp b/binding/SphericalSingle.hpp
index 3e03fb81..2cdc517b 100644
--- a/binding/SphericalSingle.hpp
+++ b/binding/SphericalSingle.hpp
@@ -7,12 +7,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_spherical_single_class(char const* name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(name,
         init<typename impl_type::identifier_type,
diff --git a/binding/SphericalSurface.hpp b/binding/SphericalSurface.hpp
index 6b20ee20..b9024a76 100644
--- a/binding/SphericalSurface.hpp
+++ b/binding/SphericalSurface.hpp
@@ -5,12 +5,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_spherical_surface_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::identifier_type,
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 53130014..8ae2b2a8 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -6,16 +6,20 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_structure_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // registering converters from standard boost templates
     // registers the projected_point/projected_distance tuple defined in ../Structure.hpp
     peer::converters::register_tuple_converter<
             typename impl_type::projected_type>();
 
+    // defining the python class
     // TODO add name and change id->real_id
     return class_<impl_type, boost::shared_ptr<impl_type>,
                   boost::noncopyable>(name, no_init)
diff --git a/binding/StructureType.hpp b/binding/StructureType.hpp
index 63964f4b..e5c11736 100644
--- a/binding/StructureType.hpp
+++ b/binding/StructureType.hpp
@@ -14,6 +14,8 @@
 
 namespace binding {
 
+
+////// Defining structure with some helper functions.
 template<typename Timpl_>
 struct StructureTypeExtras
 {
@@ -35,6 +37,8 @@ struct StructureTypeExtras
     }
 };
 
+
+////// Registering master function
 template<typename Timpl_>
 static boost::python::objects::class_base register_structure_type_class(
         char const* name)
@@ -43,6 +47,7 @@ static boost::python::objects::class_base register_structure_type_class(
     typedef Timpl_ impl_type;
     typedef StructureTypeExtras<impl_type> extras_type;
 
+    // defining the python class
     return class_<impl_type, boost::shared_ptr<impl_type> >(name, init<>())
         .add_property("id",
                 make_function((typename impl_type::identifier_type const&(impl_type::*)() const)&impl_type::id,
diff --git a/binding/Surface.hpp b/binding/Surface.hpp
index b4a1e961..b0944a59 100644
--- a/binding/Surface.hpp
+++ b/binding/Surface.hpp
@@ -5,12 +5,15 @@
 
 namespace binding {
 
+
+////// Registering master function
 template<typename Timpl>
 inline boost::python::objects::class_base register_surface_class(char const *name)
 {
     using namespace boost::python;
     typedef Timpl impl_type;
 
+    // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, no_init)
diff --git a/binding/World.hpp b/binding/World.hpp
index dada1ff4..e01a2aff 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -14,6 +14,9 @@
 
 namespace binding {
 
+//// Converters. These convert C++ types to something that Python can handle.
+
+// Species_range converter
 template<typename Timpl_>
 struct species_range_converter: public boost::python::default_call_policies
 {
@@ -118,12 +121,14 @@ struct species_range_converter: public boost::python::default_call_policies
         return result;
     }
 
+    // Register the converter.
     static void __register()
     {
         wrapper_type::__class_init__("SpeciesRange", boost::python::scope().ptr());
     }
 };
 
+// Structures_range converter
 template<typename Timpl_>
 struct structures_range_converter: public boost::python::default_call_policies
 {
@@ -228,6 +233,7 @@ struct structures_range_converter: public boost::python::default_call_policies
         return result;
     }
 
+    // Register the converter.
     static void __register()
     {
         wrapper_type::__class_init__("SurfacesRange", boost::python::scope().ptr());
@@ -242,6 +248,8 @@ World_get_particle_ids(T const& world)
 }
 
 
+
+////// Registering master function
 template<typename Timpl_, typename Tbase_, typename Tsim>
 inline boost::python::objects::class_base register_world_class(char const* name)
 {
@@ -252,10 +260,12 @@ inline boost::python::objects::class_base register_world_class(char const* name)
 //    typedef structure_types_range_converter<typename impl_type::structure_types_range> structure_types_range_converter_type;
     typedef structures_range_converter<typename impl_type::structures_range> structures_range_converter_type;
 
+    // registering the converters defined above
     species_range_converter_type::__register();
 //    structure_types_range_converter_type::__register();
     structures_range_converter_type::__register();
 
+    // registering converters from standard boost templates
     class_<std::set<typename impl_type::particle_id_type> >("ParticleIDSet")
         .def(peer::util::set_indexing_suite<std::set<typename impl_type::particle_id_type> >())
         ;
@@ -264,6 +274,7 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def(peer::util::set_indexing_suite<std::set<typename impl_type::structure_id_type> >())
         ;
 
+    // defining the python class
     return class_<impl_type, bases<Tbase_>,
                   boost::shared_ptr<impl_type> >(
         "World", init<typename impl_type::length_type, typename impl_type::size_type>())
diff --git a/binding/newBDPropagator.hpp b/binding/newBDPropagator.hpp
index d06d19ef..ffde6e22 100644
--- a/binding/newBDPropagator.hpp
+++ b/binding/newBDPropagator.hpp
@@ -15,23 +15,29 @@ static void newBDPropagator_propagate_all(Timpl_& self)
     while (self());
 }
 
+
+////// Registering master function
 template<typename Timpl_>
 inline boost::python::objects::class_base register_new_bd_propagator_class(char const* name)
 {
     using namespace boost::python;
-    typedef Timpl_ impl_type;
-    typedef typename impl_type::traits_type simulator_traits_type;
-    typedef typename simulator_traits_type::world_type world_type;
-    typedef typename world_type::particle_id_type particle_id_type;
-    typedef typename world_type::traits_type::length_type length_type;
-    typedef typename simulator_traits_type::network_rules_type network_rules_type;
-    typedef typename world_type::traits_type::rng_type rng_type;
-    typedef typename simulator_traits_type::time_type time_type;
-    typedef typename world_type::particle_container_type particle_container_type;
-    typedef typename impl_type::reaction_recorder_type reaction_recorder_type;
-    typedef typename impl_type::volume_clearer_type volume_clearer_type;
+    typedef Timpl_                                              impl_type;
+    typedef typename impl_type::traits_type                     simulator_traits_type;
+    typedef typename simulator_traits_type::world_type          world_type;
+
+    typedef typename impl_type::reaction_recorder_type          reaction_recorder_type;
+    typedef typename impl_type::volume_clearer_type             volume_clearer_type;
+    typedef typename simulator_traits_type::time_type           time_type;
+    typedef typename simulator_traits_type::network_rules_type  network_rules_type;
+    typedef typename world_type::traits_type::length_type       length_type;
+    typedef typename world_type::traits_type::rng_type          rng_type;
+    typedef typename world_type::particle_id_type               particle_id_type;
+    typedef typename world_type::particle_container_type        particle_container_type;
 
+    // registering converter from standard boost template
     peer::converters::register_pyiterable_range_converter<particle_id_type>();
+
+    // defining the python class
     return class_<impl_type, boost::noncopyable>(
         name, init<
             particle_container_type&, network_rules_type const&, rng_type&,
diff --git a/binding/position_converters.cpp b/binding/position_converters.cpp
index 2fb996c1..0bd5f321 100644
--- a/binding/position_converters.cpp
+++ b/binding/position_converters.cpp
@@ -11,11 +11,14 @@
 
 namespace binding {
 
+//// Converters. These convert C++ types to something that Python can handle.
+
 typedef peer::util::detail::array_to_ndarray_converter<
     WorldTraits::position_type,
     WorldTraits::position_type::value_type, 3>
         position_to_ndarray_converter;
 
+//
 struct ndarray_to_position_converter
 {
     typedef Position native_type;
@@ -57,6 +60,7 @@ struct ndarray_to_position_converter
     }
 };
 
+//
 struct tuple_to_position_converter
 {
     typedef Position native_type;
@@ -86,6 +90,7 @@ struct tuple_to_position_converter
     }
 };
 
+//
 struct list_to_position_converter
 {
     typedef Position native_type;
@@ -115,6 +120,8 @@ struct list_to_position_converter
     }
 };
 
+
+////// Registering master function
 void register_position_converters()
 {
     boost::python::to_python_converter<WorldTraits::position_type,
diff --git a/binding/volume_clearer_converter.hpp b/binding/volume_clearer_converter.hpp
index 89215247..e9b20f10 100644
--- a/binding/volume_clearer_converter.hpp
+++ b/binding/volume_clearer_converter.hpp
@@ -8,6 +8,7 @@
 
 namespace binding {
 
+// Defining a wrapper for the volume clearer
 template<typename Tbase_>
 class VolumeClearerWrapper: public Tbase_
 {
@@ -69,6 +70,8 @@ struct volume_clearer_converter
     }
 };
 
+
+////// Registering master function
 template<typename Timpl_>
 void register_volume_clearer_converter()
 {
diff --git a/binding/world_class.cpp b/binding/world_class.cpp
index 98b316ad..63f0386e 100644
--- a/binding/world_class.cpp
+++ b/binding/world_class.cpp
@@ -105,6 +105,7 @@ struct particle_id_pair_range_select_first_converter
         }
     };
 
+    // Also need to register the converter
     static void __register()
     {
         wrapper_type::__class_init__("ParticleIDRange", boost::python::scope().ptr());
@@ -114,6 +115,7 @@ struct particle_id_pair_range_select_first_converter
 };
 
 
+////// Registering master function
 void register_world_class()
 {
     register_world_class<World, ParticleContainer, EGFRDSimulator>("World");
diff --git a/pyGFRD.cpp b/pyGFRD.cpp
index e5371679..a55f9797 100644
--- a/pyGFRD.cpp
+++ b/pyGFRD.cpp
@@ -67,6 +67,21 @@
 #include "binding/transaction_classes.hpp"
 #include "binding/world_class.hpp"
 
+/////////////////
+// This is the masterfile that takes care of the binding of the C++ classes to Python
+/////////////////
+
+// Every 'register_...' line executes some code that makes the class/datastructure avaiable to python
+// The 'register_...classes' methods are defined in the 'binding/....class(es).cpp' files, but usually directly
+// call another (parameterized) 'register' method that is defined in the corresponding binding/....hpp file.
+// For example:
+// pyGFRD.cpp -> register_particle_class()
+//                  |_ binding/particle_class.cpp -> ParticleWrapper<Particle>::__register_class("Particle")
+//                                                      |_ binding/Particle.hpp
+//
+// The file 'binding/Particle.hpp' now finally defines 'register_class' and includes all the things it needs to
+// function properly. This includes converters for datatypes and other stuff.
+
 namespace b = binding;
 
 BOOST_PYTHON_MODULE(_gfrd)

From 09ff225fd6e3d64e61ee9e2ecec15fd12d80cd93 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Mar 2012 14:43:26 +0100
Subject: [PATCH 0713/1541] Cleanup typedefs in
 ParticleContainer/MultiParticleContainer/World/Transaction/etc to make
 clearer

---
 EGFRDSimulator.hpp        |   1 +
 EGFRDSimulatorFactory.hpp |  26 ++++++----
 Multi.hpp                 | 105 ++++++++++++++++++++------------------
 ParticleContainer.hpp     |  46 +++++++++--------
 ParticleSimulator.hpp     |  74 +++++++++++++++------------
 Transaction.hpp           |  35 +++++++------
 newBDPropagator.hpp       |  50 +++++++++---------
 7 files changed, 185 insertions(+), 152 deletions(-)

diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index cfb2888f..45613f3f 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -44,6 +44,7 @@ struct EGFRDSimulatorTraitsBase: public ParticleSimulatorTraitsBase<Tworld_>
 {
     typedef ParticleSimulatorTraitsBase<Tworld_> base_type;
     typedef Tworld_ world_type;
+
     typedef ShellID shell_id_type;
     typedef DomainID domain_id_type;
     typedef SerialIDGenerator<shell_id_type> shell_id_generator;
diff --git a/EGFRDSimulatorFactory.hpp b/EGFRDSimulatorFactory.hpp
index b28a87b1..eb61d300 100644
--- a/EGFRDSimulatorFactory.hpp
+++ b/EGFRDSimulatorFactory.hpp
@@ -10,16 +10,20 @@ template<typename Ttraits_>
 class EGFRDSimulatorFactory: public ParticleSimulatorFactory<Ttraits_>
 {
 public:
-    typedef ParticleSimulatorFactory<Ttraits_> base_type;
-    typedef Ttraits_ traits_type;
-    typedef typename traits_type::world_type::traits_type world_traits_type;
-    typedef typename traits_type::world_type world_type;
-    typedef typename traits_type::network_rules_type network_rules_type;
-    typedef typename world_traits_type::length_type length_type;
-    typedef typename world_traits_type::size_type size_type;
-    typedef typename world_traits_type::position_type position_type;
-    typedef typename world_traits_type::rng_type rng_type;
-    typedef CuboidalRegion<traits_type> cuboidal_region_type;
+    typedef ParticleSimulatorFactory<Ttraits_>  base_type;
+    typedef Ttraits_                            traits_type;
+    typedef typename traits_type::world_type    world_type;
+    typedef typename world_type::traits_type    world_traits_type;
+
+    // shorthand typedefs
+    typedef typename world_traits_type::length_type     length_type;
+    typedef typename world_traits_type::size_type       size_type;
+    typedef typename world_traits_type::position_type   position_type;
+    typedef typename world_traits_type::rng_type        rng_type;
+    typedef typename traits_type::network_rules_type    network_rules_type;
+
+    typedef CuboidalRegion<traits_type>                 cuboidal_region_type;
+
 
 public:
     EGFRDSimulatorFactory(rng_type& rng): rng_(rng) {}
@@ -83,6 +87,8 @@ class EGFRDSimulatorFactory: public ParticleSimulatorFactory<Ttraits_>
             rng_, dissociation_retry_moves);
     }
 
+
+///// Member variables
 protected:
     rng_type& rng_;
 };
diff --git a/Multi.hpp b/Multi.hpp
index 71c76470..b27b48a5 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -26,34 +26,37 @@ class MultiParticleContainer
 {
 public:
     typedef ParticleContainerUtils<typename Ttraits_::world_type::traits_type> utils;
-    typedef typename Ttraits_::world_type world_type;
-    typedef typename world_type::traits_type traits_type;
+    typedef typename Ttraits_::world_type       world_type;
+    typedef typename world_type::traits_type    traits_type;
+
     // shorthands types for used types
-    typedef typename traits_type::particle_type             particle_type;
-    typedef typename particle_type::shape_type              particle_shape_type;
+    typedef typename traits_type::length_type               length_type;
+    typedef typename traits_type::size_type                 size_type;
+    typedef typename traits_type::position_type             position_type;
     typedef typename traits_type::species_type              species_type;
     typedef typename traits_type::species_id_type           species_id_type;
-    typedef typename traits_type::position_type             position_type;
+    typedef typename traits_type::particle_type             particle_type;
     typedef typename traits_type::particle_id_type          particle_id_type;
-    typedef typename traits_type::length_type               length_type;
-    typedef typename traits_type::size_type                 size_type;
-    typedef typename traits_type::structure_type            structure_type;
-    typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
+    typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+
+    typedef typename particle_type::shape_type              particle_shape_type;
+    typedef Transaction<traits_type>                        transaction_type;
+
     // types inherited from the ParticleContainerBase class
-    typedef typename world_type::particle_container_type::structure_types_range      structure_types_range;
-    typedef typename world_type::particle_container_type::structures_range           structures_range;
-    typedef typename world_type::particle_container_type::structure_id_set           structure_id_set;
-    typedef typename world_type::particle_container_type::structure_id_pair          structure_id_pair;
-    typedef typename world_type::particle_container_type::particle_id_pair           particle_id_pair;
-
-    typedef typename Ttraits_::network_rules_type   network_rules_type;
-    typedef typename Ttraits_::reaction_rule_type   reaction_rule_type;
+    typedef typename world_type::particle_container_type::structure_types_range             structure_types_range;
+    typedef typename world_type::particle_container_type::structures_range                  structures_range;
+    typedef typename world_type::particle_container_type::particle_id_pair                  particle_id_pair;
+    typedef typename world_type::particle_container_type::structure_id_pair                 structure_id_pair;
+    typedef typename world_type::particle_container_type::structure_id_and_distance_pair    structure_id_and_distance_pair;
+    typedef typename world_type::particle_container_type::structure_id_set                  structure_id_set;
+
+    typedef typename Ttraits_::network_rules_type       network_rules_type;
+    typedef typename Ttraits_::reaction_rule_type       reaction_rule_type;
     typedef typename network_rules_type::reaction_rules reaction_rules;      
 
-    typedef typename Ttraits_::world_type::particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
-    typedef Transaction<traits_type>                                        transaction_type;
     typedef abstract_limited_generator<particle_id_pair>                    particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>                        particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance,
@@ -416,43 +419,47 @@ class Multi: public Domain<typename Tsim_::traits_type>
 {
 public:
     typedef Tsim_ simulator_type;
-    typedef typename simulator_type::traits_type traits_type;
-    typedef Domain<traits_type> base_type;
-    typedef typename traits_type::world_type::particle_type         particle_type;
-    typedef typename particle_type::shape_type                      particle_shape_type;
-    typedef typename traits_type::world_type::species_type          species_type;
-    typedef typename traits_type::world_type::species_id_type       species_id_type;
-    typedef typename traits_type::world_type::position_type         position_type;
-    typedef typename traits_type::world_type::particle_id_type      particle_id_type;
-    typedef typename traits_type::world_type::length_type           length_type;
-    typedef typename traits_type::world_type::size_type             size_type;
-    typedef typename traits_type::world_type::structure_type        structure_type;
-    typedef typename traits_type::world_type::particle_id_pair      particle_id_pair;
-    typedef typename traits_type::network_rules_type        network_rules_type;
-    typedef typename traits_type::reaction_rule_type        reaction_rule_type;
-    typedef typename network_rules_type::reaction_rules     reaction_rules;   
-    typedef typename traits_type::shell_id_type             shell_id_type;
-    typedef typename traits_type::domain_id_type            identifier_type;
+    typedef typename simulator_type::traits_type    traits_type;
+    typedef typename traits_type::world_type        world_type;
+    typedef Domain<traits_type>                     base_type;
+
+    // shorthand typenames that we use a lot
+    typedef typename world_type::length_type           length_type;
+    typedef typename world_type::size_type             size_type;
+    typedef typename world_type::position_type         position_type;
+    typedef typename world_type::particle_type         particle_type;
+    typedef typename world_type::particle_id_type      particle_id_type;
+    typedef typename particle_type::shape_type         particle_shape_type;
+    typedef typename world_type::species_type          species_type;
+    typedef typename world_type::species_id_type       species_id_type;
+    typedef typename world_type::structure_type        structure_type;
+    typedef typename world_type::particle_id_pair      particle_id_pair;
+    typedef typename traits_type::network_rules_type                network_rules_type;
+    typedef typename traits_type::reaction_rule_type                reaction_rule_type;
+    typedef typename network_rules_type::reaction_rules             reaction_rules;   
+    typedef typename traits_type::shell_id_type                     shell_id_type;
+    typedef typename traits_type::domain_id_type                    identifier_type;
     typedef typename traits_type::template shell_generator<
-        typename simulator_type::sphere_type>::type         spherical_shell_type;
-    typedef std::pair<const typename traits_type::shell_id_type, spherical_shell_type> spherical_shell_id_pair;
-    typedef std::pair<particle_id_pair, length_type> particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
+        typename simulator_type::sphere_type>::type                 spherical_shell_type;
+
+    typedef std::pair<const typename traits_type::shell_id_type, spherical_shell_type>  spherical_shell_id_pair;
+    typedef std::pair<particle_id_pair, length_type>                                            particle_id_pair_and_distance;
+    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector>  particle_id_pair_and_distance_list;
     typedef typename traits_type::reaction_record_type reaction_record_type;
-    typedef std::pair<const Real, const Real> real_pair;
+    typedef std::pair<const Real, const Real>                                                   real_pair;
 
 private:
-    typedef std::map<species_id_type, species_type> species_map;
-    typedef select_second<typename species_map::value_type> species_second_selector_type;
+    typedef std::map<species_id_type, species_type>                             species_map;
+    typedef select_second<typename species_map::value_type>                     species_second_selector_type;
             
 public:
-    typedef std::map<shell_id_type, spherical_shell_type> spherical_shell_map;
-    typedef sized_iterator_range<typename spherical_shell_map::const_iterator> spherical_shell_id_pair_range;
-    typedef MultiParticleContainer<traits_type> multi_particle_container_type;
-    typedef typename traits_type::world_type world_type;
     typedef boost::transform_iterator<species_second_selector_type,
-        typename species_map::const_iterator> species_iterator;
-    typedef sized_iterator_range<species_iterator> species_range;
+                                      typename species_map::const_iterator>     species_iterator;
+    typedef sized_iterator_range<species_iterator>                              species_range;
+
+    typedef std::map<shell_id_type, spherical_shell_type>                       spherical_shell_map;
+    typedef sized_iterator_range<typename spherical_shell_map::const_iterator>  spherical_shell_id_pair_range;
+    typedef MultiParticleContainer<traits_type>                                 multi_particle_container_type;
     
     enum event_kind
     {
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 89c385ef..30f0a320 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -19,43 +19,45 @@ class ParticleContainer
     typedef Ttraits_ traits_type;
 
     // some shorthand typename inherited from the traits
-    typedef typename traits_type::particle_type                 particle_type;
-    typedef typename particle_type::shape_type                  particle_shape_type;
+    typedef typename traits_type::length_type                   length_type;
+    typedef typename traits_type::size_type                     size_type;
+    typedef typename traits_type::position_type                 position_type;
     typedef typename traits_type::species_type                  species_type;
     typedef typename traits_type::species_id_type               species_id_type;
-    typedef typename traits_type::position_type                 position_type;
+    typedef typename traits_type::particle_type                 particle_type;
     typedef typename traits_type::particle_id_type              particle_id_type;
-    typedef typename traits_type::length_type                   length_type;
-    typedef typename traits_type::size_type                     size_type;
-    typedef typename traits_type::structure_type                structure_type;
-    typedef typename traits_type::structure_id_type             structure_id_type;
     typedef typename traits_type::structure_type_type           structure_type_type;
     typedef typename traits_type::structure_type_id_type        structure_type_id_type;
+    typedef typename traits_type::structure_type                structure_type;
+    typedef typename traits_type::structure_id_type             structure_id_type;
+
+    typedef typename particle_type::shape_type                  particle_shape_type;
+    typedef Transaction<traits_type>                            transaction_type;
 
     typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;
+    typedef abstract_limited_generator<particle_id_pair>                            particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>                                particle_id_pair_and_distance;
+    typedef unassignable_adapter<particle_id_pair_and_distance,
+                                 get_default_impl::std::vector>                     particle_id_pair_and_distance_list;
+    typedef std::set<particle_id_type>                                              particle_id_set;
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
+    typedef abstract_limited_generator<structure_id_pair>                           structure_id_pair_generator;
     typedef std::pair<structure_id_type, length_type>                               structure_id_and_distance_pair;
-    typedef Transaction<traits_type>                            transaction_type;
-    typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
-    typedef abstract_limited_generator<structure_id_pair>       structure_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
+    typedef std::set<structure_id_type>                                             structure_id_set;
 
 private:
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >         structure_map;
-    typedef select_second<typename structure_map::value_type>                       structure_second_selector_type;
-    typedef std::map<structure_type_id_type, structure_type_type >                  structure_type_map;
-    typedef select_second<typename structure_type_map::value_type>                  structure_type_second_selector_type;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >     structure_map;
+    typedef select_second<typename structure_map::value_type>                   structure_second_selector_type;
     typedef boost::transform_iterator<structure_second_selector_type,
-            typename structure_map::const_iterator>                                 structure_iterator;
+            typename structure_map::const_iterator>                             structure_iterator;
+    typedef std::map<structure_type_id_type, structure_type_type >              structure_type_map;
+    typedef select_second<typename structure_type_map::value_type>              structure_type_second_selector_type;
     typedef boost::transform_iterator<structure_type_second_selector_type,
-            typename structure_type_map::const_iterator>                            structure_type_iterator;
+            typename structure_type_map::const_iterator>                        structure_type_iterator;
 
 public:    
-    typedef sized_iterator_range<structure_iterator>                structures_range;
-    typedef sized_iterator_range<structure_type_iterator>           structure_types_range;
-    typedef std::set<particle_id_type>                              particle_id_set;
-    typedef std::set<structure_id_type>                             structure_id_set;
+    typedef sized_iterator_range<structure_iterator>                            structures_range;
+    typedef sized_iterator_range<structure_type_iterator>                       structure_types_range;
 
 
 
diff --git a/ParticleSimulator.hpp b/ParticleSimulator.hpp
index c59d649c..c03de6d7 100644
--- a/ParticleSimulator.hpp
+++ b/ParticleSimulator.hpp
@@ -22,19 +22,22 @@ template<typename Tworld_>
 struct ParticleSimulatorTraitsBase
 {
     typedef Tworld_ world_type;
+
+    // shorthand typedefs
     typedef Real rate_type;
     typedef Real time_type;
-    typedef int reaction_rule_id_type;
+    typedef int                                                     reaction_rule_id_type;
     typedef ReactionRuleInfo<
             reaction_rule_id_type,
             typename world_type::traits_type::species_id_type,
-            rate_type> reaction_rule_type;
+            rate_type>                                              reaction_rule_type;
     typedef NetworkRulesWrapper<NetworkRules,
-                                reaction_rule_type> network_rules_type;
+                                reaction_rule_type>                 network_rules_type;
     typedef ReactionRecord<typename world_type::particle_id_type,
-                           reaction_rule_id_type> reaction_record_type;
-    typedef ReactionRecorder<reaction_record_type> reaction_recorder_type;
-    typedef VolumeClearer<typename world_type::particle_shape_type, typename world_type::particle_id_type> volume_clearer_type;
+                           reaction_rule_id_type>                   reaction_record_type;
+    typedef ReactionRecorder<reaction_record_type>                  reaction_recorder_type;
+    typedef VolumeClearer<typename world_type::particle_shape_type,
+                          typename world_type::particle_id_type>    volume_clearer_type;
 
     static const Real MINIMAL_SEPARATION_FACTOR = (1.0 + 1e-7);
 };
@@ -46,10 +49,11 @@ template<typename Ttraits_>
 struct ImmutativeStructureVisitor
 {
     typedef Ttraits_ traits_type;
-    typedef typename ParticleSimulator<traits_type>::spherical_surface_type spherical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type cylindrical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::planar_surface_type planar_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cuboidal_region_type cuboidal_region_type;
+    typedef typename ParticleSimulator<traits_type>::spherical_surface_type     spherical_surface_type;
+    typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename ParticleSimulator<traits_type>::planar_surface_type        planar_surface_type;
+    typedef typename ParticleSimulator<traits_type>::cuboidal_region_type       cuboidal_region_type;
+
 
     virtual ~ImmutativeStructureVisitor() {}
 
@@ -66,10 +70,11 @@ template<typename Ttraits_>
 struct MutativeStructureVisitor
 {
     typedef Ttraits_ traits_type;
-    typedef typename ParticleSimulator<traits_type>::spherical_surface_type spherical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type cylindrical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::planar_surface_type planar_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cuboidal_region_type cuboidal_region_type;
+    typedef typename ParticleSimulator<traits_type>::spherical_surface_type     spherical_surface_type;
+    typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename ParticleSimulator<traits_type>::planar_surface_type        planar_surface_type;
+    typedef typename ParticleSimulator<traits_type>::cuboidal_region_type       cuboidal_region_type;
+
 
     virtual ~MutativeStructureVisitor() {}
 
@@ -86,24 +91,27 @@ template<typename Ttraits_>
 class ParticleSimulator
 {
 public:
-    typedef Ttraits_ traits_type;
-    typedef typename traits_type::world_type world_type;
-    typedef Sphere<typename world_type::length_type> sphere_type;
-    typedef Cylinder<typename world_type::length_type> cylinder_type;
-    typedef Box<typename world_type::length_type> box_type;
-    typedef Plane<typename world_type::length_type> plane_type;
-    typedef ParticleSimulationStructure<traits_type> particle_simulation_structure_type;
-    typedef Surface<traits_type> surface_type;
-    typedef Region<traits_type> region_type;
-    typedef SphericalSurface<traits_type> spherical_surface_type;
-    typedef CylindricalSurface<traits_type> cylindrical_surface_type;
-    typedef PlanarSurface<traits_type> planar_surface_type;
-    typedef CuboidalRegion<traits_type> cuboidal_region_type;
-    typedef typename traits_type::network_rules_type network_rules_type;
-    typedef typename world_type::traits_type::rng_type rng_type;
-    typedef typename traits_type::time_type time_type;
-    typedef typename traits_type::reaction_record_type reaction_record_type;
-    typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
+    typedef Ttraits_                            traits_type;
+    typedef typename traits_type::world_type    world_type;
+
+    // shorthand typedefs
+    typedef Sphere<typename world_type::length_type>    sphere_type;
+    typedef Cylinder<typename world_type::length_type>  cylinder_type;
+    typedef Box<typename world_type::length_type>       box_type;
+    typedef Plane<typename world_type::length_type>     plane_type;
+    typedef ParticleSimulationStructure<traits_type>    particle_simulation_structure_type;
+    typedef Surface<traits_type>                        surface_type;
+    typedef Region<traits_type>                         region_type;
+    typedef SphericalSurface<traits_type>               spherical_surface_type;
+    typedef CylindricalSurface<traits_type>             cylindrical_surface_type;
+    typedef PlanarSurface<traits_type>                  planar_surface_type;
+    typedef CuboidalRegion<traits_type>                 cuboidal_region_type;
+
+    typedef typename traits_type::network_rules_type    network_rules_type;
+    typedef typename world_type::traits_type::rng_type  rng_type;
+    typedef typename traits_type::time_type             time_type;
+    typedef typename traits_type::reaction_record_type      reaction_record_type;
+    typedef typename traits_type::reaction_recorder_type    reaction_recorder_type;
     typedef typename traits_type::volume_clearer_type volume_clearer_type;
 
 public:
@@ -169,6 +177,8 @@ class ParticleSimulator
 
     virtual bool step(time_type upto) = 0;
 
+
+////// Member variables
 protected:
     boost::shared_ptr<world_type> world_;
     boost::shared_ptr<network_rules_type const> network_rules_;
diff --git a/Transaction.hpp b/Transaction.hpp
index 595d439b..86ad8da6 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -19,15 +19,16 @@ class Transaction: public ParticleContainer<Ttraits_>
 {
 public:
     typedef Ttraits_ traits_type;
+
     // useful shorthands for types that we are using.
+    typedef typename traits_type::length_type                   length_type;
+    typedef typename traits_type::position_type                 position_type;
+    typedef typename traits_type::size_type                     size_type;
     typedef typename traits_type::particle_type                 particle_type;
+    typedef typename traits_type::particle_id_type              particle_id_type;
     typedef typename particle_type::shape_type                  particle_shape_type;
     typedef typename traits_type::species_type                  species_type;
     typedef typename traits_type::species_id_type               species_id_type;
-    typedef typename traits_type::position_type                 position_type;
-    typedef typename traits_type::particle_id_type              particle_id_type;
-    typedef typename traits_type::size_type                     size_type;
-    typedef typename traits_type::length_type                   length_type;
 
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
@@ -52,25 +53,27 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
 public:
     typedef Tpc_ particle_container_type;
     typedef typename particle_container_type::traits_type   traits_type;        // get the traits that are passed on from the particlecontainer.
+
     // define shorthands to the types that we are using here.
-    typedef typename traits_type::particle_type             particle_type;
-    typedef typename particle_type::shape_type              particle_shape_type;
+    typedef typename traits_type::length_type               length_type;
+    typedef typename traits_type::size_type                 size_type;
+    typedef typename traits_type::position_type             position_type;
     typedef typename traits_type::species_type              species_type;
     typedef typename traits_type::species_id_type           species_id_type;
-    typedef typename traits_type::position_type             position_type;
+    typedef typename traits_type::particle_type             particle_type;
     typedef typename traits_type::particle_id_type          particle_id_type;
-    typedef typename traits_type::size_type                 size_type;
-    typedef typename traits_type::length_type               length_type;
-    typedef typename traits_type::structure_id_type         structure_id_type;
-    typedef typename traits_type::structure_type            structure_type;
+    typedef typename particle_type::shape_type              particle_shape_type;
     typedef typename traits_type::structure_type_type       structure_type_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
+    typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
 
-    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
-    typedef std::pair<structure_id_type, length_type>       structure_id_and_distance_pair;
-    typedef abstract_limited_generator<particle_id_pair>    particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type>        particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
+    typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
+    typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
+    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
+    typedef unassignable_adapter<particle_id_pair_and_distance,
+                                 get_default_impl::std::vector> particle_id_pair_and_distance_list;
+    typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
 
 private:
     typedef std::map<typename particle_id_pair::first_type,
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 069b917e..7c6fe54f 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -28,32 +28,35 @@ class newBDPropagator
 public:
     typedef Ttraits_ traits_type;
     typedef typename Ttraits_::world_type::particle_container_type  particle_container_type;
-    typedef typename particle_container_type::species_id_type       species_id_type;
+
+    // shorthand typedef that we use
+    typedef typename particle_container_type::length_type           length_type;
     typedef typename particle_container_type::position_type         position_type;
-    typedef typename particle_container_type::particle_shape_type   particle_shape_type;
     typedef typename particle_container_type::species_type          species_type;
-    typedef typename particle_container_type::length_type           length_type;
+    typedef typename particle_container_type::species_id_type       species_id_type;
     typedef typename particle_container_type::particle_id_type      particle_id_type;
     typedef typename particle_container_type::particle_type         particle_type;
     typedef typename particle_container_type::particle_id_pair      particle_id_pair;
-    typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
-    typedef std::vector<particle_id_type>                           particle_id_vector_type;
-    typedef std::pair<position_type, position_type>                 position_pair_type;
-    typedef std::pair<position_type, length_type>                   projected_type;
-    typedef typename particle_container_type::particle_id_pair_generator particle_id_pair_generator;
-    typedef typename particle_container_type::particle_id_pair_and_distance particle_id_pair_and_distance;
-    typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
+    typedef typename particle_container_type::particle_shape_type   particle_shape_type;
     typedef typename particle_container_type::structure_type        structure_type;
     typedef typename particle_container_type::structure_id_type     structure_id_type;    
+
+    typedef typename particle_container_type::structure_id_and_distance_pair     structure_id_and_distance_pair;
+    typedef typename particle_container_type::particle_id_pair_generator         particle_id_pair_generator;
+    typedef typename particle_container_type::particle_id_pair_and_distance      particle_id_pair_and_distance;
+    typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
     typedef typename traits_type::world_type::traits_type::rng_type rng_type;
     typedef typename traits_type::time_type                         time_type;
     typedef typename traits_type::network_rules_type                network_rules_type;
     typedef typename network_rules_type::reaction_rules             reaction_rules;
     typedef typename network_rules_type::reaction_rule_type         reaction_rule_type;
-    typedef typename traits_type::reaction_record_type reaction_record_type;
-    typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
-    typedef typename traits_type::volume_clearer_type volume_clearer_type;
+    typedef typename traits_type::reaction_record_type              reaction_record_type;
+    typedef typename traits_type::reaction_recorder_type            reaction_recorder_type;
+    typedef typename traits_type::volume_clearer_type               volume_clearer_type;
 
+    typedef std::vector<particle_id_type>                           particle_id_vector_type;
+    typedef std::pair<position_type, position_type>                 position_pair_type;
+    typedef std::pair<position_type, length_type>                   projected_type;
 
 public:
     template<typename Trange_>
@@ -817,18 +820,19 @@ class newBDPropagator
         return v / length(v);
     }
 
+////// Member variables
 private:
-    particle_container_type& tx_;
-    network_rules_type const& rules_;
-    rng_type& rng_;
-    Real const dt_;
-    int const max_retry_count_;
+    particle_container_type&    tx_;
+    network_rules_type const&   rules_;
+    rng_type&                   rng_;
+    Real const                  dt_;
+    int const                   max_retry_count_;
     reaction_recorder_type* const rrec_;
-    volume_clearer_type* const vc_;
-    particle_id_vector_type queue_;
-    int rejected_move_count_;
-    Real const reaction_length_;
-    static Logger& log_;
+    volume_clearer_type* const  vc_;
+    particle_id_vector_type     queue_;
+    int                         rejected_move_count_;
+    Real const                  reaction_length_;
+    static Logger&              log_;
 };
 
 template<typename Ttraits_>

From 54faf5e0b1686ce50c975f8cd4055d3a24b395c2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Mar 2012 16:01:50 +0100
Subject: [PATCH 0714/1541] adjusted 'place_particle' to situation where
 species holds structure_type instead of structure

---
 gfrdbase.py | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index f61b7cd2..f3ae2f1c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -263,34 +263,45 @@ def place_particle(world, sid, position):
     model.ParticleModel.add_species_type.
 
     """
-    # TODO make sure that placed particle lives on the right structure.
     species = world.get_species(sid)
-    structure = world.get_structure(species.structure_id)
     radius = species.radius
 
+    # check that particle doesn't overlap with other particles.
     if world.check_overlap((position, radius)):
-        raise NoSpace, 'overlap check failed'
+        raise NoSpace, 'Placing particle failed: overlaps with other particle.'
 
+    surface, distance = get_closest_surface(world, position, [])
     # Check if not too close to a neighbouring structures for particles 
     # added to the world, or added to a self-defined box.
-    if isinstance(structure, _gfrd.CuboidalRegion):
-        surface, distance = get_closest_surface(world, position, [])
+    if species.structure_type_id == world.get_def_structure_type_id():
         if(surface and
            distance < surface.minimal_distance(species.radius)):
             raise RuntimeError('Placing particle failed: %s %s. '
                                'Too close to surface: %s.' %
                                (sid, position, distance))
+        else:
+            structure_id = world.get_def_structure_id()
+    else:
+        # If the particle lives on a surface then the position should be in the closest surface.
+        # The closest surface should also be of the structure_type associated with the species.
+        structure_ids = world.get_structure_ids(world.get_structure_type(species.structure_type_id))
+        if not (surface and 
+                distance < TOLERANCE*radius and 
+                surface.id in structure_ids):
+            raise RuntimeError('Placing particle failed: %s %s. Position should be in structure of structure_type %s.' %
+                                (sid, position, species.structure_type_id))
+        else:
+            structure_id = surface.id
 
     if __debug__:
-        species = world.get_species(sid)
-        structure = world.get_structure(species.structure_id)
         name = world.model.get_species_type_by_id(sid)["name"]
         if name[0] != '(':
             name = '(' + name + ')'
         log.info('\n\tplacing particle of type %s to %s at position %s' %
-                 (name, structure.id, position))
+                 (name, structure_id, position))
+        # TODO put the name of the structure here instead of its ID.
 
-    particle = world.new_particle(sid, position)
+    particle = world.new_particle(sid, structure_id, position)
     return particle
 
 

From 55e9bfabceb24de6d6c72a3457af39a14d28046b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Mar 2012 16:08:13 +0100
Subject: [PATCH 0715/1541] Make the name of the Structure availble in Python

---
 binding/Structure.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 8ae2b2a8..3bbe38a1 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -37,6 +37,9 @@ inline boost::python::objects::class_base register_structure_class(char const *n
                 impl_type, typename impl_type::structure_type_id_type,
                 &impl_type::sid,
                 &impl_type::sid>::set)
+        .add_property("name", 
+            make_function(&impl_type::name,
+                          return_value_policy<return_by_value>()))
         .def("random_position", &impl_type::random_position)
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)

From 83f0d7851685a3620fdb4fdb9d6a2dfc2a93de26 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Mar 2012 16:08:38 +0100
Subject: [PATCH 0716/1541] Print name of structure and structure_type in error
 message (more descriptive)

---
 gfrdbase.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index f3ae2f1c..68bef3b6 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -288,8 +288,8 @@ def place_particle(world, sid, position):
         if not (surface and 
                 distance < TOLERANCE*radius and 
                 surface.id in structure_ids):
-            raise RuntimeError('Placing particle failed: %s %s. Position should be in structure of structure_type %s.' %
-                                (sid, position, species.structure_type_id))
+            raise RuntimeError('Placing particle failed: %s %s. Position should be in structure of structure_type \"%s\".' %
+                                (sid, position, world.get_structure_type(species.structure_type_id)['name']))
         else:
             structure_id = surface.id
 
@@ -298,8 +298,7 @@ def place_particle(world, sid, position):
         if name[0] != '(':
             name = '(' + name + ')'
         log.info('\n\tplacing particle of type %s to %s at position %s' %
-                 (name, structure_id, position))
-        # TODO put the name of the structure here instead of its ID.
+                 (name, world.get_structure(structure_id).name, position))
 
     particle = world.new_particle(sid, structure_id, position)
     return particle

From d238c6c15ffe07a62d5608f70b6ec2327113e07a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Mar 2012 16:08:13 +0100
Subject: [PATCH 0717/1541] Make the name of the Structure availble in Python

---
 StructureUtils.hpp    | 7 +++++--
 binding/Structure.hpp | 3 +++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index 3a718381..a4fce0b2 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -12,13 +12,16 @@
 template<typename Tsim_>
 struct StructureUtils
 {
-    typedef Tsim_ simulator_type;
-    typedef typename simulator_type::traits_type traits_type;
+    typedef Tsim_                                   simulator_type;
+    typedef typename simulator_type::traits_type    traits_type;
+
+    // some typedefs
     typedef typename traits_type::world_type::position_type             position_type;
     typedef typename traits_type::world_type::length_type               length_type;
     typedef typename traits_type::world_type::structure_name_type       structure_id_type;
     typedef typename traits_type::world_type::structure_type            structure_type;
     typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
+
     typedef typename simulator_type::surface_type               surface_type;
     typedef typename simulator_type::region_type                region_type;
     typedef typename simulator_type::sphere_type                sphere_type;
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 8ae2b2a8..3bbe38a1 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -37,6 +37,9 @@ inline boost::python::objects::class_base register_structure_class(char const *n
                 impl_type, typename impl_type::structure_type_id_type,
                 &impl_type::sid,
                 &impl_type::sid>::set)
+        .add_property("name", 
+            make_function(&impl_type::name,
+                          return_value_policy<return_by_value>()))
         .def("random_position", &impl_type::random_position)
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)

From 1d1c8c324d63d3cfc491b90c99442da6b285501b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 19 Mar 2012 16:08:38 +0100
Subject: [PATCH 0718/1541] Print name of structure and structure_type in error
 message (more descriptive)

---
 gfrdbase.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index f3ae2f1c..296e475c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -31,7 +31,6 @@
     'get_surfaces',
     'get_closest_surface',
     'create_network_rules_wrapper',
-    'place_particle'
     ]
 
 World = _gfrd.World
@@ -288,8 +287,8 @@ def place_particle(world, sid, position):
         if not (surface and 
                 distance < TOLERANCE*radius and 
                 surface.id in structure_ids):
-            raise RuntimeError('Placing particle failed: %s %s. Position should be in structure of structure_type %s.' %
-                                (sid, position, species.structure_type_id))
+            raise RuntimeError('Placing particle failed: %s %s. Position should be in structure of structure_type \"%s\".' %
+                                (sid, position, world.get_structure_type(species.structure_type_id)['name']))
         else:
             structure_id = surface.id
 
@@ -297,9 +296,8 @@ def place_particle(world, sid, position):
         name = world.model.get_species_type_by_id(sid)["name"]
         if name[0] != '(':
             name = '(' + name + ')'
-        log.info('\n\tplacing particle of type %s to %s at position %s' %
-                 (name, structure_id, position))
-        # TODO put the name of the structure here instead of its ID.
+        log.info('\n\tplacing particle of type %s to structure \"%s\" at position %s' %
+                 (name, world.get_structure(structure_id).name, position))
 
     particle = world.new_particle(sid, structure_id, position)
     return particle

From 062873879273a8d4d57104406a78ee863a4569cc Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Mar 2012 15:47:47 +0100
Subject: [PATCH 0719/1541] small fixes

---
 egfrd.py                                    |  1 -
 samples/finite_planes_hack/finite_planes.py | 55 ++++++++++-----------
 2 files changed, 25 insertions(+), 31 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 58f781f6..44ff1333 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -629,7 +629,6 @@ def create_multi(self):
 
     def move_particle(self, pid_particle_pair, position):
         # moves a particle in world based on an existing particle
-        p = Particle(position, pid_particle_pair[1].radius, pid_particle_pair[1].D, pid_particle_pair[1].v, pid_particle_pair[1].sid)
 
         new_pid_particle_pair = (pid_particle_pair[0],
                                  Particle(position,
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index 1f1b19e6..215552d7 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -29,13 +29,13 @@
 datetime.datetime.now().microsecond))
 #myrandom.seed(currenttime)
 
-myrandom.seed(323) # 323 for 3 part., 523 for one is good
+myrandom.seed(523) # 323 for 3 part., 523 for one is good
 print "(Seed " + str(currenttime) + ")"
  
 
 # Constants
 # ===============================
-logging = False
+logging = True
 #logging = True
 sigma = 1e-8        # Diameter particle
 DC = 1e-13           # Diffusion constant
@@ -80,17 +80,17 @@
 m.add_structure_type(membrane6_type)
 
 # Species
-A = model.Species('A', DC, sigma, membrane1_type['name'])
+A = model.Species('A', DC, sigma, membrane1_type)
 m.add_species_type(A)
-B = model.Species('B', DC, sigma, membrane2_type['name'])
+B = model.Species('B', DC, sigma, membrane2_type)
 m.add_species_type(B)
-C = model.Species('C', DC, sigma, membrane3_type['name'])
+C = model.Species('C', DC, sigma, membrane3_type)
 m.add_species_type(C)
-D = model.Species('D', DC, sigma, membrane4_type['name'])
+D = model.Species('D', DC, sigma, membrane4_type)
 m.add_species_type(D)
-E = model.Species('E', DC, sigma, membrane5_type['name'])
+E = model.Species('E', DC, sigma, membrane5_type)
 m.add_species_type(E)
-F = model.Species('F', DC, sigma, membrane6_type['name'])
+F = model.Species('F', DC, sigma, membrane6_type)
 m.add_species_type(F)
 
 Statist = model.Species('Statist', 0.0, 10.0*sigma)
@@ -163,25 +163,22 @@
 m.network_rules.add_reaction_rule(rFE)
 
 
+# World
+w = gfrdbase.create_world(m, 3)
+
 # Create instances of membrane types
-membraneA = _gfrd.create_planar_surface(membrane1_type['name'], [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
-membraneA.sid = membrane1_type.id
-m.add_structure(membraneA)
-membraneB = _gfrd.create_planar_surface(membrane2_type['name'], [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
-membraneB.sid = membrane2_type.id
-m.add_structure(membraneB)
-membraneC = _gfrd.create_planar_surface(membrane3_type['name'], [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
-membraneC.sid = membrane3_type.id
-m.add_structure(membraneC)
-membraneD = _gfrd.create_planar_surface(membrane4_type['name'], [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
-membraneD.sid = membrane4_type.id
-m.add_structure(membraneD)
-membraneE = _gfrd.create_planar_surface(membrane5_type['name'], [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
-membraneE.sid = membrane5_type.id
-m.add_structure(membraneE)
-membraneF = _gfrd.create_planar_surface(membrane6_type['name'], [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
-membraneF.sid = membrane6_type.id
-m.add_structure(membraneF)
+membraneA = model.create_planar_surface(membrane1_type.id, 'name1', [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
+w.add_structure(membraneA)
+membraneB = model.create_planar_surface(membrane2_type.id, 'name2', [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
+w.add_structure(membraneB)
+membraneC = model.create_planar_surface(membrane3_type.id, 'name3', [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
+w.add_structure(membraneC)
+membraneD = model.create_planar_surface(membrane4_type.id, 'name4', [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
+w.add_structure(membraneD)
+membraneE = model.create_planar_surface(membrane5_type.id, 'name5', [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
+w.add_structure(membraneE)
+membraneF = model.create_planar_surface(membrane6_type.id, 'name6', [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
+w.add_structure(membraneF)
 
 print("Membrane A : unit_z = " + str(membraneA.shape.unit_z))
 print("Membrane B : unit_z = " + str(membraneB.shape.unit_z))
@@ -191,8 +188,6 @@
 print("Membrane F : unit_z = " + str(membraneF.shape.unit_z))
 
 
-# World
-w = gfrdbase.create_world(m, 3)
 # Simulator
 s = EGFRDSimulator(w, myrandom.rng)
 
@@ -202,8 +197,8 @@
 
 # Throw in particles
 place_particle(w, A, [world_size/2, world_size/2, 0])  # place one particle on membraneA
-place_particle(w, A, [world_size/4, world_size/4, 0])  # place one particle on membraneA
-place_particle(w, A, [3*world_size/4, 3*world_size/4, 0])  # place one particle on membraneA
+#place_particle(w, A, [world_size/4, world_size/4, 0])  # place one particle on membraneA
+#place_particle(w, A, [3*world_size/4, 3*world_size/4, 0])  # place one particle on membraneA
 
 # Statist particles in the corners of the system
 # does not really work because they intersect with membranes...

From 00025ff24ad295e07b0387e6037daf749d3d3966 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Mar 2012 19:05:33 +0100
Subject: [PATCH 0720/1541] Cleanup of fire_... methods. Adding structure_id to
 move_particle to allow for structure change

---
 egfrd.py | 213 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 114 insertions(+), 99 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ea307d43..4f71ac9d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -565,8 +565,9 @@ def create_multi(self):
 #        single.shell_id_shell_pair = shell_id_shell_pair
 #        self.geometrycontainer.move_shell(shell_id_shell_pair)
 
-    def move_particle(self, pid_particle_pair, position):
-        # moves a particle in world based on an existing particle
+    def move_particle(self, pid_particle_pair, position, structure_id):
+        # Moves a particle in World and performs the required change of structure_id
+        # based on an existing particle.
 
         new_pid_particle_pair = (pid_particle_pair[0],
                                  Particle(position,
@@ -574,7 +575,7 @@ def move_particle(self, pid_particle_pair, position):
                                           pid_particle_pair[1].D,
                                           pid_particle_pair[1].v,
                                           pid_particle_pair[1].sid,
-                                          pid_particle_pair[1].structure_id))
+                                          structure_id))
 
         self.world.update_particle(new_pid_particle_pair)
 
@@ -830,17 +831,20 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
         # A(any structure) -> 0
         # A(any structure) -> B(same structure or 3D)
         # A(any structure) -> B(same structure) + C(same structure or 3D)
+        if __debug__:
+            assert isinstance(single, Single)
 
         # 0. get reactant info
-        reactant           = single.pid_particle_pair
-        reactant_radius    = reactant[1].radius
-        reactant_structure = single.structure
-        species = self.world.get_species(reactant[1].sid)
-        reactant_structure_type_id = species.structure_type_id
+        reactant                    = single.pid_particle_pair
+        reactant_radius             = reactant[1].radius
+        species                     = self.world.get_species(reactant[1].sid)
+        reactant_structure_type_id  = species.structure_type_id
+        reactant_structure_id       = reactant.structure_id     # TODO should be the structure_id at the time of the reaction.
+        reactant_structure          = self.world.get_structure(reactant_structure_id)
         rr = single.reactionrule
 
-        # 1. remove the particle
-
+        # The zero_singles are the NonInteractionSingles that are the total result of the recursive
+        # bursting process.
         zero_singles = []
 
         if len(rr.products) == 0:
@@ -864,13 +868,13 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             product_radius            = product_species.radius
             product_structure_type_id = product_species.structure_type_id
 
-            # 1.5 produce a number of new possible positions for the product particle
-            # TODO make these generators for efficiency
+            # 1.5 get new position(s) of particle
             if product_structure_type_id != reactant_structure_type_id:
                 assert (product_structure_type_id == self.world.get_def_structure_type_id())
 
-                product_structure_id = self.world.get_def_structure_id()
-
+                # produce a number of new possible positions for the product particle
+                # TODO make these generators for efficiency
+                product_pos_list = []
                 if isinstance(reactant_structure, PlanarSurface):
                     a = myrandom.choice(-1, 1)
                     directions = [-a,a]
@@ -881,7 +885,6 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
                 elif isinstance(reactant_structure, CylindricalSurface):
                     vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
-                    product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
                         unit_vector3D = random_unit_vector()
                         unit_vector2D = normalize(unit_vector3D - 
@@ -891,10 +894,16 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                 else:
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+
+                product_structure_id = self.world.get_def_structure_id()    # product structure is always the default structure (bulk)
+
             else:
-                product_structure_id = reactant_structure.id
-                product_pos_list = [reactant_pos]               # no change of position is required if structure doesn't change
+                # decay happens to same structure_type
+                product_pos_list = [reactant_pos]               # no change of position is required if structure_type doesn't change
+                product_structure_id = reactant_structure_id    # The product structure is the structure where the reaction takes place.
+
 
+            ### Repeat for all the proposed positions.
             for product_pos in product_pos_list:
                 product_pos = self.world.apply_boundary(product_pos)
 
@@ -923,8 +932,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
             else:
                     # 4. Process (the lack of) change
-                    moved_reactant = self.move_particle(reactant, reactant_pos)
-                    products = [moved_reactant]     # no change
+                    moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
+                    products = [moved_reactant]
 
                     # 5. update counters
                     self.rejected_moves += 1
@@ -936,44 +945,30 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             
         elif len(rr.products) == 2:
             # 1. get product info
-            product1_species = self.world.get_species(rr.products[0])
-            product2_species = self.world.get_species(rr.products[1])
-            product1_structure_type_id = product1_species.structure_type_id 
-            product2_structure_type_id = product2_species.structure_type_id 
-            
+            product1_species            = self.world.get_species(rr.products[0])
+            product2_species            = self.world.get_species(rr.products[1])
+            product1_structure_type_id  = product1_species.structure_type_id 
+            product2_structure_type_id  = product2_species.structure_type_id 
+            product1_radius             = product1_species.radius
+            product2_radius             = product2_species.radius
             D1 = product1_species.D
             D2 = product2_species.D
-            
-            product1_radius = product1_species.radius
-            product2_radius = product2_species.radius
-            particle_radius12 = product1_radius + product2_radius
-
-            # calculate the displace of the particles according to the ratio D1:D2
-            # this way, species with small D only have small displacement from the reaction point.
-            if D1 == D2:
-            # special case (this should also catch D1==D2==0.0)
-                product1_displacement = particle_radius12 * 0.5
-                product2_displacement = particle_radius12 * 0.5
-            else:
-                D12 = D1 + D2
-                product1_displacement = particle_radius12 * (D1 / D12)
-                product2_displacement = particle_radius12 * (D2 / D12)
-
-            product1_displacement *= MINIMAL_SEPARATION_FACTOR
-            product2_displacement *= MINIMAL_SEPARATION_FACTOR
+            particle_radius12           = product1_radius + product2_radius
 
 
+            # 1.5 get new position(s) of particle
             if product1_structure_type_id != product2_structure_type_id:
                 # make sure that the reactant was on a 2D or 1D surface
-                assert not isinstance(reactant_structure, CuboidalRegion)
+                assert reactant_structure_type_id != self.world.get_def_structure_type_id()
                 # make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
                 assert ((product1_structure_type_id == self.world.get_def_structure_type_id()) ^ \
                         (product2_structure_type_id == self.world.get_def_structure_type_id()))
 
                 # figure out which product stays in the surface and which one goes to 3D
-                if (product2_structure_type_id == self.get_def_structure_type_id()):
+                # Note that A is a particle in the surface and B is in the 3D
+                if (product2_structure_type_id == self.world.get_def_structure_type_id()):
                     # product2 goes to 3D and is now particleB (product1 is particleA and is on the surface)
-                    product1_structure_id = reactant_structure.id
+                    product1_structure_id = reactant_structure_id
                     product2_structure_id = self.world.get_def_structure_id()
                     productA_radius = product1_radius
                     productB_radius = product2_radius
@@ -982,17 +977,15 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                     default = True      # we like to think of this as the default
                 else:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
-                    product2_structure_id = reactant_structure.id
+                    product2_structure_id = reactant_structure_id
                     product1_structure_id = self.world.get_def_structure_id()
                     productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2
                     DB = D1
                     default = False
-                # Note that A is a particle in the surface and B is in the 3D
 
                 if isinstance(reactant_structure, PlanarSurface):
-
                     # draw a number of new positions for the two product particles
                     # TODO make this into a generator
 
@@ -1012,41 +1005,30 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                                                                            productA_radius, productB_radius,
                                                                            reactant_structure, unit_z)
 
-                        newposA = self.world.apply_boundary(newposA)
-                        newposB = self.world.apply_boundary(newposB)
-
-                        assert (self.world.distance(newposA, newposB) >= particle_radius12)
-#                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
-
                         if default:
                             newpos1, newpos2 = newposA, newposB
                         else:
                             newpos1, newpos2 = newposB, newposA
-
                         product_pos_list.append((newpos1, newpos2))
 
                 elif isinstance(reactant_structure, CylindricalSurface):
 
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
-
                         iv = random_vector(particle_radius12 * MixedPair1D3D.calc_r_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
                         newposA, newposB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
-                                                                           productA_radius, productB_radius, reactant_structure)
+                                                                           productA_radius, productB_radius,
+                                                                           reactant_structure)
 
-                        newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
-
-                        assert (self.world.distance(newposA, newposB) >= particle_radius12)
                         assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
 
                         if default:
                             newpos1, newpos2 = newposA, newposB
                         else:
                             newpos1, newpos2 = newposB, newposA
-
                         product_pos_list.append((newpos1, newpos2))
 
                 else:
@@ -1055,8 +1037,8 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
             else:
                 # The two particles stay on the same structure as the reactant.
-                product1_structure_id = reactant_structure.id
-                product2_structure_id = reactant_structure.id
+                product1_structure_id = reactant_structure_id
+                product2_structure_id = reactant_structure_id
 
                 # generate new positions in the structure
                 # TODO Make this into a generator
@@ -1064,26 +1046,30 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                 for _ in range(self.dissociation_retry_moves):
                     # FIXME for particles on the cylinder there are only two possibilities
                     # calculate a random vector in the structure with unit length
-                    orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
-            
-                    newpos1 = reactant_pos + product1_displacement * orientation_vector
-                    newpos2 = reactant_pos - product2_displacement * orientation_vector
-                    newpos1 = self.world.apply_boundary(newpos1)
-                    newpos2 = self.world.apply_boundary(newpos2)
+                    iv = _random_vector(reactant_structure, particle_radius12, self.rng)
+                    iv *= MINIMAL_SEPARATION_FACTOR
+
+                    unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)   # not necessary
+                    newpos1, newpos2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
+                                                                    product1_radius, product2_radius,
+                                                                    reactant_structure, unit_z)
 
-                    assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
                     product_pos_list.append((newpos1, newpos2))
 
+
             # 2. make space for the products. 
-            # TODO
             #    calculate the sphere around the two product particles
-            rad = max(product1_displacement + product1_radius,
-                      product2_displacement + product2_radius)
+#            rad = max(product1_displacement + product1_radius,
+#                      product2_displacement + product2_radius)
+            rad = particle_radius12 * 2     # TODO this is wrong
             zero_singles, ignore = self.burst_volume(reactant_pos, rad, ignore)
 
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
             for newpos1, newpos2 in product_pos_list:
+                newpos1 = self.world.apply_boundary(newpos1)
+                newpos2 = self.world.apply_boundary(newpos2)
+                assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
 
                 if (not self.world.check_overlap((newpos1, product1_radius), reactant[0])
                    and
@@ -1106,10 +1092,15 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                     # exit the loop, we have found new positions
                     break
             else:
+                # Log the lack of change
                 if __debug__:
                     log.info('single reaction; placing products failed.')
-                moved_reactant = self.move_particle(reactant, reactant_pos)
+
+                # 4. process the changes (move the particle and update structure)
+                moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
                 products = [moved_reactant]
+
+                # 5. update counters.
                 self.rejected_moves += 1
 
         else:
@@ -1118,7 +1109,7 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
         return products, zero_singles, ignore
 
     def fire_interaction(self, single, reactant_pos, ignore):
-        # This takes care of the identity change when a particle associates with a surface
+        # This takes care of the identity change when a particle associates with a surface.
         # It performs the reactions:
         # A(structure) + surface -> 0
         # A(structure) + surface -> B(surface)
@@ -1126,12 +1117,13 @@ def fire_interaction(self, single, reactant_pos, ignore):
             assert isinstance(single, InteractionSingle)
 
         # 0. get reactant info
-        reactant        = single.pid_particle_pair
-        reactant_radius = reactant[1].radius
+        reactant              = single.pid_particle_pair
+        reactant_radius       = reactant[1].radius
+        reactant_structure_id = reactant[1].structure_id
         rr = single.interactionrule
 
-        # 1. remove the particle
-
+        # The zero_singles are the NonInteractionSingles that are the total result of the recursive
+        # bursting process.
         zero_singles = []
 
         if len(rr.products) == 0:
@@ -1151,10 +1143,11 @@ def fire_interaction(self, single, reactant_pos, ignore):
         elif len(rr.products) == 1:
             
             # 1. get product info
-            product_species = self.world.get_species(rr.products[0])
-            product_radius  = product_species.radius
-            product_surface = single.surface
+            product_species      = self.world.get_species(rr.products[0])
+            product_radius       = product_species.radius
+            product_surface      = single.surface
             product_structure_id = single.surface.id
+
             # TODO make sure that the product species lives on the same type of the interaction surface
 #            product_structure_type = self.world.get_structure(product_species.structure_id)
 #            assert (single.surface.sid == self.world.get_structure(product_species.structure_id)), \
@@ -1163,20 +1156,27 @@ def fire_interaction(self, single, reactant_pos, ignore):
             # 1.5 get new position of particle
             transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
             product_pos, _ = product_surface.projected_point(transposed_pos)
-            product_pos = self.world.apply_boundary(product_pos)        # not sure this is still necessary
+            product_pos    = self.world.apply_boundary(product_pos)        # not sure this is still necessary
 
             # 2. burst the volume that will contain the products.
             #    Note that an interaction domain is already sized such that it includes the
             #    reactant particle moving into the surface.
+            #    Note that the burst is recursive!!
             if product_radius > reactant_radius:
                 zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products 
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
+
+                # Log the (absence of) change
                 if __debug__:
-                    log.info('interaction; placing product failed.')
-                moved_reactant = self.move_particle(reactant, reactant_pos)
-                products = [moved_reactant]     # no change 
+                    log.info('fire_interaction: no space for product particle.')
+
+                # 4. process the changes (only move particle, stay on same structure)
+                moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
+                products = [moved_reactant]
+
+                # 5. update counters
                 self.rejected_moves += 1
 
             else:
@@ -1204,18 +1204,21 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
         # It performs the reactions:
         # A(any structure) + B(same structure) -> 0
         # A(any structure) + B(same structure or 3D) -> C(same structure)
+        if __debug__:
+            assert isinstance(pair, Pair)
 
         # 0. get reactant info
-        pid_particle_pair1 = pair.pid_particle_pair1
-        pid_particle_pair2 = pair.pid_particle_pair2
-        reactant1_species_id = pid_particle_pair1[1].sid
-        reactant2_species_id = pid_particle_pair2[1].sid
-        reactant1_structure_id = pid_particle_pair1[1].structure_id
-        reactant2_structure_id = pid_particle_pair2[1].structure_id
+        pid_particle_pair1     = pair.pid_particle_pair1
+        pid_particle_pair2     = pair.pid_particle_pair2
+        reactant1_species_id   = pid_particle_pair1[1].sid
+        reactant2_species_id   = pid_particle_pair2[1].sid
+        reactant1_structure_id = pid_particle_pair1[1].structure_id # TODO these are the structures at the time of the reaction
+        reactant2_structure_id = pid_particle_pair2[1].structure_id # and are set these according to transition/crossing event.
 
         rr = pair.draw_reaction_rule(pair.interparticle_rrs)
-        # 1. remove the particles
 
+        # The zero_singles are the NonInteractionSingles that are the Total result of the recursive
+        # bursting process.
         zero_singles = []
 
         if len(rr.products) == 0:
@@ -1239,7 +1242,8 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
             product_species = self.world.get_species(rr.products[0])
             product_radius  = product_species.radius
 
-            # select the proper structure_id for the product particle to live on.
+            # select the structure_id for the product particle to live on.
+            # TODO
             product_structure_ids = self.world.get_structure_ids(self.world.get_structure_type(product_species.structure_type_id))
             if reactant1_structure_id in product_structure_ids:
                 product_structure_id = reactant1_structure_id
@@ -1259,11 +1263,16 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
             # 3. check that there is space for the products ignoring the reactants
             if self.world.check_overlap((product_pos, product_radius), pid_particle_pair1[0],
                                                                        pid_particle_pair2[0]):
+                # Log the (lack of) change
                 if __debug__:
                     log.info('fire_pair_reaction: no space for product particle.')
-                moved_reactant1 = self.move_particle(pid_particle_pair1, reactant1_pos)
-                moved_reactant2 = self.move_particle(pid_particle_pair2, reactant2_pos)
-                products = [moved_reactant1, moved_reactant2]     # no change 
+
+                # 4. process the changes (move particles, change structure)
+                moved_reactant1 = self.move_particle(pid_particle_pair1, reactant1_pos, reactant1_structure_id)
+                moved_reactant2 = self.move_particle(pid_particle_pair2, reactant2_pos, reactant2_structure_id)
+                products = [moved_reactant1, moved_reactant2]
+
+                # 5. update counters
                 self.rejected_moves += 1
 
             else:
@@ -1290,10 +1299,15 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
 
     def fire_move(self, single, reactant_pos, ignore_p=None):
         # No reactions/Interactions have taken place -> no identity change of the particle
-        # Just only move the particles
+        # Just only move the particles and process putative structure change
+        if __debug__:
+            assert isinstance(single, Single)
 
+        # 0. get reactant info
         reactant = single.pid_particle_pair
+        reactant_structure_id = None #TODO Needs to be the structure after the particle has moved.
 
+        # 3. check that there is space for the reactants
         if ignore_p:
             if self.world.check_overlap((reactant_pos, reactant[1].radius),
                                         reactant[0], ignore_p[0]):
@@ -1303,7 +1317,8 @@ def fire_move(self, single, reactant_pos, ignore_p=None):
                                         reactant[0]):
                 raise RuntimeError('fire_move: particle overlap failed.')
 
-        moved_reactant = self.move_particle(reactant, reactant_pos)
+        # 4. process the changes (move particles, change structure)
+        moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
         return [moved_reactant]
 
 

From ea457f5c303230e01fb27b6ef984cbcfa0d25fa4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 20 Mar 2012 19:05:33 +0100
Subject: [PATCH 0721/1541] Cleanup of fire_... methods. Adding structure_id to
 move_particle to allow for structure change

---
 egfrd.py | 322 ++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 185 insertions(+), 137 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ea307d43..edf0bc6a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -565,8 +565,9 @@ def create_multi(self):
 #        single.shell_id_shell_pair = shell_id_shell_pair
 #        self.geometrycontainer.move_shell(shell_id_shell_pair)
 
-    def move_particle(self, pid_particle_pair, position):
-        # moves a particle in world based on an existing particle
+    def move_particle(self, pid_particle_pair, position, structure_id):
+        # Moves a particle in World and performs the required change of structure_id
+        # based on an existing particle.
 
         new_pid_particle_pair = (pid_particle_pair[0],
                                  Particle(position,
@@ -574,7 +575,7 @@ def move_particle(self, pid_particle_pair, position):
                                           pid_particle_pair[1].D,
                                           pid_particle_pair[1].v,
                                           pid_particle_pair[1].sid,
-                                          pid_particle_pair[1].structure_id))
+                                          structure_id))
 
         self.world.update_particle(new_pid_particle_pair)
 
@@ -830,22 +831,26 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
         # A(any structure) -> 0
         # A(any structure) -> B(same structure or 3D)
         # A(any structure) -> B(same structure) + C(same structure or 3D)
+        if __debug__:
+            assert isinstance(single, Single)
 
         # 0. get reactant info
-        reactant           = single.pid_particle_pair
-        reactant_radius    = reactant[1].radius
-        reactant_structure = single.structure
-        species = self.world.get_species(reactant[1].sid)
-        reactant_structure_type_id = species.structure_type_id
+        reactant                    = single.pid_particle_pair
+        reactant_radius             = reactant[1].radius
+        species                     = self.world.get_species(reactant[1].sid)
+        reactant_structure_type_id  = species.structure_type_id
+        reactant_structure          = single.structure          # TODO make argument to method
+        reactant_structure_id       = reactant_structure.id     # TODO should be the structure_id at the time of the reaction.
         rr = single.reactionrule
 
-        # 1. remove the particle
-
+        # The zero_singles are the NonInteractionSingles that are the total result of the recursive
+        # bursting process.
         zero_singles = []
 
         if len(rr.products) == 0:
             
             # 1. No products, no info
+            # 1.5 No new position/structure_id required
             # 2. No space required
             # 3. No space required
             # 4. process the changes (remove particle, make new ones)
@@ -853,9 +858,13 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             products = []
             # zero_singles/ignore is unchanged.
 
-            # 5. No new single to be made
-            # 6. Log the change
+            # 5. Update counters
+            self.reaction_events += 1
+            self.last_reaction = (rr, (reactant, None), products)
 
+            # 6. Log the change
+            if __debug__:
+                 log.info('single reaction: product = None.')
             
         elif len(rr.products) == 1:
             
@@ -864,13 +873,14 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
             product_radius            = product_species.radius
             product_structure_type_id = product_species.structure_type_id
 
-            # 1.5 produce a number of new possible positions for the product particle
-            # TODO make these generators for efficiency
+            # 1.5 get new position and structure_id of particle
+            # If the particle falls of a surface (non CuboidalRegion)
             if product_structure_type_id != reactant_structure_type_id:
                 assert (product_structure_type_id == self.world.get_def_structure_type_id())
 
-                product_structure_id = self.world.get_def_structure_id()
-
+                # produce a number of new possible positions for the product particle
+                # TODO make these generators for efficiency
+                product_pos_list = []
                 if isinstance(reactant_structure, PlanarSurface):
                     a = myrandom.choice(-1, 1)
                     directions = [-a,a]
@@ -881,7 +891,6 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
                 elif isinstance(reactant_structure, CylindricalSurface):
                     vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
-                    product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
                         unit_vector3D = random_unit_vector()
                         unit_vector2D = normalize(unit_vector3D - 
@@ -891,18 +900,28 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                 else:
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+
+                product_structure_id = self.world.get_def_structure_id()    # product structure is always the default structure (bulk)
+
+            # If decay happens to same structure_type
             else:
-                product_structure_id = reactant_structure.id
-                product_pos_list = [reactant_pos]               # no change of position is required if structure doesn't change
+                product_pos_list     = [reactant_pos]           # no change of position is required if structure_type doesn't change
+                product_structure_id = reactant_structure_id    # The product structure is the structure where the reaction takes place.
+
+
+            # 2. make space for the products (kinda brute force, but now we only have to burst once).
+            if not ((product_pos_list[0] == reactant_pos).all()) or product_radius > reactant_radius:
+                product_pos = self.world.apply_boundary(product_pos_list[0])
+                radius = self.world.distance(product_pos, reactant_pos) + product_radius
+                zero_singles, ignore = self.burst_volume(product_pos, radius, ignore)
 
+            # 3. check that there is space for the products (try different positions if possible)
+            # accept the new positions if there is enough space.
             for product_pos in product_pos_list:
                 product_pos = self.world.apply_boundary(product_pos)
 
-                # 2. make space for the products.
-#                if product_pos != reactant_pos or product_radius > reactant_radius:
-                zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
-
-                # 3. check that there is space for the products 
+                # check that there is space for the products 
+                # Note that we do not check overlap with surfaces (we assume that its no problem)
                 if (not self.world.check_overlap((product_pos, product_radius), reactant[0])):
 
                     # 4. process the changes (remove particle, make new ones)
@@ -912,68 +931,55 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
                     # 5. update counters
                     self.reaction_events += 1
-                    self.last_reaction = (rr, (reactant[1], None), products)
+                    self.last_reaction = (rr, (reactant, None), products)
 
                     # 6. Log the change
                     if __debug__:
-                        log.info('product (%s) = %s' % (len(products), products))
+                        log.info('single reaction: product (%s) = %s' % (len(products), products))
 
                     # exit the loop, we have found a new position
                     break
 
             else:
                     # 4. Process (the lack of) change
-                    moved_reactant = self.move_particle(reactant, reactant_pos)
-                    products = [moved_reactant]     # no change
+                    moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
+                    products = [moved_reactant]
 
                     # 5. update counters
                     self.rejected_moves += 1
 
                     # 6. Log the event
                     if __debug__:
-                        log.info('single reaction; placing product failed.')
+                        log.info('single reaction: placing product failed.')
 
             
         elif len(rr.products) == 2:
             # 1. get product info
-            product1_species = self.world.get_species(rr.products[0])
-            product2_species = self.world.get_species(rr.products[1])
-            product1_structure_type_id = product1_species.structure_type_id 
-            product2_structure_type_id = product2_species.structure_type_id 
-            
+            product1_species            = self.world.get_species(rr.products[0])
+            product2_species            = self.world.get_species(rr.products[1])
+            product1_structure_type_id  = product1_species.structure_type_id 
+            product2_structure_type_id  = product2_species.structure_type_id 
+            product1_radius             = product1_species.radius
+            product2_radius             = product2_species.radius
             D1 = product1_species.D
             D2 = product2_species.D
-            
-            product1_radius = product1_species.radius
-            product2_radius = product2_species.radius
-            particle_radius12 = product1_radius + product2_radius
-
-            # calculate the displace of the particles according to the ratio D1:D2
-            # this way, species with small D only have small displacement from the reaction point.
-            if D1 == D2:
-            # special case (this should also catch D1==D2==0.0)
-                product1_displacement = particle_radius12 * 0.5
-                product2_displacement = particle_radius12 * 0.5
-            else:
-                D12 = D1 + D2
-                product1_displacement = particle_radius12 * (D1 / D12)
-                product2_displacement = particle_radius12 * (D2 / D12)
-
-            product1_displacement *= MINIMAL_SEPARATION_FACTOR
-            product2_displacement *= MINIMAL_SEPARATION_FACTOR
+            particle_radius12           = product1_radius + product2_radius
 
 
+            # 1.5 Get new positions and structure_ids of particles
+            #     If one of the particle is not on the surface of the reactant.
             if product1_structure_type_id != product2_structure_type_id:
                 # make sure that the reactant was on a 2D or 1D surface
-                assert not isinstance(reactant_structure, CuboidalRegion)
+                assert reactant_structure_type_id != self.world.get_def_structure_type_id()
                 # make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
                 assert ((product1_structure_type_id == self.world.get_def_structure_type_id()) ^ \
                         (product2_structure_type_id == self.world.get_def_structure_type_id()))
 
                 # figure out which product stays in the surface and which one goes to 3D
-                if (product2_structure_type_id == self.get_def_structure_type_id()):
+                # Note that A is a particle in the surface and B is in the 3D
+                if (product2_structure_type_id == self.world.get_def_structure_type_id()):
                     # product2 goes to 3D and is now particleB (product1 is particleA and is on the surface)
-                    product1_structure_id = reactant_structure.id
+                    product1_structure_id = reactant_structure_id               # TODO after the displacement the structure can change!
                     product2_structure_id = self.world.get_def_structure_id()
                     productA_radius = product1_radius
                     productB_radius = product2_radius
@@ -982,24 +988,21 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                     default = True      # we like to think of this as the default
                 else:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
-                    product2_structure_id = reactant_structure.id
+                    product2_structure_id = reactant_structure_id
                     product1_structure_id = self.world.get_def_structure_id()
                     productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2
                     DB = D1
                     default = False
-                # Note that A is a particle in the surface and B is in the 3D
 
                 if isinstance(reactant_structure, PlanarSurface):
-
                     # draw a number of new positions for the two product particles
                     # TODO make this into a generator
 
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
                         # draw the random angle for the 3D particle relative to the particle left in the membrane
-                        # not all angles are available because particle cannot intersect with the membrane
 
                         # do the backtransform with a random iv with length such that the particles are at contact
                         # Note we make the iv slightly longer because otherwise the anisotropic transform will produce illegal
@@ -1007,84 +1010,85 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
                         iv = random_vector(particle_radius12 * MixedPair2D3D.calc_z_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
+                        # determine the side of the membrane the dissociation takes place
                         unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
                         newposA, newposB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                            productA_radius, productB_radius,
                                                                            reactant_structure, unit_z)
-
-                        newposA = self.world.apply_boundary(newposA)
-                        newposB = self.world.apply_boundary(newposB)
-
-                        assert (self.world.distance(newposA, newposB) >= particle_radius12)
-#                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
-
                         if default:
                             newpos1, newpos2 = newposA, newposB
                         else:
                             newpos1, newpos2 = newposB, newposA
-
                         product_pos_list.append((newpos1, newpos2))
 
                 elif isinstance(reactant_structure, CylindricalSurface):
 
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
-
                         iv = random_vector(particle_radius12 * MixedPair1D3D.calc_r_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
                         newposA, newposB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
-                                                                           productA_radius, productB_radius, reactant_structure)
+                                                                           productA_radius, productB_radius,
+                                                                           reactant_structure)
 
-                        newposA = self.world.apply_boundary(newposA)
                         newposB = self.world.apply_boundary(newposB)
-
-                        assert (self.world.distance(newposA, newposB) >= particle_radius12)
-                        assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
+                        if __debug__:
+                            assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
 
                         if default:
                             newpos1, newpos2 = newposA, newposB
                         else:
                             newpos1, newpos2 = newposB, newposA
-
                         product_pos_list.append((newpos1, newpos2))
 
                 else:
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
+            # 1.5 Get new positions and structure_ids of particles
+            #     If the two particles stay on the same structure as the reactant.
             else:
-                # The two particles stay on the same structure as the reactant.
-                product1_structure_id = reactant_structure.id
-                product2_structure_id = reactant_structure.id
-
                 # generate new positions in the structure
                 # TODO Make this into a generator
                 product_pos_list = []
                 for _ in range(self.dissociation_retry_moves):
                     # FIXME for particles on the cylinder there are only two possibilities
                     # calculate a random vector in the structure with unit length
-                    orientation_vector = _random_vector(reactant_structure, 1.0, self.rng)
-            
-                    newpos1 = reactant_pos + product1_displacement * orientation_vector
-                    newpos2 = reactant_pos - product2_displacement * orientation_vector
-                    newpos1 = self.world.apply_boundary(newpos1)
-                    newpos2 = self.world.apply_boundary(newpos2)
+                    iv = _random_vector(reactant_structure, particle_radius12, self.rng)
+                    iv *= MINIMAL_SEPARATION_FACTOR
+
+                    unit_z = reactant_structure.shape.unit_z    # not used
+                    newpos1, newpos2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
+                                                                    product1_radius, product2_radius,
+                                                                    reactant_structure, unit_z)
 
-                    assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
                     product_pos_list.append((newpos1, newpos2))
 
+                # structure_ids are the same as reactant. TODO this is not necessarily true in the corners.
+                product1_structure_id = reactant_structure_id
+                product2_structure_id = reactant_structure_id
+
+
             # 2. make space for the products. 
-            # TODO
             #    calculate the sphere around the two product particles
-            rad = max(product1_displacement + product1_radius,
-                      product2_displacement + product2_radius)
-            zero_singles, ignore = self.burst_volume(reactant_pos, rad, ignore)
+            product1_pos = self.world.apply_boundary(product_pos_list[0][0])
+            product2_pos = self.world.apply_boundary(product_pos_list[0][1])
+            radius = max(self.world.distance(product1_pos, reactant_pos) + product1_radius,
+                         self.world.distance(product2_pos, reactant_pos) + product2_radius)
+            zero_singles, ignore = self.burst_volume(reactant_pos, radius, ignore)
 
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
             for newpos1, newpos2 in product_pos_list:
+                newpos1 = self.world.apply_boundary(newpos1)
+                newpos2 = self.world.apply_boundary(newpos2)
 
+                if __debug__:
+                    assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
+
+                # check that there is space for the products 
+                # Note that we do not check overlap with surfaces -> TODO
                 if (not self.world.check_overlap((newpos1, product1_radius), reactant[0])
                    and
                    not self.world.check_overlap((newpos2, product2_radius), reactant[0])):
@@ -1097,28 +1101,33 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
                     # 5. update counters
                     self.reaction_events += 1
-                    self.last_reaction = (rr, (reactant[1], None), products)
+                    self.last_reaction = (rr, (reactant, None), products)
 
                     # 6. Log the change
                     if __debug__:
-                        log.info('products (%s) = %s' % (len(products), products))
+                        log.info('single reaction: products (%s) = %s' % (len(products), products))
 
                     # exit the loop, we have found new positions
                     break
             else:
+                # Log the lack of change
                 if __debug__:
-                    log.info('single reaction; placing products failed.')
-                moved_reactant = self.move_particle(reactant, reactant_pos)
+                    log.info('single reaction: placing products failed.')
+
+                # 4. process the changes (move the particle and update structure)
+                moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
                 products = [moved_reactant]
+
+                # 5. update counters.
                 self.rejected_moves += 1
 
         else:
-            raise RuntimeError('num products >= 3 not supported.')
+            raise RuntimeError('fire_single_reaction: num products >= 3 not supported.')
 
         return products, zero_singles, ignore
 
     def fire_interaction(self, single, reactant_pos, ignore):
-        # This takes care of the identity change when a particle associates with a surface
+        # This takes care of the identity change when a particle associates with a surface.
         # It performs the reactions:
         # A(structure) + surface -> 0
         # A(structure) + surface -> B(surface)
@@ -1126,17 +1135,19 @@ def fire_interaction(self, single, reactant_pos, ignore):
             assert isinstance(single, InteractionSingle)
 
         # 0. get reactant info
-        reactant        = single.pid_particle_pair
-        reactant_radius = reactant[1].radius
+        reactant              = single.pid_particle_pair
+        reactant_radius       = reactant[1].radius
+        reactant_structure_id = reactant[1].structure_id        # TODO make argument of method
         rr = single.interactionrule
 
-        # 1. remove the particle
-
+        # The zero_singles are the NonInteractionSingles that are the total result of the recursive
+        # bursting process.
         zero_singles = []
 
         if len(rr.products) == 0:
             
             # 1. No products, no info
+            # 1.5 No new position/structure_id required
             # 2. No space required
             # 3. No space required
             # 4. process the changes (remove particle, make new ones)
@@ -1144,39 +1155,52 @@ def fire_interaction(self, single, reactant_pos, ignore):
             products = []
             # zero_singles/ignore is unchanged.
 
-            # 5. No new single to be made
-            # 6. Log the change
+            # 5. Update counters
+            self.reaction_events += 1
+            self.last_reaction = (rr, (reactant, None), products)
 
+            # 6. Log the change
+            if __debug__:
+                 log.info('interaction: product = None.')
             
         elif len(rr.products) == 1:
             
             # 1. get product info
-            product_species = self.world.get_species(rr.products[0])
-            product_radius  = product_species.radius
-            product_surface = single.surface
-            product_structure_id = single.surface.id
+            product_species      = self.world.get_species(rr.products[0])
+            product_radius       = product_species.radius
+            product_surface      = single.surface
+
             # TODO make sure that the product species lives on the same type of the interaction surface
 #            product_structure_type = self.world.get_structure(product_species.structure_id)
 #            assert (single.surface.sid == self.world.get_structure(product_species.structure_id)), \
 #                   'Product particle should live on the surface of interaction after the reaction.'
 
-            # 1.5 get new position of particle
-            transposed_pos = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
-            product_pos, _ = product_surface.projected_point(transposed_pos)
-            product_pos = self.world.apply_boundary(product_pos)        # not sure this is still necessary
+            # 1.5 get new position and structure_id of particle
+            transposed_pos       = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
+            product_pos, _       = product_surface.projected_point(transposed_pos)
+            product_pos          = self.world.apply_boundary(product_pos)        # not sure this is still necessary
+            product_structure_id = product_surface.id
 
             # 2. burst the volume that will contain the products.
             #    Note that an interaction domain is already sized such that it includes the
             #    reactant particle moving into the surface.
+            #    Note that the burst is recursive!!
             if product_radius > reactant_radius:
                 zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products 
+            # Note that we do not check for interfering surfaces (we assume this is no problem)
             if self.world.check_overlap((product_pos, product_radius), reactant[0]):
+
+                # Log the (absence of) change
                 if __debug__:
-                    log.info('interaction; placing product failed.')
-                moved_reactant = self.move_particle(reactant, reactant_pos)
-                products = [moved_reactant]     # no change 
+                    log.info('interaction: no space for product particle.')
+
+                # 4. process the changes (only move particle, stay on same structure)
+                moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
+                products = [moved_reactant]
+
+                # 5. update counters
                 self.rejected_moves += 1
 
             else:
@@ -1187,11 +1211,11 @@ def fire_interaction(self, single, reactant_pos, ignore):
 
                 # 5. update counters
                 self.reaction_events += 1
-                self.last_reaction = (rr, (reactant[1], None), products)
+                self.last_reaction = (rr, (reactant, None), products)
 
                 # 6. Log the change
                 if __debug__:
-                     log.info('product (%s) = %s' % (len(products), products))
+                     log.info('interaction: product (%s) = %s' % (len(products), products))
 
         else:
             raise RuntimeError('fire_interaction: num products > 1 not supported.')
@@ -1204,23 +1228,25 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
         # It performs the reactions:
         # A(any structure) + B(same structure) -> 0
         # A(any structure) + B(same structure or 3D) -> C(same structure)
+        if __debug__:
+            assert isinstance(pair, Pair)
 
         # 0. get reactant info
-        pid_particle_pair1 = pair.pid_particle_pair1
-        pid_particle_pair2 = pair.pid_particle_pair2
-        reactant1_species_id = pid_particle_pair1[1].sid
-        reactant2_species_id = pid_particle_pair2[1].sid
-        reactant1_structure_id = pid_particle_pair1[1].structure_id
-        reactant2_structure_id = pid_particle_pair2[1].structure_id
+        pid_particle_pair1     = pair.pid_particle_pair1
+        pid_particle_pair2     = pair.pid_particle_pair2
+        reactant1_structure_id = pid_particle_pair1[1].structure_id # TODO these are the structures at the time of the reaction
+        reactant2_structure_id = pid_particle_pair2[1].structure_id # and are set these according to transition/crossing event.
 
         rr = pair.draw_reaction_rule(pair.interparticle_rrs)
-        # 1. remove the particles
 
+        # The zero_singles are the NonInteractionSingles that are the Total result of the recursive
+        # bursting process.
         zero_singles = []
 
         if len(rr.products) == 0:
 
             # 1. no product particles, no info
+            # 1.5 No new position/structure_id required
             # 2. No space required
             # 3. No space required
             # 4. process the change (remove particles, make new ones)
@@ -1229,9 +1255,13 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
             products = []
             # zero_singles/ignore is unchanged.
 
-            # 5. No new single to be made
+            # 5. update counters
+            self.reaction_events += 1
+            self.last_reaction = (rr, (pid_particle_pair1, pid_particle_pair2), products)
+
             # 6. Log the change
-            self.last_reaction = (rr, (pid_particle_pair1[1], pid_particle_pair2[1]), products)
+            if __debug__:
+                 log.info('pair reaction: product = None.')
 
         elif len(rr.products) == 1:
 
@@ -1239,31 +1269,38 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
             product_species = self.world.get_species(rr.products[0])
             product_radius  = product_species.radius
 
-            # select the proper structure_id for the product particle to live on.
+
+            # 1.5 get new position and structure_id for product particle
+            product_pos = pair.draw_new_com (pair.dt, pair.event_type)
+            product_pos = self.world.apply_boundary(product_pos)
+
+            # select the structure_id for the product particle to live on.
+            # TODO doesn't work for all needed cases
             product_structure_ids = self.world.get_structure_ids(self.world.get_structure_type(product_species.structure_type_id))
             if reactant1_structure_id in product_structure_ids:
                 product_structure_id = reactant1_structure_id
             elif reactant2_structure_id in product_structure_ids:
                 product_structure_id = reactant2_structure_id
 
-
-            # 1.5 get new position for product particle
-            product_pos = pair.draw_new_com (pair.dt, pair.event_type)
-            product_pos = self.world.apply_boundary(product_pos)
-
             # 2.  make space for products
             # 2.1 if the product particle sticks out of the shell
 #            if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_radius):
             zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products ignoring the reactants
+            # Note that we do not check for interfering surfaces (we assume this is no problem)
             if self.world.check_overlap((product_pos, product_radius), pid_particle_pair1[0],
                                                                        pid_particle_pair2[0]):
+                # Log the (lack of) change
                 if __debug__:
-                    log.info('fire_pair_reaction: no space for product particle.')
-                moved_reactant1 = self.move_particle(pid_particle_pair1, reactant1_pos)
-                moved_reactant2 = self.move_particle(pid_particle_pair2, reactant2_pos)
-                products = [moved_reactant1, moved_reactant2]     # no change 
+                    log.info('pair reaction: no space for product particle.')
+
+                # 4. process the changes (move particles, change structure)
+                moved_reactant1 = self.move_particle(pid_particle_pair1, reactant1_pos, reactant1_structure_id)
+                moved_reactant2 = self.move_particle(pid_particle_pair2, reactant2_pos, reactant2_structure_id)
+                products = [moved_reactant1, moved_reactant2]
+
+                # 5. update counters
                 self.rejected_moves += 1
 
             else:
@@ -1280,20 +1317,28 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
 
                 # 6. Log the change
                 if __debug__:
-                    log.info('fire_pair_reaction: product (%s) = %s' % (len(products), products))
+                    log.info('pair reaction: product (%s) = %s' % (len(products), products))
 
         else:
-            raise NotImplementedError('num products >= 2 not supported.')
+            raise NotImplementedError('fire_pair_reaction: num products >= 2 not supported.')
 
         return products, zero_singles, ignore
 
 
     def fire_move(self, single, reactant_pos, ignore_p=None):
         # No reactions/Interactions have taken place -> no identity change of the particle
-        # Just only move the particles
+        # Just only move the particles and process putative structure change
+        if __debug__:
+            assert isinstance(single, Single)
 
+        # 0. get reactant info
         reactant = single.pid_particle_pair
+        reactant_structure_id = reactant[1].structure_id #TODO make argument of method
+        # 1. No product->no info
+        # 1.5 No additional positional/structure change is needed
+        # 2. Position is in protective shell
 
+        # 3. check that there is space for the reactants
         if ignore_p:
             if self.world.check_overlap((reactant_pos, reactant[1].radius),
                                         reactant[0], ignore_p[0]):
@@ -1303,7 +1348,10 @@ def fire_move(self, single, reactant_pos, ignore_p=None):
                                         reactant[0]):
                 raise RuntimeError('fire_move: particle overlap failed.')
 
-        moved_reactant = self.move_particle(reactant, reactant_pos)
+        # 4. process the changes (move particles, change structure)
+        moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
+        # 5. No counting
+        # 6. No Logging
         return [moved_reactant]
 
 

From ce1eacdd1feb834ad99e55d52f1c87a0c0252d98 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 21 Mar 2012 15:54:01 +0100
Subject: [PATCH 0722/1541] draw_new_position(s) is now the source of the
 structure_id and is passed down. The structure_id is the id of the structure
 on which the particle 'was' at the time of the event. This information is
 passed down through process_.._event method down to the fire_... methods to
 accomodate structure changes during diffusion.

---
 egfrd.py  | 60 +++++++++++++++++++++++++++++++------------------------
 pair.py   |  4 +++-
 single.py | 25 ++++++++++++++++++-----
 3 files changed, 57 insertions(+), 32 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index edf0bc6a..f8ea6b15 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -824,13 +824,15 @@ def burst_non_multis(self, pos, radius, ignore):
 
 
 
-    def fire_single_reaction(self, single, reactant_pos, ignore):
+    def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, ignore):
         # This takes care of the identity change when a single particle decays into
         # one or a number of other particles
         # It performs the reactions:
         # A(any structure) -> 0
         # A(any structure) -> B(same structure or 3D)
         # A(any structure) -> B(same structure) + C(same structure or 3D)
+
+        # Note that the reactant_structure_id is the id of the structure on which the particle was located at the time of the reaction.
         if __debug__:
             assert isinstance(single, Single)
 
@@ -839,8 +841,7 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
         reactant_radius             = reactant[1].radius
         species                     = self.world.get_species(reactant[1].sid)
         reactant_structure_type_id  = species.structure_type_id
-        reactant_structure          = single.structure          # TODO make argument to method
-        reactant_structure_id       = reactant_structure.id     # TODO should be the structure_id at the time of the reaction.
+        reactant_structure          = self.world.get_structure(reactant_structure_id)
         rr = single.reactionrule
 
         # The zero_singles are the NonInteractionSingles that are the total result of the recursive
@@ -1126,18 +1127,20 @@ def fire_single_reaction(self, single, reactant_pos, ignore):
 
         return products, zero_singles, ignore
 
-    def fire_interaction(self, single, reactant_pos, ignore):
+    def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
         # This takes care of the identity change when a particle associates with a surface.
         # It performs the reactions:
         # A(structure) + surface -> 0
         # A(structure) + surface -> B(surface)
+
+        # Note that the reactant_structure_id is the id of the structure on which the particle was located at the time of the reaction.
+
         if __debug__:
             assert isinstance(single, InteractionSingle)
 
         # 0. get reactant info
         reactant              = single.pid_particle_pair
         reactant_radius       = reactant[1].radius
-        reactant_structure_id = reactant[1].structure_id        # TODO make argument of method
         rr = single.interactionrule
 
         # The zero_singles are the NonInteractionSingles that are the total result of the recursive
@@ -1223,20 +1226,20 @@ def fire_interaction(self, single, reactant_pos, ignore):
         return products, zero_singles, ignore
 
 
-    def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
+    def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, reactant1_structure_id, reactant2_structure_id, ignore):
         # This takes care of the identity change when two particles react with each other
         # It performs the reactions:
         # A(any structure) + B(same structure) -> 0
         # A(any structure) + B(same structure or 3D) -> C(same structure)
+
+        # Note that the reactant_structure_ids are the ids of the structures on which the particles were located at the time of the reaction.
+
         if __debug__:
             assert isinstance(pair, Pair)
 
         # 0. get reactant info
         pid_particle_pair1     = pair.pid_particle_pair1
         pid_particle_pair2     = pair.pid_particle_pair2
-        reactant1_structure_id = pid_particle_pair1[1].structure_id # TODO these are the structures at the time of the reaction
-        reactant2_structure_id = pid_particle_pair2[1].structure_id # and are set these according to transition/crossing event.
-
         rr = pair.draw_reaction_rule(pair.interparticle_rrs)
 
         # The zero_singles are the NonInteractionSingles that are the Total result of the recursive
@@ -1325,15 +1328,17 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, ignore):
         return products, zero_singles, ignore
 
 
-    def fire_move(self, single, reactant_pos, ignore_p=None):
+    def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
         # No reactions/Interactions have taken place -> no identity change of the particle
         # Just only move the particles and process putative structure change
+
+        # Note that the reactant_structure_id is the id of the structure on which the particle was located at the time of the move.
+
         if __debug__:
             assert isinstance(single, Single)
 
         # 0. get reactant info
         reactant = single.pid_particle_pair
-        reactant_structure_id = reactant[1].structure_id #TODO make argument of method
         # 1. No product->no info
         # 1.5 No additional positional/structure change is needed
         # 2. Position is in protective shell
@@ -1642,14 +1647,15 @@ def process_single_event(self, single, ignore):
                 single.event_type = single.draw_iv_event_type()
 
 
-            # get the (new) position
+            # get the (new) position and structure on which the particle is located.
             if single.getD() != 0 and single.dt > 0.0:
                 # If the particle had the possibility to diffuse
-                newpos = single.draw_new_position(single.dt, single.event_type)
+                newpos, struct_id = single.draw_new_position(single.dt, single.event_type)
                 newpos = self.world.apply_boundary(newpos)
             else:
                 # no change in position has taken place
-                newpos = pid_particle_pair[1].position
+                newpos    = pid_particle_pair[1].position
+                struct_id = pid_particle_pair[1].structure_id
             # TODO? Check if the new positions are within domain
 
             # newpos now hold the new position of the particle (not yet committed to the world)
@@ -1666,16 +1672,16 @@ def process_single_event(self, single, ignore):
 
                 if single.event_type == EventType.SINGLE_REACTION:
                     self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
-                    particles, zero_singles_b, ignore = self.fire_single_reaction(single, newpos, ignore)
+                    particles, zero_singles_b, ignore = self.fire_single_reaction(single, newpos, struct_id, ignore)
                     # The 'zero_singles_b' list now contains the resulting singles of a putative burst
                     # that occured in fire_single_reaction
 
                 else:
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
-                    particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
+                    particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, struct_id, ignore)
 
             else:
-                particles = self.fire_move(single, newpos)
+                particles = self.fire_move(single, newpos, struct_id)
                 zero_singles_b = []     # no bursting takes place
                 # ignore is unchanged
             domains = zero_singles_b
@@ -1773,9 +1779,9 @@ def process_pair_event(self, pair, ignore):
         ### 3. Process the event produced by the pair
         self.pair_steps[pair.event_type] += 1
 
-        ### 3.1 Get new position of particles
+        ### 3.1 Get new position and current structures of particles
         if pair.dt > 0.0:
-            newpos1, newpos2 = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
+            newpos1, newpos2, struct1_id, struct2_id = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
             newpos1 = self.world.apply_boundary(newpos1)
             newpos2 = self.world.apply_boundary(newpos2)
 
@@ -1788,6 +1794,8 @@ def process_pair_event(self, pair, ignore):
         else:
             newpos1 = pid_particle_pair1[1].position
             newpos2 = pid_particle_pair2[1].position
+            struct1_id = pid_particle_pair1[1].structure_id
+            struct2_id = pid_particle_pair2[1].structure_id
         # TODO? Check if the new positions are within domain
         # TODO? some more consistency checking of the positions
 ##            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
@@ -1808,14 +1816,14 @@ def process_pair_event(self, pair, ignore):
             if reactingsingle == single1:
                 theothersingle = single2
                 # first move the non-reacting particle
-                particles = self.fire_move(single2, newpos2, pid_particle_pair1)
+                particles = self.fire_move(single2, newpos2, struct2_id, pid_particle_pair1)
                 # don't ignore the (moved) non-reacting particle
-                particles2, zero_singles_b, ignore = self.fire_single_reaction(single1, newpos1, ignore)
+                particles2, zero_singles_b, ignore = self.fire_single_reaction(single1, newpos1, struct1_id, ignore)
                 particles.extend(particles2)
             else:
                 theothersingle = single1
-                particles = self.fire_move(single1, newpos1, pid_particle_pair2)
-                particles2, zero_singles_b, ignore = self.fire_single_reaction(single2, newpos2, ignore)
+                particles = self.fire_move(single1, newpos1, struct1_id, pid_particle_pair2)
+                particles2, zero_singles_b, ignore = self.fire_single_reaction(single2, newpos2, struct2_id, ignore)
                 particles.extend(particles2)
 
             if __debug__:
@@ -1834,7 +1842,7 @@ def process_pair_event(self, pair, ignore):
         #
         elif pair.event_type == EventType.IV_REACTION:
 
-            particles, zero_singles_b, ignore = self.fire_pair_reaction (pair, newpos1, newpos2, ignore)
+            particles, zero_singles_b, ignore = self.fire_pair_reaction (pair, newpos1, newpos2, struct1_id, struct2_id, ignore)
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
             zero_singles = []
@@ -1851,8 +1859,8 @@ def process_pair_event(self, pair, ignore):
              pair.event_type == EventType.COM_ESCAPE or
              pair.event_type == EventType.BURST):
 
-            particles      = self.fire_move (single1, newpos1, pid_particle_pair2)
-            particles.extend(self.fire_move (single2, newpos2, pid_particle_pair1))
+            particles      = self.fire_move (single1, newpos1, struct1_id, pid_particle_pair2)
+            particles.extend(self.fire_move (single2, newpos2, struct2_id, pid_particle_pair1))
             zero_singles_b = []
             # ignore is unchanged
 
diff --git a/pair.py b/pair.py
index 734fa740..71fca1e0 100644
--- a/pair.py
+++ b/pair.py
@@ -144,8 +144,10 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
                                                   self.pid_particle_pair2[1].radius,
                                                   self.structure,
                                                   unit_z)
+        struct1_id = self.pid_particle_pair1[1].structure_id
+        struct2_id = self.pid_particle_pair2[1].structure_id
 
-        return newpos1, newpos2
+        return newpos1, newpos2, struct1_id, struct2_id
 
     def draw_new_com(self, dt, event_type):
         # draws a new coordinate for the CoM in world coordinates
diff --git a/single.py b/single.py
index 7010a1d8..4b8d9649 100644
--- a/single.py
+++ b/single.py
@@ -77,9 +77,12 @@ def draw_new_position(self, dt, event_type):
         '''Draw a new position of the particle in the coordinate system given that an
         event of event_type has occured. No periodic boundary conditions are applied yet
         to the coordinates, as the Domains do not understand this.
+        The method also returns the structure_id of the structure on which the particle
+        is located at the time of the event.
 
         Note also that it calculates the positional information PRIOR to any identity or
-        structure change.
+        structure change. In case of a structure change the structure_id therefor is a
+        reference to the original structure.
 
         When for example a particles dissociates from the membrane (a structure change),
         it is placed next to the membrane. 'draw_new_position' will only determine the
@@ -217,8 +220,11 @@ def draw_new_position(self, dt, event_type):
             # note that we need to make sure that the shell.shape.position and displacement vector
             # are in the structure to prevent the particle leaving the structure due to numerical errors
             newpos = self.shell.shape.position + displacement
+    
+        # The structure on which the particle ended is always the same as on which it began.
+        structure_id = self.structure.id
 
-        return newpos
+        return newpos, structure_id
 
 ### TODO move this in some way to the shell making stuff in shells.py
     def calculate_shell_size_to_single(self, closest, distance_to_shell, geometrycontainer):
@@ -736,7 +742,10 @@ def draw_new_position(self, dt, event_type):
             # are correct (in the structure) to prevent the particle leaving the structure due to numerical errors
             newpos = self.shell.shape.position + vector_r + vector_z
 
-        return newpos
+        # The structure on which the particle ended is always the same as on which it began.
+        structure_id = self.structure.id
+
+        return newpos, structure_id
 
     def __str__(self):
         return ('PlanarSurfaceInteraction' + Single.__str__(self) + \
@@ -836,7 +845,10 @@ def draw_new_position(self, dt, event_type):
             # Add displacement to shell.shape.position, not to particle.position.  
             newpos = self.shell.shape.position + z_vector + r_vector
 
-        return newpos
+        # The structure on which the particle ended is always the same as on which it began.
+        structure_id = self.structure.id
+
+        return newpos, structure_id
 
     def __str__(self):
         return ('CylindricalSurfaceInteraction' + Single.__str__(self) + \
@@ -928,7 +940,10 @@ def draw_new_position(self, dt, event_type):
         z_vector = self.shell.shape.unit_z * z
         newpos = self.shell.shape.position + z_vector
 
-        return newpos
+        # The structure on which the particle ended is always the same as on which it began.
+        structure_id = self.structure.id
+
+        return newpos, structure_id
 
     def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)

From 710ad0289d75368a756307bd0c26495818331ae9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 16:00:26 +0100
Subject: [PATCH 0723/1541] Introduced TransitionSingles as a new master class

* Modified singles.py accordingly.
* Renamed PlanarSurfaceEdgeSingle to PlanarSurfaceTransitionSingle.
* Removed the interactions stuff and some other hacks from it.
* Attention! This will break functionality for now!
---
 single.py | 66 ++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 48 insertions(+), 18 deletions(-)

diff --git a/single.py b/single.py
index a2a6847a..56b6aba1 100644
--- a/single.py
+++ b/single.py
@@ -939,7 +939,52 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
-class PlanarSurfaceEdgeSingle(NonInteractionSingle, hasSphericalShell, EdgeTools, Others): # HACK
+class TransitionSingle(Single, EdgeTools, Others):
+    """TransitionSingles are used when a particle changes from
+       one surface to another. The difference to an InteractionSingle
+       is that the transition process is instantaneous, i.e. the 
+       transition propensity is infinitely high.    
+
+       TransitionSingles feature:
+        * a function process_new_position_vector which checks whether a newly
+          drawn position is still on the original structure of the particle.
+          If this is the case it will not be changed.
+          If it is on the new structure then the new position will be transformed
+          accordingly and the structure_id of the particle will be updated.
+        * several properties that are needed for the above transform.
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+
+        Single.__init__(self, domain_id, shell_id, reactionrules)
+        EdgeTools.__init__(self, testShell, self.pid_particle_pair[1].position)
+        # Note: for the Others superclass nothing is to be initialized.
+
+        self.pid_particle_pair = testShell.single.pid_particle_pair # is that necessary??
+
+        # That was part of the HACK, so we keep it now and remove it later when everything works
+        # origin_surface and target_surface are inherited from testShell via EdgeTools
+        self.structure = self.origin_surface
+        self.surface = self.target_surface
+
+    def initialize(self, t):    
+        # initialize the domain object with the appropriate time to allow reuse of
+        # the Domain at different times
+        self.dt = 0
+        self.last_time = t
+        self.event_type = None
+
+    def determine_next_event(self):
+        """Return an (event time, event type)-tuple.
+
+        """
+        return min(self.draw_escape_time_tuple(),
+                   self.draw_reaction_time_tuple())     # above two events also occur in NonInteractingSingle
+
+    def __str__(self):
+        pass
+
+
+class PlanarSurfaceTransitionSingle(TransitionSingle, hasSphericalShell):
     """1 Particle inside a (spherical) shell at the edge of two planar surfaces
 
         * Particle coordinates on surface: x, y.
@@ -952,18 +997,9 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
 
         assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
-        EdgeTools.__init__(self, testShell, self.pid_particle_pair[1].position)
-        # Note: for the Others superclass nothing is to be initialized.
-
-        self.pid_particle_pair = testShell.single.pid_particle_pair
-        # The following is copied from InteractionSingle
-        self.interactionrules = interactionrules        # the surface interaction 'reactions'
-        self.intrule = None
-        self.interaction_ktot = self.calc_ktot(interactionrules)
+        TransitionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
         # This has to be set because external functions will use it
-        # origin_surface and target_surface etc. are inherited from EdgeTools
         self.structure = self.origin_surface
         self.surface = self.target_surface
 
@@ -1011,12 +1047,6 @@ def create_position_vector(self, r):
         x, y = random_vector2D(r)
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
-    def get_interaction_rule(self): # HACK
-        if self.intrule == None:
-            self.intrule = self.draw_reaction_rule(self.interactionrules)
-        return self.intrule
-    interactionrule = property(get_interaction_rule)
-
     # copied from SphericalSingle
     # these return potentially corrected dimensions
     # For explanation see NonInteractionSingles and Others in shells.py
@@ -1043,7 +1073,7 @@ def shell_list_for_other(self):
 
 
     def __str__(self):
-        return 'PlanarSurfaceEdge' + Single.__str__(self)
+        return 'PlanarSurfaceTransition' + Single.__str__(self)
 
 
 class DummySingle(object):

From 90203654e2299d4b2fd41d026acacfe65feadac3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 16:04:06 +0100
Subject: [PATCH 0724/1541] Small fix, removed another hack

---
 single.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 56b6aba1..3c1e21b1 100644
--- a/single.py
+++ b/single.py
@@ -993,7 +993,7 @@ class PlanarSurfaceTransitionSingle(TransitionSingle, hasSphericalShell):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules): # HACK
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)

From 812ca13695339c6ba90dce1b372f4585ce4446d4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:03:24 +0100
Subject: [PATCH 0725/1541] Corresponding changes to shells.py

* new master class testTransitionSingle
* changed "surface" to "structure" in that (generalized) context
---
 shells.py | 45 +++++++++++++++++++++++++--------------------
 single.py |  2 +-
 2 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/shells.py b/shells.py
index 004682aa..99a0c18b 100755
--- a/shells.py
+++ b/shells.py
@@ -175,6 +175,20 @@ def __init__(self, single, structure, surface):
         # The reference_vector is the normalized vector from the reference_point to the particle
         self.reference_vector = normalize(pos_transposed - self.reference_point)
 
+class testTransitionSingle(testSingle, Others):
+
+    def __init__(self, single, target_structure):
+        self.single = single
+        self.structure = single.structure
+
+        self.origin_structure = single.structure
+        self.target_structure = target_structure
+
+        self.pid_particle_pair = single.pid_particle_pair
+        self.particle = single.pid_particle_pair[1]
+        self.single_radius = self.particle.radius
+        self.center = self.particle.position
+
 ##############
 class testPair(Others):
 
@@ -1146,31 +1160,22 @@ def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right, z_left
 
 #####
-class PlanarSurfaceEdgeSingletestShell(SphericaltestShell, testNonInteractionSingle):
+class PlanarSurfaceTransitionSingletestShell(SphericaltestShell, testTransitionSingle):
 
-    def __init__(self, single, surface, geometrycontainer, domains):
+    def __init__(self, single, target_structure, geometrycontainer, domains):
         SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        self.single = single
-        self.structure = single.structure
-        self.surface = surface
-
-        self.origin_surface = single.structure
-        self.target_surface = surface
-        assert isinstance(self.origin_surface, PlanarSurface)
-        assert isinstance(self.target_surface, PlanarSurface)
+        testTransitionSingle.__init__(self, single, target_structure)
 
-        self.pid_particle_pair = single.pid_particle_pair
-        self.particle = single.pid_particle_pair[1]
-        self.single_radius = self.particle.radius
-        self.center = self.particle.position
+        assert isinstance(self.origin_structure, PlanarSurface)
+        assert isinstance(self.target_structure, PlanarSurface)
 
         try:
-            self.radius = self.determine_possible_shell(self.origin_surface.id, 
+            self.radius = self.determine_possible_shell(self.origin_structure.id, 
                                                         [self.single.domain_id],
-                                                        [self.origin_surface.id, self.target_surface.id]
+                                                        [self.origin_structure.id, self.target_structure.id]
                                                        )
         except ShellmakingError as e:
-            raise testShellError('(PlanarSurfaceEdgeSingle). %s' %
+            raise testShellError('(PlanarSurfaceTransitionSingle). %s' %
                                  (str(e)))
 
     def get_min_radius(self):
@@ -1180,10 +1185,10 @@ def get_min_radius(self):
         # the target surface. Make sure that min_offset > 0.0, because only then it is
         # guaranteed that there is always a certain probability to cross the edge even
         # if the shell with minimal radius is constructed
-        return self.get_distance_to_target_surface() + min_offset
+        return self.get_distance_to_target_structure() + min_offset
 
-    def get_distance_to_target_surface(self):
-        distance = self.world.distance(self.target_surface.shape, self.center)
+    def get_distance_to_target_structure(self):
+        distance = self.world.distance(self.target_structure.shape, self.center)
         return distance
 
 #####
diff --git a/single.py b/single.py
index 3c1e21b1..bb0deb9c 100644
--- a/single.py
+++ b/single.py
@@ -995,7 +995,7 @@ class PlanarSurfaceTransitionSingle(TransitionSingle, hasSphericalShell):
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
-        assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)
+        assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
         TransitionSingle.__init__(self, domain_id, shell_id, reactionrules)
 

From e2b07bd25c74b8f6e7c592d8975aa1e56e30b2c8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:08:29 +0100
Subject: [PATCH 0726/1541] Forgot to make the same change in single.py and
 edgetools.py

---
 edgetools.py | 36 ++++++++++++++++++------------------
 single.py    | 15 ++++++++-------
 2 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/edgetools.py b/edgetools.py
index a289dd31..3f189ffb 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -28,16 +28,16 @@ class EdgeTools :
     def __init__(self, testShell, start_position):
 
         # Might be used internally by classes inheriting from here
-        self.origin_surface  = testShell.origin_surface
-        self.target_surface  = testShell.target_surface
+        self.origin_structure  = testShell.origin_structure
+        self.target_structure  = testShell.target_structure
 
-        self.origin_center = self.origin_surface.shape.position
-        self.target_center = self.target_surface.shape.position
-        self.origin_half_extent = self.origin_surface.shape.half_extent
-        self.target_half_extent = self.target_surface.shape.half_extent
+        self.origin_center = self.origin_structure.shape.position
+        self.target_center = self.target_structure.shape.position
+        self.origin_half_extent = self.origin_structure.shape.half_extent
+        self.target_half_extent = self.target_structure.shape.half_extent
 
         self.start_position  = start_position
-        self.target_distance = testShell.get_distance_to_target_surface()
+        self.target_distance = testShell.get_distance_to_target_structure()
 
         self.changes_structures = 0
 
@@ -74,21 +74,21 @@ def process_new_position_vector(self, oldpos, displacement):
             d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
             # TODO: Remove this temporary debug stuff
             print("process_new_position_vector")
-            print(self.origin_surface.id)
+            print(self.origin_structure.id)
             print(self.origin_unit_par)
             print(self.origin_unit_perp)
-            print(self.target_surface.id)
+            print(self.target_structure.id)
             print(self.target_unit_par)
             print(self.target_unit_perp)
-            print(self.target_surface.shape.unit_x)
-            print(self.target_surface.shape.unit_y)
-            print(self.target_surface.shape.unit_z)
+            print(self.target_structure.shape.unit_x)
+            print(self.target_structure.shape.unit_y)
+            print(self.target_structure.shape.unit_z)
             print(d_origin_perp)
             print(d_origin_par)
             print(d_target_par)
             # Construct the new position using the predefined unit vectors of the target surface
             newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            self.change_particle_structure(self.pid_particle_pair, self.target_surface)
+            self.change_particle_structure(self.pid_particle_pair, self.target_structure)
             self.changes_structures = 1
 
         return newpos
@@ -98,7 +98,7 @@ def get_origin_unit_vectors(self):
         # in the surface of origin and the half_extent of this surface in the
         # perpendicular vector direction
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
-        w_z = self.target_surface.shape.unit_z
+        w_z = self.target_structure.shape.unit_z
         u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
         # TODO: DEBUG output, to be removed
         if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
@@ -113,8 +113,8 @@ def get_origin_unit_vectors(self):
             
         assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
 
-        u_x = self.origin_surface.shape.unit_x
-        u_y = self.origin_surface.shape.unit_y
+        u_x = self.origin_structure.shape.unit_x
+        u_y = self.origin_structure.shape.unit_y
         if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
              u_par  = u_y
              h_perp = self.origin_half_extent[0] # half_extent in u_x direction
@@ -133,8 +133,8 @@ def get_target_unit_vectors(self):
         w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
         assert feq(numpy.sqrt(numpy.dot(w_perp, w_perp)), 1.0)
 
-        w_x = self.target_surface.shape.unit_x
-        w_y = self.target_surface.shape.unit_y
+        w_x = self.target_structure.shape.unit_x
+        w_y = self.target_structure.shape.unit_y
         if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
              w_par = w_y
              h_perp = self.origin_half_extent[0] # half_extent in w_x direction
diff --git a/single.py b/single.py
index bb0deb9c..d90f38fc 100644
--- a/single.py
+++ b/single.py
@@ -342,7 +342,7 @@ class PlanarSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):surface
 
         assert isinstance(testShell, PlanarSurfaceSingletestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
@@ -941,7 +941,7 @@ def __str__(self):
 
 class TransitionSingle(Single, EdgeTools, Others):
     """TransitionSingles are used when a particle changes from
-       one surface to another. The difference to an InteractionSingle
+       one structure to another. The difference to an InteractionSingle
        is that the transition process is instantaneous, i.e. the 
        transition propensity is infinitely high.    
 
@@ -962,9 +962,9 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         self.pid_particle_pair = testShell.single.pid_particle_pair # is that necessary??
 
         # That was part of the HACK, so we keep it now and remove it later when everything works
-        # origin_surface and target_surface are inherited from testShell via EdgeTools
-        self.structure = self.origin_surface
-        self.surface = self.target_surface
+        # origin_structure and target_structure are inherited from testShell via EdgeTools
+        self.structure = self.origin_structure
+        self.surface = self.target_structure
 
     def initialize(self, t):    
         # initialize the domain object with the appropriate time to allow reuse of
@@ -1000,8 +1000,9 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         TransitionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
         # This has to be set because external functions will use it
-        self.structure = self.origin_surface
-        self.surface = self.target_surface
+        # FIXME: Check whether this is still needed!
+        self.structure = self.origin_structure
+        self.surface = self.target_structure
 
     # The same Greens function is used as for the normal PlanarSurfaceSingle;
     # If the position is off the surface of origin, it will be transformed towards the target surface

From bfd94e1dddeffd5fe5474c5721453d2a82b9b4e5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:25:32 +0100
Subject: [PATCH 0727/1541] Some namefixes

---
 shells.py | 2 +-
 single.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 99a0c18b..667ca390 100755
--- a/shells.py
+++ b/shells.py
@@ -33,7 +33,7 @@
     'SphericalPairtestShell',
     'PlanarSurfaceSingletestShell',
     'PlanarSurfacePairtestShell',
-    'PlanarSurfaceEdgeSingletestShell',
+    'PlanarSurfaceTransitionSingletestShell',
     'CylindricalSurfaceSingletestShell',
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
diff --git a/single.py b/single.py
index 11230b8a..0ca816f4 100644
--- a/single.py
+++ b/single.py
@@ -23,7 +23,7 @@
 __all__ = [
     'CylindricalSurfaceSingle',
     'PlanarSurfaceSingle',
-    'PlanarSurfaceEdgeSingle',
+    'PlanarSurfaceTransitionSingle',
     'SphericalSingle',
     'Single',
     'NonInteractionSingle',

From c8b955e9e68e937df07f6079657f3e3738f593e0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:42:16 +0100
Subject: [PATCH 0728/1541] Teach new single and EdgeTools to return
 structure_id

---
 edgetools.py | 17 +++++------------
 single.py    |  4 ++--
 2 files changed, 7 insertions(+), 14 deletions(-)

diff --git a/edgetools.py b/edgetools.py
index 3f189ffb..1401671e 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -39,11 +39,9 @@ def __init__(self, testShell, start_position):
         self.start_position  = start_position
         self.target_distance = testShell.get_distance_to_target_structure()
 
-        self.changes_structures = 0
-
         self.edge_point = self.get_edge_point()
         self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
-        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()
+        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()        
         
 
     def process_new_position_vector(self, oldpos, displacement):
@@ -60,7 +58,8 @@ def process_new_position_vector(self, oldpos, displacement):
         if d_out <= 0.0 :
             # The new position is still in the old surface;
             # no transform required
-            newpos = oldpos + displacement
+            newpos = oldpos + displacement  
+            new_structure_id = self.origin_structure.id  # i.e. no change here
         else :
             # The new position is out of the old surface;
             # transform it to the target surface.
@@ -88,10 +87,9 @@ def process_new_position_vector(self, oldpos, displacement):
             print(d_target_par)
             # Construct the new position using the predefined unit vectors of the target surface
             newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            self.change_particle_structure(self.pid_particle_pair, self.target_structure)
-            self.changes_structures = 1
+            new_structure_id = self.target_structure.id
 
-        return newpos
+        return newpos, new_structure_id
 
     def get_origin_unit_vectors(self):
         # calculate the unit vector perpendicular and parallel to the edge
@@ -156,9 +154,4 @@ def get_edge_point(self):
         ep = self.start_position + (self.target_distance * self.origin_unit_perp)
         return ep
 
-    def change_particle_structure(self, pid_particle_pair, new_structure):
-        #pid_particle_pair[1].structure_id = new_structure.id
-        # TODO !!! This will only work once particles can remember their structure !!!
-        # => for now just...
-        pass
 
diff --git a/single.py b/single.py
index 0ca816f4..b095ea10 100644
--- a/single.py
+++ b/single.py
@@ -1053,9 +1053,9 @@ def draw_new_position(self, dt, event_type):
 
             # Now check whether the new position is in the surface of origin;
             # if not, transform it to the target surface (function inherited from EdgeTools)
-            newpos = self.process_new_position_vector(oldpos, displacement)
+            newpos, new_structure_id = self.process_new_position_vector(oldpos, displacement)
 
-        return newpos
+        return newpos, new_structure_id
 
     def create_position_vector(self, r):
         # project the vector onto the surface unit vectors to make sure

From c8798cc8a13678424a6f3d885f16e0856743e5a2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:43:44 +0100
Subject: [PATCH 0729/1541] One more assert..

---
 edgetools.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/edgetools.py b/edgetools.py
index 1401671e..cc091b4d 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -27,6 +27,8 @@ class EdgeTools :
 
     def __init__(self, testShell, start_position):
 
+        assert isinstance(testShell, testTransitionSingle);
+
         # Might be used internally by classes inheriting from here
         self.origin_structure  = testShell.origin_structure
         self.target_structure  = testShell.target_structure

From bdb767f965cc731b515769b53dd5c07f5ae6c246 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:45:41 +0100
Subject: [PATCH 0730/1541] __all__ cleanup

---
 shells.py | 1 +
 single.py | 5 +++--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 667ca390..08a0f357 100755
--- a/shells.py
+++ b/shells.py
@@ -24,6 +24,7 @@
     'testSingle',
     'testNonInteractionSingle',
     'testInteractionSingle',
+    'testTransitionSingle',
     'testPair',
     'testSimplePair',
     'testMixedPair2D3D',
diff --git a/single.py b/single.py
index b095ea10..cae3a6ab 100644
--- a/single.py
+++ b/single.py
@@ -23,14 +23,15 @@
 __all__ = [
     'CylindricalSurfaceSingle',
     'PlanarSurfaceSingle',
-    'PlanarSurfaceTransitionSingle',
     'SphericalSingle',
     'Single',
     'NonInteractionSingle',
-    'InteractionSingle',
+    'InteractionSingle',    
     'CylindricalSurfaceInteraction',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
+    'TransitionSingle',
+    'PlanarSurfaceTransitionSingle',
     ]
 
 

From 96a118e745e0ec2de2aebee6699840f9cb611563 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:55:14 +0100
Subject: [PATCH 0731/1541] Transition shell creation cleanup in egfrd.py

* Removed part of the ugly hacks (interaction rules not
  needed for transition shells any more)
* Also changed 'surface' to 'target_structure' where needed
---
 egfrd.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c5218c99..d2ccafeb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -44,7 +44,7 @@
     SphericalPairtestShell,
     PlanarSurfaceSingletestShell,
     PlanarSurfacePairtestShell,
-    PlanarSurfaceEdgeSingletestShell,
+    PlanarSurfaceTransitionSingletestShell,
     CylindricalSurfaceSingletestShell,
     CylindricalSurfacePairtestShell,
     PlanarSurfaceInteractiontestShell,
@@ -101,12 +101,12 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
 ### Transitions
-def try_default_testtransition(single, surface, geometrycontainer, domains):
+def try_default_testtransition(single, target_structure, geometrycontainer, domains):
     if isinstance(single.structure, CuboidalRegion):        
             raise testShellError('(Transition). Combination of (3D particle, surface) is not supported')
     elif isinstance(single.structure, PlanarSurface):
         if isinstance(surface, PlanarSurface):
-            return PlanarSurfaceEdgeSingletestShell(single, surface, geometrycontainer, domains)
+            return PlanarSurfaceTransitionSingletestShell(single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Transition). Combination of (2D particle, surface other than plane) is not supported')
     elif isinstance(single.structure, CylindricalSurface):        
@@ -114,9 +114,9 @@ def try_default_testtransition(single, surface, geometrycontainer, domains):
     else:
         raise testShellError('(Transition). structure of particle was of invalid type')
 
-def create_default_transition(domain_id, shell_id, testShell, reaction_rules, interaction_rules): # HACK
-    if isinstance(testShell, PlanarSurfaceEdgeSingletestShell):
-        return PlanarSurfaceEdgeSingle       (domain_id, shell_id, testShell, reaction_rules, interaction_rules) # HACK
+def create_default_transition(domain_id, shell_id, testShell, reaction_rules):
+    if isinstance(testShell, PlanarSurfaceTransitionSingletestShell):
+        return PlanarSurfaceTransitionSingle       (domain_id, shell_id, testShell, reaction_rules)
     
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
@@ -530,7 +530,7 @@ def create_transition(self, testShell):
     # Currently only plane-plane transitions are supported.
     # We assume here that the testShell was successfully created.
 
-        assert isinstance(testShell, PlanarSurfaceEdgeSingletestShell)  # TODO Possibly introduce masterclass testTransitionSingle
+        assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell)  # TODO Possibly introduce masterclass testTransitionSingle
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
         # the scheduler
@@ -1506,7 +1506,7 @@ def make_new_domain(self, single):
             if isinstance(obj, NonInteractionSingle):
                 # try making a Pair (can be Mixed Pair or Normal Pair)
                 domain = self.try_pair (single, obj)
-                # TODO: Include formation of "PlanarSurfaceEdgePair"
+                # TODO: Include formation of "PlanarSurfaceTransitionPair"
 
             elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
                 # try making an Interaction
@@ -1755,7 +1755,7 @@ def process_single_event(self, single, ignore):
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, struct_id, ignore)
 
-            elif isinstance(single, PlanarSurfaceEdgeSingle) and single.changes_structures : # HACK
+            elif isinstance(single, PlanarSurfaceTransitionSingle) and single.changes_structures : # HACK
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
             else:
                 particles = self.fire_move(single, newpos, struct_id)
@@ -2524,10 +2524,10 @@ def check_domain(self, domain):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.structure.id, domain.surface.id]
-        elif isinstance(domain, PlanarSurfaceEdgeSingle):
+        elif isinstance(domain, PlanarSurfaceTransitionSingle):
             # Ignore surface of the particle and interaction surface
             ignores = []
-            associated = [domain.structure.id, domain.surface.id]
+            associated = [domain.origin_structure.id, domain.target_structure.id]
         else:
             # Ignore the structure that the particles are associated with
             ignores = []

From 121fa5f97ebcaca41064efcbdd19c311f5d77a7f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 17:56:37 +0100
Subject: [PATCH 0732/1541] Damn, forgot to save before commit...

---
 egfrd.py | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d2ccafeb..ff8e98b9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -530,7 +530,7 @@ def create_transition(self, testShell):
     # Currently only plane-plane transitions are supported.
     # We assume here that the testShell was successfully created.
 
-        assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell)  # TODO Possibly introduce masterclass testTransitionSingle
+        assert isinstance(testShell, testTransitionSingle)
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
         # the scheduler
@@ -540,19 +540,9 @@ def create_transition(self, testShell):
         # get unimolecular reaction rules
         species_id = testShell.single.pid_particle_pair[1].sid    
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
-        # TODO !!! care for structure change once particles can remember them !!!
 
-        # OLD STUFF, PROB. NOT NEEDED
-        #print(testShell.target_surface.id)
-        surfacetype_id = testShell.target_surface.sid
-        interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
-
-        # 2. Create and register the interaction domain.
-        # The type of the interaction that will be created 
-        # depends on the surface (planar or cylindrical) the particle is 
-        # trying to associate with. Either PlanarSurfaceInteraction or 
-        # CylindricalSurfaceInteraction.
-        transition = create_default_transition(domain_id, shell_id, testShell, reaction_rules, interaction_rules) # HACK
+        # 2. Create and register the transition domain.
+        transition = create_default_transition(domain_id, shell_id, testShell, reaction_rules)
 
         assert isinstance(transition, Single)
         transition.initialize(self.t)
@@ -2155,23 +2145,23 @@ def try_interaction(self, single, surface):
             return None
 
 
-    def try_transition(self, single, surface):
-    # Try to form a transition between the 'single' particle on a surface and another 'surface'.
+    def try_transition(self, single, target_structure):
+    # Try to form a transition between the 'single' particle on a structure and another structure.
     # This is called after an interaction trial has failed.
     # Currently only transitions between two planar surfaces are supported.
 
         if __debug__:
-           log.debug('trying to form Transition(%s, %s)' % (single.pid_particle_pair[1], surface))
+           log.debug('trying to form Transition(%s, %s)' % (single.pid_particle_pair[1], target_structure))
 
 
         ### 1. Attempt to make a testShell. If it fails it will throw an exception.
         try:
-            testShell = try_default_testtransition(single, surface, self.geometrycontainer, self.domains)
+            testShell = try_default_testtransition(single, target_structure, self.geometrycontainer, self.domains)
         except testShellError as e:
             testShell = None
             if __debug__:
                 log.debug('%s not formed %s' % \
-                          ('Transition(%s, %s)' % (single.pid_particle_pair[0], surface),
+                          ('Transition(%s, %s)' % (single.pid_particle_pair[0], target_structure),
                           str(e) ))
 
 

From fab655fb35db77f2a4b7f1d25c8bdd3c77439650 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 18:08:52 +0100
Subject: [PATCH 0733/1541] Stop using fire_interaction to process transition
 events

... and removed most of the other "transition hack" stuff.
---
 egfrd.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ff8e98b9..b7c7082d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1190,8 +1190,7 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
         # Note that the reactant_structure_id is the id of the structure on which the particle was located at the time of the reaction.
 
         if __debug__:
-            #assert isinstance(single, InteractionSingle)
-            assert isinstance(single, Single) # HACK
+            assert isinstance(single, InteractionSingle)
 
         # 0. get reactant info
         reactant              = single.pid_particle_pair
@@ -1745,8 +1744,6 @@ def process_single_event(self, single, ignore):
                     self.interaction_steps[single.event_type] += 1  # TODO similarly here
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, struct_id, ignore)
 
-            elif isinstance(single, PlanarSurfaceTransitionSingle) and single.changes_structures : # HACK
-                    particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, ignore)
             else:
                 particles = self.fire_move(single, newpos, struct_id)
                 zero_singles_b = []     # no bursting takes place

From c075ab6dd1bf552e6daf7bfae43e148f852476f7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 18:13:57 +0100
Subject: [PATCH 0734/1541] Removed reactions stuff from testscript

---
 samples/finite_planes_hack/finite_planes.py | 112 +++-----------------
 1 file changed, 15 insertions(+), 97 deletions(-)

diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index 215552d7..053a7d7a 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -35,8 +35,8 @@
 
 # Constants
 # ===============================
-logging = True
 #logging = True
+logging = False
 sigma = 1e-8        # Diameter particle
 DC = 1e-13           # Diffusion constant
 N = 1000           # Number of steps simulation will last
@@ -59,125 +59,43 @@
 m = model.ParticleModel(2.01*world_size)
 
 # Planes ("membranes")
-membrane1_type = _gfrd.StructureType()
-membrane1_type['name'] = 'membrane1_type'
-membrane2_type = _gfrd.StructureType()
-membrane2_type['name'] = 'membrane2_type'
-membrane3_type = _gfrd.StructureType()
-membrane3_type['name'] = 'membrane3_type'
-membrane4_type = _gfrd.StructureType()
-membrane4_type['name'] = 'membrane4_type'
-membrane5_type = _gfrd.StructureType()
-membrane5_type['name'] = 'membrane5_type'
-membrane6_type = _gfrd.StructureType()
-membrane6_type['name'] = 'membrane6_type'
+membrane_type = _gfrd.StructureType()
+membrane_type['name'] = 'membrane_type'
 
 m.add_structure_type(membrane1_type)
-m.add_structure_type(membrane2_type)
-m.add_structure_type(membrane3_type)
-m.add_structure_type(membrane4_type)
-m.add_structure_type(membrane5_type)
-m.add_structure_type(membrane6_type)
 
 # Species
-A = model.Species('A', DC, sigma, membrane1_type)
+A = model.Species('A', DC, sigma, membrane_type)
 m.add_species_type(A)
-B = model.Species('B', DC, sigma, membrane2_type)
+B = model.Species('B', DC, sigma, membrane_type)
 m.add_species_type(B)
-C = model.Species('C', DC, sigma, membrane3_type)
+C = model.Species('C', DC, sigma, membrane_type)
 m.add_species_type(C)
-D = model.Species('D', DC, sigma, membrane4_type)
+D = model.Species('D', DC, sigma, membrane_type)
 m.add_species_type(D)
-E = model.Species('E', DC, sigma, membrane5_type)
+E = model.Species('E', DC, sigma, membrane_type)
 m.add_species_type(E)
-F = model.Species('F', DC, sigma, membrane6_type)
+F = model.Species('F', DC, sigma, membrane_type)
 m.add_species_type(F)
 
 Statist = model.Species('Statist', 0.0, 10.0*sigma)
 m.add_species_type(Statist)
 
-# Reaction rules
-rAB = model.create_binding_reaction_rule(A, membrane2_type, B, k)
-m.network_rules.add_reaction_rule(rAB)
-rBA = model.create_binding_reaction_rule(B, membrane1_type, A, k)
-m.network_rules.add_reaction_rule(rBA)
-
-rBC = model.create_binding_reaction_rule(B, membrane3_type, C, k)
-m.network_rules.add_reaction_rule(rBC)
-rCB = model.create_binding_reaction_rule(C, membrane2_type, B, k)
-m.network_rules.add_reaction_rule(rCB)
-
-rCD = model.create_binding_reaction_rule(C, membrane4_type, D, k)
-m.network_rules.add_reaction_rule(rCD)
-rDC = model.create_binding_reaction_rule(D, membrane3_type, C, k)
-m.network_rules.add_reaction_rule(rDC)
-
-rAD = model.create_binding_reaction_rule(A, membrane4_type, D, k)
-m.network_rules.add_reaction_rule(rAD)
-rDA = model.create_binding_reaction_rule(D, membrane1_type, A, k)
-m.network_rules.add_reaction_rule(rDA)
-
-rAE = model.create_binding_reaction_rule(A, membrane5_type, E, k)
-m.network_rules.add_reaction_rule(rAE)
-rEA = model.create_binding_reaction_rule(E, membrane1_type, A, k)
-m.network_rules.add_reaction_rule(rEA)
-
-rBE = model.create_binding_reaction_rule(B, membrane5_type, E, k)
-m.network_rules.add_reaction_rule(rBE)
-rEB = model.create_binding_reaction_rule(E, membrane2_type, B, k)
-m.network_rules.add_reaction_rule(rEB)
-
-rCE = model.create_binding_reaction_rule(C, membrane5_type, E, k)
-m.network_rules.add_reaction_rule(rCE)
-rEC = model.create_binding_reaction_rule(E, membrane3_type, C, k)
-m.network_rules.add_reaction_rule(rEC)
-
-rDE = model.create_binding_reaction_rule(D, membrane5_type, E, k)
-m.network_rules.add_reaction_rule(rDE)
-rED = model.create_binding_reaction_rule(E, membrane4_type, D, k)
-m.network_rules.add_reaction_rule(rED)
-
-rAF = model.create_binding_reaction_rule(A, membrane6_type, F, k)
-m.network_rules.add_reaction_rule(rAF)
-rFA = model.create_binding_reaction_rule(F, membrane1_type, A, k)
-m.network_rules.add_reaction_rule(rFA)
-
-rBF = model.create_binding_reaction_rule(B, membrane6_type, F, k)
-m.network_rules.add_reaction_rule(rBF)
-rFB = model.create_binding_reaction_rule(F, membrane2_type, B, k)
-m.network_rules.add_reaction_rule(rFB)
-
-rCF = model.create_binding_reaction_rule(C, membrane6_type, F, k)
-m.network_rules.add_reaction_rule(rCF)
-rFC = model.create_binding_reaction_rule(F, membrane3_type, C, k)
-m.network_rules.add_reaction_rule(rFC)
-
-rDF = model.create_binding_reaction_rule(D, membrane6_type, F, k)
-m.network_rules.add_reaction_rule(rDF)
-rFD = model.create_binding_reaction_rule(F, membrane4_type, D, k)
-m.network_rules.add_reaction_rule(rFD)
-
-rEF = model.create_binding_reaction_rule(E, membrane6_type, F, k)
-m.network_rules.add_reaction_rule(rEF)
-rFE = model.create_binding_reaction_rule(F, membrane5_type, E, k)
-m.network_rules.add_reaction_rule(rFE)
-
-
 # World
 w = gfrdbase.create_world(m, 3)
 
 # Create instances of membrane types
-membraneA = model.create_planar_surface(membrane1_type.id, 'name1', [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
+membraneA = model.create_planar_surface(membrane_type.id, 'name1', [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
 w.add_structure(membraneA)
-membraneB = model.create_planar_surface(membrane2_type.id, 'name2', [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
+membraneB = model.create_planar_surface(membrane_type.id, 'name2', [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
 w.add_structure(membraneB)
-membraneC = model.create_planar_surface(membrane3_type.id, 'name3', [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
+membraneC = model.create_planar_surface(membrane_type.id, 'name3', [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
 w.add_structure(membraneC)
-membraneD = model.create_planar_surface(membrane4_type.id, 'name4', [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
+membraneD = model.create_planar_surface(membrane_type.id, 'name4', [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
 w.add_structure(membraneD)
-membraneE = model.create_planar_surface(membrane5_type.id, 'name5', [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
+membraneE = model.create_planar_surface(membrane_type.id, 'name5', [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
 w.add_structure(membraneE)
-membraneF = model.create_planar_surface(membrane6_type.id, 'name6', [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
+membraneF = model.create_planar_surface(membrane_type.id, 'name6', [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
 w.add_structure(membraneF)
 
 print("Membrane A : unit_z = " + str(membraneA.shape.unit_z))

From fc7a4c3fcaed868bf0a49ac9633cecc2d3d56a6f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 18:15:35 +0100
Subject: [PATCH 0735/1541] Removed some obvious bugs

---
 samples/finite_planes_hack/finite_planes.py | 2 +-
 single.py                                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index 053a7d7a..e5709295 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -62,7 +62,7 @@
 membrane_type = _gfrd.StructureType()
 membrane_type['name'] = 'membrane_type'
 
-m.add_structure_type(membrane1_type)
+m.add_structure_type(membrane_type)
 
 # Species
 A = model.Species('A', DC, sigma, membrane_type)
diff --git a/single.py b/single.py
index cae3a6ab..97661ce7 100644
--- a/single.py
+++ b/single.py
@@ -349,7 +349,7 @@ class PlanarSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
         * Selected randomly when drawing displacement vector: theta.
 
     """
-    def __init__(self, domain_id, shell_id, testShell, reactionrules):surface
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         assert isinstance(testShell, PlanarSurfaceSingletestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)

From 184950a653b21a9a15b1a1d2337b23c135e0cf2c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 18:20:18 +0100
Subject: [PATCH 0736/1541] Some initial debugging

---
 egfrd.py                                    | 4 ++--
 samples/finite_planes_hack/finite_planes.py | 4 ++--
 single.py                                   | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b7c7082d..e03b1326 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -105,7 +105,7 @@ def try_default_testtransition(single, target_structure, geometrycontainer, doma
     if isinstance(single.structure, CuboidalRegion):        
             raise testShellError('(Transition). Combination of (3D particle, surface) is not supported')
     elif isinstance(single.structure, PlanarSurface):
-        if isinstance(surface, PlanarSurface):
+        if isinstance(target_structure, PlanarSurface):
             return PlanarSurfaceTransitionSingletestShell(single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Transition). Combination of (2D particle, surface other than plane) is not supported')
@@ -530,7 +530,7 @@ def create_transition(self, testShell):
     # Currently only plane-plane transitions are supported.
     # We assume here that the testShell was successfully created.
 
-        assert isinstance(testShell, testTransitionSingle)
+        assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell) # TODO should be generalized
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
         # the scheduler
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index e5709295..5a3c1906 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -35,8 +35,8 @@
 
 # Constants
 # ===============================
-#logging = True
-logging = False
+logging = True
+#logging = False
 sigma = 1e-8        # Diameter particle
 DC = 1e-13           # Diffusion constant
 N = 1000           # Number of steps simulation will last
diff --git a/single.py b/single.py
index 97661ce7..415d5302 100644
--- a/single.py
+++ b/single.py
@@ -1013,7 +1013,7 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        TransitionSingle.__init__(self, domain_id, shell_id, reactionrules)
+        TransitionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules)
 
         # This has to be set because external functions will use it
         # FIXME: Check whether this is still needed!

From 51675e6f6e21f671250e9209c7a4eadef408202a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Mar 2012 18:23:54 +0100
Subject: [PATCH 0737/1541] Seems to work (modulo known issues...)!

---
 samples/finite_planes_hack/finite_planes.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
index 5a3c1906..e5709295 100755
--- a/samples/finite_planes_hack/finite_planes.py
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -35,8 +35,8 @@
 
 # Constants
 # ===============================
-logging = True
-#logging = False
+#logging = True
+logging = False
 sigma = 1e-8        # Diameter particle
 DC = 1e-13           # Diffusion constant
 N = 1000           # Number of steps simulation will last

From 79e05975bd1ae83ef7974721f31c9322d2e60026 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Mar 2012 12:25:36 +0100
Subject: [PATCH 0738/1541] implemented the sizing of a cylindrical shell
 against a plane. Note that the plane still needs to be either parallel or
 perpendicular to the cylinder.

---
 shells.py | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/shells.py b/shells.py
index c8131537..b318f8e6 100755
--- a/shells.py
+++ b/shells.py
@@ -8,6 +8,7 @@
     Cylinder,
     CylindricalShell,
     CylindricalSurface,
+    Plane,
     PlanarSurface,
     CuboidalRegion,
     )
@@ -695,8 +696,50 @@ def get_radius_to_CylindricalShape(shape, testShell, r):
     return min(r, r_new)
 
 def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
+    # This function returns the dr, dz_right, dz_left for the cylindrical 'testShell' using the planar 'shape' as its closest
+    # neighbor. Note that it returns the minimum of the newly calculated parameters and the old parameters. The 'testShell' can
+    # therefore only become smaller.
+
+    assert (type(shape) is Plane)
+
+    plane_position = shape.position
+
+    # get the reference point and orientation of the domain to scale
+    reference_point = testShell.get_referencepoint()
+    orientation_vector = testShell.get_orientation_vector()
+
+    # determine what parameter of the cylinder (dr of dz) to scale.
+    relative_orientation = numpy.dot(orientation_vector, shape.unit_z)
+    if feq(relative_orientation, 0):
+        # The unit_z of the plane is perpendicular to the cylinder -> scale r
+        r = min(r, testShell.world.distance(shape, reference_point))
+        z_right = min(z_right, testShell.z_right(r))
+        z_left  = min(z_left,  testShell.z_left (r))
+
+    elif feq(abs(relative_orientation), 1):
+        # The unit_z of the plane is parallel to the axis of the cylinder -> scale z_right/z_left
+
+        # determine on what side the midpoint of the plane is relative to the reference_point
+        plane_position_t = testShell.world.cyclic_transpose (plane_position, reference_point)
+        ref_to_plane_vec = plane_position_t - reference_point
+        ref_to_plane_z = numpy.dot(ref_to_plane_vec, orientation_vector)
+
+        # if the shell is on the side of orientation_vector -> use z_right
+        if ref_to_plane_z >= 0:
+            z_right = min(z_right, testShell.world.distance(shape, reference_point))
+            r       = min(r, testShell.r_right(z_right))
+            z_left  = min(z_left, testShell.z_left(r))
+        else:
+            z_left  = min(z_left, testShell.world.distance(shape, reference_point))
+            r       = min(r, testShell.r_left(z_left))
+            z_right = min(z_right, testShell.z_right(r))
+            
+    else:
+        raise NotImplementedError('Only perpendicular planes are supported.')
+
     return r, z_right, z_left
 
+
 def get_radius_to_PlanarShape(shape, testShell, r):
     # This function returns the radius for the spherical 'testShell' using the planar 'shape' as its closest
     # neighbor. Note that it returns the minimum of the newly calculated radius and the old radius. The 'testShell' can

From e0b5fcaabcaaaa317dd286d681f83cd0e3ea8397 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Mar 2012 16:27:57 +0100
Subject: [PATCH 0739/1541] generalized the check_surface_overlap and
 check_shell_overlap into check_shape_overlap

---
 egfrd.py | 142 ++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 83 insertions(+), 59 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 66e7d213..66306410 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2421,7 +2421,7 @@ def check_domain(self, domain):
             ### check that shells do not overlap with non associated surfaces
             surfaces = get_surfaces(self.world, shell.shape.position, ignores + associated)
             for surface, _ in surfaces:
-                assert self.check_surface_overlap(shell, surface), \
+                assert self.check_shape_overlap(shell.shape, surface.shape) >= 0.0, \
                     '%s (%s) overlaps with %s.' % \
                     (str(domain), str(shell), str(surface))
 
@@ -2429,7 +2429,7 @@ def check_domain(self, domain):
             surfaces = get_surfaces(self.world, shell.shape.position, ignores)
             for surface, _ in surfaces:
                 if surface.id in associated:
-                    assert not self.check_surface_overlap(shell, surface), \
+                    assert self.check_shape_overlap(shell.shape, surface.shape) < 0.0, \
                     '%s (%s) should overlap with associated surface %s.' % \
                     (str(domain), str(shell), str(surface))
 
@@ -2446,7 +2446,7 @@ def check_domain(self, domain):
                          (isinstance(neighbor, hasCylindricalShell) and isinstance(neighbor, NonInteractionSingle) and domain.is_reset()) )):
 
                     for _, neighbor_shell in neighbor.shell_list:
-                        overlap = self.check_shell_overlap(shell, neighbor_shell)
+                        overlap = self.check_shape_overlap(shell.shape, neighbor_shell.shape)
                         assert overlap >= 0.0, \
                             '%s (%s) overlaps with %s (%s) by %s.' % \
                             (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
@@ -2471,71 +2471,95 @@ def check_domain(self, domain):
 
         return True
 
-    def check_shell_overlap(self, shell1, shell2):
-    # Return the amount of overlap between two shells (positive number means no overlap, negative means overlap)
+    def check_shape_overlap(self, shape1, shape2):
+    # Return the distance between two shapes (positive number means no overlap, negative means overlap)
 
-        # overlap criterium when both shells are spherical
-        if (type(shell1.shape) is Sphere) and (type(shell2.shape) is Sphere):
-            distance = self.world.distance(shell1.shape.position, shell2.shape.position)
-            return distance - (shell1.shape.radius + shell2.shape.radius)
+        # overlap criterium when one of the shapes is a sphere
+        if (type(shape1) is Sphere):
+            distance = self.world.distance(shape2, shape1.position)
+            return distance - shape1.radius
+        elif (type(shape2) is Sphere):
+            distance = self.world.distance(shape1, shape2.position)
+            return distance - shape2.radius
 
-        # overlap criterium when both shells are cylindrical 
-        elif (type(shell1.shape) is Cylinder) and (type(shell2.shape) is Cylinder):
-            # assuming that the cylinders are always parallel
-            assert feq(abs(numpy.dot (shell1.shape.unit_z, shell2.shape.unit_z)), 1.0), \
-                'shells are not oriented parallel, dot(unit_z1, unit_z2) = %s' % \
-                (abs(numpy.dot (shell1.shape.unit_z, shell2.shape.unit_z)))
-
-            shell1_pos = shell1.shape.position
-            shell2_pos = shell2.shape.position
-            shell2_post = self.world.cyclic_transpose(shell1_pos, shell2_pos)
-            inter_pos = shell1_pos - shell2_pos
-            inter_pos_z = shell1.shape.unit_z * numpy.dot(inter_pos, shell1.shape.unit_z)
-            inter_pos_r = inter_pos - inter_pos_z
-            overlap_r = length(inter_pos_r) - (shell1.shape.radius + shell2.shape.radius)
-            overlap_z = length(inter_pos_z) - (shell1.shape.half_length + shell2.shape.half_length)
-            if (overlap_r < 0.0) and (overlap_z < 0.0):
-                return -(overlap_r * overlap_z)           # TODO: find better number for overlap measure
-            else:
-                return 1
-
-
-        # overlap criterium when one shell is spherical and the other is cylindrical
-        elif (type(shell1.shape) is Sphere) and (type(shell2.shape) is Cylinder):
-            distance = self.world.distance(shell2.shape, shell1.shape.position)
-            return distance - shell1.shape.radius
-
-        # the other way around
-        elif (type(shell1.shape) is Cylinder) and (type(shell2.shape) is Sphere):
-            distance = self.world.distance(shell1.shape, shell2.shape.position)
-            return distance - shell2.shape.radius
-
-        # something was wrong (wrong type of shell provided)
-        else:
-            raise RuntimeError('check_shell_overlap: wrong shell type(s) provided.')
+        elif ((type(shape1) is Cylinder) and (type(shape2) is Plane)) or \
+             ((type(shape2) is Cylinder) and (type(shape1) is Plane)):
 
+            # putatively swap to make sure that shape1 is Cylinder and shape2 is Plane
+            if (type(shape2) is Cylinder) and (type(shape1) is Plane):
+                temp = shape2
+                shape2 = shape1
+                shape1 = temp
 
-    def check_surface_overlap(self, shell, surface):
-    # Returns True if the shell and surface do not overlap, and False if they do overlap.
+            if math.sqrt(shape1.half_length**2 + shape1.radius**2) < self.world.distance(shape2, shape1.position):
+                # if the plane is outside the sphere surrounding the cylinder.
+                return 1
+            else: 
+                shape1_pos = shape1.position
+                shape2_pos = shape2.position
+                shape1_post = self.world.cyclic_transpose(shape1_pos, shape2_pos)
+                inter_pos = shape1_post - shape2_pos
+                relative_orientation = numpy.dot(shape1.unit_z, shape2.unit_z)
+                # if the unit_z of the plane is perpendicular to the axis of the cylinder.
+                if feq(relative_orientation, 0):
+                    if abs(numpy.dot(inter_pos, shape2.unit_x)) - shape1.half_length > shape2.half_extent[0] or \
+                       abs(numpy.dot(inter_pos, shape2.unit_y)) - shape1.half_length > shape2.half_extent[1] or \
+                       abs(numpy.dot(inter_pos, shape2.unit_z)) > shape1.radius:
+                        return 1
+                    else:
+                        # NOTE this is still incorrect. By the above if statement the cylinder is made into a cuboid
+                        return -1
+
+                elif feq(abs(relative_orientation), 1):
+                    if abs(numpy.dot(inter_pos, shape2.unit_x)) - shape1.radius > shape2.half_extent[0] or \
+                       abs(numpy.dot(inter_pos, shape2.unit_y)) - shape1.radius > shape2.half_extent[1] or \
+                       abs(numpy.dot(inter_pos, shape2.unit_z)) > shape1.half_length:
+                        return 1
+                    else:
+                        # NOTE this is still incorrect. By the above if statement the cylinder is made into a cuboid
+                        return -1
+                else:
+                    raise RuntimeError('check_shape_overlap: planes and cylinders should be either parallel or perpendicular.')
 
-        if (type(shell.shape) is Sphere):
-            distance = self.world.distance(surface.shape, shell.shape.position)
-            return shell.shape.radius < distance
+        # overlap criterium when both shells are cylindrical 
+        elif (type(shape1) is Cylinder) and (type(shape2) is Cylinder):
 
-        elif (type(shell.shape) is Cylinder):
-            distance = self.world.distance(surface.shape, shell.shape.position)
+            if math.sqrt(shape1.half_length**2 + shape1.radius**2) < self.world.distance(shape2, shape1.position) or \
+               math.sqrt(shape2.half_length**2 + shape2.radius**2) < self.world.distance(shape1, shape2.position):
+                # if cylinder2 is outside the sphere surrounding the cylinder.
+                return 1
+            else: 
+                shape1_pos = shape1.position
+                shape2_pos = shape2.position
+                shape1_post = self.world.cyclic_transpose(shape1_pos, shape2_pos)
+                inter_pos = shape1_post - shape2_pos
+
+                relative_orientation = numpy.dot(shape1.unit_z, shape2.unit_z)
+                # if the unit_z of the plane is perpendicular to the axis of the cylinder.
+                if feq(relative_orientation, 0.0):
+                    return 1
+
+
+                elif feq(abs(relative_orientation), 1.0):
+                    inter_pos_z = shape2.unit_z * numpy.dot(inter_pos, shape2.unit_z)
+                    inter_pos_r = inter_pos - inter_pos_z
+                    overlap_r = length(inter_pos_r) - (shape1.radius + shape2.radius)
+                    overlap_z = length(inter_pos_z) - (shape1.half_length + shape2.half_length)
+                    if (overlap_r < 0.0) and (overlap_z < 0.0):
+                        return -(overlap_r * overlap_z)           # TODO: find better number for overlap measure
+                    else:
+                        return 1
+                else:
+                    raise RuntimeError('check_shape_overlap: cylinders are not oriented parallel or perpendicular.')
 
-            # Only take shells into account that have unit_z perpendicular to unit_z of surface
-            if (type(surface.shape) is Plane):
-                return shell.shape.radius < distance
-            elif (type(surface.shape) is Cylinder):
-                return shell.shape.half_length < distance
-            else:
-                raise RuntimeError('check_surface_overlap: Surface was not Plane of Cylinder.')
+        # If both shapes are planes.
+        elif (type(shape1) is Plane) and (type(shape2) is Plane):
+            # TODO
+            return 1
 
-        # something was wrong (wrong type of shell provided)
+        # something was wrong (wrong type of shape provided)
         else:
-            raise RuntimeError('check_surface_overlap: wrong shell type provided.')
+            raise RuntimeError('check_shape_overlap: wrong shape type(s) provided.')
 
 
     def check_domain_for_all(self):

From c729df511d3fbb5e5ab85c620bf322bea4e5816b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 28 Mar 2012 17:32:49 +0200
Subject: [PATCH 0740/1541] bugfix: structure should be choosen at random for
 each particle

---
 gfrdbase.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 296e475c..d412d845 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -209,18 +209,19 @@ def throw_in_particles(world, sid, n):
     """
     species = world.get_species(sid)
     structure_type = world.get_structure_type(species.structure_type_id)
-    structure = world.get_structure(random.choice(list(world.get_structure_ids(structure_type))))
+    structure_list = list(world.get_structure_ids(structure_type))
 
     if __debug__:
         name = world.model.get_species_type_by_id(sid)["name"]
         if name[0] != '(':
             name = '(' + name + ')'
         log.info('\n\tthrowing in %s particles of type %s to %s' %
-                 (n, name, structure.id))
+                 (n, name, structure_type.id))
 
     # This is a bit messy, but it works.
     i = 0
     while i < int(n):
+        structure = world.get_structure(random.choice(structure_list))
         position = structure.random_position(myrandom.rng)
         position = apply_boundary(position, world.world_size)
 

From 5e565654378145ad474983070b82c4f105f86b36 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Mar 2012 11:59:23 +0200
Subject: [PATCH 0741/1541] bugfix: Also use myrandom for choosing structure,
 otherwise no longer deterministic->bad for debugging

---
 gfrdbase.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index d412d845..501888d8 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -14,7 +14,6 @@
 import logging
 import logging.handlers
 
-import random
 import myrandom
 
 import model
@@ -221,9 +220,10 @@ def throw_in_particles(world, sid, n):
     # This is a bit messy, but it works.
     i = 0
     while i < int(n):
-        structure = world.get_structure(random.choice(structure_list))
+        myrandom.shuffle(structure_list)
+        structure = world.get_structure(structure_list[0])
         position = structure.random_position(myrandom.rng)
-        position = apply_boundary(position, world.world_size)
+        position = world.apply_boundary(position)
 
         # Check overlap.
         if not world.check_overlap((position, species.radius)):

From 15adaac5fbd447bb9442c69600ce73180d1ed4d9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 22 Mar 2012 16:49:16 +0100
Subject: [PATCH 0742/1541] small fixes

---
 egfrd.py  | 11 ++++-------
 shells.py | 10 +++-------
 single.py |  5 ++---
 3 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 68ad178e..0908790d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1,5 +1,4 @@
 #!/usr/env python
-# -*- coding: utf-8 -*-
 
 from weakref import ref
 import math
@@ -73,7 +72,7 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
         testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
 
-### Interactions (including changes from one surface to another / crossing edges)
+### Interactions
 def try_default_testinteraction(single, surface, geometrycontainer, domains):
     if isinstance(single.structure, CuboidalRegion):
         if isinstance(surface, PlanarSurface):
@@ -83,7 +82,7 @@ def try_default_testinteraction(single, surface, geometrycontainer, domains):
         else:
             raise testShellError('(Interaction). Combination of (3D particle, surface) is not supported')
     elif isinstance(single.structure, PlanarSurface):
-            raise testShellError('(Interaction). Combination of (2D particle, surface) is not supported')
+        raise testShellError('(Interaction). Combination of (2D particle, surface) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(surface, CylindricalSurface):     # TODO differentiate between a sink and a cap
             return CylindricalSurfaceSinktestShell (single, surface, geometrycontainer, domains)
@@ -1637,8 +1636,7 @@ def update_single(self, single):
         self.add_domain_event(single)
         # check everything is ok
         if __debug__:
-            #assert self.check_domain(single) # HACK
-            pass
+            assert self.check_domain(single)
 
         return single
 
@@ -1694,8 +1692,7 @@ def process_single_event(self, single, ignore):
             if __debug__:
                 if single.event_type != EventType.BURST:
                     # The burst of the domain may be caused by an overlapping domain
-                    #assert self.check_domain(single) # HACK
-                    pass
+                    assert self.check_domain(single)
 
                 # check that the event time of the single (last_time + dt) is equal to the
                 # simulator time
diff --git a/shells.py b/shells.py
index 7e81826c..813e41a7 100755
--- a/shells.py
+++ b/shells.py
@@ -1,5 +1,4 @@
 #!/usr/bin/python
-# -*- coding: utf-8 -*-
 
 import math
 
@@ -373,7 +372,7 @@ def __init__(self, sphericaltestShell, domain_id):
         # Make the appropriate shell.
         self.shell_center = sphericaltestShell.center
         self.shell_radius = sphericaltestShell.radius
-        self.shell = self.create_new_shell(self.shell_center,     # HACK! Why did it work without first arg. before?!
+        self.shell = self.create_new_shell(self.shell_center,
                                            self.shell_radius,
                                            domain_id)
 
@@ -962,9 +961,6 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         for neighbor, distance in neighbor_domains:
 
             shell_list = self.get_neighbor_shell_list(neighbor)
-            # FIXME: This gives an error 'NoneType' object is not iterable if neighbours are present
-            # This is because get_neighbor_shell_list_for_single is not implemented in PlanarSurfaceEdgeSingle yet! TODO!
-            print shell_list # HACK
             for _, shell_appearance in shell_list:
                 if isinstance(shell_appearance.shape, Sphere):
                     dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self,
@@ -986,7 +982,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
                 dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
                (dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left)
 
-        # Note that dr, dz_right, dz_left can now actually be smaller than the minimum        
+        # Note that dr, dz_right, dz_left can now actually be smaller than the minimum
         dr, dz_right, dz_left = self.apply_safety(dr, dz_right, dz_left)
 
         return dr, dz_right, dz_left
@@ -1101,7 +1097,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.dz_left  = self.pid_particle_pair[1].radius
         self.dr       = self.pid_particle_pair[1].radius
         # Here determine_possible_shell is not called since the making of a NonInteractionSingle
-        # should never fail        
+        # should never fail
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z   # just copy from structure
diff --git a/single.py b/single.py
index 415d5302..a85adcfd 100644
--- a/single.py
+++ b/single.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 from _gfrd import (
     SphericalShell,
     CylindricalShell,
@@ -26,7 +25,7 @@
     'SphericalSingle',
     'Single',
     'NonInteractionSingle',
-    'InteractionSingle',    
+    'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
@@ -305,7 +304,7 @@ def shell_list_for_other(self):
         else:
             return self.shell_list
 
-    #def create_updated_shell(self, position):
+    def create_updated_shell(self, position):
         # TODO what should we do with the position now?
         try:
             radius = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])

From 42a367584ea3687639539fef1f4851c8417e1feb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 27 Mar 2012 18:12:10 +0200
Subject: [PATCH 0743/1541] removed some of Tomeks hacks in make_new_domain

---
 egfrd.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0908790d..35c487ab 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1459,7 +1459,7 @@ def make_new_domain(self, single):
         # Note that we do not differentiate between directions. This means that we
         # look around in a sphere, the horizons are spherical.
         pair_interaction_partners = []
-        pair_interaction_partners_ids = [] # HACK
+#        pair_interaction_partners_ids = [] # HACK
         for domain, _ in neighbor_distances:
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
@@ -1468,18 +1468,20 @@ def make_new_domain(self, single):
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
-            if isinstance(surface, PlanarSurface):
+            if isinstance(surface, PlanarSurface) and (single.structure, PlanarSurface):
+                surface_horizon = single_radius * SINGLE_SHELL_FACTOR
+            elif isinstance(surface, PlanarSurface):
                 # with a planar surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 2.0  # HACK!!! The * 2 factor is added manually! REMOVE THIS!
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) #* 2.0  # HACK!!! The * 2 factor is added manually! REMOVE THIS!
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
-            pair_interaction_partners_ids.append((surface.id, surface_distance)) # HACK
+#            pair_interaction_partners_ids.append((surface.id, surface_distance)) # HACK
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
-        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners_ids)) # HACK
+#        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners_ids)) # HACK
 
         # For each particles/particle or particle/surface pair, check if a pair or interaction can be
         # made. Note that we check the closest one first and only check if the object are within the horizon

From b24b3a843d02959c80ae1c58be9c81331a977755 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 28 Mar 2012 17:34:12 +0200
Subject: [PATCH 0744/1541] implemented a testCyinder scaling up to a
 perpendicular cylindrical shell Previously all cylinders in the system needed
 to be parallel, now they can also be perpendicular.

---
 shells.py | 184 +++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 162 insertions(+), 22 deletions(-)

diff --git a/shells.py b/shells.py
index 813e41a7..c2c55654 100755
--- a/shells.py
+++ b/shells.py
@@ -654,35 +654,175 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         z1 = z_left
         z2 = z_right
 
-    # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
-    ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
-    ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
-    ref_to_shell_r = length(ref_to_shell_r_vec)         # the radius is always positive
-    ref_to_shell_z = ref_to_shell_z * direction         # ref_to_shell_z is positive on the scaling side (right/left)
+    relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
+    if feq(relative_orientation, 1.0):
+    ### If the cylinders are oriented parallelly
 
+        # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
+        ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
+        ref_to_shell_r_vec = ref_to_shell_vec - ref_to_shell_z_vec
+        ref_to_shell_r = length(ref_to_shell_r_vec)         # the radius is always positive
+        ref_to_shell_z = ref_to_shell_z * direction         # ref_to_shell_z is positive on the scaling side (right/left)
 
-    # calculate the distances in r/z from the scaling center to the shell
-    scale_center_to_shell_r = ref_to_shell_r - scale_center_r
-    scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
-    # get angles
-    to_edge_angle = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
+        # calculate the distances in r/z from the scaling center to the shell
+        scale_center_to_shell_r = ref_to_shell_r - scale_center_r
+        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
-    if (scale_center_to_shell_z - shell_half_length) < 0.0:
-        to_edge_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
-    # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
-    # otherwise: shell_angle is ok -> do nothing
+        # get angles
+        to_edge_angle = math.atan( (scale_center_to_shell_r - shell_radius) / (scale_center_to_shell_z - shell_half_length) )
+
+        if (scale_center_to_shell_z - shell_half_length) < 0.0:
+            to_edge_angle += Pi           # if the shell was too much to the side we correct the angle to be positive
+        # elif: a negative angle was caused by a negative scale_center_to_shell we want a negative angle -> do nothing
+        # otherwise: shell_angle is ok -> do nothing
+
+        if to_edge_angle <= scale_angle:
+            # shell hits the scaling cylinder on top
+            z1_new = min(z1, (ref_to_shell_z - shell_half_length))
+            r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
+        else:
+            # shell hits the scaling cylinder on the radial side
+            r_new = min(r, (ref_to_shell_r - shell_radius))
+            z1_new = min(z1, z1_function(r_new))
+
+    elif feq(relative_orientation, 0):
+    ### If the cylinders are oriented perpendicularly
+
+        # The local x-axis is defined as the vector parallel to the axis of the shell in the direction from the
+        # reference_point of the scaling cylinder to the cylindrical shell
+        # The local y-axis is defined as the vector parallel to the flat side of the shell, perpendicular to the
+        # axis of the scaling cylinder. It also point from the reference_point of the scaling cylinder to the shell.
+        # The local z-axis is defined as the vector parallel to the axis of the scaling cylinder in the direction
+        # from the reference point to the shell.
+        if numpy.dot(ref_to_shell_vec, shape.unit_z) >= 0:
+            local_x = shape.unit_z
+        else:
+            local_x = -shape.unit_z
+        local_z = orientation_vector * direction
+        cross = numpy.cross(local_x, local_z)
+        if numpy.dot(ref_to_shell_vec, cross) >= 0:
+            local_y = cross
+        else:
+            local_y = -cross
+
+        ref_to_shell_x = numpy.dot(ref_to_shell_vec, local_x)
+        ref_to_shell_y = numpy.dot(ref_to_shell_vec, local_y)
+        ref_to_shell_z = numpy.dot(ref_to_shell_vec, local_z)
+        assert (ref_to_shell_x >= 0.0) and (ref_to_shell_y >= 0.0) and (ref_to_shell_z >= 0.0)  # By the definition of the local coordinate system
+
+        scale_center_to_shell_x = ref_to_shell_x    # TODO smt with scale_center_r
+        scale_center_to_shell_y = ref_to_shell_y
+        scale_center_to_shell_z = ref_to_shell_z - scale_center_z
+        assert scale_center_to_shell_z > 0.0, 'something horribly wrong'
+        
+        ref_to_shell_x2 = ref_to_shell_x - shell_half_length
+        ref_to_shell_y2 = ref_to_shell_y - shell_radius
+
+        if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
+            situation = 4
+
+        elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
+            scale_center_to_shell_crit_angle_y = math.atan((scale_center_to_shell_x - shell_half_length)/ \
+                                                           (scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2)) )
+            scale_center_to_shell_low_angle_y  = math.atan((scale_center_to_shell_x - shell_half_length)/(scale_center_to_shell_y - shell_radius))
+            # TODO fix angles such that they are between 0-Pi
+            if scale_angle <= scale_center_to_shell_crit_angle_y:
+                situation = 1
+            elif scale_center_to_shell_low_angle_y <= scale_angle:
+                situation = 4
+            else:
+                assert scale_center_to_shell_crit_angle_y < scale_angle and \
+                       scale_angle < scale_center_to_shell_low_angle_y
+                situation = 2
+
+        elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
+            scale_center_to_shell_crit_angle_x = math.atan((scale_center_to_shell_y - shell_radius)/scale_center_to_shell_z)
+            scale_center_to_shell_low_angle_x  = math.atan(scale_center_to_shell_y/(scale_center_to_shell_z - shell_radius))
+            # TODO fix angles such that they are between 0-Pi
+            if scale_angle <= scale_center_to_shell_crit_angle_x:
+                situation = 6
+            elif scale_center_to_shell_low_angle_x <= scale_angle:
+                situation = 4
+            else:
+                assert scale_center_to_shell_crit_angle_x < scale_angle and \
+                       scale_angle < scale_center_to_shell_low_angle_x
+                situation = 5
+
+        else:
+            assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
+            scale_center_to_shell_crit_angle_xy = math.atan(math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) / \
+                                                            scale_center_to_shell_z)
+            scale_center_to_shell_low_angle_xy  = math.atan(math.sqrt(scale_center_to_shell_y**2 + (scale_center_to_shell_x - shell_half_length)**2) / \
+                                                            (scale_center_to_shell_z - shell_radius) )
+            # TODO fix angles such that they are between 0-Pi
+            if scale_angle <= scale_center_to_shell_crit_angle_xy:
+                situation = 3
+            elif scale_center_to_shell_low_angle_xy <= scale_angle:
+                situation = 4
+            else:
+                assert scale_center_to_shell_crit_angle_xy < scale_angle and \
+                       scale_angle < scale_center_to_shell_low_angle_xy
+                situation = 2
+
+        #################
+        if situation == 1:
+            # shell hits the scaling cylinder with its flat surface on the radial side
+            r_new = min(r, (ref_to_shell_x - shell_half_length))
+            z1_new = min(z1, z1_function(r_new))
+
+        elif situation == 2:
+            # shell hits the scaling cylinder with its edge on the edge
+            # TODO we have a solution but it can only be found with a root finder -> slow
+            # TODO Now we just use the lower bound of the solution.
+            z1_new = min(z1, (ref_to_shell_z - shell_radius))
+            r_new  = min(r,  r1_function(z1_new))
+
+        elif situation == 3:
+            # shell hits the scaling cylinder with its edge on the radial side
+            r_new = min(r, math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2))
+            z1_new = min(z1, z1_function(r_new))
+
+        elif situation == 4:
+            # shell hits the scaling cylinder with its round side on the top flat side
+            z1_new = min(z1, (ref_to_shell_z - shell_radius))
+            r_new  = min(r,  r1_function(z1_new))
+
+        elif situation == 5:
+            shell_radius_sq = shell_radius*shell_radius
+
+            ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_y**2)
+            scale_center_to_shell = math.sqrt(ss_sq)
+
+            shell_angle_x = math.atan(scale_center_to_shell_y/scale_center_to_shell_z)
+            angle_diff = shell_angle_x - scale_angle
+            sin_angle_diff = math.sin(angle_diff)
+            cos_angle_diff = math.cos(angle_diff)
+
+            scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
+                                       math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
+
+            if scale_angle <= Pi/4.0:
+                cos_scale_angle = math.cos(scale_angle)
+                z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist))
+                r_new  = min(r, r1_function(z1_new))
+            else:
+                sin_scale_angle = math.sin(scale_angle)
+                r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist))
+                z1_new = min(z1, z1_function(r_new))
+
+        elif situation == 6:
+            # shell hits the scaling cylinder with its round side on the radial side
+            r_new = min(r, (ref_to_shell_y - shell_radius))
+            z1_new = min(z1, z1_function(r_new))
+
+        else:
+            raise RuntimeError('get_dr_dzright_dzleft_to_CylindricalShape: Bad situation for making cylinders against cylinders.')
 
-    if to_edge_angle <= scale_angle:
-        # shell hits the scaling cylinder on top
-        z1_new = min(z1, (ref_to_shell_z - shell_half_length))
-        r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
     else:
-        # shell hits the scaling cylinder on the radial side
-        r_new = min(r, (ref_to_shell_r - shell_radius))
-        z1_new = min(z1, z1_function(r_new))
-    z2_new = min(z2, z2_function(r_new))
+        raise NotImplementedError('get_dr_dzright_dzleft_to_CylindricalShape: Cylinders should be oriented parallel or perpendicular.')
 
+    z2_new = min(z2, z2_function(r_new))
 
     # switch the z values in case it's necessary. r doesn't have to be switched.
     r = r_new

From ef55c90a7c696765fce8db1bdcbd78e15a0f79ad Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Mar 2012 15:41:15 +0200
Subject: [PATCH 0745/1541] cleanup of the code of TransitionSingle and its use
 in make_new_domain

---
 edgetools.py |   4 +--
 egfrd.py     |  17 +++++----
 shells.py    |  80 +++++++++++++++++++++--------------------
 single.py    | 100 +++++++++++++++++++++++++++------------------------
 4 files changed, 106 insertions(+), 95 deletions(-)

diff --git a/edgetools.py b/edgetools.py
index cc091b4d..65d9d0f2 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 from _gfrd import (
     SphericalShell,
     CylindricalShell,
@@ -39,7 +37,7 @@ def __init__(self, testShell, start_position):
         self.target_half_extent = self.target_structure.shape.half_extent
 
         self.start_position  = start_position
-        self.target_distance = testShell.get_distance_to_target_structure()
+        self.target_distance = testShell.distance_to_target_structure
 
         self.edge_point = self.get_edge_point()
         self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
diff --git a/egfrd.py b/egfrd.py
index 35c487ab..b0e0a4d2 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -537,7 +537,7 @@ def create_transition(self, testShell):
         shell_id = self.shell_id_generator()
 
         # get unimolecular reaction rules
-        species_id = testShell.single.pid_particle_pair[1].sid    
+        species_id = testShell.pid_particle_pair[1].sid    
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
 
         # 2. Create and register the transition domain.
@@ -1468,14 +1468,14 @@ def make_new_domain(self, single):
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
-            if isinstance(surface, PlanarSurface) and (single.structure, PlanarSurface):
-                surface_horizon = single_radius * SINGLE_SHELL_FACTOR
-            elif isinstance(surface, PlanarSurface):
+            if isinstance(surface, PlanarSurface):
                 # with a planar surface it is the center of mass that 'looks around'
                 surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) #* 2.0  # HACK!!! The * 2 factor is added manually! REMOVE THIS!
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
+            if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):        # HACK
+                surface_horizon = single_radius * SINGLE_SHELL_FACTOR * 2
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
 #            pair_interaction_partners_ids.append((surface.id, surface_distance)) # HACK
 
@@ -1498,12 +1498,15 @@ def make_new_domain(self, single):
                 domain = self.try_pair (single, obj)
                 # TODO: Include formation of "PlanarSurfaceTransitionPair"
 
+            elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
+                domain = self.try_transition(single, obj)
+
             elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
-                # if this fails try a Transition between two surfaces
-                if not domain:
-                    domain = self.try_transition (single, obj)
+#                # if this fails try a Transition between two surfaces
+#                if not domain:
+#                    domain = self.try_transition (single, obj)
 
 
         if not domain:
diff --git a/shells.py b/shells.py
index c2c55654..3cabfa4f 100755
--- a/shells.py
+++ b/shells.py
@@ -178,16 +178,21 @@ def __init__(self, single, structure, surface):
 class testTransitionSingle(testSingle, Others):
 
     def __init__(self, single, target_structure):
+
+        testSingle.__init__(self, single.pid_particle_pair, single.structure)
+
+        assert (self.structure.sid == target_structure.sid)     # Both structures are of same structure_type
         self.single = single
-        self.structure = single.structure
+#        self.structure = single.structure
 
-        self.origin_structure = single.structure
+        self.origin_structure = self.structure
         self.target_structure = target_structure
 
-        self.pid_particle_pair = single.pid_particle_pair
-        self.particle = single.pid_particle_pair[1]
-        self.single_radius = self.particle.radius
-        self.center = self.particle.position
+        # Note that we assume the structures are exactly connecting
+        self.distance_to_target_structure = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
+#        self.pid_particle_pair = single.pid_particle_pair
+#        self.particle = single.pid_particle_pair[1]
+#        self.single_radius = self.particle.radius
 
 ##############
 class testPair(Others):
@@ -1044,6 +1049,37 @@ def __init__(self, single1, single2, geometrycontainer, domains):
     def get_min_radius(self):
         return self.get_min_pair_size()
 
+#####
+class PlanarSurfaceTransitionSingletestShell(SphericaltestShell, testTransitionSingle):
+
+    def __init__(self, single, target_structure, geometrycontainer, domains):
+        SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testTransitionSingle.__init__(self, single, target_structure)
+
+        assert isinstance(self.origin_structure, PlanarSurface)
+        assert isinstance(self.target_structure, PlanarSurface)
+
+        self.center = self.pid_particle_pair[1].position
+        try:
+            self.radius = self.determine_possible_shell(self.structure.id, [self.single.domain_id],
+                                                        [self.target_structure.id])
+        except ShellmakingError as e:
+            raise testShellError('(PlanarSurfaceTransitionSingle). %s' %
+                                 (str(e)))
+
+    def get_min_radius(self):
+#        min_offset = self.single_radius#*(SINGLE_SHELL_FACTOR - 1.0)
+        # The minimal shell size also deterimines the minimal radius of the later 2D domain.
+        # min_offset here is the minimal length that the circular 2D domain protrudes into
+        # the target surface. Make sure that min_offset > 0.0, because only then it is
+        # guaranteed that there is always a certain probability to cross the edge even
+        # if the shell with minimal radius is constructed
+        return self.distance_to_target_structure + self.pid_particle_pair[1].radius
+
+#    def get_distance_to_target_structure(self):
+#        distance = self.world.distance(self.target_structure.shape, self.center)
+#        return distance
+
 ##########################
 class CylindricaltestShell(testShell):
     # The CylindricaltestShell is the geometric aspect of testDomains with a cylindrical shell.
@@ -1318,38 +1354,6 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right, z_left
 
-#####
-class PlanarSurfaceTransitionSingletestShell(SphericaltestShell, testTransitionSingle):
-
-    def __init__(self, single, target_structure, geometrycontainer, domains):
-        SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testTransitionSingle.__init__(self, single, target_structure)
-
-        assert isinstance(self.origin_structure, PlanarSurface)
-        assert isinstance(self.target_structure, PlanarSurface)
-
-        try:
-            self.radius = self.determine_possible_shell(self.origin_structure.id, 
-                                                        [self.single.domain_id],
-                                                        [self.origin_structure.id, self.target_structure.id]
-                                                       )
-        except ShellmakingError as e:
-            raise testShellError('(PlanarSurfaceTransitionSingle). %s' %
-                                 (str(e)))
-
-    def get_min_radius(self):
-        min_offset = self.single_radius#*(SINGLE_SHELL_FACTOR - 1.0)
-        # The minimal shell size also deterimines the minimal radius of the later 2D domain.
-        # min_offset here is the minimal length that the circular 2D domain protrudes into
-        # the target surface. Make sure that min_offset > 0.0, because only then it is
-        # guaranteed that there is always a certain probability to cross the edge even
-        # if the shell with minimal radius is constructed
-        return self.get_distance_to_target_structure() + min_offset
-
-    def get_distance_to_target_structure(self):
-        distance = self.world.distance(self.target_structure.shape, self.center)
-        return distance
-
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
 
diff --git a/single.py b/single.py
index a85adcfd..a8ebb3d0 100644
--- a/single.py
+++ b/single.py
@@ -59,6 +59,11 @@ def __init__(self, domain_id, shell_id, reactionrules):
         self.rrule = None                               # the reaction rule of the actual reaction (property reactionrule)
         self.k_tot = self.calc_ktot(reactionrules)
 
+    def initialize(self, t):
+        self.dt = 0.0
+        self.last_time = t
+        self.event_type = None
+
     def getD(self):
         return self.pid_particle_pair[1].D
     D = property(getD)
@@ -169,8 +174,9 @@ def __init__(self, domain_id, shell_id, reactionrules):
         # Note: for the NonInteractionSingles superclass nothing is to be initialized.
 
     def initialize(self, t):
-        self.dt = 0.0
-        self.last_time = t
+#        self.dt = 0.0
+#        self.last_time = t
+        Single.initialize(self, t)
         self.event_type = EventType.SINGLE_ESCAPE
 
 
@@ -608,12 +614,12 @@ def get_inner_dz_left(self):
     def get_inner_dz_right(self):
         pass
 
-    def initialize(self, t):    
-        # initialize the domain object with the appropriate time to allow reuse of
-        # the Domain at different times
-        self.dt = 0
-        self.last_time = t
-        self.event_type = None
+#    def initialize(self, t):    
+#        # initialize the domain object with the appropriate time to allow reuse of
+#        # the Domain at different times
+#        self.dt = 0
+#        self.last_time = t
+#        self.event_type = None
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -974,19 +980,19 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         EdgeTools.__init__(self, testShell, self.pid_particle_pair[1].position)
         # Note: for the Others superclass nothing is to be initialized.
 
-        self.pid_particle_pair = testShell.single.pid_particle_pair # is that necessary??
+#        self.pid_particle_pair = testShell.single.pid_particle_pair # is that necessary??
 
         # That was part of the HACK, so we keep it now and remove it later when everything works
         # origin_structure and target_structure are inherited from testShell via EdgeTools
-        self.structure = self.origin_structure
-        self.surface = self.target_structure
+#        self.structure = self.origin_structure
+#        self.surface = self.target_structure
 
-    def initialize(self, t):    
-        # initialize the domain object with the appropriate time to allow reuse of
-        # the Domain at different times
-        self.dt = 0
-        self.last_time = t
-        self.event_type = None
+#    def initialize(self, t):    
+#        # initialize the domain object with the appropriate time to allow reuse of
+#        # the Domain at different times
+#        self.dt = 0
+#        self.last_time = t
+#        self.event_type = None
 
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
@@ -1016,22 +1022,22 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         # This has to be set because external functions will use it
         # FIXME: Check whether this is still needed!
-        self.structure = self.origin_structure
-        self.surface = self.target_structure
+#        self.structure = self.origin_structure
+#        self.surface = self.target_structure
 
     # The same Greens function is used as for the normal PlanarSurfaceSingle;
     # If the position is off the surface of origin, it will be transformed towards the target surface
     def greens_function(self):
-        return GreensFunction2DAbsSym(self.D,
-                                          self.get_inner_a())
+        return GreensFunction2DAbsSym(self.D, self.get_inner_a())
 
     def draw_new_position(self, dt, event_type):
-        oldpos = self.start_position
+#        oldpos = self.start_position
+        oldpos = self.pid_particle_pair[1].position
 
         if self.D == 0:
-            newpos = oldpos
+            newpos, new_structure_id = oldpos, self.structure.id
         elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
-            newpos = oldpos
+            newpos, new_structure_id = oldpos, self.structure.id
         else:
             # Calculate r
             if event_type == EventType.SINGLE_ESCAPE:
@@ -1063,29 +1069,29 @@ def create_position_vector(self, r):
         x, y = random_vector2D(r)
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
-    # copied from SphericalSingle
-    # these return potentially corrected dimensions
-    # For explanation see NonInteractionSingles and Others in shells.py
-    def shell_list_for_single(self):
-        # make sure that there is at least space for the multi shell
-        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-        if  self.shell.shape.radius < min_radius:
-            position = self.shell.shape.position
-            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-            # TODO maybe just returning the dimension instead of actually making the shell is cheaper.
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
-
-    def shell_list_for_other(self):
-        # keeps all the other domains at a distance of the burst radius
-        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-        if self.shell.shape.radius < min_radius:
-            position = self.shell.shape.position
-            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-            return [(self.shell_id, fake_shell), ]
-        else:
-            return self.shell_list
+#    # copied from SphericalSingle
+#    # these return potentially corrected dimensions
+#    # For explanation see NonInteractionSingles and Others in shells.py
+#    def shell_list_for_single(self):
+#        # make sure that there is at least space for the multi shell
+#        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+#        if  self.shell.shape.radius < min_radius:
+#            position = self.shell.shape.position
+#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
+#            # TODO maybe just returning the dimension instead of actually making the shell is cheaper.
+#            return [(self.shell_id, fake_shell), ]
+#        else:
+#            return self.shell_list
+#
+#    def shell_list_for_other(self):
+#        # keeps all the other domains at a distance of the burst radius
+#        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+#        if self.shell.shape.radius < min_radius:
+#            position = self.shell.shape.position
+#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
+#            return [(self.shell_id, fake_shell), ]
+#        else:
+#            return self.shell_list
 
 
     def __str__(self):

From dbef00cd7c47ab3c428575660978efb1cede9916 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 29 Mar 2012 19:28:17 +0200
Subject: [PATCH 0746/1541] Corrected incomplete angle calculations made sure
 that the calculated angles for making a cylindrical shell against a
 perpendicular cylindrical shape are correct. Also that it works for
 cylindrical shells that only scale in the z direction.

---
 shells.py | 86 ++++++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 70 insertions(+), 16 deletions(-)

diff --git a/shells.py b/shells.py
index 3cabfa4f..99ad4ad4 100755
--- a/shells.py
+++ b/shells.py
@@ -716,10 +716,9 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         ref_to_shell_z = numpy.dot(ref_to_shell_vec, local_z)
         assert (ref_to_shell_x >= 0.0) and (ref_to_shell_y >= 0.0) and (ref_to_shell_z >= 0.0)  # By the definition of the local coordinate system
 
-        scale_center_to_shell_x = ref_to_shell_x    # TODO smt with scale_center_r
+        scale_center_to_shell_x = ref_to_shell_x
         scale_center_to_shell_y = ref_to_shell_y
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
-        assert scale_center_to_shell_z > 0.0, 'something horribly wrong'
         
         ref_to_shell_x2 = ref_to_shell_x - shell_half_length
         ref_to_shell_y2 = ref_to_shell_y - shell_radius
@@ -728,10 +727,27 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             situation = 4
 
         elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
-            scale_center_to_shell_crit_angle_y = math.atan((scale_center_to_shell_x - shell_half_length)/ \
-                                                           (scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2)) )
-            scale_center_to_shell_low_angle_y  = math.atan((scale_center_to_shell_x - shell_half_length)/(scale_center_to_shell_y - shell_radius))
-            # TODO fix angles such that they are between 0-Pi
+            scale_center_to_shell_x -= scale_center_r
+            scale_center_to_flatend_x = scale_center_to_shell_x - shell_half_length
+            scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
+            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+
+            # angle1
+            if scale_center_to_critpoint_z == 0:
+                scale_center_to_shell_crit_angle_y = Pi/2
+            else:
+                scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
+                if scale_center_to_critpoint_z < 0.0:
+                    scale_center_to_shell_crit_angle_y += Pi
+            # angle2
+            if scale_center_to_lowpoint_z == 0:
+                scale_center_to_shell_low_angle_y = Pi/2
+            else:
+                scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_flatend_x/ scale_center_to_lowpoint_z )
+                if scale_center_to_lowpoint_z < 0.0:
+                    scale_center_to_shell_low_angle_y += Pi
+
+
             if scale_angle <= scale_center_to_shell_crit_angle_y:
                 situation = 1
             elif scale_center_to_shell_low_angle_y <= scale_angle:
@@ -742,9 +758,26 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 situation = 2
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
-            scale_center_to_shell_crit_angle_x = math.atan((scale_center_to_shell_y - shell_radius)/scale_center_to_shell_z)
-            scale_center_to_shell_low_angle_x  = math.atan(scale_center_to_shell_y/(scale_center_to_shell_z - shell_radius))
-            # TODO fix angles such that they are between 0-Pi
+            scale_center_to_shell_y -= scale_center_r
+            scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
+            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+
+            # angle1
+            if scale_center_to_shell_z == 0.0:
+                scale_center_to_shell_crit_angle_x = Pi/2.0
+            else:
+                scale_center_to_shell_crit_angle_x = math.atan(scale_center_to_critpoint_y / scale_center_to_shell_z)
+                if scale_center_to_shell_z < 0.0:
+                    scale_center_to_shell_crit_angle_x += Pi
+            # angle2
+            if scale_center_to_lowpoint_z == 0.0:
+                scale_center_to_shell_low_angle_x = Pi/2.0
+            else:
+                scale_center_to_shell_low_angle_x  = math.atan(scale_center_to_shell_y/scale_center_to_lowpoint_z)
+                if scale_center_to_lowpoint_z < 0.0:
+                    scale_center_to_shell_low_angle_x += Pi
+
+
             if scale_angle <= scale_center_to_shell_crit_angle_x:
                 situation = 6
             elif scale_center_to_shell_low_angle_x <= scale_angle:
@@ -756,11 +789,27 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
         else:
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
-            scale_center_to_shell_crit_angle_xy = math.atan(math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) / \
-                                                            scale_center_to_shell_z)
-            scale_center_to_shell_low_angle_xy  = math.atan(math.sqrt(scale_center_to_shell_y**2 + (scale_center_to_shell_x - shell_half_length)**2) / \
-                                                            (scale_center_to_shell_z - shell_radius) )
-            # TODO fix angles such that they are between 0-Pi
+
+            scale_center_to_critpoint_r = math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r
+            scale_center_to_lowpoint_r = math.sqrt(scale_center_to_shell_y**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r
+            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+
+            # angle1
+            if scale_center_to_shell_z == 0.0:
+                scale_center_to_shell_crit_angle_xy = Pi/2.0
+            else:
+                scale_center_to_shell_crit_angle_xy = math.atan(scale_center_to_critpoint_r / scale_center_to_shell_z)
+                if scale_center_to_shell_z < 0.0:
+                    scale_center_to_shell_crit_angle_xy += Pi
+            # angle2
+            if scale_center_to_lowpoint_z == 0.0:
+                scale_center_to_shell_low_angle_xy = Pi/2.0
+            else:
+                scale_center_to_shell_low_angle_xy  = math.atan(scale_center_to_lowpoint_r / scale_center_to_lowpoint_z )
+                if scale_center_to_lowpoint_z < 0.0:
+                    scale_center_to_shell_low_angle_xy += Pi
+
+
             if scale_angle <= scale_center_to_shell_crit_angle_xy:
                 situation = 3
             elif scale_center_to_shell_low_angle_xy <= scale_angle:
@@ -780,8 +829,12 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # shell hits the scaling cylinder with its edge on the edge
             # TODO we have a solution but it can only be found with a root finder -> slow
             # TODO Now we just use the lower bound of the solution.
-            z1_new = min(z1, (ref_to_shell_z - shell_radius))
-            r_new  = min(r,  r1_function(z1_new))
+            if scale_angle <= Pi/4.0:
+                z1_new = min(z1, (ref_to_shell_z - shell_radius))
+                r_new  = min(r,  r1_function(z1_new))
+            else:
+                r_new  = min(r,  (max(ref_to_shell_x - shell_half_length, ref_to_shell_y - shell_radius)))
+                z1_new = min(z1, z1_function(r_new))
 
         elif situation == 3:
             # shell hits the scaling cylinder with its edge on the radial side
@@ -794,6 +847,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             r_new  = min(r,  r1_function(z1_new))
 
         elif situation == 5:
+            # shell hist the scaling cylinder with its round side on the edge of the scaling cylinder.
             shell_radius_sq = shell_radius*shell_radius
 
             ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_y**2)

From 3c4f766acb052181744f851997b79cf49a2601ee Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 2 Apr 2012 15:33:53 +0200
Subject: [PATCH 0747/1541] Two things: -Implemented correct calculation for
 radius/height of cylinder when cylinder edges touch. Previously we used a
 rough estimate  and this breaks the simulator. The calculation is now
 implemented using a root finder, which is slow but at least it now works.
 -Made sure that PlanarSurfaceSingles can overlap with other planes for the
 distance sigma. This because particles  only feel the membranes with their
 COM and not their surface.

---
 egfrd.py  |  2 +-
 shells.py | 48 ++++++++++++++++++++++++++++++++++++++++++++----
 utils.py  |  4 ++++
 3 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b0e0a4d2..edf2b960 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2505,7 +2505,7 @@ def check_domain(self, domain):
             # surfaces.
             ignores = [s.id for s in self.world.structures]
             associated = []
-        elif isinstance(domain, SphericalSingle) or isinstance(domain, SphericalPair):
+        elif isinstance(domain, SphericalSingle) or isinstance(domain, SphericalPair) or isinstance(domain, PlanarSurfaceSingle):
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
diff --git a/shells.py b/shells.py
index 99ad4ad4..f2acdc8c 100755
--- a/shells.py
+++ b/shells.py
@@ -724,9 +724,13 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         ref_to_shell_y2 = ref_to_shell_y - shell_radius
 
         if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
+            # quadrant 1
+#            print "quadrant 1"
             situation = 4
 
         elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
+            # quadrant 2
+#            print "quadrant 2"
             scale_center_to_shell_x -= scale_center_r
             scale_center_to_flatend_x = scale_center_to_shell_x - shell_half_length
             scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
@@ -756,8 +760,12 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 assert scale_center_to_shell_crit_angle_y < scale_angle and \
                        scale_angle < scale_center_to_shell_low_angle_y
                 situation = 2
+                r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
+                h1_min = r1_min/math.tan(scale_angle)
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
+            # quadrant 3
+#            print "quadrant 3"
             scale_center_to_shell_y -= scale_center_r
             scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
             scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
@@ -788,6 +796,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 situation = 5
 
         else:
+            # quadrant 4
+#            print "quadrant 4"
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
 
             scale_center_to_critpoint_r = math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r
@@ -818,7 +828,10 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 assert scale_center_to_shell_crit_angle_xy < scale_angle and \
                        scale_angle < scale_center_to_shell_low_angle_xy
                 situation = 2
+                r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
+                h1_min = r1_min/math.tan(scale_angle)
 
+#        print "situation= ", situation
         #################
         if situation == 1:
             # shell hits the scaling cylinder with its flat surface on the radial side
@@ -828,12 +841,33 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         elif situation == 2:
             # shell hits the scaling cylinder with its edge on the edge
             # TODO we have a solution but it can only be found with a root finder -> slow
-            # TODO Now we just use the lower bound of the solution.
+            tan_scale_angle = math.tan(scale_angle)
+
             if scale_angle <= Pi/4.0:
-                z1_new = min(z1, (ref_to_shell_z - shell_radius))
+                def h1(x):
+#                    print "tan_psi= ", tan_scale_angle
+#                    print "x= ", x
+#                    print "ds= ", scale_center_to_shell_x - shell_half_length
+#                    print "bla= ", (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2
+#                    print "bla1= ", shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2
+                    return x - scale_center_to_shell_z + \
+                           math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2 )
+
+#                print "h1_min= ", h1_min
+#                print "h1_max= ", scale_center_to_shell_z*(1.0-TOLERANCE)
+                h_touch = scale_center_z + findroot(h1, h1_min, scale_center_to_shell_z*(1.0-TOLERANCE))
+#                print "h_touch+ ", h_touch
+                z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
             else:
-                r_new  = min(r,  (max(ref_to_shell_x - shell_half_length, ref_to_shell_y - shell_radius)))
+                def r1(x):
+                    shell_radius_sq = shell_radius**2
+                    return x/tan_scale_angle - scale_center_to_shell_z + \
+                           math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2))**2)
+
+                r_touch = findroot(r1, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
+#                print "r_touch= ", r_touch
+                r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))
 
         elif situation == 3:
@@ -926,8 +960,14 @@ def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
     # determine what parameter of the cylinder (dr of dz) to scale.
     relative_orientation = numpy.dot(orientation_vector, shape.unit_z)
     if feq(relative_orientation, 0):
+
+        distance = testShell.world.distance(shape, reference_point)
+        # FIXME ugly hack to make planar surface singles overlap with membranes
+        if isinstance(testShell, PlanarSurfaceSingletestShell):
+            distance += testShell.pid_particle_pair[1].radius
+
         # The unit_z of the plane is perpendicular to the cylinder -> scale r
-        r = min(r, testShell.world.distance(shape, reference_point))
+        r = min(r, distance)
         z_right = min(z_right, testShell.z_right(r))
         z_left  = min(z_left,  testShell.z_left (r))
 
diff --git a/utils.py b/utils.py
index 33f97b6b..62c04aaa 100644
--- a/utils.py
+++ b/utils.py
@@ -2,6 +2,7 @@
 import math
 import numpy
 import scipy
+import scipy.optimize
 import myrandom
 
 import _gfrd
@@ -258,6 +259,9 @@ def calculate_pair_CoM(pos1, pos2, D1, D2, world_size):
 
 apply_boundary = _gfrd.apply_boundary
 
+def findroot(f, a, b):
+    return scipy.optimize.brentq(f, a, b)
+
 def permutate(seq):
     # permutate a sequence and return a list of the permutations
     if not seq:

From 0245c122d46424659059243f51b6580c7dcb72a3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Apr 2012 18:53:13 +0200
Subject: [PATCH 0748/1541] Fixed some really stupid but well-hidden bug in
 edgetools.py

... and introduced some temporary hacks by Laurens.

Calculation of target surface properties made partly use of origin
surface properties (due to copypasting). This only showed up when
we introduced non-quadratic planes.
---
 edgetools.py | 61 ++++++++++++++++++++++++++++++++++------------------
 shells.py    |  6 +++---
 2 files changed, 43 insertions(+), 24 deletions(-)

diff --git a/edgetools.py b/edgetools.py
index 65d9d0f2..dbeef461 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -71,23 +71,32 @@ def process_new_position_vector(self, oldpos, displacement):
             # either parallel or antiparallel to the parallel unit vector in the origin surface
             d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
             d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
-            # TODO: Remove this temporary debug stuff
-            print("process_new_position_vector")
+            # Construct the new position using the predefined unit vectors of the target surface
+            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
+            new_structure_id = self.target_structure.id
+
+            # FIXME: Remove this temporary debug stuff
+            print("FUNCTION process_new_position_vector")
+            print("Input:")
             print(self.origin_structure.id)
-            print(self.origin_unit_par)
+            print(self.origin_structure.shape.unit_x)
+            print(self.origin_structure.shape.unit_y)
+            print(self.origin_structure.shape.unit_z)
             print(self.origin_unit_perp)
+            print(self.origin_unit_par)
             print(self.target_structure.id)
-            print(self.target_unit_par)
-            print(self.target_unit_perp)
             print(self.target_structure.shape.unit_x)
             print(self.target_structure.shape.unit_y)
             print(self.target_structure.shape.unit_z)
+            print(self.target_unit_perp)
+            print(self.target_unit_par)
+            print("Calculations:")
             print(d_origin_perp)
+            print(d_target_perp)
             print(d_origin_par)
             print(d_target_par)
-            # Construct the new position using the predefined unit vectors of the target surface
-            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            new_structure_id = self.target_structure.id
+            print("Result:")
+            print(newpos)
 
         return newpos, new_structure_id
 
@@ -98,16 +107,9 @@ def get_origin_unit_vectors(self):
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
         w_z = self.target_structure.shape.unit_z
         u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
-        # TODO: DEBUG output, to be removed
+        # FIXME: DEBUG output, to be removed
         if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
-            print("get_origin_unit_vectors")
-            print(self.target_distance)
-            print(self.target_center)
-            print(self.start_position)
-            print(self.target_center - self.start_position)
-            print(w_z)
-            print(u_perp)
-            
+            print("WARNING! u_perp not normalized properly!")            
             
         assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
 
@@ -120,6 +122,20 @@ def get_origin_unit_vectors(self):
              u_par  = u_x
              h_perp = self.origin_half_extent[1] # half_extent in u_y direction
 
+        # FIXME: DEBUG output, to be removed
+        print("FUNCTION get_origin_unit_vectors")
+        print("Calculations:")
+        print(w_z)
+        print(self.target_distance)
+        print(self.target_center)
+        print(self.start_position)
+        print(self.target_center - self.start_position)
+        print(numpy.dot(self.target_center-self.start_position, w_z ))
+        print("Results:")
+        print(u_perp)
+        print(u_par)
+        print(h_perp)
+
         return u_perp, u_par, h_perp
 
     def get_target_unit_vectors(self):
@@ -135,17 +151,20 @@ def get_target_unit_vectors(self):
         w_y = self.target_structure.shape.unit_y
         if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
              w_par = w_y
-             h_perp = self.origin_half_extent[0] # half_extent in w_x direction
+             h_perp = self.target_half_extent[0] # half_extent in w_x direction
         else:
              w_par = w_x
-             h_perp = self.origin_half_extent[1] # half_extent in w_y direction
+             h_perp = self.target_half_extent[1] # half_extent in w_y direction
 
-        # TODO: DEBUG output, to be removed
-        print("get_target_unit_vectors")
+        # FIXME: DEBUG output, to be removed
+        print("FUNCTION get_target_unit_vectors")
+        print("Calculations:")
         print(self.target_center)
         print(w_perp_unnorm)
+        print("Results:")
         print(w_perp)
         print(w_par)
+        print(h_perp)
 
         return w_perp, w_par, h_perp
 
diff --git a/shells.py b/shells.py
index f2acdc8c..1632c390 100755
--- a/shells.py
+++ b/shells.py
@@ -449,7 +449,7 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     orientation_vector = testShell.get_orientation_vector()
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
-    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
+#    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
 
     # determine on what side the midpoint of the shell is relative to the reference_point
     shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
@@ -602,7 +602,7 @@ def get_radius_to_SphericalShape(shape, testShell, r):
     r_new = testShell.world.distance(shape, scale_point)
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
-    r_new = min(r_new, testShell.world.distance(shape.position, scale_point)/2)
+#    r_new = min(r_new, testShell.world.distance(shape.position, scale_point)/2)
 
     # if the newly calculated dimensions are smaller than the current one, use them
     return min(r, r_new)
@@ -629,7 +629,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     orientation_vector = testShell.get_orientation_vector()
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
-    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
+#    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
 
     # determine on what side the midpoint of the shell is relative to the reference_point
     shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)

From e44e8912e580fa654ac7245e72db03de0c7a1833 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Apr 2012 19:00:04 +0200
Subject: [PATCH 0749/1541] Basic definition of generalized transform function
 in C++

... not really exciting yet.
---
 Plane.hpp         | 14 ++++++++++++++
 binding/Plane.hpp |  3 ++-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/Plane.hpp b/Plane.hpp
index a9b7a900..a9389790 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -260,6 +260,20 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
     }
 }
 
+template<typename T_>
+inline typename Plane<T_>::position_type
+deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& r1)
+// Calculates the distance from 'pos' to plane 'obj' Note that when the plane is finite,
+// and also calculates the distance to the edge of the plane if necessary
+{
+   typedef typename Plane<T_>::length_type length_type;
+   boost::array<length_type, 3> const x_y_z_0(to_internal(obj, r0));
+   boost::array<length_type, 3> const x_y_z_1(to_internal(obj, r1));
+   
+   // for now this returns the new position without changes
+   return x_y_z_1;
+}
+
 template<typename T, typename Trng>
 inline typename Plane<T>::position_type
 random_position(Plane<T> const& shape, Trng& rng)
diff --git a/binding/Plane.hpp b/binding/Plane.hpp
index c341e5c3..0350d99e 100644
--- a/binding/Plane.hpp
+++ b/binding/Plane.hpp
@@ -102,7 +102,8 @@ inline boost::python::objects::class_base register_plane_class(char const* name)
                     typename impl_type::position_type,
                     &impl_type::unit_z,
                     &impl_type::unit_z>::set));
-
+     // .add_property("deflect",
+                        
 }
 
 } // namespace binding

From d1f17b826227f11219b00baa86824a49cba26a08 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Apr 2012 18:53:13 +0200
Subject: [PATCH 0750/1541] Fixed some really stupid but well-hidden bug in
 edgetools.py

... and introduced some temporary hacks by Laurens.

Calculation of target surface properties made partly use of origin
surface properties (due to copypasting). This only showed up when
we introduced non-quadratic planes.
---
 edgetools.py | 61 ++++++++++++++++++++++++++++++++++------------------
 shells.py    |  6 +++---
 2 files changed, 43 insertions(+), 24 deletions(-)

diff --git a/edgetools.py b/edgetools.py
index 65d9d0f2..dbeef461 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -71,23 +71,32 @@ def process_new_position_vector(self, oldpos, displacement):
             # either parallel or antiparallel to the parallel unit vector in the origin surface
             d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
             d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
-            # TODO: Remove this temporary debug stuff
-            print("process_new_position_vector")
+            # Construct the new position using the predefined unit vectors of the target surface
+            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
+            new_structure_id = self.target_structure.id
+
+            # FIXME: Remove this temporary debug stuff
+            print("FUNCTION process_new_position_vector")
+            print("Input:")
             print(self.origin_structure.id)
-            print(self.origin_unit_par)
+            print(self.origin_structure.shape.unit_x)
+            print(self.origin_structure.shape.unit_y)
+            print(self.origin_structure.shape.unit_z)
             print(self.origin_unit_perp)
+            print(self.origin_unit_par)
             print(self.target_structure.id)
-            print(self.target_unit_par)
-            print(self.target_unit_perp)
             print(self.target_structure.shape.unit_x)
             print(self.target_structure.shape.unit_y)
             print(self.target_structure.shape.unit_z)
+            print(self.target_unit_perp)
+            print(self.target_unit_par)
+            print("Calculations:")
             print(d_origin_perp)
+            print(d_target_perp)
             print(d_origin_par)
             print(d_target_par)
-            # Construct the new position using the predefined unit vectors of the target surface
-            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            new_structure_id = self.target_structure.id
+            print("Result:")
+            print(newpos)
 
         return newpos, new_structure_id
 
@@ -98,16 +107,9 @@ def get_origin_unit_vectors(self):
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
         w_z = self.target_structure.shape.unit_z
         u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
-        # TODO: DEBUG output, to be removed
+        # FIXME: DEBUG output, to be removed
         if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
-            print("get_origin_unit_vectors")
-            print(self.target_distance)
-            print(self.target_center)
-            print(self.start_position)
-            print(self.target_center - self.start_position)
-            print(w_z)
-            print(u_perp)
-            
+            print("WARNING! u_perp not normalized properly!")            
             
         assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
 
@@ -120,6 +122,20 @@ def get_origin_unit_vectors(self):
              u_par  = u_x
              h_perp = self.origin_half_extent[1] # half_extent in u_y direction
 
+        # FIXME: DEBUG output, to be removed
+        print("FUNCTION get_origin_unit_vectors")
+        print("Calculations:")
+        print(w_z)
+        print(self.target_distance)
+        print(self.target_center)
+        print(self.start_position)
+        print(self.target_center - self.start_position)
+        print(numpy.dot(self.target_center-self.start_position, w_z ))
+        print("Results:")
+        print(u_perp)
+        print(u_par)
+        print(h_perp)
+
         return u_perp, u_par, h_perp
 
     def get_target_unit_vectors(self):
@@ -135,17 +151,20 @@ def get_target_unit_vectors(self):
         w_y = self.target_structure.shape.unit_y
         if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
              w_par = w_y
-             h_perp = self.origin_half_extent[0] # half_extent in w_x direction
+             h_perp = self.target_half_extent[0] # half_extent in w_x direction
         else:
              w_par = w_x
-             h_perp = self.origin_half_extent[1] # half_extent in w_y direction
+             h_perp = self.target_half_extent[1] # half_extent in w_y direction
 
-        # TODO: DEBUG output, to be removed
-        print("get_target_unit_vectors")
+        # FIXME: DEBUG output, to be removed
+        print("FUNCTION get_target_unit_vectors")
+        print("Calculations:")
         print(self.target_center)
         print(w_perp_unnorm)
+        print("Results:")
         print(w_perp)
         print(w_par)
+        print(h_perp)
 
         return w_perp, w_par, h_perp
 
diff --git a/shells.py b/shells.py
index f2acdc8c..1632c390 100755
--- a/shells.py
+++ b/shells.py
@@ -449,7 +449,7 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     orientation_vector = testShell.get_orientation_vector()
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
-    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
+#    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
 
     # determine on what side the midpoint of the shell is relative to the reference_point
     shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
@@ -602,7 +602,7 @@ def get_radius_to_SphericalShape(shape, testShell, r):
     r_new = testShell.world.distance(shape, scale_point)
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
-    r_new = min(r_new, testShell.world.distance(shape.position, scale_point)/2)
+#    r_new = min(r_new, testShell.world.distance(shape.position, scale_point)/2)
 
     # if the newly calculated dimensions are smaller than the current one, use them
     return min(r, r_new)
@@ -629,7 +629,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     orientation_vector = testShell.get_orientation_vector()
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
-    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
+#    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
 
     # determine on what side the midpoint of the shell is relative to the reference_point
     shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)

From 3452fe32b982f5e6ac99430b1ea41603a62b45ec Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Apr 2012 14:50:39 +0200
Subject: [PATCH 0751/1541] removed old (commented out) code and print
 statements

---
 edgetools.py | 54 +-------------------------------------------------
 shells.py    | 17 ----------------
 single.py    | 56 ----------------------------------------------------
 3 files changed, 1 insertion(+), 126 deletions(-)

diff --git a/edgetools.py b/edgetools.py
index dbeef461..37f9535e 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -75,29 +75,6 @@ def process_new_position_vector(self, oldpos, displacement):
             newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
             new_structure_id = self.target_structure.id
 
-            # FIXME: Remove this temporary debug stuff
-            print("FUNCTION process_new_position_vector")
-            print("Input:")
-            print(self.origin_structure.id)
-            print(self.origin_structure.shape.unit_x)
-            print(self.origin_structure.shape.unit_y)
-            print(self.origin_structure.shape.unit_z)
-            print(self.origin_unit_perp)
-            print(self.origin_unit_par)
-            print(self.target_structure.id)
-            print(self.target_structure.shape.unit_x)
-            print(self.target_structure.shape.unit_y)
-            print(self.target_structure.shape.unit_z)
-            print(self.target_unit_perp)
-            print(self.target_unit_par)
-            print("Calculations:")
-            print(d_origin_perp)
-            print(d_target_perp)
-            print(d_origin_par)
-            print(d_target_par)
-            print("Result:")
-            print(newpos)
-
         return newpos, new_structure_id
 
     def get_origin_unit_vectors(self):
@@ -107,11 +84,7 @@ def get_origin_unit_vectors(self):
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
         w_z = self.target_structure.shape.unit_z
         u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
-        # FIXME: DEBUG output, to be removed
-        if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
-            print("WARNING! u_perp not normalized properly!")            
-            
-        assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
+        assert feq( length(u_perp), 1.0) 
 
         u_x = self.origin_structure.shape.unit_x
         u_y = self.origin_structure.shape.unit_y
@@ -122,20 +95,6 @@ def get_origin_unit_vectors(self):
              u_par  = u_x
              h_perp = self.origin_half_extent[1] # half_extent in u_y direction
 
-        # FIXME: DEBUG output, to be removed
-        print("FUNCTION get_origin_unit_vectors")
-        print("Calculations:")
-        print(w_z)
-        print(self.target_distance)
-        print(self.target_center)
-        print(self.start_position)
-        print(self.target_center - self.start_position)
-        print(numpy.dot(self.target_center-self.start_position, w_z ))
-        print("Results:")
-        print(u_perp)
-        print(u_par)
-        print(h_perp)
-
         return u_perp, u_par, h_perp
 
     def get_target_unit_vectors(self):
@@ -156,16 +115,6 @@ def get_target_unit_vectors(self):
              w_par = w_x
              h_perp = self.target_half_extent[1] # half_extent in w_y direction
 
-        # FIXME: DEBUG output, to be removed
-        print("FUNCTION get_target_unit_vectors")
-        print("Calculations:")
-        print(self.target_center)
-        print(w_perp_unnorm)
-        print("Results:")
-        print(w_perp)
-        print(w_par)
-        print(h_perp)
-
         return w_perp, w_par, h_perp
 
     def get_edge_point(self):
@@ -173,4 +122,3 @@ def get_edge_point(self):
         ep = self.start_position + (self.target_distance * self.origin_unit_perp)
         return ep
 
-
diff --git a/shells.py b/shells.py
index 1632c390..6f900410 100755
--- a/shells.py
+++ b/shells.py
@@ -183,16 +183,12 @@ def __init__(self, single, target_structure):
 
         assert (self.structure.sid == target_structure.sid)     # Both structures are of same structure_type
         self.single = single
-#        self.structure = single.structure
 
         self.origin_structure = self.structure
         self.target_structure = target_structure
 
         # Note that we assume the structures are exactly connecting
         self.distance_to_target_structure = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
-#        self.pid_particle_pair = single.pid_particle_pair
-#        self.particle = single.pid_particle_pair[1]
-#        self.single_radius = self.particle.radius
 
 ##############
 class testPair(Others):
@@ -845,18 +841,10 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
             if scale_angle <= Pi/4.0:
                 def h1(x):
-#                    print "tan_psi= ", tan_scale_angle
-#                    print "x= ", x
-#                    print "ds= ", scale_center_to_shell_x - shell_half_length
-#                    print "bla= ", (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2
-#                    print "bla1= ", shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2
                     return x - scale_center_to_shell_z + \
                            math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2 )
 
-#                print "h1_min= ", h1_min
-#                print "h1_max= ", scale_center_to_shell_z*(1.0-TOLERANCE)
                 h_touch = scale_center_z + findroot(h1, h1_min, scale_center_to_shell_z*(1.0-TOLERANCE))
-#                print "h_touch+ ", h_touch
                 z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
             else:
@@ -866,7 +854,6 @@ def r1(x):
                            math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2))**2)
 
                 r_touch = findroot(r1, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
-#                print "r_touch= ", r_touch
                 r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))
 
@@ -1162,7 +1149,6 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
                                  (str(e)))
 
     def get_min_radius(self):
-#        min_offset = self.single_radius#*(SINGLE_SHELL_FACTOR - 1.0)
         # The minimal shell size also deterimines the minimal radius of the later 2D domain.
         # min_offset here is the minimal length that the circular 2D domain protrudes into
         # the target surface. Make sure that min_offset > 0.0, because only then it is
@@ -1170,9 +1156,6 @@ def get_min_radius(self):
         # if the shell with minimal radius is constructed
         return self.distance_to_target_structure + self.pid_particle_pair[1].radius
 
-#    def get_distance_to_target_structure(self):
-#        distance = self.world.distance(self.target_structure.shape, self.center)
-#        return distance
 
 ##########################
 class CylindricaltestShell(testShell):
diff --git a/single.py b/single.py
index 3b5831f9..62c83231 100644
--- a/single.py
+++ b/single.py
@@ -174,8 +174,6 @@ def __init__(self, domain_id, shell_id, reactionrules):
         # Note: for the NonInteractionSingles superclass nothing is to be initialized.
 
     def initialize(self, t):
-#        self.dt = 0.0
-#        self.last_time = t
         Single.initialize(self, t)
         self.event_type = EventType.SINGLE_ESCAPE
 
@@ -388,9 +386,7 @@ def shell_list_for_other(self):
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR     # The burst radius
-#            half_length = self.shell.shape.half_length
             # keep everything at a burstradius distance
-#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
             fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
             return [(self.shell_id, fake_shell), ]
         else:
@@ -496,7 +492,6 @@ def shell_list_for_other(self):
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
             radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-#            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
             # Keep all the other shells outside the burst radius (which is spherical!)
             # Note that this makes the cylindrical shell have a slightly smaller radius than the burst radius.
             fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
@@ -614,13 +609,6 @@ def get_inner_dz_left(self):
     def get_inner_dz_right(self):
         pass
 
-#    def initialize(self, t):    
-#        # initialize the domain object with the appropriate time to allow reuse of
-#        # the Domain at different times
-#        self.dt = 0
-#        self.last_time = t
-#        self.event_type = None
-
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
@@ -980,20 +968,6 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         EdgeTools.__init__(self, testShell, self.pid_particle_pair[1].position)
         # Note: for the Others superclass nothing is to be initialized.
 
-#        self.pid_particle_pair = testShell.single.pid_particle_pair # is that necessary??
-
-        # That was part of the HACK, so we keep it now and remove it later when everything works
-        # origin_structure and target_structure are inherited from testShell via EdgeTools
-#        self.structure = self.origin_structure
-#        self.surface = self.target_structure
-
-#    def initialize(self, t):    
-#        # initialize the domain object with the appropriate time to allow reuse of
-#        # the Domain at different times
-#        self.dt = 0
-#        self.last_time = t
-#        self.event_type = None
-
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
@@ -1020,10 +994,6 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         hasSphericalShell.__init__(self, testShell, domain_id)
         TransitionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules)
 
-        # This has to be set because external functions will use it
-        # FIXME: Check whether this is still needed!
-#        self.structure = self.origin_structure
-#        self.surface = self.target_structure
 
     # The same Greens function is used as for the normal PlanarSurfaceSingle;
     # If the position is off the surface of origin, it will be transformed towards the target surface
@@ -1031,7 +1001,6 @@ def greens_function(self):
         return GreensFunction2DAbsSym(self.D, self.get_inner_a())
 
     def draw_new_position(self, dt, event_type):
-#        oldpos = self.start_position
         oldpos = self.pid_particle_pair[1].position
 
         if self.D == 0:
@@ -1069,31 +1038,6 @@ def create_position_vector(self, r):
         x, y = random_vector2D(r)
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
-#    # copied from SphericalSingle
-#    # these return potentially corrected dimensions
-#    # For explanation see NonInteractionSingles and Others in shells.py
-#    def shell_list_for_single(self):
-#        # make sure that there is at least space for the multi shell
-#        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-#        if  self.shell.shape.radius < min_radius:
-#            position = self.shell.shape.position
-#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-#            # TODO maybe just returning the dimension instead of actually making the shell is cheaper.
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-#
-#    def shell_list_for_other(self):
-#        # keeps all the other domains at a distance of the burst radius
-#        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-#        if self.shell.shape.radius < min_radius:
-#            position = self.shell.shape.position
-#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-
-
     def __str__(self):
         return 'PlanarSurfaceTransition' + Single.__str__(self)
 

From c6f6fb1efcb4eff5b0bb3dce0e87c8f793dcbd60 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Apr 2012 14:50:39 +0200
Subject: [PATCH 0752/1541] removed old (commented out) code and print
 statements

---
 edgetools.py                                |  54 +------
 samples/finite_planes_hack/finite_planes.py | 158 --------------------
 shells.py                                   |  17 ---
 single.py                                   |  56 -------
 4 files changed, 1 insertion(+), 284 deletions(-)
 delete mode 100755 samples/finite_planes_hack/finite_planes.py

diff --git a/edgetools.py b/edgetools.py
index dbeef461..37f9535e 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -75,29 +75,6 @@ def process_new_position_vector(self, oldpos, displacement):
             newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
             new_structure_id = self.target_structure.id
 
-            # FIXME: Remove this temporary debug stuff
-            print("FUNCTION process_new_position_vector")
-            print("Input:")
-            print(self.origin_structure.id)
-            print(self.origin_structure.shape.unit_x)
-            print(self.origin_structure.shape.unit_y)
-            print(self.origin_structure.shape.unit_z)
-            print(self.origin_unit_perp)
-            print(self.origin_unit_par)
-            print(self.target_structure.id)
-            print(self.target_structure.shape.unit_x)
-            print(self.target_structure.shape.unit_y)
-            print(self.target_structure.shape.unit_z)
-            print(self.target_unit_perp)
-            print(self.target_unit_par)
-            print("Calculations:")
-            print(d_origin_perp)
-            print(d_target_perp)
-            print(d_origin_par)
-            print(d_target_par)
-            print("Result:")
-            print(newpos)
-
         return newpos, new_structure_id
 
     def get_origin_unit_vectors(self):
@@ -107,11 +84,7 @@ def get_origin_unit_vectors(self):
         # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
         w_z = self.target_structure.shape.unit_z
         u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
-        # FIXME: DEBUG output, to be removed
-        if not feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0):
-            print("WARNING! u_perp not normalized properly!")            
-            
-        assert feq(numpy.sqrt(numpy.dot(u_perp, u_perp)), 1.0)
+        assert feq( length(u_perp), 1.0) 
 
         u_x = self.origin_structure.shape.unit_x
         u_y = self.origin_structure.shape.unit_y
@@ -122,20 +95,6 @@ def get_origin_unit_vectors(self):
              u_par  = u_x
              h_perp = self.origin_half_extent[1] # half_extent in u_y direction
 
-        # FIXME: DEBUG output, to be removed
-        print("FUNCTION get_origin_unit_vectors")
-        print("Calculations:")
-        print(w_z)
-        print(self.target_distance)
-        print(self.target_center)
-        print(self.start_position)
-        print(self.target_center - self.start_position)
-        print(numpy.dot(self.target_center-self.start_position, w_z ))
-        print("Results:")
-        print(u_perp)
-        print(u_par)
-        print(h_perp)
-
         return u_perp, u_par, h_perp
 
     def get_target_unit_vectors(self):
@@ -156,16 +115,6 @@ def get_target_unit_vectors(self):
              w_par = w_x
              h_perp = self.target_half_extent[1] # half_extent in w_y direction
 
-        # FIXME: DEBUG output, to be removed
-        print("FUNCTION get_target_unit_vectors")
-        print("Calculations:")
-        print(self.target_center)
-        print(w_perp_unnorm)
-        print("Results:")
-        print(w_perp)
-        print(w_par)
-        print(h_perp)
-
         return w_perp, w_par, h_perp
 
     def get_edge_point(self):
@@ -173,4 +122,3 @@ def get_edge_point(self):
         ep = self.start_position + (self.target_distance * self.origin_unit_perp)
         return ep
 
-
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
deleted file mode 100755
index e5709295..00000000
--- a/samples/finite_planes_hack/finite_planes.py
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/python
-
-# Small script to test transfers between membranes
-#
-# Make sure that the egfrd system is added to your PYTHONPATH
-# This means, in bash for example:
-# $ export PYTHONPATH=$HOME/egfrd
-
-# Modules
-# ===============================
-import sys
-import os
-import datetime
-
-from egfrd import *
-from visualization import vtklogger
-
-import model
-import gfrdbase
-import _gfrd
-
-
-# Unique seed
-# ===============================
-currenttime = (long(
-datetime.datetime.now().month*30.5*24*3600*1e6+
-datetime.datetime.now().day*24*3600*1e6+datetime.datetime.now().hour*3600*1e6+
-datetime.datetime.now().minute*60*1e6+datetime.datetime.now().second*1e6+
-datetime.datetime.now().microsecond))
-#myrandom.seed(currenttime)
-
-myrandom.seed(523) # 323 for 3 part., 523 for one is good
-print "(Seed " + str(currenttime) + ")"
- 
-
-# Constants
-# ===============================
-#logging = True
-logging = False
-sigma = 1e-8        # Diameter particle
-DC = 1e-13           # Diffusion constant
-N = 1000           # Number of steps simulation will last
-world_size = 1e-6   # Lengths of simulation box
-Nparticles = 1     # Number of particles in the simulation
-k = 2e-14           # Reaction constant
-
-# VTK Logger
-# ===============================
-if (logging == True):
-    vtk_output_directory = 'VTK_out'
-    if (os.path.exists(vtk_output_directory)):
-        print '** WARNING: VTK output directory already exists, possible '+ \
-                'present old VTK files might lead to errors.'
-
-
-# Basic set up simulator
-# ===============================
-# Model
-m = model.ParticleModel(2.01*world_size)
-
-# Planes ("membranes")
-membrane_type = _gfrd.StructureType()
-membrane_type['name'] = 'membrane_type'
-
-m.add_structure_type(membrane_type)
-
-# Species
-A = model.Species('A', DC, sigma, membrane_type)
-m.add_species_type(A)
-B = model.Species('B', DC, sigma, membrane_type)
-m.add_species_type(B)
-C = model.Species('C', DC, sigma, membrane_type)
-m.add_species_type(C)
-D = model.Species('D', DC, sigma, membrane_type)
-m.add_species_type(D)
-E = model.Species('E', DC, sigma, membrane_type)
-m.add_species_type(E)
-F = model.Species('F', DC, sigma, membrane_type)
-m.add_species_type(F)
-
-Statist = model.Species('Statist', 0.0, 10.0*sigma)
-m.add_species_type(Statist)
-
-# World
-w = gfrdbase.create_world(m, 3)
-
-# Create instances of membrane types
-membraneA = model.create_planar_surface(membrane_type.id, 'name1', [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
-w.add_structure(membraneA)
-membraneB = model.create_planar_surface(membrane_type.id, 'name2', [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
-w.add_structure(membraneB)
-membraneC = model.create_planar_surface(membrane_type.id, 'name3', [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
-w.add_structure(membraneC)
-membraneD = model.create_planar_surface(membrane_type.id, 'name4', [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
-w.add_structure(membraneD)
-membraneE = model.create_planar_surface(membrane_type.id, 'name5', [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
-w.add_structure(membraneE)
-membraneF = model.create_planar_surface(membrane_type.id, 'name6', [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
-w.add_structure(membraneF)
-
-print("Membrane A : unit_z = " + str(membraneA.shape.unit_z))
-print("Membrane B : unit_z = " + str(membraneB.shape.unit_z))
-print("Membrane C : unit_z = " + str(membraneC.shape.unit_z))
-print("Membrane D : unit_z = " + str(membraneD.shape.unit_z))
-print("Membrane E : unit_z = " + str(membraneE.shape.unit_z))
-print("Membrane F : unit_z = " + str(membraneF.shape.unit_z))
-
-
-# Simulator
-s = EGFRDSimulator(w, myrandom.rng)
-
-# Set up logger
-if (logging == True):
-    l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
-
-# Throw in particles
-place_particle(w, A, [world_size/2, world_size/2, 0])  # place one particle on membraneA
-#place_particle(w, A, [world_size/4, world_size/4, 0])  # place one particle on membraneA
-#place_particle(w, A, [3*world_size/4, 3*world_size/4, 0])  # place one particle on membraneA
-
-# Statist particles in the corners of the system
-# does not really work because they intersect with membranes...
-#place_particle(w, Statist, [0, 0, 0])
-#place_particle(w, Statist, [world_size, 0, 0])
-#place_particle(w, Statist, [0, world_size, 0])
-#place_particle(w, Statist, [0, 0, world_size])
-#place_particle(w, Statist, [0, world_size, world_size])
-#place_particle(w, Statist, [world_size, 0, world_size])
-#place_particle(w, Statist, [world_size, world_size, 0])
-#place_particle(w, Statist, [world_size, world_size, world_size])
-
-
-#throw_in_particles(w, A, Nparticles) # THIS DOES NOT WORK BECAUSE PARTICLES INTERSECT WITH PLANES YET!
-#throw_in_particles(w, B, Nparticles)
-
-# Running 2
-# ===============================
-for t in range(N):
-
-    # if logging, log and also use "try statement"
-    if (logging == True): 
-        # take a step (but ignore errors)
-        try:
-            s.step()
-        except:
-            print "Broken (run with logging=False for errormessage)!"
-            break
-        # log the step
-        l.log()
-    # otherwise just make steps.
-    else:
-        s.step()
-
-s.stop(s.t)
-
-if (logging == True):
-    l.stop()
-
diff --git a/shells.py b/shells.py
index 1632c390..6f900410 100755
--- a/shells.py
+++ b/shells.py
@@ -183,16 +183,12 @@ def __init__(self, single, target_structure):
 
         assert (self.structure.sid == target_structure.sid)     # Both structures are of same structure_type
         self.single = single
-#        self.structure = single.structure
 
         self.origin_structure = self.structure
         self.target_structure = target_structure
 
         # Note that we assume the structures are exactly connecting
         self.distance_to_target_structure = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
-#        self.pid_particle_pair = single.pid_particle_pair
-#        self.particle = single.pid_particle_pair[1]
-#        self.single_radius = self.particle.radius
 
 ##############
 class testPair(Others):
@@ -845,18 +841,10 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
             if scale_angle <= Pi/4.0:
                 def h1(x):
-#                    print "tan_psi= ", tan_scale_angle
-#                    print "x= ", x
-#                    print "ds= ", scale_center_to_shell_x - shell_half_length
-#                    print "bla= ", (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2
-#                    print "bla1= ", shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2
                     return x - scale_center_to_shell_z + \
                            math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2 )
 
-#                print "h1_min= ", h1_min
-#                print "h1_max= ", scale_center_to_shell_z*(1.0-TOLERANCE)
                 h_touch = scale_center_z + findroot(h1, h1_min, scale_center_to_shell_z*(1.0-TOLERANCE))
-#                print "h_touch+ ", h_touch
                 z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
             else:
@@ -866,7 +854,6 @@ def r1(x):
                            math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2))**2)
 
                 r_touch = findroot(r1, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
-#                print "r_touch= ", r_touch
                 r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))
 
@@ -1162,7 +1149,6 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
                                  (str(e)))
 
     def get_min_radius(self):
-#        min_offset = self.single_radius#*(SINGLE_SHELL_FACTOR - 1.0)
         # The minimal shell size also deterimines the minimal radius of the later 2D domain.
         # min_offset here is the minimal length that the circular 2D domain protrudes into
         # the target surface. Make sure that min_offset > 0.0, because only then it is
@@ -1170,9 +1156,6 @@ def get_min_radius(self):
         # if the shell with minimal radius is constructed
         return self.distance_to_target_structure + self.pid_particle_pair[1].radius
 
-#    def get_distance_to_target_structure(self):
-#        distance = self.world.distance(self.target_structure.shape, self.center)
-#        return distance
 
 ##########################
 class CylindricaltestShell(testShell):
diff --git a/single.py b/single.py
index 3b5831f9..62c83231 100644
--- a/single.py
+++ b/single.py
@@ -174,8 +174,6 @@ def __init__(self, domain_id, shell_id, reactionrules):
         # Note: for the NonInteractionSingles superclass nothing is to be initialized.
 
     def initialize(self, t):
-#        self.dt = 0.0
-#        self.last_time = t
         Single.initialize(self, t)
         self.event_type = EventType.SINGLE_ESCAPE
 
@@ -388,9 +386,7 @@ def shell_list_for_other(self):
         if self.shell.shape.radius < min_radius:
             position = self.shell.shape.position
             radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR     # The burst radius
-#            half_length = self.shell.shape.half_length
             # keep everything at a burstradius distance
-#            fake_shell = self.create_new_shell(position, min_radius, half_length, self.domain_id)
             fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
             return [(self.shell_id, fake_shell), ]
         else:
@@ -496,7 +492,6 @@ def shell_list_for_other(self):
         if self.shell.shape.half_length < min_half_length:
             position = self.shell.shape.position
             radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-#            fake_shell = self.create_new_shell(position, radius, min_half_length, self.domain_id)
             # Keep all the other shells outside the burst radius (which is spherical!)
             # Note that this makes the cylindrical shell have a slightly smaller radius than the burst radius.
             fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
@@ -614,13 +609,6 @@ def get_inner_dz_left(self):
     def get_inner_dz_right(self):
         pass
 
-#    def initialize(self, t):    
-#        # initialize the domain object with the appropriate time to allow reuse of
-#        # the Domain at different times
-#        self.dt = 0
-#        self.last_time = t
-#        self.event_type = None
-
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
@@ -980,20 +968,6 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         EdgeTools.__init__(self, testShell, self.pid_particle_pair[1].position)
         # Note: for the Others superclass nothing is to be initialized.
 
-#        self.pid_particle_pair = testShell.single.pid_particle_pair # is that necessary??
-
-        # That was part of the HACK, so we keep it now and remove it later when everything works
-        # origin_structure and target_structure are inherited from testShell via EdgeTools
-#        self.structure = self.origin_structure
-#        self.surface = self.target_structure
-
-#    def initialize(self, t):    
-#        # initialize the domain object with the appropriate time to allow reuse of
-#        # the Domain at different times
-#        self.dt = 0
-#        self.last_time = t
-#        self.event_type = None
-
     def determine_next_event(self):
         """Return an (event time, event type)-tuple.
 
@@ -1020,10 +994,6 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules):
         hasSphericalShell.__init__(self, testShell, domain_id)
         TransitionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules)
 
-        # This has to be set because external functions will use it
-        # FIXME: Check whether this is still needed!
-#        self.structure = self.origin_structure
-#        self.surface = self.target_structure
 
     # The same Greens function is used as for the normal PlanarSurfaceSingle;
     # If the position is off the surface of origin, it will be transformed towards the target surface
@@ -1031,7 +1001,6 @@ def greens_function(self):
         return GreensFunction2DAbsSym(self.D, self.get_inner_a())
 
     def draw_new_position(self, dt, event_type):
-#        oldpos = self.start_position
         oldpos = self.pid_particle_pair[1].position
 
         if self.D == 0:
@@ -1069,31 +1038,6 @@ def create_position_vector(self, r):
         x, y = random_vector2D(r)
         return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
 
-#    # copied from SphericalSingle
-#    # these return potentially corrected dimensions
-#    # For explanation see NonInteractionSingles and Others in shells.py
-#    def shell_list_for_single(self):
-#        # make sure that there is at least space for the multi shell
-#        min_radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
-#        if  self.shell.shape.radius < min_radius:
-#            position = self.shell.shape.position
-#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-#            # TODO maybe just returning the dimension instead of actually making the shell is cheaper.
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-#
-#    def shell_list_for_other(self):
-#        # keeps all the other domains at a distance of the burst radius
-#        min_radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-#        if self.shell.shape.radius < min_radius:
-#            position = self.shell.shape.position
-#            fake_shell = self.create_new_shell(position, min_radius, self.domain_id)
-#            return [(self.shell_id, fake_shell), ]
-#        else:
-#            return self.shell_list
-
-
     def __str__(self):
         return 'PlanarSurfaceTransition' + Single.__str__(self)
 

From 98d40c4b7d2d1b9f41913e7657c409bbeff4b3a7 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <wehrens@bionet3.amolf.nl>
Date: Tue, 3 Apr 2012 18:52:12 +0200
Subject: [PATCH 0753/1541] Clearifies comment.

---
 dumper.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/dumper.py b/dumper.py
index 3d9ba629..5193dea1 100644
--- a/dumper.py
+++ b/dumper.py
@@ -116,7 +116,9 @@ def get_particles(sim, identifier=None):
             all (particle identifier, particle)-pairs will be returned.
 
     """
-# TODO: Gillespie simulator should be legacy; remove
+# TODO: Code below leads to crash in some situations, currently
+#       Gillespie simulator is not implemented, so code can be
+#       left out.
 #    if isinstance(sim, GillespieSimulator):
 #        raise RuntimeError('GillespieSimulator does not keep track '
 #                           'of individual particles.')

From f5fceb8fd26330d8da8db46fc461a6626fab5805 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Apr 2012 19:01:50 +0200
Subject: [PATCH 0754/1541] typo

---
 shells.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index ca6c2956..20f57c15 100755
--- a/shells.py
+++ b/shells.py
@@ -291,8 +291,8 @@ class testMixedPair2D3D(testPair):
     def __init__(self, single2D, single3D):
 
         if __debug__: 
-		assert isinstance(single2D.structure, PlanarSurface) 
-        	assert isinstance(single3D.structure, CuboidalRegion) 
+            assert isinstance(single2D.structure, PlanarSurface) 
+            assert isinstance(single3D.structure, CuboidalRegion) 
         self.surface   = single2D.structure         # note that these need to be initialized before calling testPair.__init__
         self.structure = single3D.structure         # since then these are needed for calculating the transform
 

From dbbc18814c4c9a611b4db376a2f1625669b4674f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 3 Apr 2012 19:21:55 +0200
Subject: [PATCH 0755/1541] added comments and minor change

---
 newBDPropagator.hpp | 40 ++++++++++++++++++++++++++--------------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 7c6fe54f..d3e32171 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -59,6 +59,7 @@ class newBDPropagator
     typedef std::pair<position_type, length_type>                   projected_type;
 
 public:
+    // The constructor
     template<typename Trange_>
     newBDPropagator(
         particle_container_type& tx, network_rules_type const& rules,
@@ -81,6 +82,9 @@ class newBDPropagator
         shuffle(rng, queue_);
     }
 
+    // This method is called to process the change of position and putative reaction of every particle.
+    // The method only treats one particle at a time and returns 'True' as long as there are still particles
+    //    in the container that need to be processed.
     bool operator()()
     {
         if (queue_.empty())
@@ -120,11 +124,12 @@ class newBDPropagator
            to it's original position. For a particle with D = 0, new_pos = old_pos */        
         if (pp_species.D() != 0.)
         {
-            // Make a step, dependent on the surface the particle lives on.
+            // get a new position, dependent on the structure the particle lives on.
             position_type const displacement( pp_structure->
-                                            bd_displacement(pp_species.v() * dt_, std::sqrt(2.0 * pp_species.D() * dt_), rng_) );
+                                              bd_displacement(pp_species.v() * dt_, std::sqrt(2.0 * pp_species.D() * dt_), rng_) );
 
             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
+            // TODO check if the new position is actually still in the structure
         }
         else
         {
@@ -132,7 +137,7 @@ class newBDPropagator
         }
         
         /* Use a spherical shape with radius = particle_radius + reaction_length.
-	       We use it to check for overlaps with other particels. */
+	       We use it to check for overlaps with other particles. */
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                 tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
         int particles_in_overlap(overlapped ? overlapped->size(): 0);
@@ -145,6 +150,7 @@ class newBDPropagator
         
         /* If the particle has not bounced with another particle and lives in the bulk: 
            check for core overlap with a surface. */
+        // TODO maybe always check for overlaps with surface ignoring its own surface? (regardless of in bulk)
         if(!bounced && pp.second.structure_id() == tx_.get_def_structure_id())
         {
             struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp.second.structure_id());
@@ -182,21 +188,20 @@ class newBDPropagator
         Real accumulated_prob = 0;
         Real const rnd( rng_() );
         
-        /* First, if a surface is inside the reaction volume, attempt an interaction. */
+        /* First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction. */
+        // TODO also interaction should be allowed when a particle is on a cylinder.
         if( pp.second.structure_id() == tx_.get_def_structure_id())
         {
-            if( tx_.get_structure( struct_id_distance_pair.first )->
-                in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
+            boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure( struct_id_distance_pair.first) );
+
+            if( closest_surf->in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
             {        
-                boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure( struct_id_distance_pair.first) );
-                
                 accumulated_prob += k_total( pp.second.sid(), closest_surf->sid() ) * dt_ / 
-                    closest_surf->surface_reaction_volume( r0, reaction_length_ );
+                                    closest_surf->surface_reaction_volume( r0, reaction_length_ );
         
                 if(accumulated_prob >= 1.)
                 {
-                    LOG_WARNING((
-                                 "the acceptance probability of an interaction exeeded one; %f.",
+                    LOG_WARNING(("the acceptance probability of an interaction exeeded one; %f.",
                                  accumulated_prob));
                 } 
                 
@@ -285,7 +290,11 @@ class newBDPropagator
         if(!bounced)
         {   
             particle_id_pair particle_to_update( pp.first, 
-                        particle_type(pp_species.id(), particle_shape_type(new_pos, r0), pp.second.structure_id(), pp_species.D()) );
+                                                 particle_type(pp_species.id(),
+                                                               particle_shape_type(new_pos, r0),
+                                                               pp.second.structure_id(),
+                                                               pp_species.D(),
+                                                               pp_species.v()) );
                 
             if (vc_)
             {
@@ -310,6 +319,7 @@ class newBDPropagator
 private:
 
     bool attempt_reaction(particle_id_pair const& pp)
+    // Handles only monomolecular reactions?
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
         if (::size(rules) == 0)
@@ -536,6 +546,7 @@ class newBDPropagator
     
     
     bool fire_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1, species_type const& s0, species_type const& s1)
+    // This handles the reaction between a pair of particles.
     // unclear what the convention for pp0, pp1 and s0,s1 is with regard to being in 3D/2D.
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
@@ -657,6 +668,7 @@ class newBDPropagator
 
         
     bool fire_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& surface)
+    // This handles the 'reaction' (interaction) between a particle and a surface.
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), surface->sid() ));
         if (::size(rules) == 0)
@@ -735,7 +747,7 @@ class newBDPropagator
     
     
     /* Given a position pair and two species, the function generates two new 
-       positions based on two moves drawn from the free propegator. */
+       positions based on two moves drawn from the free propagator. */
     position_pair_type const make_pair_move(species_type const& s0, species_type const& s1, position_pair_type const& pp01, 
                                             particle_id_type const& ignore)
     {
@@ -822,7 +834,7 @@ class newBDPropagator
 
 ////// Member variables
 private:
-    particle_container_type&    tx_;
+    particle_container_type&    tx_;            // The 'ParticleContainer' object that contains the particles.
     network_rules_type const&   rules_;
     rng_type&                   rng_;
     Real const                  dt_;

From 1894433bf2bfc91ac22f0a9fc60d9958f9e5338a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 4 Apr 2012 16:15:19 +0200
Subject: [PATCH 0756/1541] Some comments and cleanup

---
 BDSimulator.hpp            | 25 +++++++++++++------------
 GreensFunction2DRadAbs.cpp | 16 ++++++++--------
 2 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/BDSimulator.hpp b/BDSimulator.hpp
index da73cf12..9ebad93a 100644
--- a/BDSimulator.hpp
+++ b/BDSimulator.hpp
@@ -22,18 +22,19 @@ class BDSimulator: public ParticleSimulator<Ttraits_>
     typedef Ttraits_ traits_type;
     typedef ParticleSimulator<Ttraits_> base_type;
     typedef typename traits_type::world_type world_type;
-    typedef typename world_type::traits_type::rng_type rng_type;
-    typedef typename world_type::species_id_type species_id_type;
-    typedef typename world_type::species_type species_type;
-    typedef typename world_type::length_type length_type;
-    typedef typename world_type::structure_type structure_type;
-    typedef typename traits_type::time_type time_type;  
-    typedef typename traits_type::network_rules_type network_rules_type;
-    typedef typename traits_type::reaction_rule_type reaction_rule_type;
-    typedef typename network_rules_type::reaction_rules reaction_rules;
-    typedef typename traits_type::rate_type rate_type;
-    typedef typename traits_type::reaction_record_type reaction_record_type;
-    typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
+
+    typedef typename world_type::traits_type::rng_type      rng_type;
+    typedef typename world_type::species_id_type            species_id_type;
+    typedef typename world_type::species_type               species_type;
+    typedef typename world_type::length_type                length_type;
+    typedef typename world_type::structure_type             structure_type;
+    typedef typename traits_type::time_type                 time_type;  
+    typedef typename traits_type::network_rules_type        network_rules_type;
+    typedef typename traits_type::reaction_rule_type        reaction_rule_type;
+    typedef typename network_rules_type::reaction_rules     reaction_rules;
+    typedef typename traits_type::rate_type                 rate_type;
+    typedef typename traits_type::reaction_record_type      reaction_record_type;
+    typedef typename traits_type::reaction_recorder_type    reaction_recorder_type;
     typedef std::pair<const Real, const Real> real_pair;
 
 public:
diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index fe9f40e2..b692447f 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -117,7 +117,7 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 	const Real s_An( sigma * alpha );
 	const Real a_An( a * alpha );
 	// Needed? TODO
-	const Real h_s( h * sigma);
+//	const Real h_s( h * sigma);
 
 	const double J0_s_An (gsl_sf_bessel_J0(s_An));
 	const double J1_s_An (gsl_sf_bessel_J1(s_An));
@@ -518,7 +518,7 @@ GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
 		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRoot0" ) );
     gsl_root_fsolver_free( solver );
     
-    const Real sigma(getSigma());
+//    const Real sigma(getSigma());
     return alpha; 
 }    
 
@@ -622,7 +622,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                                              RealVector::size_type i // ith root
                                            ) const 
 {
-    const Real sigma(getSigma());
+//    const Real sigma(this->getSigma());
     Real current_root_, low, high;   
     
     // # "Administration"
@@ -1584,7 +1584,7 @@ GreensFunction2DRadAbs::givePDFTheta( const Real theta,
 {
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
-    const Real D( this->getD() );
+//    const Real D( this->getD() );
     const Real r0( this->getr0() );
 
 	// input parameter range checks.
@@ -1613,14 +1613,14 @@ GreensFunction2DRadAbs::givePDFTheta( const Real theta,
 // Output the PDF of r, given time t has passed.
 Real GreensFunction2DRadAbs::givePDFR( const Real r, const Real t ) const
 {
-    const Real D( this->getD() );
-    const Real sigma( getSigma() );
-    const Real a( this->geta() );
+//    const Real D( this->getD() );
+//    const Real sigma( this->getSigma() );
+//    const Real a( this->geta() );
     const Real r0( this->getr0() );
 
     if( t == 0.0 )		// if no time has passed
     {
-	return r0;
+	    return r0;
     }
 
     const Real psurv( p_survival( t ) );	// calculate the survival probability at this time

From 239d8d0370d624c2553896cd3d1f97590af4b0b9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 4 Apr 2012 16:15:54 +0200
Subject: [PATCH 0757/1541] namechange of method in structures and comments

---
 Region.hpp          |  3 ++-
 Structure.hpp       | 31 +++++++++------------
 Surface.hpp         |  2 +-
 World.hpp           |  6 ++---
 newBDPropagator.hpp | 66 ++++++++++++++++++++++++++++-----------------
 5 files changed, 60 insertions(+), 48 deletions(-)

diff --git a/Region.hpp b/Region.hpp
index 0da4ae0d..61622c8a 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -100,11 +100,12 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::distance(shape(), pos);
     }
     
-    virtual position_type const& structure_position() const
+    virtual position_type const& position() const
     {
         return shape_.position();
     }
 
+    // The constructor
     BasicRegionImpl(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
         : base_type(id, sid), shape_(shape) {}
 
diff --git a/Structure.hpp b/Structure.hpp
index 60da0e2c..ef64c75d 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -82,39 +82,34 @@ class Structure
 
     virtual position_type random_vector(length_type const& r, rng_type& rng) const = 0;
 
-    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
 
+    // Methods used in the 'old' BDPropagator
+    virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
     virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
-
     virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, Real const& D0, Real const& D1, Real const& v0, Real const& v1) const = 0;
 
-    virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
-    
+    // Methods used in the 'new' BDPropagator
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
+    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, length_type const& dist_to_surface, length_type const& particle_radius) const = 0;
+    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const = 0;
+
+
+    // TODO this are just functions->move somewhere else
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const = 0;
-    
     virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const = 0;
-
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const = 0;
+    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const = 0;     // This does contain a surface dependent component.
     
-    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const = 0;
-    
+    // Methods used to calculate dissociation positions
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const = 0;
-    
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const = 0;
-    
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const = 0;
     
-    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, length_type const& dist_to_surface, length_type const& particle_radius) const = 0;
-    
-    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const = 0;
-
+    // general method for getting some measures/info
     virtual projected_type projected_point(position_type const& pos) const = 0;
-    
     virtual projected_type projected_point_on_surface(position_type const& pos) const = 0;
-    
     virtual length_type distance(position_type const& pos) const = 0;
-    
-    virtual position_type const& structure_position() const = 0;
+    virtual position_type const& position() const = 0;
 
     virtual std::size_t hash() const
     {
diff --git a/Surface.hpp b/Surface.hpp
index 25c258f0..932a221c 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -109,7 +109,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::distance(shape(), pos);
     }
     
-    virtual position_type const& structure_position() const
+    virtual position_type const& position() const
     {
         return shape_.position();
     }
diff --git a/World.hpp b/World.hpp
index 141d4342..517c0ed5 100644
--- a/World.hpp
+++ b/World.hpp
@@ -368,8 +368,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
         structure_id_type structure_id(structidgen_());
         structure->set_id(structure_id);
-        if (update_structure(std::make_pair(structure_id, structure)))
-            return structure_id;
+        update_structure(std::make_pair(structure_id, structure));
+        return structure_id;
     }
     // update structure
     virtual bool update_structure(structure_id_pair const& structid_pair)
@@ -464,7 +464,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             if( structure->real_id() == ignore)
                 continue;
             
-            position_type const cyc_pos(cyclic_transpose(pos, structure->structure_position(), world_size));
+            position_type const cyc_pos(cyclic_transpose(pos, structure->position(), world_size));
             length_type const dist( fabs( structure->projected_point_on_surface( cyc_pos ).second ) );
                 
             if( dist < ret_dist )
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index d3e32171..213efaa9 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -73,12 +73,15 @@ class newBDPropagator
         call_with_size_if_randomly_accessible(
             boost::bind(&particle_id_vector_type::reserve, &queue_, _1),
             particle_ids);
+
+        // initialize the queue with the particle_ids of the particles to propagate.
         for (typename boost::range_const_iterator<Trange_>::type
                 i(boost::begin(particle_ids)),
                 e(boost::end(particle_ids)); i != e; ++i)
         {
             queue_.push_back(*i);
         }
+        // randomize the queue
         shuffle(rng, queue_);
     }
 
@@ -87,15 +90,20 @@ class newBDPropagator
     //    in the container that need to be processed.
     bool operator()()
     {
+        // if there are no more particle to treat -> end
         if (queue_.empty())
             return false;        
 
+        //// 0.
+        // Get the next particle from the queue
         particle_id_type pid(queue_.back());
         queue_.pop_back();
         particle_id_pair pp(tx_.get_particle(pid));
-
+        // Log
         LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
         
+
+
         /* Consider decay reactions first. Particles can move after decay, but this is done
            inside the 'attempt_reaction' function. */
         try
@@ -110,30 +118,38 @@ class newBDPropagator
             return true;
         }
         
-        species_type const pp_species(tx_.get_species(pp.second.sid()));
-        length_type const r0( pp_species.radius() );
-        position_type const old_pos( pp.second.position() );
+
+        //// 1.?
+        // Get info of the particle
+        species_type const                      pp_species(tx_.get_species(pp.second.sid()));
+        length_type const                       r0( pp_species.radius() );
+        position_type const                     old_pos( pp.second.position() );
         boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( pp.second.structure_id() ) );
-        
-        structure_id_and_distance_pair struct_id_distance_pair;
-        length_type particle_surface_distance = 0;
-        position_type new_pos;
-        
+        // declare variables to use
+        structure_id_and_distance_pair  struct_id_distance_pair;
+        length_type                     particle_surface_distance = 0;
+        position_type                   new_pos;
+//        structure_id_type               new_structure;
+
+        //// 2. New position
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
-           particle or surface. If this is the case the particlem bounces, and is returned
+           particle or surface. If this is the case the particle bounces, and is returned
            to it's original position. For a particle with D = 0, new_pos = old_pos */        
         if (pp_species.D() != 0.)
         {
             // get a new position, dependent on the structure the particle lives on.
-            position_type const displacement( pp_structure->
-                                              bd_displacement(pp_species.v() * dt_, std::sqrt(2.0 * pp_species.D() * dt_), rng_) );
+            position_type const displacement( pp_structure->bd_displacement(pp_species.v() * dt_,
+                                                                            std::sqrt(2.0 * pp_species.D() * dt_),
+                                                                            rng_) );
 
             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
             // TODO check if the new position is actually still in the structure
+//            new_structure_id = pp_structure->deflect();
         }
         else
         {
             new_pos = old_pos;
+//            new_structure_id = pp.second.structure_id();
         }
         
         /* Use a spherical shape with radius = particle_radius + reaction_length.
@@ -158,8 +174,8 @@ class newBDPropagator
 
             /* Check for overlap with nearest surface. */
             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
-            bounced = closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->structure_position() ), 
-                                               tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
+            bounced = closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
+                                               tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
                                                particle_surface_distance, r0);
         }
          
@@ -389,8 +405,8 @@ class newBDPropagator
                             
                             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
-                            if( closest_struct->bounced( tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
-                                                         tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
+                            if( closest_struct->bounced( tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
+                                                         tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
                                                          struct_id_distance_pair.second, s0.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
@@ -473,15 +489,15 @@ class newBDPropagator
                                 structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, tx_.get_def_structure_id() ) );
                                 boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
-                                surface_bounce0 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->structure_position() ), 
-                                                                           tx_.cyclic_transpose( pp01.first, closest_struct->structure_position() ), 
+                                surface_bounce0 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
+                                                                           tx_.cyclic_transpose( pp01.first, closest_struct->position() ), 
                                                                            struct_id_distance_pair.second, s0.radius() );
 
                                 struct_id_distance_pair = tx_.get_closest_surface( pp01.second, tx_.get_def_structure_id() );
                                 closest_struct = tx_.get_structure( struct_id_distance_pair.first );
 
-                                surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->structure_position() ), 
-                                                                           tx_.cyclic_transpose( pp01.second, closest_struct->structure_position() ), 
+                                surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
+                                                                           tx_.cyclic_transpose( pp01.second, closest_struct->position() ), 
                                                                            struct_id_distance_pair.second, s1.radius() );
                             }
                                     
@@ -602,7 +618,7 @@ class newBDPropagator
                             sp_struct = tx_.get_structure( new_structure_id );
                             projected_type const position_on_surface( sp_struct->
                                                                       projected_point( tx_.cyclic_transpose( new_pos, 
-                                                                                                             sp_struct->structure_position() ) ) );
+                                                                                                             sp_struct->position() ) ) );
                             
                             new_pos = tx_.apply_boundary( position_on_surface.first );
                         }
@@ -631,8 +647,8 @@ class newBDPropagator
                             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_def_structure_id() ) );
                             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
-                            if( closest_struct->bounced( tx_.cyclic_transpose( pp0.second.position(), closest_struct->structure_position() ), 
-                                                         tx_.cyclic_transpose( pp1.second.position(), closest_struct->structure_position() ), 
+                            if( closest_struct->bounced( tx_.cyclic_transpose( pp0.second.position(), closest_struct->position() ), 
+                                                         tx_.cyclic_transpose( pp1.second.position(), closest_struct->position() ), 
                                                          struct_id_distance_pair.second, sp.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
@@ -806,8 +822,8 @@ class newBDPropagator
             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_particle(ignore).second.structure_id() ) );
             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
-            if( closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->structure_position() ), 
-                                         tx_.cyclic_transpose( new_pos, closest_struct->structure_position() ), 
+            if( closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
+                                         tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
                                          struct_id_distance_pair.second, s0.radius() ) )    
                 return old_pos;        
         }

From c584d83e32ff52e82ac5a22f4c1a462acf104d1d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 4 Apr 2012 18:41:28 +0200
Subject: [PATCH 0758/1541] Implement deflection function for Plane and other
 shapes.

...and pass them to Region and Surface.

Attention! The transform is not properly tested yet.
This is just a basic implementation.
---
 Box.hpp               | 12 ++++++
 Cylinder.hpp          | 12 ++++++
 Plane.hpp             | 92 ++++++++++++++++++++++++++++++++++++-------
 Region.hpp            |  9 ++++-
 Sphere.hpp            | 10 +++++
 Structure.hpp         |  2 +
 Surface.hpp           |  5 +++
 binding/Plane.hpp     |  4 +-
 binding/Structure.hpp |  1 +
 edgetools.py          |  3 ++
 10 files changed, 133 insertions(+), 17 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 06499dc9..bbe14572 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -277,6 +277,18 @@ distance(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
     }
 }
 
+template<typename T_>
+inline typename Box<T_>::position_type
+deflect(Box<T_> const& obj,
+        typename Box<T_>::position_type const& r0,
+        typename Box<T_>::position_type const& d  )
+{
+    // Displacements are not deflected on cuboidal regions,
+    // but this function has to be defined for every shape to be used in structure.
+    // For now it just returns the new position.
+    return add(r0, d);
+}
+
 template<typename T, typename Trng>
 inline typename Box<T>::position_type
 random_position(Box<T> const& shape, Trng& rng)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index bed133a4..d6e5cb63 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -200,6 +200,18 @@ distance(Cylinder<T_> const& obj,
     return distance;
 }
 
+template<typename T_>
+inline typename Cylinder<T_>::position_type
+deflect(Cylinder<T_> const& obj,
+        typename Cylinder<T_>::position_type const& r0,
+        typename Cylinder<T_>::position_type const& d  )
+{
+    // Displacements are not deflected on cylinders (yet),
+    // but this function has to be defined for every shape to be used in structure.
+    // For now it just returns the new position.
+    return add(r0, d);
+}
+
 template<typename T, typename Trng>
 inline typename Cylinder<T>::position_type
 random_position(Cylinder<T> const& shape, Trng& rng)
diff --git a/Plane.hpp b/Plane.hpp
index a9389790..4f5b99a7 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -168,6 +168,9 @@ class Plane
         strm << *this;
         return strm.str();
     }
+    
+    position_type deflect(position_type const& r0, position_type const& displacement);
+    //position_type deflect(const Plane&, position_type const& pos0, position_type const& pos1);
 
 protected:
     position_type position_;
@@ -175,6 +178,81 @@ class Plane
     boost::array<length_type, 2> half_extent_;
 };
 
+template<typename T_>
+inline typename Plane<T_>::position_type
+deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& d)
+// This routine deflects a displacement on a plane.
+// If the displacement vector intersects with the plane (starting from r0) the part
+// ranging out of the plane will be deflected into the plane, always into the direction
+// towards the plane center.
+{
+  
+   // Type abbreviations
+   typedef typename Plane<T_>::length_type length_type;
+   typedef typename Plane<T_>::position_type position_type;
+      
+   // Plane properties to make use of
+   position_type corner_pt = obj.position();
+   position_type u_x = obj.unit_x();
+   position_type u_y = obj.unit_y();
+   position_type u_z = obj.unit_z();
+   
+   length_type half_extent_x = multiply(0.5, obj.Lx());
+   length_type half_extent_y = multiply(0.5, obj.Ly());
+   
+   // Variables used for calculation
+   position_type center_pt, center_edge, center_perp;
+   position_type intersect_pt, d_out, d_edge, d_perp;      
+   position_type new_pos;
+   
+   length_type intersect_parameter;
+   length_type l_edge, l_perp;
+   
+   // First calculate the center point of the plane
+   center_pt = add( corner_pt, add(multiply(u_x, half_extent_x), multiply(u_y, half_extent_y)) );
+   
+   // Calculate the intersection parameter and intersection point
+   // r0 is the origin position, d is a displacement vector
+   // If intersect_parameter is <= 1 we have an intersection
+   intersect_parameter = divide( dot_product( subtract( center_pt, r0), u_z), dot_product( d, u_z) );
+   
+   // Check whether the displacement actually crosses the plane;
+   // If not, just return original position plus displacement;
+   // if yes, calculate the deflection.
+   if(intersect_parameter > 1.0){
+     
+        new_pos = add(r0, d);
+   }
+   else{
+    
+        // Calculate the intersection point and the part of the displacement
+        // that ranges out of the target plane
+        intersect_pt = add(r0, multiply(d, intersect_parameter));
+        d_out = multiply(d, subtract(1.0, intersect_parameter));
+        
+        // Calculate the length of the component of d_out perpendicular to the edge
+        // and the component parallel to the edge
+        l_perp = dot_product(d_out, u_z);
+        d_edge = subtract(r0, multiply(u_z, l_perp));
+        //l_edge = abs(d_edge); // FIXME Make this work or just throw it out...
+        
+        // Find the vector pointing from the edge towards the center of the plane, which is
+        // the component of (center_pt - intersect_pt) perpendicular to the edge.
+        // First we calculate the component parallel to the edge
+        center_edge = multiply(d_edge, dot_product(subtract(center_pt, intersect_pt), d_edge));
+        center_perp = subtract( subtract(center_pt, intersect_pt), center_edge );
+        
+        d_perp = multiply( normalize(center_perp), l_perp );
+        
+        new_pos = add(r0, add(d_edge, d_perp));
+   }
+   
+   
+   // for now this returns the new position without changes
+   return new_pos;
+   //return center_pt;  // FIXME DEBUG 
+}
+
 template<typename T_>
 inline boost::array<typename Plane<T_>::length_type, 3>
 to_internal(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
@@ -260,20 +338,6 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
     }
 }
 
-template<typename T_>
-inline typename Plane<T_>::position_type
-deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& r1)
-// Calculates the distance from 'pos' to plane 'obj' Note that when the plane is finite,
-// and also calculates the distance to the edge of the plane if necessary
-{
-   typedef typename Plane<T_>::length_type length_type;
-   boost::array<length_type, 3> const x_y_z_0(to_internal(obj, r0));
-   boost::array<length_type, 3> const x_y_z_1(to_internal(obj, r1));
-   
-   // for now this returns the new position without changes
-   return x_y_z_1;
-}
-
 template<typename T, typename Trng>
 inline typename Plane<T>::position_type
 random_position(Plane<T> const& shape, Trng& rng)
diff --git a/Region.hpp b/Region.hpp
index 0da4ae0d..2cbbd51f 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -65,7 +65,9 @@ class BasicRegionImpl: public Region<Ttraits_>
     }
 
     virtual std::size_t hash() const
-    {
+    {    // Displacements are not deflected on cylinders (yet),
+    // but this function has to be defined for every shape to be used in structure
+    // For now it just returns the new position
 #if defined(HAVE_TR1_FUNCTIONAL)
         using std::tr1::hash;
 #elif defined(HAVE_STD_HASH)
@@ -100,6 +102,11 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::distance(shape(), pos);
     }
     
+    virtual position_type deflect(position_type const& pos0, position_type const& displacement) const
+    {
+        return ::deflect(shape(), pos0, displacement);
+    }
+    
     virtual position_type const& structure_position() const
     {
         return shape_.position();
diff --git a/Sphere.hpp b/Sphere.hpp
index 157c49f9..1000afd4 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -102,6 +102,16 @@ distance(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
     return distance(pos, obj.position()) - obj.radius();
 }
 
+template<typename T_>
+inline typename Sphere<T_>::position_type
+deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typename Sphere<T_>::position_type const& d)
+{
+    // Displacements are not deflected on spheres (yet),
+    // but this function has to be defined for every shape to be used in structure.
+    // For now it just returns the new position.
+    return add(r0, d);
+}
+
 template<typename T_>
 inline Sphere<T_> const& shape(Sphere<T_> const& shape)
 {
diff --git a/Structure.hpp b/Structure.hpp
index 60da0e2c..74e6bf85 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -114,6 +114,8 @@ class Structure
     
     virtual length_type distance(position_type const& pos) const = 0;
     
+//    virtual position_type deflect(position_type const& pos1, position_type const& pos2) const = 0;      // FIXME TOMEK
+    
     virtual position_type const& structure_position() const = 0;
 
     virtual std::size_t hash() const
diff --git a/Surface.hpp b/Surface.hpp
index 25c258f0..5f047815 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -109,6 +109,11 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::distance(shape(), pos);
     }
     
+    virtual position_type deflect(position_type const& pos0, position_type const& displacement) const
+    {
+        return ::deflect(shape(), pos0, displacement);
+    }
+    
     virtual position_type const& structure_position() const
     {
         return shape_.position();
diff --git a/binding/Plane.hpp b/binding/Plane.hpp
index 0350d99e..ba6cd338 100644
--- a/binding/Plane.hpp
+++ b/binding/Plane.hpp
@@ -101,8 +101,8 @@ inline boost::python::objects::class_base register_plane_class(char const* name)
                     impl_type,
                     typename impl_type::position_type,
                     &impl_type::unit_z,
-                    &impl_type::unit_z>::set));
-     // .add_property("deflect",
+                    &impl_type::unit_z>::set))
+        ;
                         
 }
 
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 3bbe38a1..df4f9d2a 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -44,6 +44,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("projected_point", &impl_type::projected_point)
+//        .def("deflect", &impl_type::deflect)  // FIXME TOMEK
         ;
 }
 
diff --git a/edgetools.py b/edgetools.py
index dbeef461..b5724b14 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -97,6 +97,9 @@ def process_new_position_vector(self, oldpos, displacement):
             print(d_target_par)
             print("Result:")
             print(newpos)
+            print("Deflection test:")
+            deflected = self.target_structure.shape.deflect(newpos, newpos)
+            print(deflected)
 
         return newpos, new_structure_id
 

From 41164871083059561ce8d0b332631acceda41658 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 4 Apr 2012 18:51:48 +0200
Subject: [PATCH 0759/1541] Expose deflect function to Structure + Python
 binding

---
 Structure.hpp         | 2 +-
 binding/Structure.hpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Structure.hpp b/Structure.hpp
index 74e6bf85..c3910789 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -114,7 +114,7 @@ class Structure
     
     virtual length_type distance(position_type const& pos) const = 0;
     
-//    virtual position_type deflect(position_type const& pos1, position_type const& pos2) const = 0;      // FIXME TOMEK
+    virtual position_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
     
     virtual position_type const& structure_position() const = 0;
 
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index df4f9d2a..d63794b1 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -44,7 +44,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("projected_point", &impl_type::projected_point)
-//        .def("deflect", &impl_type::deflect)  // FIXME TOMEK
+        .def("deflect", &impl_type::deflect)
         ;
 }
 

From dffe7b249422143aa05fa181f44d79851b9712ff Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 4 Apr 2012 19:01:51 +0200
Subject: [PATCH 0760/1541] Small fix to edgetools.py for testing the
 deflection code

---
 edgetools.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/edgetools.py b/edgetools.py
index b5724b14..6cc79b6d 100644
--- a/edgetools.py
+++ b/edgetools.py
@@ -98,7 +98,7 @@ def process_new_position_vector(self, oldpos, displacement):
             print("Result:")
             print(newpos)
             print("Deflection test:")
-            deflected = self.target_structure.shape.deflect(newpos, newpos)
+            deflected = self.target_structure.deflect(newpos, newpos)
             print(deflected)
 
         return newpos, new_structure_id

From f37c482aeefbc3afca1552febe7f2dc2baedd8b4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Apr 2012 16:00:16 +0200
Subject: [PATCH 0761/1541] General compactification and debugging of C++ based
 deflection function

---
 Plane.hpp | 64 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 35 insertions(+), 29 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index 4f5b99a7..4bf4bc8a 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -167,10 +167,7 @@ class Plane
         strm.precision(precision);
         strm << *this;
         return strm.str();
-    }
-    
-    position_type deflect(position_type const& r0, position_type const& displacement);
-    //position_type deflect(const Plane&, position_type const& pos0, position_type const& pos1);
+    }   
 
 protected:
     position_type position_;
@@ -192,65 +189,74 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    typedef typename Plane<T_>::position_type position_type;
       
    // Plane properties to make use of
-   position_type corner_pt = obj.position();
+   position_type center_pt = obj.position();
    position_type u_x = obj.unit_x();
    position_type u_y = obj.unit_y();
-   position_type u_z = obj.unit_z();
-   
-   length_type half_extent_x = multiply(0.5, obj.Lx());
-   length_type half_extent_y = multiply(0.5, obj.Ly());
+   position_type u_z = obj.unit_z();   
    
    // Variables used for calculation
-   position_type center_pt, center_edge, center_perp;
-   position_type intersect_pt, d_out, d_edge, d_perp;      
+   position_type intersect_pt;          // the point at which the displacement vector intersects the edge
+   position_type d_out, d_edge, d_perp; // the part of the displacement ranging out of the plane and
+                                        // the components parallel and perpendicular to the edge
+   position_type d_edge_n;              // normalized d_edge                                        
+   position_type icv;                   // = intersect_to_center_vector
+   position_type icv_edge, icv_perp;    // the components of icv parallel and perpendicular to the edge
+   
    position_type new_pos;
    
    length_type intersect_parameter;
-   length_type l_edge, l_perp;
-   
-   // First calculate the center point of the plane
-   center_pt = add( corner_pt, add(multiply(u_x, half_extent_x), multiply(u_y, half_extent_y)) );
+   length_type l_edge, l_perp;   
    
-   // Calculate the intersection parameter and intersection point
-   // r0 is the origin position, d is a displacement vector
-   // If intersect_parameter is <= 1 we have an intersection
-   intersect_parameter = divide( dot_product( subtract( center_pt, r0), u_z), dot_product( d, u_z) );
+   // Calculate the intersection parameter and intersection point.
+   // r0 is the origin position, d is a displacement vector.
+   // If intersect_parameter <= 1 we have an intersection.
+   if(dot_product(d, u_z) != 0.0)
+      intersect_parameter = divide( dot_product(subtract(center_pt, r0), u_z), dot_product(d, u_z) );
+   else
+      intersect_parameter = (length_type)INT_MAX;       // infinity, displacement is parallel to edge
+      
    
    // Check whether the displacement actually crosses the plane;
    // If not, just return original position plus displacement;
    // if yes, calculate the deflection.
    if(intersect_parameter > 1.0){
      
+        // No intersection; the new position is just r0+displacement
         new_pos = add(r0, d);
    }
    else{
     
         // Calculate the intersection point and the part of the displacement
         // that ranges out of the target plane
-        intersect_pt = add(r0, multiply(d, intersect_parameter));
+        intersect_pt = add(r0, multiply(d, intersect_parameter));        
         d_out = multiply(d, subtract(1.0, intersect_parameter));
         
         // Calculate the length of the component of d_out perpendicular to the edge
-        // and the component parallel to the edge
-        l_perp = dot_product(d_out, u_z);
-        d_edge = subtract(r0, multiply(u_z, l_perp));
-        //l_edge = abs(d_edge); // FIXME Make this work or just throw it out...
+        // and the vector of the component parallel to the edge
+        l_perp = dot_product(d_out, u_z);       // note that this can be positive or negative,
+                                                // depending on whether u_z points in or out!
+        d_edge = subtract(d_out, multiply(u_z, l_perp));
+        d_edge_n = normalize(d_edge);
         
         // Find the vector pointing from the edge towards the center of the plane, which is
         // the component of (center_pt - intersect_pt) perpendicular to the edge.
         // First we calculate the component parallel to the edge
-        center_edge = multiply(d_edge, dot_product(subtract(center_pt, intersect_pt), d_edge));
-        center_perp = subtract( subtract(center_pt, intersect_pt), center_edge );
+        icv = subtract(center_pt, intersect_pt);
+        icv_edge = multiply(d_edge_n, dot_product(icv, d_edge_n));
+        icv_perp = subtract(icv, icv_edge);
         
-        d_perp = multiply( normalize(center_perp), l_perp );
+        // Calculate the component perpendicular to the edge in the plane.
+        // Note that l_perp can be pos. or neg. while icv_perp always points towards
+        // the center of the plane; therefore use abs(l_perp).
+        d_perp = multiply( normalize(icv_perp), abs(l_perp) );
         
-        new_pos = add(r0, add(d_edge, d_perp));
+        // Construct the new position vector
+        new_pos = add(intersect_pt, add(d_edge, d_perp));
    }
    
    
    // for now this returns the new position without changes
    return new_pos;
-   //return center_pt;  // FIXME DEBUG 
 }
 
 template<typename T_>

From 8e72a2e65eb614bf2f2be1a88feec9187770b69b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Apr 2012 18:14:07 +0200
Subject: [PATCH 0762/1541] Project vectors into plane when necessary to
 correct for numerical inaccuracy.

The latter may cause problems with periodic BCs.
---
 Plane.hpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index 4bf4bc8a..12e47565 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -175,6 +175,7 @@ class Plane
     boost::array<length_type, 2> half_extent_;
 };
 
+
 template<typename T_>
 inline typename Plane<T_>::position_type
 deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& d)
@@ -182,6 +183,7 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
 // If the displacement vector intersects with the plane (starting from r0) the part
 // ranging out of the plane will be deflected into the plane, always into the direction
 // towards the plane center.
+// ATTENTION! As for now, this only works for displacement vectors perpendicular to the plane
 {
   
    // Type abbreviations
@@ -227,8 +229,10 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    else{
     
         // Calculate the intersection point and the part of the displacement
-        // that ranges out of the target plane
-        intersect_pt = add(r0, multiply(d, intersect_parameter));        
+        // that ranges out of the target plane.
+        // Project all points that are supposed to be in the plane into it,
+        // just to be sure.
+        intersect_pt = projected_point( obj, add(r0, multiply(d, intersect_parameter)) ).first;
         d_out = multiply(d, subtract(1.0, intersect_parameter));
         
         // Calculate the length of the component of d_out perpendicular to the edge
@@ -250,8 +254,9 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
         // the center of the plane; therefore use abs(l_perp).
         d_perp = multiply( normalize(icv_perp), abs(l_perp) );
         
-        // Construct the new position vector
-        new_pos = add(intersect_pt, add(d_edge, d_perp));
+        // Construct the new position vector, make sure it's in the plane to
+        // avoid trouble with periodic boundary conditions
+        new_pos = projected_point(obj, add(intersect_pt, add(d_edge, d_perp)) ).first;
    }
    
    

From 9cbed9358c65d5691267357f7f263cb899ac5444 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Apr 2012 19:32:27 +0200
Subject: [PATCH 0763/1541] Implement C++ based deflection function into
 Python.

+ some minor changes.
+ EdgeTools is called TransitionTools now.
---
 edgetools.py                                | 124 ----------------
 samples/finite_planes_hack/finite_planes.py | 157 ++++++++++++++++++++
 single.py                                   |   8 +-
 transitiontools.py                          |  57 +++++++
 4 files changed, 218 insertions(+), 128 deletions(-)
 delete mode 100644 edgetools.py
 create mode 100644 samples/finite_planes_hack/finite_planes.py
 create mode 100644 transitiontools.py

diff --git a/edgetools.py b/edgetools.py
deleted file mode 100644
index 37f9535e..00000000
--- a/edgetools.py
+++ /dev/null
@@ -1,124 +0,0 @@
-from _gfrd import (
-    SphericalShell,
-    CylindricalShell,
-    Sphere,
-    Cylinder,
-    CuboidalRegion,
-    PlanarSurface,
-    CylindricalSurface,
-    )
-
-from utils import *
-
-from domain import (
-    Domain,
-    ProtectiveDomain)
-
-from shells import *
-
-__all__ = [
-    'EdgeTools'
-    ]
-
-
-class EdgeTools :
-
-    def __init__(self, testShell, start_position):
-
-        assert isinstance(testShell, testTransitionSingle);
-
-        # Might be used internally by classes inheriting from here
-        self.origin_structure  = testShell.origin_structure
-        self.target_structure  = testShell.target_structure
-
-        self.origin_center = self.origin_structure.shape.position
-        self.target_center = self.target_structure.shape.position
-        self.origin_half_extent = self.origin_structure.shape.half_extent
-        self.target_half_extent = self.target_structure.shape.half_extent
-
-        self.start_position  = start_position
-        self.target_distance = testShell.distance_to_target_structure
-
-        self.edge_point = self.get_edge_point()
-        self.origin_unit_perp, self.origin_unit_par, self.origin_half_extent_perp = self.get_origin_unit_vectors()
-        self.target_unit_perp, self.target_unit_par, self.target_half_extent_perp = self.get_target_unit_vectors()        
-        
-
-    def process_new_position_vector(self, oldpos, displacement):
-        # This routine checks whether the new position in the surface of origin
-        # reaches out of it and if necessary calculates the position in the
-        # target surface.
-        # First calculate the coordinate perpendicular to the edge
-        # in the old surface
-        newpos_in_origin = (oldpos - self.origin_center) + displacement
-        d_origin_perp = numpy.dot(newpos_in_origin, self.origin_unit_perp)
-        assert (d_origin_perp >= 0.0 )
-        # Calculate the part of it that reaches out of the surface of origin
-        d_out = d_origin_perp - self.origin_half_extent_perp
-        if d_out <= 0.0 :
-            # The new position is still in the old surface;
-            # no transform required
-            newpos = oldpos + displacement  
-            new_structure_id = self.origin_structure.id  # i.e. no change here
-        else :
-            # The new position is out of the old surface;
-            # transform it to the target surface.
-            # First calculate the coordinate in the target surface
-            # that is perpendicular to the edge:
-            d_target_perp = self.target_half_extent_perp - d_out
-            # Now the same for the parallel component
-            # Take into account that the parallel unit vector in the target surface might be
-            # either parallel or antiparallel to the parallel unit vector in the origin surface
-            d_origin_par = numpy.dot(newpos_in_origin, self.origin_unit_par)
-            d_target_par = d_origin_par * numpy.dot(self.origin_unit_par, self.target_unit_par)
-            # Construct the new position using the predefined unit vectors of the target surface
-            newpos = self.target_center + d_target_perp*self.target_unit_perp + d_target_par*self.target_unit_par
-            new_structure_id = self.target_structure.id
-
-        return newpos, new_structure_id
-
-    def get_origin_unit_vectors(self):
-        # calculate the unit vector perpendicular and parallel to the edge
-        # in the surface of origin and the half_extent of this surface in the
-        # perpendicular vector direction
-        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
-        w_z = self.target_structure.shape.unit_z
-        u_perp = (1.0/self.target_distance * numpy.dot(self.target_center-self.start_position, w_z )) * w_z
-        assert feq( length(u_perp), 1.0) 
-
-        u_x = self.origin_structure.shape.unit_x
-        u_y = self.origin_structure.shape.unit_y
-        if feq(abs(numpy.dot(u_x, u_perp)), 1.0):
-             u_par  = u_y
-             h_perp = self.origin_half_extent[0] # half_extent in u_x direction
-        else:
-             u_par  = u_x
-             h_perp = self.origin_half_extent[1] # half_extent in u_y direction
-
-        return u_perp, u_par, h_perp
-
-    def get_target_unit_vectors(self):
-        # calculate the unit vector perpendicular and parallel to the edge
-        # in the target surface and the half_extent of this surface in the
-        # perpendicular vector direction
-        # ATTENTION! THIS DOES NOT YET WORK WITH PERIODIC BC!
-        w_perp_unnorm = (self.origin_center - self.target_center) + self.origin_half_extent_perp * self.origin_unit_perp
-        w_perp = ( 1.0/numpy.sqrt(numpy.dot(w_perp_unnorm,w_perp_unnorm)) ) * w_perp_unnorm
-        assert feq(numpy.sqrt(numpy.dot(w_perp, w_perp)), 1.0)
-
-        w_x = self.target_structure.shape.unit_x
-        w_y = self.target_structure.shape.unit_y
-        if feq(abs(numpy.dot(w_x, w_perp)), 1.0):
-             w_par = w_y
-             h_perp = self.target_half_extent[0] # half_extent in w_x direction
-        else:
-             w_par = w_x
-             h_perp = self.target_half_extent[1] # half_extent in w_y direction
-
-        return w_perp, w_par, h_perp
-
-    def get_edge_point(self):
-        self.origin_unit_perp, _, _ = self.get_origin_unit_vectors()
-        ep = self.start_position + (self.target_distance * self.origin_unit_perp)
-        return ep
-
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
new file mode 100644
index 00000000..bfdc05de
--- /dev/null
+++ b/samples/finite_planes_hack/finite_planes.py
@@ -0,0 +1,157 @@
+#!/usr/bin/python
+
+# Small script to test transfers between membranes
+#
+# Make sure that the egfrd system is added to your PYTHONPATH
+# This means, in bash for example:
+# $ export PYTHONPATH=$HOME/egfrd
+
+# Modules
+# ===============================
+import sys
+import os
+import datetime
+
+from egfrd import *
+from visualization import vtklogger
+
+import model
+import gfrdbase
+import _gfrd
+
+
+# Unique seed
+# ===============================
+currenttime = (long(
+datetime.datetime.now().month*30.5*24*3600*1e6+
+datetime.datetime.now().day*24*3600*1e6+datetime.datetime.now().hour*3600*1e6+
+datetime.datetime.now().minute*60*1e6+datetime.datetime.now().second*1e6+
+datetime.datetime.now().microsecond))
+#myrandom.seed(currenttime)
+
+myrandom.seed(523) # 323 for 3 part., 523 for one is good
+print "(Seed " + str(currenttime) + ")"
+ 
+
+# Constants
+# ===============================
+logging = True
+#logging = False
+sigma = 1e-8 # Diameter particle
+DC = 1e-13 # Diffusion constant
+N = 300 # Number of steps simulation will last
+world_size = 1e-6 # Lengths of simulation box
+Nparticles = 1 # Number of particles in the simulation
+k = 2e-14 # Reaction constant
+
+# VTK Logger
+# ===============================
+if (logging == True):
+    vtk_output_directory = 'VTK_out'
+    if (os.path.exists(vtk_output_directory)):
+        print '** WARNING: VTK output directory already exists, possible '+ \
+                'present old VTK files might lead to errors.'
+
+
+# Basic set up simulator
+# ===============================
+# Model
+m = model.ParticleModel(2.01*world_size)
+
+# Planes ("membranes")
+membrane_type = _gfrd.StructureType()
+membrane_type['name'] = 'membrane_type'
+
+m.add_structure_type(membrane_type)
+
+# Species
+A = model.Species('A', DC, sigma, membrane_type)
+m.add_species_type(A)
+B = model.Species('B', DC, sigma, membrane_type)
+m.add_species_type(B)
+C = model.Species('C', DC, sigma, membrane_type)
+m.add_species_type(C)
+D = model.Species('D', DC, sigma, membrane_type)
+m.add_species_type(D)
+E = model.Species('E', DC, sigma, membrane_type)
+m.add_species_type(E)
+F = model.Species('F', DC, sigma, membrane_type)
+m.add_species_type(F)
+
+Statist = model.Species('Statist', 0.0, 10.0*sigma)
+m.add_species_type(Statist)
+
+# World
+w = gfrdbase.create_world(m, 3)
+
+# Create instances of membrane types
+membraneA = model.create_planar_surface(membrane_type.id, 'name1', [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
+w.add_structure(membraneA)
+membraneB = model.create_planar_surface(membrane_type.id, 'name2', [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
+w.add_structure(membraneB)
+membraneC = model.create_planar_surface(membrane_type.id, 'name3', [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
+w.add_structure(membraneC)
+membraneD = model.create_planar_surface(membrane_type.id, 'name4', [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
+w.add_structure(membraneD)
+membraneE = model.create_planar_surface(membrane_type.id, 'name5', [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
+w.add_structure(membraneE)
+membraneF = model.create_planar_surface(membrane_type.id, 'name6', [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
+w.add_structure(membraneF)
+
+print("Membrane A : unit_z = " + str(membraneA.shape.unit_z))
+print("Membrane B : unit_z = " + str(membraneB.shape.unit_z))
+print("Membrane C : unit_z = " + str(membraneC.shape.unit_z))
+print("Membrane D : unit_z = " + str(membraneD.shape.unit_z))
+print("Membrane E : unit_z = " + str(membraneE.shape.unit_z))
+print("Membrane F : unit_z = " + str(membraneF.shape.unit_z))
+
+
+# Simulator
+s = EGFRDSimulator(w, myrandom.rng)
+
+# Set up logger
+if (logging == True):
+    l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True)
+
+# Throw in particles
+place_particle(w, A, [world_size/2, world_size/2, 0]) # place one particle on membraneA
+#place_particle(w, A, [world_size/4, world_size/4, 0]) # place one particle on membraneA
+#place_particle(w, A, [3*world_size/4, 3*world_size/4, 0]) # place one particle on membraneA
+
+# Statist particles in the corners of the system
+# does not really work because they intersect with membranes...
+#place_particle(w, Statist, [0, 0, 0])
+#place_particle(w, Statist, [world_size, 0, 0])
+#place_particle(w, Statist, [0, world_size, 0])
+#place_particle(w, Statist, [0, 0, world_size])
+#place_particle(w, Statist, [0, world_size, world_size])
+#place_particle(w, Statist, [world_size, 0, world_size])
+#place_particle(w, Statist, [world_size, world_size, 0])
+#place_particle(w, Statist, [world_size, world_size, world_size])
+
+
+#throw_in_particles(w, A, Nparticles) # THIS DOES NOT WORK BECAUSE PARTICLES INTERSECT WITH PLANES YET!
+#throw_in_particles(w, B, Nparticles)
+
+# Running 2
+# ===============================
+for t in range(N):
+
+    # if logging, log and also use "try statement"
+    if (logging == True):
+        # take a step (but ignore errors)
+        try:
+            s.step()
+        except:
+            print "Broken (run with logging=False for errormessage)!"
+            break
+        # log the step
+        l.log()
+    # otherwise just make steps.
+    else:
+        s.step()
+
+s.stop(s.t)
+
+if (logging == True):
+    l.stop()
diff --git a/single.py b/single.py
index 62c83231..fa50c681 100644
--- a/single.py
+++ b/single.py
@@ -11,7 +11,7 @@
 from greens_function_wrapper import *
 from constants import EventType
 from utils import *
-from edgetools import *
+from transitiontools import *
 
 from domain import (
     Domain,
@@ -948,7 +948,7 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
-class TransitionSingle(Single, EdgeTools, Others):
+class TransitionSingle(Single, TransitionTools, Others):
     """TransitionSingles are used when a particle changes from
        one structure to another. The difference to an InteractionSingle
        is that the transition process is instantaneous, i.e. the 
@@ -965,7 +965,7 @@ class TransitionSingle(Single, EdgeTools, Others):
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
         Single.__init__(self, domain_id, shell_id, reactionrules)
-        EdgeTools.__init__(self, testShell, self.pid_particle_pair[1].position)
+        TransitionTools.__init__(self, testShell, self.pid_particle_pair[1].position)
         # Note: for the Others superclass nothing is to be initialized.
 
     def determine_next_event(self):
@@ -1027,7 +1027,7 @@ def draw_new_position(self, dt, event_type):
             displacement = self.create_position_vector(r)
 
             # Now check whether the new position is in the surface of origin;
-            # if not, transform it to the target surface (function inherited from EdgeTools)
+            # if not, transform it to the target surface (function inherited from TransitionTools)
             newpos, new_structure_id = self.process_new_position_vector(oldpos, displacement)
 
         return newpos, new_structure_id
diff --git a/transitiontools.py b/transitiontools.py
new file mode 100644
index 00000000..2eb35aef
--- /dev/null
+++ b/transitiontools.py
@@ -0,0 +1,57 @@
+from _gfrd import (
+    SphericalShell,
+    CylindricalShell,
+    Sphere,
+    Cylinder,
+    CuboidalRegion,
+    PlanarSurface,
+    CylindricalSurface,
+    )
+
+from utils import *
+
+from domain import (
+    Domain,
+    ProtectiveDomain)
+
+from shells import *
+
+__all__ = [
+    'TransitionTools'
+    ]
+
+
+class TransitionTools :
+
+    def __init__(self, testShell, start_position):
+
+        assert isinstance(testShell, testTransitionSingle);
+
+        # Might be used internally by classes inheriting from here
+        self.origin_structure  = testShell.origin_structure
+        self.target_structure  = testShell.target_structure
+
+        self.origin_center = self.origin_structure.shape.position
+        self.target_center = self.target_structure.shape.position
+        self.origin_half_extent = self.origin_structure.shape.half_extent
+        self.target_half_extent = self.target_structure.shape.half_extent
+
+        self.start_position  = start_position
+        self.target_distance = testShell.distance_to_target_structure
+        
+
+    def process_new_position_vector(self, old_pos, displacement):
+                
+        # Construct the new position using the deflection function of the target surface            
+        new_pos = self.target_structure.deflect(old_pos, displacement)        
+                
+        if numpy.alltrue(new_pos == (old_pos + displacement) ) :    # FIXME will this not fail at some point?
+            # The new position is still in the old surface;
+            new_structure_id = self.origin_structure.id  # i.e. no change here
+        else :
+            # The new position is out of the old surface;            
+            new_structure_id = self.target_structure.id
+
+        return new_pos, new_structure_id
+
+

From 1ac50e784c03be013b11d182e5a6649fe293c994 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 6 Apr 2012 13:47:59 +0200
Subject: [PATCH 0764/1541] Deflect function now returns information about
 structure change

+ Introduced a new boolean flag that is true if the particle changes structures.
+ Introduced corresponding new type position_flag_pair_type
+ Modified the shape/surface/structre etc. files
+ Polished the binding
+ Deleted unfinished testscript finite_planes.py
---
 Box.hpp                                     |   6 +-
 Cylinder.hpp                                |   6 +-
 Plane.hpp                                   |  12 +-
 Region.hpp                                  |  11 +-
 Sphere.hpp                                  |   6 +-
 Structure.hpp                               |   3 +-
 Surface.hpp                                 |   3 +-
 binding/Structure.hpp                       |   2 +
 samples/finite_planes_hack/finite_planes.py | 157 --------------------
 transitiontools.py                          |   4 +-
 10 files changed, 31 insertions(+), 179 deletions(-)
 delete mode 100644 samples/finite_planes_hack/finite_planes.py

diff --git a/Box.hpp b/Box.hpp
index bbe14572..39b5af8a 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -278,15 +278,15 @@ distance(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
 }
 
 template<typename T_>
-inline typename Box<T_>::position_type
+inline std::pair<typename Box<T_>::position_type, bool>
 deflect(Box<T_> const& obj,
         typename Box<T_>::position_type const& r0,
         typename Box<T_>::position_type const& d  )
 {
     // Displacements are not deflected on cuboidal regions,
     // but this function has to be defined for every shape to be used in structure.
-    // For now it just returns the new position.
-    return add(r0, d);
+    // For now it just returns the new position. The changeflag = 0.
+    return std::make_pair( add(r0, d), false );
 }
 
 template<typename T, typename Trng>
diff --git a/Cylinder.hpp b/Cylinder.hpp
index d6e5cb63..e521546d 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -201,15 +201,15 @@ distance(Cylinder<T_> const& obj,
 }
 
 template<typename T_>
-inline typename Cylinder<T_>::position_type
+inline std::pair<typename Cylinder<T_>::position_type, bool>
 deflect(Cylinder<T_> const& obj,
         typename Cylinder<T_>::position_type const& r0,
         typename Cylinder<T_>::position_type const& d  )
 {
     // Displacements are not deflected on cylinders (yet),
     // but this function has to be defined for every shape to be used in structure.
-    // For now it just returns the new position.
-    return add(r0, d);
+    // For now it just returns the new position. The changeflage = false.
+    return std::make_pair( add(r0, d), false );
 }
 
 template<typename T, typename Trng>
diff --git a/Plane.hpp b/Plane.hpp
index 12e47565..94ebe4cb 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -177,7 +177,7 @@ class Plane
 
 
 template<typename T_>
-inline typename Plane<T_>::position_type
+inline std::pair<typename Plane<T_>::position_type, bool>
 deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& d)
 // This routine deflects a displacement on a plane.
 // If the displacement vector intersects with the plane (starting from r0) the part
@@ -207,7 +207,9 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    position_type new_pos;
    
    length_type intersect_parameter;
-   length_type l_edge, l_perp;   
+   length_type l_edge, l_perp;
+   
+   bool changeflag = false;
    
    // Calculate the intersection parameter and intersection point.
    // r0 is the origin position, d is a displacement vector.
@@ -225,6 +227,7 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
      
         // No intersection; the new position is just r0+displacement
         new_pos = add(r0, d);
+        changeflag = false;
    }
    else{
     
@@ -256,12 +259,13 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
         
         // Construct the new position vector, make sure it's in the plane to
         // avoid trouble with periodic boundary conditions
-        new_pos = projected_point(obj, add(intersect_pt, add(d_edge, d_perp)) ).first;
+        new_pos = projected_point(obj, add(intersect_pt, add(d_edge, d_perp)) ).first;        
+        changeflag = true;
    }
    
    
    // for now this returns the new position without changes
-   return new_pos;
+   return std::make_pair( new_pos, changeflag );
 }
 
 template<typename T_>
diff --git a/Region.hpp b/Region.hpp
index 2cbbd51f..d5c4c739 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -35,12 +35,13 @@ template<typename Ttraits_, typename Tshape_>
 class BasicRegionImpl: public Region<Ttraits_>
 {
 public:
-    typedef Region<Ttraits_> base_type;
-    typedef Tshape_ shape_type;
+    typedef Region<Ttraits_>                            base_type;
+    typedef Tshape_                                     shape_type;
     typedef typename base_type::identifier_type         identifier_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::length_type length_type;
-    typedef typename base_type::position_type position_type;
+    typedef typename base_type::length_type             length_type;
+    typedef typename base_type::position_type           position_type;
+    typedef std::pair<position_type, bool>              position_flag_pair_type;
 
 public:
     virtual ~BasicRegionImpl() {}
@@ -102,7 +103,7 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::distance(shape(), pos);
     }
     
-    virtual position_type deflect(position_type const& pos0, position_type const& displacement) const
+    virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const
     {
         return ::deflect(shape(), pos0, displacement);
     }
diff --git a/Sphere.hpp b/Sphere.hpp
index 1000afd4..e50bb96d 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -103,13 +103,13 @@ distance(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
 }
 
 template<typename T_>
-inline typename Sphere<T_>::position_type
+inline std::pair<typename Sphere<T_>::position_type, bool>
 deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typename Sphere<T_>::position_type const& d)
 {
     // Displacements are not deflected on spheres (yet),
     // but this function has to be defined for every shape to be used in structure.
-    // For now it just returns the new position.
-    return add(r0, d);
+    // For now it just returns the new position. The changeflag = 0.
+    return std::make_pair( add(r0, d), false );
 }
 
 template<typename T_>
diff --git a/Structure.hpp b/Structure.hpp
index c3910789..29dbb892 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -30,6 +30,7 @@ class Structure
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
     typedef std::pair<position_type, length_type>           projected_type;
     typedef std::pair<position_type, position_type>         position_pair_type;
+    typedef std::pair<position_type, bool>                  position_flag_pair_type;
 
 public:
     virtual ~Structure() {}
@@ -114,7 +115,7 @@ class Structure
     
     virtual length_type distance(position_type const& pos) const = 0;
     
-    virtual position_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
+    virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
     
     virtual position_type const& structure_position() const = 0;
 
diff --git a/Surface.hpp b/Surface.hpp
index 5f047815..1b0b0f95 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -50,6 +50,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::position_type           position_type;
     typedef std::pair<position_type, length_type>       projected_type;
+    typedef std::pair<position_type, bool>              position_flag_pair_type;
 
 public:
     virtual ~BasicSurfaceImpl() {}
@@ -109,7 +110,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::distance(shape(), pos);
     }
     
-    virtual position_type deflect(position_type const& pos0, position_type const& displacement) const
+    virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const
     {
         return ::deflect(shape(), pos0, displacement);
     }
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index d63794b1..bdee301e 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -18,6 +18,8 @@ inline boost::python::objects::class_base register_structure_class(char const *n
     // registers the projected_point/projected_distance tuple defined in ../Structure.hpp
     peer::converters::register_tuple_converter<
             typename impl_type::projected_type>();
+    peer::converters::register_tuple_converter<
+            typename impl_type::position_flag_pair_type>();
 
     // defining the python class
     // TODO add name and change id->real_id
diff --git a/samples/finite_planes_hack/finite_planes.py b/samples/finite_planes_hack/finite_planes.py
deleted file mode 100644
index bfdc05de..00000000
--- a/samples/finite_planes_hack/finite_planes.py
+++ /dev/null
@@ -1,157 +0,0 @@
-#!/usr/bin/python
-
-# Small script to test transfers between membranes
-#
-# Make sure that the egfrd system is added to your PYTHONPATH
-# This means, in bash for example:
-# $ export PYTHONPATH=$HOME/egfrd
-
-# Modules
-# ===============================
-import sys
-import os
-import datetime
-
-from egfrd import *
-from visualization import vtklogger
-
-import model
-import gfrdbase
-import _gfrd
-
-
-# Unique seed
-# ===============================
-currenttime = (long(
-datetime.datetime.now().month*30.5*24*3600*1e6+
-datetime.datetime.now().day*24*3600*1e6+datetime.datetime.now().hour*3600*1e6+
-datetime.datetime.now().minute*60*1e6+datetime.datetime.now().second*1e6+
-datetime.datetime.now().microsecond))
-#myrandom.seed(currenttime)
-
-myrandom.seed(523) # 323 for 3 part., 523 for one is good
-print "(Seed " + str(currenttime) + ")"
- 
-
-# Constants
-# ===============================
-logging = True
-#logging = False
-sigma = 1e-8 # Diameter particle
-DC = 1e-13 # Diffusion constant
-N = 300 # Number of steps simulation will last
-world_size = 1e-6 # Lengths of simulation box
-Nparticles = 1 # Number of particles in the simulation
-k = 2e-14 # Reaction constant
-
-# VTK Logger
-# ===============================
-if (logging == True):
-    vtk_output_directory = 'VTK_out'
-    if (os.path.exists(vtk_output_directory)):
-        print '** WARNING: VTK output directory already exists, possible '+ \
-                'present old VTK files might lead to errors.'
-
-
-# Basic set up simulator
-# ===============================
-# Model
-m = model.ParticleModel(2.01*world_size)
-
-# Planes ("membranes")
-membrane_type = _gfrd.StructureType()
-membrane_type['name'] = 'membrane_type'
-
-m.add_structure_type(membrane_type)
-
-# Species
-A = model.Species('A', DC, sigma, membrane_type)
-m.add_species_type(A)
-B = model.Species('B', DC, sigma, membrane_type)
-m.add_species_type(B)
-C = model.Species('C', DC, sigma, membrane_type)
-m.add_species_type(C)
-D = model.Species('D', DC, sigma, membrane_type)
-m.add_species_type(D)
-E = model.Species('E', DC, sigma, membrane_type)
-m.add_species_type(E)
-F = model.Species('F', DC, sigma, membrane_type)
-m.add_species_type(F)
-
-Statist = model.Species('Statist', 0.0, 10.0*sigma)
-m.add_species_type(Statist)
-
-# World
-w = gfrdbase.create_world(m, 3)
-
-# Create instances of membrane types
-membraneA = model.create_planar_surface(membrane_type.id, 'name1', [0,0,0], [1,0,0], [0,1,0], world_size, world_size)
-w.add_structure(membraneA)
-membraneB = model.create_planar_surface(membrane_type.id, 'name2', [0,0,0], [0,0,1], [0,1,0], world_size, world_size)
-w.add_structure(membraneB)
-membraneC = model.create_planar_surface(membrane_type.id, 'name3', [0,0,world_size], [1,0,0], [0,1,0], world_size, world_size)
-w.add_structure(membraneC)
-membraneD = model.create_planar_surface(membrane_type.id, 'name4', [world_size,0,0], [0,0,1], [0,1,0], world_size, world_size)
-w.add_structure(membraneD)
-membraneE = model.create_planar_surface(membrane_type.id, 'name5', [0,0,0], [1,0,0], [0,0,1], world_size, world_size)
-w.add_structure(membraneE)
-membraneF = model.create_planar_surface(membrane_type.id, 'name6', [0,world_size,0], [1,0,0], [0,0,1], world_size, world_size)
-w.add_structure(membraneF)
-
-print("Membrane A : unit_z = " + str(membraneA.shape.unit_z))
-print("Membrane B : unit_z = " + str(membraneB.shape.unit_z))
-print("Membrane C : unit_z = " + str(membraneC.shape.unit_z))
-print("Membrane D : unit_z = " + str(membraneD.shape.unit_z))
-print("Membrane E : unit_z = " + str(membraneE.shape.unit_z))
-print("Membrane F : unit_z = " + str(membraneF.shape.unit_z))
-
-
-# Simulator
-s = EGFRDSimulator(w, myrandom.rng)
-
-# Set up logger
-if (logging == True):
-    l = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True)
-
-# Throw in particles
-place_particle(w, A, [world_size/2, world_size/2, 0]) # place one particle on membraneA
-#place_particle(w, A, [world_size/4, world_size/4, 0]) # place one particle on membraneA
-#place_particle(w, A, [3*world_size/4, 3*world_size/4, 0]) # place one particle on membraneA
-
-# Statist particles in the corners of the system
-# does not really work because they intersect with membranes...
-#place_particle(w, Statist, [0, 0, 0])
-#place_particle(w, Statist, [world_size, 0, 0])
-#place_particle(w, Statist, [0, world_size, 0])
-#place_particle(w, Statist, [0, 0, world_size])
-#place_particle(w, Statist, [0, world_size, world_size])
-#place_particle(w, Statist, [world_size, 0, world_size])
-#place_particle(w, Statist, [world_size, world_size, 0])
-#place_particle(w, Statist, [world_size, world_size, world_size])
-
-
-#throw_in_particles(w, A, Nparticles) # THIS DOES NOT WORK BECAUSE PARTICLES INTERSECT WITH PLANES YET!
-#throw_in_particles(w, B, Nparticles)
-
-# Running 2
-# ===============================
-for t in range(N):
-
-    # if logging, log and also use "try statement"
-    if (logging == True):
-        # take a step (but ignore errors)
-        try:
-            s.step()
-        except:
-            print "Broken (run with logging=False for errormessage)!"
-            break
-        # log the step
-        l.log()
-    # otherwise just make steps.
-    else:
-        s.step()
-
-s.stop(s.t)
-
-if (logging == True):
-    l.stop()
diff --git a/transitiontools.py b/transitiontools.py
index 2eb35aef..5d63c3a2 100644
--- a/transitiontools.py
+++ b/transitiontools.py
@@ -43,9 +43,9 @@ def __init__(self, testShell, start_position):
     def process_new_position_vector(self, old_pos, displacement):
                 
         # Construct the new position using the deflection function of the target surface            
-        new_pos = self.target_structure.deflect(old_pos, displacement)        
+        new_pos, changeflag = self.target_structure.deflect(old_pos, displacement)        
                 
-        if numpy.alltrue(new_pos == (old_pos + displacement) ) :    # FIXME will this not fail at some point?
+        if changeflag==0 :
             # The new position is still in the old surface;
             new_structure_id = self.origin_structure.id  # i.e. no change here
         else :

From 09ffb2e1f6f9a180327385bd8dafc0aa10152ceb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 5 Apr 2012 18:52:45 +0200
Subject: [PATCH 0765/1541] added comments and some minor changes

---
 CuboidalRegion.hpp     |   4 +-
 CylindricalSurface.hpp |   2 +-
 PlanarSurface.hpp      |   2 +-
 Structure.hpp          |   1 +
 World.hpp              |   1 +
 bd.py                  |   6 ++-
 binding/Structure.hpp  |   3 +-
 newBDPropagator.hpp    | 114 ++++++++++++++++++++++++-----------------
 8 files changed, 80 insertions(+), 53 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 821540cd..cf208f68 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -127,11 +127,11 @@ class CuboidalRegion
         return position_pair_type(); //No special geminate dissociation 'from' the bulk
     }
     
-    /* Determine if particle has bouned from the surface */
+    /* Determine if particle has bounced from the surface */
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
         length_type const& dist_to_surface, length_type const& particle_radius) const
     {       
-        return false; //Can't use cuboidal region as surface jet.
+        return false; //Can't bounce from a cuboidal region.
     }
     
     virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 3b43ba24..32409351 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -191,7 +191,7 @@ class CylindricalSurface
         return pp01;
     }
 
-    /* Determine if particle has bouned from the surface. */
+    /* Determine if particle has crossed the 'surface' of the structure. */
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
         length_type const& dist_to_surface, length_type const& particle_radius) const
     {       
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 6077e303..aef8252e 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -174,7 +174,7 @@ class PlanarSurface
         
     }
     
-    /* Determine if particle has bouned from the surface */
+    /* Determine if particle has moved through the surface */
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
         length_type const& dist_to_surface, length_type const& particle_radius) const
     {       
diff --git a/Structure.hpp b/Structure.hpp
index ef64c75d..aeb669a8 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -90,6 +90,7 @@ class Structure
 
     // Methods used in the 'new' BDPropagator
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
+    // TODO rename bounced to smt else. It denotes whether a particle has crossed the 'surface' of the structure.
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, length_type const& dist_to_surface, length_type const& particle_radius) const = 0;
     virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const = 0;
 
diff --git a/World.hpp b/World.hpp
index 517c0ed5..ea407979 100644
--- a/World.hpp
+++ b/World.hpp
@@ -453,6 +453,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         default_structure_id_ = id;
     }
     // Get the closest surface(surface is a subclass of structures)
+    // TODO change this to get all the surfaces within a certain distance of the particle.
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
     {       
         length_type const world_size( base_type::world_size() );
diff --git a/bd.py b/bd.py
index 54cd0af4..78a2f16b 100644
--- a/bd.py
+++ b/bd.py
@@ -94,7 +94,11 @@ def check(self):
             assert not self.tx.check_overlap(pp)
 
 class BDSimulator(ParticleSimulatorBase):
-    def __init__(self, world, rng, network_rules):
+    def __init__(self, world, rng, network_rules=None):
+
+        if network_rules == None:
+            network_rules = NetworkRulesWrapper(world.model.network_rules)
+
         ParticleSimulatorBase.__init__(self, world, rng, network_rules)
         self.is_dirty = True
         self.core = BDSimulatorCore(self.world, self.rng, self.network_rules,
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 3bbe38a1..9d31f9b5 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -16,8 +16,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
 
     // registering converters from standard boost templates
     // registers the projected_point/projected_distance tuple defined in ../Structure.hpp
-    peer::converters::register_tuple_converter<
-            typename impl_type::projected_type>();
+    peer::converters::register_tuple_converter<typename impl_type::projected_type>();
 
     // defining the python class
     // TODO add name and change id->real_id
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 213efaa9..ad9a7490 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -105,10 +105,10 @@ class newBDPropagator
 
 
         /* Consider decay reactions first. Particles can move after decay, but this is done
-           inside the 'attempt_reaction' function. */
+           inside the 'attempt_single_reaction' function. */
         try
         {
-            if (attempt_reaction(pp))
+            if (attempt_single_reaction(pp))
                 return true;
         }
         catch (propagation_error const& reason)
@@ -129,7 +129,7 @@ class newBDPropagator
         structure_id_and_distance_pair  struct_id_distance_pair;
         length_type                     particle_surface_distance = 0;
         position_type                   new_pos;
-//        structure_id_type               new_structure;
+        structure_id_type               new_structure_id;
 
         //// 2. New position
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
@@ -142,63 +142,79 @@ class newBDPropagator
                                                                             std::sqrt(2.0 * pp_species.D() * dt_),
                                                                             rng_) );
 
-            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
             // TODO check if the new position is actually still in the structure
-//            new_structure_id = pp_structure->deflect();
+            // else
+            // get 'connecting' structure and apply deflection. Should we do this recursively until the coordinate stays in the currents structure?
+            // This actually kinda similar to the boundary condition application.
+            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
+            new_structure_id = pp.second.structure_id(); //pp_structure->deflect();
         }
         else
         {
             new_pos = old_pos;
-//            new_structure_id = pp.second.structure_id();
+            new_structure_id = pp.second.structure_id();
         }
         
+        // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
 	       We use it to check for overlaps with other particles. */
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                 tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
         int particles_in_overlap(overlapped ? overlapped->size(): 0);
+        bool bounced( false );
+
 
+        //// 3.1 Check for core overlaps with particles
         /* Check if the particle at new_pos overlaps with any particle cores. */        
-        bool bounced( false );
         int j( 0 );
         while(!bounced && j < particles_in_overlap)
             bounced = overlapped->at(j++).second < r0;
         
+        //// 3.2 Check for core overlaps structures
         /* If the particle has not bounced with another particle and lives in the bulk: 
            check for core overlap with a surface. */
-        // TODO maybe always check for overlaps with surface ignoring its own surface? (regardless of in bulk)
+        // TODO always check for overlaps with surface ignoring its own surface (regardless of in bulk)
         if(!bounced && pp.second.structure_id() == tx_.get_def_structure_id())
         {
-            struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp.second.structure_id());
-            particle_surface_distance = struct_id_distance_pair.second;
+            // TODO Get all the structures within the reaction volume (and that may consequently also be in the core)
+            struct_id_distance_pair = tx_.get_closest_surface( new_pos, new_structure_id);
 
             /* Check for overlap with nearest surface. */
+            // TODO check all the surfaces while bounced != true.
+            particle_surface_distance = struct_id_distance_pair.second;
             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
             bounced = closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
                                                tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
                                                particle_surface_distance, r0);
         }
          
-        /* If particle is bounced, check reaction_volume for reaction partners at old_pos. */
+        //// 4. Finalize the position
+        /* If particle is bounced, restore old position and check reaction_volume for reaction partners at old_pos. */
         if(bounced)
         {
+            // restore old position and structure_id
             new_pos = old_pos;
+            new_structure_id = pp.second.structure_id();
             
+            // re-get the reaction partners (particles), now on old position.
             boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_after_bounce( 
-                    tx_.check_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), 
-                            pp.first) );
-                            
-            overlapped.swap( overlapped_after_bounce );
+                    tx_.check_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first) );
+            overlapped.swap( overlapped_after_bounce );     // FIXME is there no better way?
                                             
             particles_in_overlap = overlapped ? overlapped->size(): 0; 
             
+            // re-get the reaction partners (structures), at old position. TODO don't just do this when in the bulk.
             if(pp.second.structure_id() == tx_.get_def_structure_id())
             {
+                // TODO get all near surfaces instead of just the closest.
                 struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp.second.structure_id() );
+                // TODO get the number of surfaces.
                 particle_surface_distance = struct_id_distance_pair.second;  
             }
         }
         
+
+        //// 5.
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
         Real accumulated_prob = 0;
@@ -206,10 +222,14 @@ class newBDPropagator
         
         /* First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction. */
         // TODO also interaction should be allowed when a particle is on a cylinder.
+        // TODO don't check only the closest but check all overlapping surfaces.
         if( pp.second.structure_id() == tx_.get_def_structure_id())
         {
+            // TODO get all the surfaces that overlap with the reaction volume (depends on current structure)
             boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure( struct_id_distance_pair.first) );
 
+            // TODO check that the projected point of the position of the particle is in the surface. If not, than no
+            // reaction is possible.
             if( closest_surf->in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
             {        
                 accumulated_prob += k_total( pp.second.sid(), closest_surf->sid() ) * dt_ / 
@@ -238,13 +258,14 @@ class newBDPropagator
                 else                
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
-                               boost::lexical_cast<std::string>(closest_surf->real_id()).c_str()));
+                               boost::lexical_cast<std::string>(closest_surf->real_id()).c_str()));     // TODO is this the correct interpretation?
                     ++rejected_move_count_;
                 }
             }
 
         }
         
+        ////
         /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
         while(j < particles_in_overlap)
@@ -295,7 +316,7 @@ class newBDPropagator
             else                
             {
                 LOG_DEBUG(("Particle attempted a reaction with a non-reactive particle %s.", 
-                    boost::lexical_cast<std::string>(closest.first.first).c_str()));
+                    boost::lexical_cast<std::string>(closest.first.first).c_str()));    // TODO is this really a rejected move?
                 ++rejected_move_count_;
             }
             
@@ -308,7 +329,7 @@ class newBDPropagator
             particle_id_pair particle_to_update( pp.first, 
                                                  particle_type(pp_species.id(),
                                                                particle_shape_type(new_pos, r0),
-                                                               pp.second.structure_id(),
+                                                               new_structure_id,
                                                                pp_species.D(),
                                                                pp_species.v()) );
                 
@@ -334,7 +355,26 @@ class newBDPropagator
 
 private:
 
-    bool attempt_reaction(particle_id_pair const& pp)
+    /* Function returns the accumulated intrinsic reaction rate between to species. */
+    Real k_total(species_id_type const& s0_id, species_id_type const& s1_id)
+    {   
+        reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
+        if(::size(rules) == 0)
+        {
+            return 0;
+        }
+
+        Real k_tot = 0;
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            k_tot += (*i).k();
+        }
+        
+        return k_tot;
+    }
+
+    bool attempt_single_reaction(particle_id_pair const& pp)
     // Handles only monomolecular reactions?
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
@@ -353,12 +393,11 @@ class newBDPropagator
             prob += r.k();
             if (prob > rnd)
             {
-                typename reaction_rule_type::species_id_range products(
-                        r.get_products());
+                typename reaction_rule_type::species_id_range products(r.get_products());
                 switch (::size(products))
                 {
                 case 0:
-                    tx_.remove_particle(pp.first);
+                    tx_.remove_particle(pp.first);          // FIXME how come the local method 'remove_particle' is not called?
                     break;
 
                 case 1:
@@ -541,26 +580,6 @@ class newBDPropagator
         return false;
     }
         
-    /* Function returns the accumulated intrinsic reaction rate between to species. */
-    Real k_total(species_id_type const& s0_id, species_id_type const& s1_id)
-    {   
-        reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
-        if(::size(rules) == 0)
-        {
-            return 0;
-        }
-
-        Real k_tot = 0;
-        for (typename boost::range_const_iterator<reaction_rules>::type
-                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
-        {
-            k_tot += (*i).k();
-        }
-        
-        return k_tot;
-    }
-    
-    
     bool fire_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1, species_type const& s0, species_type const& s1)
     // This handles the reaction between a pair of particles.
     // unclear what the convention for pp0, pp1 and s0,s1 is with regard to being in 3D/2D.
@@ -799,24 +818,27 @@ class newBDPropagator
     position_type const make_move(species_type const& s0, position_type const& old_pos, particle_id_type const& ignore)
     // generates a move for a particle.
     {
+
+        // FIXME this is just redoing what we are doing above when moving a particle.
+
         if(s0.D() == 0)
             return old_pos;
     
         boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( tx_.get_particle(ignore).second.structure_id() ) );
 
-        position_type displacement( s0_struct->
-                                    bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
-
+        position_type displacement( s0_struct->bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
         position_type new_pos(tx_.apply_boundary( add( old_pos, displacement ) ));
+        // TODO apply deflection
                         
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( 
                                     tx_.check_overlap(
                                     particle_shape_type(new_pos, s0.radius()),
                                     ignore));
                                                                 
+        // See if it overlaps with any particles
         if ( (overlapped && overlapped->size() > 0) )
             return old_pos;
-        
+        // See if it overlaps with any surfaces.
         if(s0.structure_type_id() == tx_.get_def_structure_type_id())
         {
             structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_particle(ignore).second.structure_id() ) );

From 21baeb2dab309a8b14a27e7ffe954185c492dbba Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Apr 2012 15:02:29 +0200
Subject: [PATCH 0766/1541] cleanup of make_pair_move and make_move methods and
 some namechanges/cleanup

---
 newBDPropagator.hpp | 116 +++++++++++++++++++++++---------------------
 1 file changed, 62 insertions(+), 54 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index ad9a7490..f6d29be3 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -246,7 +246,7 @@ class newBDPropagator
                     try
                     {
                         LOG_DEBUG(("fire surface interaction"));
-                        if(fire_interaction(pp, closest_surf ))
+                        if(attempt_interaction(pp, closest_surf ))
                             return true;
                     }   
                     catch (propagation_error const& reason)
@@ -259,7 +259,7 @@ class newBDPropagator
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
                                boost::lexical_cast<std::string>(closest_surf->real_id()).c_str()));     // TODO is this the correct interpretation?
-                    ++rejected_move_count_;
+//                    ++rejected_move_count_;
                 }
             }
 
@@ -304,7 +304,7 @@ class newBDPropagator
                 LOG_DEBUG(("fire reaction"));
     		    try
                 {
-                    if( fire_reaction(pp, closest.first, s0, s1) )
+                    if( attempt_pair_reaction(pp, closest.first, s0, s1) )
                         return true;
                 }
                 catch (propagation_error const& reason)
@@ -315,9 +315,9 @@ class newBDPropagator
             }
             else                
             {
-                LOG_DEBUG(("Particle attempted a reaction with a non-reactive particle %s.", 
+                LOG_DEBUG(("Particle attempted a reaction with particle %s and failed.", 
                     boost::lexical_cast<std::string>(closest.first.first).c_str()));    // TODO is this really a rejected move?
-                ++rejected_move_count_;
+//                ++rejected_move_count_;
             }
             
             j++;
@@ -580,7 +580,7 @@ class newBDPropagator
         return false;
     }
         
-    bool fire_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1, species_type const& s0, species_type const& s1)
+    bool attempt_pair_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1, species_type const& s0, species_type const& s1)
     // This handles the reaction between a pair of particles.
     // unclear what the convention for pp0, pp1 and s0,s1 is with regard to being in 3D/2D.
     {
@@ -702,7 +702,7 @@ class newBDPropagator
     }
 
         
-    bool fire_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& surface)
+    bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& surface)
     // This handles the 'reaction' (interaction) between a particle and a surface.
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), surface->sid() ));
@@ -783,73 +783,81 @@ class newBDPropagator
     
     /* Given a position pair and two species, the function generates two new 
        positions based on two moves drawn from the free propagator. */
-    position_pair_type const make_pair_move(species_type const& s0, species_type const& s1, position_pair_type const& pp01, 
-                                            particle_id_type const& ignore)
+    const position_pair_type make_pair_move(species_type const& s0, species_type const& s1,
+                                            position_pair_type const& pos0_pos1, particle_id_type const& ignore) const
     {
-//        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( s0.structure_id() ) );
-//        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( s1.structure_id() ) );
-
-        length_type const r01( s0.radius() + s1.radius() );
+        const length_type min_distance_01( s0.radius() + s1.radius() );
         
-        position_type temp_pos0, temp_pos1;
-        position_pair_type new_pp01( pp01 );
+        position_type temp_pos0(pos0_pos1.first),
+                      temp_pos1(pos0_pos1.second);
         
         //Randomize which species moves first, and if there will be one or two moves. (50% of the cases)
-        bool move_prt0_first( rng_.uniform_int(0, 1) );
-        int move_count( 1 + rng_.uniform_int(0, 1) );
+        int  move_count( 1 + rng_.uniform_int(0, 1) );  // determine number of particles to move (1 or 2)
+        bool move_first( rng_.uniform_int(0, 1) );      // Set to true if the first particle is moved, false means second particle.
         while( move_count-- )
         {
-            if( move_prt0_first )
+            if( move_first )
+            // Move the first particle
             {
-                temp_pos0 = make_move(s0, pp01.first, ignore);
-                new_pp01.first = tx_.distance(temp_pos0, new_pp01.second) - r01 < 0 ? pp01.first : temp_pos0;
+                temp_pos0 = make_move(s0, pos0_pos1.first, ignore);
+                // check for overlap with the second particle (and potentially revert move)
+                temp_pos0 = tx_.distance(temp_pos0, temp_pos1) - min_distance_01 < 0 ? pos0_pos1.first : temp_pos0;
             }                       
             else
+            // Move the second particle
             {
-                temp_pos1 = make_move(s1, pp01.second, ignore);
-                new_pp01.second = tx_.distance(temp_pos1, new_pp01.first) - r01 < 0 ? pp01.second : temp_pos1;
+                temp_pos1 = make_move(s1, pos0_pos1.second, ignore);
+                // check for overlap with the first particle (and potentially revert move)
+                temp_pos1 = tx_.distance(temp_pos1, temp_pos0) - min_distance_01 < 0 ? pos0_pos1.second : temp_pos1;
             }
-            move_prt0_first = !move_prt0_first;
+
+            // Swap what particle to move
+            move_first = !move_first;
         }  
             
-        return new_pp01;
+        return std::make_pair(temp_pos0, temp_pos1);
     }
 
-    position_type const make_move(species_type const& s0, position_type const& old_pos, particle_id_type const& ignore)
-    // generates a move for a particle.
+    const position_type make_move(species_type const& species, position_type const& old_pos, particle_id_type const& ignore) const
+    // generates a move for a particle and checks if the move was allowed.
     {
 
         // FIXME this is just redoing what we are doing above when moving a particle.
+        position_type new_pos;
 
-        if(s0.D() == 0)
-            return old_pos;
-    
-        boost::shared_ptr<structure_type> s0_struct( tx_.get_structure( tx_.get_particle(ignore).second.structure_id() ) );
+        if(species.D() == 0)
+        {
+            new_pos = old_pos;
+//            new_structure_id = old_structure_id;
+        }
+        else
+        {
+            const boost::shared_ptr<const structure_type> s0_struct( tx_.get_structure( tx_.get_particle(ignore).second.structure_id() ) );
 
-        position_type displacement( s0_struct->bd_displacement(s0.v() * dt_, std::sqrt(2.0 * s0.D() * dt_), rng_) );
-        position_type new_pos(tx_.apply_boundary( add( old_pos, displacement ) ));
-        // TODO apply deflection
+            const position_type displacement( s0_struct->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
+            new_pos = tx_.apply_boundary( add( old_pos, displacement ) );
+            // TODO apply deflection
                         
-        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped( 
-                                    tx_.check_overlap(
-                                    particle_shape_type(new_pos, s0.radius()),
-                                    ignore));
+            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped( 
+                                        tx_.check_overlap(
+                                        particle_shape_type(new_pos, species.radius()),
+                                        ignore));
                                                                 
-        // See if it overlaps with any particles
-        if ( (overlapped && overlapped->size() > 0) )
-            return old_pos;
-        // See if it overlaps with any surfaces.
-        if(s0.structure_type_id() == tx_.get_def_structure_type_id())
-        {
-            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_particle(ignore).second.structure_id() ) );
-            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+            // See if it overlaps with any particles
+            if ( (overlapped && overlapped->size() > 0) )
+                return old_pos;
+            // See if it overlaps with any surfaces.
+            if(species.structure_type_id() == tx_.get_def_structure_type_id())
+            {
+                const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_particle(ignore).second.structure_id() ) );
+                const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
-            if( closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
-                                         tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
-                                         struct_id_distance_pair.second, s0.radius() ) )    
-                return old_pos;        
-        }
-            
+                if( closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
+                                             tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
+                                             struct_id_distance_pair.second, species.radius() ) )    
+                    return old_pos;        
+            }
+        }    
         return new_pos;
     }
     
@@ -875,13 +883,13 @@ class newBDPropagator
     particle_container_type&    tx_;            // The 'ParticleContainer' object that contains the particles.
     network_rules_type const&   rules_;
     rng_type&                   rng_;
-    Real const                  dt_;
-    int const                   max_retry_count_;
+    const Real                  dt_;
+    const int                   max_retry_count_;
     reaction_recorder_type* const rrec_;
     volume_clearer_type* const  vc_;
     particle_id_vector_type     queue_;
     int                         rejected_move_count_;
-    Real const                  reaction_length_;
+    const Real                  reaction_length_;
     static Logger&              log_;
 };
 

From 92bf04262dfa223d9d3f306bf4d9612a4af0c2a5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Apr 2012 17:47:20 +0200
Subject: [PATCH 0767/1541] Cleanup of attempt_interaction and more cleanup on
 newBDPropagator

---
 newBDPropagator.hpp | 114 ++++++++++++++++++++++++++------------------
 1 file changed, 68 insertions(+), 46 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index f6d29be3..8a4f46d8 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -356,21 +356,24 @@ class newBDPropagator
 private:
 
     /* Function returns the accumulated intrinsic reaction rate between to species. */
-    Real k_total(species_id_type const& s0_id, species_id_type const& s1_id)
+    /* Note that the species_id_type is equal to the structure_type_id_type for structure_types */
+    const Real k_total(species_id_type const& s0_id, species_id_type const& s1_id) const
     {   
+        Real k_tot (0);
         reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
-        if(::size(rules) == 0)
-        {
-            return 0;
-        }
 
-        Real k_tot = 0;
-        for (typename boost::range_const_iterator<reaction_rules>::type
-                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
-        {
-            k_tot += (*i).k();
-        }
-        
+//        if(::size(rules) != 0)
+//        {
+//            return 0;
+//        }
+//        else
+//        {
+            for (typename boost::range_const_iterator<reaction_rules>::type
+                    i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+            {
+                k_tot += (*i).k();
+            }
+//        }
         return k_tot;
     }
 
@@ -702,14 +705,15 @@ class newBDPropagator
     }
 
         
-    bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& surface)
+    const bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& surface)
     // This handles the 'reaction' (interaction) between a particle and a surface.
+    // Returns True if the interaction was succesfull
     {
+        // Get the reaction rules for the interaction with this surface.
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), surface->sid() ));
         if (::size(rules) == 0)
             throw propagation_error("trying to fire an interaction with a non-interactive surface");
         
-        const species_type s0(tx_.get_species(pp.second.sid()));
                 
         const Real k_tot( k_total(pp.second.sid(), surface->sid()) );
         const Real rnd( k_tot * rng_() );
@@ -718,66 +722,74 @@ class newBDPropagator
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
-            reaction_rule_type const& r(*i); 
-            prob += r.k();
+            reaction_rule_type const& reaction_rule(*i); 
+            prob += reaction_rule.k();
 
-            if (prob > rnd)
+            if (prob >= rnd)
+            // We have found the reaction rule that is in effect
             {
-                const typename reaction_rule_type::species_id_range products(
-                    r.get_products());
+                // get the products
+                const typename reaction_rule_type::species_id_range products(reaction_rule.get_products());
 
                 switch (::size(products))
                 {
-                case 1:
+                    // When no products
+                    case 0:
                     {
-                        const species_id_type product(products[0]);
-                        const species_type sp(tx_.get_species(product));
+                        remove_particle(pp.first);
+                        break;
+                    }
+                    // When one product particle
+                    case 1:
+                    {
+                        const species_type product_species(tx_.get_species(products[0]));
 
+                        // Get the new position of the particle on the surface
                         const position_type new_pos( tx_.apply_boundary( surface->projected_point( pp.second.position() ).first ) );
                             
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
-                            tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
-                                              pp.first));
+                        // check for overlap with particles that are in the propagator
+                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped(
+                            tx_.check_overlap(particle_shape_type(new_pos, product_species.radius()), pp.first));
                         if (overlapped && overlapped->size() > 0)
                         {
                             throw propagation_error("no space");
                         }
-
+                        // check for overlap with particles outside of the progator (e.g. the eGFRD simulator)
                         if (vc_)
                         {
                             if (!(*vc_)(
-                                    particle_shape_type(new_pos, sp.radius()), 
+                                    particle_shape_type(new_pos, product_species.radius()), 
                                     pp.first))
                             {
                                 throw propagation_error("no space (vc)");
                             }
                         }
+                        // TODO check overlap with surfaces.
 
+                        // Process changes
                         remove_particle(pp.first);
-                        const particle_id_pair product_particle( tx_.new_particle(sp.id(), surface->real_id(), new_pos) );
+                        // Make new particle in interaction surface 
+                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), surface->real_id(), new_pos) );
+                        // Record changes
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(product_particle.first), pp.first));
+                                    reaction_rule.id(), array_gen(product_particle.first), pp.first));
                         }
                         break;
                     }
-                case 0:
-                    {
-                        remove_particle(pp.first);
-                        break;
-                    }
-                
-                default:
-                    throw not_implemented("surface interactions that produce more than one product are not supported");
+                    // When number of products was not '0' or '1'
+                    default:
+                        throw not_implemented("surface interactions that produce more than one product are not supported");
                 }
-
+                // After we processed the reaction, we return.
                 return true;
             }
         }
         //should not reach here.
-        return false;
+        throw illegal_state("Surface interaction failed, no interaction selected.");
+//        return false;
     }
     
     
@@ -823,7 +835,8 @@ class newBDPropagator
     {
 
         // FIXME this is just redoing what we are doing above when moving a particle.
-        position_type new_pos;
+        position_type     new_pos(old_pos);
+        structure_id_type new_structure_id();
 
         if(species.D() == 0)
         {
@@ -862,21 +875,30 @@ class newBDPropagator
     }
     
     void remove_particle(particle_id_type const& pid)
+    // Removes a particle from the propagator and particle container.
     {
         LOG_DEBUG(("remove particle %s", boost::lexical_cast<std::string>(pid).c_str()));
+
         tx_.remove_particle(pid);
         typename particle_id_vector_type::iterator i(
             std::find(queue_.begin(), queue_.end(), pid));
         if (queue_.end() != i)
+        {
             queue_.erase(i);
+        }
+        else
+        {
+            throw not_found(std::string("Unknown particle (id=") + boost::lexical_cast<std::string>(pid) + ")");
+        }
     }
 
-private:
-    position_type random_unit_vector()
-    {
-        position_type v(rng_() - .5, rng_() - .5, rng_() - .5);
-        return v / length(v);
-    }
+
+//private:
+//    position_type random_unit_vector()
+//    {
+//        position_type v(rng_() - .5, rng_() - .5, rng_() - .5);
+//        return v / length(v);
+//    }
 
 ////// Member variables
 private:

From dcbfb9715a8cfb478fa94646c3bc6fe6c8a7bdac Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 6 Apr 2012 18:55:46 +0200
Subject: [PATCH 0768/1541] adding comments to attempt_pair_reaction and some
 cleanup

---
 newBDPropagator.hpp | 115 ++++++++++++++++++++++++--------------------
 1 file changed, 63 insertions(+), 52 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 8a4f46d8..82927bf1 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -378,7 +378,7 @@ class newBDPropagator
     }
 
     bool attempt_single_reaction(particle_id_pair const& pp)
-    // Handles only monomolecular reactions?
+    // Handles all monomolecular reactions
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
         if (::size(rules) == 0)
@@ -583,36 +583,46 @@ class newBDPropagator
         return false;
     }
         
-    bool attempt_pair_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1, species_type const& s0, species_type const& s1)
+    const bool attempt_pair_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1,
+                                     species_type const& s0, species_type const& s1)
     // This handles the reaction between a pair of particles.
     // unclear what the convention for pp0, pp1 and s0,s1 is with regard to being in 3D/2D.
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
         if(::size(rules) == 0)
-            throw propagation_error("trying to fire a reaction between non-reactive particles");
-        
-//        boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( pp1.structure_id() ) );
+            throw propagation_error("trying to fire a reaction between particles without a reaction rule.");
         
         const Real k_tot( k_total(pp0.second.sid(), pp1.second.sid()) );
         const Real rnd( k_tot * rng_() );
-        Real prob = 0;    
+        Real k_cumm = 0;    
         
+        // select one of the available reaction rules that led to the pair reaction
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
-            reaction_rule_type const& r(*i);  
-            prob += r.k();
-            if (prob > rnd)
+            reaction_rule_type const& reaction_rule(*i);  
+            k_cumm += reaction_rule.k();
+
+            if (k_cumm >= rnd)
+            // We have found the reaction rule that is in effect
             {
-                const typename reaction_rule_type::species_id_range products(
-                    r.get_products());
+                // get the products
+                const typename reaction_rule_type::species_id_range products(reaction_rule.get_products());
 
                 switch (::size(products))
                 {
-                case 1:
+                    // When no products
+                    case 0:
                     {
-                        const species_id_type product(products[0]);
-                        const species_type sp(tx_.get_species(product));
+                        remove_particle(pp0.first);
+                        remove_particle(pp1.first);
+                        break;
+                    }
+                    // When one product particle
+                    case 1:
+                    {
+//                        const species_id_type product(products[0]);
+                        const species_type product_species(tx_.get_species(products[0]));
                         
                         position_type new_pos( tx_.apply_boundary(
                                         divide(
@@ -621,10 +631,12 @@ class newBDPropagator
                                                 pp1.second.position(),
                                                 pp0.second.position()), s0.D())),
                                         (s0.D() + s1.D()))) );
+
+//                        position_type new_pos (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D());
                         structure_id_type new_structure_id;
 
                         //For unequal structures, project new_pos on surface.
-                        if(sp.structure_type_id() != s1.structure_type_id())
+                        if(product_species.structure_type_id() != s1.structure_type_id())
                         {
                             // make sure that pp1 is the particle that is in 3D.
                             // FIXME Ugly!!
@@ -641,67 +653,69 @@ class newBDPropagator
                             projected_type const position_on_surface( sp_struct->
                                                                       projected_point( tx_.cyclic_transpose( new_pos, 
                                                                                                              sp_struct->position() ) ) );
-                            
+                            // check that the projected point is not outside of the product surface.
+                            if (sp_struct->distance( position_on_surface.first) < 0)
+                                throw propagation_error("position product particle was not in surface.");
                             new_pos = tx_.apply_boundary( position_on_surface.first );
                         }
 
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
-                            tx_.check_overlap(particle_shape_type(new_pos, sp.radius()),
+
+                        // check for overlap with particles that are inside the propagator
+                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped(
+                            tx_.check_overlap(particle_shape_type(new_pos, product_species.radius()),
                                               pp0.first, pp1.first));
                         if( overlapped && overlapped->size() > 0 )
                         {
                             throw propagation_error("no space due to particle");
                         }
-
+                        // check for overlap with particles outside of the propagator (for example the eGFRD simulator)
                         if( vc_ )
                         {
                             if (!(*vc_)(
-                                    particle_shape_type(new_pos, sp.radius()), 
+                                    particle_shape_type(new_pos, product_species.radius()), 
                                     pp0.first, pp1.first))
                             {
                                 throw propagation_error("no space due to particle (vc)");
                             }
                         }
                         
-                        // If the product lives in the bulk
-                        if( sp.structure_type_id() == tx_.get_def_structure_type_id() )
+                        // Check overlap with surfaces
+                        if( product_species.structure_type_id() == tx_.get_def_structure_type_id() )
                         {
-                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_def_structure_id() ) );
-                            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+                            const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_def_structure_id() ) );
+                            const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
                             if( closest_struct->bounced( tx_.cyclic_transpose( pp0.second.position(), closest_struct->position() ), 
                                                          tx_.cyclic_transpose( pp1.second.position(), closest_struct->position() ), 
-                                                         struct_id_distance_pair.second, sp.radius() ) )
+                                                         struct_id_distance_pair.second, product_species.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
 
+
+                        // Process changes
                         remove_particle(pp0.first);
                         remove_particle(pp1.first);
-                        particle_id_pair npp(tx_.new_particle(product, new_structure_id, new_pos));
+                        // Make new particle on right structure
+                        particle_id_pair product_particle(tx_.new_particle(product_species.id(), new_structure_id, new_pos));
+                        // Record changes
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(npp.first), pp0.first, pp1.first));
+                                    reaction_rule.id(), array_gen(product_particle.first), pp0.first, pp1.first));
                         }
                         break;
                     }
-                case 0:
-                    {
-                        remove_particle(pp0.first);
-                        remove_particle(pp1.first);
-                        break;
-                    }
-                
-                default:
-                    throw not_implemented("bimolecular reactions that produce more than one product are not supported");
+                    // When number of products was not '0' or '1'
+                    default:
+                        throw not_implemented("bimolecular reactions that produce more than one product are not supported");
                 }
-                
+                // After we processed the reaction, we return -> no other reaction should be done.
                 return true;
             }
         }
         //Should not reach here.
-        return false;
+        throw illegal_state("Pair reaction failed, no reaction selected when reaction was supposed to happen.");
     }
 
         
@@ -712,20 +726,20 @@ class newBDPropagator
         // Get the reaction rules for the interaction with this surface.
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), surface->sid() ));
         if (::size(rules) == 0)
-            throw propagation_error("trying to fire an interaction with a non-interactive surface");
+            throw propagation_error("trying to fire an interaction with a surface without a reaction rule.");
         
                 
         const Real k_tot( k_total(pp.second.sid(), surface->sid()) );
         const Real rnd( k_tot * rng_() );
-        Real prob = 0;  
+        Real k_cumm = 0;  
 
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
             reaction_rule_type const& reaction_rule(*i); 
-            prob += reaction_rule.k();
+            k_cumm += reaction_rule.k();
 
-            if (prob >= rnd)
+            if (k_cumm >= rnd)
             // We have found the reaction rule that is in effect
             {
                 // get the products
@@ -783,16 +797,17 @@ class newBDPropagator
                     default:
                         throw not_implemented("surface interactions that produce more than one product are not supported");
                 }
-                // After we processed the reaction, we return.
+                // After we processed the reaction, we return -> no other reaction should be done.
                 return true;
             }
         }
         //should not reach here.
-        throw illegal_state("Surface interaction failed, no interaction selected.");
-//        return false;
+        throw illegal_state("Surface interaction failed, no interaction selected when interaction was supposed to happen.");
     }
     
     
+
+
     /* Given a position pair and two species, the function generates two new 
        positions based on two moves drawn from the free propagator. */
     const position_pair_type make_pair_move(species_type const& s0, species_type const& s1,
@@ -874,6 +889,9 @@ class newBDPropagator
         return new_pos;
     }
     
+
+
+
     void remove_particle(particle_id_type const& pid)
     // Removes a particle from the propagator and particle container.
     {
@@ -893,13 +911,6 @@ class newBDPropagator
     }
 
 
-//private:
-//    position_type random_unit_vector()
-//    {
-//        position_type v(rng_() - .5, rng_() - .5, rng_() - .5);
-//        return v / length(v);
-//    }
-
 ////// Member variables
 private:
     particle_container_type&    tx_;            // The 'ParticleContainer' object that contains the particles.

From c34413bb5c3934f0206b49e61a42da13cb5c07fd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 10 Apr 2012 15:20:10 +0200
Subject: [PATCH 0769/1541] cleanup: changed variable names, added consts,
 added comments, re-ordered methods.

---
 newBDPropagator.hpp | 380 ++++++++++++++++++++++++--------------------
 1 file changed, 206 insertions(+), 174 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 82927bf1..a2f020f1 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -85,6 +85,8 @@ class newBDPropagator
         shuffle(rng, queue_);
     }
 
+
+    //// MAIN 'step' method 
     // This method is called to process the change of position and putative reaction of every particle.
     // The method only treats one particle at a time and returns 'True' as long as there are still particles
     //    in the container that need to be processed.
@@ -121,15 +123,16 @@ class newBDPropagator
 
         //// 1.?
         // Get info of the particle
-        species_type const                      pp_species(tx_.get_species(pp.second.sid()));
-        length_type const                       r0( pp_species.radius() );
-        position_type const                     old_pos( pp.second.position() );
-        boost::shared_ptr<structure_type> const pp_structure( tx_.get_structure( pp.second.structure_id() ) );
+        const species_type                            pp_species(tx_.get_species(pp.second.sid()));
+        const length_type                             r0( pp_species.radius() );
+        const position_type                           old_pos( pp.second.position() );
+        const structure_id_type                       old_struct_id(pp.second.structure_id());
+        const boost::shared_ptr<const structure_type> pp_structure( tx_.get_structure( old_struct_id ) );
         // declare variables to use
         structure_id_and_distance_pair  struct_id_distance_pair;
-        length_type                     particle_surface_distance = 0;
+        length_type                     particle_surface_distance (0);
         position_type                   new_pos;
-        structure_id_type               new_structure_id;
+        structure_id_type               new_structure_id( old_struct_id );
 
         //// 2. New position
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
@@ -138,7 +141,7 @@ class newBDPropagator
         if (pp_species.D() != 0.)
         {
             // get a new position, dependent on the structure the particle lives on.
-            position_type const displacement( pp_structure->bd_displacement(pp_species.v() * dt_,
+            const position_type displacement( pp_structure->bd_displacement(pp_species.v() * dt_,
                                                                             std::sqrt(2.0 * pp_species.D() * dt_),
                                                                             rng_) );
 
@@ -146,13 +149,12 @@ class newBDPropagator
             // else
             // get 'connecting' structure and apply deflection. Should we do this recursively until the coordinate stays in the currents structure?
             // This actually kinda similar to the boundary condition application.
-            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
+            new_pos = tx_.apply_boundary( add( old_pos, displacement ) );
             new_structure_id = pp.second.structure_id(); //pp_structure->deflect();
         }
         else
         {
             new_pos = old_pos;
-            new_structure_id = pp.second.structure_id();
         }
         
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
@@ -259,7 +261,6 @@ class newBDPropagator
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
                                boost::lexical_cast<std::string>(closest_surf->real_id()).c_str()));     // TODO is this the correct interpretation?
-//                    ++rejected_move_count_;
                 }
             }
 
@@ -270,10 +271,10 @@ class newBDPropagator
         j = 0;
         while(j < particles_in_overlap)
         {
-            particle_id_pair_and_distance const& closest( overlapped->at(j) );
+            const particle_id_pair_and_distance & closest( overlapped->at(j) );
 
-            species_type s0(pp_species),
-                         s1(tx_.get_species(closest.first.second.sid()));
+            species_type s0(pp_species);
+            species_type s1(tx_.get_species(closest.first.second.sid()));
                 
             /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
                and we let this be s1, the particle from the surface is named s0. */
@@ -288,7 +289,7 @@ class newBDPropagator
                     std::swap(s0,s1);
             }
             
-            boost::shared_ptr<structure_type> s1_struct( tx_.get_structure( closest.first.second.structure_id()) );
+            const boost::shared_ptr<const structure_type> s1_struct( tx_.get_structure( closest.first.second.structure_id()) );
             const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
             accumulated_prob += k_total(s0.id(), s1.id()) * dt_ / ( 2. * reaction_volume ); 
             
@@ -317,7 +318,6 @@ class newBDPropagator
             {
                 LOG_DEBUG(("Particle attempted a reaction with particle %s and failed.", 
                     boost::lexical_cast<std::string>(closest.first.first).c_str()));    // TODO is this really a rejected move?
-//                ++rejected_move_count_;
             }
             
             j++;
@@ -326,12 +326,12 @@ class newBDPropagator
         /* If the particle did neither react, interact or bounce, update it to it's new position. */
         if(!bounced)
         {   
-            particle_id_pair particle_to_update( pp.first, 
-                                                 particle_type(pp_species.id(),
-                                                               particle_shape_type(new_pos, r0),
-                                                               new_structure_id,
-                                                               pp_species.D(),
-                                                               pp_species.v()) );
+            const particle_id_pair particle_to_update( pp.first, 
+                                                       particle_type(pp_species.id(),
+                                                                     particle_shape_type(new_pos, r0),
+                                                                     new_structure_id,
+                                                                     pp_species.D(),
+                                                                     pp_species.v()) );
                 
             if (vc_)
             {
@@ -348,35 +348,15 @@ class newBDPropagator
         return true;
     }
 
+
+    // Getter of rejected_move
     std::size_t get_rejected_move_count() const
     {
         return rejected_move_count_;
     }
 
+////// Private methods
 private:
-
-    /* Function returns the accumulated intrinsic reaction rate between to species. */
-    /* Note that the species_id_type is equal to the structure_type_id_type for structure_types */
-    const Real k_total(species_id_type const& s0_id, species_id_type const& s1_id) const
-    {   
-        Real k_tot (0);
-        reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
-
-//        if(::size(rules) != 0)
-//        {
-//            return 0;
-//        }
-//        else
-//        {
-            for (typename boost::range_const_iterator<reaction_rules>::type
-                    i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
-            {
-                k_tot += (*i).k();
-            }
-//        }
-        return k_tot;
-    }
-
     bool attempt_single_reaction(particle_id_pair const& pp)
     // Handles all monomolecular reactions
     {
@@ -387,52 +367,65 @@ class newBDPropagator
         }
 
         const Real rnd(rng_() / dt_);
-        Real prob = 0.;
+        Real k_cumm = 0.;
 
+        // select one of the available reaction rules that led to the monomolecular reaction
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
             reaction_rule_type const& r(*i);
-            prob += r.k();
-            if (prob > rnd)
+            k_cumm += r.k();
+
+            if (k_cumm > rnd)
+            // We have found the reaction rule that is in effect
             {
+                // get the products
                 typename reaction_rule_type::species_id_range products(r.get_products());
+
                 switch (::size(products))
                 {
-                case 0:
-                    tx_.remove_particle(pp.first);          // FIXME how come the local method 'remove_particle' is not called?
-                    break;
+                    // When no product particles
+                    case 0:
+                    {
+                        tx_.remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
+                        break;
+                    }
 
-                case 1:
+                    // When one product particle
+                    case 1:
                     {
-                        const species_type s0(tx_.get_species(products[0]));
-                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure(pp.second.structure_id()) );
-                        position_type new_pos = pp.second.position();
-                        structure_id_type new_structure_id(pp.second.structure_id());
+                        const boost::shared_ptr<const structure_type> reactant_structure( tx_.get_structure(pp.second.structure_id()) );
+                        const species_type product_species(tx_.get_species(products[0]));
+
+                        // default values for the position and structure of the product
+                        position_type     new_pos          (pp.second.position());
+                        structure_id_type new_structure_id (pp.second.structure_id());
                         
                         /* If the product particle does NOT live on the same structure type as the reactant => surface -> bulk dissociation. */
-                        if( s0.structure_type_id() != pp_struct->sid() )
+                        if( product_species.structure_type_id() != reactant_structure->sid() )
                         {
-                            if( s0.structure_type_id() != tx_.get_def_structure_type_id() )
+                            // dissociation from a structure_type into another must always be TO the bulk (default structure/structure_type)
+                            if( product_species.structure_type_id() != tx_.get_def_structure_type_id() )
                                 throw not_implemented("No surface -> surface dissociation allowed");
+                            new_structure_id = tx_.get_def_structure_id();
                         
-                            position_type const displacement( pp_struct->surface_dissociation_vector(rng_, s0.radius(), reaction_length_ ) );
-
+                            // get dissociation position.
+                            const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
                             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
                             
                             //Particle is allowed to move after dissociation from surface.
-                            new_pos = make_move(s0, new_pos, pp.first);
-                            new_structure_id = tx_.get_def_structure_id();
+                            new_pos = make_move(product_species, new_pos, pp.first);
                         }
                       
-                        const particle_shape_type new_shape(new_pos, s0.radius());
-                                                    
-                        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_shape, pp.first));
+
+                        const particle_shape_type new_shape(new_pos, product_species.radius());
+                        // check for overlap with particles that are inside the propagator
+                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_shape, pp.first));
                         if (overlapped && overlapped->size() > 0)
                         {
                             throw propagation_error("no space due to other particle");
                         }
-
+                        // check for overlap with particles outside of the propagator (for example the eGFRD simulator)
                         if (vc_)
                         {
                             if (!(*vc_)(new_shape, pp.first))
@@ -441,152 +434,168 @@ class newBDPropagator
                             }
                         }
 
-                        if( s0.structure_type_id() == tx_.get_def_structure_type_id() && pp.second.structure_id() == tx_.get_def_structure_id() )
+                        // check overlap with surfaces
+                        if( product_species.structure_type_id() == tx_.get_def_structure_type_id() && pp.second.structure_id() == tx_.get_def_structure_id() )
                         {
-                            structure_id_and_distance_pair const struct_id_distance_pair( tx_.get_closest_surface( new_pos, pp.second.structure_id()) );
-                            
-                            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+                            const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, pp.second.structure_id()) );
+                            const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
                             if( closest_struct->bounced( tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
                                                          tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
-                                                         struct_id_distance_pair.second, s0.radius() ) )
+                                                         struct_id_distance_pair.second, product_species.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
 
+                        // Process changes
                         tx_.remove_particle(pp.first);
-                        const particle_id_pair product( tx_.new_particle(s0.id(), new_structure_id, new_pos) );
+                        // Make new particle on right surface
+                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), new_structure_id, new_pos) );
 
+                        // Record changes
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(product.first), pp.first));
+                                    r.id(), array_gen(product_particle.first), pp.first));
                         }
+                        break;
                     }
-                    break;
 
-                case 2:
+                    // When two product particles
+                    case 2:
                     {
-                        species_type s0(tx_.get_species(products[0])),
-                                     s1(tx_.get_species(products[1]));
-                        int i = max_retry_count_;
-                        position_pair_type pp01;
-                        structure_id_type new_structure_id0;
-                        structure_id_type new_structure_id1;
-
-                        boost::shared_ptr<structure_type> pp_struct( tx_.get_structure( pp.second.structure_id() ) );
+                        const position_type reactant_pos(pp.second.position());
+                        const boost::shared_ptr<const structure_type> reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
                         
+                        species_type product0_species(tx_.get_species(products[0]));
+                        species_type product1_species(tx_.get_species(products[1]));
+                        position_pair_type pos0pos1_pair;
+                        structure_id_type prod0_struct_id;
+                        structure_id_type prod1_struct_id;
+
                         /* Create positions (np0, np1) for the reaction products. 
                         The ipv between the products lies within the reation volume. */
-                        for (;;)
+                        int i (max_retry_count_);
+                        while (true)
                         {
-                            if (--i < 0)
+                            // Escape clause #1: Too many tries
+                            if (i-- == 0)
                             {
                                 throw propagation_error("no space due to particle or surface");
                             }
                             
+
+                            //// Generate positions and structure_id for product particles after reaction
+
                             /* If the product particles do NOT live on the same structure => surface -> surface + bulk dissociation.
                                Else, the products live on the same structure AND on the same structure as the reactant. 
                                => standard geminate dissociation. 
                                
-                               We set: species 0 lives on the surface; species 1 lives in the bulk. */
-                            if( s0.structure_type_id() != s1.structure_type_id() )
+                            We set: species 0 lives on the surface; species 1 lives in the bulk. */
+                            if( product0_species.structure_type_id() != product1_species.structure_type_id() )
                             {
-                                if( !(s0.structure_type_id() == tx_.get_def_structure_type_id() || s1.structure_type_id() == tx_.get_def_structure_type_id())  )
+                                if( !(product0_species.structure_type_id() == tx_.get_def_structure_type_id() || 
+                                      product1_species.structure_type_id() == tx_.get_def_structure_type_id())  )
                                     throw not_implemented("No surface -> surface + surface - dissociation allowed");
                                                  
-                                if(s0.structure_type_id() == tx_.get_def_structure_type_id())    
-                                     std::swap(s0,s1);
+                                if(product0_species.structure_type_id() == tx_.get_def_structure_type_id())    
+                                     std::swap(product0_species,product1_species);
 
-                                pp01 = pp_struct->
-                                        special_geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ );
-                                new_structure_id0 = pp.second.structure_id();
-                                new_structure_id1 = tx_.get_def_structure_id();
+                                pos0pos1_pair = reactant_structure-> special_geminate_dissociation_positions( rng_, product0_species, product1_species,
+                                                                                                              reactant_pos, reaction_length_ );
+                                prod0_struct_id = pp.second.structure_id();         // The 'original' structure
+                                prod1_struct_id = tx_.get_def_structure_id();       // The bulk
                             }
                             else
                             {
-                                pp01 = pp_struct->
-                                        geminate_dissociation_positions( rng_, s0, s1, pp.second.position(), reaction_length_ );
-                                new_structure_id0 = pp.second.structure_id();
-                                new_structure_id1 = pp.second.structure_id();
+                                pos0pos1_pair = reactant_structure-> geminate_dissociation_positions( rng_, product0_species, product1_species,
+                                                                                                      reactant_pos, reaction_length_ );
+                                prod0_struct_id = pp.second.structure_id();         // same structure as the reactant
+                                prod1_struct_id = pp.second.structure_id();         // ditto
                             }
-                            
-                            pp01.first = tx_.apply_boundary( pp01.first );
-                            pp01.second = tx_.apply_boundary( pp01.second );
-                                                                                   
-                            boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_s0(
-                                tx_.check_overlap(
-                                    particle_shape_type(pp01.first, s0.radius()),
-                                    pp.first));
-                            boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_s1(
-                                tx_.check_overlap(
-                                    particle_shape_type(pp01.second, s1.radius()),
-                                    pp.first));
+                            pos0pos1_pair.first  = tx_.apply_boundary( pos0pos1_pair.first );
+                            pos0pos1_pair.second = tx_.apply_boundary( pos0pos1_pair.second );
+
+
+                            // check overlap with particle in the propagator
+                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped_product0(
+                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.first, product0_species.radius()),  pp.first));
+                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped_product1(
+                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.second, product1_species.radius()), pp.first));
                                     
                             /* Only when both products live in the bulk, check for possible overlap with a surface. */
                             bool surface_bounce0( false );
                             bool surface_bounce1( false );
-                            if( s0.structure_type_id() == tx_.get_def_structure_type_id() && s1.structure_type_id() == tx_.get_def_structure_type_id() )
+                            if( product0_species.structure_type_id() == tx_.get_def_structure_type_id() && product1_species.structure_type_id() == tx_.get_def_structure_type_id() )
                             {
-                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pp01.first, tx_.get_def_structure_id() ) );
+                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pos0pos1_pair.first, tx_.get_def_structure_id() ) );
                                 boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
                                 surface_bounce0 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
-                                                                           tx_.cyclic_transpose( pp01.first, closest_struct->position() ), 
-                                                                           struct_id_distance_pair.second, s0.radius() );
+                                                                           tx_.cyclic_transpose( pos0pos1_pair.first, closest_struct->position() ), 
+                                                                           struct_id_distance_pair.second, product0_species.radius() );
 
-                                struct_id_distance_pair = tx_.get_closest_surface( pp01.second, tx_.get_def_structure_id() );
+                                struct_id_distance_pair = tx_.get_closest_surface( pos0pos1_pair.second, tx_.get_def_structure_id() );
                                 closest_struct = tx_.get_structure( struct_id_distance_pair.first );
 
                                 surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
-                                                                           tx_.cyclic_transpose( pp01.second, closest_struct->position() ), 
-                                                                           struct_id_distance_pair.second, s1.radius() );
+                                                                           tx_.cyclic_transpose( pos0pos1_pair.second, closest_struct->position() ), 
+                                                                           struct_id_distance_pair.second, product1_species.radius() );
                             }
-                                    
-                            if ( !(overlapped_s0 && overlapped_s0->size() > 0) && !(overlapped_s1 && overlapped_s1->size() > 0) 
-                                && !surface_bounce0 && !surface_bounce1 )
+                            
+                            // If the positions were allowed -> SUCCESS and leave the loop
+                            if ( !(overlapped_product0 && overlapped_product0->size() > 0) && 
+                                 !(overlapped_product1 && overlapped_product1->size() > 0) &&
+                                 !surface_bounce0 && !surface_bounce1 )
                                 break;
                         }
 
                         /* After dissociation both particles are allowed to move. */
-                        pp01 = make_pair_move(s0, s1, pp01, pp.first);
+                        pos0pos1_pair = make_pair_move(product0_species, product1_species, pos0pos1_pair, pp.first);
 
+                        // check overlap with particle outside of propagator (for example in eGFRD simulator)
                         if (vc_)
                         {
-                            if (!(*vc_)(particle_shape_type(pp01.first, s0.radius()), pp.first) || !(*vc_)(particle_shape_type(pp01.second, s1.radius()), pp.first))
+                            if (!(*vc_)(particle_shape_type(pos0pos1_pair.first,  product0_species.radius()), pp.first) ||
+                                !(*vc_)(particle_shape_type(pos0pos1_pair.second, product1_species.radius()), pp.first))
                             {
                                 throw propagation_error("no space due to near particle (vc)");
                             }
                         }
 
+                        // Process changes
                         tx_.remove_particle(pp.first);
-                        const particle_id_pair
-                            npp0(tx_.new_particle(s0.id(), new_structure_id0, pp01.first)),
-                            npp1(tx_.new_particle(s1.id(), new_structure_id1, pp01.second));
+                        const particle_id_pair product0_particle(tx_.new_particle(product0_species.id(), prod0_struct_id, pos0pos1_pair.first));
+                        const particle_id_pair product1_particle(tx_.new_particle(product1_species.id(), prod1_struct_id, pos0pos1_pair.second));
 
+                        // Record changes
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
                                     r.id(),
-                                    array_gen(npp0.first, npp1.first),
+                                    array_gen(product0_particle.first, product1_particle.first),
                                     pp.first));
                         }
+                        break;
                     }
-                    break;
-                default:
-                    throw not_implemented("monomolecular reactions that produce more than two products are not supported");
+                    default:
+                        throw not_implemented("monomolecular reactions that produce more than two products are not supported");
                 }
+                // After we processed the reaction, we return -> no other reaction should be done.
                 return true;
             }
         }
+        // No monomolecular reaction has taken place. 
         return false;
     }
-        
+
+
     const bool attempt_pair_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1,
                                      species_type const& s0, species_type const& s1)
     // This handles the reaction between a pair of particles.
-    // unclear what the convention for pp0, pp1 and s0,s1 is with regard to being in 3D/2D.
+    // pp0 is the initiating particle (also no longer in the queue) and pp1 is the target particle (still in the queue).
+    // pp0, pp1 and s0,s1 can either be in 3D/2D/1D or mixed.
     {
         reaction_rules const& rules(rules_.query_reaction_rule(pp0.second.sid(), pp1.second.sid()));
         if(::size(rules) == 0)
@@ -614,7 +623,7 @@ class newBDPropagator
                     // When no products
                     case 0:
                     {
-                        remove_particle(pp0.first);
+                        tx_.remove_particle(pp0.first);
                         remove_particle(pp1.first);
                         break;
                     }
@@ -693,7 +702,7 @@ class newBDPropagator
 
 
                         // Process changes
-                        remove_particle(pp0.first);
+                        tx_.remove_particle(pp0.first);
                         remove_particle(pp1.first);
                         // Make new particle on right structure
                         particle_id_pair product_particle(tx_.new_particle(product_species.id(), new_structure_id, new_pos));
@@ -750,7 +759,8 @@ class newBDPropagator
                     // When no products
                     case 0:
                     {
-                        remove_particle(pp.first);
+
+                        tx_.remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
                         break;
                     }
                     // When one product particle
@@ -781,7 +791,7 @@ class newBDPropagator
                         // TODO check overlap with surfaces.
 
                         // Process changes
-                        remove_particle(pp.first);
+                        tx_.remove_particle(pp.first);
                         // Make new particle in interaction surface 
                         const particle_id_pair product_particle( tx_.new_particle(product_species.id(), surface->real_id(), new_pos) );
                         // Record changes
@@ -805,45 +815,6 @@ class newBDPropagator
         throw illegal_state("Surface interaction failed, no interaction selected when interaction was supposed to happen.");
     }
     
-    
-
-
-    /* Given a position pair and two species, the function generates two new 
-       positions based on two moves drawn from the free propagator. */
-    const position_pair_type make_pair_move(species_type const& s0, species_type const& s1,
-                                            position_pair_type const& pos0_pos1, particle_id_type const& ignore) const
-    {
-        const length_type min_distance_01( s0.radius() + s1.radius() );
-        
-        position_type temp_pos0(pos0_pos1.first),
-                      temp_pos1(pos0_pos1.second);
-        
-        //Randomize which species moves first, and if there will be one or two moves. (50% of the cases)
-        int  move_count( 1 + rng_.uniform_int(0, 1) );  // determine number of particles to move (1 or 2)
-        bool move_first( rng_.uniform_int(0, 1) );      // Set to true if the first particle is moved, false means second particle.
-        while( move_count-- )
-        {
-            if( move_first )
-            // Move the first particle
-            {
-                temp_pos0 = make_move(s0, pos0_pos1.first, ignore);
-                // check for overlap with the second particle (and potentially revert move)
-                temp_pos0 = tx_.distance(temp_pos0, temp_pos1) - min_distance_01 < 0 ? pos0_pos1.first : temp_pos0;
-            }                       
-            else
-            // Move the second particle
-            {
-                temp_pos1 = make_move(s1, pos0_pos1.second, ignore);
-                // check for overlap with the first particle (and potentially revert move)
-                temp_pos1 = tx_.distance(temp_pos1, temp_pos0) - min_distance_01 < 0 ? pos0_pos1.second : temp_pos1;
-            }
-
-            // Swap what particle to move
-            move_first = !move_first;
-        }  
-            
-        return std::make_pair(temp_pos0, temp_pos1);
-    }
 
     const position_type make_move(species_type const& species, position_type const& old_pos, particle_id_type const& ignore) const
     // generates a move for a particle and checks if the move was allowed.
@@ -888,12 +859,73 @@ class newBDPropagator
         }    
         return new_pos;
     }
-    
 
 
+    /* Given a position pair and two species, the function generates two new 
+       positions based on two moves drawn from the free propagator. */
+    const position_pair_type make_pair_move(species_type const& s0, species_type const& s1,
+                                            position_pair_type const& pos0_pos1, particle_id_type const& ignore) const
+    {
+        const length_type min_distance_01( s0.radius() + s1.radius() );
+        
+        position_type temp_pos0(pos0_pos1.first),
+                      temp_pos1(pos0_pos1.second);
+        
+        //Randomize which species moves first, and if there will be one or two moves. (50% of the cases)
+        int  move_count( 1 + rng_.uniform_int(0, 1) );  // determine number of particles to move (1 or 2)
+        bool move_first( rng_.uniform_int(0, 1) );      // Set to true if the first particle is moved, false means second particle.
+        while( move_count-- )
+        {
+            if( move_first )
+            // Move the first particle
+            {
+                temp_pos0 = make_move(s0, pos0_pos1.first, ignore);
+                // check for overlap with the second particle (and potentially revert move)
+                temp_pos0 = tx_.distance(temp_pos0, temp_pos1) - min_distance_01 < 0 ? pos0_pos1.first : temp_pos0;
+            }                       
+            else
+            // Move the second particle
+            {
+                temp_pos1 = make_move(s1, pos0_pos1.second, ignore);
+                // check for overlap with the first particle (and potentially revert move)
+                temp_pos1 = tx_.distance(temp_pos1, temp_pos0) - min_distance_01 < 0 ? pos0_pos1.second : temp_pos1;
+            }
+
+            // Swap what particle to move
+            move_first = !move_first;
+        }  
+            
+        return std::make_pair(temp_pos0, temp_pos1);
+    }
+
+
+    /* Function returns the accumulated intrinsic reaction rate between to species. */
+    /* Note that the species_id_type is equal to the structure_type_id_type for structure_types */
+    const Real k_total(species_id_type const& s0_id, species_id_type const& s1_id) const
+    {   
+        Real k_tot (0);
+        reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
+
+//        if(::size(rules) != 0)
+//        {
+//            return 0;
+//        }
+//        else
+//        {
+        // This should also work when 'rules' is empty.
+            for (typename boost::range_const_iterator<reaction_rules>::type
+                    i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+            {
+                k_tot += (*i).k();
+            }
+//        }
+        return k_tot;
+    }
+
 
     void remove_particle(particle_id_type const& pid)
     // Removes a particle from the propagator and particle container.
+    // Note that this should only be called for the particles that are NOT processed currently (i.e. the particle that are just popped of the queue)
     {
         LOG_DEBUG(("remove particle %s", boost::lexical_cast<std::string>(pid).c_str()));
 

From 794521b18103b9c088c93c3aedeaba97f8e88636 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 11 Apr 2012 15:55:28 +0200
Subject: [PATCH 0770/1541] small fix to deflection method in Plane

---
 Plane.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index 94ebe4cb..28211710 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -219,11 +219,10 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    else
       intersect_parameter = (length_type)INT_MAX;       // infinity, displacement is parallel to edge
       
-   
    // Check whether the displacement actually crosses the plane;
    // If not, just return original position plus displacement;
    // if yes, calculate the deflection.
-   if(intersect_parameter > 1.0){
+   if(intersect_parameter > 1.0 || intersect_parameter < 0.0){
      
         // No intersection; the new position is just r0+displacement
         new_pos = add(r0, d);

From e4f13a34c201ce0e00367cc487cd3065aea5798b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 11 Apr 2012 18:09:00 +0200
Subject: [PATCH 0771/1541] 1. clearing up the identifier_type ->
 structure_name_type, id -> name, real_id -> id confusion. 2. start
 implementing use deflection in newBDPropagator

---
 CuboidalRegion.hpp              | 13 +++----------
 CylindricalSurface.hpp          |  6 +++---
 ParticleSimulationStructure.hpp |  4 ++--
 PlanarSurface.hpp               | 18 ++++++++---------
 Region.hpp                      | 16 ++++++++--------
 SphericalSurface.hpp            | 16 ++++++++--------
 Structure.hpp                   | 34 ++++++++++++++++-----------------
 StructureType.hpp               |  1 -
 StructureUtils.hpp              | 18 ++++++++---------
 Surface.hpp                     | 16 ++++++++--------
 World.hpp                       |  4 ++--
 binding/CuboidalRegion.hpp      |  2 +-
 binding/CylindricalSurface.hpp  |  2 +-
 binding/PlanarSurface.hpp       |  2 +-
 binding/SphericalSurface.hpp    |  2 +-
 binding/Structure.hpp           |  3 +--
 newBDPropagator.hpp             | 18 ++++++++++++++---
 17 files changed, 89 insertions(+), 86 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index cf208f68..9f3602a6 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -15,7 +15,7 @@ class CuboidalRegion
     typedef typename base_type::traits_type traits_type;
 
     // name shorthands of types that we use.
-    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type              shape_type;
     typedef typename base_type::rng_type                rng_type;
@@ -24,13 +24,6 @@ class CuboidalRegion
     typedef typename Ttraits_::world_type::species_type species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
 
-
-    // TODO why is this here? This the same as the method in the superclass 'Structure'
-    identifier_type const& id() const
-    {
-        return base_type::id_;
-    }
-
     virtual position_type random_position(rng_type& rng) const
     {
         return ::random_position(base_type::shape(),
@@ -150,8 +143,8 @@ class CuboidalRegion
     }
 
     // Constructor
-    CuboidalRegion(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(id, sid, shape) {}
+    CuboidalRegion(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(name, sid, shape) {}
 };
 
 #endif /* CUBOIDAL_REGION_HPP */
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 32409351..7175c03c 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -16,7 +16,7 @@ class CylindricalSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type         identifier_type;        // This is just the name of the structure
+    typedef typename base_type::structure_name_type     structure_name_type;        // This is just the name of the structure
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type              shape_type;
     typedef typename base_type::rng_type                rng_type;
@@ -226,8 +226,8 @@ class CylindricalSurface
         visitor(*this);
     }
 
-    CylindricalSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(id, sid, shape) {}
+    CylindricalSurface(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(name, sid, shape) {}
 };
 
 #endif /* CYLINDRICAL_SURFACE_HPP */
diff --git a/ParticleSimulationStructure.hpp b/ParticleSimulationStructure.hpp
index 0e40a08d..e4f03ab2 100644
--- a/ParticleSimulationStructure.hpp
+++ b/ParticleSimulationStructure.hpp
@@ -15,7 +15,7 @@ struct ParticleSimulationStructure: public Structure<typename Ttraits_::world_ty
     typedef Ttraits_ traits_type;
     typedef Structure<typename traits_type::world_type::traits_type> base_type;
 
-    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
 
     virtual ~ParticleSimulationStructure() {}
@@ -25,7 +25,7 @@ struct ParticleSimulationStructure: public Structure<typename Ttraits_::world_ty
     virtual void accept(MutativeStructureVisitor<traits_type> const&) = 0;
 
     // Constructor
-    ParticleSimulationStructure(identifier_type const& id, structure_type_id_type const& sid): base_type(id, sid) {}
+    ParticleSimulationStructure(structure_name_type const& name, structure_type_id_type const& sid): base_type(name, sid) {}
 };
 
 #endif /* PARTICLE_SIMULATION_STRUCTURE_HPP */
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index aef8252e..731c0aaf 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -15,15 +15,15 @@ class PlanarSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type         identifier_type;        // This is just the name of the structure
+    typedef typename base_type::structure_name_type     structure_name_type;        // This is just the name of the structure
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::shape_type shape_type;
-    typedef typename base_type::rng_type rng_type;
-    typedef typename base_type::position_type position_type;
-    typedef typename base_type::length_type length_type;
+    typedef typename base_type::shape_type              shape_type;
+    typedef typename base_type::rng_type                rng_type;
+    typedef typename base_type::position_type           position_type;
+    typedef typename base_type::length_type             length_type;
     typedef typename Ttraits_::world_type::species_type species_type;
-    typedef std::pair<position_type, position_type> position_pair_type;
-    typedef std::pair<position_type, length_type> projected_type;
+    typedef std::pair<position_type, position_type>     position_pair_type;
+    typedef std::pair<position_type, length_type>       projected_type;
 
     virtual position_type random_position(rng_type& rng) const
     // Selects a random position in the plane
@@ -215,8 +215,8 @@ class PlanarSurface
         visitor(*this);
     }
 
-    PlanarSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(id, sid, shape) {}
+    PlanarSurface(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(name, sid, shape) {}
 };
 
 
diff --git a/Region.hpp b/Region.hpp
index c1c17ee9..f527d1e8 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -19,14 +19,14 @@ class Region: public ParticleSimulationStructure<Ttraits_>
 {
 public:
     typedef ParticleSimulationStructure<Ttraits_>       base_type;
-    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
 
 public:
     virtual ~Region() {}
 
     // Constructor
-    Region(identifier_type const& id, structure_type_id_type const& sid): base_type(id, sid) {}
+    Region(structure_name_type const& name, structure_type_id_type const& sid): base_type(name, sid) {}
 };
 
 
@@ -37,7 +37,7 @@ class BasicRegionImpl: public Region<Ttraits_>
 public:
     typedef Region<Ttraits_>                            base_type;
     typedef Tshape_                                     shape_type;
-    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::position_type           position_type;
@@ -60,7 +60,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     {
         BasicRegionImpl const* _rhs(dynamic_cast<BasicRegionImpl const*>(&rhs));
         return _rhs &&
-               base_type::real_id_ == rhs.real_id() &&
+               base_type::id_ == rhs.id() &&
                base_type::sid_ == rhs.sid() &&
                shape_ == _rhs->shape();
     }
@@ -76,7 +76,7 @@ class BasicRegionImpl: public Region<Ttraits_>
 #elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
         using boost::hash;
 #endif
-        return hash<identifier_type>()(base_type::id_) ^
+        return hash<structure_name_type>()(base_type::name_) ^
                hash<structure_type_id_type>()(base_type::sid_) ^
                hash<shape_type>()(shape());
     }
@@ -84,7 +84,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     virtual std::string as_string() const
     {
         std::ostringstream out;
-        out << "Region(" << base_type::real_id_ << ":" << shape() << ")";
+        out << "Region(" << base_type::id_ << ":" << shape() << ")";
         return out.str();
     }
 
@@ -114,8 +114,8 @@ class BasicRegionImpl: public Region<Ttraits_>
     }
     
     // The constructor
-    BasicRegionImpl(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(id, sid), shape_(shape) {}
+    BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(name, sid), shape_(shape) {}
 
 protected:
     shape_type shape_;
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 23173e19..fe0875c9 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -12,14 +12,14 @@ class SphericalSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::identifier_type         identifier_type;        // THis is just the name of the structure
+    typedef typename base_type::structure_name_type     structure_name_type;        // THis is just the name of the structure
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::shape_type shape_type;
-    typedef typename base_type::rng_type rng_type;
-    typedef typename base_type::position_type position_type;
-    typedef typename base_type::length_type length_type;
+    typedef typename base_type::shape_type              shape_type;
+    typedef typename base_type::rng_type                rng_type;
+    typedef typename base_type::position_type           position_type;
+    typedef typename base_type::length_type             length_type;
     typedef typename Ttraits_::world_type::species_type species_type;
-    typedef std::pair<position_type, position_type> position_pair_type;
+    typedef std::pair<position_type, position_type>     position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
@@ -115,8 +115,8 @@ class SphericalSurface
     }
 
     // The Constructor
-    SphericalSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(id, sid, shape) {}
+    SphericalSurface(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(name, sid, shape) {}
 };
 
 #endif /* SPHERICAL_SURFACE_HPP */
diff --git a/Structure.hpp b/Structure.hpp
index 0f0d540e..2e0c1d2c 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -22,7 +22,7 @@ class Structure
     typedef Ttraits_ traits_type;
     // shorthands for types that we use
     typedef typename traits_type::rng_type                  rng_type;
-    typedef typename traits_type::structure_name_type       identifier_type;
+    typedef typename traits_type::structure_name_type       structure_name_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::length_type               length_type;
     typedef typename traits_type::position_type             position_type;
@@ -35,23 +35,23 @@ class Structure
 public:
     virtual ~Structure() {}
 
-    identifier_type const& name()
+    structure_id_type const& id() const
     {
-        return id_;
-    }
-
-    structure_id_type const& real_id() const
-    {
-        if (!real_id_)
+        if (!id_)
         {
             throw illegal_state("ID for structure not defined");
         }
-        return real_id_;
+        return id_;
     }
 
     void set_id(structure_id_type const& id)
     {
-        real_id_ = id;
+        id_ = id;
+    }
+
+    structure_name_type const& name()
+    {
+        return name_;
     }
 
     // Get the StructureType of the structure
@@ -71,7 +71,7 @@ class Structure
 
     virtual bool operator==(Structure const& rhs) const
     {
-        return real_id_ == rhs.real_id() && sid_ == rhs.sid();
+        return id_ == rhs.id() && sid_ == rhs.sid();
     }
 
     bool operator!=(Structure const& rhs) const
@@ -125,25 +125,25 @@ class Structure
 #elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
         using boost::hash;
 #endif
-        return hash<identifier_type>()(id_) ^
+        return hash<structure_name_type>()(name_) ^
                hash<structure_type_id_type>()(sid_);
     }
 
     virtual std::string as_string() const
     {
         std::ostringstream out;
-        out << "Structure(" << real_id() << ", " << sid() << ")";
+        out << "Structure(" << id() << ", " << sid() << ")";
         return out.str();
     }
 
     // Constructor
-    Structure(identifier_type const& id, structure_type_id_type const& sid)
-        : id_(id), sid_(sid) {}
+    Structure(structure_name_type const& name, structure_type_id_type const& sid)
+        : name_(name), sid_(sid) {}
 
 ////// Member variables
 protected:
-    structure_id_type       real_id_;   // id of the structure
-    identifier_type         id_;        // This is now just the name
+    structure_id_type       id_;        // id of the structure
+    structure_name_type     name_;      // just the name
     structure_type_id_type  sid_;       // id of the structure_type of the structure
 };
 
diff --git a/StructureType.hpp b/StructureType.hpp
index 87698ba6..f0f1aca7 100644
--- a/StructureType.hpp
+++ b/StructureType.hpp
@@ -21,7 +21,6 @@ class StructureType
     typedef get_mapper_mf<std::string, std::string>::type string_map_type;
 
 public:
-    // typedef std::string identifier_type;
     typedef SpeciesTypeID                               identifier_type;    // NOTE: we use the same identifier as for the species!
     typedef string_map_type::const_iterator             string_map_iterator;
     typedef boost::iterator_range<string_map_iterator>  attributes_range;
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index a4fce0b2..fa84fc71 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -18,7 +18,7 @@ struct StructureUtils
     // some typedefs
     typedef typename traits_type::world_type::position_type             position_type;
     typedef typename traits_type::world_type::length_type               length_type;
-    typedef typename traits_type::world_type::structure_name_type       structure_id_type;
+    typedef typename traits_type::world_type::structure_name_type       structure_name_type;
     typedef typename traits_type::world_type::structure_type            structure_type;
     typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
 
@@ -36,7 +36,7 @@ struct StructureUtils
  
     static planar_surface_type* create_planar_surface(
             structure_type_id_type const& sid,          // This refers to the structure type of the planar surface
-            structure_id_type   const& id,
+            structure_name_type   const& name,
             position_type const& corner,
             position_type const& unit_x,
             position_type const& unit_y,
@@ -56,23 +56,23 @@ struct StructureUtils
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
                                                 multiply(unit_y, half_ly)));
 
-        return new planar_surface_type(id, sid,
+        return new planar_surface_type(name, sid,
                                        plane_type(pos, unit_x, unit_y,
                                                   half_lx, half_ly));
     }
 
     static spherical_surface_type* create_spherical_surface(
             structure_type_id_type const& sid,
-            structure_id_type const& id,
+            structure_name_type const& name,
             position_type const& pos,
             length_type const& radius)
     {
-        return new spherical_surface_type(id, sid, sphere_type(pos, radius));
+        return new spherical_surface_type(name, sid, sphere_type(pos, radius));
     }
 
     static cylindrical_surface_type* create_cylindrical_surface(
             structure_type_id_type const& sid,
-            structure_id_type const& id,
+            structure_name_type const& name,
             position_type const& corner,
             length_type const& radius,
             position_type const& unit_z,
@@ -83,18 +83,18 @@ struct StructureUtils
         const length_type half_length(length / 2);
         const position_type pos(add(corner, multiply(unit_z, half_length)));
 
-        return new cylindrical_surface_type(id, sid,
+        return new cylindrical_surface_type(name, sid,
                 cylinder_type(pos, radius, unit_z, half_length));
     }
 
     static cuboidal_region_type* create_cuboidal_region(
             structure_type_id_type const& sid,
-            structure_id_type const& id,
+            structure_name_type const& name,
             position_type const& corner,
             boost::array<length_type, 3> const& extent)
     {
         const boost::array<length_type, 3> half_extent(divide(extent, 2));
-        return new cuboidal_region_type(id, sid,
+        return new cuboidal_region_type(name, sid,
                 box_type(add(corner, half_extent),
                          create_vector<position_type>(1, 0, 0),
                          create_vector<position_type>(0, 1, 0),
diff --git a/Surface.hpp b/Surface.hpp
index 1e77e44c..fc791aa6 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -21,7 +21,7 @@ class Surface: public ParticleSimulationStructure<Ttraits_>
 {
 public:
     typedef ParticleSimulationStructure<Ttraits_>       base_type;
-    typedef typename base_type::identifier_type         identifier_type;    // This is just a string
+    typedef typename base_type::structure_name_type     structure_name_type;    // This is just a string
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::length_type             length_type;
 
@@ -29,7 +29,7 @@ class Surface: public ParticleSimulationStructure<Ttraits_>
     virtual ~Surface() {}
 
     // Constructor
-    Surface(identifier_type const& id, structure_type_id_type const& sid): base_type(id, sid) {}
+    Surface(structure_name_type const& name, structure_type_id_type const& sid): base_type(name, sid) {}
 
     virtual length_type minimal_distance(length_type const& radius) const = 0;
 };
@@ -45,7 +45,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     typedef Surface<Ttraits_> base_type;
     typedef Tshape_ shape_type;
 
-    typedef typename base_type::identifier_type         identifier_type;
+    typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::position_type           position_type;
@@ -69,7 +69,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     {
         BasicSurfaceImpl const* _rhs(dynamic_cast<BasicSurfaceImpl const*>(&rhs));
         return _rhs &&
-               base_type::real_id_ == rhs.real_id() &&
+               base_type::id_ == rhs.id() &&
                base_type::sid_ == rhs.sid() &&
                shape_ == _rhs->shape();
     }
@@ -83,7 +83,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
 #elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
         using boost::hash;
 #endif
-        return hash<identifier_type>()(base_type::id_) ^
+        return hash<structure_name_type>()(base_type::name_) ^
                hash<structure_type_id_type>()(base_type::sid_) ^
                hash<shape_type>()(shape());
     }
@@ -91,7 +91,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     virtual std::string as_string() const
     {
         std::ostringstream out;
-        out << "Surface(" << base_type::real_id_ << ":" << shape() << ")";
+        out << "Surface(" << base_type::id_ << ":" << shape() << ")";
         return out.str();
     }
 
@@ -121,8 +121,8 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     }
     
     // Constructor
-    BasicSurfaceImpl(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(id, sid), shape_(shape) {}
+    BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(name, sid), shape_(shape) {}
 
 protected:
     shape_type shape_;
diff --git a/World.hpp b/World.hpp
index ea407979..02dfd37c 100644
--- a/World.hpp
+++ b/World.hpp
@@ -462,7 +462,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
         BOOST_FOREACH(boost::shared_ptr<structure_type> const structure, get_structures())
         {
-            if( structure->real_id() == ignore)
+            if( structure->id() == ignore)
                 continue;
             
             position_type const cyc_pos(cyclic_transpose(pos, structure->position(), world_size));
@@ -471,7 +471,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             if( dist < ret_dist )
             {
                 ret_dist = dist;
-                ret_id = structure->real_id();
+                ret_id = structure->id();
             }  
         }
         
diff --git a/binding/CuboidalRegion.hpp b/binding/CuboidalRegion.hpp
index 5bfdb6d7..e439ee29 100644
--- a/binding/CuboidalRegion.hpp
+++ b/binding/CuboidalRegion.hpp
@@ -15,7 +15,7 @@ inline boost::python::objects::class_base register_cuboidal_region_class(char co
 
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
-            name, init<typename impl_type::identifier_type,
+            name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
diff --git a/binding/CylindricalSurface.hpp b/binding/CylindricalSurface.hpp
index fac1cc7b..96925c30 100644
--- a/binding/CylindricalSurface.hpp
+++ b/binding/CylindricalSurface.hpp
@@ -15,7 +15,7 @@ inline boost::python::objects::class_base register_cylindrical_surface_class(cha
 
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
-            name, init<typename impl_type::identifier_type,
+            name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
diff --git a/binding/PlanarSurface.hpp b/binding/PlanarSurface.hpp
index 7ef7e688..0537c227 100644
--- a/binding/PlanarSurface.hpp
+++ b/binding/PlanarSurface.hpp
@@ -16,7 +16,7 @@ inline boost::python::objects::class_base register_planar_surface_class(char con
     // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
-            name, init<typename impl_type::identifier_type,
+            name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
diff --git a/binding/SphericalSurface.hpp b/binding/SphericalSurface.hpp
index b9024a76..9cf17e31 100644
--- a/binding/SphericalSurface.hpp
+++ b/binding/SphericalSurface.hpp
@@ -16,7 +16,7 @@ inline boost::python::objects::class_base register_spherical_surface_class(char
     // defining the python class
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
-            name, init<typename impl_type::identifier_type,
+            name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 3cae59a8..d0eaa3a8 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -20,11 +20,10 @@ inline boost::python::objects::class_base register_structure_class(char const *n
     peer::converters::register_tuple_converter<typename impl_type::position_flag_pair_type>();
 
     // defining the python class
-    // TODO add name and change id->real_id
     return class_<impl_type, boost::shared_ptr<impl_type>,
                   boost::noncopyable>(name, no_init)
         .add_property("id", 
-            make_function(&impl_type::real_id,
+            make_function(&impl_type::id,
                           return_value_policy<return_by_value>()))
         .add_property("sid",
             make_function(
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index a2f020f1..25547a8e 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -150,7 +150,19 @@ class newBDPropagator
             // get 'connecting' structure and apply deflection. Should we do this recursively until the coordinate stays in the currents structure?
             // This actually kinda similar to the boundary condition application.
             new_pos = tx_.apply_boundary( add( old_pos, displacement ) );
-            new_structure_id = pp.second.structure_id(); //pp_structure->deflect();
+/*            const structure_id_type target_struct_id(pp_structure->get_target_structure(new_pos));
+            const structure_id_type target_struct_id(pp_structure->get_target_structure(new_pos));
+
+            if (target_struct_id != pp_structure.id())
+            // The particle jumped to a new position outside of the current surface.
+            {
+                const structure_type target_structure(tx_.get_structure(target_struct_id));
+                new_structure_id = target_struct_id;
+                const position_flag_pair_type newpos_flag (target_structure->deflect(old_pos, displacement));
+                new_pos = newpos_flag.first;
+            }
+            // Else, just use the current information.
+*/
         }
         else
         {
@@ -260,7 +272,7 @@ class newBDPropagator
                 else                
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
-                               boost::lexical_cast<std::string>(closest_surf->real_id()).c_str()));     // TODO is this the correct interpretation?
+                               boost::lexical_cast<std::string>(closest_surf->id()).c_str()));     // TODO is this the correct interpretation?
                 }
             }
 
@@ -793,7 +805,7 @@ class newBDPropagator
                         // Process changes
                         tx_.remove_particle(pp.first);
                         // Make new particle in interaction surface 
-                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), surface->real_id(), new_pos) );
+                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), surface->id(), new_pos) );
                         // Record changes
                         if (rrec_)
                         {

From 5ba82a3427d5141d8f92a545cb259061f2b311bd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 11 Apr 2012 17:26:41 +0200
Subject: [PATCH 0772/1541] introduced new function for nearest surfaces.

---
 World.hpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/World.hpp b/World.hpp
index 02dfd37c..f773063b 100644
--- a/World.hpp
+++ b/World.hpp
@@ -477,6 +477,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         
         return structure_id_and_distance_pair( ret_id , ret_dist );
     }
+    virtual structures_range get_close_structures(position_type const& pos, structure_id_type const& current_struct_id)const
+    {
+    }
+
     // Get all the particle ids of the particles on a structure
     particle_id_set get_particle_ids_on_struct(structure_id_type const& struct_id) const
     {

From ab662b96908d215c977b9e083981b0d159cd097b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 11 Apr 2012 19:04:03 +0200
Subject: [PATCH 0773/1541] changed World such that the default structure_id is
 already known beforehand.

---
 World.hpp         | 19 ++++++++++++-------
 binding/World.hpp |  2 +-
 gfrdbase.py       |  8 ++++----
 3 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/World.hpp b/World.hpp
index f773063b..5aaf1a58 100644
--- a/World.hpp
+++ b/World.hpp
@@ -256,7 +256,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 public:
     // The constructor
     World(length_type world_size = 1., size_type size = 1)
-        : base_type(world_size, size) {}
+        : base_type(world_size, size), default_structure_id_(structidgen_()) {}
 
     // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
@@ -442,15 +442,20 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // Get and set the default structure of the World
     virtual structure_id_type get_def_structure_id() const
     {
-        if (!default_structure_id_)
-        {
-            throw not_found("Default structure is not defined.");
-        }
         return default_structure_id_;
     }
-    void set_def_structure_id(structure_id_type const& id)
+    void set_def_structure(const boost::shared_ptr<structure_type> structure)
     {
-        default_structure_id_ = id;
+        // check that the structure_type is the default structure_type
+        if (!default_structure_type_id_ || (structure->sid() != default_structure_type_id_) )
+        {
+            throw illegal_state("StructureType of default structure not default StructureType");
+        }
+        // check that the structure_type that is defined in the structure exists!
+        structure_type_type const& structure_type(get_structure_type(structure->sid()));
+
+        structure->set_id(default_structure_id_);
+        update_structure(std::make_pair(default_structure_id_, structure));
     }
     // Get the closest surface(surface is a subclass of structures)
     // TODO change this to get all the surfaces within a certain distance of the particle.
diff --git a/binding/World.hpp b/binding/World.hpp
index e01a2aff..7dba5170 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -298,7 +298,7 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("add_structure", &impl_type::add_structure)
         .def("update_structure", &impl_type::update_structure)      // Not sure if this should be here or in ParticleContainer.hpp
 //        .def("remove_structure", &impl_type::remove_structure)
-        .def("set_def_structure_id", &impl_type::set_def_structure_id)
+        .def("set_def_structure", &impl_type::set_def_structure)
         // StructureType stuff
         .def("add_structure_type", &impl_type::add_structure_type)
         .def("set_def_structure_type_id", &impl_type::set_def_structure_type_id)
diff --git a/gfrdbase.py b/gfrdbase.py
index 501888d8..3a26991c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -157,13 +157,14 @@ def create_world(m, matrix_size=10):
     # The model (a ParticleModel) now only holds SpeciesTypes
     # The SpeciesTYpes hold the information that is required for spatial simulations
     # in auxiliairy string fields. This information is here converted to the right
-    # SpeciesInfo object and added to the world. Not sure this works -> TODO
+    # SpeciesInfo object and added to the world.
     for st in m.species_types:
         if st["structure_type"] == "world":
             # The default structure_type
             structure_type_id = world_structure_type_id
         else:
             # Find the corresponding structure_type between all the structure_types known
+            # FIXME: ugly hack
             for stt in m.structure_types:
                 if st["structure_type"] == stt['name']:
                     structure_type_id = stt.id
@@ -173,7 +174,7 @@ def create_world(m, matrix_size=10):
 
         world.add_species(
             _gfrd.SpeciesInfo(st.id, 
-                              structure_type_id,    # FIXME not sure this works
+                              structure_type_id,
                               float(st["D"]), 
                               float(st["radius"]), 
                               float(st["v"])))
@@ -183,8 +184,7 @@ def create_world(m, matrix_size=10):
     # find the proper structure_type.
     x = numpy.repeat(m.world_size / 2, 3)
     region = _gfrd.CuboidalRegion("world", world_structure_type_id, _gfrd.Box(x, x))
-    world_structure_id = world.add_structure(region)
-    world.set_def_structure_id(world_structure_id)
+    world.set_def_structure(region)
 
     world.model = m
     return world

From 67056a176260f70d42dcb0f2942de7ec660b108a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 11 Apr 2012 19:47:37 +0200
Subject: [PATCH 0774/1541] introduced 'parent_structure_id' as a property of a
 structure.

---
 CuboidalRegion.hpp              |  5 +++--
 CylindricalSurface.hpp          |  5 +++--
 ParticleSimulationStructure.hpp |  4 +++-
 PlanarSurface.hpp               |  5 +++--
 Region.hpp                      |  9 ++++++---
 SphericalSurface.hpp            |  5 +++--
 Structure.hpp                   | 12 +++++++-----
 StructureUtils.hpp              | 34 +++++++++++++++++++--------------
 Surface.hpp                     |  9 ++++++---
 binding/CuboidalRegion.hpp      |  3 ++-
 binding/CylindricalSurface.hpp  |  1 +
 binding/PlanarSurface.hpp       |  1 +
 binding/SphericalSurface.hpp    |  1 +
 gfrdbase.py                     |  2 +-
 14 files changed, 60 insertions(+), 36 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 9f3602a6..7ed9d443 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -16,6 +16,7 @@ class CuboidalRegion
 
     // name shorthands of types that we use.
     typedef typename base_type::structure_name_type     structure_name_type;
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type              shape_type;
     typedef typename base_type::rng_type                rng_type;
@@ -143,8 +144,8 @@ class CuboidalRegion
     }
 
     // Constructor
-    CuboidalRegion(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(name, sid, shape) {}
+    CuboidalRegion(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
+        : base_type(name, sid, parent_struct_id, shape) {}
 };
 
 #endif /* CUBOIDAL_REGION_HPP */
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 7175c03c..98d01e9e 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -17,6 +17,7 @@ class CylindricalSurface
     typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
     typedef typename base_type::structure_name_type     structure_name_type;        // This is just the name of the structure
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type              shape_type;
     typedef typename base_type::rng_type                rng_type;
@@ -226,8 +227,8 @@ class CylindricalSurface
         visitor(*this);
     }
 
-    CylindricalSurface(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(name, sid, shape) {}
+    CylindricalSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
+        : base_type(name, sid, parent_struct_id, shape) {}
 };
 
 #endif /* CYLINDRICAL_SURFACE_HPP */
diff --git a/ParticleSimulationStructure.hpp b/ParticleSimulationStructure.hpp
index e4f03ab2..13f27adc 100644
--- a/ParticleSimulationStructure.hpp
+++ b/ParticleSimulationStructure.hpp
@@ -17,6 +17,7 @@ struct ParticleSimulationStructure: public Structure<typename Ttraits_::world_ty
 
     typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
+    typedef typename base_type::structure_id_type       structure_id_type;
 
     virtual ~ParticleSimulationStructure() {}
 
@@ -25,7 +26,8 @@ struct ParticleSimulationStructure: public Structure<typename Ttraits_::world_ty
     virtual void accept(MutativeStructureVisitor<traits_type> const&) = 0;
 
     // Constructor
-    ParticleSimulationStructure(structure_name_type const& name, structure_type_id_type const& sid): base_type(name, sid) {}
+    ParticleSimulationStructure(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id):
+        base_type(name, sid, parent_struct_id) {}
 };
 
 #endif /* PARTICLE_SIMULATION_STRUCTURE_HPP */
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 731c0aaf..aa33a623 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -16,6 +16,7 @@ class PlanarSurface
     typedef BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
     typedef typename base_type::structure_name_type     structure_name_type;        // This is just the name of the structure
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type              shape_type;
     typedef typename base_type::rng_type                rng_type;
@@ -215,8 +216,8 @@ class PlanarSurface
         visitor(*this);
     }
 
-    PlanarSurface(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(name, sid, shape) {}
+    PlanarSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
+        : base_type(name, sid, parent_struct_id, shape) {}
 };
 
 
diff --git a/Region.hpp b/Region.hpp
index f527d1e8..c69795df 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -20,13 +20,15 @@ class Region: public ParticleSimulationStructure<Ttraits_>
 public:
     typedef ParticleSimulationStructure<Ttraits_>       base_type;
     typedef typename base_type::structure_name_type     structure_name_type;
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
 
 public:
     virtual ~Region() {}
 
     // Constructor
-    Region(structure_name_type const& name, structure_type_id_type const& sid): base_type(name, sid) {}
+    Region(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id)
+        : base_type(name, sid, parent_struct_id) {}
 };
 
 
@@ -38,6 +40,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     typedef Region<Ttraits_>                            base_type;
     typedef Tshape_                                     shape_type;
     typedef typename base_type::structure_name_type     structure_name_type;
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::position_type           position_type;
@@ -114,8 +117,8 @@ class BasicRegionImpl: public Region<Ttraits_>
     }
     
     // The constructor
-    BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(name, sid), shape_(shape) {}
+    BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
+        : base_type(name, sid, parent_struct_id), shape_(shape) {}
 
 protected:
     shape_type shape_;
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index fe0875c9..0d8734fa 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -13,6 +13,7 @@ class SphericalSurface
     typedef BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::world_type::traits_type::length_type> > base_type;
     typedef typename base_type::traits_type traits_type;
     typedef typename base_type::structure_name_type     structure_name_type;        // THis is just the name of the structure
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type              shape_type;
     typedef typename base_type::rng_type                rng_type;
@@ -115,8 +116,8 @@ class SphericalSurface
     }
 
     // The Constructor
-    SphericalSurface(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(name, sid, shape) {}
+    SphericalSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
+        : base_type(name, sid, parent_struct_id, shape) {}
 };
 
 #endif /* SPHERICAL_SURFACE_HPP */
diff --git a/Structure.hpp b/Structure.hpp
index 2e0c1d2c..c037e3fa 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -137,14 +137,16 @@ class Structure
     }
 
     // Constructor
-    Structure(structure_name_type const& name, structure_type_id_type const& sid)
-        : name_(name), sid_(sid) {}
+    Structure(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id)
+        : name_(name), sid_(sid), parent_struct_id_(parent_struct_id) {}
 
 ////// Member variables
 protected:
-    structure_id_type       id_;        // id of the structure
-    structure_name_type     name_;      // just the name
-    structure_type_id_type  sid_;       // id of the structure_type of the structure
+    structure_name_type     name_;                  // just the name
+    structure_type_id_type  sid_;                   // id of the structure_type of the structure
+    structure_id_type       parent_struct_id_;
+
+    structure_id_type       id_;        // id of the structure (filled in later)
 };
 
 
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index fa84fc71..95b5d835 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -19,6 +19,7 @@ struct StructureUtils
     typedef typename traits_type::world_type::position_type             position_type;
     typedef typename traits_type::world_type::length_type               length_type;
     typedef typename traits_type::world_type::structure_name_type       structure_name_type;
+    typedef typename traits_type::world_type::structure_id_type         structure_id_type;
     typedef typename traits_type::world_type::structure_type            structure_type;
     typedef typename traits_type::world_type::structure_type_id_type    structure_type_id_type;
 
@@ -41,7 +42,8 @@ struct StructureUtils
             position_type const& unit_x,
             position_type const& unit_y,
             length_type const& lx,
-            length_type const& ly)
+            length_type const& ly,
+            structure_id_type const& parent_struct_id)
     {
         BOOST_ASSERT(is_cartesian_versor(unit_x));
         BOOST_ASSERT(is_cartesian_versor(unit_y));
@@ -56,7 +58,7 @@ struct StructureUtils
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
                                                 multiply(unit_y, half_ly)));
 
-        return new planar_surface_type(name, sid,
+        return new planar_surface_type(name, sid, parent_struct_id,
                                        plane_type(pos, unit_x, unit_y,
                                                   half_lx, half_ly));
     }
@@ -65,9 +67,11 @@ struct StructureUtils
             structure_type_id_type const& sid,
             structure_name_type const& name,
             position_type const& pos,
-            length_type const& radius)
+            length_type const& radius,
+            structure_id_type const& parent_struct_id)
     {
-        return new spherical_surface_type(name, sid, sphere_type(pos, radius));
+        return new spherical_surface_type(name, sid, parent_struct_id,
+                                          sphere_type(pos, radius));
     }
 
     static cylindrical_surface_type* create_cylindrical_surface(
@@ -76,30 +80,32 @@ struct StructureUtils
             position_type const& corner,
             length_type const& radius,
             position_type const& unit_z,
-            length_type const& length)
+            length_type const& length,
+            structure_id_type const& parent_struct_id)
     {
         BOOST_ASSERT(is_cartesian_versor(unit_z));
 
         const length_type half_length(length / 2);
         const position_type pos(add(corner, multiply(unit_z, half_length)));
 
-        return new cylindrical_surface_type(name, sid,
-                cylinder_type(pos, radius, unit_z, half_length));
+        return new cylindrical_surface_type(name, sid, parent_struct_id,
+                                            cylinder_type(pos, radius, unit_z, half_length));
     }
 
     static cuboidal_region_type* create_cuboidal_region(
             structure_type_id_type const& sid,
             structure_name_type const& name,
             position_type const& corner,
-            boost::array<length_type, 3> const& extent)
+            boost::array<length_type, 3> const& extent,
+            structure_id_type const& parent_struct_id)
     {
         const boost::array<length_type, 3> half_extent(divide(extent, 2));
-        return new cuboidal_region_type(name, sid,
-                box_type(add(corner, half_extent),
-                         create_vector<position_type>(1, 0, 0),
-                         create_vector<position_type>(0, 1, 0),
-                         create_vector<position_type>(0, 0, 1),
-                         half_extent));
+        return new cuboidal_region_type(name, sid, parent_struct_id,
+                                        box_type(add(corner, half_extent),
+                                                 create_vector<position_type>(1, 0, 0),
+                                                 create_vector<position_type>(0, 1, 0),
+                                                 create_vector<position_type>(0, 0, 1),
+                                                 half_extent));
     }
 
     static position_type random_vector(structure_type const& structure,
diff --git a/Surface.hpp b/Surface.hpp
index fc791aa6..81129234 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -22,6 +22,7 @@ class Surface: public ParticleSimulationStructure<Ttraits_>
 public:
     typedef ParticleSimulationStructure<Ttraits_>       base_type;
     typedef typename base_type::structure_name_type     structure_name_type;    // This is just a string
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::length_type             length_type;
 
@@ -29,7 +30,8 @@ class Surface: public ParticleSimulationStructure<Ttraits_>
     virtual ~Surface() {}
 
     // Constructor
-    Surface(structure_name_type const& name, structure_type_id_type const& sid): base_type(name, sid) {}
+    Surface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id):
+         base_type(name, sid, parent_struct_id) {}
 
     virtual length_type minimal_distance(length_type const& radius) const = 0;
 };
@@ -46,6 +48,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     typedef Tshape_ shape_type;
 
     typedef typename base_type::structure_name_type     structure_name_type;
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::position_type           position_type;
@@ -121,8 +124,8 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     }
     
     // Constructor
-    BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(name, sid), shape_(shape) {}
+    BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
+        : base_type(name, sid, parent_struct_id), shape_(shape) {}
 
 protected:
     shape_type shape_;
diff --git a/binding/CuboidalRegion.hpp b/binding/CuboidalRegion.hpp
index e439ee29..4bb6feb8 100644
--- a/binding/CuboidalRegion.hpp
+++ b/binding/CuboidalRegion.hpp
@@ -17,6 +17,7 @@ inline boost::python::objects::class_base register_cuboidal_region_class(char co
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
+                       typename impl_type::structure_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape,
@@ -24,6 +25,6 @@ inline boost::python::objects::class_base register_cuboidal_region_class(char co
         ;
 }
 
-} // namespce binding
+} // namespace binding
 
 #endif /* BINDING_CUBOIDAL_REGION_HPP */
diff --git a/binding/CylindricalSurface.hpp b/binding/CylindricalSurface.hpp
index 96925c30..d956b4e3 100644
--- a/binding/CylindricalSurface.hpp
+++ b/binding/CylindricalSurface.hpp
@@ -17,6 +17,7 @@ inline boost::python::objects::class_base register_cylindrical_surface_class(cha
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
+                       typename impl_type::structure_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
diff --git a/binding/PlanarSurface.hpp b/binding/PlanarSurface.hpp
index 0537c227..68b518ca 100644
--- a/binding/PlanarSurface.hpp
+++ b/binding/PlanarSurface.hpp
@@ -18,6 +18,7 @@ inline boost::python::objects::class_base register_planar_surface_class(char con
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
+                       typename impl_type::structure_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
diff --git a/binding/SphericalSurface.hpp b/binding/SphericalSurface.hpp
index 9cf17e31..1d87f6f4 100644
--- a/binding/SphericalSurface.hpp
+++ b/binding/SphericalSurface.hpp
@@ -18,6 +18,7 @@ inline boost::python::objects::class_base register_spherical_surface_class(char
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
+                       typename impl_type::structure_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
diff --git a/gfrdbase.py b/gfrdbase.py
index 3a26991c..0edc3af8 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -183,7 +183,7 @@ def create_world(m, matrix_size=10):
     # This needs to be done after making the structure_types or add_structure can't
     # find the proper structure_type.
     x = numpy.repeat(m.world_size / 2, 3)
-    region = _gfrd.CuboidalRegion("world", world_structure_type_id, _gfrd.Box(x, x))
+    region = _gfrd.CuboidalRegion("world", world_structure_type_id, world.get_def_structure_id(), _gfrd.Box(x, x))
     world.set_def_structure(region)
 
     world.model = m

From e715257990ac0ca337c9bccd02342461c5afc25c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 Apr 2012 15:28:03 +0200
Subject: [PATCH 0775/1541] Added structure_type as a property of the
 StructureType to make sure that every StructureType has a parent
 structure_type where it lives analogous to a Species having a structure_type
 where it lives.

---
 StructureType.cpp |  9 +++++++++
 StructureType.hpp | 13 ++++++++++---
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/StructureType.cpp b/StructureType.cpp
index e847663c..284fdef9 100644
--- a/StructureType.cpp
+++ b/StructureType.cpp
@@ -13,6 +13,15 @@ StructureType::identifier_type const& StructureType::id() const
     return id_;
 }
     
+StructureType::structure_type_id_type const& StructureType::structure_type_id() const
+{
+    if (!structure_type_id_)
+    {
+        throw illegal_state("no structure_type defined");
+    }
+    return structure_type_id_;
+}
+
 std::string const& StructureType::operator[](std::string const& name) const
 {
     string_map_type::const_iterator i(attrs_.find(name));
diff --git a/StructureType.hpp b/StructureType.hpp
index f0f1aca7..28a245e5 100644
--- a/StructureType.hpp
+++ b/StructureType.hpp
@@ -24,14 +24,20 @@ class StructureType
     typedef SpeciesTypeID                               identifier_type;    // NOTE: we use the same identifier as for the species!
     typedef string_map_type::const_iterator             string_map_iterator;
     typedef boost::iterator_range<string_map_iterator>  attributes_range;
+    typedef identifier_type                             structure_type_id_type;
 
 public:
     // Constructor
+    // TODO should add StructureType as property of StructureType so that we can
+    //      build a hyarchie of StructureTypes living in Structuretypes just like structure living in structures.
     StructureType(): model_(0) {}
  
     // Get the id
     identifier_type const& id() const;
 
+    // Get the id of the structure type the structure_type lives on/in
+    structure_type_id_type const& structure_type_id() const;
+
     std::string const& operator[](std::string const& name) const;
 
     std::string& operator[](std::string const& name);
@@ -55,9 +61,10 @@ class StructureType
 
 //////// Member variables
 private:
-    ParticleModel*  model_;         // to what model is it associated
-    identifier_type id_;            // identifier Note that these are only defined if the object is bound to a model.
-    string_map_type attrs_;
+    ParticleModel*          model_;             // to what model is it associated
+    identifier_type         id_;                // identifier Note that these are only defined if the object is bound to a model.
+    structure_type_id_type  structure_type_id_; // The structure type that the structure_type lives on/in
+    string_map_type         attrs_;
 };
 
 /////// Inline functions

From b488085469b4fe4d8265fb780f895a74b776ddd9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 16 Apr 2012 17:25:29 +0200
Subject: [PATCH 0776/1541] added function to create box

---
 gfrdbase.py | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/gfrdbase.py b/gfrdbase.py
index 0edc3af8..0dd958c2 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -26,6 +26,7 @@
     'place_particle',
     'NoSpace',
     'create_world',
+    'create_box',
     'ParticleSimulatorBase',
     'get_surfaces',
     'get_closest_surface',
@@ -189,6 +190,35 @@ def create_world(m, matrix_size=10):
     world.model = m
     return world
 
+def create_box(world, structure_type, center, size):
+    # Creates a box of PlanarSurface sections and adds it to the world.
+    # size is a vector in x, y, z
+
+    # assert that the center and size is ok
+    center = numpy.array(center)
+    size   = numpy.array(size)
+    assert all(0 < center) and all(center < world.world_size)
+    assert all(0 < size)   and all(size < world.world_size)
+    assert all(0 < center - size/2.0) and all(center + size/2.0 < world.world_size)
+
+    sid = structure_type.id
+    name = 'box'
+    def_struct_id = world.get_def_structure_id()
+    
+    front  = model.create_planar_surface(sid, name+'_front', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
+    back   = model.create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
+    right  = model.create_planar_surface(sid, name+'_right', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
+    left   = model.create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
+    top    = model.create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
+    bottom = model.create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
+    world.add_structure(front)
+    world.add_structure(back)
+    world.add_structure(right)
+    world.add_structure(left)
+    world.add_structure(top)
+    world.add_structure(bottom)
+
+
 def create_network_rules_wrapper(model):
     return _gfrd.NetworkRulesWrapper(model.network_rules)
 

From f67890c7645e75db77ff6569a09e17a30893caf5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 17 Apr 2012 14:53:31 +0200
Subject: [PATCH 0777/1541] changed Structure parent_struct_id() to
 structure_id() to match method in Particle

---
 Structure.hpp         | 5 +++++
 binding/Structure.hpp | 3 +++
 2 files changed, 8 insertions(+)

diff --git a/Structure.hpp b/Structure.hpp
index c037e3fa..027b09ea 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -69,6 +69,11 @@ class Structure
         return sid_;
     }
 
+    structure_id_type const& structure_id() const
+    {
+        return parent_struct_id_;
+    }
+
     virtual bool operator==(Structure const& rhs) const
     {
         return id_ == rhs.id() && sid_ == rhs.sid();
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index d0eaa3a8..ac92c3e2 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -36,6 +36,9 @@ inline boost::python::objects::class_base register_structure_class(char const *n
                 impl_type, typename impl_type::structure_type_id_type,
                 &impl_type::sid,
                 &impl_type::sid>::set)
+        .add_property("structure_id", 
+            make_function(&impl_type::structure_id,
+                          return_value_policy<return_by_value>()))
         .add_property("name", 
             make_function(&impl_type::name,
                           return_value_policy<return_by_value>()))

From 9408c0c4cabf04da4c28c37b4a91d25e5a3d3eab Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 17 Apr 2012 15:02:04 +0200
Subject: [PATCH 0778/1541] Implemented mapping for superstructure ->
 substructure ids + getter method

---
 World.hpp | 41 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 36 insertions(+), 5 deletions(-)

diff --git a/World.hpp b/World.hpp
index 5aaf1a58..3a09d6ad 100644
--- a/World.hpp
+++ b/World.hpp
@@ -239,6 +239,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
     typedef std::map<structure_type_id_type, structure_id_set>              per_structure_type_structure_id_set;
     typedef std::map<structure_id_type, particle_id_set>                    per_structure_particle_id_set;
+    typedef std::map<structure_id_type, structure_id_set>                   per_structure_substructure_id_set;
     typedef select_second<typename species_map::value_type>                 species_second_selector_type;   // not sure what this does.
     typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
     typedef select_second<typename structure_type_map::value_type>          structure_types_second_selector_type;
@@ -256,7 +257,11 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 public:
     // The constructor
     World(length_type world_size = 1., size_type size = 1)
-        : base_type(world_size, size), default_structure_id_(structidgen_()) {}
+        : base_type(world_size, size), default_structure_id_(structidgen_())
+    {
+        // Make sure that the mapping for the default structure already exists.
+        structure_substructures_map_[default_structure_id_] = structure_id_set();
+    }
 
     // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
@@ -379,16 +384,23 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         // The item was already found in the map
         {
             // FIXME what to do when the structure has particles and moves or changes structure_type?!?!
+            // FIXME Or what to do when the structure has substructures?!
             //  get all particles on the structure
             //  assert that no particles if structure type changes.
 
-
             if ((*i).second->sid() != structid_pair.second->sid())
             // If the structuretype changed we need to update the 'structure_type_id->structure ids' mapping
             {
                 structure_pool_[(*i).second->sid()].erase((*i).first);
                 structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
             }
+            if ((*i).second->structure_id() != structid_pair.second->structure_id())
+            // If the structure had a different parent structure
+            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hyarchie)
+            {
+                structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
+                structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+            }
             structure_map_[(*i).first] = structid_pair.second;
             return false;
         }
@@ -400,6 +412,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
         // create a new mapping from structure id -> set of particles
         particleonstruct_pool_[structid_pair.first] = particle_id_set();
+        // add the id the mapping 'super_structure_id -> set of substructures'
+        structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+        // create a new mapping from structure id -> set of substructures
+        structure_substructures_map_[structid_pair.first] = structure_id_set();
         return true;
     }
     // remove structure
@@ -407,7 +423,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         // TODO
         //  -get all particles on structure
-        //  -only remove if no particles
+        //  -get all the substructures of structure
+        //  -only remove if no particles and no substructures
         return false;
     }
     // Get a structure by id
@@ -439,6 +456,17 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         return (*i).second;
     }
+    // Get all the structure ids of the substructures
+    structure_id_set get_substructure_ids(structure_id_type const& id) const
+    {
+        typename per_structure_substructure_id_set::const_iterator i(
+            structure_substructures_map_.find(id));
+        if (i == structure_substructures_map_.end())
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
     // Get and set the default structure of the World
     virtual structure_id_type get_def_structure_id() const
     {
@@ -447,9 +475,11 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     void set_def_structure(const boost::shared_ptr<structure_type> structure)
     {
         // check that the structure_type is the default structure_type
-        if (!default_structure_type_id_ || (structure->sid() != default_structure_type_id_) )
+        if (!default_structure_type_id_ ||
+            (structure->sid() != default_structure_type_id_) || 
+            (structure->structure_id() != default_structure_id_) )
         {
-            throw illegal_state("StructureType of default structure not default StructureType");
+            throw illegal_state("Default structure doesn't have right properties");
         }
         // check that the structure_type that is defined in the structure exists!
         structure_type_type const& structure_type(get_structure_type(structure->sid()));
@@ -549,6 +579,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     per_structure_type_structure_id_set structure_pool_;    // mapping: structure_type_id -> set of structure ids of that structure type
     per_species_particle_id_set         particle_pool_;     // mapping: species_id -> set of particle ids of that species
     per_structure_particle_id_set       particleonstruct_pool_;
+    per_structure_substructure_id_set   structure_substructures_map_;
 
     structure_id_type                   default_structure_id_;      // The default structure of the World (is a CuboidalRegion of the size of the world)
     structure_type_id_type              default_structure_type_id_; // The default structure_type of the World (every structure must have a StructureType)

From 7be26d8996f371e696aed2dd66863d27d1d75be5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 17 Apr 2012 16:12:18 +0200
Subject: [PATCH 0779/1541] New function deflect_back for the back transform at
 the edge

---
 Box.hpp               | 10 ++++++++++
 Cylinder.hpp          | 10 ++++++++++
 Plane.hpp             | 26 ++++++++++++++++++++++++++
 Region.hpp            |  5 +++++
 Sphere.hpp            | 10 ++++++++++
 Structure.hpp         |  2 ++
 Surface.hpp           |  5 +++++
 binding/Structure.hpp |  1 +
 8 files changed, 69 insertions(+)

diff --git a/Box.hpp b/Box.hpp
index 39b5af8a..fbd6fbba 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -289,6 +289,16 @@ deflect(Box<T_> const& obj,
     return std::make_pair( add(r0, d), false );
 }
 
+template<typename T_>
+inline typename Box<T_>::position_type
+deflect_back(Box<T_> const& obj,
+        typename Box<T_>::position_type const& r0,
+        typename Box<T_>::position_type const& r1  )
+{
+    // Return the difference vector without any changes
+    return subtract(r1, r0);
+}
+
 template<typename T, typename Trng>
 inline typename Box<T>::position_type
 random_position(Box<T> const& shape, Trng& rng)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index e521546d..a647475f 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -212,6 +212,16 @@ deflect(Cylinder<T_> const& obj,
     return std::make_pair( add(r0, d), false );
 }
 
+template<typename T_>
+inline typename Cylinder<T_>::position_type
+deflect_back(Cylinder<T_> const& obj,
+        typename Cylinder<T_>::position_type const& r0,
+        typename Cylinder<T_>::position_type const& r1  )
+{
+    // Return the difference vector without any changes
+    return subtract(r1, r0);
+}
+
 template<typename T, typename Trng>
 inline typename Cylinder<T>::position_type
 random_position(Cylinder<T> const& shape, Trng& rng)
diff --git a/Plane.hpp b/Plane.hpp
index 94ebe4cb..64c9307b 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -268,6 +268,32 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    return std::make_pair( new_pos, changeflag );
 }
 
+template<typename T_>
+inline typename Plane<T_>::position_type
+deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& r1)
+// This function projects a vector onto a plane and prolongates the projection by the part of it orthogonal to the plane,
+// returning a (vector) position type 
+{
+     // Type abbreviations
+    typedef typename Plane<T_>::length_type length_type;
+    typedef typename Plane<T_>::position_type position_type;
+    typedef std::pair<position_type, length_type> projected_type;
+            
+    position_type  dr(subtract(r1, r0));            // difference vector r1 - r0
+    projected_type dr_proj(projected_point(obj, dr));
+    length_type    dr_proj_len(length(dr_proj.first)); // length of dr projected onto plane obj        
+    
+    position_type u_dr_proj; // the normalized projection of dr on the plane (given in the global coord. system)
+    position_type r1_new;
+    length_type   dr_len_new;
+            
+    u_dr_proj  = normalize(dr_proj.first);    
+    dr_len_new = add(dr_proj_len, dr_proj.second);    
+    r1_new     = add(r0, multiply(u_dr_proj, dr_len_new));
+    
+    return r1_new;  
+}
+
 template<typename T_>
 inline boost::array<typename Plane<T_>::length_type, 3>
 to_internal(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
diff --git a/Region.hpp b/Region.hpp
index d5c4c739..f2d5653b 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -108,6 +108,11 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::deflect(shape(), pos0, displacement);
     }
     
+    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1) const
+    {
+        return ::deflect_back(shape(), pos0, pos1);
+    }
+    
     virtual position_type const& structure_position() const
     {
         return shape_.position();
diff --git a/Sphere.hpp b/Sphere.hpp
index e50bb96d..999578d7 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -112,6 +112,16 @@ deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typ
     return std::make_pair( add(r0, d), false );
 }
 
+template<typename T_>
+inline typename Sphere<T_>::position_type
+deflect_back(Sphere<T_> const& obj,
+        typename Sphere<T_>::position_type const& r0,
+        typename Sphere<T_>::position_type const& r1  )
+{
+    // Return the difference vector without any changes
+    return subtract(r1, r0);
+}
+
 template<typename T_>
 inline Sphere<T_> const& shape(Sphere<T_> const& shape)
 {
diff --git a/Structure.hpp b/Structure.hpp
index 29dbb892..a0b78f6c 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -117,6 +117,8 @@ class Structure
     
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
     
+    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1) const = 0;
+    
     virtual position_type const& structure_position() const = 0;
 
     virtual std::size_t hash() const
diff --git a/Surface.hpp b/Surface.hpp
index 1b0b0f95..10316a41 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -115,6 +115,11 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::deflect(shape(), pos0, displacement);
     }
     
+    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1) const
+    {
+        return ::deflect_back(shape(), pos0, pos1);
+    }
+    
     virtual position_type const& structure_position() const
     {
         return shape_.position();
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index bdee301e..07df17aa 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -47,6 +47,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("projected_point", &impl_type::projected_point)
         .def("deflect", &impl_type::deflect)
+        .def("deflect_back", &impl_type::deflect)
         ;
 }
 

From 3a8cbf663abc4a8564d8e0a683b0ccda1cd49361 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 17 Apr 2012 18:00:46 +0200
Subject: [PATCH 0780/1541] Rudimentary implementation of testMixedPair2D2D

---
 shells.py | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/shells.py b/shells.py
index ca6c2956..7fa3aff5 100755
--- a/shells.py
+++ b/shells.py
@@ -26,6 +26,7 @@
     'testTransitionSingle',
     'testPair',
     'testSimplePair',
+    'testMixedPair2D2D',
     'testMixedPair2D3D',
     'hasSphericalShell',
     'hasCylindricalShell',   
@@ -34,6 +35,7 @@
     'PlanarSurfaceSingletestShell',
     'PlanarSurfacePairtestShell',
     'PlanarSurfaceTransitionSingletestShell',
+    'PlanarSurfaceTransitionPairtestShell',
     'CylindricalSurfaceSingletestShell',
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
@@ -347,6 +349,45 @@ def get_scaling_factor(self):
                                                 # normal to the plane
         return math.sqrt(self.D_r/D_2)
 
+class testMixedPair2D2D(testPair):
+
+    def __init__(self, single1, single2):
+
+        if __debug__: 
+                assert isinstance(single1.structure, PlanarSurface) 
+                assert isinstance(single2.structure, PlanarSurface) 
+        self.surface1 = single1.structure         # note that these need to be initialized before calling testPair.__init__
+        self.surface2 = single2.structure         # since then these are needed for calculating the transform
+
+        testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
+
+    def get_sigma(self):
+        # Nothing changed as compared to the simple pair here
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        return radius1 + radius2
+    sigma = property(get_sigma)
+
+    def do_transform(self):
+        # Transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
+        # As an indermediate step project position of single2 into plane of single1 and prolongate
+        # it by the orthogonal component to transform the whole problem into a single 2D plane
+        pos1 = self.pid_particle_pair1[1].position
+        pos2 = self.surface1.deflect_back(self.pid_particle_pair2[1].position)
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
+
+        com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
+        com = self.world.apply_boundary(com)
+        # make sure that the com is in the structure of the particle (assume that this is done correctly in
+        # calculate_pair_CoM)
+
+        pos2t = self.world.cyclic_transpose(pos2, pos1)
+        iv = pos2t - pos1
+
+        return com, iv
+
+
 
 ##################################
 # These classes define the geometric aspect of the existing domains. When making a domain, the domain

From 32a306c736268749f5358de38953400bfe43899d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 17 Apr 2012 19:27:35 +0200
Subject: [PATCH 0781/1541] Revised version of the back deflection function

The former was not correct. It is not the prolongation of the projection
that determines the undeflected point; the new vector is the sum of the
projection and the orthogonal part rotated by 90 degrees.
---
 Box.hpp       |  9 +++++----
 Cylinder.hpp  |  9 +++++----
 Plane.hpp     | 38 ++++++++++++++++++++++++--------------
 Region.hpp    |  4 ++--
 Sphere.hpp    |  9 +++++----
 Structure.hpp |  2 +-
 Surface.hpp   |  4 ++--
 7 files changed, 44 insertions(+), 31 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index fbd6fbba..dbfa333b 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -291,12 +291,13 @@ deflect(Box<T_> const& obj,
 
 template<typename T_>
 inline typename Box<T_>::position_type
-deflect_back(Box<T_> const& obj,
+deflect_back(Box<T_> const& obj0,
         typename Box<T_>::position_type const& r0,
-        typename Box<T_>::position_type const& r1  )
+        typename Box<T_>::position_type const& r1,
+        typename Box<T_>::position_type const& n1  )
 {
-    // Return the difference vector without any changes
-    return subtract(r1, r0);
+    // Return the vector r1 without any changes
+    return r1;
 }
 
 template<typename T, typename Trng>
diff --git a/Cylinder.hpp b/Cylinder.hpp
index a647475f..8e40fb2b 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -214,12 +214,13 @@ deflect(Cylinder<T_> const& obj,
 
 template<typename T_>
 inline typename Cylinder<T_>::position_type
-deflect_back(Cylinder<T_> const& obj,
+deflect_back(Cylinder<T_> const& obj0,
         typename Cylinder<T_>::position_type const& r0,
-        typename Cylinder<T_>::position_type const& r1  )
+        typename Cylinder<T_>::position_type const& r1,
+        typename Cylinder<T_>::position_type const& n1  )
 {
-    // Return the difference vector without any changes
-    return subtract(r1, r0);
+    // Return the vector r1 without any changes
+    return r1;
 }
 
 template<typename T, typename Trng>
diff --git a/Plane.hpp b/Plane.hpp
index 64c9307b..9d815498 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -270,26 +270,36 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
 
 template<typename T_>
 inline typename Plane<T_>::position_type
-deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& r1)
-// This function projects a vector onto a plane and prolongates the projection by the part of it orthogonal to the plane,
-// returning a (vector) position type 
+deflect_back(Plane<T_> const& obj0, typename Plane<T_>::position_type const& r0,
+                                    typename Plane<T_>::position_type const& r1,
+                                    typename Plane<T_>::position_type const& n1)
+// This function projects a vector onto plane obj 0 and prolongates the projection by adding the part of it orthogonal
+// to the plane rotated by 90 degrees towards the outward of plane obj 0; it thus performs the deflection transition backward.
+// The function is meant to be used to calculate the shortest distance between two particles on different orthogonal planes;
+// note that the latter in general is not simply the sum of the projections of the interparticle vector on the two planes.
+// ATTENTION: r0 is assumed to be in plane obj0 while n1 is the normal vector of the plane that r1 lives on!
+// The function will only yield meaningful results if the input information is provided correctly!
 {
      // Type abbreviations
     typedef typename Plane<T_>::length_type length_type;
     typedef typename Plane<T_>::position_type position_type;
     typedef std::pair<position_type, length_type> projected_type;
-            
-    position_type  dr(subtract(r1, r0));            // difference vector r1 - r0
-    projected_type dr_proj(projected_point(obj, dr));
-    length_type    dr_proj_len(length(dr_proj.first)); // length of dr projected onto plane obj        
+        
+    position_type  dr(subtract(r1, r0)); // difference vector r1 - r0    
+    projected_type r1_proj(projected_point(obj0, r1));
+    position_type  dc(subtract(r1_proj.first, obj0.position()));  
+                   // vector pointing towards the projection of r1 on obj0
+                   // from the center of the latter
+    
+    position_type u_perp;    // unit vector pointing away from the edge between the two planes
+    position_type r1_new;    // r1 projected into plane 0 + rotated orthogonal part of it
+
+    
+    // Find the unit vector perpendicular to the edge by comparing with n1
+    if(dot_product(dc, n1) > 0.0)       u_perp = n1;
+    else                                u_perp = multiply(n1, -1.0);        
     
-    position_type u_dr_proj; // the normalized projection of dr on the plane (given in the global coord. system)
-    position_type r1_new;
-    length_type   dr_len_new;
-            
-    u_dr_proj  = normalize(dr_proj.first);    
-    dr_len_new = add(dr_proj_len, dr_proj.second);    
-    r1_new     = add(r0, multiply(u_dr_proj, dr_len_new));
+    r1_new = add(r1_proj.first, multiply(u_perp, abs(r1_proj.second)) );
     
     return r1_new;  
 }
diff --git a/Region.hpp b/Region.hpp
index f2d5653b..91e7ece1 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -108,9 +108,9 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::deflect(shape(), pos0, displacement);
     }
     
-    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1) const
+    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1, position_type const& n1) const
     {
-        return ::deflect_back(shape(), pos0, pos1);
+        return ::deflect_back(shape(), pos0, pos1, n1);
     }
     
     virtual position_type const& structure_position() const
diff --git a/Sphere.hpp b/Sphere.hpp
index 999578d7..fed03e35 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -114,12 +114,13 @@ deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typ
 
 template<typename T_>
 inline typename Sphere<T_>::position_type
-deflect_back(Sphere<T_> const& obj,
+deflect_back(Sphere<T_> const& obj0,
         typename Sphere<T_>::position_type const& r0,
-        typename Sphere<T_>::position_type const& r1  )
+        typename Sphere<T_>::position_type const& r1,
+        typename Sphere<T_>::position_type const& n1  )
 {
-    // Return the difference vector without any changes
-    return subtract(r1, r0);
+    // Return the vector r1 without any changes
+    return r1;
 }
 
 template<typename T_>
diff --git a/Structure.hpp b/Structure.hpp
index a0b78f6c..7652ff7f 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -117,7 +117,7 @@ class Structure
     
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
     
-    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1) const = 0;
+    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1, position_type const& n1) const = 0;
     
     virtual position_type const& structure_position() const = 0;
 
diff --git a/Surface.hpp b/Surface.hpp
index 10316a41..3d891435 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -115,9 +115,9 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::deflect(shape(), pos0, displacement);
     }
     
-    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1) const
+    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1, position_type const& n1) const
     {
-        return ::deflect_back(shape(), pos0, pos1);
+        return ::deflect_back(shape(), pos0, pos1, n1);
     }
     
     virtual position_type const& structure_position() const

From d1ba7357e012fa7151547edba5f7541bb789cf3e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 18 Apr 2012 15:05:52 +0200
Subject: [PATCH 0782/1541] generalized the distance_comparator to also be used
 for lists of structure_id_pair_and_distance_lists

---
 ParticleContainer.hpp     |  5 ++++-
 ParticleContainerBase.hpp | 19 +++++++++++--------
 2 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 30f0a320..d40406fe 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -42,7 +42,10 @@ class ParticleContainer
     typedef std::set<particle_id_type>                                              particle_id_set;
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
     typedef abstract_limited_generator<structure_id_pair>                           structure_id_pair_generator;
-    typedef std::pair<structure_id_type, length_type>                               structure_id_and_distance_pair;
+    typedef std::pair<structure_id_type, length_type>                               structure_id_and_distance_pair; // TODO remove
+    typedef std::pair<structure_id_pair, length_type>                               structure_id_pair_and_distance;
+    typedef unassignable_adapter<structure_id_pair_and_distance,
+                                 get_default_impl::std::vector>                     structure_id_pair_and_distance_list;
     typedef std::set<structure_id_type>                                             structure_id_set;
 
 private:
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 7569623b..09a4f76d 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -23,15 +23,16 @@ struct ParticleContainerUtils
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
+    template<typename Tobject_and_distance_list_>
     struct distance_comparator:
             public std::binary_function<
-                typename particle_id_pair_and_distance_list::placeholder,
-                typename particle_id_pair_and_distance_list::placeholder,
+                typename Tobject_and_distance_list_::placeholder,
+                typename Tobject_and_distance_list_::placeholder,
                 bool>
     {
-        typedef typename particle_id_pair_and_distance_list::placeholder
-                first_argument_type;
-        typedef typename particle_id_pair_and_distance_list::const_caster const_caster;
+        typedef Tobject_and_distance_list_              list_type;
+        typedef typename list_type::placeholder         first_argument_type;
+        typedef typename list_type::const_caster        const_caster;
         bool operator()(first_argument_type const& lhs,
                         first_argument_type const& rhs) const
         {
@@ -72,9 +73,9 @@ struct ParticleContainerUtils
         }
 
     private:
-        Tset_ const& ignore_;
+        Tset_ const&                        ignore_;
         particle_id_pair_and_distance_list* result_;
-        distance_comparator compare_;
+        distance_comparator<particle_id_pair_and_distance_list>                 compare_;
     };
 };
 
@@ -115,7 +116,9 @@ class ParticleContainerBase
     typedef std::pair<particle_id_pair, length_type>                    particle_id_pair_and_distance;
     typedef sized_iterator_range<typename particle_matrix_type::const_iterator> particle_id_pair_range;
 
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
+    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector>  particle_id_pair_and_distance_list;
+    typedef typename base_type::structure_id_pair_and_distance_list                             structure_id_pair_and_distance_list;
+    typedef typename base_type::structure_id_pair_and_distance                                  structure_id_pair_and_distance;
 
 protected:
 // Implementation of the methods.

From 5cf52fc37227e96d3078529a85b7afc972d98bac Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 18 Apr 2012 15:08:11 +0200
Subject: [PATCH 0783/1541] Implemented methods to get set of visible
 structures, and list of visibles structures and their distance.

---
 World.hpp | 75 +++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 62 insertions(+), 13 deletions(-)

diff --git a/World.hpp b/World.hpp
index 3a09d6ad..7df509c8 100644
--- a/World.hpp
+++ b/World.hpp
@@ -227,6 +227,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename base_type::structure_id_pair                           structure_id_pair;
     typedef std::pair<position_type, length_type>                           projected_type;
     typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
+    typedef typename base_type::structure_id_pair_and_distance_list         structure_id_pair_and_distance_list;
+    typedef typename base_type::structure_id_pair_and_distance              structure_id_pair_and_distance;
 
     typedef typename base_type::particle_id_set                             particle_id_set;
     typedef typename base_type::structure_id_set                            structure_id_set;
@@ -268,7 +270,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             position_type const& pos)
     {
         species_type const& species(get_species(sid));
-        boost::shared_ptr<structure_type> structure(get_structure(structure_id));
+        const boost::shared_ptr<const structure_type> structure(get_structure(structure_id));
         // assert that the structure is of the type denoted by the species of the particle.
         BOOST_ASSERT(structure->sid() == species.structure_type_id());
 
@@ -456,17 +458,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         return (*i).second;
     }
-    // Get all the structure ids of the substructures
-    structure_id_set get_substructure_ids(structure_id_type const& id) const
-    {
-        typename per_structure_substructure_id_set::const_iterator i(
-            structure_substructures_map_.find(id));
-        if (i == structure_substructures_map_.end())
-        {
-            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
-        }
-        return (*i).second;
-    }
     // Get and set the default structure of the World
     virtual structure_id_type get_def_structure_id() const
     {
@@ -512,8 +503,36 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         
         return structure_id_and_distance_pair( ret_id , ret_dist );
     }
-    virtual structures_range get_close_structures(position_type const& pos, structure_id_type const& current_struct_id)const
+    virtual structure_id_pair_and_distance_list get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
+                                                                     structure_id_type const& ignore) const
     {
+        const length_type world_size( base_type::world_size() );
+        structure_id_pair_and_distance_list result;
+
+        const structure_id_set visible_structures (get_visible_structures(current_struct_id));
+        BOOST_FOREACH(const structure_id_type id, visible_structures)
+        {
+            if( id == ignore)
+                continue;
+            
+            boost::shared_ptr<structure_type> structure(get_structure(id));
+            const position_type cyc_pos(cyclic_transpose(pos, structure->position(), world_size));
+            const length_type dist(structure->distance(cyc_pos));
+
+            result.push_back(std::make_pair(std::make_pair(id, structure), dist));
+        }
+
+        struct dist_comparer
+        {
+            bool operator()(structure_id_pair_and_distance const& struct_id_pair_dist_1,
+                            structure_id_pair_and_distance const& struct_id_pair_dist_2) const
+            {
+                return (struct_id_pair_dist_1.second < struct_id_pair_dist_2.second);
+            }
+        } comparer;
+
+//        std::sort(result.begin(), result.end(), comparer);
+        return result;
     }
 
     // Get all the particle ids of the particles on a structure
@@ -568,6 +587,36 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         default_structure_type_id_ = sid;
     }
 
+private:
+    // Get all the structure ids of the substructures
+    structure_id_set get_substructure_ids(structure_id_type const& id) const
+    {
+        typename per_structure_substructure_id_set::const_iterator i(
+            structure_substructures_map_.find(id));
+        if (i == structure_substructures_map_.end())
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
+    structure_id_set get_visible_structures(structure_id_type const& id) const
+    {
+        structure_id_set visible_structures;
+
+        const boost::shared_ptr<const structure_type> structure(get_structure(id));
+        if (structure->structure_id() == id)
+        {
+            visible_structures = structure_id_set();
+        }
+        else
+        {
+            visible_structures = get_visible_structures(structure->structure_id());
+            visible_structures.erase(id);
+        }
+        const structure_id_set substructures (get_substructure_ids(id));
+        visible_structures.insert(substructures.begin(), substructures.end());
+        return visible_structures;
+    }
 
 ///////////// Member variables
 private:

From 3468548023abf58fdebfddb490a21c4f355760ec Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 18 Apr 2012 15:22:38 +0200
Subject: [PATCH 0784/1541] generalized the overlap_checker to also work for
 particles vs structures.

---
 Multi.hpp                 |  2 +-
 ParticleContainerBase.hpp | 22 ++++++++++++----------
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index b27b48a5..1c022845 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -203,7 +203,7 @@ class MultiParticleContainer
     template<typename Tsph_, typename Tset_>
     particle_id_pair_and_distance_list* check_overlap(Tsph_ const& s, Tset_ const& ignore) const
     {
-        typename utils::template overlap_checker<Tset_> checker(ignore);
+        typename utils::template overlap_checker<particle_id_pair_and_distance_list, Tset_> checker(ignore);
         for (typename particle_map::const_iterator i(particles_.begin()),
                                                    e(particles_.end());
              i != e; ++i)
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 09a4f76d..e4cbb322 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -44,9 +44,11 @@ struct ParticleContainerUtils
 
 
 
-    template<typename Tset_>
+    template<typename Tobject_and_distance_list_, typename Tset_>
     struct overlap_checker
     {
+        typedef Tobject_and_distance_list_  list_type;
+
         // The constructor
         overlap_checker(Tset_ const& ignore = Tset_()): ignore_(ignore), result_(0) {}
 
@@ -57,13 +59,13 @@ struct ParticleContainerUtils
             {
                 if (!result_)
                 {
-                    result_ = new particle_id_pair_and_distance_list();
+                    result_ = new list_type();
                 }
                 result_->push_back(std::make_pair(*i, dist));
             }
         }
 
-        particle_id_pair_and_distance_list* result() const
+        list_type* result() const
         {
             if (result_)
             {
@@ -73,9 +75,9 @@ struct ParticleContainerUtils
         }
 
     private:
-        Tset_ const&                        ignore_;
-        particle_id_pair_and_distance_list* result_;
-        distance_comparator<particle_id_pair_and_distance_list>                 compare_;
+        Tset_ const&                    ignore_;
+        list_type*                      result_;
+        distance_comparator<list_type>  compare_;
     };
 };
 
@@ -206,7 +208,7 @@ class ParticleContainerBase
 
     virtual particle_id_pair_and_distance_list* check_overlap(particle_shape_type const& s, particle_id_type const& ignore) const
     {
-        return check_overlap(s, array_gen(ignore));
+        return check_overlap(s, array_gen(ignore)); // Why no parameterization of the template here?
     }
 
     virtual particle_id_pair_and_distance_list* check_overlap(particle_shape_type const& s, particle_id_type const& ignore1, particle_id_type const& ignore2) const
@@ -218,16 +220,16 @@ class ParticleContainerBase
     particle_id_pair_and_distance_list* check_overlap(Tsph_ const& s, Tset_ const& ignore,
         typename boost::disable_if<boost::is_same<Tsph_, particle_id_pair> >::type* =0) const
     {
-        typename utils::template overlap_checker<Tset_> oc(ignore);
+        typename utils::template overlap_checker<particle_id_pair_and_distance_list, Tset_> oc(ignore);
         traits_type::take_neighbor(pmat_, oc, s);
         return oc.result();
     }
-
+    // This is the same method as the one above but now without the 'ignore' list
     template<typename Tsph_>
     particle_id_pair_and_distance_list* check_overlap(Tsph_ const& s,
         typename boost::disable_if<boost::is_same<Tsph_, particle_id_pair> >::type* =0) const
     {
-        typename utils::template overlap_checker<boost::array<particle_id_type, 0> > oc;
+        typename utils::template overlap_checker<particle_id_pair_and_distance_list, boost::array<particle_id_type, 0> > oc;
         traits_type::take_neighbor(pmat_, oc, s);
         return oc.result();
     }

From 20dee1829ba2ce3bf29f81aee62df6d429883ab5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Apr 2012 15:54:28 +0200
Subject: [PATCH 0785/1541] Further cleanup of deflect_back: r0 is not needed
 to transform r1.

... given that the function is called of the plane that the r0 particle
lives on and that we provide the unit vector of the plane that the
r1 particle lives on.
---
 Box.hpp       | 11 +++++------
 Cylinder.hpp  | 11 +++++------
 Plane.hpp     | 38 +++++++++++++++++++-------------------
 Region.hpp    |  4 ++--
 Sphere.hpp    | 11 +++++------
 Structure.hpp |  2 +-
 Surface.hpp   |  4 ++--
 7 files changed, 39 insertions(+), 42 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index dbfa333b..080c3273 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -291,13 +291,12 @@ deflect(Box<T_> const& obj,
 
 template<typename T_>
 inline typename Box<T_>::position_type
-deflect_back(Box<T_> const& obj0,
-        typename Box<T_>::position_type const& r0,
-        typename Box<T_>::position_type const& r1,
-        typename Box<T_>::position_type const& n1  )
+deflect_back(Box<T_> const& obj,
+        typename Box<T_>::position_type const& r,
+        typename Box<T_>::position_type const& u_z  )
 {
-    // Return the vector r1 without any changes
-    return r1;
+    // Return the vector r without any changes
+    return r;
 }
 
 template<typename T, typename Trng>
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 8e40fb2b..d6d21e2b 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -214,13 +214,12 @@ deflect(Cylinder<T_> const& obj,
 
 template<typename T_>
 inline typename Cylinder<T_>::position_type
-deflect_back(Cylinder<T_> const& obj0,
-        typename Cylinder<T_>::position_type const& r0,
-        typename Cylinder<T_>::position_type const& r1,
-        typename Cylinder<T_>::position_type const& n1  )
+deflect_back(Cylinder<T_> const& obj,
+        typename Cylinder<T_>::position_type const& r,
+        typename Cylinder<T_>::position_type const& u_z  )
 {
-    // Return the vector r1 without any changes
-    return r1;
+    // Return the vector r without any changes
+    return r;
 }
 
 template<typename T, typename Trng>
diff --git a/Plane.hpp b/Plane.hpp
index 9d815498..b29fe792 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -270,38 +270,38 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
 
 template<typename T_>
 inline typename Plane<T_>::position_type
-deflect_back(Plane<T_> const& obj0, typename Plane<T_>::position_type const& r0,
-                                    typename Plane<T_>::position_type const& r1,
-                                    typename Plane<T_>::position_type const& n1)
-// This function projects a vector onto plane obj 0 and prolongates the projection by adding the part of it orthogonal
-// to the plane rotated by 90 degrees towards the outward of plane obj 0; it thus performs the deflection transition backward.
-// The function is meant to be used to calculate the shortest distance between two particles on different orthogonal planes;
-// note that the latter in general is not simply the sum of the projections of the interparticle vector on the two planes.
-// ATTENTION: r0 is assumed to be in plane obj0 while n1 is the normal vector of the plane that r1 lives on!
+deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, typename Plane<T_>::position_type const& u_z)
+// This function projects a vector onto plane obj and prolongates the projection by adding the part of it orthogonal
+// to the plane rotated by 90 degrees towards the outward of plane obj; it thus performs the deflection transition backward.
+// The function is meant to be used to calculate the shortest distance between two particles on different orthogonal planes
+// by projecting an orthogonal position back into the plane; note that the shortest distance in general is not simply the sum
+// of the projections of the interparticle vector on the two planes.
+// ATTENTION: u_z must be the normal vector of the plane that the particle at pos. r lives on!
 // The function will only yield meaningful results if the input information is provided correctly!
 {
      // Type abbreviations
     typedef typename Plane<T_>::length_type length_type;
     typedef typename Plane<T_>::position_type position_type;
     typedef std::pair<position_type, length_type> projected_type;
-        
-    position_type  dr(subtract(r1, r0)); // difference vector r1 - r0    
-    projected_type r1_proj(projected_point(obj0, r1));
-    position_type  dc(subtract(r1_proj.first, obj0.position()));  
-                   // vector pointing towards the projection of r1 on obj0
+    
+    projected_type r_proj(projected_point(obj, r));
+    position_type  dc(subtract(r_proj.first, obj.position()));
+                   // vector pointing towards the projection of r on plane obj
                    // from the center of the latter
     
     position_type u_perp;    // unit vector pointing away from the edge between the two planes
-    position_type r1_new;    // r1 projected into plane 0 + rotated orthogonal part of it
+    position_type r_new;    // r1 projected into plane 0 + rotated orthogonal part of it
 
+    // TODO: Assert that u_z is perpendicular to obj.unit_z ?
     
-    // Find the unit vector perpendicular to the edge by comparing with n1
-    if(dot_product(dc, n1) > 0.0)       u_perp = n1;
-    else                                u_perp = multiply(n1, -1.0);        
+    // Find the unit vector perpendicular to the edge by comparing with u_z
+    // (u_z might point outwards or inwards with respect to plane obj)
+    if(dot_product(dc, u_z) > 0.0)     u_perp = u_z;
+    else                               u_perp = multiply(u_z, -1.0);        
     
-    r1_new = add(r1_proj.first, multiply(u_perp, abs(r1_proj.second)) );
+    r_new = add(r_proj.first, multiply(u_perp, abs(r_proj.second)) );
     
-    return r1_new;  
+    return projected_point(obj, r_new).first;
 }
 
 template<typename T_>
diff --git a/Region.hpp b/Region.hpp
index 91e7ece1..a67401c1 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -108,9 +108,9 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::deflect(shape(), pos0, displacement);
     }
     
-    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1, position_type const& n1) const
+    virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const
     {
-        return ::deflect_back(shape(), pos0, pos1, n1);
+        return ::deflect_back(shape(), pos, u_z);
     }
     
     virtual position_type const& structure_position() const
diff --git a/Sphere.hpp b/Sphere.hpp
index fed03e35..a982aa33 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -114,13 +114,12 @@ deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typ
 
 template<typename T_>
 inline typename Sphere<T_>::position_type
-deflect_back(Sphere<T_> const& obj0,
-        typename Sphere<T_>::position_type const& r0,
-        typename Sphere<T_>::position_type const& r1,
-        typename Sphere<T_>::position_type const& n1  )
+deflect_back(Sphere<T_> const& obj,
+        typename Sphere<T_>::position_type const& r,
+        typename Sphere<T_>::position_type const& u_z  )
 {
-    // Return the vector r1 without any changes
-    return r1;
+    // Return the vector r without any changes
+    return r;
 }
 
 template<typename T_>
diff --git a/Structure.hpp b/Structure.hpp
index 7652ff7f..8f1fd3ec 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -117,7 +117,7 @@ class Structure
     
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
     
-    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1, position_type const& n1) const = 0;
+    virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const = 0;
     
     virtual position_type const& structure_position() const = 0;
 
diff --git a/Surface.hpp b/Surface.hpp
index 3d891435..1055ece7 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -115,9 +115,9 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::deflect(shape(), pos0, displacement);
     }
     
-    virtual position_type deflect_back(position_type const& pos0, position_type const& pos1, position_type const& n1) const
+    virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const
     {
-        return ::deflect_back(shape(), pos0, pos1, n1);
+        return ::deflect_back(shape(), pos, u_z);
     }
     
     virtual position_type const& structure_position() const

From 4c183380f8ad4cc8a954159d88cd6b333317e037 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Apr 2012 15:55:45 +0200
Subject: [PATCH 0786/1541] Continued basic implementation of
 TransitionPairtestShell

Also renamed stuff in a better way.
---
 shells.py | 69 +++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 62 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index 7fa3aff5..56415103 100755
--- a/shells.py
+++ b/shells.py
@@ -26,7 +26,7 @@
     'testTransitionSingle',
     'testPair',
     'testSimplePair',
-    'testMixedPair2D2D',
+    'testPlanarSurfaceTransitionPair',
     'testMixedPair2D3D',
     'hasSphericalShell',
     'hasCylindricalShell',   
@@ -349,15 +349,22 @@ def get_scaling_factor(self):
                                                 # normal to the plane
         return math.sqrt(self.D_r/D_2)
 
-class testMixedPair2D2D(testPair):
+class testPlanarSurfaceTransitionPair(testPair):
+
+    # This is essentially a copy of testSimplePair; however, the latter does
+    # not allow for particles being on different structures. Ergo we have to
+    # define a new class for that purpose.
+    # The main difference is in do_transform and get_min_pair_size which use
+    # the CoM calculated after projection of single2 into the plane of single1
+    # via deflect_back.
 
     def __init__(self, single1, single2):
 
         if __debug__: 
                 assert isinstance(single1.structure, PlanarSurface) 
                 assert isinstance(single2.structure, PlanarSurface) 
-        self.surface1 = single1.structure         # note that these need to be initialized before calling testPair.__init__
-        self.surface2 = single2.structure         # since then these are needed for calculating the transform
+        self.structure1 = single1.structure         # note that these need to be initialized before calling testPair.__init__
+        self.structure2 = single2.structure         # since then these are needed for calculating the transform
 
         testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
 
@@ -370,10 +377,10 @@ def get_sigma(self):
 
     def do_transform(self):
         # Transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
-        # As an indermediate step project position of single2 into plane of single1 and prolongate
-        # it by the orthogonal component to transform the whole problem into a single 2D plane
+        # As an indermediate step project position of single2 into plane of single1 and add its
+        # orthogonal component rotated by 90 deg. to transform the whole problem into a single 2D plane
         pos1 = self.pid_particle_pair1[1].position
-        pos2 = self.surface1.deflect_back(self.pid_particle_pair2[1].position)
+        pos2 = self.structure1.deflect_back(self.pid_particle_pair2[1].position, self.structure2.shape.unit_z)
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
@@ -387,6 +394,31 @@ def do_transform(self):
 
         return com, iv
 
+    def get_min_pair_size(self):
+        # This calculates the minimal 'size' of a simple pair.
+        # Note that the 'size' is interpreted differently dependent on the type of pair. When the pair is a
+        # SphericalPair          -> size = radius
+        # PlanarSurfacePair      -> size = radius
+        # CylindricalSurfacePair -> size = half_length
+
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+
+        dist_from_com1 = self.r0 * D_1 / self.D_tot      # particle distance from CoM
+        dist_from_com2 = self.r0 * D_2 / self.D_tot
+        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
+        iv_shell_size2 = dist_from_com2 + radius2
+
+        # also fix the minimum shellsize for the CoM domain
+        com_shell_size = max(radius1, radius2)
+
+        # calculate total radii including the margin for the burst volume for the particles
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * SINGLE_SHELL_FACTOR,
+                         iv_shell_size2 + com_shell_size + radius2 * SINGLE_SHELL_FACTOR)
+
+        return shell_size
 
 
 ##################################
@@ -1198,6 +1230,29 @@ def get_min_radius(self):
         # if the shell with minimal radius is constructed
         return self.distance_to_target_structure + self.pid_particle_pair[1].radius
 
+#####
+class PlanarSurfaceTransitionPairtestShell(SphericaltestShell, testPlanarSurfaceTransitionPair):
+
+    def __init__(self, single1, single2, geometrycontainer, domains):
+        SphericaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+
+        try:
+            testPlanarSurfaceTransitionPair.__init__(self, single1, single2)
+        except protoDomainError as e:
+            raise testShellError('(PlanarSurfaceTransitionPair). %s' %
+                                 (str(e)))
+
+        self.center = self.com
+        try:
+            self.radius = self.determine_possible_shell(self.structure1.id, [self.single1.domain_id, self.single2.domain_id],
+                                                        [self.structure2.id])
+        except ShellmakingError as e:
+            raise testShellError('(PlanarSurfaceTransitionPair). %s' %
+                                 (str(e)))
+
+    def get_min_radius(self):
+        return self.get_min_pair_size()
+
 
 ##########################
 class CylindricaltestShell(testShell):

From 1b9be191f7e83289c6ee58ad50c0d0b3a10bcb77 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 19 Apr 2012 11:33:53 +0200
Subject: [PATCH 0787/1541] started implementation of check_surface_overlap
 method

---
 Multi.hpp                     | 6 ++++++
 ParticleContainer.hpp         | 2 ++
 ParticleContainerBase.hpp     | 9 ++++++++-
 Transaction.hpp               | 6 ++++++
 binding/ParticleContainer.hpp | 8 ++++++++
 filters.hpp                   | 6 +++---
 6 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 1c022845..71e10718 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -52,6 +52,7 @@ class MultiParticleContainer
     typedef typename world_type::particle_container_type::structure_id_pair                 structure_id_pair;
     typedef typename world_type::particle_container_type::structure_id_and_distance_pair    structure_id_and_distance_pair;
     typedef typename world_type::particle_container_type::structure_id_set                  structure_id_set;
+    typedef typename world_type::particle_container_type::structure_id_pair_and_distance_list   structure_id_pair_and_distance_list;
 
     typedef typename Ttraits_::network_rules_type       network_rules_type;
     typedef typename Ttraits_::reaction_rule_type       reaction_rule_type;
@@ -217,6 +218,11 @@ class MultiParticleContainer
         return checker.result();
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    {
+        return world_.check_surface_overlap(s, old_pos, current);
+    }
+
     virtual particle_id_pair_generator* get_particles() const
     {
         return make_range_generator<particle_id_pair>(particles_);
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index d40406fe..ac4af20a 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -113,6 +113,8 @@ class ParticleContainer
 
     virtual particle_id_pair_and_distance_list* check_overlap(particle_shape_type const& s, particle_id_type const& ignore1, particle_id_type const& ignore2) const = 0;
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const = 0;
+
     virtual particle_id_pair_generator* get_particles() const = 0;
 
     virtual transaction_type* create_transaction() = 0;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index e4cbb322..214a8db3 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -65,6 +65,7 @@ struct ParticleContainerUtils
             }
         }
 
+        // The list of items is only sorted when the results are queried.
         list_type* result() const
         {
             if (result_)
@@ -109,7 +110,6 @@ class ParticleContainerBase
     typedef typename base_type::structure_id_set            structure_id_set;
     typedef typename base_type::structure_id_pair           structure_id_pair;
     typedef typename base_type::structure_types_range       structure_types_range;
-//    typedef std::pair<const particle_id_type, particle_type> particle_id_pair;
     typedef typename base_type::particle_id_pair            particle_id_pair;
     typedef Transaction<traits_type>                        transaction_type;
 
@@ -234,6 +234,13 @@ class ParticleContainerBase
         return oc.result();
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    {
+        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > oc;
+        // TODO
+        return oc.result();
+    }
+
     particle_id_pair get_particle(particle_id_type const& id, bool& found) const
     {
         typename particle_matrix_type::const_iterator i(pmat_.find(id));
diff --git a/Transaction.hpp b/Transaction.hpp
index 86ad8da6..ed382d9f 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -73,6 +73,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance,
                                  get_default_impl::std::vector> particle_id_pair_and_distance_list;
+    typedef typename particle_container_type::structure_id_pair_and_distance_list   structure_id_pair_and_distance_list;
     typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
 
 private:
@@ -170,6 +171,11 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.check_overlap(s, ignore1, ignore2);
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    {
+        return pc_.check_surface_overlap(s, old_pos, current);
+    }
+
     virtual Transaction<traits_type>* create_transaction()
     {
         return new TransactionImpl<particle_container_type>(*this);
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 48622a9a..dc489301 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -246,6 +246,7 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::particle_id_pair_generator           particle_id_pair_generator;
     typedef typename wrapped_type::structure_id_pair_generator          structure_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
+    typedef typename wrapped_type::structure_id_pair_and_distance_list  structure_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
     typedef typename wrapped_type::structure_id_set                     structure_id_set;
     typedef typename wrapped_type::structures_range                     structures_range;
@@ -380,6 +381,13 @@ class ParticleContainerWrapper
                .template unchecked<particle_id_pair_and_distance_list*>();
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    {
+        return py_wrapper_type::get_override("check_surface_overlap")(
+                s, old_pos, boost::python::make_tuple(current))
+               .template unchecked<structure_id_pair_and_distance_list*>();
+    }
+
     virtual particle_id_pair_generator* get_particles() const
     {
         return py_wrapper_type::get_override("__iter__")()
diff --git a/filters.hpp b/filters.hpp
index a8cb454d..c7e02730 100644
--- a/filters.hpp
+++ b/filters.hpp
@@ -34,13 +34,13 @@ class neighbor_filter
             distance(shape(offset(item.second, off)), cmp_.position()));
         if (dist < cmp_.radius())
         {
-            next_(i, dist);
+            next_(i, dist);     // put the item in the sorted list of overlapping particles.
         }
     }
 
 private:
-    Tfun_& next_;
-    const sphere_type cmp_;
+    Tfun_&              next_;  // structure (overlap checker) storing the overlapping particles.
+    const sphere_type   cmp_;   // The spherical particle whose neighbors are being checked.
 };
 
 template<typename Toc_, typename Tfun_, typename Tsphere_>

From 4089d567673f84ff7cf6a28152e646a40b943abc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Apr 2012 12:13:22 +0200
Subject: [PATCH 0788/1541] Basic implementation of PlanarSurfaceTransitionPair

... and some modifications of do_transform (also returns
structure ids now).

Not yet tested.
---
 pair.py   | 156 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 shells.py |   1 +
 2 files changed, 149 insertions(+), 8 deletions(-)

diff --git a/pair.py b/pair.py
index 71fca1e0..a0d048dc 100644
--- a/pair.py
+++ b/pair.py
@@ -17,6 +17,7 @@
 __all__ = [
     'CylindricalSurfacePair',
     'PlanarSurfacePair',
+    'PlanarSurfaceTransitionPair',
     'SphericalPair',
     'Pair',
     'SimplePair',
@@ -137,17 +138,16 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
         new_iv = self.draw_new_iv(dt, r0, old_iv, event_type)
 
         unit_z = self.get_shell_direction()
-        newpos1, newpos2 = self.do_back_transform(new_com, new_iv,
+        newpos1, newpos2, sid1, sid2 = self.do_back_transform(new_com, new_iv,
                                                   self.pid_particle_pair1[1].D,
                                                   self.pid_particle_pair2[1].D,
                                                   self.pid_particle_pair1[1].radius,
                                                   self.pid_particle_pair2[1].radius,
                                                   self.structure,
                                                   unit_z)
-        struct1_id = self.pid_particle_pair1[1].structure_id
-        struct2_id = self.pid_particle_pair2[1].structure_id
+        # sid = structure_id
 
-        return newpos1, newpos2, struct1_id, struct2_id
+        return newpos1, newpos2, sid1, sid2
 
     def draw_new_com(self, dt, event_type):
         # draws a new coordinate for the CoM in world coordinates
@@ -211,7 +211,7 @@ def __init__(self, domain_id, shell_id, rrs):
         # set the radii of the inner domains as a function of the outer protective domain
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
 
@@ -219,7 +219,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
 
-        return pos1, pos2
+        return pos1, pos2, self.structure.id, self.structure.id
 
     def get_shell_size(self):
         return self.shell.shape.radius
@@ -499,6 +499,146 @@ def __str__(self):
         return 'PlanarSurface' + Pair.__str__(self)
 
 
+class PlanarSurfaceTransitionPair(SimplePair, hasSphericalShell):
+    """2 Particles on two different but adjacent and orthogonal planar surfaces
+
+    """
+    # The test shell already defines structure1 and structure2 and should set
+    # structure=structure1 by default.
+    # We do all calculations here in structure1 assuming that pos2 has been 
+    # "deflected back" properly into structure1 at test shell construction.
+    # For safety each occurance of structure is replaced by structure1.
+    # Otherwise this class is equal to PlanarSurfacePair inheriting from
+    # hasSphericalShell instead of hasCylindricalShell and a modified 
+    # do_back_transform() method.
+    def __init__(self, domain_id, shell_id, testShell, rrs):
+
+        assert isinstance(testShell, PlanarSurfaceTransitionPairtestShell)
+        hasSphericalShell.__init__(self, testShell, domain_id)
+        self.LD_MAX = numpy.inf # 20?
+        SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
+        
+        assert(self.structure.id == self.structure1.id) # for safety, but self.structure shall not be used here
+    
+    def com_greens_function(self):
+        return GreensFunction2DAbsSym(self.D_R, self.a_R)
+
+    def iv_greens_function(self, r0):
+        return GreensFunction2DRadAbs(self.D_r, self.interparticle_ktot, r0,
+                                      self.sigma, self.a_r)
+
+    def choose_pair_greens_function(self, r0, t):
+        # selects between the full solution or an approximation where one of
+        # the boundaries is ignored
+        distance_from_sigma = r0 - self.sigma
+        distance_from_shell = self.a_r - r0
+
+        threshold_distance = Pair.CUTOFF_FACTOR * \
+            math.sqrt(4.0 * self.D_r * t)
+
+        if distance_from_sigma < threshold_distance:
+        
+            if distance_from_shell < threshold_distance:
+                # near both a and sigma;
+                # use GreensFunction2DRadAbs
+                if __debug__:
+                    log.debug('GF2D: normal')
+                return self.iv_greens_function(r0)
+            else:
+                # near sigma; use GreensFunction2DRadInf
+                if __debug__:
+                    log.debug('GF2D: only sigma')
+                return self.iv_greens_function(r0)
+                # Todo
+                # return GreensFunction2DRadInf(self.D_r, self.interparticle_ktot, r0, self.sigma)
+        else:
+            if distance_from_shell < threshold_distance:
+                # near a;
+                if __debug__:
+                    log.debug('GF2D: only a')
+                return self.iv_greens_function(r0)
+                # Todo
+                # return GreensFunction2DAbs(self.D_r, r0, self.a_r)
+                
+            else:
+                # distant from both a and sigma; 
+                if __debug__:
+                    log.debug('GF2D: free')
+                return self.iv_greens_function(r0)
+                # Todo
+                # return GreensFunction2D(self.D_r, r0)
+
+    def create_com_vector(self, r):
+        x, y = random_vector2D(r)
+        # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
+        # note that we use structure1 here, assuming that position of particle2 has been projected corretly
+        # into this plane at construction of the test shell
+        return x * self.structure1.shape.unit_x + y * self.structure1.shape.unit_y
+
+    def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
+
+        if __debug__:
+            log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
+        theta = draw_theta_wrapper(gf, r, dt)
+
+        # note that r0 = length (old_iv)
+        new_iv = (r/r0) * rotate_vector(old_iv, self.structure1.shape.unit_z, theta)
+        # note that unit_z can point two ways rotating the vector clockwise or counterclockwise
+        # Since theta is symmetric this doesn't matter.
+
+        # project the new_iv down on the unit vectors of the surface to prevent the particle from
+        # leaving the surface due to numerical problem
+        unit_x = self.structure1.shape.unit_x
+        unit_y = self.structure1.shape.unit_y
+
+        new_iv_x = unit_x * numpy.dot(new_iv, unit_x)
+        new_iv_y = unit_y * numpy.dot(new_iv, unit_y)
+
+        return new_iv_x + new_iv_y
+
+    @ classmethod
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure, unit_z):
+
+        # structure should be = structure1, but for safety we use the structures
+        # inherited from the test shell
+
+        # Calculate the new positions still in structure1
+        D_tot = D1 + D2
+        pos1 = com - iv * (D1 / D_tot)
+        pos2 = com + iv * (D2 / D_tot)
+
+        # Now we have to check (for both[!] new positions) whether they are still in plane1;
+        # if not, they have to be deflected on structure2.
+        # The structure.deflect() method requires a starting point and a displacement; we can construct
+        # bogus parameters for these by subtracting the center position of structure1 from pos1 and pos2.
+        s1_ctr = self.structure1.shape.position
+
+        new_pos1, changeflag1 = self.structure2.deflect(s1_ctr, pos1 - s1_ctr)
+        new_pos2, changeflag2 = self.structure2.deflect(s1_ctr, pos2 - s1_ctr)
+        
+        # adjust the structure_ids of the particles
+        if changeflag1 == 0 :
+            new_sid1 = self.structure1.id
+        else :
+            new_sid1 = self.structure2.id
+
+        if changeflag2 == 0 :
+            new_sid2 = self.structure1.id
+        else :
+            new_sid2 = self.structure2.id
+
+        # TODO: Check that the new positions are in their new planes and 
+        # maybe also that pos1 and pos2 are in structure1 in the first place?
+
+        return new_pos1, new_pos2, new_sid1, new_sid2
+
+    def get_shell_size(self):
+        return self.shell.shape.radius
+
+    def __str__(self):
+        return 'PlanarSurfaceTransition' + Pair.__str__(self)
+
+
 class CylindricalSurfacePair(SimplePair, hasCylindricalShell):
     """2 Particles inside a (cylindrical) shell on a CylindricalSurface.  
     (Rods).
@@ -703,7 +843,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         pos1 = com - weight1 * (iv_x + iv_y)
         pos2 = com + weight2 * (iv_x + iv_y) + iv_z 
 
-        return pos1, pos2
+        return pos1, pos2, self.surface.id, self.surface.id
 
     @classmethod
     def calc_z_scaling_factor(cls, D2d, D3d):
@@ -815,7 +955,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         pos1 = com - weight1 * iv_z
         pos2 = com + weight2 * iv_z + iv_r
 
-        return pos1, pos2
+        return pos1, pos2, self.surface.id, self.surface.id
 
     @classmethod
     def calc_r_scaling_factor(cls, D1, D2):
diff --git a/shells.py b/shells.py
index 56415103..15cceff0 100755
--- a/shells.py
+++ b/shells.py
@@ -365,6 +365,7 @@ def __init__(self, single1, single2):
                 assert isinstance(single2.structure, PlanarSurface) 
         self.structure1 = single1.structure         # note that these need to be initialized before calling testPair.__init__
         self.structure2 = single2.structure         # since then these are needed for calculating the transform
+        self.structure  = self.structure1           # some pair methods might need this to be defined
 
         testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
 

From 4c7d29ad2a2fab881f3cfc6c9fccabb15366aeed Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Apr 2012 16:03:40 +0200
Subject: [PATCH 0789/1541] Change pair switchbox in egfrd.py

---
 egfrd.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index edf2b960..4d90fae3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -126,6 +126,8 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return PlanarSurfacePairtestShell(single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, CylindricalSurface):
             return CylindricalSurfacePairtestShell(single1, single2, geometrycontainer, domains)
+    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
+        return PlanarSurfaceTransitiontestShell(single1, single2, geometrycontainer, domains) 
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
         return MixedPair2D3DtestShell(single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):

From 66b9e2c5c462c10edd1d1d4b32471bc31ad08ca7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Apr 2012 16:03:58 +0200
Subject: [PATCH 0790/1541] Add overlap safety check to new position sampling

---
 pair.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/pair.py b/pair.py
index a0d048dc..089c38dc 100644
--- a/pair.py
+++ b/pair.py
@@ -607,6 +607,33 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure, unit_z)
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
 
+        # Check whether the new positions will end up on the same structure
+        # by comparing their orthogonal components in the coordinate system of
+        # structure2 (which is orthogonal to structure1).
+        # These components also are used to calculate the safety factor for
+        # interparticle vector enlargement in case that the two particles
+        # indeed are on two different planes.
+        _. pos1_orth = self.structure2.projected_point(pos1)
+        _. pos2_orth = self.structure2.projected_point(pos2)
+
+        if( pos1_orth * pos2_orth < 0.0 ) :
+            # The particles will end up on different planes, i.e.
+            # that one of the points will be deflected.
+            # The interparticle vector therefore must be enlarged to
+            # ensure that there is no overlap after deflection.
+            particles_on_same_structure = 0
+            # Calculate the safety (= IPV enlargement) factor
+            l_iv = length(iv)
+            assert(2.0*abs(pos1_orth*pos2_orth) < (l_iv*l_iv))  # That should never fail!
+            iv_safety = 1.0/( 1.0 - 2.0*abs(pos1_orth*pos2_orth)/(l_iv*l_iv) )
+            # Recalculate the interparticle vector and new positions
+            iv_rescaled = iv_safety * iv            
+            pos1 = com - iv_rescaled * (D1 / D_tot)
+            pos2 = com + iv_rescaled * (D2 / D_tot)
+
+        else :
+            particles_on_same_structure = 1
+
         # Now we have to check (for both[!] new positions) whether they are still in plane1;
         # if not, they have to be deflected on structure2.
         # The structure.deflect() method requires a starting point and a displacement; we can construct

From dd71993355eae0f8a0194a18333807c0c55d581c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Apr 2012 16:47:32 +0200
Subject: [PATCH 0791/1541] Some egfrd.py cleanup

---
 egfrd.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4d90fae3..51840cf7 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -44,6 +44,7 @@
     PlanarSurfaceSingletestShell,
     PlanarSurfacePairtestShell,
     PlanarSurfaceTransitionSingletestShell,
+    PlanarSurfaceTransitionPairtestShell,
     CylindricalSurfaceSingletestShell,
     CylindricalSurfacePairtestShell,
     PlanarSurfaceInteractiontestShell,
@@ -127,7 +128,7 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
         elif isinstance(single1.structure, CylindricalSurface):
             return CylindricalSurfacePairtestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
-        return PlanarSurfaceTransitiontestShell(single1, single2, geometrycontainer, domains) 
+        return PlanarSurfaceTransitionPairtestShell(single1, single2, geometrycontainer, domains) 
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
         return MixedPair2D3DtestShell(single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
@@ -1461,7 +1462,6 @@ def make_new_domain(self, single):
         # Note that we do not differentiate between directions. This means that we
         # look around in a sphere, the horizons are spherical.
         pair_interaction_partners = []
-#        pair_interaction_partners_ids = [] # HACK
         for domain, _ in neighbor_distances:
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
@@ -1479,12 +1479,9 @@ def make_new_domain(self, single):
             if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):        # HACK
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR * 2
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
-#            pair_interaction_partners_ids.append((surface.id, surface_distance)) # HACK
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
-#        log.debug('pair_interaction_partners: %s' % str(pair_interaction_partners_ids)) # HACK
-
         # For each particles/particle or particle/surface pair, check if a pair or interaction can be
         # made. Note that we check the closest one first and only check if the object are within the horizon
         domain = None
@@ -1498,7 +1495,6 @@ def make_new_domain(self, single):
             if isinstance(obj, NonInteractionSingle):
                 # try making a Pair (can be Mixed Pair or Normal Pair)
                 domain = self.try_pair (single, obj)
-                # TODO: Include formation of "PlanarSurfaceTransitionPair"
 
             elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
                 domain = self.try_transition(single, obj)

From 4e715d1df0be87f02c65b5d7e005beb9f490c0a6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Apr 2012 18:02:31 +0200
Subject: [PATCH 0792/1541] Fix stupid binding bug

---
 binding/Structure.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 07df17aa..7d98b43a 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -47,7 +47,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("projected_point", &impl_type::projected_point)
         .def("deflect", &impl_type::deflect)
-        .def("deflect_back", &impl_type::deflect)
+        .def("deflect_back", &impl_type::deflect_back)
         ;
 }
 

From 96715e0e5dd5f8b3a800513d901c462986cf8112 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Apr 2012 19:20:37 +0200
Subject: [PATCH 0793/1541] Cleanup and debugging

Careful, there are still some hacks in there for testing purposes,
yet to be removed!
---
 egfrd.py           | 18 ++++++++++--------
 pair.py            | 26 ++++++++++++++++++--------
 shells.py          |  6 ++++++
 transitiontools.py |  2 ++
 4 files changed, 36 insertions(+), 16 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 51840cf7..82812a7b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -140,14 +140,16 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
 def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
     # Either SphericalPair, PlanarSurfacePair, or CylindricalSurfacePair.
     if   isinstance(testShell, SphericalPairtestShell):
-        return SphericalPair          (domain_id, shell_id, testShell, reaction_rules)
+        return SphericalPair               (domain_id, shell_id, testShell, reaction_rules)
     elif isinstance(testShell, PlanarSurfacePairtestShell):
-        return PlanarSurfacePair      (domain_id, shell_id, testShell, reaction_rules)
+        return PlanarSurfacePair           (domain_id, shell_id, testShell, reaction_rules)
+    elif isinstance(testShell, PlanarSurfaceTransitionPairtestShell):
+        return PlanarSurfaceTransitionPair (domain_id, shell_id, testShell, reaction_rules)
     elif isinstance(testShell, CylindricalSurfacePairtestShell):
-        return CylindricalSurfacePair (domain_id, shell_id, testShell, reaction_rules)
+        return CylindricalSurfacePair      (domain_id, shell_id, testShell, reaction_rules)
     # or MixedPair (3D/2D)
     elif isinstance(testShell, MixedPair2D3DtestShell):
-        return MixedPair2D3D          (domain_id, shell_id, testShell, reaction_rules)
+        return MixedPair2D3D               (domain_id, shell_id, testShell, reaction_rules)
 
 
 class DomainEvent(Event):
@@ -1466,13 +1468,13 @@ def make_new_domain(self, single):
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
                 pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
-                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR
+                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR * 5 # HACK
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
             if isinstance(surface, PlanarSurface):
                 # with a planar surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) #* 2.0  # HACK!!! The * 2 factor is added manually! REMOVE THIS!
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
@@ -2511,10 +2513,10 @@ def check_domain(self, domain):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.structure.id, domain.surface.id]
-        elif isinstance(domain, PlanarSurfaceTransitionSingle):
+        elif isinstance(domain, PlanarSurfaceTransitionSingle) or isinstance(domain, PlanarSurfaceTransitionPair):
             # Ignore surface of the particle and interaction surface
             ignores = []
-            associated = [domain.origin_structure.id, domain.target_structure.id]
+            associated = [domain.structure1.id, domain.structure2.id]
         else:
             # Ignore the structure that the particles are associated with
             ignores = []
diff --git a/pair.py b/pair.py
index 089c38dc..f991ae2c 100644
--- a/pair.py
+++ b/pair.py
@@ -518,7 +518,17 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.LD_MAX = numpy.inf # 20?
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
         
-        assert(self.structure.id == self.structure1.id) # for safety, but self.structure shall not be used here
+        self.structure1 = self.testShell.structure1
+        self.structure2 = self.testShell.structure2
+        self.structure  = self.testShell.structure1 # just for safety
+
+    #@ property
+    #def structure1(self):
+        #return self.testShell.structure1
+
+    #@ property
+    #def structure2(self):
+        #return self.testShell.structure2
     
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
@@ -596,8 +606,8 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
         return new_iv_x + new_iv_y
 
-    @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure, unit_z):
+    #@ classmethod # TODO Why do we actually need this???
+    def do_back_transform(self, com, iv, D1, D2, radius1, radius2, structure, unit_z):
 
         # structure should be = structure1, but for safety we use the structures
         # inherited from the test shell
@@ -613,8 +623,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure, unit_z)
         # These components also are used to calculate the safety factor for
         # interparticle vector enlargement in case that the two particles
         # indeed are on two different planes.
-        _. pos1_orth = self.structure2.projected_point(pos1)
-        _. pos2_orth = self.structure2.projected_point(pos2)
+        _, pos1_orth = self.structure2.projected_point(pos1)
+        _, pos2_orth = self.structure2.projected_point(pos2)
 
         if( pos1_orth * pos2_orth < 0.0 ) :
             # The particles will end up on different planes, i.e.
@@ -872,7 +882,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
 
         return pos1, pos2, self.surface.id, self.surface.id
 
-    @classmethod
+    @ classmethod
     def calc_z_scaling_factor(cls, D2d, D3d):
         # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
         return math.sqrt( (D2d + D3d) / D3d)
@@ -950,7 +960,7 @@ def __str__(self):
 
 class MixedPair1D3D(Pair):
 
-    @classmethod
+    @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
@@ -984,7 +994,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
 
         return pos1, pos2, self.surface.id, self.surface.id
 
-    @classmethod
+    @ classmethod
     def calc_r_scaling_factor(cls, D1, D2):
         return math.sqrt((D1 + D2)/D2)
 
diff --git a/shells.py b/shells.py
index 15cceff0..324be817 100755
--- a/shells.py
+++ b/shells.py
@@ -188,6 +188,10 @@ def __init__(self, single, target_structure):
 
         self.origin_structure = self.structure
         self.target_structure = target_structure
+        # The following is needed by check_domain()
+        # TODO: Drop origin_structure and target_structure everywhere?
+        self.structure1 = self.structure
+        self.structure2 = target_structure
 
         # Note that we assume the structures are exactly connecting
         self.distance_to_target_structure = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
@@ -401,6 +405,8 @@ def get_min_pair_size(self):
         # SphericalPair          -> size = radius
         # PlanarSurfacePair      -> size = radius
         # CylindricalSurfacePair -> size = half_length
+        # TODO: Make sure this also works correctly when IP-vectors are enlarged to remove overlaps
+        # at deflection.
 
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
diff --git a/transitiontools.py b/transitiontools.py
index 5d63c3a2..cceb7c8d 100644
--- a/transitiontools.py
+++ b/transitiontools.py
@@ -30,6 +30,8 @@ def __init__(self, testShell, start_position):
         # Might be used internally by classes inheriting from here
         self.origin_structure  = testShell.origin_structure
         self.target_structure  = testShell.target_structure
+        self.structure1        = testShell.structure1
+        self.structure2        = testShell.structure2
 
         self.origin_center = self.origin_structure.shape.position
         self.target_center = self.target_structure.shape.position

From 1fc11dc43ac8b282cfc8691afcd502a858351555 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Apr 2012 19:36:12 +0200
Subject: [PATCH 0794/1541] Add a fix that deflects the new CoM if event =
 reaction

---
 pair.py | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/pair.py b/pair.py
index f991ae2c..27599e5e 100644
--- a/pair.py
+++ b/pair.py
@@ -669,6 +669,27 @@ def do_back_transform(self, com, iv, D1, D2, radius1, radius2, structure, unit_z
 
         return new_pos1, new_pos2, new_sid1, new_sid2
 
+    def draw_new_com(self, dt, event_type):
+        # Draws a new coordinate for the CoM in world coordinates.
+        # Since fire_pair_reaction() will call this function we have to
+        # change the default draw_new_com() to ensure that the new CoM
+        # is deflected into the right plane
+        if event_type == EventType.COM_ESCAPE:
+            r = self.a_R
+        else:
+            gf = self.com_greens_function()
+            r = draw_r_wrapper(gf, dt, self.a_R)
+
+        new_com = self.com + self.create_com_vector(r)
+
+        if event_type == EventType.IV_REACTION:
+            # Express the new CoM in plane1 and deflect it to plane2 if necessary
+            s1_ctr = self.structure1.shape.position
+            new_com, changeflag = self.structure2.deflect(s1_ctr, new_com - s1_ctr)
+
+        # TODO: Check whether the new CoM is in the right structure
+        return new_com
+
     def get_shell_size(self):
         return self.shell.shape.radius
 

From 268fb04920d80ad0f0c9251486b2d835d181f7a2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Apr 2012 14:42:23 +0200
Subject: [PATCH 0795/1541] Major revision of structure names in shells.py

* Pairs can have 2 structures now (structure1, structure2)
* testSimplePair still has a property structure (=structure1=structure2)
* For interaction singles we have renamed:
  - structure -> origin_structure
  - surface   -> target_structure
* testTransitionSingle has now:
  - origin_structure
  - target_structure
  - structure1 = origin_structure
  - structure2 = target_structure
* testMixedPair2D3D:
  - structure -> structure2
  - surface   -> structure1
  ... because the 2D particle is the first argument (single1)
  For clarity it now also has
  - structure2D = structure1 (ex-surface)
  - structure3D = structure2 (ex-structure)

*
---
 shells.py | 109 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 56 insertions(+), 53 deletions(-)

diff --git a/shells.py b/shells.py
index 324be817..54086b1c 100755
--- a/shells.py
+++ b/shells.py
@@ -151,28 +151,29 @@ def __init__(self, pid_particle_pair, structure):
 
 class testInteractionSingle(testSingle, Others):
 
-    def __init__(self, single, structure, surface):
+    def __init__(self, single, origin_structure, target_structure):
 
         # assert that the single is reset
         assert single.is_reset()
 
-        testSingle.__init__(self, single.pid_particle_pair, structure)
+        testSingle.__init__(self, single.pid_particle_pair, origin_structure)
         # Note: for the Others superclass nothing is to be initialized.
 
-        self.single  = single
-        self.surface = surface
+        self.single           = single
+        self.origin_structure = origin_structure
+        self.target_structure = target_structure
 
         ### initialize some constants that are common for the testInteractionSingle domains.
 
-        # calculate the Projected_point and distance to the surface
-        # Cyclic transpose needed when calling surface.projected_point!
+        # calculate the Projected_point and distance to the target_structure
+        # Cyclic transpose needed when calling target_structure.projected_point!
         pos_transposed = self.world.cyclic_transpose(self.pid_particle_pair[1].position,
-                                                     self.surface.shape.position)
-        self.reference_point, projection_length = self.surface.projected_point(pos_transposed)
+                                                     self.target_structure.shape.position)
+        self.reference_point, projection_length = self.target_structure.projected_point(pos_transposed)
 
         # projection_distance can be negative in case of plane
         # note that the distance is to the center of the cylinder in case of cylinders
-        self.particle_surface_distance = self.world.distance(self.surface.shape, self.pid_particle_pair[1].position)
+        self.particle_surface_distance = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
 
         # The reference_vector is the normalized vector from the reference_point to the particle
         self.reference_vector = normalize(pos_transposed - self.reference_point)
@@ -182,16 +183,14 @@ class testTransitionSingle(testSingle, Others):
     def __init__(self, single, target_structure):
 
         testSingle.__init__(self, single.pid_particle_pair, single.structure)
-
         assert (self.structure.sid == target_structure.sid)     # Both structures are of same structure_type
+
         self.single = single
 
         self.origin_structure = self.structure
         self.target_structure = target_structure
-        # The following is needed by check_domain()
-        # TODO: Drop origin_structure and target_structure everywhere?
-        self.structure1 = self.structure
-        self.structure2 = target_structure
+        self.structure1       = self.origin_structure
+        self.structure2       = self.target_structure
 
         # Note that we assume the structures are exactly connecting
         self.distance_to_target_structure = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
@@ -210,13 +209,17 @@ def __init__(self, single1, single2):
         self.single2 = single2
         self.pid_particle_pair1 = single1.pid_particle_pair
         self.pid_particle_pair2 = single2.pid_particle_pair
+
+        # In general we allow the two particles to be on different structures
+        self.structure1 = single1.structure
+        self.structure2 = single2.structure
+
         self.com, self.iv = self.do_transform()         # NOTE The IV always points from particle1 to particle2
         self.r0 = length(self.iv)
         if self.r0 < self.sigma:
             raise protoDomainError('distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
                 (self.single1, self.single2, FORMAT_DOUBLE % (self.r0 - self.sigma)))
 
-
     def get_D_tot(self):
         return self.pid_particle_pair1[1].D + \
                self.pid_particle_pair2[1].D
@@ -238,9 +241,9 @@ def __init__(self, single1, single2):
 
         # Simple pairs are pairs of particles that are on the same structure
         assert single1.structure == single2.structure
-        self.structure = single1.structure
-
         testPair.__init__(self, single1, single2)
+        self.structure = single1.structure # equal to self.structure1 and self.structure2,
+                                           # needed by some class methods downstream
 
     def get_sigma(self):
         radius1 = self.pid_particle_pair1[1].radius
@@ -297,13 +300,15 @@ class testMixedPair2D3D(testPair):
     def __init__(self, single2D, single3D):
 
         if __debug__: 
-		assert isinstance(single2D.structure, PlanarSurface) 
-        	assert isinstance(single3D.structure, CuboidalRegion) 
-        self.surface   = single2D.structure         # note that these need to be initialized before calling testPair.__init__
-        self.structure = single3D.structure         # since then these are needed for calculating the transform
+                assert isinstance(single2D.structure, PlanarSurface) 
+                assert isinstance(single3D.structure, CuboidalRegion)
+        testPair.__init__(self, single2D, single3D)
+          # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
+          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
 
-        testPair.__init__(self, single2D, single3D) # note: this makes self.single1/self.pid_particle_pair1 the 2D particle
-                                                    #              and self.single2/self.pid_particle_pair2 the 3D particle
+        # for clarity:
+        self.structure2D = single2D.structure   # equal to self.structure1
+        self.structure3D = single3D.structure   # equal to self.structure2
 
     def get_sigma(self):
         # rescale sigma to correct for the rescaling of the coordinate system
@@ -328,8 +333,8 @@ def do_transform(self):
         com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
 
         # and then projected onto the plane to make sure the CoM is in the surface
-        com = self.world.cyclic_transpose(com, self.surface.shape.position)
-        com, _ = self.surface.projected_point (com)
+        com = self.world.cyclic_transpose(com, self.structure2D.shape.position)
+        com, _ = self.structure2D.projected_point (com)
         com = self.world.apply_boundary(com)
 
 
@@ -338,9 +343,9 @@ def do_transform(self):
         iv = pos2t - pos1
 
         # rescale the iv in the axis normal to the plane
-        iv_z_component = numpy.dot (iv, self.surface.shape.unit_z)
-        iv_z     = self.surface.shape.unit_z * iv_z_component
-        new_iv_z = self.surface.shape.unit_z * (iv_z_component * self.get_scaling_factor())
+        iv_z_component = numpy.dot (iv, self.structure2D.shape.unit_z)
+        iv_z     = self.structure2D.shape.unit_z * iv_z_component
+        new_iv_z = self.structure2D.shape.unit_z * (iv_z_component * self.get_scaling_factor())
 
         iv = iv - iv_z + new_iv_z
 
@@ -367,9 +372,7 @@ def __init__(self, single1, single2):
         if __debug__: 
                 assert isinstance(single1.structure, PlanarSurface) 
                 assert isinstance(single2.structure, PlanarSurface) 
-        self.structure1 = single1.structure         # note that these need to be initialized before calling testPair.__init__
-        self.structure2 = single2.structure         # since then these are needed for calculating the transform
-        self.structure  = self.structure1           # some pair methods might need this to be defined
+        self.structure  = self.structure1           # some pair methods might need this to be defined TODO Remove and test
 
         testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
 
@@ -1223,7 +1226,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
 
         self.center = self.pid_particle_pair[1].position
         try:
-            self.radius = self.determine_possible_shell(self.structure.id, [self.single.domain_id],
+            self.radius = self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id],
                                                         [self.target_structure.id])
         except ShellmakingError as e:
             raise testShellError('(PlanarSurfaceTransitionSingle). %s' %
@@ -1644,9 +1647,9 @@ def apply_safety(self, r, z_right, z_left):
 #####
 class PlanarSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
-    def __init__(self, single, surface, geometrycontainer, domains):
+    def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testInteractionSingle.__init__(self, single, single.structure, surface)
+        testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
         # initialize scaling parameters
         self.dzdr_right = 1.0
@@ -1663,7 +1666,7 @@ def __init__(self, single, surface, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure.id, [self.single.domain_id], [self.surface.id])
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
             raise testShellError('(PlanarSurfaceInteration). %s' %
                                  (str(e)))
@@ -1700,15 +1703,15 @@ def apply_safety(self, r, z_right, z_left):
 #####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
-    def __init__(self, single, surface, geometrycontainer, domains):
+    def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testInteractionSingle.__init__(self, single, single.structure, surface)
+        testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
         # initialize scaling parameters
         self.dzdr_right = 1.0
         self.drdz_right = 1.0
         self.r0_right   = 0.0
-        self.z0_right   = -(self.particle_surface_distance + self.surface.shape.radius)   # note that this is because dzdr_right = 1.0
+        self.z0_right   = -(self.particle_surface_distance + self.target_structure.shape.radius)   # note that this is because dzdr_right = 1.0
         self.dzdr_left  = self.dzdr_right
         self.drdz_left  = self.drdz_right
         self.r0_left    = self.r0_right
@@ -1719,14 +1722,14 @@ def __init__(self, single, surface, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure.id, [self.single.domain_id], [self.surface.id])
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
             raise testShellError('(CylindricalSurfaceInteraction). %s' %
                                  (str(e)))
 
 
     def get_orientation_vector(self):
-        return self.surface.shape.unit_z
+        return self.target_structure.shape.unit_z
 
     def get_searchpoint(self):
         return self.reference_point         # calculated in the __init__ of testInteractionSingle
@@ -1735,17 +1738,17 @@ def get_referencepoint(self):
         return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + (self.particle_surface_distance + self.surface.shape.radius)
+        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + (self.particle_surface_distance + self.target_structure.shape.radius)
         dz_right = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         # TODO clarify
-        dz_right = ((-(self.particle_surface_distance + self.surface.shape.radius) + \
-                     math.sqrt(2*(self.get_searchradius()**2) - (self.particle_surface_distance + self.surface.shape.radius)**2)) / 2.0)
+        dz_right = ((-(self.particle_surface_distance + self.target_structure.shape.radius) + \
+                     math.sqrt(2*(self.get_searchradius()**2) - (self.particle_surface_distance + self.target_structure.shape.radius)**2)) / 2.0)
         dz_left  = dz_right
-        dr       = ((self.particle_surface_distance + self.surface.shape.radius) + dz_right)
+        dr       = ((self.particle_surface_distance + self.target_structure.shape.radius) + dz_right)
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1753,9 +1756,9 @@ def apply_safety(self, r, z_right, z_left):
 
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
 
-    def __init__(self, single, surface, geometrycontainer, domains):
+    def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testInteractionSingle.__init__(self, single, single.structure, surface)
+        testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
         # initialize scaling parameters
         self.dzdr_right = numpy.inf
@@ -1772,7 +1775,7 @@ def __init__(self, single, surface, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure.id, [self.single.domain_id], [self.surface.id])
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
             raise testShellError('(CylindricalSurfaceSink). %s' %
                                  (str(e)))
@@ -1787,10 +1790,10 @@ def __init__(self, single, surface, geometrycontainer, domains):
 
 
     def get_orientation_vector(self):
-        pos = self.world.cyclic_transpose(self.pid_particle_pair[1].position, self.surface.shape.position)
-        orientation_vector = pos - self.surface.shape.position
+        pos = self.world.cyclic_transpose(self.pid_particle_pair[1].position, self.target_structure.shape.position)
+        orientation_vector = pos - self.target_structure.shape.position
         # if the dot product is negative, then take the -unit_z, otherwise take unit_z
-        return self.surface.shape.unit_z * cmp(numpy.dot(orientation_vector, self.surface.shape.unit_z), 0)
+        return self.target_structure.shape.unit_z * cmp(numpy.dot(orientation_vector, self.target_structure.shape.unit_z), 0)
 
     def get_searchpoint(self):
         return self.pid_particle_pair[1].position
@@ -1855,8 +1858,8 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
-                                                          [self.surface.id])
+                            self.determine_possible_shell(self.structure3D.id, [self.single1.domain_id, self.single2.domain_id],
+                                                          [self.structure2D.id])
         except ShellmakingError as e:
             raise testShellError('(MixedPair2D3D). %s' %
                                  (str(e)))
@@ -1864,7 +1867,7 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
 
     def get_orientation_vector(self):
         # if the dot product is negative, then take the -unit_z, otherwise take unit_z
-        return self.surface.shape.unit_z * cmp(numpy.dot(self.iv, self.surface.shape.unit_z), 0)
+        return self.structure2D.shape.unit_z * cmp(numpy.dot(self.iv, self.structure2D.shape.unit_z), 0)
 
     def get_searchpoint(self):
         # TODO this can be improved, now same as PlanarSurfaceInteraction

From e6f4dbea50e721a7450fb087af49db3eff743934 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Apr 2012 15:14:43 +0200
Subject: [PATCH 0796/1541] Corresponding changes to pair.py

* Pair objects now have structure1 and structure2 by default
* Simple pair has an additional property structure
* extended do_back_transform classmethod to take two structures as arguments
* Some further nomenclature changes

TODO:
* PlanarSurfaceTransitionPair still inherits from SimplePair and overrides
  the check for equal structure.id for the two particles. This is not
  pretty but practical because it uses the same determine_radii function
  (defined by SimplePair).

  Solution: Make determine_radii a classmethod, too? For later...
---
 pair.py | 74 ++++++++++++++++++++++++++++++---------------------------
 1 file changed, 39 insertions(+), 35 deletions(-)

diff --git a/pair.py b/pair.py
index 27599e5e..d39b03a8 100644
--- a/pair.py
+++ b/pair.py
@@ -52,6 +52,9 @@ def __init__(self, domain_id, shell_id, rrs):
         self.pid_particle_pair1 = self.testShell.pid_particle_pair1
         self.pid_particle_pair2 = self.testShell.pid_particle_pair2
 
+        self.structure1 = self.testShell.structure1
+        self.structure2 = self.testShell.structure2
+
         self.interparticle_rrs = rrs
         self.interparticle_ktot = self.calc_ktot(rrs)
         # copy constants from the testShell so that we don't have to recalculate them.
@@ -143,7 +146,8 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
                                                   self.pid_particle_pair2[1].D,
                                                   self.pid_particle_pair1[1].radius,
                                                   self.pid_particle_pair2[1].radius,
-                                                  self.structure,
+                                                  self.structure1,
+                                                  self.structure2,
                                                   unit_z)
         # sid = structure_id
 
@@ -204,22 +208,24 @@ def __init__(self, domain_id, shell_id, rrs):
 
         Pair.__init__(self, domain_id, shell_id, rrs)
 
-        self.structure = self.testShell.structure              # structure on which both particles live
+        self.structure = self.testShell.structure # structure on which both particles live
 
         shell_size = self.get_shell_size()                  # FIXME
         self.a_R, self.a_r = self.determine_radii(self.r0, shell_size)
         # set the radii of the inner domains as a function of the outer protective domain
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
 
+        # For simple pairs the particles live on the same structure
+        assert(self.structure1.id == self.structure2.id)
         D_tot = D1 + D2
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
 
-        return pos1, pos2, self.structure.id, self.structure.id
+        return pos1, pos2, self.structure1.id, self.structure2.id
 
     def get_shell_size(self):
         return self.shell.shape.radius
@@ -515,21 +521,13 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         assert isinstance(testShell, PlanarSurfaceTransitionPairtestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        self.LD_MAX = numpy.inf # 20?
+        self.LD_MAX = numpy.inf # TODO was 20. Why?
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
         
         self.structure1 = self.testShell.structure1
         self.structure2 = self.testShell.structure2
         self.structure  = self.testShell.structure1 # just for safety
 
-    #@ property
-    #def structure1(self):
-        #return self.testShell.structure1
-
-    #@ property
-    #def structure2(self):
-        #return self.testShell.structure2
-    
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
@@ -606,8 +604,8 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
         return new_iv_x + new_iv_y
 
-    #@ classmethod # TODO Why do we actually need this???
-    def do_back_transform(self, com, iv, D1, D2, radius1, radius2, structure, unit_z):
+    @ classmethod
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
 
         # structure should be = structure1, but for safety we use the structures
         # inherited from the test shell
@@ -623,8 +621,8 @@ def do_back_transform(self, com, iv, D1, D2, radius1, radius2, structure, unit_z
         # These components also are used to calculate the safety factor for
         # interparticle vector enlargement in case that the two particles
         # indeed are on two different planes.
-        _, pos1_orth = self.structure2.projected_point(pos1)
-        _, pos2_orth = self.structure2.projected_point(pos2)
+        _, pos1_orth = cls.structure2.projected_point(pos1)
+        _, pos2_orth = cls.structure2.projected_point(pos2)
 
         if( pos1_orth * pos2_orth < 0.0 ) :
             # The particles will end up on different planes, i.e.
@@ -650,19 +648,19 @@ def do_back_transform(self, com, iv, D1, D2, radius1, radius2, structure, unit_z
         # bogus parameters for these by subtracting the center position of structure1 from pos1 and pos2.
         s1_ctr = self.structure1.shape.position
 
-        new_pos1, changeflag1 = self.structure2.deflect(s1_ctr, pos1 - s1_ctr)
-        new_pos2, changeflag2 = self.structure2.deflect(s1_ctr, pos2 - s1_ctr)
+        new_pos1, changeflag1 = cls.structure2.deflect(s1_ctr, pos1 - s1_ctr)
+        new_pos2, changeflag2 = cls.structure2.deflect(s1_ctr, pos2 - s1_ctr)
         
         # adjust the structure_ids of the particles
         if changeflag1 == 0 :
-            new_sid1 = self.structure1.id
+            new_sid1 = cls.structure1.id
         else :
-            new_sid1 = self.structure2.id
+            new_sid1 = cls.structure2.id
 
         if changeflag2 == 0 :
-            new_sid2 = self.structure1.id
+            new_sid2 = cls.structure1.id
         else :
-            new_sid2 = self.structure2.id
+            new_sid2 = cls.structure2.id
 
         # TODO: Check that the new positions are in their new planes and 
         # maybe also that pos1 and pos2 are in structure1 in the first place?
@@ -803,8 +801,8 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         Pair.__init__(self, domain_id, shell_id, rrs)
 
         assert isinstance(self.testShell, testMixedPair2D3D)
-        self.surface = self.testShell.surface       # the surface on which particle1 lives
-        self.structure = self.testShell.structure   # structure on which both particles live
+        self.structure2D = self.testShell.structure2D   # the surface on which particle1 lives
+        self.structure3D = self.testShell.structure3D   # structure on which both particles live
 
         # initialize some useful constants
         self.z_scaling_factor = self.testShell.get_scaling_factor()
@@ -867,9 +865,11 @@ def determine_radii(self):
         return a_R, a_r
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, structure3D, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
+    #
+    # structure3D is not used here but has to be passed because of the classmethod property
 
         D_tot = D1 + D2
         weight1 = D1 / D_tot
@@ -880,8 +880,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         min_iv_z_length = (radius1 + radius2) * 0.5 * (MINIMAL_SEPARATION_FACTOR - 1.0)
 
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
-        iv_x = surface.shape.unit_x * numpy.dot(iv, surface.shape.unit_x)
-        iv_y = surface.shape.unit_y * numpy.dot(iv, surface.shape.unit_y)
+        iv_x = structure2D.shape.unit_x * numpy.dot(iv, structure2D.shape.unit_x)
+        iv_y = structure2D.shape.unit_y * numpy.dot(iv, structure2D.shape.unit_y)
 
         # reflect the coordinates in the unit_z direction back to the side of the membrane
         # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
@@ -901,7 +901,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         pos1 = com - weight1 * (iv_x + iv_y)
         pos2 = com + weight2 * (iv_x + iv_y) + iv_z 
 
-        return pos1, pos2, self.surface.id, self.surface.id
+        return pos1, pos2, self.structure2D.id, self.structure2D.id
 
     @ classmethod
     def calc_z_scaling_factor(cls, D2d, D3d):
@@ -924,7 +924,7 @@ def iv_greens_function(self, r0):
     def create_com_vector(self, r):
         x, y = random_vector2D(r)
         # project the com onto the surface unit vectors to make sure that the coordinates are in the surface
-        return x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
+        return x * self.structure2D.shape.unit_x + y * self.structure2D.shape.unit_y
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
         # FIXME This is actually the same method as for SphericalPair
@@ -973,7 +973,7 @@ def check(self):
             'MixedPair2D3D: Domain did not obey scaling relationship. '
 
         # check that the CoM is in the surface
-        assert numpy.dot( (self.com-self.surface.shape.position), self.surface.shape.unit_z) == 0.0
+        assert numpy.dot( (self.com-self.structure2D.shape.position), self.structure2D.shape.unit_z) == 0.0
         # check that the IV is NOT in the surface
 
     def __str__(self):
@@ -982,19 +982,23 @@ def __str__(self):
 class MixedPair1D3D(Pair):
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1D, structure3D, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
     # unit_z is a putatively different unit_z than that available in the surface object
+    #
+    # note that structure1D is not a 1D object but the surface that the 1D particle is bound to
+    #
+    # structure3D is not used here but has to be passed because of the classmethod property
 
         D_tot = D1 + D2
         weight1 = D1 / D_tot
         weight2 = D2 / D_tot
 
-        min_iv_r_length = radius2 + surface.shape.radius
+        min_iv_r_length = radius2 + structure1D.shape.radius
 
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
-        iv_z = surface.shape.unit_z * numpy.dot(iv, surface.shape.unit_z)
+        iv_z = structure1D.shape.unit_z * numpy.dot(iv, structure1D.shape.unit_z)
         iv_r = iv - iv_z
 
         # reflect the coordinates in the unit_z direction back to the side of the membrane
@@ -1013,7 +1017,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, surface, unit_z):
         pos1 = com - weight1 * iv_z
         pos2 = com + weight2 * iv_z + iv_r
 
-        return pos1, pos2, self.surface.id, self.surface.id
+        return pos1, pos2, self.structure1D.id, self.structure1D.id
 
     @ classmethod
     def calc_r_scaling_factor(cls, D1, D2):

From a585d54701ae6484515ca09bc9a1e3f26943daa5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Apr 2012 13:43:10 +0200
Subject: [PATCH 0797/1541] moved stuff for structures from World to
 ParticleContainerBase

---
 Multi.hpp                     |  20 +++++-
 ParticleContainer.hpp         |  17 +++--
 ParticleContainerBase.hpp     | 129 ++++++++++++++++++++++++++++++++--
 Transaction.hpp               |  23 ++++--
 World.hpp                     | 122 +++-----------------------------
 binding/ParticleContainer.hpp |  20 +++++-
 binding/World.hpp             |   2 +-
 7 files changed, 201 insertions(+), 132 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 71e10718..f3ec1d80 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -52,6 +52,7 @@ class MultiParticleContainer
     typedef typename world_type::particle_container_type::structure_id_pair                 structure_id_pair;
     typedef typename world_type::particle_container_type::structure_id_and_distance_pair    structure_id_and_distance_pair;
     typedef typename world_type::particle_container_type::structure_id_set                  structure_id_set;
+    typedef typename world_type::particle_container_type::particle_id_pair_and_distance_list    particle_id_pair_and_distance_list;
     typedef typename world_type::particle_container_type::structure_id_pair_and_distance_list   structure_id_pair_and_distance_list;
 
     typedef typename Ttraits_::network_rules_type       network_rules_type;
@@ -60,8 +61,8 @@ class MultiParticleContainer
 
     typedef abstract_limited_generator<particle_id_pair>                    particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>                        particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance,
-                                 get_default_impl::std::vector>             particle_id_pair_and_distance_list;
+//    typedef unassignable_adapter<particle_id_pair_and_distance,
+//                                 get_default_impl::std::vector>             particle_id_pair_and_distance_list;
     typedef std::map<particle_id_type, particle_type>                       particle_map;
     typedef sized_iterator_range<typename particle_map::const_iterator>     particle_id_pair_range;
     typedef std::pair<const Real, const Real> real_pair;
@@ -105,11 +106,19 @@ class MultiParticleContainer
     {
         return world_.get_structures();     // TODO now gets all structures in world, -> make structure local to Multi
     }
+    // virtual structure_id_type add_structure(structure_type const& structure); // TODO add structure from the world to multi
+    virtual bool update_structure(structure_id_pair const& structid_pair)
+    {
+        return world_.update_structure(structid_pair);
+    }
+    virtual bool remove_structure(structure_id_type const& id)
+    {
+        return world_.remove_structure(id);
+    }
     virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const
     {
         return world_.get_structure_ids(sid);
     }
-    // virtual structure_id_type add_structure(structure_type const& structure); // TODO add structure from the world to multi
     virtual structure_id_type get_def_structure_id() const
     {
         return world_.get_def_structure_id();
@@ -118,6 +127,11 @@ class MultiParticleContainer
     {        
         return world_.get_closest_surface( pos, ignore );   // TODO loop only over 'local' surfaces
     }
+    virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
+                                                                      structure_id_type const& ignore) const
+    {
+        return world_.get_close_structures(pos, current_struct_id, ignore);
+    }
     // End structure stuff
 
     // StructureType stuff
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index ac4af20a..87cdb6e5 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -34,22 +34,22 @@ class ParticleContainer
     typedef typename particle_type::shape_type                  particle_shape_type;
     typedef Transaction<traits_type>                            transaction_type;
 
+    typedef std::set<particle_id_type>                                              particle_id_set;
     typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;
     typedef abstract_limited_generator<particle_id_pair>                            particle_id_pair_generator;
     typedef std::pair<particle_id_pair, length_type>                                particle_id_pair_and_distance;
     typedef unassignable_adapter<particle_id_pair_and_distance,
                                  get_default_impl::std::vector>                     particle_id_pair_and_distance_list;
-    typedef std::set<particle_id_type>                                              particle_id_set;
+    typedef std::set<structure_id_type>                                             structure_id_set;
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
     typedef abstract_limited_generator<structure_id_pair>                           structure_id_pair_generator;
     typedef std::pair<structure_id_type, length_type>                               structure_id_and_distance_pair; // TODO remove
     typedef std::pair<structure_id_pair, length_type>                               structure_id_pair_and_distance;
     typedef unassignable_adapter<structure_id_pair_and_distance,
                                  get_default_impl::std::vector>                     structure_id_pair_and_distance_list;
-    typedef std::set<structure_id_type>                                             structure_id_set;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >     structure_map;
 
 private:
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >     structure_map;
     typedef select_second<typename structure_map::value_type>                   structure_second_selector_type;
     typedef boost::transform_iterator<structure_second_selector_type,
             typename structure_map::const_iterator>                             structure_iterator;
@@ -89,12 +89,21 @@ class ParticleContainer
     
     virtual structures_range get_structures() const = 0;
 
+    virtual bool update_structure(structure_id_pair const& structid_pair) = 0;
+
+    virtual bool remove_structure(structure_id_type const& id) = 0;
+
     virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const = 0;
 
     virtual structure_id_type get_def_structure_id() const = 0;
 
     virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
 
+    virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
+                                                                      structure_id_type const& ignore) const = 0;
+
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const = 0;
+
     // Particle stuff
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos) = 0;
@@ -113,8 +122,6 @@ class ParticleContainer
 
     virtual particle_id_pair_and_distance_list* check_overlap(particle_shape_type const& s, particle_id_type const& ignore1, particle_id_type const& ignore2) const = 0;
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const = 0;
-
     virtual particle_id_pair_generator* get_particles() const = 0;
 
     virtual transaction_type* create_transaction() = 0;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 214a8db3..3bce8984 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -21,7 +21,6 @@ struct ParticleContainerUtils
     typedef typename traits_type::particle_id_type              particle_id_type;
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
     template<typename Tobject_and_distance_list_>
     struct distance_comparator:
@@ -107,10 +106,13 @@ class ParticleContainerBase
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type            structure_type;
     typedef typename base_type::particle_id_set             particle_id_set;
+    typedef typename base_type::particle_id_pair            particle_id_pair;
     typedef typename base_type::structure_id_set            structure_id_set;
     typedef typename base_type::structure_id_pair           structure_id_pair;
     typedef typename base_type::structure_types_range       structure_types_range;
-    typedef typename base_type::particle_id_pair            particle_id_pair;
+
+    typedef typename base_type::structure_map               structure_map;
+    typedef typename base_type::structures_range            structures_range;
     typedef Transaction<traits_type>                        transaction_type;
 
     typedef MatrixSpace<particle_type, particle_id_type, get_mapper_mf> particle_matrix_type;
@@ -118,12 +120,17 @@ class ParticleContainerBase
     typedef std::pair<particle_id_pair, length_type>                    particle_id_pair_and_distance;
     typedef sized_iterator_range<typename particle_matrix_type::const_iterator> particle_id_pair_range;
 
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector>  particle_id_pair_and_distance_list;
+    typedef typename base_type::particle_id_pair_and_distance_list                              particle_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance_list                             structure_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance                                  structure_id_pair_and_distance;
 
 protected:
 // Implementation of the methods.
+    typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
+    typedef boost::transform_iterator<structures_second_selector_type,
+            typename structure_map::const_iterator>                         structure_iterator;
+    typedef std::map<structure_id_type, structure_id_set>                   per_structure_substructure_id_set;
+
 public:
     ParticleContainerBase(length_type world_size, size_type size)
         : pmat_(world_size, size) {}
@@ -289,15 +296,129 @@ class ParticleContainerBase
         return pmat_.erase(id);
     }
 
+//////
+    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
+    {
+        typename structure_map::const_iterator i(structure_map_.find(id));
+        if (structure_map_.end() == i)
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
+    virtual structures_range get_structures() const
+    {
+        return get_structures_range();
+    }
+    virtual bool update_structure(structure_id_pair const& structid_pair)
+    {
+        typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
+        if (i != structure_map_.end())
+        // The item was already found in the map
+        {
+            if ((*i).second->structure_id() != structid_pair.second->structure_id())
+            // If the structure had a different parent structure
+            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hierarchy)
+            {
+                structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
+                structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+            }
+            structure_map_[(*i).first] = structid_pair.second;
+            return false;
+        }
 
+        // The structure was not yet in the world.
+        // create a new item in the structure mapping
+        structure_map_[structid_pair.first] = structid_pair.second;
+        // add the id the mapping 'super_structure_id -> set of substructures'
+        structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+        // create a new mapping from structure id -> set of substructures
+        structure_substructures_map_[structid_pair.first] = structure_id_set();
+        return true;
+    }
+    virtual bool remove_structure(structure_id_type const& id)
+    {
+        // TODO
+        //  -get all the substructures of structure
+        //  -only remove if no substructures
+        return false;
+    }
+    virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
+                                                                      structure_id_type const& ignore) const
+    {
+        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
+        const structure_id_set visible_structures (get_visible_structures(current_struct_id));
+
+        structure_map temp_map;
+        for (typename structure_id_set::const_iterator i(visible_structures.begin()),
+                                                       e(visible_structures.end());
+             i != e; ++i)
+        {
+            temp_map[(*i)] = get_structure(*i);
+        }
+
+        for (typename structure_map::const_iterator i(temp_map.begin()),
+                                                    e(temp_map.end());
+             i != e; ++i)
+        {
+            const position_type cyc_pos(cyclic_transpose(pos, ((*i).second)->position()));
+            const length_type dist((*i).second->distance(cyc_pos));
+            checker(i, dist);
+        }
+        return checker.result();
+    }
 
 ///////// Member variables
 protected:
     particle_matrix_type pmat_;         // just the structure (MatrixSpace) containing the particles.
-};
 
 
 
+///////// The following are public and private methods and variables of the class but should maybe be made into a separate class
+//        (and not a part of ParticleContainerBase).
+private:
+    structures_range get_structures_range() const
+    {
+        return structures_range(
+        structure_iterator(structure_map_.begin(), structures_second_selector_type()),
+        structure_iterator(structure_map_.end(),   structures_second_selector_type()),
+        structure_map_.size());
+    }
+    // Get all the structure ids of the substructures
+    structure_id_set get_substructure_ids(structure_id_type const& id) const
+    {
+        typename per_structure_substructure_id_set::const_iterator i(
+            structure_substructures_map_.find(id));
+        if (i == structure_substructures_map_.end())
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
+    structure_id_set get_visible_structures(structure_id_type const& id) const
+    {
+        structure_id_set visible_structures;
+
+        const boost::shared_ptr<const structure_type> structure(get_structure(id));
+        if (structure->structure_id() == id)
+        {
+            visible_structures = structure_id_set();
+        }
+        else
+        {
+            visible_structures = get_visible_structures(structure->structure_id());
+            visible_structures.erase(id);
+        }
+        const structure_id_set substructures (get_substructure_ids(id));
+        visible_structures.insert(substructures.begin(), substructures.end());
+        return visible_structures;
+    }
+
+protected:
+    structure_map                       structure_map_;     // mapping: structure_id -> structure
+    per_structure_substructure_id_set   structure_substructures_map_;
+};
+
 //////// Inline methods are defined separately
 template<typename Tderived_, typename Ttraits_>
 inline Transaction<Ttraits_>*
diff --git a/Transaction.hpp b/Transaction.hpp
index ed382d9f..fba507fe 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -32,8 +32,6 @@ class Transaction: public ParticleContainer<Ttraits_>
 
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance, get_default_impl::std::vector> particle_id_pair_and_distance_list;
 
     virtual ~Transaction() {}
 
@@ -68,12 +66,11 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
 
+    typedef typename particle_container_type::particle_id_pair_and_distance_list    particle_id_pair_and_distance_list;
+    typedef typename particle_container_type::structure_id_pair_and_distance_list   structure_id_pair_and_distance_list;
+
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
-    typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
-    typedef unassignable_adapter<particle_id_pair_and_distance,
-                                 get_default_impl::std::vector> particle_id_pair_and_distance_list;
-    typedef typename particle_container_type::structure_id_pair_and_distance_list   structure_id_pair_and_distance_list;
     typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
 
 private:
@@ -93,6 +90,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
             typename structure_type_map::const_iterator>                    structure_type_iterator;
     typedef typename particle_container_type::structure_types_range         structure_types_range;
     typedef typename particle_container_type::structure_id_set              structure_id_set;
+    typedef typename particle_container_type::structure_id_pair             structure_id_pair;
 
 
     // Particle Stuff
@@ -215,6 +213,14 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_structures();
     }    
+    virtual bool update_structure(structure_id_pair const& structid_pair)
+    {
+        return pc_.update_structure(structid_pair);
+    }
+    virtual bool remove_structure(structure_id_type const& id)
+    {
+        return pc_.remove_structure(id);
+    }
     virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const
     {
         return pc_.get_structure_ids(sid);
@@ -227,6 +233,11 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_closest_surface( pos, ignore );
     }
+    virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
+                                                                      structure_id_type const& ignore) const
+    {
+        return pc_.get_close_structures(pos, current_struct_id, ignore);
+    }
     // End structure stuff
 
 
diff --git a/World.hpp b/World.hpp
index 7df509c8..09eebc93 100644
--- a/World.hpp
+++ b/World.hpp
@@ -227,8 +227,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename base_type::structure_id_pair                           structure_id_pair;
     typedef std::pair<position_type, length_type>                           projected_type;
     typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
-    typedef typename base_type::structure_id_pair_and_distance_list         structure_id_pair_and_distance_list;
-    typedef typename base_type::structure_id_pair_and_distance              structure_id_pair_and_distance;
 
     typedef typename base_type::particle_id_set                             particle_id_set;
     typedef typename base_type::structure_id_set                            structure_id_set;
@@ -241,20 +239,15 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef std::map<species_id_type, particle_id_set>                      per_species_particle_id_set;
     typedef std::map<structure_type_id_type, structure_id_set>              per_structure_type_structure_id_set;
     typedef std::map<structure_id_type, particle_id_set>                    per_structure_particle_id_set;
-    typedef std::map<structure_id_type, structure_id_set>                   per_structure_substructure_id_set;
     typedef select_second<typename species_map::value_type>                 species_second_selector_type;   // not sure what this does.
-    typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
     typedef select_second<typename structure_type_map::value_type>          structure_types_second_selector_type;
 
 public:
     typedef boost::transform_iterator<species_second_selector_type,
             typename species_map::const_iterator>                           species_iterator;
-    typedef boost::transform_iterator<structures_second_selector_type,
-            typename structure_map::const_iterator>                         structure_iterator;
     typedef boost::transform_iterator<structure_types_second_selector_type,
             typename structure_type_map::const_iterator>                    structure_type_iterator;
     typedef sized_iterator_range<species_iterator>                          species_range;
-    typedef sized_iterator_range<structure_iterator>                        structures_range;
 
 public:
     // The constructor
@@ -262,7 +255,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         : base_type(world_size, size), default_structure_id_(structidgen_())
     {
         // Make sure that the mapping for the default structure already exists.
-        structure_substructures_map_[default_structure_id_] = structure_id_set();
+        // FIXME this is kinda ugly, but didn't want to add another argument to the base_type constructor
+        base_type::structure_substructures_map_[default_structure_id_] = structure_id_set();
     }
 
     // To create new particles
@@ -381,9 +375,9 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // update structure
     virtual bool update_structure(structure_id_pair const& structid_pair)
     {
-        typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
-        if (i != structure_map_.end())
-        // The item was already found in the map
+        typename base_type::structure_map::const_iterator i(base_type::structure_map_.find(structid_pair.first));
+        if (i != base_type::structure_map_.end())
+        // The item was already found
         {
             // FIXME what to do when the structure has particles and moves or changes structure_type?!?!
             // FIXME Or what to do when the structure has substructures?!
@@ -396,28 +390,16 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
                 structure_pool_[(*i).second->sid()].erase((*i).first);
                 structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
             }
-            if ((*i).second->structure_id() != structid_pair.second->structure_id())
-            // If the structure had a different parent structure
-            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hyarchie)
-            {
-                structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
-                structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
-            }
-            structure_map_[(*i).first] = structid_pair.second;
+            base_type::update_structure(structid_pair);
             return false;
         }
 
         // The structure was not yet in the world.
-        // create a new item in the structure mapping
-        structure_map_[structid_pair.first] = structid_pair.second;
+        BOOST_ASSERT(base_type::update_structure(structid_pair));
         // update the mapping 'structure_type_id -> set of structure ids'
         structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
         // create a new mapping from structure id -> set of particles
         particleonstruct_pool_[structid_pair.first] = particle_id_set();
-        // add the id the mapping 'super_structure_id -> set of substructures'
-        structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
-        // create a new mapping from structure id -> set of substructures
-        structure_substructures_map_[structid_pair.first] = structure_id_set();
         return true;
     }
     // remove structure
@@ -425,27 +407,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         // TODO
         //  -get all particles on structure
-        //  -get all the substructures of structure
-        //  -only remove if no particles and no substructures
-        return false;
-    }
-    // Get a structure by id
-    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
-    {
-        typename structure_map::const_iterator i(structure_map_.find(id));
-        if (structure_map_.end() == i)
-        {
-            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
-        }
-        return (*i).second;
-    }
-    // Get all the structures
-    virtual structures_range get_structures() const
-    {
-        return structures_range(
-            structure_iterator(structure_map_.begin(), structures_second_selector_type()),
-            structure_iterator(structure_map_.end(),   structures_second_selector_type()),
-            structure_map_.size());
+        //  -only remove if no particles
+        return base_type::remove_structure(id);
     }
     // Get all the structure ids by structure_type id
     structure_id_set get_structure_ids(structure_type_id_type const& sid) const
@@ -486,7 +449,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         length_type ret_dist( std::numeric_limits<length_type>::max() );
         structure_id_type ret_id( ignore );
 
-        BOOST_FOREACH(boost::shared_ptr<structure_type> const structure, get_structures())
+        BOOST_FOREACH(boost::shared_ptr<structure_type> const structure, base_type::get_structures())
         {
             if( structure->id() == ignore)
                 continue;
@@ -503,38 +466,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         
         return structure_id_and_distance_pair( ret_id , ret_dist );
     }
-    virtual structure_id_pair_and_distance_list get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
-                                                                     structure_id_type const& ignore) const
-    {
-        const length_type world_size( base_type::world_size() );
-        structure_id_pair_and_distance_list result;
-
-        const structure_id_set visible_structures (get_visible_structures(current_struct_id));
-        BOOST_FOREACH(const structure_id_type id, visible_structures)
-        {
-            if( id == ignore)
-                continue;
-            
-            boost::shared_ptr<structure_type> structure(get_structure(id));
-            const position_type cyc_pos(cyclic_transpose(pos, structure->position(), world_size));
-            const length_type dist(structure->distance(cyc_pos));
-
-            result.push_back(std::make_pair(std::make_pair(id, structure), dist));
-        }
-
-        struct dist_comparer
-        {
-            bool operator()(structure_id_pair_and_distance const& struct_id_pair_dist_1,
-                            structure_id_pair_and_distance const& struct_id_pair_dist_2) const
-            {
-                return (struct_id_pair_dist_1.second < struct_id_pair_dist_2.second);
-            }
-        } comparer;
-
-//        std::sort(result.begin(), result.end(), comparer);
-        return result;
-    }
-
     // Get all the particle ids of the particles on a structure
     particle_id_set get_particle_ids_on_struct(structure_id_type const& struct_id) const
     {
@@ -587,48 +518,15 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         default_structure_type_id_ = sid;
     }
 
-private:
-    // Get all the structure ids of the substructures
-    structure_id_set get_substructure_ids(structure_id_type const& id) const
-    {
-        typename per_structure_substructure_id_set::const_iterator i(
-            structure_substructures_map_.find(id));
-        if (i == structure_substructures_map_.end())
-        {
-            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
-        }
-        return (*i).second;
-    }
-    structure_id_set get_visible_structures(structure_id_type const& id) const
-    {
-        structure_id_set visible_structures;
-
-        const boost::shared_ptr<const structure_type> structure(get_structure(id));
-        if (structure->structure_id() == id)
-        {
-            visible_structures = structure_id_set();
-        }
-        else
-        {
-            visible_structures = get_visible_structures(structure->structure_id());
-            visible_structures.erase(id);
-        }
-        const structure_id_set substructures (get_substructure_ids(id));
-        visible_structures.insert(substructures.begin(), substructures.end());
-        return visible_structures;
-    }
-
 ///////////// Member variables
 private:
     particle_id_generator               pidgen_;            // generator used to produce the unique ids for the particles
     structure_id_generator              structidgen_;
     species_map                         species_map_;       // mapping: species_id -> species
     structure_type_map                  structure_type_map_;// mapping: structure_type_id -> structure_type
-    structure_map                       structure_map_;     // mapping: structure_id -> structure
     per_structure_type_structure_id_set structure_pool_;    // mapping: structure_type_id -> set of structure ids of that structure type
     per_species_particle_id_set         particle_pool_;     // mapping: species_id -> set of particle ids of that species
     per_structure_particle_id_set       particleonstruct_pool_;
-    per_structure_substructure_id_set   structure_substructures_map_;
 
     structure_id_type                   default_structure_id_;      // The default structure of the World (is a CuboidalRegion of the size of the world)
     structure_type_id_type              default_structure_type_id_; // The default structure_type of the World (every structure must have a StructureType)
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index dc489301..f728b5b8 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -295,6 +295,16 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_structures")();
     }
 
+    virtual bool update_structure(structure_id_pair const& structid_pair)
+    {
+        return py_wrapper_type::get_override("update_structure")(structid_pair);
+    }
+
+    virtual bool remove_structure(structure_id_type const& id)
+    {
+        return py_wrapper_type::get_override("remove_structure")(id);
+    }
+
     virtual structure_id_set get_structure_ids(structure_type_id_type const& sid) const
     {
         return py_wrapper_type::get_override("get_structure_ids")(sid);
@@ -309,6 +319,14 @@ class ParticleContainerWrapper
     {
         return py_wrapper_type::get_override("get_closest_surface")(pos, ignore);
     }
+    virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
+                                                                      structure_id_type const& ignore) const
+    {
+        return py_wrapper_type::get_override("get_close_structures")(
+                pos, current_struct_id, boost::python::make_tuple(ignore))
+               .template unchecked<structure_id_pair_and_distance_list*>();
+    }
+
     // end structure stuff
 
     // Begin StructureType stuff
@@ -384,7 +402,7 @@ class ParticleContainerWrapper
     virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
     {
         return py_wrapper_type::get_override("check_surface_overlap")(
-                s, old_pos, boost::python::make_tuple(current))
+                s, old_pos, current)
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
 
diff --git a/binding/World.hpp b/binding/World.hpp
index 7dba5170..f8bdc995 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -236,7 +236,7 @@ struct structures_range_converter: public boost::python::default_call_policies
     // Register the converter.
     static void __register()
     {
-        wrapper_type::__class_init__("SurfacesRange", boost::python::scope().ptr());
+        wrapper_type::__class_init__("StructuresRange", boost::python::scope().ptr());
     }
 };
 

From e3ba44644a4e975494548e0c156a703aedfdbc50 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Apr 2012 14:43:08 +0200
Subject: [PATCH 0798/1541] Pythonified get_close_structures and
 check_surface_overlap (including converter)

---
 binding/ParticleContainer.hpp | 115 +++++++++++++++++++++++++++++++++-
 1 file changed, 113 insertions(+), 2 deletions(-)

diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index f728b5b8..9ca2a6e0 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -71,7 +71,6 @@ struct particle_id_pair_generator_converter
     }
 };
 
-// Not sure if this should be defined here or in binding/World.hpp
 template<typename Timpl_>
 struct structure_id_pair_generator_converter
 {
@@ -219,6 +218,112 @@ struct particle_id_pair_and_distance_list_converter
     }
 };
 
+template<typename Timpl_>
+struct structure_id_pair_and_distance_list_converter
+{
+    typedef Timpl_ native_type;
+
+    struct to_python_converter
+    {
+        template<typename T_>
+        struct policy
+        {
+            typedef typename boost::range_size<T_>::type size_type;
+            typedef typename boost::range_value<T_>::type value_type;
+            typedef value_type const& reference;
+            typedef value_type const& const_reference;
+            typedef typename boost::range_const_iterator<T_>::type iterator;
+            typedef typename boost::range_const_iterator<T_>::type const_iterator;
+
+            static size_type size(T_ const& c)
+            {
+                return ::size(c);
+            }
+
+            static void set(T_& c, size_type i, const_reference v)
+            {
+                c.set(i, v);
+            }
+
+            static reference get(T_ const& c, size_type i)
+            {
+                return c.at(i);
+            }
+
+            static iterator begin(T_ const& c)
+            {
+                return boost::begin(c);
+            }
+
+            static iterator end(T_ const& c)
+            {
+                return boost::end(c);
+            }
+        };
+
+        typedef peer::wrappers::stl_container_wrapper<native_type, std::auto_ptr<native_type>, peer::wrappers::default_policy_generator<policy> > wrapper_type;
+        static PyObject* convert(native_type* v)
+        {
+            return reinterpret_cast<PyObject*>(wrapper_type::create(std::auto_ptr<native_type>(v ? v: new native_type())));
+        }
+    };
+
+    struct to_native_converter
+    {
+        static PyTypeObject const* expected_pytype()
+        {
+            return &PyBaseObject_Type;
+        }
+
+        static void* convert(PyObject* pyo)
+        {
+            if (pyo == Py_None)
+            {
+                return 0;
+            }
+
+            Py_ssize_t hint(-1);
+            hint = PyObject_Size(pyo);
+            if (hint < 0)
+            {
+                PyErr_Clear();
+            }
+
+            boost::python::handle<> iter(PyObject_GetIter(pyo));
+            if (!iter)
+            {
+                boost::python::throw_error_already_set();
+            }
+
+            if (hint < 0)
+            {
+                hint = compat_PyObject_LengthHint(iter.get());
+                if (hint < 0)
+                {
+                    hint = 0;
+                }
+            }
+
+            native_type* obj(new native_type);
+            obj->reserve(hint);
+            while (PyObject* item = PyIter_Next(iter.get()))
+            {
+                obj->push_back(boost::python::extract<typename native_type::value_type>(item)());
+            }
+
+            return obj;
+        }
+    };
+
+    // Also need to register the converter.
+    static void __register()
+    {
+        to_python_converter::wrapper_type::__class_init__("StructureIDAndDistanceVector", boost::python::scope().ptr());
+        boost::python::to_python_converter<native_type*, to_python_converter>();
+        peer::util::to_native_lvalue_converter<native_type, to_native_converter>();
+    }
+};
+
 
 // ParticleContainer wrapper class
 template<typename Tbase_>
@@ -457,12 +562,14 @@ inline boost::python::objects::class_base register_particle_container_class(
     // registering converters from standard boost templates.
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair>();
     peer::converters::register_tuple_converter<typename impl_type::structure_id_pair>();
-    peer::converters::register_tuple_converter<typename impl_type::structure_id_and_distance_pair>();
+    peer::converters::register_tuple_converter<typename impl_type::structure_id_and_distance_pair>();   // TODO remove later.
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair_and_distance>();
+    peer::converters::register_tuple_converter<typename impl_type::structure_id_pair_and_distance>();
 
     // register the converters that are defined above (not sure what this does)
     particle_id_pair_and_distance_list_converter<typename impl_type::particle_id_pair_and_distance_list>::__register();
     particle_id_pair_generator_converter<typename impl_type::particle_id_pair_generator>::__register();
+    structure_id_pair_and_distance_list_converter<typename impl_type::structure_id_pair_and_distance_list>::__register();
     structure_id_pair_generator_converter<typename impl_type::structure_id_pair_generator>::__register();
 
     // defining the python class
@@ -480,9 +587,12 @@ inline boost::python::objects::class_base register_particle_container_class(
         // Structure stuff
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
+        .def("update_structure", pure_virtual(&impl_type::update_structure))
+        .def("remove_structure", pure_virtual(&impl_type::remove_structure))
         .def("get_structure_ids", pure_virtual(&impl_type::get_structure_ids))
         .def("get_def_structure_id", pure_virtual(&impl_type::get_def_structure_id))
         .def("get_closest_surface", pure_virtual(&impl_type::get_closest_surface))
+        .def("get_close_structures", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::position_type const& pos, typename impl_type::structure_id_type const&, typename impl_type::structure_id_type const&) const)&impl_type::get_close_structures), return_value_policy<return_by_value>())
         // Particle stuff
         .def("new_particle", pure_virtual(&impl_type::new_particle))
         .def("update_particle", pure_virtual(&impl_type::update_particle))
@@ -491,6 +601,7 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
+        .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
         .def("create_transaction", pure_virtual(&impl_type::create_transaction),
                 return_value_policy<manage_new_object>())
         .def("distance", pure_virtual(&impl_type::distance))

From 4835709400f6a69aee0d36e88acfa123fc8a7ae2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Apr 2012 14:44:30 +0200
Subject: [PATCH 0799/1541] implemented == and != operator for StructureType
 (needed for structure_type_range converter)

---
 StructureType.cpp | 14 ++++++++++++++
 StructureType.hpp |  5 +++++
 2 files changed, 19 insertions(+)

diff --git a/StructureType.cpp b/StructureType.cpp
index 284fdef9..63ff6f98 100644
--- a/StructureType.cpp
+++ b/StructureType.cpp
@@ -22,6 +22,20 @@ StructureType::structure_type_id_type const& StructureType::structure_type_id()
     return structure_type_id_;
 }
 
+// Check equality/inequality
+bool StructureType::operator==(StructureType const& rhs) const
+{
+    return id_ == rhs.id() &&
+           structure_type_id_ == rhs.structure_type_id() &&
+           model_ == rhs.model();
+}
+
+bool StructureType::operator!=(StructureType const& rhs) const
+{
+    return !operator==(rhs);
+}
+
+
 std::string const& StructureType::operator[](std::string const& name) const
 {
     string_map_type::const_iterator i(attrs_.find(name));
diff --git a/StructureType.hpp b/StructureType.hpp
index 28a245e5..e9d38c2f 100644
--- a/StructureType.hpp
+++ b/StructureType.hpp
@@ -38,6 +38,11 @@ class StructureType
     // Get the id of the structure type the structure_type lives on/in
     structure_type_id_type const& structure_type_id() const;
 
+    // Check equality/inequality
+    bool operator==(StructureType const& rhs) const;
+
+    bool operator!=(StructureType const& rhs) const;
+
     std::string const& operator[](std::string const& name) const;
 
     std::string& operator[](std::string const& name);

From 0fc50e6ab6c01e025e62a7c51500a5b84a9eef55 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Apr 2012 14:45:18 +0200
Subject: [PATCH 0800/1541] fixed binding of structure_type_range and
 'structure_types' property of world.

---
 binding/World.hpp | 126 +++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 118 insertions(+), 8 deletions(-)

diff --git a/binding/World.hpp b/binding/World.hpp
index f8bdc995..dde75ab9 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -128,6 +128,118 @@ struct species_range_converter: public boost::python::default_call_policies
     }
 };
 
+// Structure_types_range converter
+template<typename Timpl_>
+struct structure_types_range_converter: public boost::python::default_call_policies
+{
+    typedef Timpl_ native_type;
+
+    template<typename T_>
+    struct policy
+    {
+        typedef typename boost::range_size<T_>::type size_type;
+        typedef typename boost::range_value<T_>::type value_type;
+        typedef value_type const& reference;
+        typedef value_type const& const_reference;
+        typedef typename boost::range_const_iterator<T_>::type iterator;
+        typedef typename boost::range_const_iterator<T_>::type const_iterator;
+
+        static size_type size(T_ const& c)
+        {
+            return ::size(c);
+        }
+
+        static void set(T_& c, size_type i, const_reference v)
+        {
+            PyErr_SetString(PyExc_TypeError, "object does not support indexing");
+            boost::python::throw_error_already_set();
+        }
+
+        static reference get(T_ const& c, size_type i)
+        {
+            PyErr_SetString(PyExc_TypeError, "object does not support indexing");
+            boost::python::throw_error_already_set();
+            throw 0;
+        }
+
+        static iterator begin(T_ const& c)
+        {
+            return boost::begin(c);
+        }
+
+        static iterator end(T_ const& c)
+        {
+            return boost::end(c);
+        }
+    };
+
+    struct instance_holder
+    {
+        instance_holder(native_type const& instance,
+                        boost::python::handle<> owner)
+            : instance_(instance), owner_(owner) {}
+
+        native_type const& operator*() const
+        {
+            return instance_;
+        }
+
+        native_type const* operator->() const
+        {
+            return &(**this);
+        }
+
+        native_type& operator*()
+        {
+            PyErr_SetString(PyExc_RuntimeError, "object is immutable");
+            boost::python::throw_error_already_set();
+            return *static_cast<native_type*>(0);
+        }
+
+        native_type* operator->()
+        {
+            return &(**this);
+        }
+
+        native_type instance_;
+        boost::python::handle<> owner_;
+    };
+
+    typedef peer::wrappers::stl_container_wrapper<native_type, instance_holder, peer::wrappers::default_policy_generator<policy> > wrapper_type;
+
+    struct result_converter
+    {
+        template<typename T_>
+        struct apply
+        {
+            struct type {
+                PyObject* operator()(native_type const& val) const
+                {
+                    return wrapper_type::create(instance_holder(val, boost::python::handle<>()));
+                }
+
+                PyTypeObject const* get_pytype() const
+                {
+                    return &wrapper_type::__class__;
+                }
+            };
+        };
+    };
+
+    template<typename Targs>
+    static PyObject* postcall(Targs const& arg, PyObject* result)
+    {
+        reinterpret_cast<wrapper_type*>(result)->ptr().owner_ = boost::python::handle<>(boost::python::borrowed(PyTuple_GET_ITEM(arg, 0)));
+        return result;
+    }
+
+    // Register the converter.
+    static void __register()
+    {
+        wrapper_type::__class_init__("StructureTypesRange", boost::python::scope().ptr());
+    }
+};
+
 // Structures_range converter
 template<typename Timpl_>
 struct structures_range_converter: public boost::python::default_call_policies
@@ -257,12 +369,12 @@ inline boost::python::objects::class_base register_world_class(char const* name)
     typedef Timpl_ impl_type;       // The class World that is being wrapped.
 
     typedef species_range_converter<typename impl_type::species_range> species_range_converter_type;
-//    typedef structure_types_range_converter<typename impl_type::structure_types_range> structure_types_range_converter_type;
+    typedef structure_types_range_converter<typename impl_type::structure_types_range> structure_types_range_converter_type;
     typedef structures_range_converter<typename impl_type::structures_range> structures_range_converter_type;
 
     // registering the converters defined above
     species_range_converter_type::__register();
-//    structure_types_range_converter_type::__register();
+    structure_types_range_converter_type::__register();
     structures_range_converter_type::__register();
 
     // registering converters from standard boost templates
@@ -286,18 +398,16 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .add_property("structures",
             make_function(
                 (typename impl_type::structures_range(impl_type::*)() const)&impl_type::get_structures, structures_range_converter_type()))
-//        .add_property("structure_types",
-//            make_function(
-//                (typename impl_type::structure_types_range(impl_type::*)() const)&impl_type::get_structure_types,
-//                 structure_types_range_converter_type()))
+        .add_property("structure_types",
+            make_function(
+                (typename impl_type::structure_types_range(impl_type::*)() const)&impl_type::get_structure_types,
+                 structure_types_range_converter_type()))
         .add_property("particle_ids", &World_get_particle_ids<impl_type>)
         .def("get_particle_ids", &impl_type::get_particle_ids)
         .def("get_particle_ids_on_struct", &impl_type::get_particle_ids_on_struct)
         .def("add_species", &impl_type::add_species)
         // Structure stuff
         .def("add_structure", &impl_type::add_structure)
-        .def("update_structure", &impl_type::update_structure)      // Not sure if this should be here or in ParticleContainer.hpp
-//        .def("remove_structure", &impl_type::remove_structure)
         .def("set_def_structure", &impl_type::set_def_structure)
         // StructureType stuff
         .def("add_structure_type", &impl_type::add_structure_type)

From 30e6bd0fc2c522f5a93d09a90122b9d630bc7626 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Apr 2012 15:31:07 +0200
Subject: [PATCH 0801/1541] Corresponding changes to single.py

... to adapt the new notation.
---
 single.py | 23 ++++++++++++-----------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/single.py b/single.py
index fa50c681..e429e225 100644
--- a/single.py
+++ b/single.py
@@ -591,8 +591,9 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         self.intrule = None
         self.interaction_ktot = self.calc_ktot(interactionrules)
 
-        self.surface = self.testShell.surface           # The surface with which the particle is
-                                                        # trying to interact
+        self.origin_structure = self.testShell.origin_structure
+        self.target_structure = self.testShell.target_structure 
+             # The surface with which the particle is trying to interact
 
     def get_interaction_rule(self):
         if self.intrule == None:
@@ -712,7 +713,7 @@ def draw_new_position(self, dt, event_type):
             x, y = random_vector2D(r)
             # express the r vector in the unit vectors of the surface to make sure the particle is
             # parallel to the surface (due to numerical problem)
-            vector_r = x * self.surface.shape.unit_x + y * self.surface.shape.unit_y
+            vector_r = x * self.target_structure.shape.unit_x + y * self.target_structure.shape.unit_y
 
             # calculate z vector
             z_surface = -self.get_inner_dz_left()       # left side of the inner domain
@@ -742,7 +743,7 @@ def draw_new_position(self, dt, event_type):
             newpos = self.shell.shape.position + vector_r + vector_z
 
         # The structure on which the particle ended is always the same as on which it began.
-        structure_id = self.structure.id
+        structure_id = self.origin_structure.id
 
         return newpos, structure_id
 
@@ -771,7 +772,7 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # r0 is the distance from the center of the cylinder to the center of the particle
         # z0 is known to be zero (the particle being in the center of the shell in the z direction)
         self.unit_r = self.testShell.reference_vector    
-        self.r0     = self.testShell.particle_surface_distance + self.surface.shape.radius
+        self.r0     = self.testShell.particle_surface_distance + self.target_structure.shape.radius
         self.z0     = 0.0
 
     def get_inner_dz_left(self):
@@ -781,7 +782,7 @@ def get_inner_dz_right(self):
         return self.shell.shape.half_length - self.pid_particle_pair[1].radius
 
     def get_inner_sigma(self):
-        return self.surface.shape.radius + self.pid_particle_pair[1].radius
+        return self.target_structure.shape.radius + self.pid_particle_pair[1].radius
 
     def greens_function(self):
         # The greens function not used for the interaction but for the other coordinate
@@ -845,7 +846,7 @@ def draw_new_position(self, dt, event_type):
             newpos = self.shell.shape.position + z_vector + r_vector
 
         # The structure on which the particle ended is always the same as on which it began.
-        structure_id = self.structure.id
+        structure_id = self.origin_structure.id
 
         return newpos, structure_id
 
@@ -940,7 +941,7 @@ def draw_new_position(self, dt, event_type):
             newpos = self.shell.shape.position + z_vector
 
         # The structure on which the particle ended is always the same as on which it began.
-        structure_id = self.structure.id
+        structure_id = self.origin_structure.id
 
         return newpos, structure_id
 
@@ -1004,9 +1005,9 @@ def draw_new_position(self, dt, event_type):
         oldpos = self.pid_particle_pair[1].position
 
         if self.D == 0:
-            newpos, new_structure_id = oldpos, self.structure.id
+            newpos, new_structure_id = oldpos, self.origin_structure.id
         elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
-            newpos, new_structure_id = oldpos, self.structure.id
+            newpos, new_structure_id = oldpos, self.origin_structure.id
         else:
             # Calculate r
             if event_type == EventType.SINGLE_ESCAPE:
@@ -1036,7 +1037,7 @@ def create_position_vector(self, r):
         # project the vector onto the surface unit vectors to make sure
         # that the coordinates are in the surface
         x, y = random_vector2D(r)
-        return x * self.structure.shape.unit_x + y * self.structure.shape.unit_y
+        return x * self.origin_structure.shape.unit_x + y * self.origin_structure.shape.unit_y
 
     def __str__(self):
         return 'PlanarSurfaceTransition' + Single.__str__(self)

From 2c39f69f591e3ded39a1b627059b973430328145 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Apr 2012 15:41:41 +0200
Subject: [PATCH 0802/1541] Notation cleanup in egfrd.py

---
 egfrd.py | 52 ++++++++++++++++++++++++++--------------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 82812a7b..5dcf67bc 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -74,21 +74,21 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
         return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
 
 ### Interactions
-def try_default_testinteraction(single, surface, geometrycontainer, domains):
+def try_default_testinteraction(single, target_structure, geometrycontainer, domains):
     if isinstance(single.structure, CuboidalRegion):
-        if isinstance(surface, PlanarSurface):
-            return PlanarSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
-        elif isinstance(surface, CylindricalSurface):
-            return CylindricalSurfaceInteractiontestShell(single, surface, geometrycontainer, domains)
+        if isinstance(target_structure, PlanarSurface):
+            return PlanarSurfaceInteractiontestShell(single, target_structure, geometrycontainer, domains)
+        elif isinstance(target_structure, CylindricalSurface):
+            return CylindricalSurfaceInteractiontestShell(single, target_structure, geometrycontainer, domains)
         else:
-            raise testShellError('(Interaction). Combination of (3D particle, surface) is not supported')
+            raise testShellError('(Interaction). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
-        raise testShellError('(Interaction). Combination of (2D particle, surface) is not supported')
+        raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
-        if isinstance(surface, CylindricalSurface):     # TODO differentiate between a sink and a cap
-            return CylindricalSurfaceSinktestShell (single, surface, geometrycontainer, domains)
+        if isinstance(target_structure, CylindricalSurface):     # TODO differentiate between a sink and a cap
+            return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
         else:
-            raise testShellError('(Interaction). Combination of (1D particle, surface) is not supported')
+            raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported')
     else:
         raise testShellError('(Interaction). structure of particle was of invalid type')
 
@@ -103,14 +103,14 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
 ### Transitions
 def try_default_testtransition(single, target_structure, geometrycontainer, domains):
     if isinstance(single.structure, CuboidalRegion):        
-            raise testShellError('(Transition). Combination of (3D particle, surface) is not supported')
+            raise testShellError('(Transition). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
         if isinstance(target_structure, PlanarSurface):
             return PlanarSurfaceTransitionSingletestShell(single, target_structure, geometrycontainer, domains)
         else:
-            raise testShellError('(Transition). Combination of (2D particle, surface other than plane) is not supported')
+            raise testShellError('(Transition). Combination of (2D particle, target_structure other than plane) is not supported')
     elif isinstance(single.structure, CylindricalSurface):        
-            raise testShellError('(Transition). Combination of (1D particle, surface) is not supported')
+            raise testShellError('(Transition). Combination of (1D particle, target_structure) is not supported')
     else:
         raise testShellError('(Transition). structure of particle was of invalid type')
 
@@ -504,8 +504,8 @@ def create_interaction(self, testShell):
         species_id = testShell.pid_particle_pair[1].sid
         reaction_rules = self.network_rules.query_reaction_rule(species_id)
         # get reaction rules for interaction
-        surfacetype_id = testShell.surface.sid
-        interaction_rules = self.network_rules.query_reaction_rule(species_id, surfacetype_id)
+        structure_type_id = testShell.target_structure.sid
+        interaction_rules = self.network_rules.query_reaction_rule(species_id, structure_type_id)
 
         # 2. Create and register the interaction domain.
         # The type of the interaction that will be created 
@@ -1229,18 +1229,18 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
             # 1. get product info
             product_species      = self.world.get_species(rr.products[0])
             product_radius       = product_species.radius
-            product_surface      = single.surface
+            product_structure    = single.target_structure
 
             # TODO make sure that the product species lives on the same type of the interaction surface
 #            product_structure_type = self.world.get_structure(product_species.structure_id)
-#            assert (single.surface.sid == self.world.get_structure(product_species.structure_id)), \
+#            assert (single.target_structure.sid == self.world.get_structure(product_species.structure_id)), \
 #                   'Product particle should live on the surface of interaction after the reaction.'
 
             # 1.5 get new position and structure_id of particle
-            transposed_pos       = self.world.cyclic_transpose(reactant_pos, product_surface.shape.position)
-            product_pos, _       = product_surface.projected_point(transposed_pos)
+            transposed_pos       = self.world.cyclic_transpose(reactant_pos, product_structure.shape.position)
+            product_pos, _       = product_structure.projected_point(transposed_pos)
             product_pos          = self.world.apply_boundary(product_pos)        # not sure this is still necessary
-            product_structure_id = product_surface.id
+            product_structure_id = product_structure.id
 
             # 2. burst the volume that will contain the products.
             #    Note that an interaction domain is already sized such that it includes the
@@ -2095,23 +2095,23 @@ def break_up_multi(self, multi, ignore):
         return zero_singles_fin, ignore
 
 
-    def try_interaction(self, single, surface):
-    # Try to form an interaction between the 'single' particle and the 'surface'. The interaction can be a:
+    def try_interaction(self, single, target_structure):
+    # Try to form an interaction between the 'single' particle and the 'target_structure'. The interaction can be a:
     # -CylindricalSurfaceInteraction
     # -PlanarSurfaceInteraction
 
         if __debug__:
-           log.debug('trying to form Interaction(%s, %s)' % (single.pid_particle_pair[1], surface))
+           log.debug('trying to form Interaction(%s, %s)' % (single.pid_particle_pair[1], target_structure))
 
 
         ### 1. Attempt to make a testShell. If it fails it will throw an exception.
         try:
-            testShell = try_default_testinteraction(single, surface, self.geometrycontainer, self.domains)
+            testShell = try_default_testinteraction(single, target_structure, self.geometrycontainer, self.domains)
         except testShellError as e:
             testShell = None
             if __debug__:
                 log.debug('%s not formed %s' % \
-                          ('Interaction(%s, %s)' % (single.pid_particle_pair[0], surface),
+                          ('Interaction(%s, %s)' % (single.pid_particle_pair[0], target_structure),
                           str(e) ))
 
 
@@ -2512,7 +2512,7 @@ def check_domain(self, domain):
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
             ignores = []
-            associated = [domain.structure.id, domain.surface.id]
+            associated = [domain.origin_structure.id, domain.target_structure.id]
         elif isinstance(domain, PlanarSurfaceTransitionSingle) or isinstance(domain, PlanarSurfaceTransitionPair):
             # Ignore surface of the particle and interaction surface
             ignores = []

From b862b279dbd773cec160dd23de1a6978e952a940 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Apr 2012 16:25:07 +0200
Subject: [PATCH 0803/1541] Debugging

---
 pair.py   | 18 +++++++++---------
 shells.py |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/pair.py b/pair.py
index d39b03a8..fcd8637d 100644
--- a/pair.py
+++ b/pair.py
@@ -621,8 +621,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # These components also are used to calculate the safety factor for
         # interparticle vector enlargement in case that the two particles
         # indeed are on two different planes.
-        _, pos1_orth = cls.structure2.projected_point(pos1)
-        _, pos2_orth = cls.structure2.projected_point(pos2)
+        _, pos1_orth = structure2.projected_point(pos1)
+        _, pos2_orth = structure2.projected_point(pos2)
 
         if( pos1_orth * pos2_orth < 0.0 ) :
             # The particles will end up on different planes, i.e.
@@ -646,21 +646,21 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # if not, they have to be deflected on structure2.
         # The structure.deflect() method requires a starting point and a displacement; we can construct
         # bogus parameters for these by subtracting the center position of structure1 from pos1 and pos2.
-        s1_ctr = self.structure1.shape.position
+        s1_ctr = structure1.shape.position
 
-        new_pos1, changeflag1 = cls.structure2.deflect(s1_ctr, pos1 - s1_ctr)
-        new_pos2, changeflag2 = cls.structure2.deflect(s1_ctr, pos2 - s1_ctr)
+        new_pos1, changeflag1 = structure2.deflect(s1_ctr, pos1 - s1_ctr)
+        new_pos2, changeflag2 = structure2.deflect(s1_ctr, pos2 - s1_ctr)
         
         # adjust the structure_ids of the particles
         if changeflag1 == 0 :
-            new_sid1 = cls.structure1.id
+            new_sid1 = structure1.id
         else :
-            new_sid1 = cls.structure2.id
+            new_sid1 = structure2.id
 
         if changeflag2 == 0 :
-            new_sid2 = cls.structure1.id
+            new_sid2 = structure1.id
         else :
-            new_sid2 = cls.structure2.id
+            new_sid2 = structure2.id
 
         # TODO: Check that the new positions are in their new planes and 
         # maybe also that pos1 and pos2 are in structure1 in the first place?
diff --git a/shells.py b/shells.py
index 54086b1c..5357ff33 100755
--- a/shells.py
+++ b/shells.py
@@ -372,9 +372,9 @@ def __init__(self, single1, single2):
         if __debug__: 
                 assert isinstance(single1.structure, PlanarSurface) 
                 assert isinstance(single2.structure, PlanarSurface) 
-        self.structure  = self.structure1           # some pair methods might need this to be defined TODO Remove and test
 
         testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
+        self.structure  = self.structure1         # some pair methods might need this to be defined TODO Remove and test
 
     def get_sigma(self):
         # Nothing changed as compared to the simple pair here

From c02ece5866a3d927bb73a6e5d081cd281e63623a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Apr 2012 18:49:06 +0200
Subject: [PATCH 0804/1541] using get_close_structures (based on visibility) in
 python code. Note that get_all_surfaces still has the 'old' behaviour
 (fallback).

---
 egfrd.py          |  8 +++---
 gfrdbase.py       | 69 ++++++++++++++++++++++++++---------------------
 shellcontainer.py | 45 -------------------------------
 shells.py         |  5 +++-
 4 files changed, 45 insertions(+), 82 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index edf2b960..4609c2a8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1442,9 +1442,7 @@ def make_new_domain(self, single):
         # 1.0 Get neighboring domains and surfaces
         neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
-#        surface_distances = []
-#        if isinstance(single, SphericalSingle):
-        surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
+        surface_distances = get_neighbor_surfaces(self.world, single_pos, single.structure.id, ignores=[])
 
         # 2.3 We prefer to make NonInteractionSingles for efficiency.
         #     But if objects (Shells and surfaces) get close enough (closer than
@@ -2533,14 +2531,14 @@ def check_domain(self, domain):
         for shell_id, shell in domain.shell_list:
 
             ### check that shells do not overlap with non associated surfaces
-            surfaces = get_surfaces(self.world, shell.shape.position, ignores + associated)
+            surfaces = get_all_surfaces(self.world, shell.shape.position, ignores + associated)
             for surface, _ in surfaces:
                 assert self.check_shape_overlap(shell.shape, surface.shape) >= 0.0, \
                     '%s (%s) overlaps with %s.' % \
                     (str(domain), str(shell), str(surface))
 
             ### check that shells DO overlap with associated surfaces.
-            surfaces = get_surfaces(self.world, shell.shape.position, ignores)
+            surfaces = get_all_surfaces(self.world, shell.shape.position, ignores)
             for surface, _ in surfaces:
                 if surface.id in associated:
                     assert self.check_shape_overlap(shell.shape, surface.shape) < 0.0, \
diff --git a/gfrdbase.py b/gfrdbase.py
index 0dd958c2..4769e995 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -28,8 +28,8 @@
     'create_world',
     'create_box',
     'ParticleSimulatorBase',
-    'get_surfaces',
-    'get_closest_surface',
+    'get_all_surfaces',
+    'get_neighbor_surfaces',
     'create_network_rules_wrapper',
     ]
 
@@ -81,13 +81,25 @@ def p_free(r, t, D):
     jacobian = 4.0 * numpy.pi * rsq
 
     return p * jacobian
+
+def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[]):
     
-def get_surfaces(world, pos, ignore=[]):
-    
+    if ignores:
+        ignore = ignores[0]
+    else:
+        ignore = world.get_def_structure_id()   # smt random
+
+    surface_distances = [(structure, distance) for ((id, structure), distance) in world.get_close_structures(pos, current_struct_id, ignore)]
+#    print surface_distances
+
+    return surface_distances
+
+def get_all_surfaces(world, pos, ignores=[]):
+
     surface_distances = []
 
     for surface in world.structures:
-        if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
+        if isinstance(surface, _gfrd.Surface) and surface.id not in ignores:
             pos_transposed = \
                 world.cyclic_transpose(pos, surface.shape.position)
             distance = world.distance(surface.shape, pos_transposed)
@@ -95,22 +107,6 @@ def get_surfaces(world, pos, ignore=[]):
 
     return surface_distances
 
-def get_closest_surface(world, pos, ignore=[]):
-    """Return
-      - closest surface
-      - distance to closest surface
-    
-    We can not use matrix_space, it would miss a surface if the 
-    origin of the surface would not be in the same or neighboring 
-    cells as pos."""
-
-    surface_distances = get_surfaces(world, pos, ignore)
-
-    if surface_distances:
-        return min(surface_distances, key=lambda surface_dist: surface_dist[1])
-    else:
-        return None, numpy.inf
-
 def create_world(m, matrix_size=10):
     """Create a world object.
     
@@ -247,7 +243,7 @@ def throw_in_particles(world, sid, n):
         log.info('\n\tthrowing in %s particles of type %s to %s' %
                  (n, name, structure_type.id))
 
-    # This is a bit messy, but it works.
+    # This is messy, but it works.
     i = 0
     while i < int(n):
         myrandom.shuffle(structure_list)
@@ -255,20 +251,26 @@ def throw_in_particles(world, sid, n):
         position = structure.random_position(myrandom.rng)
         position = world.apply_boundary(position)
 
+        surfaces = get_neighbor_surfaces(world, position, structure.id, [])
+        if surfaces:
+            surface, distance = surfaces[0]
+        else:
+            surface, distance = None, 0
+
         # Check overlap.
         if not world.check_overlap((position, species.radius)):
             create = True
             # Check if not too close to a neighbouring structures for 
             # particles added to the world, or added to a self-defined 
             # box.
-            if isinstance(structure, _gfrd.CuboidalRegion):
-                surface, distance = get_closest_surface(world, position, [])
-                if(surface and
-                   distance < surface.minimal_distance(species.radius)):
-                    if __debug__:
-                        log.info('\t%d-th particle rejected. Too close to '
-                                 'surface. I will keep trying.' % i)
-                    create = False
+            # FIXME replace by check_surface_overlap
+            if (isinstance(structure, _gfrd.CuboidalRegion) and \
+                surface and \
+                distance < surface.minimal_distance(species.radius)):
+                if __debug__:
+                    log.info('\t%d-th particle rejected. Too close to '
+                             'surface. I will keep trying.' % i)
+                create = False
             if create:
                 # All checks passed. Create particle.
                 p = world.new_particle(sid, structure.id, position)
@@ -300,7 +302,12 @@ def place_particle(world, sid, position):
     if world.check_overlap((position, radius)):
         raise NoSpace, 'Placing particle failed: overlaps with other particle.'
 
-    surface, distance = get_closest_surface(world, position, [])
+    surfaces = get_all_surfaces(world, position, [])
+    if surfaces:
+        surface, distance = surfaces[0]
+    else:
+        surface, distance = None, numpy.inf
+
     # Check if not too close to a neighbouring structures for particles 
     # added to the world, or added to a self-defined box.
     if species.structure_type_id == world.get_def_structure_type_id():
diff --git a/shellcontainer.py b/shellcontainer.py
index c3665958..a2a958d1 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -11,10 +11,6 @@
 from utils import *
 from single import NonInteractionSingle
 from multi import Multi
-from gfrdbase import (
-    get_surfaces,
-    get_closest_surface
-    )
 
 class ShellContainer(object):
 
@@ -106,33 +102,6 @@ def get_intruders(self, position, radius, ignore):
 
         return intruders, closest_domain, closest_distance
 
-    def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
-        # ignore: domain ids.
-        # TODO It's bad to pass the domains to this function, but is currently
-        # only way to be able to return a domain object (instead of domain_id)
-        closest_domain = None
-        closest_distance = numpy.inf
-
-        for container in self.containers:
-            result = container.get_neighbors(pos)
-
-            for shell_id_shell_pair, distance in result:
-                domain_id = shell_id_shell_pair[1].did
-
-                if ((domain_id not in ignore) and (distance < closest_distance)):
-                    domain = domains[domain_id]
-                    closest_domain, closest_distance = domain, distance
-                    # Found yet a closer domain. Break out of inner for 
-                    # loop and check other containers.
-#                    break
-
-        surface, distance = get_closest_surface(self.world, pos, ignores)
-
-        if distance < closest_distance:
-            return surface, distance
-        else:
-            return closest_domain, closest_distance
-
     def get_neighbor_domains(self, position, domains, ignore=[]):
     # returns the neighboring domains and the distance to their nearest shell (Multi's can have multiple)
 
@@ -171,20 +140,6 @@ def filter_partners(self, neighbor_domains):
     def sort_domain_distance(self, neighbor_domains):
         return sorted(neighbor_domains, key=lambda domain_dist: domain_dist[1])
 
-    def get_neighbor_surfaces(self, position, base_structure_id, ignores=[]):
-        # analogous to get_neighbor domains, this returns a list of (surface, distance) tuples
-        # The base_structure_id argument is the id of the structure on which the particle lives
-        # calling this function. In the future, this function will only return surfaces a particle
-        # living on the base_structure can have interactions with.
-
-        # We assume a particle can't have an interaction with the same surface on/in which it lives.
-        ignores.append( base_structure_id )
-
-        surface_distances = get_surfaces(self.world, position, ignores)
-
-        return surface_distances
-
-
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # Get neighbor domains within given radius.
         # Note that the function returns a generator
diff --git a/shells.py b/shells.py
index 20f57c15..5f33ef3c 100755
--- a/shells.py
+++ b/shells.py
@@ -14,6 +14,9 @@
     )
 
 from utils import *
+from gfrdbase import (
+    get_neighbor_surfaces,
+    )
 
 __all__ = [
     'ShellmakingError',
@@ -1018,7 +1021,7 @@ def get_neighbors(self, base_structure_id, ignore, ignores):
         radius = self.get_searchradius()
 
         neighbor_domains  = self.geometrycontainer.get_neighbor_domains(searchpoint, self.domains, ignore)
-        neighbor_surfaces = self.geometrycontainer.get_neighbor_surfaces(searchpoint, base_structure_id, ignores)
+        neighbor_surfaces = get_neighbor_surfaces(self.world, searchpoint, base_structure_id, ignores)
         return neighbor_domains, neighbor_surfaces
 
     def get_orientation_vector(self):

From b05acdb398c902769dbfe09bb4cdcc682425f2f7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 20 Apr 2012 18:49:06 +0200
Subject: [PATCH 0805/1541] using get_close_structures (based on visibility) in
 python code. Note that get_all_surfaces still has the 'old' behaviour
 (fallback).

---
 egfrd.py          |  8 +++---
 gfrdbase.py       | 68 ++++++++++++++++++++++++++---------------------
 shellcontainer.py | 45 -------------------------------
 shells.py         |  5 +++-
 4 files changed, 44 insertions(+), 82 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index edf2b960..4609c2a8 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1442,9 +1442,7 @@ def make_new_domain(self, single):
         # 1.0 Get neighboring domains and surfaces
         neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
         # Get also surfaces but only if the particle is in 3D
-#        surface_distances = []
-#        if isinstance(single, SphericalSingle):
-        surface_distances = self.geometrycontainer.get_neighbor_surfaces(single_pos, single.structure.id, ignores=[])
+        surface_distances = get_neighbor_surfaces(self.world, single_pos, single.structure.id, ignores=[])
 
         # 2.3 We prefer to make NonInteractionSingles for efficiency.
         #     But if objects (Shells and surfaces) get close enough (closer than
@@ -2533,14 +2531,14 @@ def check_domain(self, domain):
         for shell_id, shell in domain.shell_list:
 
             ### check that shells do not overlap with non associated surfaces
-            surfaces = get_surfaces(self.world, shell.shape.position, ignores + associated)
+            surfaces = get_all_surfaces(self.world, shell.shape.position, ignores + associated)
             for surface, _ in surfaces:
                 assert self.check_shape_overlap(shell.shape, surface.shape) >= 0.0, \
                     '%s (%s) overlaps with %s.' % \
                     (str(domain), str(shell), str(surface))
 
             ### check that shells DO overlap with associated surfaces.
-            surfaces = get_surfaces(self.world, shell.shape.position, ignores)
+            surfaces = get_all_surfaces(self.world, shell.shape.position, ignores)
             for surface, _ in surfaces:
                 if surface.id in associated:
                     assert self.check_shape_overlap(shell.shape, surface.shape) < 0.0, \
diff --git a/gfrdbase.py b/gfrdbase.py
index 0dd958c2..abbe45eb 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -28,8 +28,8 @@
     'create_world',
     'create_box',
     'ParticleSimulatorBase',
-    'get_surfaces',
-    'get_closest_surface',
+    'get_all_surfaces',
+    'get_neighbor_surfaces',
     'create_network_rules_wrapper',
     ]
 
@@ -81,13 +81,24 @@ def p_free(r, t, D):
     jacobian = 4.0 * numpy.pi * rsq
 
     return p * jacobian
+
+def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[]):
     
-def get_surfaces(world, pos, ignore=[]):
-    
+    if ignores:
+        ignore = ignores[0]
+    else:
+        ignore = world.get_def_structure_id()   # smt random
+
+    surface_distances = [(structure, distance) for ((id, structure), distance) in world.get_close_structures(pos, current_struct_id, ignore)]
+
+    return surface_distances
+
+def get_all_surfaces(world, pos, ignores=[]):
+
     surface_distances = []
 
     for surface in world.structures:
-        if isinstance(surface, _gfrd.Surface) and surface.id not in ignore:
+        if isinstance(surface, _gfrd.Surface) and surface.id not in ignores:
             pos_transposed = \
                 world.cyclic_transpose(pos, surface.shape.position)
             distance = world.distance(surface.shape, pos_transposed)
@@ -95,22 +106,6 @@ def get_surfaces(world, pos, ignore=[]):
 
     return surface_distances
 
-def get_closest_surface(world, pos, ignore=[]):
-    """Return
-      - closest surface
-      - distance to closest surface
-    
-    We can not use matrix_space, it would miss a surface if the 
-    origin of the surface would not be in the same or neighboring 
-    cells as pos."""
-
-    surface_distances = get_surfaces(world, pos, ignore)
-
-    if surface_distances:
-        return min(surface_distances, key=lambda surface_dist: surface_dist[1])
-    else:
-        return None, numpy.inf
-
 def create_world(m, matrix_size=10):
     """Create a world object.
     
@@ -247,7 +242,7 @@ def throw_in_particles(world, sid, n):
         log.info('\n\tthrowing in %s particles of type %s to %s' %
                  (n, name, structure_type.id))
 
-    # This is a bit messy, but it works.
+    # This is messy, but it works.
     i = 0
     while i < int(n):
         myrandom.shuffle(structure_list)
@@ -255,20 +250,26 @@ def throw_in_particles(world, sid, n):
         position = structure.random_position(myrandom.rng)
         position = world.apply_boundary(position)
 
+        surfaces = get_neighbor_surfaces(world, position, structure.id, [])
+        if surfaces:
+            surface, distance = surfaces[0]
+        else:
+            surface, distance = None, 0
+
         # Check overlap.
         if not world.check_overlap((position, species.radius)):
             create = True
             # Check if not too close to a neighbouring structures for 
             # particles added to the world, or added to a self-defined 
             # box.
-            if isinstance(structure, _gfrd.CuboidalRegion):
-                surface, distance = get_closest_surface(world, position, [])
-                if(surface and
-                   distance < surface.minimal_distance(species.radius)):
-                    if __debug__:
-                        log.info('\t%d-th particle rejected. Too close to '
-                                 'surface. I will keep trying.' % i)
-                    create = False
+            # FIXME replace by check_surface_overlap
+            if (isinstance(structure, _gfrd.CuboidalRegion) and \
+                surface and \
+                distance < surface.minimal_distance(species.radius)):
+                if __debug__:
+                    log.info('\t%d-th particle rejected. Too close to '
+                             'surface. I will keep trying.' % i)
+                create = False
             if create:
                 # All checks passed. Create particle.
                 p = world.new_particle(sid, structure.id, position)
@@ -300,7 +301,12 @@ def place_particle(world, sid, position):
     if world.check_overlap((position, radius)):
         raise NoSpace, 'Placing particle failed: overlaps with other particle.'
 
-    surface, distance = get_closest_surface(world, position, [])
+    surfaces = get_all_surfaces(world, position, [])
+    if surfaces:
+        surface, distance = surfaces[0]
+    else:
+        surface, distance = None, numpy.inf
+
     # Check if not too close to a neighbouring structures for particles 
     # added to the world, or added to a self-defined box.
     if species.structure_type_id == world.get_def_structure_type_id():
diff --git a/shellcontainer.py b/shellcontainer.py
index c3665958..a2a958d1 100644
--- a/shellcontainer.py
+++ b/shellcontainer.py
@@ -11,10 +11,6 @@
 from utils import *
 from single import NonInteractionSingle
 from multi import Multi
-from gfrdbase import (
-    get_surfaces,
-    get_closest_surface
-    )
 
 class ShellContainer(object):
 
@@ -106,33 +102,6 @@ def get_intruders(self, position, radius, ignore):
 
         return intruders, closest_domain, closest_distance
 
-    def get_closest_obj(self, pos, domains, ignore=[], ignores=[]):
-        # ignore: domain ids.
-        # TODO It's bad to pass the domains to this function, but is currently
-        # only way to be able to return a domain object (instead of domain_id)
-        closest_domain = None
-        closest_distance = numpy.inf
-
-        for container in self.containers:
-            result = container.get_neighbors(pos)
-
-            for shell_id_shell_pair, distance in result:
-                domain_id = shell_id_shell_pair[1].did
-
-                if ((domain_id not in ignore) and (distance < closest_distance)):
-                    domain = domains[domain_id]
-                    closest_domain, closest_distance = domain, distance
-                    # Found yet a closer domain. Break out of inner for 
-                    # loop and check other containers.
-#                    break
-
-        surface, distance = get_closest_surface(self.world, pos, ignores)
-
-        if distance < closest_distance:
-            return surface, distance
-        else:
-            return closest_domain, closest_distance
-
     def get_neighbor_domains(self, position, domains, ignore=[]):
     # returns the neighboring domains and the distance to their nearest shell (Multi's can have multiple)
 
@@ -171,20 +140,6 @@ def filter_partners(self, neighbor_domains):
     def sort_domain_distance(self, neighbor_domains):
         return sorted(neighbor_domains, key=lambda domain_dist: domain_dist[1])
 
-    def get_neighbor_surfaces(self, position, base_structure_id, ignores=[]):
-        # analogous to get_neighbor domains, this returns a list of (surface, distance) tuples
-        # The base_structure_id argument is the id of the structure on which the particle lives
-        # calling this function. In the future, this function will only return surfaces a particle
-        # living on the base_structure can have interactions with.
-
-        # We assume a particle can't have an interaction with the same surface on/in which it lives.
-        ignores.append( base_structure_id )
-
-        surface_distances = get_surfaces(self.world, position, ignores)
-
-        return surface_distances
-
-
     def get_neighbors_within_radius_no_sort(self, pos, radius, ignore=[]):
         # Get neighbor domains within given radius.
         # Note that the function returns a generator
diff --git a/shells.py b/shells.py
index 20f57c15..5f33ef3c 100755
--- a/shells.py
+++ b/shells.py
@@ -14,6 +14,9 @@
     )
 
 from utils import *
+from gfrdbase import (
+    get_neighbor_surfaces,
+    )
 
 __all__ = [
     'ShellmakingError',
@@ -1018,7 +1021,7 @@ def get_neighbors(self, base_structure_id, ignore, ignores):
         radius = self.get_searchradius()
 
         neighbor_domains  = self.geometrycontainer.get_neighbor_domains(searchpoint, self.domains, ignore)
-        neighbor_surfaces = self.geometrycontainer.get_neighbor_surfaces(searchpoint, base_structure_id, ignores)
+        neighbor_surfaces = get_neighbor_surfaces(self.world, searchpoint, base_structure_id, ignores)
         return neighbor_domains, neighbor_surfaces
 
     def get_orientation_vector(self):

From ed321dd80bb9ab5f6d6d484b906e0432dc98ee0a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 23 Apr 2012 16:36:40 +0200
Subject: [PATCH 0806/1541] Update usage of do_back_transform() in egfrd.py

---
 egfrd.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 5dcf67bc..a812c535 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -933,7 +933,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             product_structure_type_id = product_species.structure_type_id
 
             # 1.5 get new position and structure_id of particle
-            # If the particle falls of a surface (non CuboidalRegion)
+            # If the particle falls off a surface (non CuboidalRegion)
             if product_structure_type_id != reactant_structure_type_id:
                 assert (product_structure_type_id == self.world.get_def_structure_type_id())
 
@@ -1073,7 +1073,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
                         newposA, newposB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                            productA_radius, productB_radius,
-                                                                           reactant_structure, unit_z)
+                                                                           reactant_structure, reactant_structure,
+                                                                           unit_z)
+                        # the second reactant_structure parameter passed is ignored here
+
                         if default:
                             newpos1, newpos2 = newposA, newposB
                         else:
@@ -1089,7 +1092,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
                         newposA, newposB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                            productA_radius, productB_radius,
-                                                                           reactant_structure)
+                                                                           reactant_structure, reactant_structure)
+                        # the second reactant_structure parameter passed is ignored here
+                        # TODO: Why is there no unit_z passed here?
 
                         newposB = self.world.apply_boundary(newposB)
                         if __debug__:
@@ -1120,7 +1125,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     unit_z = reactant_structure.shape.unit_z    # not used
                     newpos1, newpos2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
                                                                     product1_radius, product2_radius,
-                                                                    reactant_structure, unit_z)
+                                                                    reactant_structure, reactant_structure,
+                                                                    unit_z)
+                    # here do_back_transform requires that the two structures passed are the same because
+                    # it will checks for this!
 
                     product_pos_list.append((newpos1, newpos2))
 

From c4be00a3770acab4a66481f6d2c87a78c7f62227 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 23 Apr 2012 18:11:53 +0200
Subject: [PATCH 0807/1541] updated/implemented check_surface_overlap and
 associated newBD_distance method newBD_distance returns a (corrected)
 distance for a particle to a surface which is used in the newBD scheme.

---
 CuboidalRegion.hpp            |  5 +++++
 CylindricalSurface.hpp        |  6 ++++++
 Multi.hpp                     |  5 +++--
 ParticleContainer.hpp         |  3 ++-
 ParticleContainerBase.hpp     | 26 ++++++++++++++++++++++----
 PlanarSurface.hpp             |  8 ++++++++
 SphericalSurface.hpp          |  6 ++++++
 Structure.hpp                 |  2 ++
 Transaction.hpp               |  5 +++--
 binding/ParticleContainer.hpp |  7 ++++---
 newBDPropagator.hpp           |  2 ++
 11 files changed, 63 insertions(+), 12 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 7ed9d443..71f112ad 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -132,6 +132,11 @@ class CuboidalRegion
     {
         return false; //Cube has no reaction volume.
     }
+    // This should replace above two methods.
+    virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
+    {
+        return base_type::distance(new_pos);
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 98d01e9e..e0cfc4c9 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -210,6 +210,12 @@ class CylindricalSurface
             return false;
     }
 
+    // This should replace above two methods.
+    virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
+    {
+        return base_type::distance(new_pos);
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         length_type cylinder_radius = base_type::shape().radius();
diff --git a/Multi.hpp b/Multi.hpp
index f3ec1d80..bc8e8720 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -232,9 +232,10 @@ class MultiParticleContainer
         return checker.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma) const
     {
-        return world_.check_surface_overlap(s, old_pos, current);
+        return world_.check_surface_overlap(s, old_pos, current, sigma);
     }
 
     virtual particle_id_pair_generator* get_particles() const
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 87cdb6e5..c12bcf48 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -102,7 +102,8 @@ class ParticleContainer
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const = 0;
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const = 0;
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma) const = 0;
 
     // Particle stuff
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 3bce8984..f2ad780d 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -241,11 +241,29 @@ class ParticleContainerBase
         return oc.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma) const
     {
-        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > oc;
-        // TODO
-        return oc.result();
+        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
+        const structure_id_set visible_structures (get_visible_structures(current));
+
+        structure_map temp_map;
+        for (typename structure_id_set::const_iterator i(visible_structures.begin()),
+                                                       e(visible_structures.end());
+             i != e; ++i)
+        {
+            temp_map[(*i)] = get_structure(*i);
+        }
+
+        for (typename structure_map::const_iterator i(temp_map.begin()),
+                                                    e(temp_map.end());
+             i != e; ++i)
+        {
+            const position_type cyc_pos(cyclic_transpose(s.position(), ((*i).second)->position())); //
+            const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), old_pos, sigma));
+            checker(i, dist);
+        }
+        return checker.result();
     }
 
     particle_id_pair get_particle(particle_id_type const& id, bool& found) const
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index aa33a623..d50860b7 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -200,6 +200,14 @@ class PlanarSurface
             return false;
     }
 
+    // This should replace above two methods.
+    virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
+    {
+        const length_type sign(1.0);
+        // TODO
+        return sign * base_type::distance(new_pos) + sigma;
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         // PlanarSurface has thickness of 0.
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 0d8734fa..2c9bc0b2 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -100,6 +100,12 @@ class SphericalSurface
         return false; //TODO
     }
 
+    // This should replace above two methods.
+    virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
+    {
+        return base_type::distance(new_pos);
+    }
+
     virtual length_type minimal_distance(length_type const& radius) const
     {
         return 0.; // TODO
diff --git a/Structure.hpp b/Structure.hpp
index 027b09ea..d0db4e59 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -99,6 +99,8 @@ class Structure
     // TODO rename bounced to smt else. It denotes whether a particle has crossed the 'surface' of the structure.
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, length_type const& dist_to_surface, length_type const& particle_radius) const = 0;
     virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const = 0;
+    // This should replace above two methods.
+    virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const = 0;
 
 
     // TODO this are just functions->move somewhere else
diff --git a/Transaction.hpp b/Transaction.hpp
index fba507fe..cac7c485 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -169,9 +169,10 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.check_overlap(s, ignore1, ignore2);
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma) const
     {
-        return pc_.check_surface_overlap(s, old_pos, current);
+        return pc_.check_surface_overlap(s, old_pos, current, sigma);
     }
 
     virtual Transaction<traits_type>* create_transaction()
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 9ca2a6e0..1514aee8 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -504,10 +504,11 @@ class ParticleContainerWrapper
                .template unchecked<particle_id_pair_and_distance_list*>();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current) const
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma) const
     {
         return py_wrapper_type::get_override("check_surface_overlap")(
-                s, old_pos, current)
+                s, old_pos, current, sigma)
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
 
@@ -601,7 +602,7 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
-        .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
+        .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&, typename impl_type::length_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
         .def("create_transaction", pure_virtual(&impl_type::create_transaction),
                 return_value_policy<manage_new_object>())
         .def("distance", pure_virtual(&impl_type::distance))
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 25547a8e..0429ad98 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -215,6 +215,8 @@ class newBDPropagator
                     tx_.check_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first) );
             overlapped.swap( overlapped_after_bounce );     // FIXME is there no better way?
                                             
+            // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
+            // and surfaces is False!
             particles_in_overlap = overlapped ? overlapped->size(): 0; 
             
             // re-get the reaction partners (structures), at old position. TODO don't just do this when in the bulk.

From 1c474de053a2687bf5e71d9875aa882a12116c99 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Apr 2012 12:35:39 +0200
Subject: [PATCH 0808/1541] egfrd.py: do_back_transform() returns structure ids

---
 egfrd.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a812c535..6f6603b4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1071,10 +1071,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
                         # determine the side of the membrane the dissociation takes place
                         unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-                        newposA, newposB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
-                                                                           productA_radius, productB_radius,
-                                                                           reactant_structure, reactant_structure,
-                                                                           unit_z)
+                        newposA, newposB, sidA, sidB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
+                                                                                       productA_radius, productB_radius,
+                                                                                       reactant_structure, reactant_structure,
+                                                                                       unit_z)
                         # the second reactant_structure parameter passed is ignored here
 
                         if default:
@@ -1090,9 +1090,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         iv = random_vector(particle_radius12 * MixedPair1D3D.calc_r_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
-                        newposA, newposB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
-                                                                           productA_radius, productB_radius,
-                                                                           reactant_structure, reactant_structure)
+                        newposA, newposB, sidA, sidB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
+                                                                                       productA_radius, productB_radius,
+                                                                                       reactant_structure, reactant_structure)
                         # the second reactant_structure parameter passed is ignored here
                         # TODO: Why is there no unit_z passed here?
 
@@ -1123,10 +1123,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     iv *= MINIMAL_SEPARATION_FACTOR
 
                     unit_z = reactant_structure.shape.unit_z    # not used
-                    newpos1, newpos2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
-                                                                    product1_radius, product2_radius,
-                                                                    reactant_structure, reactant_structure,
-                                                                    unit_z)
+                    newpos1, newpos2, sid1, sid2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
+                                                                                product1_radius, product2_radius,
+                                                                                reactant_structure, reactant_structure,
+                                                                                unit_z)
                     # here do_back_transform requires that the two structures passed are the same because
                     # it will checks for this!
 

From 4363f5b06ff7c9a4d52475b27857be6dd93729e1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 24 Apr 2012 15:02:00 +0200
Subject: [PATCH 0809/1541] Implemented 'overlap' criterium for PlanarSurface

---
 PlanarSurface.hpp | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index d50860b7..5618403e 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -203,9 +203,19 @@ class PlanarSurface
     // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
-        const length_type sign(1.0);
-        // TODO
-        return sign * base_type::distance(new_pos) + sigma;
+        const boost::array<length_type, 2> half_lengths(base_type::shape().half_extent());
+        const boost::array<length_type, 3> new_pos_xyz(::to_internal(base_type::shape(), new_pos));
+        const boost::array<length_type, 3> old_pos_xyz(::to_internal(base_type::shape(), old_pos));
+        if (new_pos_xyz[2] * old_pos_xyz[2] < 0 &&
+            ((abs(new_pos_xyz[0]) < half_lengths[0] && abs(new_pos_xyz[1]) < half_lengths[1]) ||
+             (abs(old_pos_xyz[0]) < half_lengths[0] && abs(old_pos_xyz[1]) < half_lengths[1])))
+        {
+            return -1.0 * base_type::distance(new_pos) + sigma;
+        }
+        else
+        {
+            return base_type::distance(new_pos) + sigma;
+        }
     }
 
     virtual length_type minimal_distance(length_type const& radius) const

From c7874249e782c3b42fbfce440c8cc3256bc97673 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Apr 2012 16:21:48 +0200
Subject: [PATCH 0810/1541] Correclty deflect 2D particles dissocitating into 2
 products

* fire_single_event() was altered accordingly.
* In case of 2 dissociation products living on a PlanarSurface
  it will now check whether one of them is out and deflect it
  into the closest neighboring plane.
---
 egfrd.py | 77 +++++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 65 insertions(+), 12 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6f6603b4..d8cef191 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1111,7 +1111,8 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
             # 1.5 Get new positions and structure_ids of particles
-            #     If the two particles stay on the same structure as the reactant.
+            #     If the two particles stay on the same structure type as the reactant
+            #     (but not necessarily on the same structure!)
             else:
                 # generate new positions in the structure
                 # TODO Make this into a generator
@@ -1127,14 +1128,69 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                                                                 product1_radius, product2_radius,
                                                                                 reactant_structure, reactant_structure,
                                                                                 unit_z)
-                    # here do_back_transform requires that the two structures passed are the same because
-                    # it will checks for this!
-
-                    product_pos_list.append((newpos1, newpos2))
-
-                # structure_ids are the same as reactant. TODO this is not necessarily true in the corners.
-                product1_structure_id = reactant_structure_id
-                product2_structure_id = reactant_structure_id
+                    # for the SimplePair do_back_transform() requires that the two structures passed are the same
+                    # because it will check for this!
+
+                    # If reactant_structure is a finite PlanarSurface the new position potentially can
+                    # lie outside of the plane. The two product particles then will end up on different
+                    # planes of the same structure_type.
+                    #
+                    # In this case we have to:
+                    #
+                    # (1) Check whether one of the new positions are out of plane reactant_structure
+                    #     (note that this can be the case for at most one of the particles).
+                    # (2) If yes, find the plane that they should be deflected to, which is
+                    #     the closest one with respect to the new position.
+                    # (3) Calculate the new postions again using the correct back transform function.
+                    if isinstance(reactant_structure, PlanarSurface):
+
+                        # Check whether one of the two positions is out of reactant_structure
+                        newpos1_in_rs = reactant_structure.to_internal(reactant_structure, newpos1)
+                        newpos2_in_rs = reactant_structure.to_internal(reactant_structure, newpos2)
+
+                        rs_hl = reactant_structure.shape.half_extent
+
+                        newpos1_is_out = 0
+                        newpos2_is_out = 0
+                        if(abs(newpos1_in_rs[0]) > rs_hl[0] || abs(newpos1_in_rs[1]) > rs_hl[1]):
+                            newpos1_is_out = 1
+                            out_pos = newpos1
+                            in_pos  = newpos2
+
+                        if(abs(newpos2_in_rs[0]) > rs_hl[0] || abs(newpos2_in_rs[1]) > rs_hl[1]):
+                            newpos2_is_out = 1
+                            out_pos = newpos2
+                            in_pos  = newpos1
+
+                        assert(newpos1_is_out * newpos2_is_out == 0)
+                            # at most one particle should be out if the CoM did not move out of the plane!
+
+                        if(newpos1_is_out or newpos2_is_out):
+
+                            # Get the closest plane
+                            neighbors = self.geometrycontainer.get_neighbor_surfaces(out_pos, reactant_structure.id, ignores=[])
+                            
+                            for structure, structure_distance in neighbors:
+                                if isinstance(structure, PlanarSurface):
+                                neighbor_planes.append((structure, structure_distance))
+
+                            neighbor_planes = sorted(neighbor_planes, key=lambda plane_and_dist: plane_and_dist[1])
+                            target_structure, _  = neighbor_planes[0]
+
+                            # Recalculate the back transform taking into account the deflection
+                            newpos1, newpos2, sid1, sid2 = PlanarSurfaceTransitionPair.do_back_transform(reactant_pos, iv,
+                                                                                                         D1, D2,
+                                                                                                         product1_radius, product2_radius,
+                                                                                                         reactant_structure, target_structure,
+                                                                                                         unit_z)
+                        # If none of the new pos. is out the call to SimplePair.do_back_transform() should have
+                        # produced the correct positions.
+
+                # End of special treatment for PlanarSurface particles
+                                        
+                product_pos_list.append((newpos1, newpos2))
+                product1_structure_id = sid1
+                product2_structure_id = sid2
 
 
             # 2. make space for the products. 
@@ -1512,9 +1568,6 @@ def make_new_domain(self, single):
             elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
-#                # if this fails try a Transition between two surfaces
-#                if not domain:
-#                    domain = self.try_transition (single, obj)
 
 
         if not domain:

From 2e432b39bac0cb9149e805caecbad1d60807d3f6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Apr 2012 17:50:33 +0200
Subject: [PATCH 0811/1541] Using world.distance instead of to_internal +
 debugging

* to_internal is not accessible from Python code, therefore
  the check for leaving the plane of origin is done via world.distance
  now
* removed some obvious bugs
* stuff seems to work now for a particle placed very close to an edge
---
 egfrd.py | 21 +++++++++++----------
 pair.py  |  4 ++--
 2 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d8cef191..0cb2b3bb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1144,20 +1144,17 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     # (3) Calculate the new postions again using the correct back transform function.
                     if isinstance(reactant_structure, PlanarSurface):
 
-                        # Check whether one of the two positions is out of reactant_structure
-                        newpos1_in_rs = reactant_structure.to_internal(reactant_structure, newpos1)
-                        newpos2_in_rs = reactant_structure.to_internal(reactant_structure, newpos2)
-
-                        rs_hl = reactant_structure.shape.half_extent
+                        dist1 = self.world.distance(reactant_structure.shape, newpos1)
+                        dist2 = self.world.distance(reactant_structure.shape, newpos2)
 
                         newpos1_is_out = 0
                         newpos2_is_out = 0
-                        if(abs(newpos1_in_rs[0]) > rs_hl[0] || abs(newpos1_in_rs[1]) > rs_hl[1]):
+                        if(dist1 > 0.0):
                             newpos1_is_out = 1
                             out_pos = newpos1
                             in_pos  = newpos2
 
-                        if(abs(newpos2_in_rs[0]) > rs_hl[0] || abs(newpos2_in_rs[1]) > rs_hl[1]):
+                        if(dist2 > 0.0):
                             newpos2_is_out = 1
                             out_pos = newpos2
                             in_pos  = newpos1
@@ -1168,12 +1165,14 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         if(newpos1_is_out or newpos2_is_out):
 
                             # Get the closest plane
+                            neighbors = []
                             neighbors = self.geometrycontainer.get_neighbor_surfaces(out_pos, reactant_structure.id, ignores=[])
-                            
+
+                            neighbor_planes = []
                             for structure, structure_distance in neighbors:
                                 if isinstance(structure, PlanarSurface):
-                                neighbor_planes.append((structure, structure_distance))
-
+                                    neighbor_planes.append((structure, structure_distance))
+                        
                             neighbor_planes = sorted(neighbor_planes, key=lambda plane_and_dist: plane_and_dist[1])
                             target_structure, _  = neighbor_planes[0]
 
@@ -1183,6 +1182,8 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                                                                                          product1_radius, product2_radius,
                                                                                                          reactant_structure, target_structure,
                                                                                                          unit_z)
+
+                        log.info('reactant_position = %s, iv = %s, rs_id = %s, sid1 = %s, sid2 = %s \n' % (reactant_pos, iv, reactant_structure.id, sid1, sid2 ) ) # TODO remove this DEBUG stuff
                         # If none of the new pos. is out the call to SimplePair.do_back_transform() should have
                         # produced the correct positions.
 
diff --git a/pair.py b/pair.py
index fcd8637d..67c220ca 100644
--- a/pair.py
+++ b/pair.py
@@ -220,12 +220,12 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
     # made
 
         # For simple pairs the particles live on the same structure
-        assert(self.structure1.id == self.structure2.id)
+        assert(structure1.id == structure2.id)
         D_tot = D1 + D2
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
 
-        return pos1, pos2, self.structure1.id, self.structure2.id
+        return pos1, pos2, structure1.id, structure2.id
 
     def get_shell_size(self):
         return self.shell.shape.radius

From d4eb8e4f5ba4b29d92a6880afcc3249260678faf Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 24 Apr 2012 19:20:15 +0200
Subject: [PATCH 0812/1541] small fix to check_surface_overlap

---
 ParticleContainerBase.hpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index f2ad780d..ac93caae 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -261,7 +261,10 @@ class ParticleContainerBase
         {
             const position_type cyc_pos(cyclic_transpose(s.position(), ((*i).second)->position())); //
             const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), old_pos, sigma));
-            checker(i, dist);
+            if (dist < s.radius())
+            {
+                checker(i, dist);
+            }
         }
         return checker.result();
     }

From fab09035c64ea864b771e36b47b1fde6f9e33fc0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 24 Apr 2012 19:20:48 +0200
Subject: [PATCH 0813/1541] implemented the use of check_surface_overlap in
 newBDPropagator instead of closest_surface construction.

---
 newBDPropagator.hpp | 116 +++++++++++++++++++++++++++++++++-----------
 1 file changed, 88 insertions(+), 28 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 0429ad98..d1b96557 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -172,11 +172,10 @@ class newBDPropagator
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
 	       We use it to check for overlaps with other particles. */
+        bool bounced( false );
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
                 tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
         int particles_in_overlap(overlapped ? overlapped->size(): 0);
-        bool bounced( false );
-
 
         //// 3.1 Check for core overlaps with particles
         /* Check if the particle at new_pos overlaps with any particle cores. */        
@@ -188,12 +187,13 @@ class newBDPropagator
         /* If the particle has not bounced with another particle and lives in the bulk: 
            check for core overlap with a surface. */
         // TODO always check for overlaps with surface ignoring its own surface (regardless of in bulk)
+/*
         if(!bounced && pp.second.structure_id() == tx_.get_def_structure_id())
         {
             // TODO Get all the structures within the reaction volume (and that may consequently also be in the core)
             struct_id_distance_pair = tx_.get_closest_surface( new_pos, new_structure_id);
 
-            /* Check for overlap with nearest surface. */
+            // Check for overlap with nearest surface.
             // TODO check all the surfaces while bounced != true.
             particle_surface_distance = struct_id_distance_pair.second;
             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
@@ -201,6 +201,17 @@ class newBDPropagator
                                                tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
                                                particle_surface_distance, r0);
         }
+*/
+        if (!bounced)
+        {
+            boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures(
+                tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0));
+            int structures_in_overlap(overlap_structures ? overlap_structures->size(): 0);
+
+            j = 0
+            while(!bounced && j < structures_in_overlap)
+                bounced = overlap_structures->at(j++).second < r0;
+        }
          
         //// 4. Finalize the position
         /* If particle is bounced, restore old position and check reaction_volume for reaction partners at old_pos. */
@@ -214,12 +225,19 @@ class newBDPropagator
             boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_after_bounce( 
                     tx_.check_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first) );
             overlapped.swap( overlapped_after_bounce );     // FIXME is there no better way?
-                                            
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
             particles_in_overlap = overlapped ? overlapped->size(): 0; 
             
-            // re-get the reaction partners (structures), at old position. TODO don't just do this when in the bulk.
+            // re-get the reaction partners (particles), now on old position.
+            boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_struct_after_bounce( 
+                    tx_.check_surface_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0) );
+            overlap_structures.swap( overlap_struct_after_bounce );     // FIXME is there no better way?
+            // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
+            // and surfaces is False!
+            structures_in_overlap = overlap_structures ? overlap_structures->size(): 0; 
+            
+/*            // re-get the reaction partners (structures), at old position. TODO don't just do this when in the bulk.
             if(pp.second.structure_id() == tx_.get_def_structure_id())
             {
                 // TODO get all near surfaces instead of just the closest.
@@ -227,6 +245,7 @@ class newBDPropagator
                 // TODO get the number of surfaces.
                 particle_surface_distance = struct_id_distance_pair.second;  
             }
+*/
         }
         
 
@@ -236,20 +255,24 @@ class newBDPropagator
         Real accumulated_prob = 0;
         Real const rnd( rng_() );
         
+        const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
         /* First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction. */
         // TODO also interaction should be allowed when a particle is on a cylinder.
         // TODO don't check only the closest but check all overlapping surfaces.
-        if( pp.second.structure_id() == tx_.get_def_structure_id())
+        j = 0;
+        while(j < structures_in_overlap)
         {
-            // TODO get all the surfaces that overlap with the reaction volume (depends on current structure)
-            boost::shared_ptr<structure_type> const closest_surf( tx_.get_structure( struct_id_distance_pair.first) );
-
-            // TODO check that the projected point of the position of the particle is in the surface. If not, than no
-            // reaction is possible.
-            if( closest_surf->in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
-            {        
-                accumulated_prob += k_total( pp.second.sid(), closest_surf->sid() ) * dt_ / 
-                                    closest_surf->surface_reaction_volume( r0, reaction_length_ );
+            const structure_id_pair_and_distance & closest_surf( overlap_structures->at(j) );
+//        if( pp.second.structure_id() == tx_.get_def_structure_id())
+//        {
+
+            if( (closest_surf.first.second->sid() != current_struct->sid()) &&
+                (closest_surf.second < r0 + reaction_length_) &&
+                (closest_surf.first.second->is_alongside(new_pos)))
+//                closest_surf.second->in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
+            {
+                accumulated_prob += k_total( pp.second.sid(), closest_surf.first.second->sid() ) * dt_ / 
+                                    closest_surf.first.second->surface_reaction_volume( r0, reaction_length_ );
         
                 if(accumulated_prob >= 1.)
                 {
@@ -262,7 +285,7 @@ class newBDPropagator
                     try
                     {
                         LOG_DEBUG(("fire surface interaction"));
-                        if(attempt_interaction(pp, closest_surf ))
+                        if(attempt_interaction(pp, closest_surf.first.second ))
                             return true;
                     }   
                     catch (propagation_error const& reason)
@@ -274,14 +297,17 @@ class newBDPropagator
                 else                
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
-                               boost::lexical_cast<std::string>(closest_surf->id()).c_str()));     // TODO is this the correct interpretation?
+                               boost::lexical_cast<std::string>(closest_surf.first.first).c_str()));     // TODO is this the correct interpretation?
                 }
             }
 
+            j++;
         }
         
         ////
         /* Now attempt a reaction with all particles inside the reaction volume. */
+        accumulated_prob = 0;
+        rnd = rng_();
         j = 0;
         while(j < particles_in_overlap)
         {
@@ -290,7 +316,7 @@ class newBDPropagator
             species_type s0(pp_species);
             species_type s1(tx_.get_species(closest.first.second.sid()));
                 
-            /* If the structures of the reactants do not equal, one of the reactants has to come from the bulk,
+            /* If the structures of the reactants are not equal, one of the reactants has to come from the bulk,
                and we let this be s1, the particle from the surface is named s0. */
             if(s0.structure_type_id() != s1.structure_type_id())
             {
@@ -448,6 +474,15 @@ class newBDPropagator
                             }
                         }
 
+                        // check overlap with surfaces
+                        // check for overlap with particles that are inside the propagator
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(tx_.check_surface_overlap(new_shape, old_pos, reactant_structure->id(),
+                                                                                                           product_species.radius()));
+                        if (overlap_surface && overlap_surface->size() > 0)
+                        {
+                            throw propagation_error("no space due to near surface");
+                        }
+/*
                         // check overlap with surfaces
                         if( product_species.structure_type_id() == tx_.get_def_structure_type_id() && pp.second.structure_id() == tx_.get_def_structure_id() )
                         {
@@ -459,7 +494,7 @@ class newBDPropagator
                                                          struct_id_distance_pair.second, product_species.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
-
+*/
                         // Process changes
                         tx_.remove_particle(pp.first);
                         // Make new particle on right surface
@@ -538,9 +573,14 @@ class newBDPropagator
                                 tx_.check_overlap( particle_shape_type(pos0pos1_pair.second, product1_species.radius()), pp.first));
                                     
                             /* Only when both products live in the bulk, check for possible overlap with a surface. */
-                            bool surface_bounce0( false );
-                            bool surface_bounce1( false );
-                            if( product0_species.structure_type_id() == tx_.get_def_structure_type_id() && product1_species.structure_type_id() == tx_.get_def_structure_type_id() )
+//                            bool surface_bounce0( false );
+//                            bool surface_bounce1( false );
+                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface0(
+                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.first, product0_species.radius()), reactant_pos, reactant_structure->id(), product0_species.radius()));
+                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface1(
+                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.second, product1_species.radius()), reactant_pos, reactant_structure->id(), product1_species.radius()));
+
+/*                            if( product0_species.structure_type_id() == tx_.get_def_structure_type_id() && product1_species.structure_type_id() == tx_.get_def_structure_type_id() )
                             {
                                 structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pos0pos1_pair.first, tx_.get_def_structure_id() ) );
                                 boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
@@ -555,12 +595,14 @@ class newBDPropagator
                                 surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
                                                                            tx_.cyclic_transpose( pos0pos1_pair.second, closest_struct->position() ), 
                                                                            struct_id_distance_pair.second, product1_species.radius() );
+*/
                             }
                             
                             // If the positions were allowed -> SUCCESS and leave the loop
                             if ( !(overlapped_product0 && overlapped_product0->size() > 0) && 
                                  !(overlapped_product1 && overlapped_product1->size() > 0) &&
-                                 !surface_bounce0 && !surface_bounce1 )
+                                 !(overlap_surface0 && overlap_surface0->size() > 0) &&
+                                 !(overlap_surface1 && overlap_surface1->size() > 0)) 
                                 break;
                         }
 
@@ -703,7 +745,14 @@ class newBDPropagator
                         }
                         
                         // Check overlap with surfaces
-                        if( product_species.structure_type_id() == tx_.get_def_structure_type_id() )
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(
+                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, new_structure_id, product_species.radius()));
+                        if (overlap_surface && overlap_surface->size() > 0)
+                        {
+                            throw propagation_error("no space due to near surface");
+                        }
+
+/*                        if( product_species.structure_type_id() == tx_.get_def_structure_type_id() )
                         {
                             const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_def_structure_id() ) );
                             const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
@@ -713,7 +762,7 @@ class newBDPropagator
                                                          struct_id_distance_pair.second, product_species.radius() ) )
                                 throw propagation_error("no space due to near surface");
                         }
-
+*/
 
                         // Process changes
                         tx_.remove_particle(pp0.first);
@@ -802,7 +851,13 @@ class newBDPropagator
                                 throw propagation_error("no space (vc)");
                             }
                         }
-                        // TODO check overlap with surfaces.
+                        // check overlap with surfaces.
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(
+                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, surface->id(), product_species.radius()));
+                        if (overlap_surface && overlap_surface->size() > 0)
+                        {
+                            throw propagation_error("no space due to near surface");
+                        }
 
                         // Process changes
                         tx_.remove_particle(pp.first);
@@ -857,10 +912,10 @@ class newBDPropagator
                                         ignore));
                                                                 
             // See if it overlaps with any particles
-            if ( (overlapped && overlapped->size() > 0) )
+            if (overlapped && overlapped->size() > 0)
                 return old_pos;
             // See if it overlaps with any surfaces.
-            if(species.structure_type_id() == tx_.get_def_structure_type_id())
+/*            if(species.structure_type_id() == tx_.get_def_structure_type_id())
             {
                 const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_particle(ignore).second.structure_id() ) );
                 const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
@@ -870,6 +925,11 @@ class newBDPropagator
                                              struct_id_distance_pair.second, species.radius() ) )    
                     return old_pos;        
             }
+*/
+            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(
+                    tx_.check_surface_overlap(particle_shape_type(new_pos, species.radius()), old_pos, new_structure_id, species.radius()));
+            if (overlap_surface && overlap_surface->size() > 0)
+                return old_pos;
         }    
         return new_pos;
     }

From c4b27a8c543d51767bc377fcabcb926573d293d0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Apr 2012 11:45:11 +0200
Subject: [PATCH 0814/1541] commented out legacy code

---
 CuboidalRegion.hpp     | 4 +++-
 CylindricalSurface.hpp | 6 +++---
 PlanarSurface.hpp      | 7 ++++---
 SphericalSurface.hpp   | 2 ++
 Structure.hpp          | 2 ++
 5 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 71f112ad..83b9bc78 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -121,7 +121,8 @@ class CuboidalRegion
         return position_pair_type(); //No special geminate dissociation 'from' the bulk
     }
     
-    /* Determine if particle has bounced from the surface */
+/*
+    // Determine if particle has bounced from the surface 
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
         length_type const& dist_to_surface, length_type const& particle_radius) const
     {       
@@ -132,6 +133,7 @@ class CuboidalRegion
     {
         return false; //Cube has no reaction volume.
     }
+*/
     // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index e0cfc4c9..b11d9feb 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -191,8 +191,8 @@ class CylindricalSurface
         
         return pp01;
     }
-
-    /* Determine if particle has crossed the 'surface' of the structure. */
+/*
+    // Determine if particle has crossed the 'surface' of the structure.
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
         length_type const& dist_to_surface, length_type const& particle_radius) const
     {       
@@ -209,7 +209,7 @@ class CylindricalSurface
         else
             return false;
     }
-
+*/
     // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 5618403e..2d931032 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -175,7 +175,8 @@ class PlanarSurface
         
     }
     
-    /* Determine if particle has moved through the surface */
+/*
+    // Determine if particle has moved through the surface 
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
         length_type const& dist_to_surface, length_type const& particle_radius) const
     {       
@@ -191,7 +192,7 @@ class PlanarSurface
             return false;
     }
     
-    /* Determine wether particle lies inside reaction volume. */
+    // Determine wether particle lies inside reaction volume. 
     virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
     {
         if( dist_to_surface <= rl )
@@ -199,7 +200,7 @@ class PlanarSurface
         else
             return false;
     }
-
+*/
     // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 2c9bc0b2..0ba6c632 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -89,6 +89,7 @@ class SphericalSurface
         return position_pair_type(); //TODO
     }
     
+/*
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
         length_type const& dist_to_surface, length_type const& particle_radius) const
     {  
@@ -99,6 +100,7 @@ class SphericalSurface
     {
         return false; //TODO
     }
+*/
 
     // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
diff --git a/Structure.hpp b/Structure.hpp
index d0db4e59..6263b699 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -96,9 +96,11 @@ class Structure
 
     // Methods used in the 'new' BDPropagator
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
+/*
     // TODO rename bounced to smt else. It denotes whether a particle has crossed the 'surface' of the structure.
     virtual bool bounced(position_type const& old_pos, position_type const& new_pos, length_type const& dist_to_surface, length_type const& particle_radius) const = 0;
     virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const = 0;
+*/
     // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const = 0;
 

From cbac8a04296b3f205d34863dfe2c49065cd17488 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Apr 2012 11:47:47 +0200
Subject: [PATCH 0815/1541] Remove a debugging info

---
 egfrd.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 0cb2b3bb..348365b6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1183,7 +1183,6 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                                                                                          reactant_structure, target_structure,
                                                                                                          unit_z)
 
-                        log.info('reactant_position = %s, iv = %s, rs_id = %s, sid1 = %s, sid2 = %s \n' % (reactant_pos, iv, reactant_structure.id, sid1, sid2 ) ) # TODO remove this DEBUG stuff
                         # If none of the new pos. is out the call to SimplePair.do_back_transform() should have
                         # produced the correct positions.
 

From 698e4bc1366d083276836afc6bea5594af86c8b1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Apr 2012 12:20:12 +0200
Subject: [PATCH 0816/1541] implemented 'is_alongside' for all the shapes

---
 Box.hpp      |  9 +++++++++
 Cylinder.hpp | 14 ++++++++++++++
 Plane.hpp    | 13 +++++++++++++
 Sphere.hpp   | 18 ++++++++++++++++++
 4 files changed, 54 insertions(+)

diff --git a/Box.hpp b/Box.hpp
index 39b5af8a..0295d3b9 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -190,6 +190,15 @@ class Box
     boost::array<length_type, 3> half_extent_;
 };
 
+template<typename T_>
+inline bool
+is_alongside(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
+// The function checks if the projection of the position 'pos' is 'inside' the object.
+{
+    // Todo. If we ever need it.
+    return true;
+}
+
 template<typename T_>
 inline boost::array<typename Box<T_>::length_type, 3>
 to_internal(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index e521546d..9fa03aef 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -102,6 +102,20 @@ inline std::basic_ostream<Tstrm_>& operator<<(std::basic_ostream<Tstrm_>& strm,
     return strm;
 }
 
+template<typename T_>
+inline bool
+is_alongside(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const& pos)
+// The function checks if the projection of the position 'pos' is 'inside' the object.
+{
+    typedef typename Cylinder<T_>::position_type    position_type;
+    typedef typename Cylinder<T_>::length_type      length_type;
+
+    const position_type pos_vector(subtract(pos, obj.position()));
+
+    return (abs(dot_product(pos_vector, obj.unit_z())) <= obj.half_length());
+}
+
+
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::length_type,
                  typename Cylinder<T_>::length_type>
diff --git a/Plane.hpp b/Plane.hpp
index 28211710..32c19a00 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -266,6 +266,19 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    // for now this returns the new position without changes
    return std::make_pair( new_pos, changeflag );
 }
+template<typename T_>
+inline bool
+is_alongside(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// The function checks if the projection of the position 'pos' is 'inside' the object.
+{
+    typedef typename Plane<T_>::position_type position_type;
+
+    boost::array<typename Plane<T_>::length_type, 2> half_extends(obj.half_extend());
+    position_type pos_vector(subtract(pos, obj.position()));
+
+    return ((abs(dot_product(pos_vector, obj.unit_x())) < half_extends[0]) &&
+            (abs(dot_product(pos_vector, obj.unit_y())) < half_extends[1]));
+}
 
 template<typename T_>
 inline boost::array<typename Plane<T_>::length_type, 3>
diff --git a/Sphere.hpp b/Sphere.hpp
index e50bb96d..133822f7 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -71,6 +71,24 @@ inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm
     return strm;
 }
 
+template<typename T_>
+inline bool
+is_alongside(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
+// The function checks if the projection of the position 'pos' is 'inside' the object.
+// This is always true because the projection is always onto the center of the sphere.
+{
+    return true;
+}
+
+template<typename T_>
+inline typename Sphere<T_>::length_type
+to_internal(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
+// The function calculates the coefficients to express 'pos' into the base of the sphere 'obj'
+{
+    // Todo. If we ever need it.
+    return typename Sphere<T_>::length_type();
+}
+
 template<typename T_>
 inline std::pair<typename Sphere<T_>::position_type,
                  typename Sphere<T_>::length_type>

From 7a9e4d1204da04a1e25b29cc08b226d48b6d59cb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Apr 2012 19:28:54 +0200
Subject: [PATCH 0817/1541] Basic implementation of disk object + binding

The disk is basically a cylinder without z-extension and
altered projected_point() method.
---
 Box.hpp      | 2 +-
 Cylinder.hpp | 4 ++--
 Surface.hpp  | 1 +
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 080c3273..93ff13ac 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -285,7 +285,7 @@ deflect(Box<T_> const& obj,
 {
     // Displacements are not deflected on cuboidal regions,
     // but this function has to be defined for every shape to be used in structure.
-    // For now it just returns the new position. The changeflag = 0.
+    // For now it just returns original pos. + displacement. The changeflage = false.
     return std::make_pair( add(r0, d), false );
 }
 
diff --git a/Cylinder.hpp b/Cylinder.hpp
index d6d21e2b..08b53b65 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -135,7 +135,7 @@ projected_point(Cylinder<T_> const& obj,
         r_z.first);
 }
 
-//Allmost equal to projected point method, but for the substraction of the cylinder radius from the radial distance r.
+//Almost equal to projected point method, but for the substraction of the cylinder radius from the radial distance r.
 //And projected point now lies on the surface, not on the central axis.
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::position_type,
@@ -208,7 +208,7 @@ deflect(Cylinder<T_> const& obj,
 {
     // Displacements are not deflected on cylinders (yet),
     // but this function has to be defined for every shape to be used in structure.
-    // For now it just returns the new position. The changeflage = false.
+    // For now it just returns original pos. + displacement. The changeflage = false.
     return std::make_pair( add(r0, d), false );
 }
 
diff --git a/Surface.hpp b/Surface.hpp
index 2cf83db5..08e1a02a 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -12,6 +12,7 @@
 
 #include <sstream>
 #include "ParticleSimulationStructure.hpp"
+#include "Disk.hpp"
 #include "Cylinder.hpp"
 #include "Sphere.hpp"
 #include "Plane.hpp"

From 1b642b6d0bab5c328c1b1431891804b5573c3ae2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Apr 2012 17:45:55 +0200
Subject: [PATCH 0818/1541] Further implementation of disk structure + binding

---
 EGFRDSimulator.hpp         | 1 +
 ParticleSimulator.hpp      | 2 ++
 binding/World.hpp          | 1 +
 binding/binding_common.hpp | 2 ++
 4 files changed, 6 insertions(+)

diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index 45613f3f..c831a1d2 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -166,6 +166,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
     typedef ParticleSimulator<Ttraits_> base_type;
     typedef typename base_type::sphere_type sphere_type;
     typedef typename base_type::cylinder_type cylinder_type;
+    typedef typename base_type::disk_type disk_type;
     typedef typename base_type::particle_simulation_structure_type particle_simulation_structure_type;
     typedef typename base_type::spherical_surface_type spherical_surface_type;
     typedef typename base_type::cylindrical_surface_type cylindrical_surface_type;
diff --git a/ParticleSimulator.hpp b/ParticleSimulator.hpp
index c03de6d7..47102594 100644
--- a/ParticleSimulator.hpp
+++ b/ParticleSimulator.hpp
@@ -4,6 +4,7 @@
 #include <boost/bind.hpp>
 #include <boost/shared_ptr.hpp>
 #include "Sphere.hpp"
+#include "Disk.hpp"
 #include "Cylinder.hpp"
 #include "Box.hpp"
 #include "ParticleSimulationStructure.hpp"
@@ -97,6 +98,7 @@ class ParticleSimulator
     // shorthand typedefs
     typedef Sphere<typename world_type::length_type>    sphere_type;
     typedef Cylinder<typename world_type::length_type>  cylinder_type;
+    typedef Disk<typename world_type::length_type>      disk_type;
     typedef Box<typename world_type::length_type>       box_type;
     typedef Plane<typename world_type::length_type>     plane_type;
     typedef ParticleSimulationStructure<traits_type>    particle_simulation_structure_type;
diff --git a/binding/World.hpp b/binding/World.hpp
index e01a2aff..d81166cd 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -305,6 +305,7 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("distance", &impl_type::template distance<typename impl_type::position_type>)
         .def("distance", &impl_type::template distance<typename Tsim::sphere_type>)
         .def("distance", &impl_type::template distance<typename Tsim::cylinder_type>)
+        .def("distance", &impl_type::template distance<typename Tsim::disk_type>)
         .def("distance", &impl_type::template distance<typename Tsim::box_type>)
         .def("distance", &impl_type::template distance<typename Tsim::plane_type>)
         .def("calculate_pair_CoM", &impl_type::template calculate_pair_CoM<typename impl_type::position_type>)
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index b1762cce..a6778622 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -16,6 +16,7 @@
 #include "../Vector3.hpp"
 #include "../Sphere.hpp"
 #include "../Cylinder.hpp"
+#include "../Disk.hpp"
 #include "../Box.hpp"
 #include "../Plane.hpp"
 #include "../Point.hpp"
@@ -73,6 +74,7 @@ typedef ::MultiParticleContainer<EGFRDSimulatorTraits> MultiParticleContainer;
 typedef EGFRDSimulator::box_type        Box;
 typedef EGFRDSimulator::sphere_type     Sphere;
 typedef EGFRDSimulator::cylinder_type   Cylinder;
+typedef EGFRDSimulator::disk_type       Disk;
 typedef EGFRDSimulator::plane_type      Plane;
 
 typedef ::BDPropagator<EGFRDSimulatorTraits> BDPropagator;

From 87c7cd904e71c8169349317d583bf3becdbdfd44 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 25 Apr 2012 18:13:15 +0200
Subject: [PATCH 0819/1541] bug/typo fixes to newBDPropagator

---
 newBDPropagator.hpp | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index d1b96557..507ac0ef 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -41,10 +41,12 @@ class newBDPropagator
     typedef typename particle_container_type::structure_type        structure_type;
     typedef typename particle_container_type::structure_id_type     structure_id_type;    
 
-    typedef typename particle_container_type::structure_id_and_distance_pair     structure_id_and_distance_pair;
+//    typedef typename particle_container_type::structure_id_and_distance_pair     structure_id_and_distance_pair;
     typedef typename particle_container_type::particle_id_pair_generator         particle_id_pair_generator;
     typedef typename particle_container_type::particle_id_pair_and_distance      particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
+    typedef typename particle_container_type::structure_id_pair_and_distance      structure_id_pair_and_distance;
+    typedef typename particle_container_type::structure_id_pair_and_distance_list structure_id_pair_and_distance_list;
     typedef typename traits_type::world_type::traits_type::rng_type rng_type;
     typedef typename traits_type::time_type                         time_type;
     typedef typename traits_type::network_rules_type                network_rules_type;
@@ -129,8 +131,8 @@ class newBDPropagator
         const structure_id_type                       old_struct_id(pp.second.structure_id());
         const boost::shared_ptr<const structure_type> pp_structure( tx_.get_structure( old_struct_id ) );
         // declare variables to use
-        structure_id_and_distance_pair  struct_id_distance_pair;
-        length_type                     particle_surface_distance (0);
+//        structure_id_and_distance_pair  struct_id_distance_pair;
+//        length_type                     particle_surface_distance (0);
         position_type                   new_pos;
         structure_id_type               new_structure_id( old_struct_id );
 
@@ -190,11 +192,9 @@ class newBDPropagator
 /*
         if(!bounced && pp.second.structure_id() == tx_.get_def_structure_id())
         {
-            // TODO Get all the structures within the reaction volume (and that may consequently also be in the core)
             struct_id_distance_pair = tx_.get_closest_surface( new_pos, new_structure_id);
 
             // Check for overlap with nearest surface.
-            // TODO check all the surfaces while bounced != true.
             particle_surface_distance = struct_id_distance_pair.second;
             boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
             bounced = closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
@@ -202,13 +202,19 @@ class newBDPropagator
                                                particle_surface_distance, r0);
         }
 */
+        boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures;
+        int structures_in_overlap(0);
+
+        // Check for overlap with nearest surface.
         if (!bounced)
         {
-            boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures(
+            // Get all the structures within the reaction volume (and that may consequently also be in the core)
+            boost::scoped_ptr<structure_id_pair_and_distance_list> temp_structs(
                 tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0));
+            temp_structs.swap(overlap_structures);
             int structures_in_overlap(overlap_structures ? overlap_structures->size(): 0);
 
-            j = 0
+            j = 0;
             while(!bounced && j < structures_in_overlap)
                 bounced = overlap_structures->at(j++).second < r0;
         }
@@ -253,7 +259,7 @@ class newBDPropagator
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
         Real accumulated_prob = 0;
-        Real const rnd( rng_() );
+        Real rnd( rng_() );
         
         const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
         /* First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction. */
@@ -436,9 +442,10 @@ class newBDPropagator
                     {
                         const boost::shared_ptr<const structure_type> reactant_structure( tx_.get_structure(pp.second.structure_id()) );
                         const species_type product_species(tx_.get_species(products[0]));
+                        const position_type old_pos(pp.second.position());
 
                         // default values for the position and structure of the product
-                        position_type     new_pos          (pp.second.position());
+                        position_type     new_pos          (old_pos);
                         structure_id_type new_structure_id (pp.second.structure_id());
                         
                         /* If the product particle does NOT live on the same structure type as the reactant => surface -> bulk dissociation. */
@@ -595,8 +602,8 @@ class newBDPropagator
                                 surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
                                                                            tx_.cyclic_transpose( pos0pos1_pair.second, closest_struct->position() ), 
                                                                            struct_id_distance_pair.second, product1_species.radius() );
-*/
                             }
+*/
                             
                             // If the positions were allowed -> SUCCESS and leave the loop
                             if ( !(overlapped_product0 && overlapped_product0->size() > 0) && 
@@ -698,7 +705,7 @@ class newBDPropagator
                                         (s0.D() + s1.D()))) );
 
 //                        position_type new_pos (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D());
-                        structure_id_type new_structure_id;
+                        structure_id_type new_structure_id(pp0.second.structure_id());
 
                         //For unequal structures, project new_pos on surface.
                         if(product_species.structure_type_id() != s1.structure_type_id())
@@ -927,7 +934,7 @@ class newBDPropagator
             }
 */
             const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(
-                    tx_.check_surface_overlap(particle_shape_type(new_pos, species.radius()), old_pos, new_structure_id, species.radius()));
+                    tx_.check_surface_overlap(particle_shape_type(new_pos, species.radius()), old_pos, s0_struct->id(), species.radius()));
             if (overlap_surface && overlap_surface->size() > 0)
                 return old_pos;
         }    

From 572bef0da7d530555460067eed6c65342a7ae3a9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Apr 2012 11:26:36 +0200
Subject: [PATCH 0820/1541] fixes to is_alongside

---
 Plane.hpp     | 2 +-
 Region.hpp    | 4 ++++
 Structure.hpp | 1 +
 Surface.hpp   | 5 +++++
 4 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/Plane.hpp b/Plane.hpp
index 90849280..edb982aa 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -273,7 +273,7 @@ is_alongside(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 {
     typedef typename Plane<T_>::position_type position_type;
 
-    boost::array<typename Plane<T_>::length_type, 2> half_extends(obj.half_extend());
+    boost::array<typename Plane<T_>::length_type, 2> half_extends(obj.half_extent());
     position_type pos_vector(subtract(pos, obj.position()));
 
     return ((abs(dot_product(pos_vector, obj.unit_x())) < half_extends[0]) &&
diff --git a/Region.hpp b/Region.hpp
index f183c49f..747b77c9 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -121,6 +121,10 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::deflect_back(shape(), pos, u_z);
     }
     
+    virtual bool is_alongside(position_type const& pos) const
+    {
+        return ::is_alongside(shape(), pos);
+    }
 
     // The constructor
     BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
diff --git a/Structure.hpp b/Structure.hpp
index 55f4a1ba..b9d6019f 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -103,6 +103,7 @@ class Structure
 */
     // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const = 0;
+    virtual bool is_alongside(position_type const& pos) const = 0;
 
 
     // TODO this are just functions->move somewhere else
diff --git a/Surface.hpp b/Surface.hpp
index 6b7a5335..f691d7db 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -128,6 +128,11 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::deflect_back(shape(), pos, u_z);
     }
     
+    virtual bool is_alongside(position_type const& pos) const
+    {
+        return ::is_alongside(shape(), pos);
+    }
+
     // Constructor
     BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
         : base_type(name, sid, parent_struct_id), shape_(shape) {}

From 69547ad67be90f2202e9df1ed761a47ea30713e2 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Apr 2012 15:26:23 +0200
Subject: [PATCH 0821/1541] cleanup of newBDPropagator changing structures.
 Also general cleanup.

---
 newBDPropagator.hpp | 373 +++++++++++++++++++-------------------------
 1 file changed, 163 insertions(+), 210 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 507ac0ef..19d14e53 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -58,6 +58,8 @@ class newBDPropagator
 
     typedef std::vector<particle_id_type>                           particle_id_vector_type;
     typedef std::pair<position_type, position_type>                 position_pair_type;
+    typedef std::pair<position_type, structure_id_type>             position_structid_pair_type;
+    typedef std::pair<position_structid_pair_type, position_structid_pair_type> posstructid_posstructid_pair_type;
     typedef std::pair<position_type, length_type>                   projected_type;
 
 public:
@@ -133,14 +135,14 @@ class newBDPropagator
         // declare variables to use
 //        structure_id_and_distance_pair  struct_id_distance_pair;
 //        length_type                     particle_surface_distance (0);
-        position_type                   new_pos;
+        position_type                   new_pos(old_pos);
         structure_id_type               new_structure_id( old_struct_id );
 
         //// 2. New position
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particle bounces, and is returned
            to it's original position. For a particle with D = 0, new_pos = old_pos */        
-        if (pp_species.D() != 0.)
+        if (pp_species.D() != 0.0)
         {
             // get a new position, dependent on the structure the particle lives on.
             const position_type displacement( pp_structure->bd_displacement(pp_species.v() * dt_,
@@ -166,24 +168,25 @@ class newBDPropagator
             // Else, just use the current information.
 */
         }
-        else
+/*        else
         {
             new_pos = old_pos;
         }
-        
+*/        
+
+        bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
 	       We use it to check for overlaps with other particles. */
-        bool bounced( false );
-        boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped(
+        boost::scoped_ptr<particle_id_pair_and_distance_list> overlap_particles(
                 tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
-        int particles_in_overlap(overlapped ? overlapped->size(): 0);
+        int particles_in_overlap(overlap_particles ? overlap_particles->size(): 0);
 
         //// 3.1 Check for core overlaps with particles
         /* Check if the particle at new_pos overlaps with any particle cores. */        
         int j( 0 );
         while(!bounced && j < particles_in_overlap)
-            bounced = overlapped->at(j++).second < r0;
+            bounced = overlap_particles->at(j++).second < r0;
         
         //// 3.2 Check for core overlaps structures
         /* If the particle has not bounced with another particle and lives in the bulk: 
@@ -209,9 +212,9 @@ class newBDPropagator
         if (!bounced)
         {
             // Get all the structures within the reaction volume (and that may consequently also be in the core)
-            boost::scoped_ptr<structure_id_pair_and_distance_list> temp_structs(
+            boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_tmp(
                 tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0));
-            temp_structs.swap(overlap_structures);
+            overlap_structures.swap(overlap_structures_tmp);
             int structures_in_overlap(overlap_structures ? overlap_structures->size(): 0);
 
             j = 0;
@@ -225,20 +228,20 @@ class newBDPropagator
         {
             // restore old position and structure_id
             new_pos = old_pos;
-            new_structure_id = pp.second.structure_id();
+            new_structure_id = old_struct_id;
             
             // re-get the reaction partners (particles), now on old position.
-            boost::scoped_ptr<particle_id_pair_and_distance_list> overlapped_after_bounce( 
-                    tx_.check_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first) );
-            overlapped.swap( overlapped_after_bounce );     // FIXME is there no better way?
+            boost::scoped_ptr<particle_id_pair_and_distance_list> overlap_particles_after_bounce( 
+                    tx_.check_overlap( particle_shape_type( old_pos, r0 + reaction_length_ ), pp.first) );
+            overlap_particles.swap( overlap_particles_after_bounce );     // FIXME is there no better way?
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
-            particles_in_overlap = overlapped ? overlapped->size(): 0; 
+            particles_in_overlap = overlap_particles ? overlap_particles->size(): 0; 
             
-            // re-get the reaction partners (particles), now on old position.
-            boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_struct_after_bounce( 
-                    tx_.check_surface_overlap( particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0) );
-            overlap_structures.swap( overlap_struct_after_bounce );     // FIXME is there no better way?
+            // re-get the reaction partners (structures), now on old position.
+            boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_after_bounce( 
+                    tx_.check_surface_overlap( particle_shape_type( old_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0) );
+            overlap_structures.swap( overlap_structures_after_bounce );     // FIXME is there no better way?
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
             structures_in_overlap = overlap_structures ? overlap_structures->size(): 0; 
@@ -258,7 +261,7 @@ class newBDPropagator
         //// 5.
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
-        Real accumulated_prob = 0;
+        Real accumulated_prob (0);
         Real rnd( rng_() );
         
         const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
@@ -268,21 +271,22 @@ class newBDPropagator
         j = 0;
         while(j < structures_in_overlap)
         {
-            const structure_id_pair_and_distance & closest_surf( overlap_structures->at(j) );
+            const structure_id_pair_and_distance & overlap_struct( overlap_structures->at(j) );
 //        if( pp.second.structure_id() == tx_.get_def_structure_id())
 //        {
 
-            if( (closest_surf.first.second->sid() != current_struct->sid()) &&
-                (closest_surf.second < r0 + reaction_length_) &&
-                (closest_surf.first.second->is_alongside(new_pos)))
-//                closest_surf.second->in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
+            // For an interaction the structure must be:
+            if( (overlap_struct.first.second->sid() != current_struct->sid()) &&    // - of a different structure_type
+                (overlap_struct.second < r0 + reaction_length_) &&                  // - within the reaction volume
+                (overlap_struct.first.second->is_alongside(new_pos)))               // - 'alongside' of the particle
+//                overlap_struct.second->in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
             {
-                accumulated_prob += k_total( pp.second.sid(), closest_surf.first.second->sid() ) * dt_ / 
-                                    closest_surf.first.second->surface_reaction_volume( r0, reaction_length_ );
+                accumulated_prob += k_total( pp.second.sid(), overlap_struct.first.second->sid() ) * dt_ / 
+                                    overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ );
         
                 if(accumulated_prob >= 1.)
                 {
-                    LOG_WARNING(("the acceptance probability of an interaction exeeded one; %f.",
+                    LOG_WARNING(("the acceptance probability of an interaction/reaction exeeded one; %f.",
                                  accumulated_prob));
                 } 
                 
@@ -291,7 +295,7 @@ class newBDPropagator
                     try
                     {
                         LOG_DEBUG(("fire surface interaction"));
-                        if(attempt_interaction(pp, closest_surf.first.second ))
+                        if(attempt_interaction(pp, overlap_struct.first.second ))
                             return true;
                     }   
                     catch (propagation_error const& reason)
@@ -303,7 +307,7 @@ class newBDPropagator
                 else                
                 {
                     LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
-                               boost::lexical_cast<std::string>(closest_surf.first.first).c_str()));     // TODO is this the correct interpretation?
+                               boost::lexical_cast<std::string>(overlap_struct.first.first).c_str()));
                 }
             }
 
@@ -312,32 +316,33 @@ class newBDPropagator
         
         ////
         /* Now attempt a reaction with all particles inside the reaction volume. */
-        accumulated_prob = 0;
-        rnd = rng_();
+//        accumulated_prob = 0;
+//        rnd = rng_();
         j = 0;
         while(j < particles_in_overlap)
         {
-            const particle_id_pair_and_distance & closest( overlapped->at(j) );
+            const particle_id_pair_and_distance & overlap_particle( overlap_particles->at(j) );
 
             species_type s0(pp_species);
-            species_type s1(tx_.get_species(closest.first.second.sid()));
+            species_type s1(tx_.get_species(overlap_particle.first.second.sid()));
                 
-            /* If the structures of the reactants are not equal, one of the reactants has to come from the bulk,
+            /* If the structure_types of the reactants are not equal, one of the reactants has to come from the bulk,
                and we let this be s1, the particle from the surface is named s0. */
             if(s0.structure_type_id() != s1.structure_type_id())
             {
                 if( !(s0.structure_type_id() == tx_.get_def_structure_type_id() || s1.structure_type_id() == tx_.get_def_structure_type_id())  )
                 {
-                    log_.warn("A surface particle overlapped with a particle living on a different surface. No reaction implemented.");
-                    continue;
+                    log_.warn("A surface particle overlapped with a particle living on a different structure_type. No reaction implemented.");
+                    continue;           // FIXME this now blocks the cap dissociation.
                 }
                 if(s0.structure_type_id() == tx_.get_def_structure_type_id())
-                    std::swap(s0,s1);
+                    std::swap(s0,s1);       // ??????
             }
             
-            const boost::shared_ptr<const structure_type> s1_struct( tx_.get_structure( closest.first.second.structure_id()) );
-            const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
-            accumulated_prob += k_total(s0.id(), s1.id()) * dt_ / ( 2. * reaction_volume ); 
+            const boost::shared_ptr<const structure_type> s1_struct( tx_.get_structure( overlap_particle.first.second.structure_id()) );
+//            const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
+            accumulated_prob += k_total(s0.id(), s1.id()) * dt_ /
+                                ( 2. * s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ); 
             
             if (accumulated_prob >= 1.)
             {
@@ -351,7 +356,7 @@ class newBDPropagator
                 LOG_DEBUG(("fire reaction"));
     		    try
                 {
-                    if( attempt_pair_reaction(pp, closest.first, s0, s1) )
+                    if( attempt_pair_reaction(pp, overlap_particle.first, s0, s1) )
                         return true;
                 }
                 catch (propagation_error const& reason)
@@ -363,7 +368,7 @@ class newBDPropagator
             else                
             {
                 LOG_DEBUG(("Particle attempted a reaction with particle %s and failed.", 
-                    boost::lexical_cast<std::string>(closest.first.first).c_str()));    // TODO is this really a rejected move?
+                    boost::lexical_cast<std::string>(overlap_particle.first.first).c_str()));
             }
             
             j++;
@@ -445,30 +450,31 @@ class newBDPropagator
                         const position_type old_pos(pp.second.position());
 
                         // default values for the position and structure of the product
-                        position_type     new_pos          (old_pos);
-                        structure_id_type new_structure_id (pp.second.structure_id());
+                        position_structid_pair_type     new_pos_structure_id;
+                        position_type                   new_pos          (old_pos);
+                        structure_id_type               new_structure_id (pp.second.structure_id());
                         
-                        /* If the product particle does NOT live on the same structure type as the reactant => surface -> bulk dissociation. */
+                        /* If the product particle does NOT live on the same structure type as the reactant => structure -> superstructure dissociation. */
                         if( product_species.structure_type_id() != reactant_structure->sid() )
                         {
-                            // dissociation from a structure_type into another must always be TO the bulk (default structure/structure_type)
-                            if( product_species.structure_type_id() != tx_.get_def_structure_type_id() )
-                                throw not_implemented("No surface -> surface dissociation allowed");
-                            new_structure_id = tx_.get_def_structure_id();
+                            // TODO check that the species lives on the parents structure structure_type
+                            new_structure_id = reactant_structure->structure_id();      // TODO when dissociating from the 'cap' structure, we go up two levels.
                         
                             // get dissociation position.
                             const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
                             new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
                             
                             //Particle is allowed to move after dissociation from surface.
-                            new_pos = make_move(product_species, new_pos, pp.first);
+                            new_pos_structure_id = make_move(product_species, std::make_pair(new_pos, new_structure_id), pp.first);
+                            new_pos = new_pos_structure_id.first;
+                            new_structure_id = new_pos_structure_id.second;
                         }
                       
 
                         const particle_shape_type new_shape(new_pos, product_species.radius());
                         // check for overlap with particles that are inside the propagator
-                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped(tx_.check_overlap(new_shape, pp.first));
-                        if (overlapped && overlapped->size() > 0)
+                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(tx_.check_overlap(new_shape, pp.first));
+                        if (overlap_particles && overlap_particles->size() > 0)
                         {
                             throw propagation_error("no space due to other particle");
                         }
@@ -483,25 +489,13 @@ class newBDPropagator
 
                         // check overlap with surfaces
                         // check for overlap with particles that are inside the propagator
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(tx_.check_surface_overlap(new_shape, old_pos, reactant_structure->id(),
-                                                                                                           product_species.radius()));
-                        if (overlap_surface && overlap_surface->size() > 0)
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
+                                tx_.check_surface_overlap(new_shape, old_pos, new_structure_id, product_species.radius()));
+                        if (overlap_surfaces && overlap_surfaces->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");
                         }
-/*
-                        // check overlap with surfaces
-                        if( product_species.structure_type_id() == tx_.get_def_structure_type_id() && pp.second.structure_id() == tx_.get_def_structure_id() )
-                        {
-                            const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, pp.second.structure_id()) );
-                            const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
 
-                            if( closest_struct->bounced( tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
-                                                         tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
-                                                         struct_id_distance_pair.second, product_species.radius() ) )
-                                throw propagation_error("no space due to near surface");
-                        }
-*/
                         // Process changes
                         tx_.remove_particle(pp.first);
                         // Make new particle on right surface
@@ -525,12 +519,13 @@ class newBDPropagator
                         
                         species_type product0_species(tx_.get_species(products[0]));
                         species_type product1_species(tx_.get_species(products[1]));
-                        position_pair_type pos0pos1_pair;
+                        position_pair_type pos0pos1;
                         structure_id_type prod0_struct_id;
                         structure_id_type prod1_struct_id;
+                        posstructid_posstructid_pair_type pos0pos1_pair;
 
                         /* Create positions (np0, np1) for the reaction products. 
-                        The ipv between the products lies within the reation volume. */
+                        The iv between the products lies within the reation volume. */
                         int i (max_retry_count_);
                         while (true)
                         {
@@ -543,73 +538,60 @@ class newBDPropagator
 
                             //// Generate positions and structure_id for product particles after reaction
 
-                            /* If the product particles do NOT live on the same structure => surface -> surface + bulk dissociation.
+                            /* If the product particles do NOT live on the same structure => structure -> structure + parent_structure dissociation.
                                Else, the products live on the same structure AND on the same structure as the reactant. 
                                => standard geminate dissociation. 
                                
-                            We set: species 0 lives on the surface; species 1 lives in the bulk. */
+                            We set: species 0 lives on the current structure; species 1 lives in the parent structure. */
                             if( product0_species.structure_type_id() != product1_species.structure_type_id() )
                             {
-                                if( !(product0_species.structure_type_id() == tx_.get_def_structure_type_id() || 
-                                      product1_species.structure_type_id() == tx_.get_def_structure_type_id())  )
-                                    throw not_implemented("No surface -> surface + surface - dissociation allowed");
+                                const boost::shared_ptr<const structure_type> parent_structure( tx_.get_structure( reactant_structure->structure_id() ) );
+                                if( !(product0_species.structure_type_id() == parent_structure->sid() || 
+                                      product1_species.structure_type_id() == parent_structure->sid())  )
+                                    throw not_implemented("One of product species should live on parent structure.");
                                                  
-                                if(product0_species.structure_type_id() == tx_.get_def_structure_type_id())    
-                                     std::swap(product0_species,product1_species);
+                                if ( !(product0_species.structure_type_id() == reactant_structure->sid()) )
+                                    std::swap(product0_species, product1_species);
 
-                                pos0pos1_pair = reactant_structure-> special_geminate_dissociation_positions( rng_, product0_species, product1_species,
+                                pos0pos1 = reactant_structure-> special_geminate_dissociation_positions( rng_, product0_species, product1_species,
                                                                                                               reactant_pos, reaction_length_ );
-                                prod0_struct_id = pp.second.structure_id();         // The 'original' structure
-                                prod1_struct_id = tx_.get_def_structure_id();       // The bulk
+                                prod0_struct_id = pp.second.structure_id();             // The 'original' structure
+                                prod1_struct_id = reactant_structure->structure_id();   // The parent structure
                             }
                             else
                             {
-                                pos0pos1_pair = reactant_structure-> geminate_dissociation_positions( rng_, product0_species, product1_species,
+                                pos0pos1 = reactant_structure-> geminate_dissociation_positions( rng_, product0_species, product1_species,
                                                                                                       reactant_pos, reaction_length_ );
                                 prod0_struct_id = pp.second.structure_id();         // same structure as the reactant
                                 prod1_struct_id = pp.second.structure_id();         // ditto
                             }
-                            pos0pos1_pair.first  = tx_.apply_boundary( pos0pos1_pair.first );
-                            pos0pos1_pair.second = tx_.apply_boundary( pos0pos1_pair.second );
+                            // TODO check that the positions do not cross any edges.
+                            pos0pos1.first  = tx_.apply_boundary( pos0pos1.first );
+                            pos0pos1.second = tx_.apply_boundary( pos0pos1.second );
+                            pos0pos1_pair = std::make_pair(std::make_pair(pos0pos1.first, prod0_struct_id),
+                                                           std::make_pair(pos0pos1.second, prod1_struct_id));
 
 
+                            // TODO make more efficient, don't do checking after one has failed.
                             // check overlap with particle in the propagator
-                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped_product0(
-                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.first, product0_species.radius()),  pp.first));
-                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped_product1(
-                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.second, product1_species.radius()), pp.first));
+                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product0(
+                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.first.first, product0_species.radius()),  pp.first));
+                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product1(
+                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.second.first, product1_species.radius()), pp.first));
                                     
                             /* Only when both products live in the bulk, check for possible overlap with a surface. */
-//                            bool surface_bounce0( false );
-//                            bool surface_bounce1( false );
-                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface0(
-                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.first, product0_species.radius()), reactant_pos, reactant_structure->id(), product0_species.radius()));
-                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface1(
-                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.second, product1_species.radius()), reactant_pos, reactant_structure->id(), product1_species.radius()));
-
-/*                            if( product0_species.structure_type_id() == tx_.get_def_structure_type_id() && product1_species.structure_type_id() == tx_.get_def_structure_type_id() )
-                            {
-                                structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( pos0pos1_pair.first, tx_.get_def_structure_id() ) );
-                                boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product0(
+                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.first.first, product0_species.radius()), reactant_pos,
+                                                          pos0pos1_pair.first.second, product0_species.radius()));
+                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product1(
+                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.second.first, product1_species.radius()), reactant_pos,
+                                                          pos0pos1_pair.second.second, product1_species.radius()));
 
-                                surface_bounce0 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
-                                                                           tx_.cyclic_transpose( pos0pos1_pair.first, closest_struct->position() ), 
-                                                                           struct_id_distance_pair.second, product0_species.radius() );
-
-                                struct_id_distance_pair = tx_.get_closest_surface( pos0pos1_pair.second, tx_.get_def_structure_id() );
-                                closest_struct = tx_.get_structure( struct_id_distance_pair.first );
-
-                                surface_bounce1 = closest_struct->bounced( tx_.cyclic_transpose( pp.second.position(), closest_struct->position() ), 
-                                                                           tx_.cyclic_transpose( pos0pos1_pair.second, closest_struct->position() ), 
-                                                                           struct_id_distance_pair.second, product1_species.radius() );
-                            }
-*/
-                            
                             // If the positions were allowed -> SUCCESS and leave the loop
-                            if ( !(overlapped_product0 && overlapped_product0->size() > 0) && 
-                                 !(overlapped_product1 && overlapped_product1->size() > 0) &&
-                                 !(overlap_surface0 && overlap_surface0->size() > 0) &&
-                                 !(overlap_surface1 && overlap_surface1->size() > 0)) 
+                            if ( !(overlap_particles_product0 && overlap_particles_product0->size() > 0) && 
+                                 !(overlap_particles_product1 && overlap_particles_product1->size() > 0) &&
+                                 !(overlap_structures_product0 && overlap_structures_product0->size() > 0) &&
+                                 !(overlap_structures_product1 && overlap_structures_product1->size() > 0)) 
                                 break;
                         }
 
@@ -619,8 +601,8 @@ class newBDPropagator
                         // check overlap with particle outside of propagator (for example in eGFRD simulator)
                         if (vc_)
                         {
-                            if (!(*vc_)(particle_shape_type(pos0pos1_pair.first,  product0_species.radius()), pp.first) ||
-                                !(*vc_)(particle_shape_type(pos0pos1_pair.second, product1_species.radius()), pp.first))
+                            if (!(*vc_)(particle_shape_type(pos0pos1_pair.first.first,  product0_species.radius()), pp.first) ||
+                                !(*vc_)(particle_shape_type(pos0pos1_pair.second.first, product1_species.radius()), pp.first))
                             {
                                 throw propagation_error("no space due to near particle (vc)");
                             }
@@ -628,8 +610,8 @@ class newBDPropagator
 
                         // Process changes
                         tx_.remove_particle(pp.first);
-                        const particle_id_pair product0_particle(tx_.new_particle(product0_species.id(), prod0_struct_id, pos0pos1_pair.first));
-                        const particle_id_pair product1_particle(tx_.new_particle(product1_species.id(), prod1_struct_id, pos0pos1_pair.second));
+                        const particle_id_pair product0_particle(tx_.new_particle(product0_species.id(), pos0pos1_pair.first.second, pos0pos1_pair.first.first));
+                        const particle_id_pair product1_particle(tx_.new_particle(product1_species.id(), pos0pos1_pair.second.second, pos0pos1_pair.second.first));
 
                         // Record changes
                         if (rrec_)
@@ -693,7 +675,6 @@ class newBDPropagator
                     // When one product particle
                     case 1:
                     {
-//                        const species_id_type product(products[0]);
                         const species_type product_species(tx_.get_species(products[0]));
                         
                         position_type new_pos( tx_.apply_boundary(
@@ -707,39 +688,45 @@ class newBDPropagator
 //                        position_type new_pos (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D());
                         structure_id_type new_structure_id(pp0.second.structure_id());
 
-                        //For unequal structures, project new_pos on surface.
-                        if(product_species.structure_type_id() != s1.structure_type_id())
+                        // For unequal structures, project new_pos on the 'lesser' structure.
+                        // The 'lesser' structure is the structure that is the lowest in the hierarchy of the two.
+                        if( s0.structure_type_id() != s1.structure_type_id() )
                         {
-                            // make sure that pp1 is the particle that is in 3D.
-                            // FIXME Ugly!!
-                            boost::shared_ptr<structure_type> sp_struct;
-                            if(pp0.second.structure_id() == tx_.get_def_structure_id())
+                            const boost::shared_ptr<const structure_type> reactant0_structure (tx_.get_structure( pp0.second.structure_id() ));
+                            if ( reactant0_structure->structure_id() == pp1.second.structure_id() )     // if pp1 lives on the parent structure of pp0
                             {
-                                new_structure_id = pp1.second.structure_id();
+                                new_structure_id = pp0.second.structure_id();                           // -> lesser structure is structure0
                             }
-                            else
+                            else                                                                        // pp0 lives on the parent structure of pp1
                             {
-                                new_structure_id = pp0.second.structure_id();
+                                new_structure_id = pp1.second.structure_id();                           // -> lesser structure is structure1
                             }
-                            sp_struct = tx_.get_structure( new_structure_id );
-                            projected_type const position_on_surface( sp_struct->
-                                                                      projected_point( tx_.cyclic_transpose( new_pos, 
-                                                                                                             sp_struct->position() ) ) );
+
+                            boost::shared_ptr<structure_type> product_structure = tx_.get_structure( new_structure_id );
+                            projected_type const position_on_surface( product_structure-> projected_point( tx_.cyclic_transpose( new_pos, product_structure->position() )));
+                            new_pos = tx_.apply_boundary( position_on_surface.first );
+
                             // check that the projected point is not outside of the product surface.
-                            if (sp_struct->distance( position_on_surface.first) < 0)
+                            if (product_structure->distance( position_on_surface.first) < 0)
                                 throw propagation_error("position product particle was not in surface.");
-                            new_pos = tx_.apply_boundary( position_on_surface.first );
                         }
+                        // TODO check if the new position needs to be deflected.
 
 
                         // check for overlap with particles that are inside the propagator
-                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped(
-                            tx_.check_overlap(particle_shape_type(new_pos, product_species.radius()),
-                                              pp0.first, pp1.first));
-                        if( overlapped && overlapped->size() > 0 )
+                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
+                            tx_.check_overlap(particle_shape_type(new_pos, product_species.radius()), pp0.first, pp1.first));
+                        if( overlap_particles && overlap_particles->size() > 0 )
                         {
                             throw propagation_error("no space due to particle");
                         }
+                        // Check overlap with surfaces
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
+                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, new_structure_id, product_species.radius()));
+                        if (overlap_structures && overlap_structures->size() > 0)
+                        {
+                            throw propagation_error("no space due to near surface");
+                        }
                         // check for overlap with particles outside of the propagator (for example the eGFRD simulator)
                         if( vc_ )
                         {
@@ -751,26 +738,6 @@ class newBDPropagator
                             }
                         }
                         
-                        // Check overlap with surfaces
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(
-                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, new_structure_id, product_species.radius()));
-                        if (overlap_surface && overlap_surface->size() > 0)
-                        {
-                            throw propagation_error("no space due to near surface");
-                        }
-
-/*                        if( product_species.structure_type_id() == tx_.get_def_structure_type_id() )
-                        {
-                            const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_def_structure_id() ) );
-                            const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
-
-                            if( closest_struct->bounced( tx_.cyclic_transpose( pp0.second.position(), closest_struct->position() ), 
-                                                         tx_.cyclic_transpose( pp1.second.position(), closest_struct->position() ), 
-                                                         struct_id_distance_pair.second, product_species.radius() ) )
-                                throw propagation_error("no space due to near surface");
-                        }
-*/
-
                         // Process changes
                         tx_.remove_particle(pp0.first);
                         remove_particle(pp1.first);
@@ -793,7 +760,7 @@ class newBDPropagator
                 return true;
             }
         }
-        //Should not reach here.
+        // Should not reach here.
         throw illegal_state("Pair reaction failed, no reaction selected when reaction was supposed to happen.");
     }
 
@@ -842,12 +809,19 @@ class newBDPropagator
                         const position_type new_pos( tx_.apply_boundary( surface->projected_point( pp.second.position() ).first ) );
                             
                         // check for overlap with particles that are in the propagator
-                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped(
+                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
                             tx_.check_overlap(particle_shape_type(new_pos, product_species.radius()), pp.first));
-                        if (overlapped && overlapped->size() > 0)
+                        if (overlap_particles && overlap_particles->size() > 0)
                         {
                             throw propagation_error("no space");
                         }
+                        // check overlap with surfaces.
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
+                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, surface->id(), product_species.radius()));
+                        if (overlap_surfaces && overlap_surfaces->size() > 0)
+                        {
+                            throw propagation_error("no space due to near surface");
+                        }
                         // check for overlap with particles outside of the progator (e.g. the eGFRD simulator)
                         if (vc_)
                         {
@@ -858,13 +832,6 @@ class newBDPropagator
                                 throw propagation_error("no space (vc)");
                             }
                         }
-                        // check overlap with surfaces.
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(
-                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, surface->id(), product_species.radius()));
-                        if (overlap_surface && overlap_surface->size() > 0)
-                        {
-                            throw propagation_error("no space due to near surface");
-                        }
 
                         // Process changes
                         tx_.remove_particle(pp.first);
@@ -892,65 +859,49 @@ class newBDPropagator
     }
     
 
-    const position_type make_move(species_type const& species, position_type const& old_pos, particle_id_type const& ignore) const
+    const position_structid_pair_type make_move(species_type const& species, position_structid_pair_type const& old_pos_struct_id,
+                                                particle_id_type const& ignore) const
     // generates a move for a particle and checks if the move was allowed.
     {
 
         // FIXME this is just redoing what we are doing above when moving a particle.
-        position_type     new_pos(old_pos);
-        structure_id_type new_structure_id();
+        position_type     new_pos(old_pos_struct_id.first);
+        structure_id_type new_structure_id(old_pos_struct_id.second);
 
-        if(species.D() == 0)
-        {
-            new_pos = old_pos;
-//            new_structure_id = old_structure_id;
-        }
-        else
+        if(species.D() != 0)
         {
-            const boost::shared_ptr<const structure_type> s0_struct( tx_.get_structure( tx_.get_particle(ignore).second.structure_id() ) );
+            const boost::shared_ptr<const structure_type> s0_struct( tx_.get_structure( new_structure_id ) );
 
             const position_type displacement( s0_struct->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
-            new_pos = tx_.apply_boundary( add( old_pos, displacement ) );
-            // TODO apply deflection
+            new_pos = tx_.apply_boundary( add( old_pos_struct_id.first, displacement ) );
+            // TODO apply deflection and change structure_id
                         
-            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlapped( 
-                                        tx_.check_overlap(
-                                        particle_shape_type(new_pos, species.radius()),
-                                        ignore));
-                                                                
             // See if it overlaps with any particles
-            if (overlapped && overlapped->size() > 0)
-                return old_pos;
-            // See if it overlaps with any surfaces.
-/*            if(species.structure_type_id() == tx_.get_def_structure_type_id())
-            {
-                const structure_id_and_distance_pair struct_id_distance_pair( tx_.get_closest_surface( new_pos, tx_.get_particle(ignore).second.structure_id() ) );
-                const boost::shared_ptr<const structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
+            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles( 
+                    tx_.check_overlap( particle_shape_type(new_pos, species.radius()), ignore));
+            if (overlap_particles && overlap_particles->size() > 0)
+                return old_pos_struct_id;
 
-                if( closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
-                                             tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
-                                             struct_id_distance_pair.second, species.radius() ) )    
-                    return old_pos;        
-            }
-*/
-            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surface(
-                    tx_.check_surface_overlap(particle_shape_type(new_pos, species.radius()), old_pos, s0_struct->id(), species.radius()));
-            if (overlap_surface && overlap_surface->size() > 0)
-                return old_pos;
+            // See if it overlaps with any surfaces.
+            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
+                    tx_.check_surface_overlap(particle_shape_type(new_pos, species.radius()), old_pos_struct_id.first, s0_struct->id(), species.radius()));
+            if (overlap_surfaces && overlap_surfaces->size() > 0)
+                return old_pos_struct_id;
         }    
-        return new_pos;
+
+        return std::make_pair(new_pos, new_structure_id);
     }
 
 
     /* Given a position pair and two species, the function generates two new 
        positions based on two moves drawn from the free propagator. */
-    const position_pair_type make_pair_move(species_type const& s0, species_type const& s1,
-                                            position_pair_type const& pos0_pos1, particle_id_type const& ignore) const
+    const posstructid_posstructid_pair_type make_pair_move(species_type const& s0, species_type const& s1,
+                                                           posstructid_posstructid_pair_type const& pos0_pos1, particle_id_type const& ignore) const
     {
         const length_type min_distance_01( s0.radius() + s1.radius() );
         
-        position_type temp_pos0(pos0_pos1.first),
-                      temp_pos1(pos0_pos1.second);
+        position_structid_pair_type temp_pos0(pos0_pos1.first),
+                                    temp_pos1(pos0_pos1.second);
         
         //Randomize which species moves first, and if there will be one or two moves. (50% of the cases)
         int  move_count( 1 + rng_.uniform_int(0, 1) );  // determine number of particles to move (1 or 2)
@@ -962,14 +913,16 @@ class newBDPropagator
             {
                 temp_pos0 = make_move(s0, pos0_pos1.first, ignore);
                 // check for overlap with the second particle (and potentially revert move)
-                temp_pos0 = tx_.distance(temp_pos0, temp_pos1) - min_distance_01 < 0 ? pos0_pos1.first : temp_pos0;
+                // TODO also revert structure_id in case of bounce
+                temp_pos0.first = tx_.distance(temp_pos0.first, temp_pos1.first) - min_distance_01 < 0 ? pos0_pos1.first.first : temp_pos0.first;
             }                       
             else
             // Move the second particle
             {
                 temp_pos1 = make_move(s1, pos0_pos1.second, ignore);
                 // check for overlap with the first particle (and potentially revert move)
-                temp_pos1 = tx_.distance(temp_pos1, temp_pos0) - min_distance_01 < 0 ? pos0_pos1.second : temp_pos1;
+                // TODO also revert structure_id in case of bounce
+                temp_pos1.first = tx_.distance(temp_pos1.first, temp_pos0.first) - min_distance_01 < 0 ? pos0_pos1.second.first : temp_pos1.first;
             }
 
             // Swap what particle to move

From 9294b8c94c32cc41bc2266671ef0236aefdef460 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Apr 2012 15:36:32 +0200
Subject: [PATCH 0822/1541] cleanup of old code

---
 CuboidalRegion.hpp     | 14 ----------
 CylindricalSurface.hpp | 20 --------------
 PlanarSurface.hpp      | 27 ------------------
 SphericalSurface.hpp   | 14 ----------
 Structure.hpp          |  6 ----
 newBDPropagator.hpp    | 63 ++++++------------------------------------
 6 files changed, 9 insertions(+), 135 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 83b9bc78..d61235e2 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -121,20 +121,6 @@ class CuboidalRegion
         return position_pair_type(); //No special geminate dissociation 'from' the bulk
     }
     
-/*
-    // Determine if particle has bounced from the surface 
-    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
-        length_type const& dist_to_surface, length_type const& particle_radius) const
-    {       
-        return false; //Can't bounce from a cuboidal region.
-    }
-    
-    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
-    {
-        return false; //Cube has no reaction volume.
-    }
-*/
-    // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         return base_type::distance(new_pos);
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index b11d9feb..561b08db 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -191,26 +191,6 @@ class CylindricalSurface
         
         return pp01;
     }
-/*
-    // Determine if particle has crossed the 'surface' of the structure.
-    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
-        length_type const& dist_to_surface, length_type const& particle_radius) const
-    {       
-        if( dist_to_surface < particle_radius )
-            return true;
-        else
-            return false;
-    }
-    
-    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
-    {
-        if( dist_to_surface - particle_radius <= rl )
-            return true;
-        else
-            return false;
-    }
-*/
-    // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         return base_type::distance(new_pos);
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 2d931032..a5799ca7 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -175,33 +175,6 @@ class PlanarSurface
         
     }
     
-/*
-    // Determine if particle has moved through the surface 
-    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
-        length_type const& dist_to_surface, length_type const& particle_radius) const
-    {       
-         if( dist_to_surface > particle_radius )
-            return false;
-            
-        projected_type const old_projection( base_type::projected_point_on_surface( old_pos ) );
-        projected_type const new_projection( base_type::projected_point_on_surface( new_pos ) );
-        
-        if( old_projection.second * new_projection.second <= 0 )
-            return true;
-        else
-            return false;
-    }
-    
-    // Determine wether particle lies inside reaction volume. 
-    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
-    {
-        if( dist_to_surface <= rl )
-            return true;
-        else
-            return false;
-    }
-*/
-    // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         const boost::array<length_type, 2> half_lengths(base_type::shape().half_extent());
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 0ba6c632..afc69be6 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -89,20 +89,6 @@ class SphericalSurface
         return position_pair_type(); //TODO
     }
     
-/*
-    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
-        length_type const& dist_to_surface, length_type const& particle_radius) const
-    {  
-        return false; //TODO
-    }
-    
-    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
-    {
-        return false; //TODO
-    }
-*/
-
-    // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         return base_type::distance(new_pos);
diff --git a/Structure.hpp b/Structure.hpp
index b9d6019f..70ae2779 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -96,12 +96,6 @@ class Structure
 
     // Methods used in the 'new' BDPropagator
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
-/*
-    // TODO rename bounced to smt else. It denotes whether a particle has crossed the 'surface' of the structure.
-    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, length_type const& dist_to_surface, length_type const& particle_radius) const = 0;
-    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const = 0;
-*/
-    // This should replace above two methods.
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const = 0;
     virtual bool is_alongside(position_type const& pos) const = 0;
 
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 19d14e53..aef34666 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -41,7 +41,6 @@ class newBDPropagator
     typedef typename particle_container_type::structure_type        structure_type;
     typedef typename particle_container_type::structure_id_type     structure_id_type;    
 
-//    typedef typename particle_container_type::structure_id_and_distance_pair     structure_id_and_distance_pair;
     typedef typename particle_container_type::particle_id_pair_generator         particle_id_pair_generator;
     typedef typename particle_container_type::particle_id_pair_and_distance      particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
@@ -56,11 +55,11 @@ class newBDPropagator
     typedef typename traits_type::reaction_recorder_type            reaction_recorder_type;
     typedef typename traits_type::volume_clearer_type               volume_clearer_type;
 
-    typedef std::vector<particle_id_type>                           particle_id_vector_type;
-    typedef std::pair<position_type, position_type>                 position_pair_type;
-    typedef std::pair<position_type, structure_id_type>             position_structid_pair_type;
+    typedef std::vector<particle_id_type>                                       particle_id_vector_type;
+    typedef std::pair<position_type, position_type>                             position_pair_type;
+    typedef std::pair<position_type, structure_id_type>                         position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type> posstructid_posstructid_pair_type;
-    typedef std::pair<position_type, length_type>                   projected_type;
+    typedef std::pair<position_type, length_type>                               projected_type;
 
 public:
     // The constructor
@@ -133,8 +132,6 @@ class newBDPropagator
         const structure_id_type                       old_struct_id(pp.second.structure_id());
         const boost::shared_ptr<const structure_type> pp_structure( tx_.get_structure( old_struct_id ) );
         // declare variables to use
-//        structure_id_and_distance_pair  struct_id_distance_pair;
-//        length_type                     particle_surface_distance (0);
         position_type                   new_pos(old_pos);
         structure_id_type               new_structure_id( old_struct_id );
 
@@ -168,11 +165,6 @@ class newBDPropagator
             // Else, just use the current information.
 */
         }
-/*        else
-        {
-            new_pos = old_pos;
-        }
-*/        
 
         bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
@@ -191,20 +183,6 @@ class newBDPropagator
         //// 3.2 Check for core overlaps structures
         /* If the particle has not bounced with another particle and lives in the bulk: 
            check for core overlap with a surface. */
-        // TODO always check for overlaps with surface ignoring its own surface (regardless of in bulk)
-/*
-        if(!bounced && pp.second.structure_id() == tx_.get_def_structure_id())
-        {
-            struct_id_distance_pair = tx_.get_closest_surface( new_pos, new_structure_id);
-
-            // Check for overlap with nearest surface.
-            particle_surface_distance = struct_id_distance_pair.second;
-            boost::shared_ptr<structure_type> closest_struct( tx_.get_structure( struct_id_distance_pair.first ) );
-            bounced = closest_struct->bounced( tx_.cyclic_transpose( old_pos, closest_struct->position() ), 
-                                               tx_.cyclic_transpose( new_pos, closest_struct->position() ), 
-                                               particle_surface_distance, r0);
-        }
-*/
         boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures;
         int structures_in_overlap(0);
 
@@ -245,16 +223,6 @@ class newBDPropagator
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
             structures_in_overlap = overlap_structures ? overlap_structures->size(): 0; 
-            
-/*            // re-get the reaction partners (structures), at old position. TODO don't just do this when in the bulk.
-            if(pp.second.structure_id() == tx_.get_def_structure_id())
-            {
-                // TODO get all near surfaces instead of just the closest.
-                struct_id_distance_pair = tx_.get_closest_surface( new_pos, pp.second.structure_id() );
-                // TODO get the number of surfaces.
-                particle_surface_distance = struct_id_distance_pair.second;  
-            }
-*/
         }
         
 
@@ -272,14 +240,11 @@ class newBDPropagator
         while(j < structures_in_overlap)
         {
             const structure_id_pair_and_distance & overlap_struct( overlap_structures->at(j) );
-//        if( pp.second.structure_id() == tx_.get_def_structure_id())
-//        {
 
             // For an interaction the structure must be:
             if( (overlap_struct.first.second->sid() != current_struct->sid()) &&    // - of a different structure_type
                 (overlap_struct.second < r0 + reaction_length_) &&                  // - within the reaction volume
                 (overlap_struct.first.second->is_alongside(new_pos)))               // - 'alongside' of the particle
-//                overlap_struct.second->in_reaction_volume( particle_surface_distance, r0, reaction_length_ ) )
             {
                 accumulated_prob += k_total( pp.second.sid(), overlap_struct.first.second->sid() ) * dt_ / 
                                     overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ );
@@ -316,8 +281,6 @@ class newBDPropagator
         
         ////
         /* Now attempt a reaction with all particles inside the reaction volume. */
-//        accumulated_prob = 0;
-//        rnd = rng_();
         j = 0;
         while(j < particles_in_overlap)
         {
@@ -340,7 +303,6 @@ class newBDPropagator
             }
             
             const boost::shared_ptr<const structure_type> s1_struct( tx_.get_structure( overlap_particle.first.second.structure_id()) );
-//            const Real reaction_volume( s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) );
             accumulated_prob += k_total(s0.id(), s1.id()) * dt_ /
                                 ( 2. * s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ); 
             
@@ -940,19 +902,12 @@ class newBDPropagator
         Real k_tot (0);
         reaction_rules const& rules(rules_.query_reaction_rule(s0_id, s1_id));
 
-//        if(::size(rules) != 0)
-//        {
-//            return 0;
-//        }
-//        else
-//        {
         // This should also work when 'rules' is empty.
-            for (typename boost::range_const_iterator<reaction_rules>::type
-                    i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
-            {
-                k_tot += (*i).k();
-            }
-//        }
+        for (typename boost::range_const_iterator<reaction_rules>::type
+                i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
+        {
+            k_tot += (*i).k();
+        }
         return k_tot;
     }
 

From e230690512689f87be3f6c6b0e88ac3743baa5bd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Apr 2012 17:09:19 +0200
Subject: [PATCH 0823/1541] cleanup and correction of fire_single_reaction with
 one product

---
 newBDPropagator.hpp | 71 +++++++++++++++++++++------------------------
 1 file changed, 33 insertions(+), 38 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index aef34666..bfa37b36 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -386,60 +386,67 @@ class newBDPropagator
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
-            reaction_rule_type const& r(*i);
-            k_cumm += r.k();
+            reaction_rule_type const& reaction_rule(*i);
+            k_cumm += reaction_rule.k();
 
             if (k_cumm > rnd)
             // We have found the reaction rule that is in effect
             {
                 // get the products
-                typename reaction_rule_type::species_id_range products(r.get_products());
+                typename reaction_rule_type::species_id_range products(reaction_rule.get_products());
 
                 switch (::size(products))
                 {
                     // When no product particles
                     case 0:
                     {
-                        tx_.remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
+                        remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
                         break;
                     }
 
                     // When one product particle
                     case 1:
                     {
-                        const boost::shared_ptr<const structure_type> reactant_structure( tx_.get_structure(pp.second.structure_id()) );
-                        const species_type product_species(tx_.get_species(products[0]));
-                        const position_type old_pos(pp.second.position());
+                        const position_type                             reactant_pos(pp.second.position());
+                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure(pp.second.structure_id()) );
+                        const species_type                              product_species(tx_.get_species(products[0]));
 
                         // default values for the position and structure of the product
-                        position_structid_pair_type     new_pos_structure_id;
-                        position_type                   new_pos          (old_pos);
-                        structure_id_type               new_structure_id (pp.second.structure_id());
+                        position_structid_pair_type     product_pos_struct_id (std::make_pair(reactant_pos, pp.second.structure_id()));
                         
                         /* If the product particle does NOT live on the same structure type as the reactant => structure -> superstructure dissociation. */
                         if( product_species.structure_type_id() != reactant_structure->sid() )
                         {
-                            // TODO check that the species lives on the parents structure structure_type
-                            new_structure_id = reactant_structure->structure_id();      // TODO when dissociating from the 'cap' structure, we go up two levels.
-                        
-                            // get dissociation position.
+                            // get dissociation position and structure
+                            // TODO merge the structure_id thing into the 'surface_dissociation_vector' method.
+                            // TODO when dissociating from the 'cap' structure, we go up two levels instead of one.
                             const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
-                            new_pos = tx_.apply_boundary( add( pp.second.position(), displacement ) );
-                            
+                            const position_type product_pos (tx_.apply_boundary( add( reactant_pos, displacement ) ));
+                            // When dissociating, the new structure is the parent structure (is this always true?)
+                            const structure_id_type product_structure_id (reactant_structure->structure_id());
+
+                            product_pos_struct_id = std::make_pair(product_pos, product_structure_id);
                             //Particle is allowed to move after dissociation from surface.
-                            new_pos_structure_id = make_move(product_species, std::make_pair(new_pos, new_structure_id), pp.first);
-                            new_pos = new_pos_structure_id.first;
-                            new_structure_id = new_pos_structure_id.second;
+                            product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
-                      
 
-                        const particle_shape_type new_shape(new_pos, product_species.radius());
+
+                        ////// Check for overlaps
+                        const particle_shape_type new_shape(product_pos_struct_id.first, product_species.radius());
                         // check for overlap with particles that are inside the propagator
-                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(tx_.check_overlap(new_shape, pp.first));
+                        const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
+                                tx_.check_overlap(new_shape, pp.first));
                         if (overlap_particles && overlap_particles->size() > 0)
                         {
                             throw propagation_error("no space due to other particle");
                         }
+                        // check overlap with surfaces
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
+                                tx_.check_surface_overlap(new_shape, reactant_pos, product_pos_struct_id.second, product_species.radius()));
+                        if (overlap_surfaces && overlap_surfaces->size() > 0)
+                        {
+                            throw propagation_error("no space due to near surface");
+                        }
                         // check for overlap with particles outside of the propagator (for example the eGFRD simulator)
                         if (vc_)
                         {
@@ -449,26 +456,18 @@ class newBDPropagator
                             }
                         }
 
-                        // check overlap with surfaces
-                        // check for overlap with particles that are inside the propagator
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
-                                tx_.check_surface_overlap(new_shape, old_pos, new_structure_id, product_species.radius()));
-                        if (overlap_surfaces && overlap_surfaces->size() > 0)
-                        {
-                            throw propagation_error("no space due to near surface");
-                        }
 
                         // Process changes
                         tx_.remove_particle(pp.first);
                         // Make new particle on right surface
-                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), new_structure_id, new_pos) );
+                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), product_pos_struct_id.second, product_pos_struct_id.first) );
 
                         // Record changes
                         if (rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(), array_gen(product_particle.first), pp.first));
+                                    reaction_rule.id(), array_gen(product_particle.first), pp.first));
                         }
                         break;
                     }
@@ -487,7 +486,7 @@ class newBDPropagator
                         posstructid_posstructid_pair_type pos0pos1_pair;
 
                         /* Create positions (np0, np1) for the reaction products. 
-                        The iv between the products lies within the reation volume. */
+                        The iv between the products lies within the reaction volume. */
                         int i (max_retry_count_);
                         while (true)
                         {
@@ -580,7 +579,7 @@ class newBDPropagator
                         {
                             (*rrec_)(
                                 reaction_record_type(
-                                    r.id(),
+                                    reaction_rule.id(),
                                     array_gen(product0_particle.first, product1_particle.first),
                                     pp.first));
                         }
@@ -925,10 +924,6 @@ class newBDPropagator
         {
             queue_.erase(i);
         }
-        else
-        {
-            throw not_found(std::string("Unknown particle (id=") + boost::lexical_cast<std::string>(pid) + ")");
-        }
     }
 
 

From 8a14a8c86f63dc87367fd6b564fad1f64b2c7f16 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Apr 2012 19:59:09 +0200
Subject: [PATCH 0824/1541] fixed ugly codestyle

---
 Plane.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index edb982aa..bab466e1 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -308,8 +308,10 @@ deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, t
     
     // Find the unit vector perpendicular to the edge by comparing with u_z
     // (u_z might point outwards or inwards with respect to plane obj)
-    if(dot_product(dc, u_z) > 0.0)     u_perp = u_z;
-    else                               u_perp = multiply(u_z, -1.0);        
+    if(dot_product(dc, u_z) > 0.0)
+        u_perp = u_z;
+    else
+        u_perp = multiply(u_z, -1.0);
     
     r_new = add(r_proj.first, multiply(u_perp, abs(r_proj.second)) );
     

From 112e548192e31cc6611c06372ee4484b4e2c68b9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 26 Apr 2012 19:58:05 +0200
Subject: [PATCH 0825/1541] cleanup of fire_reaction and fire_interaction. Also
 fire_reaction now supports two particles on same structure_type but different
 structures.

---
 newBDPropagator.hpp | 135 ++++++++++++++++++++++++++------------------
 1 file changed, 80 insertions(+), 55 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index bfa37b36..78cdb1e0 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -475,8 +475,8 @@ class newBDPropagator
                     // When two product particles
                     case 2:
                     {
-                        const position_type reactant_pos(pp.second.position());
-                        const boost::shared_ptr<const structure_type> reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
+                        const position_type                             reactant_pos(pp.second.position());
+                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
                         
                         species_type product0_species(tx_.get_species(products[0]));
                         species_type product1_species(tx_.get_species(products[1]));
@@ -629,61 +629,86 @@ class newBDPropagator
                     // When no products
                     case 0:
                     {
-                        tx_.remove_particle(pp0.first);
+                        remove_particle(pp0.first);
                         remove_particle(pp1.first);
                         break;
                     }
                     // When one product particle
                     case 1:
                     {
-                        const species_type product_species(tx_.get_species(products[0]));
-                        
-                        position_type new_pos( tx_.apply_boundary(
-                                        divide(
-                                        add(multiply(pp0.second.position(), s1.D()),
-                                            multiply(tx_.cyclic_transpose(
-                                                pp1.second.position(),
-                                                pp0.second.position()), s0.D())),
-                                        (s0.D() + s1.D()))) );
-
-//                        position_type new_pos (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D());
-                        structure_id_type new_structure_id(pp0.second.structure_id());
-
-                        // For unequal structures, project new_pos on the 'lesser' structure.
+                        const structure_id_type             reactant0_structure_id (pp0.second.structure_id());
+                        const structure_id_type             reactant1_structure_id (pp1.second.structure_id());
+                        boost::shared_ptr<structure_type>   reactant0_structure (tx_.get_structure( reactant0_structure_id ));
+                        boost::shared_ptr<structure_type>   reactant1_structure (tx_.get_structure( reactant1_structure_id ));
+                        position_type                       reactant0_pos (pp0.second.position());
+                        position_type                       reactant1_pos (pp1.second.position());
+                        const species_type                  product_species(tx_.get_species(products[0]));
+
+                        structure_id_type                   product_structure_id(reactant0_structure_id);
+
+                        if ((s0.structure_type_id() == s1.structure_type_id()) &&
+                            (reactant0_structure_id != reactant1_structure_id))
+                        {
+                            // deflect_back one of the coordinates.
+                            reactant1_pos = reactant0_structure->deflect_back(reactant1_pos, reactant1_structure->shape().unit_z());
+                        }
+
+                        position_type product_pos( tx_.apply_boundary(
+                                                    divide(
+                                                    add(multiply(reactant0_pos, s1.D()),
+                                                        multiply(tx_.cyclic_transpose(
+                                                            reactant1_pos,
+                                                            reactant0_pos), s0.D())),
+                                                    (s0.D() + s1.D()))) );
+//                        position_type product_pos (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D());
+
+                        // For unequal structure types, project product_pos on the 'lesser' structure.
                         // The 'lesser' structure is the structure that is the lowest in the hierarchy of the two.
                         if( s0.structure_type_id() != s1.structure_type_id() )
                         {
-                            const boost::shared_ptr<const structure_type> reactant0_structure (tx_.get_structure( pp0.second.structure_id() ));
-                            if ( reactant0_structure->structure_id() == pp1.second.structure_id() )     // if pp1 lives on the parent structure of pp0
+
+                            boost::shared_ptr<structure_type> product_structure;
+                            if ( reactant0_structure->structure_id() == reactant1_structure_id )        // if pp1 lives on the parent structure of pp0
                             {
-                                new_structure_id = pp0.second.structure_id();                           // -> lesser structure is structure0
+                                product_structure_id = reactant0_structure_id;                          // -> lesser structure is structure0
+                                product_structure = reactant0_structure;
                             }
                             else                                                                        // pp0 lives on the parent structure of pp1
                             {
-                                new_structure_id = pp1.second.structure_id();                           // -> lesser structure is structure1
+                                product_structure_id = reactant1_structure_id;                          // -> lesser structure is structure1
+                                product_structure = reactant1_structure;
                             }
 
-                            boost::shared_ptr<structure_type> product_structure = tx_.get_structure( new_structure_id );
-                            projected_type const position_on_surface( product_structure-> projected_point( tx_.cyclic_transpose( new_pos, product_structure->position() )));
-                            new_pos = tx_.apply_boundary( position_on_surface.first );
+                            projected_type const position_on_surface( product_structure-> projected_point(
+                                    tx_.cyclic_transpose( product_pos, product_structure->position() )));       // TODO check of cyclic transpose is still needed.
 
                             // check that the projected point is not outside of the product surface.
-                            if (product_structure->distance( position_on_surface.first) < 0)
+                            if (product_structure->distance( position_on_surface.first) > 0)
                                 throw propagation_error("position product particle was not in surface.");
+
+                            product_pos = tx_.apply_boundary( position_on_surface.first );
+                        }
+                        else if ((s0.structure_type_id() == s1.structure_type_id()) &&
+                                 (reactant0_structure_id != reactant1_structure_id))
+                        {
+                            // deflect the product coordinate and get right structure_id.
+                            std::pair<position_type, bool> bla = reactant1_structure->deflect(reactant0_pos, subtract(product_pos, reactant0_pos));
+                            product_pos = bla.first;
                         }
-                        // TODO check if the new position needs to be deflected.
 
 
+                        //// Check for overlaps
+                        const particle_shape_type new_shape(product_pos, product_species.radius());
                         // check for overlap with particles that are inside the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
-                            tx_.check_overlap(particle_shape_type(new_pos, product_species.radius()), pp0.first, pp1.first));
+                                tx_.check_overlap(new_shape, pp0.first, pp1.first));
                         if( overlap_particles && overlap_particles->size() > 0 )
                         {
                             throw propagation_error("no space due to particle");
                         }
                         // Check overlap with surfaces
                         const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
-                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, new_structure_id, product_species.radius()));
+                                tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius()));
                         if (overlap_structures && overlap_structures->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");
@@ -691,19 +716,18 @@ class newBDPropagator
                         // check for overlap with particles outside of the propagator (for example the eGFRD simulator)
                         if( vc_ )
                         {
-                            if (!(*vc_)(
-                                    particle_shape_type(new_pos, product_species.radius()), 
-                                    pp0.first, pp1.first))
+                            if (!(*vc_)(new_shape, pp0.first, pp1.first))
                             {
                                 throw propagation_error("no space due to particle (vc)");
                             }
                         }
-                        
+
+
                         // Process changes
-                        tx_.remove_particle(pp0.first);
+                        remove_particle(pp0.first);
                         remove_particle(pp1.first);
                         // Make new particle on right structure
-                        particle_id_pair product_particle(tx_.new_particle(product_species.id(), new_structure_id, new_pos));
+                        particle_id_pair product_particle(tx_.new_particle(product_species.id(), product_structure_id, product_pos));
                         // Record changes
                         if (rrec_)
                         {
@@ -726,17 +750,17 @@ class newBDPropagator
     }
 
         
-    const bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& surface)
-    // This handles the 'reaction' (interaction) between a particle and a surface.
+    const bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
+    // This handles the 'reaction' (interaction) between a particle and a structure.
     // Returns True if the interaction was succesfull
     {
-        // Get the reaction rules for the interaction with this surface.
-        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), surface->sid() ));
+        // Get the reaction rules for the interaction with this structure.
+        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), structure->sid() ));
         if (::size(rules) == 0)
-            throw propagation_error("trying to fire an interaction with a surface without a reaction rule.");
+            throw propagation_error("trying to fire an interaction with a structure without a reaction rule.");
         
                 
-        const Real k_tot( k_total(pp.second.sid(), surface->sid()) );
+        const Real k_tot( k_total(pp.second.sid(), structure->sid()) );
         const Real rnd( k_tot * rng_() );
         Real k_cumm = 0;  
 
@@ -758,7 +782,7 @@ class newBDPropagator
                     case 0:
                     {
 
-                        tx_.remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
+                        remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
                         break;
                     }
                     // When one product particle
@@ -766,29 +790,30 @@ class newBDPropagator
                     {
                         const species_type product_species(tx_.get_species(products[0]));
 
-                        // Get the new position of the particle on the surface
-                        const position_type new_pos( tx_.apply_boundary( surface->projected_point( pp.second.position() ).first ) );
-                            
+                        // Get the new position of the particle on the structure
+                        const position_type product_pos( tx_.apply_boundary( structure->projected_point( pp.second.position() ).first ) );
+
+
+                        ///// Check for overlaps   
+                        const particle_shape_type new_shape(product_pos, product_species.radius());
                         // check for overlap with particles that are in the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
-                            tx_.check_overlap(particle_shape_type(new_pos, product_species.radius()), pp.first));
+                            tx_.check_overlap(new_shape, pp.first));
                         if (overlap_particles && overlap_particles->size() > 0)
                         {
                             throw propagation_error("no space");
                         }
-                        // check overlap with surfaces.
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
-                                tx_.check_surface_overlap(particle_shape_type(new_pos, product_species.radius()), new_pos, surface->id(), product_species.radius()));
-                        if (overlap_surfaces && overlap_surfaces->size() > 0)
+                        // check overlap with structures.
+                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
+                                tx_.check_surface_overlap(new_shape, product_pos, structure->id(), product_species.radius()));
+                        if (overlap_structures && overlap_structures->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");
                         }
                         // check for overlap with particles outside of the progator (e.g. the eGFRD simulator)
                         if (vc_)
                         {
-                            if (!(*vc_)(
-                                    particle_shape_type(new_pos, product_species.radius()), 
-                                    pp.first))
+                            if (!(*vc_)(new_shape, pp.first))
                             {
                                 throw propagation_error("no space (vc)");
                             }
@@ -796,8 +821,8 @@ class newBDPropagator
 
                         // Process changes
                         tx_.remove_particle(pp.first);
-                        // Make new particle in interaction surface 
-                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), surface->id(), new_pos) );
+                        // Make new particle in interaction structure 
+                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), structure->id(), product_pos) );
                         // Record changes
                         if (rrec_)
                         {
@@ -809,7 +834,7 @@ class newBDPropagator
                     }
                     // When number of products was not '0' or '1'
                     default:
-                        throw not_implemented("surface interactions that produce more than one product are not supported");
+                        throw not_implemented("structure interactions that produce more than one product are not supported");
                 }
                 // After we processed the reaction, we return -> no other reaction should be done.
                 return true;

From d4c348de69ce13e02afaf9e1c0ddf5079c7a5b24 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 27 Apr 2012 16:19:48 +0200
Subject: [PATCH 0826/1541] additional clarification/improvements to facilitate
 reactions from surfaces and edgecrossing.

---
 newBDPropagator.hpp | 178 ++++++++++++++++++++++++++++----------------
 1 file changed, 115 insertions(+), 63 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 78cdb1e0..643d90cd 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -151,8 +151,14 @@ class newBDPropagator
             // get 'connecting' structure and apply deflection. Should we do this recursively until the coordinate stays in the currents structure?
             // This actually kinda similar to the boundary condition application.
             new_pos = tx_.apply_boundary( add( old_pos, displacement ) );
+            if ( !(pp_structure->is_alongside(new_pos)) )
+            {
+                // TODO apply deflection and change structure_id with appropriate neighbor structure
+                //new_pos = ;
+                //new_structure_id = ;
+            }
+
 /*            const structure_id_type target_struct_id(pp_structure->get_target_structure(new_pos));
-            const structure_id_type target_struct_id(pp_structure->get_target_structure(new_pos));
 
             if (target_struct_id != pp_structure.id())
             // The particle jumped to a new position outside of the current surface.
@@ -426,7 +432,7 @@ class newBDPropagator
                             const structure_id_type product_structure_id (reactant_structure->structure_id());
 
                             product_pos_struct_id = std::make_pair(product_pos, product_structure_id);
-                            //Particle is allowed to move after dissociation from surface.
+                            // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
 
@@ -458,10 +464,9 @@ class newBDPropagator
 
 
                         // Process changes
-                        tx_.remove_particle(pp.first);
+                        remove_particle(pp.first);
                         // Make new particle on right surface
                         const particle_id_pair product_particle( tx_.new_particle(product_species.id(), product_pos_struct_id.second, product_pos_struct_id.first) );
-
                         // Record changes
                         if (rrec_)
                         {
@@ -477,9 +482,21 @@ class newBDPropagator
                     {
                         const position_type                             reactant_pos(pp.second.position());
                         const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
+                        const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure( reactant_structure->structure_id() ) );
                         
+                        // We set: species 0 lives on the current structure; species 1 lives in the parent structure (if applicable).
                         species_type product0_species(tx_.get_species(products[0]));
                         species_type product1_species(tx_.get_species(products[1]));
+                        if( product0_species.structure_type_id() != product1_species.structure_type_id() )
+                        {
+                            if( !(product0_species.structure_type_id() == parent_structure->sid() || 
+                                  product1_species.structure_type_id() == parent_structure->sid())  )
+                                throw not_implemented("One of product species should live on parent structure.");
+                                             
+                            if ( !(product0_species.structure_type_id() == reactant_structure->sid()) )
+                                std::swap(product0_species, product1_species);
+                        }
+
                         position_pair_type pos0pos1;
                         structure_id_type prod0_struct_id;
                         structure_id_type prod1_struct_id;
@@ -501,59 +518,73 @@ class newBDPropagator
 
                             /* If the product particles do NOT live on the same structure => structure -> structure + parent_structure dissociation.
                                Else, the products live on the same structure AND on the same structure as the reactant. 
-                               => standard geminate dissociation. 
-                               
-                            We set: species 0 lives on the current structure; species 1 lives in the parent structure. */
+                               => standard geminate dissociation. */
                             if( product0_species.structure_type_id() != product1_species.structure_type_id() )
                             {
-                                const boost::shared_ptr<const structure_type> parent_structure( tx_.get_structure( reactant_structure->structure_id() ) );
-                                if( !(product0_species.structure_type_id() == parent_structure->sid() || 
-                                      product1_species.structure_type_id() == parent_structure->sid())  )
-                                    throw not_implemented("One of product species should live on parent structure.");
-                                                 
-                                if ( !(product0_species.structure_type_id() == reactant_structure->sid()) )
-                                    std::swap(product0_species, product1_species);
-
+                                // TODO include structure_id in return_type of dissociation_positions
                                 pos0pos1 = reactant_structure-> special_geminate_dissociation_positions( rng_, product0_species, product1_species,
-                                                                                                              reactant_pos, reaction_length_ );
+                                                                                                         reactant_pos, reaction_length_ );
                                 prod0_struct_id = pp.second.structure_id();             // The 'original' structure
                                 prod1_struct_id = reactant_structure->structure_id();   // The parent structure
                             }
                             else
                             {
+                                // TODO include structure_id in return_type of dissociation_positions
                                 pos0pos1 = reactant_structure-> geminate_dissociation_positions( rng_, product0_species, product1_species,
-                                                                                                      reactant_pos, reaction_length_ );
+                                                                                                 reactant_pos, reaction_length_ );
                                 prod0_struct_id = pp.second.structure_id();         // same structure as the reactant
                                 prod1_struct_id = pp.second.structure_id();         // ditto
                             }
-                            // TODO check that the positions do not cross any edges.
                             pos0pos1.first  = tx_.apply_boundary( pos0pos1.first );
                             pos0pos1.second = tx_.apply_boundary( pos0pos1.second );
+
+                            // check that the positions do not cross any edges.
+                            const boost::shared_ptr<const structure_type> prod0_structure(reactant_structure);
+                            const boost::shared_ptr<const structure_type> prod1_structure(tx_.get_structure(prod1_struct_id));
+                            if ( !(prod0_structure->is_alongside(pos0pos1.first)))
+                            {
+                                // TODO deflect pos0pos1.first with right neigboring structure
+                            }
+                            if ( !(prod1_structure->is_alongside(pos0pos1.second)))
+                            {
+                                // TODO deflect pos0pos1.second with right neigboring structure
+                            }
+
                             pos0pos1_pair = std::make_pair(std::make_pair(pos0pos1.first, prod0_struct_id),
                                                            std::make_pair(pos0pos1.second, prod1_struct_id));
 
 
-                            // TODO make more efficient, don't do checking after one has failed.
+                            ////// Check for overlaps
+                            const particle_shape_type new_shape0(pos0pos1_pair.first.first, product0_species.radius());
                             // check overlap with particle in the propagator
                             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product0(
-                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.first.first, product0_species.radius()),  pp.first));
-                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product1(
-                                tx_.check_overlap( particle_shape_type(pos0pos1_pair.second.first, product1_species.radius()), pp.first));
-                                    
+                                    tx_.check_overlap( new_shape0,  pp.first));
+                            if (overlap_particles_product0 && overlap_particles_product0->size() > 0)
+                            {
+                                continue;   // try other positions pair
+                            }
                             /* Only when both products live in the bulk, check for possible overlap with a surface. */
                             const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product0(
-                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.first.first, product0_species.radius()), reactant_pos,
-                                                          pos0pos1_pair.first.second, product0_species.radius()));
+                                    tx_.check_surface_overlap(new_shape0, reactant_pos, pos0pos1_pair.first.second, product0_species.radius()));
+                            if (overlap_structures_product0 && overlap_structures_product0->size() > 0)
+                            {
+                                continue;   // try other positions pair
+                            }
+                            const particle_shape_type new_shape1(pos0pos1_pair.second.first, product1_species.radius());
+                            const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product1(
+                                    tx_.check_overlap( new_shape1, pp.first));
+                            if (overlap_particles_product1 && overlap_particles_product1->size() > 0)
+                            {
+                                continue;   // try other positions pair
+                            }
                             const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product1(
-                                tx_.check_surface_overlap(particle_shape_type(pos0pos1_pair.second.first, product1_species.radius()), reactant_pos,
-                                                          pos0pos1_pair.second.second, product1_species.radius()));
-
-                            // If the positions were allowed -> SUCCESS and leave the loop
-                            if ( !(overlap_particles_product0 && overlap_particles_product0->size() > 0) && 
-                                 !(overlap_particles_product1 && overlap_particles_product1->size() > 0) &&
-                                 !(overlap_structures_product0 && overlap_structures_product0->size() > 0) &&
-                                 !(overlap_structures_product1 && overlap_structures_product1->size() > 0)) 
-                                break;
+                                    tx_.check_surface_overlap(new_shape1, reactant_pos, pos0pos1_pair.second.second, product1_species.radius()));
+                            if (overlap_structures_product1 && overlap_structures_product1->size() > 0)
+                            {
+                                continue;   // try other positions pair
+                            }
+                            // If no overlap occured -> positions are ok
+                            break;
                         }
 
                         /* After dissociation both particles are allowed to move. */
@@ -570,8 +601,8 @@ class newBDPropagator
                         }
 
                         // Process changes
-                        tx_.remove_particle(pp.first);
-                        const particle_id_pair product0_particle(tx_.new_particle(product0_species.id(), pos0pos1_pair.first.second, pos0pos1_pair.first.first));
+                        remove_particle(pp.first);
+                        const particle_id_pair product0_particle(tx_.new_particle(product0_species.id(), pos0pos1_pair.first.second,  pos0pos1_pair.first.first));
                         const particle_id_pair product1_particle(tx_.new_particle(product1_species.id(), pos0pos1_pair.second.second, pos0pos1_pair.second.first));
 
                         // Record changes
@@ -646,13 +677,16 @@ class newBDPropagator
 
                         structure_id_type                   product_structure_id(reactant0_structure_id);
 
+                        // If the particles lived on adjacent structures of the same type
                         if ((s0.structure_type_id() == s1.structure_type_id()) &&
                             (reactant0_structure_id != reactant1_structure_id))
                         {
                             // deflect_back one of the coordinates.
-                            reactant1_pos = reactant0_structure->deflect_back(reactant1_pos, reactant1_structure->shape().unit_z());
+                            // TODO unit_z() is not accessible!
+//                            reactant1_pos = reactant0_structure->deflect_back(reactant1_pos, reactant1_structure->shape().unit_z());
                         }
 
+                        // calculate the product position (CoM of the two particles)
                         position_type product_pos( tx_.apply_boundary(
                                                     divide(
                                                     add(multiply(reactant0_pos, s1.D()),
@@ -664,6 +698,7 @@ class newBDPropagator
 
                         // For unequal structure types, project product_pos on the 'lesser' structure.
                         // The 'lesser' structure is the structure that is the lowest in the hierarchy of the two.
+                        // Note that this means that a reaction can only cross ONE hierarchical level of structures.
                         if( s0.structure_type_id() != s1.structure_type_id() )
                         {
 
@@ -683,17 +718,25 @@ class newBDPropagator
                                     tx_.cyclic_transpose( product_pos, product_structure->position() )));       // TODO check of cyclic transpose is still needed.
 
                             // check that the projected point is not outside of the product surface.
-                            if (product_structure->distance( position_on_surface.first) > 0)
+                            if ( !(product_structure->is_alongside( position_on_surface.first)) )
                                 throw propagation_error("position product particle was not in surface.");
 
                             product_pos = tx_.apply_boundary( position_on_surface.first );
                         }
-                        else if ((s0.structure_type_id() == s1.structure_type_id()) &&
-                                 (reactant0_structure_id != reactant1_structure_id))
+                        else
+                        // The structure_types are the same
                         {
-                            // deflect the product coordinate and get right structure_id.
-                            std::pair<position_type, bool> bla = reactant1_structure->deflect(reactant0_pos, subtract(product_pos, reactant0_pos));
-                            product_pos = bla.first;
+                            if (reactant0_structure_id != reactant1_structure_id)
+                            {
+                                // deflect the product coordinate and get right structure_id.
+                                std::pair<position_type, bool> bla = reactant1_structure->deflect(reactant0_pos, subtract(product_pos, reactant0_pos));
+                                if (bla.second)
+                                {
+                                    product_pos = bla.first;
+                                    product_structure_id = reactant1_structure_id;
+                                }
+
+                            }
                         }
 
 
@@ -804,6 +847,7 @@ class newBDPropagator
                             throw propagation_error("no space");
                         }
                         // check overlap with structures.
+                        // No need to include old structure as ignore because going down the structure hierarchy anyway.
                         const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
                                 tx_.check_surface_overlap(new_shape, product_pos, structure->id(), product_species.radius()));
                         if (overlap_structures && overlap_structures->size() > 0)
@@ -820,7 +864,7 @@ class newBDPropagator
                         }
 
                         // Process changes
-                        tx_.remove_particle(pp.first);
+                        remove_particle(pp.first);
                         // Make new particle in interaction structure 
                         const particle_id_pair product_particle( tx_.new_particle(product_species.id(), structure->id(), product_pos) );
                         // Record changes
@@ -856,21 +900,27 @@ class newBDPropagator
 
         if(species.D() != 0)
         {
-            const boost::shared_ptr<const structure_type> s0_struct( tx_.get_structure( new_structure_id ) );
+            const boost::shared_ptr<const structure_type> old_structure( tx_.get_structure( new_structure_id ) );
 
-            const position_type displacement( s0_struct->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
+            const position_type displacement( old_structure->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
             new_pos = tx_.apply_boundary( add( old_pos_struct_id.first, displacement ) );
-            // TODO apply deflection and change structure_id
-                        
+            if ( !(old_structure->is_alongside(new_pos)) )
+            {
+                // TODO apply deflection and change structure_id with appropriate neighbor structure
+                //new_pos = ;
+                //new_structure_id = ;
+            }
+        
             // See if it overlaps with any particles
+            const particle_shape_type new_shape(new_pos, species.radius());
             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles( 
-                    tx_.check_overlap( particle_shape_type(new_pos, species.radius()), ignore));
+                    tx_.check_overlap( new_shape, ignore));
             if (overlap_particles && overlap_particles->size() > 0)
                 return old_pos_struct_id;
 
             // See if it overlaps with any surfaces.
             const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
-                    tx_.check_surface_overlap(particle_shape_type(new_pos, species.radius()), old_pos_struct_id.first, s0_struct->id(), species.radius()));
+                    tx_.check_surface_overlap(new_shape, old_pos_struct_id.first, new_structure_id, species.radius())); // TODO include to ignore old_structure
             if (overlap_surfaces && overlap_surfaces->size() > 0)
                 return old_pos_struct_id;
         }    
@@ -882,12 +932,13 @@ class newBDPropagator
     /* Given a position pair and two species, the function generates two new 
        positions based on two moves drawn from the free propagator. */
     const posstructid_posstructid_pair_type make_pair_move(species_type const& s0, species_type const& s1,
-                                                           posstructid_posstructid_pair_type const& pos0_pos1, particle_id_type const& ignore) const
+                                                           posstructid_posstructid_pair_type const& posstruct0_posstruct1,
+                                                           particle_id_type const& ignore) const
     {
         const length_type min_distance_01( s0.radius() + s1.radius() );
         
-        position_structid_pair_type temp_pos0(pos0_pos1.first),
-                                    temp_pos1(pos0_pos1.second);
+        position_structid_pair_type temp_posstruct0(posstruct0_posstruct1.first),
+                                    temp_posstruct1(posstruct0_posstruct1.second);
         
         //Randomize which species moves first, and if there will be one or two moves. (50% of the cases)
         int  move_count( 1 + rng_.uniform_int(0, 1) );  // determine number of particles to move (1 or 2)
@@ -897,25 +948,25 @@ class newBDPropagator
             if( move_first )
             // Move the first particle
             {
-                temp_pos0 = make_move(s0, pos0_pos1.first, ignore);
-                // check for overlap with the second particle (and potentially revert move)
-                // TODO also revert structure_id in case of bounce
-                temp_pos0.first = tx_.distance(temp_pos0.first, temp_pos1.first) - min_distance_01 < 0 ? pos0_pos1.first.first : temp_pos0.first;
+                temp_posstruct0 = make_move(s0, posstruct0_posstruct1.first, ignore);
+                // check for overlap with the second particle and potentially revert move
+                if (tx_.distance(temp_posstruct0.first, temp_posstruct1.first) < min_distance_01)
+                    temp_posstruct0 = posstruct0_posstruct1.first;
             }                       
             else
             // Move the second particle
             {
-                temp_pos1 = make_move(s1, pos0_pos1.second, ignore);
-                // check for overlap with the first particle (and potentially revert move)
-                // TODO also revert structure_id in case of bounce
-                temp_pos1.first = tx_.distance(temp_pos1.first, temp_pos0.first) - min_distance_01 < 0 ? pos0_pos1.second.first : temp_pos1.first;
+                temp_posstruct1 = make_move(s1, posstruct0_posstruct1.second, ignore);
+                // check for overlap with the first particle and potentially revert move
+                if (tx_.distance(temp_posstruct1.first, temp_posstruct0.first) < min_distance_01)
+                    temp_posstruct1 = posstruct0_posstruct1.second;
             }
 
             // Swap what particle to move
             move_first = !move_first;
         }  
             
-        return std::make_pair(temp_pos0, temp_pos1);
+        return std::make_pair(temp_posstruct0, temp_posstruct1);
     }
 
 
@@ -938,7 +989,8 @@ class newBDPropagator
 
     void remove_particle(particle_id_type const& pid)
     // Removes a particle from the propagator and particle container.
-    // Note that this should only be called for the particles that are NOT processed currently (i.e. the particle that are just popped of the queue)
+    // Note that if the particle is no longer in the local list (we just popped it off and treating it currently), it will
+    // only be removed in the particle container (tx_)
     {
         LOG_DEBUG(("remove particle %s", boost::lexical_cast<std::string>(pid).c_str()));
 

From 969bf6dac34c68b0564347e7517b453efd4dcd30 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 27 Apr 2012 18:05:54 +0200
Subject: [PATCH 0827/1541] small fix to getting the shape position

---
 Region.hpp  | 2 +-
 Surface.hpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Region.hpp b/Region.hpp
index 747b77c9..6deedea3 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -108,7 +108,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     
     virtual position_type const& position() const
     {
-        return shape_.position();
+        return ::shape_position(shape());
     }
 
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const
diff --git a/Surface.hpp b/Surface.hpp
index f691d7db..52ec6c38 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -115,7 +115,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     
     virtual position_type const& position() const
     {
-        return shape_.position();
+        return ::shape_position(shape());
     }
 
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const

From 9f3cb941c50ad5f9791691458d7d05916b6de5d5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 27 Apr 2012 18:47:11 +0200
Subject: [PATCH 0828/1541] started work on
 StructureContainer/ConnectivityContainer

---
 ConnectionContainer.hpp | 151 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)
 create mode 100644 ConnectionContainer.hpp

diff --git a/ConnectionContainer.hpp b/ConnectionContainer.hpp
new file mode 100644
index 00000000..5cfae06f
--- /dev/null
+++ b/ConnectionContainer.hpp
@@ -0,0 +1,151 @@
+
+
+template
+// overloaded typedef so as to fix the length of the vectors for different shape types
+// -Cylinder n=2
+// -Plane n=4
+// -Box n=6
+
+
+
+template<typename StructureType_>
+class ConnectivityContainer
+// implements the way structures are connected.
+// It allows to to check what structure you enter into when you leave the current one.
+{
+    typedef typename StructureType_ structure_type;
+
+public:
+    position_structid_pair_type apply_boundary (position_structid_pair_type const& pos_structure_id) const
+    {
+        ::to_internal(structure_type::base_type.shape(), pos);
+    }
+
+private:
+    // mapping StructureID -> vector<(StructureID, index), max_index+1>
+
+};
+
+
+
+class StructureContainer
+{
+
+public:
+    add_structure (CylindricalSurface)  // can I make this into a template function?
+    {
+        // add to Connectivity container for cylindrical surfaces
+    }
+    add_structure (PlanarSurface)
+    {
+        // add to Connectivity container for planar surfaces
+    }
+    add_structure (CuboidalRegion)
+    {
+        // add to Connectivity container for planar surfaces
+    }
+
+    position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_structure_id) const
+    // Propagate these to the ParticleContainer such that world.apply_boundary( (pos, struct_id)) can be called
+    {
+    }
+    position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_structure_id) const
+    // This is essentially the deflect_back function
+    {
+    }
+
+    remove_structure (StructureID)
+    {
+        // find StructureID in all ConnectivityContainers -> remove references
+    }
+
+    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
+    {
+        typename structure_map::const_iterator i(structure_map_.find(id));
+        if (structure_map_.end() == i)
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
+    virtual bool update_structure(structure_id_pair const& structid_pair)
+    {
+        typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
+        if (i != structure_map_.end())
+        // The item was already found in the map
+        {
+            if ((*i).second->structure_id() != structid_pair.second->structure_id())
+            // If the structure had a different parent structure
+            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hierarchy)
+            {
+                structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
+                structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+            }
+            structure_map_[(*i).first] = structid_pair.second;
+            return false;
+        }
+
+        // The structure was not yet in the world.
+        // create a new item in the structure mapping
+        structure_map_[structid_pair.first] = structid_pair.second;
+        // add the id the mapping 'super_structure_id -> set of substructures'
+        structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+        // create a new mapping from structure id -> set of substructures
+        structure_substructures_map_[structid_pair.first] = structure_id_set();
+        return true;
+    }
+    virtual bool remove_structure(structure_id_type const& id)
+    {
+        // TODO
+        //  -get all the substructures of structure
+        //  -only remove if no substructures
+        return false;
+    }
+
+private:
+    structures_range get_structures_range() const
+    {
+        return structures_range(
+        structure_iterator(structure_map_.begin(), structures_second_selector_type()),
+        structure_iterator(structure_map_.end(),   structures_second_selector_type()),
+        structure_map_.size());
+    }
+    // Get all the structure ids of the substructures
+    structure_id_set get_substructure_ids(structure_id_type const& id) const
+    {
+        typename per_structure_substructure_id_set::const_iterator i(
+            structure_substructures_map_.find(id));
+        if (i == structure_substructures_map_.end())
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
+    structure_id_set get_visible_structures(structure_id_type const& id) const
+    {
+        structure_id_set visible_structures;
+
+        const boost::shared_ptr<const structure_type> structure(get_structure(id));
+        if (structure->structure_id() == id)
+        {
+            visible_structures = structure_id_set();
+        }
+        else
+        {
+            visible_structures = get_visible_structures(structure->structure_id());
+            visible_structures.erase(id);
+        }
+        const structure_id_set substructures (get_substructure_ids(id));
+        visible_structures.insert(substructures.begin(), substructures.end());
+        return visible_structures;
+    }
+
+protected:
+    structure_map                       structure_map_;     // mapping: structure_id -> structure
+    per_structure_substructure_id_set   structure_substructures_map_;
+
+    CylindricalSurfaceConnectivityContainer     // This contains a StructureID -> vector <(StructureID, index), 2> map
+    PlanarSurfaceConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 4> map
+    CuboidalReginConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 6> map
+
+};

From 6141a48015e6066f6ad4df7d115aaa9c00efe2eb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 2 May 2012 18:01:03 +0200
Subject: [PATCH 0829/1541] small cosmetic changes

---
 Plane.hpp | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index bab466e1..d7f45e4e 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -176,6 +176,8 @@ class Plane
 };
 
 
+///// Function below are inline functions that can be applied on Plane objects.
+
 template<typename T_>
 inline std::pair<typename Plane<T_>::position_type, bool>
 deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& d)
@@ -194,13 +196,13 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    position_type center_pt = obj.position();
    position_type u_x = obj.unit_x();
    position_type u_y = obj.unit_y();
-   position_type u_z = obj.unit_z();   
+   position_type u_z = obj.unit_z();
    
    // Variables used for calculation
    position_type intersect_pt;          // the point at which the displacement vector intersects the edge
    position_type d_out, d_edge, d_perp; // the part of the displacement ranging out of the plane and
                                         // the components parallel and perpendicular to the edge
-   position_type d_edge_n;              // normalized d_edge                                        
+   position_type d_edge_n;              // normalized d_edge
    position_type icv;                   // = intersect_to_center_vector
    position_type icv_edge, icv_perp;    // the components of icv parallel and perpendicular to the edge
    
@@ -266,19 +268,6 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    // for now this returns the new position without changes
    return std::make_pair( new_pos, changeflag );
 }
-template<typename T_>
-inline bool
-is_alongside(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// The function checks if the projection of the position 'pos' is 'inside' the object.
-{
-    typedef typename Plane<T_>::position_type position_type;
-
-    boost::array<typename Plane<T_>::length_type, 2> half_extends(obj.half_extent());
-    position_type pos_vector(subtract(pos, obj.position()));
-
-    return ((abs(dot_product(pos_vector, obj.unit_x())) < half_extends[0]) &&
-            (abs(dot_product(pos_vector, obj.unit_y())) < half_extends[1]));
-}
 
 template<typename T_>
 inline typename Plane<T_>::position_type
@@ -318,6 +307,20 @@ deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, t
     return projected_point(obj, r_new).first;
 }
 
+template<typename T_>
+inline bool
+is_alongside(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// The function checks if the projection of the position 'pos' is 'inside' the object.
+{
+    typedef typename Plane<T_>::position_type position_type;
+
+    boost::array<typename Plane<T_>::length_type, 2> half_extends(obj.half_extent());
+    position_type pos_vector(subtract(pos, obj.position()));
+
+    return ((abs(dot_product(pos_vector, obj.unit_x())) < half_extends[0]) &&
+            (abs(dot_product(pos_vector, obj.unit_y())) < half_extends[1]));
+}
+
 template<typename T_>
 inline boost::array<typename Plane<T_>::length_type, 3>
 to_internal(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)

From 1e3677ff030d9148a9f2cc48d4fbbecc33eab5f1 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 2 May 2012 18:02:09 +0200
Subject: [PATCH 0830/1541] mostly implemented the apply_boundary function for
 planes

---
 ConnectionContainer.hpp | 174 +++++++++++++++++++++++++++++++++++-----
 1 file changed, 156 insertions(+), 18 deletions(-)

diff --git a/ConnectionContainer.hpp b/ConnectionContainer.hpp
index 5cfae06f..ce9af0fe 100644
--- a/ConnectionContainer.hpp
+++ b/ConnectionContainer.hpp
@@ -1,5 +1,3 @@
-
-
 template
 // overloaded typedef so as to fix the length of the vectors for different shape types
 // -Cylinder n=2
@@ -8,26 +6,63 @@ template
 
 
 
-template<typename StructureType_>
+template<typename Ttraits, Tobj_, std::size_t max_neighbors>
 class ConnectivityContainer
 // implements the way structures are connected.
-// It allows to to check what structure you enter into when you leave the current one.
+// It allows you to check what structure you enter into when you leave the current one.
 {
-    typedef typename StructureType_ structure_type;
+public:
+    typedef typename Ttraits        traits_type;
+    typedef typename Tobj_          obj_type;
+    typedef typename std::size_t    size_type;
+    typedef typename traits_type::structure_id_type structure_id_type;
+    typedef typename traits_type::position_type     position_type;
+
+protected:
+    // the structureID of the neighbor and the normal vector pointing from the
+    // intersection in the direction of the center of the neighbor
+    typedef std::pair<structure_id_type, position_type>                     structure_id_vector_pair_type;
+    typedef boost::array<structure_id_vector_pair_type, max_neighbors>      structure_id_vector_array_type;
+    // the mapping from the structure and all its neighbors and how they are connected.
+    typedef std::map<structure_id_type, structure_id_vector_array_type>     structid_neighbor_pair_map;
+    typedef select_second<typename structid_neighbor_pair_map::value_type>  structid_neighbor_second_selector_type;
+    typedef boost::transform_iterator<structid_neighbor_second_selector_type,
+            typename structid_neighbor_pair_map::const_iterator>            structid_neighbor_iterator;
+
+public:
+    static const size_type max = max_neighbors;
 
 public:
-    position_structid_pair_type apply_boundary (position_structid_pair_type const& pos_structure_id) const
+    virtual bool add_neighbor_info(obj_type const& obj) = 0;
+
+    virtual structure_id_vector_pair_type get_neighbor_info(structure_id_type const& id, size_type const n) const
     {
-        ::to_internal(structure_type::base_type.shape(), pos);
+        // check that the index is not too large
+        if ( n>= max )
+            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + ")");
+
+        typename structid_neighbor_pair_map::const_iterator i(structid_neighbor_pair_map_.find(id));
+        if (structid_neighbor_pair_map_.end() == i)
+        {
+            throw not_found(std::string("Neighbor structure not found(id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second[n];
     }
 
-private:
-    // mapping StructureID -> vector<(StructureID, index), max_index+1>
+    virtual ConnectivityContainer()
+    // do we start with an empty container or do we construct it as a static object with n structures already connected.
 
+private:
+    // mapping StructureID -> array<(StructureID, vector3D), max_neighbors>
+    structid_neighbor_pair_map  neighbor_mapping_;
 };
 
 
 
+
+
+
+template <typename Ttraits>
 class StructureContainer
 {
 
@@ -45,15 +80,6 @@ class StructureContainer
         // add to Connectivity container for planar surfaces
     }
 
-    position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_structure_id) const
-    // Propagate these to the ParticleContainer such that world.apply_boundary( (pos, struct_id)) can be called
-    {
-    }
-    position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_structure_id) const
-    // This is essentially the deflect_back function
-    {
-    }
-
     remove_structure (StructureID)
     {
         // find StructureID in all ConnectivityContainers -> remove references
@@ -149,3 +175,115 @@ class StructureContainer
     CuboidalReginConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 6> map
 
 };
+
+
+
+//////// Inline functions applicable to the StructureContainer
+
+
+//// functions for Planes
+
+template<typename ConnectivityContainer<> >
+inline typename ConnectivityContainer::traits_type::position_structid_pair_type
+apply_boundary (StructureContainer const& sc, position_structid_pair_type const& pos_structure_id) const
+// The template needs to be parameterized with the appropriate shape (which then parameterizes the type
+// of the ConnectivityContainer that we use.
+// We supply the structure container as an argument so that we can get the structures that we need.
+// The connectivity container then needs to a part of the structure container such that we can also
+// query the boundary conditions and connectivity.
+{
+    // useful typedefs
+    typedef typename plane_type;
+    typedef typename plane_type::length_type    length_type;
+    typedef typename position_type;
+    typedef typename structure_id_type;
+    typedef typename position_structid_pair_type;
+
+    // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
+    const plane_type origin_plane (sc.get_structure(pos_structure_id.second)->shape());
+    boost::array<length_type, 2> half_extends(origin_plane.half_extent());
+    const length_type origin_length_x (2*half_extends[0]);
+    const length_type origin_length_y (2*half_extends[1]);
+
+    // TODO do cyclic transpose here first
+    const position_type pos_vector( subtract(pos_structure_id.first, origin_plane.position()) );
+    const length_type component_x ( dot_product(pos_vector, origin_plane.unit_x()) );
+    const length_type component_y ( dot_product(pos_vector, origin_plane.unit_y()) );
+
+    // declare the variables that will be written
+    structure_id_type new_id;
+    position_type neighbor_plane_par;
+    position_type neighbor_plane_inl;
+
+    if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
+         (-half_extends[1] < component_y) && ( component_y < half_extends[1]) )
+    {
+        // we are still in the plane (did not pass any of the boundaries)
+        // don't have to do anything
+        return pos_structure_id;
+    }
+    else if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
+              (half_extends[1] < component_y) )
+    {
+        // we are at the 'top' of the plane (side nr. 0)
+        // get the unit vector pointing from the edge between the two planes to the center of the plane
+        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 0).second);
+
+        new_id = neighbor_mapping_[pos_structure_id.second][0].first;
+        neighbor_plane_par = component_x * origin_plane.unit_x();
+        neighbor_plane_inl = (component_y - origin_length_y)* neighbor_plane_unit_inline;
+    }
+    else if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
+              (component_y < -half_extends[1] ) )
+    {
+        // we are at the 'bottom' of the plane (side nr. 1)
+        // get the unit vector pointing from the edge between the two planes to the center of the plane
+        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 1).second);
+
+        new_id = neighbor_mapping_[pos_structure_id.second][1].first;
+        neighbor_plane_par = component_x * origin_plane.unit_x();
+        neighbor_plane_inl = (-component_y - origin_length_y)* neighbor_plane_unit_inline;
+    }
+    else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
+              (component_x < -half_extends[0]) )
+    {
+        // we are at the 'left' of the plane (side nr. 2)
+        // get the unit vector pointing from the edge between the two planes to the center of the plane
+        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 2).second);
+
+        new_id = neighbor_mapping_[pos_structure_id.second][2].first;
+        neighbor_plane_par = component_y * origin_plane.unit_y();
+        neighbor_plane_inl = (-component_x - origin_length_x)* neighbor_plane_unit_inline;
+    }
+    else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
+              (half_extends[0] < component_x) )
+    {
+        // we are at the 'right' of the plane (side nr. 3)
+        // this is a unit vector pointing from the edge between the two planes to the center of the plane
+        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 3).second);
+
+        new_id = neighbor_mapping_[pos_structure_id.second][3].first;
+        neighbor_plane_par = component_y * origin_plane.unit_y();
+        neighbor_plane_inl = (component_x - origin_length_x)* neighbor_plane_unit_inline;
+    }
+    else
+    {
+        // we are somewhere in the corners and don't know what to do
+        // throw exception?
+    }
+
+    const position_type new_pos ( add(sc.get_structure(new_id)->position(),
+                                      add(neighbor_plane_par, neighbor_plane_inl)));
+    // TODO do normal apply_boundary too?
+    return std::make_pair(new_id, new_pos);
+}
+
+template<>
+inline
+cyclic_transpose
+
+
+
+///// Functions for Cylinders
+
+//// Functions for Boxes

From 3a1e9914fa6a8835f3061e0ffe080ee37d52f318 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 2 May 2012 18:29:55 +0200
Subject: [PATCH 0831/1541] moving structure stuff to structurecontainer

---
 ConnectionContainer.hpp   | 58 +++++++++++++++++++++++----------------
 ParticleContainerBase.hpp | 30 ++++++++++++++++----
 2 files changed, 58 insertions(+), 30 deletions(-)

diff --git a/ConnectionContainer.hpp b/ConnectionContainer.hpp
index ce9af0fe..3ef02ce9 100644
--- a/ConnectionContainer.hpp
+++ b/ConnectionContainer.hpp
@@ -65,6 +65,16 @@ class ConnectivityContainer
 template <typename Ttraits>
 class StructureContainer
 {
+public:
+    typedef typename structure_type;
+    typedef typename structure_id_type;
+    typedef typename structure_map;
+    typedef typename structures_range;
+    typedef typename structure_iterator;
+    typedef typename structures_second_selector_type;
+    typedef typename structure_id_pair;
+    typedef typename structure_id_set;
+    typedef typename per_structure_substructure_id_set;
 
 public:
     add_structure (CylindricalSurface)  // can I make this into a template function?
@@ -79,12 +89,12 @@ class StructureContainer
     {
         // add to Connectivity container for planar surfaces
     }
-
     remove_structure (StructureID)
     {
         // find StructureID in all ConnectivityContainers -> remove references
     }
 
+
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
@@ -94,6 +104,13 @@ class StructureContainer
         }
         return (*i).second;
     }
+    structures_range get_structures_range() const
+    {
+        return structures_range(
+        structure_iterator(structure_map_.begin(), structures_second_selector_type()),
+        structure_iterator(structure_map_.end(),   structures_second_selector_type()),
+        structure_map_.size());
+    }
     virtual bool update_structure(structure_id_pair const& structid_pair)
     {
         typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
@@ -127,26 +144,6 @@ class StructureContainer
         //  -only remove if no substructures
         return false;
     }
-
-private:
-    structures_range get_structures_range() const
-    {
-        return structures_range(
-        structure_iterator(structure_map_.begin(), structures_second_selector_type()),
-        structure_iterator(structure_map_.end(),   structures_second_selector_type()),
-        structure_map_.size());
-    }
-    // Get all the structure ids of the substructures
-    structure_id_set get_substructure_ids(structure_id_type const& id) const
-    {
-        typename per_structure_substructure_id_set::const_iterator i(
-            structure_substructures_map_.find(id));
-        if (i == structure_substructures_map_.end())
-        {
-            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
-        }
-        return (*i).second;
-    }
     structure_id_set get_visible_structures(structure_id_type const& id) const
     {
         structure_id_set visible_structures;
@@ -166,13 +163,26 @@ class StructureContainer
         return visible_structures;
     }
 
+private:
+    // Get all the structure ids of the substructures
+    structure_id_set get_substructure_ids(structure_id_type const& id) const
+    {
+        typename per_structure_substructure_id_set::const_iterator i(
+            structure_substructures_map_.find(id));
+        if (i == structure_substructures_map_.end())
+        {
+            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second;
+    }
+
 protected:
     structure_map                       structure_map_;     // mapping: structure_id -> structure
     per_structure_substructure_id_set   structure_substructures_map_;
 
-    CylindricalSurfaceConnectivityContainer     // This contains a StructureID -> vector <(StructureID, index), 2> map
-    PlanarSurfaceConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 4> map
-    CuboidalReginConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 6> map
+//    CylindricalSurfaceConnectivityContainer     // This contains a StructureID -> vector <(StructureID, index), 2> map
+//    PlanarSurfaceConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 4> map
+//    CuboidalReginConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 6> map
 
 };
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index ac93caae..df71595d 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -317,8 +317,8 @@ class ParticleContainerBase
         return pmat_.erase(id);
     }
 
-//////
-    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
+////// Structure stuff
+/*    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
         if (structure_map_.end() == i)
@@ -327,10 +327,24 @@ class ParticleContainerBase
         }
         return (*i).second;
     }
+*/
+    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
+    {
+        return structures_.get_structure(id);
+    }
     virtual structures_range get_structures() const
     {
-        return get_structures_range();
+        return structures_.get_structures_range();
+    }
+    virtual bool update_structure(structure_id_pair const& structid_pair)
+    {
+        return structures_.update_structure(structid_pair);
+    }
+    virtual bool remove_structure(structure_id_type const& id)
+    {
+        return structures_.remove_structure(id);
     }
+/*
     virtual bool update_structure(structure_id_pair const& structid_pair)
     {
         typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
@@ -364,11 +378,12 @@ class ParticleContainerBase
         //  -only remove if no substructures
         return false;
     }
+*/
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
-        const structure_id_set visible_structures (get_visible_structures(current_struct_id));
+        const structure_id_set visible_structures (structures_.get_visible_structures(current_struct_id));
 
         structure_map temp_map;
         for (typename structure_id_set::const_iterator i(visible_structures.begin()),
@@ -391,9 +406,10 @@ class ParticleContainerBase
 
 ///////// Member variables
 protected:
-    particle_matrix_type pmat_;         // just the structure (MatrixSpace) containing the particles.
-
+    particle_matrix_type        pmat_;         // just the structure (MatrixSpace) containing the particles.
+    structure_container_type    structures_;
 
+/*
 
 ///////// The following are public and private methods and variables of the class but should maybe be made into a separate class
 //        (and not a part of ParticleContainerBase).
@@ -439,6 +455,8 @@ class ParticleContainerBase
     structure_map                       structure_map_;     // mapping: structure_id -> structure
     per_structure_substructure_id_set   structure_substructures_map_;
 };
+*/
+
 
 //////// Inline methods are defined separately
 template<typename Tderived_, typename Ttraits_>

From fc468273c02b64925f14ad8798698411544f7b1b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 May 2012 19:04:17 +0200
Subject: [PATCH 0832/1541] Forgot to add new files to last commits

---
 Disk.hpp               | 268 +++++++++++++++++++++++++++++++++++++++++
 binding/Disk.hpp       |  78 ++++++++++++
 binding/disk_class.cpp |  15 +++
 binding/disk_class.hpp |  10 ++
 4 files changed, 371 insertions(+)
 create mode 100644 Disk.hpp
 create mode 100644 binding/Disk.hpp
 create mode 100644 binding/disk_class.cpp
 create mode 100644 binding/disk_class.hpp

diff --git a/Disk.hpp b/Disk.hpp
new file mode 100644
index 00000000..1a2d6263
--- /dev/null
+++ b/Disk.hpp
@@ -0,0 +1,268 @@
+#ifndef DISK_HPP
+#define DISK_HPP
+
+#include <ostream>
+#include <cmath>
+#include "Vector3.hpp"
+#include "Shape.hpp"
+
+template<typename T_>
+class Disk
+{
+public:
+    typedef T_ value_type;
+    typedef Vector3<T_> position_type;
+    typedef T_ length_type;
+
+public:
+    // constructors
+    Disk()
+        : position_(), radius_(0), unit_z_() {}
+
+    Disk(position_type const& position, length_type const& radius,
+             position_type const& unit_z)
+        : position_(position), radius_(radius), unit_z_(unit_z) {}
+
+    
+    bool operator==(const Disk& rhs) const
+    {
+        return position_ == rhs.position() && radius_ == rhs.radius() && unit_z_ == rhs.unit_z();
+    }
+
+    bool operator!=(const Disk& rhs) const
+    {
+        return !operator==(rhs);
+    }
+
+    position_type const& position() const
+    {
+        return position_;
+    }
+
+    position_type& position()
+    {
+        return position_;
+    }
+
+    length_type const& radius() const
+    {
+        return radius_;
+    }
+
+    length_type& radius()
+    {
+        return radius_;
+    }
+
+    position_type const& unit_z() const
+    {
+        return unit_z_;
+    }
+
+    position_type& unit_z()
+    {
+        return unit_z_;
+    }
+
+    std::string show(int precision)
+    {
+        std::ostringstream strm;
+        strm.precision(precision);
+        strm << *this;
+        return strm.str();
+    }
+
+/////// Member variables
+private:
+    position_type position_;    // centre.
+    length_type radius_;
+    position_type unit_z_;      // Z-unit_z. should be normalized.
+};
+
+
+//////// Inline functions
+template<typename Tstrm_, typename T_>
+inline std::basic_ostream<Tstrm_>& operator<<(std::basic_ostream<Tstrm_>& strm,
+        const Disk<T_>& v)
+{
+    strm << "{" << v.position() <<  ", " << v.radius() << ", " << v.unit_z() << ", " << "}";
+    return strm;
+}
+
+template<typename T_>
+inline std::pair<typename Disk<T_>::length_type,
+                 typename Disk<T_>::length_type>
+to_internal(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
+{
+    // Same as for the cylinder:
+    // Return pos relative to position of the disk.
+    typedef typename Disk<T_>::position_type position_type;
+    typedef typename Disk<T_>::length_type length_type;
+
+    const position_type pos_vector(subtract(pos, obj.position()));
+    // z can be < 0
+    const length_type z(dot_product(pos_vector, obj.unit_z()));
+    // r is always >= 0
+    const length_type r(length(pos_vector - multiply(obj.unit_z(), z)));
+
+    return std::make_pair(r, z);
+}
+
+template<typename T_>
+inline std::pair<typename Disk<T_>::position_type,
+                 typename Disk<T_>::length_type>
+projected_point(Disk<T_> const& obj,
+                typename Disk<T_>::position_type const& pos)
+{
+    typedef typename Disk<T_>::length_type length_type;
+
+    // The disk is in principle a 1D object:
+    // Projecting onto the disk means projecting onto its center.
+    // The distance is the z-component returned by to_internal().
+    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    
+    return std::make_pair( obj.position(), r_z.second);
+}
+
+// The same as in case of the plane: projected_point_on_surface = projected_point
+template<typename T_>
+inline std::pair<typename Disk<T_>::position_type,
+                 typename Disk<T_>::length_type>
+projected_point_on_surface(Disk<T_> const& obj,
+                typename Disk<T_>::position_type const& pos)
+{
+    return projected_point(obj, pos);
+}
+
+template<typename T_>
+inline typename Disk<T_>::length_type
+distance(Disk<T_> const& obj,
+                typename Disk<T_>::position_type const& pos)
+{
+    typedef typename Disk<T_>::position_type position_type;
+    typedef typename Disk<T_>::length_type length_type;
+
+    /* First compute the (r,z) components of pos in a coordinate system 
+     * defined by the vectors unitR and unit_z, where unitR is
+     * choosen such that unitR and unit_z define a plane in which
+     * pos lies. */
+    const std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+
+    /* Then compute distance to cylinder with zero length. */
+    const length_type dz(std::fabs(r_z.second));
+    const length_type dr(r_z.first - obj.radius());
+    length_type distance;
+
+    if (r_z.first > obj.radius())
+    {
+        // pos is not above the disk.
+        // Compute distance to edge.
+        distance = std::sqrt( dz * dz + dr * dr );
+    }
+    else
+    {
+        // pos is above the disk.
+        distance = dz;
+    }
+
+    return distance;
+}
+
+template<typename T_>
+inline std::pair<typename Disk<T_>::position_type, bool>
+deflect(Disk<T_> const& obj,
+        typename Disk<T_>::position_type const& r0,
+        typename Disk<T_>::position_type const& d  )
+{
+    // Displacements are not deflected on disks (yet),
+    // but this function has to be defined for every shape to be used in structure.
+    // For now it just returns original pos. + displacement. The changeflage = false.
+    return std::make_pair( add(r0, d), false );
+}
+
+template<typename T_>
+inline typename Disk<T_>::position_type
+deflect_back(Disk<T_> const& obj,
+        typename Disk<T_>::position_type const& r,
+        typename Disk<T_>::position_type const& u_z  )
+{
+    // Return the vector r without any changes
+    return r;
+}
+
+template<typename T, typename Trng>
+inline typename Disk<T>::position_type
+random_position(Disk<T> const& shape, Trng& rng)
+{
+    // The disk has only one "legal" position = its center
+    return shape.position();
+}
+
+template<typename T_>
+inline Disk<T_> const& shape(Disk<T_> const& shape)
+{
+    return shape;
+}
+
+template<typename T_>
+inline Disk<T_>& shape(Disk<T_>& shape)
+{
+    return shape;
+}
+
+template<typename T_>
+struct is_shape<Disk<T_> >: public boost::mpl::true_ {};
+
+template<typename T_>
+struct shape_position_type<Disk<T_> >
+{
+    typedef typename Disk<T_>::position_type type;
+};
+
+template<typename T_>
+struct shape_length_type<Disk<T_> > {
+    typedef typename Disk<T_>::length_type type;
+};
+
+template<typename T>
+inline typename shape_length_type<Disk<T> >::type const& shape_size(Disk<T> const& shape)
+{
+    return shape.radius();
+} 
+
+template<typename T>
+inline typename shape_length_type<Disk<T> >::type& shape_size(Disk<T>& shape)
+{
+    return shape.radius();
+} 
+
+#if defined(HAVE_TR1_FUNCTIONAL)
+namespace std { namespace tr1 {
+#elif defined(HAVE_STD_HASH)
+namespace std {
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+namespace boost {
+#endif
+
+template<typename T_>
+struct hash<Disk<T_> >
+{
+    typedef Disk<T_> argument_type;
+
+    std::size_t operator()(argument_type const& val)
+    {
+        return hash<typename argument_type::position_type>()(val.position()) ^
+            hash<typename argument_type::length_type>()(val.radius()) ^
+            hash<typename argument_type::position_type>()(val.unit_z());
+    }
+};
+
+#if defined(HAVE_TR1_FUNCTIONAL)
+} } // namespace std::tr1
+#elif defined(HAVE_STD_HASH)
+} // namespace std
+#elif defined(HAVE_BOOST_FUNCTIONAL_HASH_HPP)
+} // namespace boost
+#endif
+
+#endif /* DISK_HPP */
diff --git a/binding/Disk.hpp b/binding/Disk.hpp
new file mode 100644
index 00000000..6a44de9c
--- /dev/null
+++ b/binding/Disk.hpp
@@ -0,0 +1,78 @@
+#ifndef BINDING_DISK_HPP
+#define BINDING_DISK_HPP
+
+#include <boost/python.hpp>
+#include "peer/utils.hpp"
+
+namespace binding {
+
+// A template to perform string conversions?
+template<typename Timpl_>
+static std::string Disk___str__(Timpl_* impl)
+{
+    return boost::lexical_cast<std::string>(*impl);
+}
+
+
+////// Registering master function
+template<typename Timpl_>
+inline boost::python::objects::class_base register_disk_class(char const* name)
+{
+    using namespace boost::python;
+    typedef Timpl_ impl_type;
+
+    return class_<impl_type>(name)
+        .def(init<typename impl_type::position_type, 
+                  typename impl_type::length_type,
+                  typename impl_type::position_type, 
+                  typename impl_type::length_type>())
+        .add_property("position",
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::position_type,
+                    &impl_type::position,
+                    &impl_type::position>::get,
+                return_value_policy<return_by_value>()),
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::position_type,
+                    &impl_type::position,
+                    &impl_type::position>::set))
+        .add_property("radius",
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::length_type,
+                    &impl_type::radius,
+                    &impl_type::radius>::get,
+                return_value_policy<return_by_value>()),
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::length_type,
+                    &impl_type::radius,
+                    &impl_type::radius>::set))        
+        .add_property("unit_z",
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::position_type,
+                    &impl_type::unit_z,
+                    &impl_type::unit_z>::get,
+                return_value_policy<return_by_value>()),
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::position_type,
+                    &impl_type::unit_z,
+                    &impl_type::unit_z>::set))
+        .def("__str__", &Disk___str__<impl_type>)
+        .def("show", &impl_type::show);
+
+}
+
+} // namespace binding
+
+#endif /* BINDING_DISK_HPP */
diff --git a/binding/disk_class.cpp b/binding/disk_class.cpp
new file mode 100644
index 00000000..237b71ac
--- /dev/null
+++ b/binding/disk_class.cpp
@@ -0,0 +1,15 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif /* HAVE_CONFIG_H */
+
+#include "Disk.hpp"
+#include "binding_common.hpp"
+
+namespace binding {
+
+void register_disk_class()
+{
+    register_disk_class<Disk>("Disk");
+}
+
+} // namespace binding
diff --git a/binding/disk_class.hpp b/binding/disk_class.hpp
new file mode 100644
index 00000000..82f38e50
--- /dev/null
+++ b/binding/disk_class.hpp
@@ -0,0 +1,10 @@
+#ifndef BINDING_DISK_CLASS_HPP
+#define BINDING_DISK_CLASS_HPP
+
+namespace binding {
+
+void register_disk_class();
+
+} // namespace binding
+
+#endif /* BINDING_DISK_CLASS_HPP */

From 71a03daeaf71e092b02c6ae816110a24c8041330 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 May 2012 19:04:53 +0200
Subject: [PATCH 0833/1541] Basic implementation of DiskStructure

---
 DiskSurface.hpp         | 243 ++++++++++++++++++++++++++++++++++++++++
 binding/DiskSurface.hpp |  28 +++++
 2 files changed, 271 insertions(+)
 create mode 100644 DiskSurface.hpp
 create mode 100644 binding/DiskSurface.hpp

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
new file mode 100644
index 00000000..3330c39c
--- /dev/null
+++ b/DiskSurface.hpp
@@ -0,0 +1,243 @@
+#ifndef DISK_SURFACE_HPP
+#define DISK_SURFACE_HPP
+
+#include <boost/bind.hpp>
+#include "Surface.hpp"
+#include "Disk.hpp"
+#include "freeFunctions.hpp"
+#include "geometry.hpp"
+
+template<typename Ttraits_>
+class DiskSurface
+    : public BasicSurfaceImpl<Ttraits_, Disk<typename Ttraits_::world_type::traits_type::length_type> >
+{
+    // The DiskSurface is the implementation of a Basic surface parameterized with a Disk
+
+public:
+    typedef BasicSurfaceImpl<Ttraits_, Disk<typename Ttraits_::world_type::traits_type::length_type> > base_type;
+    typedef typename base_type::traits_type             traits_type;
+    typedef typename base_type::identifier_type         identifier_type;        // This is just the name of the structure
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
+    typedef typename base_type::shape_type              shape_type;
+    typedef typename base_type::rng_type                rng_type;
+    typedef typename base_type::position_type           position_type;
+    typedef typename base_type::length_type             length_type;
+    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef std::pair<position_type, position_type>     position_pair_type;
+
+    virtual position_type random_position(rng_type& rng) const
+    // Gives a "random position" in the disk, which is always its center,
+    // the only "legal" position
+    {
+        return ::random_position(base_type::shape(), boost::bind(&rng_type::uniform, rng, -1., 1.));
+        // return base_type::shape().position(); // TODO maybe this variant is better
+    }
+
+    virtual position_type random_vector(length_type const& r, rng_type& rng) const
+    // Gives a "random vector" on the disk; returns the same as random_position()
+    {
+        return base_type::shape().position();
+    }
+
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
+    // BD displacement = zero vector because there is only one legal position on the disk
+    {
+        return multiply(base_type::shape().unit_z(), 0.0);
+    }
+
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
+    {
+         // TODO: This is part of the old BD scheme and should be removed at some point
+        return drawR_gbd_1D(rnd, r01, dt, D01, v);
+    }
+
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
+    {
+        // TODO: This is part of the old BD scheme and should be removed at some point
+        /*
+            The I_bd factors used for calculating the acceptance probability are dependent on the direction 
+            of the overlap step (r = r_1 - r_0), compared to the direction of the drift. 
+            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0).
+            Since the I_bd terms calulated here are for the backward move, we have to invert their drifts.
+            When the particle comes from the left (r > 0) we have to invert its drift again.
+
+            ---Code below is used for drift dependent backstep.
+
+            Real numerator = g_bd_1D(ipv, r01, dt, D0, -v0);
+            Real denominator = g_bd_1D(ipv, r01, dt, D0, v0)*exp( ipv/abs_ipv*(abs_ipv - r01)*v/D01 );
+            Real correction = numerator/denominator;
+            if( ipv < 0 )
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, -v0) + I_bd_1D(r01, dt, D1, v1) ) );
+            else
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, -v1) ) );
+
+            Also change v -> -v in drawR for the dissociation move.
+        */
+
+        return 0.5*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
+  
+    }
+
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
+    {
+        // TODO: This is part of the old BD scheme and should be removed at some point
+        return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
+    }
+    
+    virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
+    {
+        // This rate does not make sense on the ("zero-dimensional") disk object
+        // but is used to determine the maximal time step in a Multi object and
+        // therefore should be defined in a proper way.
+        return 0.0;
+    }
+    
+    virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
+    {
+        return k;
+    }
+
+    virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
+    {
+        // The disk can only hold 1 particle; this function therefore never should be called.
+        return rl;
+    }
+
+    virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
+    {        
+        // The reaction volume for a particle on the rod interacting with a disk;
+        // should be the same as for two particles interacting with each other on the rod.
+        return rl;
+    }
+    
+    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
+    {
+        // This function produces a position for a particle unbinding from the disk onto the rod.
+        // It should lie within the reaction volume around the disk.
+        // TODO: We have to make a distinction between sink and cap already here!
+        Real X( rng.uniform(0.,1.) );
+        length_type const rod_radius = base_type::shape().radius();
+        position_type const unit_z = base_type::shape().unit_z();
+
+        length_type const rrl( rod_radius + r0 + rl );
+        length_type const rrl_sq( gsl_pow_2(rrl) );
+        length_type const rr_sq( gsl_pow_2(rod_radius + r0) );
+        
+        length_type const diss_vec_length( sqrt( X * (rrl_sq - rr_sq) + rr_sq ) );
+
+        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);        
+        v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
+         
+        return multiply( v, diss_vec_length); 
+    }
+
+    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
+        length_type const& rl ) const
+    {
+        // The positions of a particle dissociating into two new ones on the disk; should never happen,
+        // therefore this function just returns a dummy positions pair (2x the disk center)        
+        
+        return position_pair_type( base_type::shape().position(), base_type::shape().position() );
+    }
+    
+    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
+        position_type const& op_surf, length_type const& rl ) const
+    {
+        // TODO 
+        // This function produces two new positions for a dissociating particle in the case
+        // that one stays on the surface and the other one changes to the parent structure.
+        // We have to distinguish between sink and cap here and between dissociation onto
+        // the rod and into the bulk for the cap!
+        
+        Real const rod_radius( base_type::shape().radius() );
+        
+        //Species living on the rod should have a larger radius than the rod.
+        assert( rod_radius < s_surf.radius() );
+    
+        length_type const r01( s_bulk.radius() + s_surf.radius() );
+        Real const D01( s_bulk.D() + s_surf.D() );
+        Real const D_bulk_D01( s_bulk.D() / D01 );
+        Real const D_surf_D01( s_surf.D() / D01 );
+        
+        //Commented code for direct binding case with c.o.m. reaction.
+        //Real const theta_min( asin(rod_radius / r01) );       
+        Real const theta_min( asin( (rod_radius + s_bulk.radius()) / r01) );       
+        Real const theta( theta_min + rng.uniform(0.,1.) * (M_PI - 2 * theta_min) );  
+        Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
+        
+        Real const X( rng.uniform(0.,1.) );
+        length_type const r01l( r01 + rl );
+        length_type const r01l_cb( r01l * r01l * r01l );
+        length_type const r01_cb( r01 * r01 * r01 );
+        
+        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb) + r01_cb ) );
+        
+        position_type v;
+        v[0] = 1.; v[1] = 1.; v[2] = 1.;
+        
+        position_type const unit_z( base_type::shape().unit_z() );      
+        position_type const unit_x( normalize( subtract( v, 
+                                        multiply( unit_z, dot_product(v, unit_z) ) ) ) );
+        position_type const unit_y( normalize( cross_product( unit_x, unit_z ) ) );
+                
+        length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
+        length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
+        length_type const z( diss_vec_length * cos( theta ) );
+                                
+        position_pair_type pp01;
+        
+        pp01.first = subtract( op_surf, unit_z * (z * D_surf_D01) );
+        
+        pp01.second = add( op_surf, 
+                        add( unit_x * x,
+                          add( unit_y * y, 
+                                 unit_z * (z * D_bulk_D01) ) ) );
+        
+        return pp01;
+    }
+
+    /* Determine if particle has crossed the 'surface' of the structure. */
+    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
+        length_type const& dist_to_surface, length_type const& particle_radius) const
+    {       
+        // TODO Remove this after merge with newest development version!
+        if( dist_to_surface < particle_radius )
+            return true;
+        else
+            return false;
+    }
+    
+    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
+    {
+        // TODO Remove this after merge with newest development version!
+        if( dist_to_surface - particle_radius <= rl )
+            return true;
+        else
+            return false;
+    }
+
+    virtual length_type minimal_distance(length_type const& radius) const
+    {
+        // TODO
+        length_type cylinder_radius = base_type::shape().radius();
+        // Return minimal distance *to* surface.
+        return (cylinder_radius + radius) * traits_type::MINIMAL_SEPARATION_FACTOR - cylinder_radius;
+    }
+
+    virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
+    {
+        visitor(*this);
+    }
+
+    virtual void accept(MutativeStructureVisitor<traits_type> const& visitor)
+    {
+        visitor(*this);
+    }
+
+    DiskSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
+        : base_type(id, sid, shape) {}
+};
+
+#endif /* DISK_SURFACE_HPP */
diff --git a/binding/DiskSurface.hpp b/binding/DiskSurface.hpp
new file mode 100644
index 00000000..6f6efa35
--- /dev/null
+++ b/binding/DiskSurface.hpp
@@ -0,0 +1,28 @@
+#ifndef BINDING_DISK_SURFACE_HPP
+#define BINDING_DISK_SURFACE_HPP
+
+#include <boost/python.hpp>
+
+namespace binding {
+
+
+////// Registering master function
+template<typename Timpl>
+inline boost::python::objects::class_base register_disk_surface_class(char const *name)
+{
+    using namespace boost::python;
+    typedef Timpl impl_type;
+
+    return class_<impl_type, bases<typename impl_type::base_type::base_type>,
+           boost::shared_ptr<impl_type>, boost::noncopyable>(
+            name, init<typename impl_type::identifier_type,
+                       typename impl_type::structure_type_id_type,
+                       typename impl_type::shape_type>())
+        .add_property("shape",
+            make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
+        ;
+}
+
+} // namespace binding
+
+#endif /* BINDING_DISK_SURFACE_HPP */

From a8a8b6196b821a2343cd22a3811abadfabeaaa30 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 May 2012 19:05:41 +0200
Subject: [PATCH 0834/1541] Binding for Disk and DiskStructure objects

---
 binding/binding_common.hpp    | 1 +
 binding/structure_classes.cpp | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index a6778622..57ba0ecb 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -104,6 +104,7 @@ typedef EGFRDSimulator::region_type                 Region;
 typedef EGFRDSimulator::planar_surface_type         PlanarSurface;
 typedef EGFRDSimulator::spherical_surface_type      SphericalSurface;
 typedef EGFRDSimulator::cylindrical_surface_type    CylindricalSurface;
+typedef EGFRDSimulator::disk_surface_type           DiskSurface;
 typedef EGFRDSimulator::cuboidal_region_type        CuboidalRegion;
 
 typedef EGFRDSimulatorTraits::reaction_record_type ReactionRecord;
diff --git a/binding/structure_classes.cpp b/binding/structure_classes.cpp
index a3fe82f2..dd2cd3a9 100644
--- a/binding/structure_classes.cpp
+++ b/binding/structure_classes.cpp
@@ -8,6 +8,7 @@
 #include "Region.hpp"
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
+#include "DiskSurface.hpp"
 #include "SphericalSurface.hpp"
 #include "CuboidalRegion.hpp"
 #include "binding_common.hpp"
@@ -24,6 +25,7 @@ void register_structure_classes()
     register_planar_surface_class<PlanarSurface>("PlanarSurface");
     register_spherical_surface_class<SphericalSurface>("SphericalSurface");
     register_cylindrical_surface_class<CylindricalSurface>("CylindricalSurface");
+    register_disk_surface_class<DiskSurface>("DiskSurface");
 }
 
 } // namespace binding

From 46539a81e0cd7cbb1a4b2f6e003391a4e1a4c1c3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 May 2012 19:06:25 +0200
Subject: [PATCH 0835/1541] Implementation of disk objects into EGFRDSimulator
 and ParticleSimulator

---
 EGFRDSimulator.hpp    | 31 +++++++++++++++++++++++++++++++
 ParticleSimulator.hpp |  8 ++++++++
 2 files changed, 39 insertions(+)

diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index c831a1d2..e43f37f8 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -170,6 +170,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
     typedef typename base_type::particle_simulation_structure_type particle_simulation_structure_type;
     typedef typename base_type::spherical_surface_type spherical_surface_type;
     typedef typename base_type::cylindrical_surface_type cylindrical_surface_type;
+    typedef typename base_type::disk_surface_type disk_surface_type;
     typedef typename base_type::planar_surface_type planar_surface_type;
     typedef typename base_type::cuboidal_region_type cuboidal_region_type;
     typedef typename traits_type::world_type world_type;
@@ -1470,6 +1471,21 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
                 new_single = new cylindrical_single_type(did, p, new_shell);
                 kind = CYLINDRICAL_SINGLE;
             }
+            
+            virtual void operator()(disk_surface_type const& structure) const
+            {
+                // This is only a copy of the operator for
+                // cylindrical_surface_type for now;
+                // TODO: Is that really what we want?
+                const cylindrical_shell_id_pair new_shell(
+                    _this->new_shell(
+                        did, cylinder_type(
+                            p.second.position(), p.second.radius(),
+                            structure.shape().unit_z(),
+                            p.second.radius())));
+                new_single = new cylindrical_single_type(did, p, new_shell);
+                kind = CYLINDRICAL_SINGLE;
+            }
 
             virtual void operator()(planar_surface_type const& structure) const
             {
@@ -1552,6 +1568,21 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
                 kind = CYLINDRICAL_PAIR;
             }
 
+            virtual void operator()(disk_surface_type const& structure) const
+            {
+                // This is only a copy of the operator for
+                // cylindrical_surface_type for now;
+                // TODO: Is that really what we want?
+                cylindrical_shell_id_pair const new_shell(
+                    _this->new_shell(did, cylinder_type(
+                        com,
+                        shell_size,
+                        shape(structure).unit_z(),
+                        std::max(p0.second.radius(), p1.second.radius()))));
+                new_pair = new cylindrical_pair_type(did, p0, p1, new_shell,
+                                                     iv, rules);
+                kind = CYLINDRICAL_PAIR;
+            }
         
             virtual void operator()(planar_surface_type const& structure) const
             {
diff --git a/ParticleSimulator.hpp b/ParticleSimulator.hpp
index 47102594..a287cb86 100644
--- a/ParticleSimulator.hpp
+++ b/ParticleSimulator.hpp
@@ -11,6 +11,7 @@
 #include "CuboidalRegion.hpp"
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
+#include "DiskSurface.hpp"
 #include "SphericalSurface.hpp"
 #include "NetworkRules.hpp"
 #include "NetworkRulesWrapper.hpp"
@@ -52,6 +53,7 @@ struct ImmutativeStructureVisitor
     typedef Ttraits_ traits_type;
     typedef typename ParticleSimulator<traits_type>::spherical_surface_type     spherical_surface_type;
     typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename ParticleSimulator<traits_type>::disk_surface_type          disk_surface_type;
     typedef typename ParticleSimulator<traits_type>::planar_surface_type        planar_surface_type;
     typedef typename ParticleSimulator<traits_type>::cuboidal_region_type       cuboidal_region_type;
 
@@ -61,6 +63,8 @@ struct ImmutativeStructureVisitor
     virtual void operator()(spherical_surface_type const&) const = 0;
 
     virtual void operator()(cylindrical_surface_type const&) const = 0;
+    
+    virtual void operator()(disk_surface_type const&) const = 0;
 
     virtual void operator()(planar_surface_type const&) const = 0;
 
@@ -73,6 +77,7 @@ struct MutativeStructureVisitor
     typedef Ttraits_ traits_type;
     typedef typename ParticleSimulator<traits_type>::spherical_surface_type     spherical_surface_type;
     typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename ParticleSimulator<traits_type>::disk_surface_type          disk_surface_type;
     typedef typename ParticleSimulator<traits_type>::planar_surface_type        planar_surface_type;
     typedef typename ParticleSimulator<traits_type>::cuboidal_region_type       cuboidal_region_type;
 
@@ -82,6 +87,8 @@ struct MutativeStructureVisitor
     virtual void operator()(spherical_surface_type&) const = 0;
 
     virtual void operator()(cylindrical_surface_type&) const = 0;
+    
+    virtual void operator()(disk_surface_type const&) const = 0;
 
     virtual void operator()(planar_surface_type&) const = 0;
 
@@ -106,6 +113,7 @@ class ParticleSimulator
     typedef Region<traits_type>                         region_type;
     typedef SphericalSurface<traits_type>               spherical_surface_type;
     typedef CylindricalSurface<traits_type>             cylindrical_surface_type;
+    typedef DiskSurface<traits_type>                    disk_surface_type;
     typedef PlanarSurface<traits_type>                  planar_surface_type;
     typedef CuboidalRegion<traits_type>                 cuboidal_region_type;
 

From 1d10dcba61876846579cddb561afcc4f9e4a0ea7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 May 2012 12:51:39 +0200
Subject: [PATCH 0836/1541] Implement DiskStructure constructor in
 StructureUtils.hpp

---
 StructureUtils.hpp | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index a4fce0b2..a9726d50 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -26,10 +26,12 @@ struct StructureUtils
     typedef typename simulator_type::region_type                region_type;
     typedef typename simulator_type::sphere_type                sphere_type;
     typedef typename simulator_type::cylinder_type              cylinder_type;
+    typedef typename simulator_type::disk_type                  disk_type;
     typedef typename simulator_type::box_type                   box_type;
     typedef typename simulator_type::plane_type                 plane_type;
     typedef typename simulator_type::spherical_surface_type     spherical_surface_type;
     typedef typename simulator_type::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename simulator_type::disk_surface_type          disk_surface_type;
     typedef typename simulator_type::planar_surface_type        planar_surface_type;
     typedef typename simulator_type::cuboidal_region_type       cuboidal_region_type;
     typedef typename simulator_type::world_type::traits_type::rng_type rng_type;
@@ -86,6 +88,19 @@ struct StructureUtils
         return new cylindrical_surface_type(id, sid,
                 cylinder_type(pos, radius, unit_z, half_length));
     }
+    
+    static disk_surface_type* create_disk_surface(
+            structure_type_id_type const& sid,
+            structure_id_type const& id,
+            position_type const& center,
+            length_type const& radius,
+            position_type const& unit_z)
+    {
+        BOOST_ASSERT(is_cartesian_versor(unit_z));
+
+        return new disk_surface_type(id, sid,
+                disk_type(center, radius, unit_z));
+    }
 
     static cuboidal_region_type* create_cuboidal_region(
             structure_type_id_type const& sid,

From 024f81c73b8d0b0ecf0f2115dcafd01ab366be9b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 May 2012 15:52:48 +0200
Subject: [PATCH 0837/1541] Further necessary changes for binding of Disk stuff

---
 Makefile.am         | 1 +
 binding/Disk.hpp    | 3 +--
 binding/Makefile.am | 4 ++++
 pyGFRD.cpp          | 2 ++
 4 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 29abf30e..51ae519c 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -53,6 +53,7 @@ noinst_HEADERS = \
 	Box.hpp\
 	ConsoleAppender.hpp\
 	Cylinder.hpp\
+	Disk.hpp\
 	Defs.hpp\
 	DomainFactory.hpp\
 	Domain.hpp\
diff --git a/binding/Disk.hpp b/binding/Disk.hpp
index 6a44de9c..65560922 100644
--- a/binding/Disk.hpp
+++ b/binding/Disk.hpp
@@ -24,8 +24,7 @@ inline boost::python::objects::class_base register_disk_class(char const* name)
     return class_<impl_type>(name)
         .def(init<typename impl_type::position_type, 
                   typename impl_type::length_type,
-                  typename impl_type::position_type, 
-                  typename impl_type::length_type>())
+                  typename impl_type::position_type>())
         .add_property("position",
             make_function(
                 &peer::util::reference_accessor_wrapper<
diff --git a/binding/Makefile.am b/binding/Makefile.am
index 79bc6ed8..547ad700 100644
--- a/binding/Makefile.am
+++ b/binding/Makefile.am
@@ -20,6 +20,9 @@ noinst_HEADERS = \
 	cylinder_class.hpp \
 	Cylinder.hpp \
 	CylindricalSurface.hpp \
+	disk_class.hpp \
+	Disk.hpp \
+	DiskSurface.hpp \
 	domain_classes.hpp \
 	domain_id_class.hpp \
 	egfrd_simulator_classes.hpp \
@@ -97,6 +100,7 @@ libbinding_utils_la_SOURCES = \
 	box_class.cpp \
 	ConsoleAppender.cpp \
 	cylinder_class.cpp \
+	disk_class.cpp \
 	domain_classes.cpp \
 	domain_id_class.cpp \
 	egfrd_simulator_classes.cpp \
diff --git a/pyGFRD.cpp b/pyGFRD.cpp
index a55f9797..fc252791 100644
--- a/pyGFRD.cpp
+++ b/pyGFRD.cpp
@@ -32,6 +32,7 @@
 #include "binding/binding_common.hpp"
 #include "binding/box_class.hpp"
 #include "binding/cylinder_class.hpp"
+#include "binding/disk_class.hpp"
 #include "binding/domain_id_class.hpp"
 #include "binding/domain_classes.hpp"
 #include "binding/egfrd_simulator_classes.hpp"
@@ -107,6 +108,7 @@ BOOST_PYTHON_MODULE(_gfrd)
     b::register_spherical_shell_container_class();
     b::register_plane_class();
     b::register_cylinder_class();
+    b::register_disk_class();
     b::register_cylindrical_shell_container_class();
     b::register_network_rules_class();
     b::register_network_rules_wrapper_class();

From d6ea203ee3ee4e061c7f0bc4a3cddff5981e2045 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 May 2012 15:53:13 +0200
Subject: [PATCH 0838/1541] Including create_disk_surface into model.py +
 binding

---
 binding/module_functions.cpp |  2 ++
 model.py                     | 28 +++++++++++++++++++++++++++-
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/binding/module_functions.cpp b/binding/module_functions.cpp
index 552c2be2..38049e49 100644
--- a/binding/module_functions.cpp
+++ b/binding/module_functions.cpp
@@ -51,6 +51,8 @@ void register_module_functions()
             return_value_policy<manage_new_object>());
     def("create_cylindrical_surface", &StructureUtils::create_cylindrical_surface,
             return_value_policy<manage_new_object>());
+    def("create_disk_surface", &StructureUtils::create_disk_surface,
+            return_value_policy<manage_new_object>());
     def("create_cuboidal_region", &StructureUtils::create_cuboidal_region,
             return_value_policy<manage_new_object>());
     def("_random_vector", (Position(*)(Structure const&, Length const&, GSLRandomNumberGenerator&))&StructureUtils::random_vector);
diff --git a/model.py b/model.py
index 12b72dde..8bd19e6f 100644
--- a/model.py
+++ b/model.py
@@ -1,6 +1,6 @@
 import _gfrd
 from _gfrd import create_cuboidal_region, create_cylindrical_surface, \
-        create_planar_surface
+        create_disk_surface, create_planar_surface
 import numpy
 
 __all__ = [
@@ -18,6 +18,7 @@
     # From _gfrd. Should be part of the world class.
     'create_cuboidal_region',
     'create_cylindrical_surface',
+    'create_disk_surface',
     'create_planar_surface',
     ]
 
@@ -71,6 +72,31 @@
 
 """
 
+_gfrd.create_disk_surface.__doc__ = \
+"""create_disk_surface(sid, id, center, radius, orientation)
+
+Create and return a new disk Surface.
+
+Arguments:
+    - sid
+        the structure type of the cylindrical surface.
+    - id
+        the name of the structure
+    - center
+        The center point of the circle defining the disk.
+        Units: [meters, meters, meters]
+    - radius
+        the radius of the disk. Units: meters.
+    - orientation
+        the unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1]
+        perpendicular to the disk. This vector typically defines
+        the direction of dissociation from the disk if it is a
+        cap.
+
+Surfaces are not allowed to touch or overlap.
+
+"""
+
 _gfrd.create_planar_surface.__doc__ = \
 """create_planar_surface(sid, id, corner, unit_x, unit_y, length_x, length_y)
 

From 42f29f05fd6a58529148d532e72a61eeeb7982eb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 May 2012 16:07:04 +0200
Subject: [PATCH 0839/1541] Moving stuff from the ConnectionContainer to the
 StructureContainer

---
 ...ionContainer.hpp => StructureContainer.hpp | 61 ++++++++++++-------
 1 file changed, 40 insertions(+), 21 deletions(-)
 rename ConnectionContainer.hpp => StructureContainer.hpp (88%)

diff --git a/ConnectionContainer.hpp b/StructureContainer.hpp
similarity index 88%
rename from ConnectionContainer.hpp
rename to StructureContainer.hpp
index 3ef02ce9..761e546d 100644
--- a/ConnectionContainer.hpp
+++ b/StructureContainer.hpp
@@ -1,11 +1,11 @@
-template
-// overloaded typedef so as to fix the length of the vectors for different shape types
-// -Cylinder n=2
-// -Plane n=4
-// -Box n=6
-
+#ifndef STRUCTURE_CONTAINER_HPP
+#define STRUCTURE_CONTAINER_HPP
 
+#include <boost/lexical_cast.hpp>
+#include "exceptions.hpp"
+#include "linear_algebra.hpp"
 
+/*
 template<typename Ttraits, Tobj_, std::size_t max_neighbors>
 class ConnectivityContainer
 // implements the way structures are connected.
@@ -57,27 +57,37 @@ class ConnectivityContainer
     structid_neighbor_pair_map  neighbor_mapping_;
 };
 
+*/
 
 
 
 
-
-template <typename Ttraits>
+template <typename Tobj_, typename Tid_>
 class StructureContainer
 {
 public:
-    typedef typename structure_type;
-    typedef typename structure_id_type;
-    typedef typename structure_map;
-    typedef typename structures_range;
-    typedef typename structure_iterator;
-    typedef typename structures_second_selector_type;
-    typedef typename structure_id_pair;
-    typedef typename structure_id_set;
-    typedef typename per_structure_substructure_id_set;
+    typedef Tobj_              structure_type;
+    typedef Tid_               structure_id_type;
+    typedef std::set<structure_id_type>                                             structure_id_set;
+    typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >         structure_map;
+
+protected:
+    typedef select_second<typename structure_map::value_type>                       structures_second_selector_type;
+    typedef boost::transform_iterator<structures_second_selector_type,
+            typename structure_map::const_iterator>                                 structure_iterator;
+    typedef typename std::map<structure_id_type, structure_id_set>                  per_structure_substructure_id_set;
 
 public:
-    add_structure (CylindricalSurface)  // can I make this into a template function?
+    typedef sized_iterator_range<structure_iterator>                                structures_range;
+
+
+public:
+    virtual ~StructureContainer() {};
+
+    StructureContainer() {};
+
+/*    add_structure (CylindricalSurface)  // can I make this into a template function?
     {
         // add to Connectivity container for cylindrical surfaces
     }
@@ -94,7 +104,12 @@ class StructureContainer
         // find StructureID in all ConnectivityContainers -> remove references
     }
 
-
+*/
+    virtual bool has_structure(structure_id_type const& id) const
+    {
+        typename structure_map::const_iterator i(structure_map_.find(id));
+        return i != structure_map_.end();
+    }
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
@@ -185,7 +200,7 @@ class StructureContainer
 //    CuboidalReginConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 6> map
 
 };
-
+/*
 
 
 //////// Inline functions applicable to the StructureContainer
@@ -292,8 +307,12 @@ template<>
 inline
 cyclic_transpose
 
-
+*/
 
 ///// Functions for Cylinders
 
 //// Functions for Boxes
+
+
+#endif /* STRUCTURE_CONTAINER_HPP */
+

From 4a8891c8f6e8b5905799d0789ee9d62adfe0a376 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 May 2012 16:08:37 +0200
Subject: [PATCH 0840/1541] making use of the new StructureContainer

---
 Makefile.am               |  1 +
 ParticleContainerBase.hpp | 19 +++++++++++++------
 World.hpp                 | 11 +++++++----
 3 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index 29abf30e..695c67b6 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -118,6 +118,7 @@ noinst_HEADERS = \
 	SphericalBesselTable.hpp\
 	Structure.hpp\
     StructureID.hpp\
+    StructureContainer.hpp\
 	StructureUtils.hpp\
 	StructureType.hpp\
 	Surface.hpp\
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index df71595d..2d5456c5 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -8,6 +8,7 @@
 #include "generator.hpp"
 #include "exceptions.hpp"
 #include "ParticleContainer.hpp"
+#include "StructureContainer.hpp"
 #include "Transaction.hpp"
 
 template<typename Ttraits_>
@@ -120,16 +121,18 @@ class ParticleContainerBase
     typedef std::pair<particle_id_pair, length_type>                    particle_id_pair_and_distance;
     typedef sized_iterator_range<typename particle_matrix_type::const_iterator> particle_id_pair_range;
 
+    typedef StructureContainer<structure_type, structure_id_type>       structure_container_type;
+
     typedef typename base_type::particle_id_pair_and_distance_list                              particle_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance_list                             structure_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance                                  structure_id_pair_and_distance;
 
 protected:
 // Implementation of the methods.
-    typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
-    typedef boost::transform_iterator<structures_second_selector_type,
-            typename structure_map::const_iterator>                         structure_iterator;
-    typedef std::map<structure_id_type, structure_id_set>                   per_structure_substructure_id_set;
+//    typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
+//    typedef boost::transform_iterator<structures_second_selector_type,
+//            typename structure_map::const_iterator>                         structure_iterator;
+//    typedef std::map<structure_id_type, structure_id_set>                   per_structure_substructure_id_set;
 
 public:
     ParticleContainerBase(length_type world_size, size_type size)
@@ -245,7 +248,7 @@ class ParticleContainerBase
                                                                        length_type const& sigma) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
-        const structure_id_set visible_structures (get_visible_structures(current));
+        const structure_id_set visible_structures (structures_.get_visible_structures(current));
 
         structure_map temp_map;
         for (typename structure_id_set::const_iterator i(visible_structures.begin()),
@@ -328,6 +331,10 @@ class ParticleContainerBase
         return (*i).second;
     }
 */
+    virtual bool has_structure(structure_id_type const& id) const
+    {
+        return structures_.has_structure(id);
+    }
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         return structures_.get_structure(id);
@@ -454,8 +461,8 @@ class ParticleContainerBase
 protected:
     structure_map                       structure_map_;     // mapping: structure_id -> structure
     per_structure_substructure_id_set   structure_substructures_map_;
-};
 */
+};
 
 
 //////// Inline methods are defined separately
diff --git a/World.hpp b/World.hpp
index 09eebc93..eb2a0547 100644
--- a/World.hpp
+++ b/World.hpp
@@ -375,8 +375,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // update structure
     virtual bool update_structure(structure_id_pair const& structid_pair)
     {
-        typename base_type::structure_map::const_iterator i(base_type::structure_map_.find(structid_pair.first));
-        if (i != base_type::structure_map_.end())
+//        typename base_type::structure_map::const_iterator i(base_type::structure_container_type::structure_map_.find(structid_pair.first));
+//        if (i != base_type::structure_container_type::structure_map_.end())
+
+        if ( base_type::has_structure(structid_pair.first) )
         // The item was already found
         {
             // FIXME what to do when the structure has particles and moves or changes structure_type?!?!
@@ -384,10 +386,11 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             //  get all particles on the structure
             //  assert that no particles if structure type changes.
 
-            if ((*i).second->sid() != structid_pair.second->sid())
+            const boost::shared_ptr<const structure_type> structure (base_type::get_structure(structid_pair.first));
+            if (structure->sid() != structid_pair.second->sid())
             // If the structuretype changed we need to update the 'structure_type_id->structure ids' mapping
             {
-                structure_pool_[(*i).second->sid()].erase((*i).first);
+                structure_pool_[structure->sid()].erase(structure->id());
                 structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
             }
             base_type::update_structure(structid_pair);

From b081fb9929668e21892c173bd60434398d689c3d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 May 2012 16:53:09 +0200
Subject: [PATCH 0841/1541] moved the setting of the default structure to the
 structurecontainer

---
 ParticleContainerBase.hpp |  2 ++
 StructureContainer.hpp    | 22 ++++++++++++++++++++--
 World.hpp                 | 16 ++++------------
 3 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 2d5456c5..2882d9f5 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -137,6 +137,8 @@ class ParticleContainerBase
 public:
     ParticleContainerBase(length_type world_size, size_type size)
         : pmat_(world_size, size) {}
+    ParticleContainerBase(length_type world_size, size_type size, structure_id_type default_structid)
+        : pmat_(world_size, size), structures_(default_structid) {}
     // constructor
 
     virtual size_type num_particles() const
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 761e546d..681045b0 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -85,7 +85,10 @@ class StructureContainer
 public:
     virtual ~StructureContainer() {};
 
-    StructureContainer() {};
+    StructureContainer(structure_id_type default_structid) : default_structure_id_(default_structid)
+    {
+        structure_substructures_map_[default_structid] = structure_id_set();
+    }
 
 /*    add_structure (CylindricalSurface)  // can I make this into a template function?
     {
@@ -105,6 +108,20 @@ class StructureContainer
     }
 
 */
+    virtual structure_id_type get_def_structure_id() const
+    {
+        return default_structure_id_;
+    }
+    void set_def_structure(const boost::shared_ptr<structure_type> structure)
+    {
+        // check that the structure_type is the default structure_type
+        if ( structure->structure_id() != default_structure_id_)
+        {
+            throw illegal_state("Default structure doesn't have right properties");
+        }
+        structure->set_id(default_structure_id_);
+        update_structure(std::make_pair(default_structure_id_, structure));
+    }
     virtual bool has_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
@@ -119,7 +136,7 @@ class StructureContainer
         }
         return (*i).second;
     }
-    structures_range get_structures_range() const
+    virtual structures_range get_structures_range() const
     {
         return structures_range(
         structure_iterator(structure_map_.begin(), structures_second_selector_type()),
@@ -194,6 +211,7 @@ class StructureContainer
 protected:
     structure_map                       structure_map_;     // mapping: structure_id -> structure
     per_structure_substructure_id_set   structure_substructures_map_;
+    structure_id_type                   default_structure_id_;
 
 //    CylindricalSurfaceConnectivityContainer     // This contains a StructureID -> vector <(StructureID, index), 2> map
 //    PlanarSurfaceConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 4> map
diff --git a/World.hpp b/World.hpp
index eb2a0547..6b5b96c9 100644
--- a/World.hpp
+++ b/World.hpp
@@ -252,12 +252,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 public:
     // The constructor
     World(length_type world_size = 1., size_type size = 1)
-        : base_type(world_size, size), default_structure_id_(structidgen_())
-    {
-        // Make sure that the mapping for the default structure already exists.
-        // FIXME this is kinda ugly, but didn't want to add another argument to the base_type constructor
-        base_type::structure_substructures_map_[default_structure_id_] = structure_id_set();
-    }
+        : base_type(world_size, size, structidgen_()) {}
 
     // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
@@ -427,22 +422,19 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // Get and set the default structure of the World
     virtual structure_id_type get_def_structure_id() const
     {
-        return default_structure_id_;
+        return base_type::structures_.get_def_structure_id();
     }
     void set_def_structure(const boost::shared_ptr<structure_type> structure)
     {
         // check that the structure_type is the default structure_type
         if (!default_structure_type_id_ ||
-            (structure->sid() != default_structure_type_id_) || 
-            (structure->structure_id() != default_structure_id_) )
+            (structure->sid() != default_structure_type_id_) )
         {
             throw illegal_state("Default structure doesn't have right properties");
         }
         // check that the structure_type that is defined in the structure exists!
         structure_type_type const& structure_type(get_structure_type(structure->sid()));
-
-        structure->set_id(default_structure_id_);
-        update_structure(std::make_pair(default_structure_id_, structure));
+        base_type::structures_.set_def_structure(structure);
     }
     // Get the closest surface(surface is a subclass of structures)
     // TODO change this to get all the surfaces within a certain distance of the particle.

From ae07c659e405710c4c0fc8cd8c8a13dbe781c7a4 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 May 2012 16:59:31 +0200
Subject: [PATCH 0842/1541] cleanup of commented out code

---
 ParticleContainerBase.hpp | 110 +++-----------------------------------
 World.hpp                 |   4 --
 2 files changed, 6 insertions(+), 108 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 2882d9f5..59933bc2 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -127,19 +127,13 @@ class ParticleContainerBase
     typedef typename base_type::structure_id_pair_and_distance_list                             structure_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance                                  structure_id_pair_and_distance;
 
-protected:
-// Implementation of the methods.
-//    typedef select_second<typename structure_map::value_type>               structures_second_selector_type;
-//    typedef boost::transform_iterator<structures_second_selector_type,
-//            typename structure_map::const_iterator>                         structure_iterator;
-//    typedef std::map<structure_id_type, structure_id_set>                   per_structure_substructure_id_set;
 
 public:
-    ParticleContainerBase(length_type world_size, size_type size)
-        : pmat_(world_size, size) {}
+//    ParticleContainerBase(length_type world_size, size_type size)
+//        : pmat_(world_size, size) {}
     ParticleContainerBase(length_type world_size, size_type size, structure_id_type default_structid)
         : pmat_(world_size, size), structures_(default_structid) {}
-    // constructor
+    // constructors
 
     virtual size_type num_particles() const
     {
@@ -322,17 +316,7 @@ class ParticleContainerBase
         return pmat_.erase(id);
     }
 
-////// Structure stuff
-/*    virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
-    {
-        typename structure_map::const_iterator i(structure_map_.find(id));
-        if (structure_map_.end() == i)
-        {
-            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
-        }
-        return (*i).second;
-    }
-*/
+    ///// Structure stuff
     virtual bool has_structure(structure_id_type const& id) const
     {
         return structures_.has_structure(id);
@@ -353,41 +337,6 @@ class ParticleContainerBase
     {
         return structures_.remove_structure(id);
     }
-/*
-    virtual bool update_structure(structure_id_pair const& structid_pair)
-    {
-        typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
-        if (i != structure_map_.end())
-        // The item was already found in the map
-        {
-            if ((*i).second->structure_id() != structid_pair.second->structure_id())
-            // If the structure had a different parent structure
-            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hierarchy)
-            {
-                structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
-                structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
-            }
-            structure_map_[(*i).first] = structid_pair.second;
-            return false;
-        }
-
-        // The structure was not yet in the world.
-        // create a new item in the structure mapping
-        structure_map_[structid_pair.first] = structid_pair.second;
-        // add the id the mapping 'super_structure_id -> set of substructures'
-        structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
-        // create a new mapping from structure id -> set of substructures
-        structure_substructures_map_[structid_pair.first] = structure_id_set();
-        return true;
-    }
-    virtual bool remove_structure(structure_id_type const& id)
-    {
-        // TODO
-        //  -get all the substructures of structure
-        //  -only remove if no substructures
-        return false;
-    }
-*/
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const
     {
@@ -415,55 +364,8 @@ class ParticleContainerBase
 
 ///////// Member variables
 protected:
-    particle_matrix_type        pmat_;         // just the structure (MatrixSpace) containing the particles.
-    structure_container_type    structures_;
-
-/*
-
-///////// The following are public and private methods and variables of the class but should maybe be made into a separate class
-//        (and not a part of ParticleContainerBase).
-private:
-    structures_range get_structures_range() const
-    {
-        return structures_range(
-        structure_iterator(structure_map_.begin(), structures_second_selector_type()),
-        structure_iterator(structure_map_.end(),   structures_second_selector_type()),
-        structure_map_.size());
-    }
-    // Get all the structure ids of the substructures
-    structure_id_set get_substructure_ids(structure_id_type const& id) const
-    {
-        typename per_structure_substructure_id_set::const_iterator i(
-            structure_substructures_map_.find(id));
-        if (i == structure_substructures_map_.end())
-        {
-            throw not_found(std::string("Unknown structure (id=") + boost::lexical_cast<std::string>(id) + ")");
-        }
-        return (*i).second;
-    }
-    structure_id_set get_visible_structures(structure_id_type const& id) const
-    {
-        structure_id_set visible_structures;
-
-        const boost::shared_ptr<const structure_type> structure(get_structure(id));
-        if (structure->structure_id() == id)
-        {
-            visible_structures = structure_id_set();
-        }
-        else
-        {
-            visible_structures = get_visible_structures(structure->structure_id());
-            visible_structures.erase(id);
-        }
-        const structure_id_set substructures (get_substructure_ids(id));
-        visible_structures.insert(substructures.begin(), substructures.end());
-        return visible_structures;
-    }
-
-protected:
-    structure_map                       structure_map_;     // mapping: structure_id -> structure
-    per_structure_substructure_id_set   structure_substructures_map_;
-*/
+    particle_matrix_type        pmat_;          // the structure (MatrixSpace) containing the particles.
+    structure_container_type    structures_;    // an object containing the structures.
 };
 
 
diff --git a/World.hpp b/World.hpp
index 6b5b96c9..840f72d1 100644
--- a/World.hpp
+++ b/World.hpp
@@ -370,14 +370,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     // update structure
     virtual bool update_structure(structure_id_pair const& structid_pair)
     {
-//        typename base_type::structure_map::const_iterator i(base_type::structure_container_type::structure_map_.find(structid_pair.first));
-//        if (i != base_type::structure_container_type::structure_map_.end())
-
         if ( base_type::has_structure(structid_pair.first) )
         // The item was already found
         {
             // FIXME what to do when the structure has particles and moves or changes structure_type?!?!
-            // FIXME Or what to do when the structure has substructures?!
             //  get all particles on the structure
             //  assert that no particles if structure type changes.
 

From 140415c7bf1a446a593ab95736e209238a3dd30c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 May 2012 18:19:14 +0200
Subject: [PATCH 0843/1541] cleaned up ConnectivityContainer template class

---
 StructureContainer.hpp | 57 ++++++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 27 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 681045b0..4596952e 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -5,60 +5,63 @@
 #include "exceptions.hpp"
 #include "linear_algebra.hpp"
 
-/*
-template<typename Ttraits, Tobj_, std::size_t max_neighbors>
+
+template<typename Tobj_, typename Tdata_, std::size_t num_neighbors>
 class ConnectivityContainer
-// implements the way structures are connected.
+// implements the datastructure of objects that each have exactly 'num_neighbors' neighbors and have Tdata_ data associated
+// with each edge from the one of the object to the other.
+// NOTE the edges to neighbors are MANDATORY and have a specific ORDER.
+
 // It allows you to check what structure you enter into when you leave the current one.
 {
 public:
-    typedef typename Ttraits        traits_type;
-    typedef typename Tobj_          obj_type;
-    typedef typename std::size_t    size_type;
-    typedef typename traits_type::structure_id_type structure_id_type;
-    typedef typename traits_type::position_type     position_type;
+    typedef Tobj_          obj_type;               // is in our case the StructureID
+    typedef Tdata_         data_type;              // is the normal vector into the neighboring structure
+    typedef std::size_t    size_type;              // the type for the index in the array
+
+    typedef std::pair<obj_type, data_type>                                          obj_data_pair_type;
 
 protected:
     // the structureID of the neighbor and the normal vector pointing from the
     // intersection in the direction of the center of the neighbor
-    typedef std::pair<structure_id_type, position_type>                     structure_id_vector_pair_type;
-    typedef boost::array<structure_id_vector_pair_type, max_neighbors>      structure_id_vector_array_type;
+    typedef boost::array<obj_data_pair_type, num_neighbors>                         obj_data_pair_array_type;
     // the mapping from the structure and all its neighbors and how they are connected.
-    typedef std::map<structure_id_type, structure_id_vector_array_type>     structid_neighbor_pair_map;
-    typedef select_second<typename structid_neighbor_pair_map::value_type>  structid_neighbor_second_selector_type;
-    typedef boost::transform_iterator<structid_neighbor_second_selector_type,
-            typename structid_neighbor_pair_map::const_iterator>            structid_neighbor_iterator;
+    typedef std::map<obj_type, obj_data_pair_array_type>                            obj_neighbor_objdata_array_map;
+    typedef select_second<typename obj_neighbor_objdata_array_map::value_type>      obj_neighbor_objdata_second_selector_type;
+    typedef boost::transform_iterator<obj_neighbor_objdata_second_selector_type,
+            typename obj_neighbor_objdata_array_map::const_iterator>                obj_neighbor_objdata_array_iterator;
 
 public:
-    static const size_type max = max_neighbors;
+    static const size_type max = num_neighbors;
 
 public:
-    virtual bool add_neighbor_info(obj_type const& obj) = 0;
+    void set_neighbor_info(obj_type const& obj, size_type const n, obj_data_pair_type const& obj_data_pair)
+    {
+        neighbor_mapping_[obj][n] = obj_data_pair;
+    }
 
-    virtual structure_id_vector_pair_type get_neighbor_info(structure_id_type const& id, size_type const n) const
+    obj_data_pair_type get_neighbor_info(obj_type const& id, size_type const n) const
     {
         // check that the index is not too large
-        if ( n>= max )
-            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + ")");
+        if ( n >= max )
+            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
 
-        typename structid_neighbor_pair_map::const_iterator i(structid_neighbor_pair_map_.find(id));
-        if (structid_neighbor_pair_map_.end() == i)
+        typename obj_neighbor_objdata_array_map::const_iterator i(neighbor_mapping_.find(id));
+        if (neighbor_mapping_.end() == i)
         {
-            throw not_found(std::string("Neighbor structure not found(id=") + boost::lexical_cast<std::string>(id) + ")");
+            throw not_found(std::string("Object not found(id=") + boost::lexical_cast<std::string>(id) + ")");
         }
         return (*i).second[n];
     }
 
-    virtual ConnectivityContainer()
+    ConnectivityContainer() {}
     // do we start with an empty container or do we construct it as a static object with n structures already connected.
 
 private:
-    // mapping StructureID -> array<(StructureID, vector3D), max_neighbors>
-    structid_neighbor_pair_map  neighbor_mapping_;
+    // mapping StructureID -> array<(StructureID, vector3D), num_neighbors>
+    obj_neighbor_objdata_array_map  neighbor_mapping_;
 };
 
-*/
-
 
 
 

From 090a254a89d38e8de1f05f0126e29764251ed7d6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 May 2012 19:10:08 +0200
Subject: [PATCH 0844/1541] Enable visual logging for disk objects

---
 visualization/vtklogger.py | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 020a227d..b77c8020 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -2,7 +2,7 @@
 import shutil
 import numpy
 from vtk_xml_serial_unstructured import *
-from _gfrd import Sphere, Cylinder, Box, Plane
+from _gfrd import Sphere, Cylinder, Box, Plane, Disk
 from multi import Multi
 from utils import crossproduct, INF
 
@@ -331,7 +331,7 @@ def get_sphere_and_cylinder_data(self):
                 try:
                     shell = object.shell_list[0][1]
                     # Only cylinders have half_length.
-                    shell.shape.half_length
+                    shell.shape.half_length                    
                     cylinders.append(shell)
                     cylinder_colors.append(color)
                 except:
@@ -361,7 +361,8 @@ def get_cylindrical_surface_data(self):
         # Todo. Make DNA blink when reaction takes place.
         cylinders = [surface for surface
                              in self.sim.world.structures
-                             if isinstance(surface.shape, Cylinder)]
+                             if isinstance(surface.shape, Cylinder)
+                             or isinstance(surface.shape, Disk)]
         return self.process_cylinders(cylinders)
 
     def process_spheres(self, spheres=[], color_list=[]):
@@ -402,9 +403,27 @@ def process_cylinders(self, cylinders=[], color_list=[]):
             # Add dummy cylinder to stop TensorGlyph from complaining.
             cylinders = [self.get_dummy_cylinder()]
             color_list = [0]
+            c = cylinders[0]            
 
         for cylinder in cylinders:
             # Todo. Which one is it.
+
+            # Pre-process disks which are put into the same
+            # list as cylinders but lack the half_length property
+            # TODO Give disks a different color!
+            try:
+                if isinstance(cylinder.shape, Disk):
+                    disk = cylinder
+                    cylinder = self.get_dummy_cylinder()
+                    cylinder.position    = disk.shape.position
+                    cylinder.radius      = disk.shape.radius
+                    cylinder.unit_z      = disk.shape.unit_z
+                    cylinder.half_length = 0.0
+            except:
+                pass
+
+            # The following is necessary to distinguish
+            # shells from surfaces
             try:
                 position = cylinder.position
                 radius = cylinder.radius

From 6b5b8ca5e77fdfab2988ce04be2e4194655a4bcd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 3 May 2012 20:03:31 +0200
Subject: [PATCH 0845/1541] fixed compile errors in 'apply_boundary' for planar
 submanifolds.

---
 StructureContainer.hpp | 64 ++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 27 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 4596952e..84682595 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -63,6 +63,10 @@ class ConnectivityContainer
 };
 
 
+////// Inline functions related to ConnectivityContainer
+// TODO
+
+
 
 
 template <typename Tobj_, typename Tid_>
@@ -81,6 +85,7 @@ class StructureContainer
             typename structure_map::const_iterator>                                 structure_iterator;
     typedef typename std::map<structure_id_type, structure_id_set>                  per_structure_substructure_id_set;
 
+
 public:
     typedef sized_iterator_range<structure_iterator>                                structures_range;
 
@@ -221,17 +226,18 @@ class StructureContainer
 //    CuboidalReginConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 6> map
 
 };
-/*
+
 
 
 //////// Inline functions applicable to the StructureContainer
 
 
 //// functions for Planes
-
-template<typename ConnectivityContainer<> >
-inline typename ConnectivityContainer::traits_type::position_structid_pair_type
-apply_boundary (StructureContainer const& sc, position_structid_pair_type const& pos_structure_id) const
+template<typename T_, typename Ttraits_ >
+inline std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type> const& sc,
+                ConnectivityContainer<typename Ttraits_::structure_id_type, typename Plane<T_>::position_type, 4> const& cc, // Plane<T_>::num_neighbors > const& cc,
+                std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
 // We supply the structure container as an argument so that we can get the structures that we need.
@@ -239,11 +245,14 @@ apply_boundary (StructureContainer const& sc, position_structid_pair_type const&
 // query the boundary conditions and connectivity.
 {
     // useful typedefs
-    typedef typename plane_type;
-    typedef typename plane_type::length_type    length_type;
-    typedef typename position_type;
-    typedef typename structure_id_type;
-    typedef typename position_structid_pair_type;
+    typedef Ttraits_    traits_type;
+    typedef Plane<T_>   plane_type;
+    typedef typename plane_type::length_type            length_type;
+    typedef typename plane_type::position_type          position_type;
+    typedef typename traits_type::structure_id_type     structure_id_type;
+    typedef typename traits_type::structure_type        structure_type;
+    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
+    typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
     const plane_type origin_plane (sc.get_structure(pos_structure_id.second)->shape());
@@ -257,7 +266,7 @@ apply_boundary (StructureContainer const& sc, position_structid_pair_type const&
     const length_type component_y ( dot_product(pos_vector, origin_plane.unit_y()) );
 
     // declare the variables that will be written
-    structure_id_type new_id;
+    structure_id_type new_id(pos_structure_id.second);
     position_type neighbor_plane_par;
     position_type neighbor_plane_inl;
 
@@ -273,61 +282,62 @@ apply_boundary (StructureContainer const& sc, position_structid_pair_type const&
     {
         // we are at the 'top' of the plane (side nr. 0)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
-        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 0).second);
+        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 0));
 
-        new_id = neighbor_mapping_[pos_structure_id.second][0].first;
+        new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_x * origin_plane.unit_x();
-        neighbor_plane_inl = (component_y - origin_length_y)* neighbor_plane_unit_inline;
+        neighbor_plane_inl = (component_y - origin_length_y)* neighbor_id_vector.second;
     }
     else if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
               (component_y < -half_extends[1] ) )
     {
         // we are at the 'bottom' of the plane (side nr. 1)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
-        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 1).second);
+        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 1));
 
-        new_id = neighbor_mapping_[pos_structure_id.second][1].first;
+        new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_x * origin_plane.unit_x();
-        neighbor_plane_inl = (-component_y - origin_length_y)* neighbor_plane_unit_inline;
+        neighbor_plane_inl = (-component_y - origin_length_y)* neighbor_id_vector.second;
     }
     else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
               (component_x < -half_extends[0]) )
     {
         // we are at the 'left' of the plane (side nr. 2)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
-        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 2).second);
+        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 2));
 
-        new_id = neighbor_mapping_[pos_structure_id.second][2].first;
+        new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_y * origin_plane.unit_y();
-        neighbor_plane_inl = (-component_x - origin_length_x)* neighbor_plane_unit_inline;
+        neighbor_plane_inl = (-component_x - origin_length_x)* neighbor_id_vector.second;
     }
     else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
               (half_extends[0] < component_x) )
     {
         // we are at the 'right' of the plane (side nr. 3)
         // this is a unit vector pointing from the edge between the two planes to the center of the plane
-        const position_type neighbor_plane_unit_inline (sc.get_neighbor_info(pos_structure_id.second, 3).second);
+        const position_type neighbor_plane_unit_inline (cc.get_neighbor_info(pos_structure_id.second, 3).second);
+        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 3));
 
-        new_id = neighbor_mapping_[pos_structure_id.second][3].first;
+        new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_y * origin_plane.unit_y();
-        neighbor_plane_inl = (component_x - origin_length_x)* neighbor_plane_unit_inline;
+        neighbor_plane_inl = (component_x - origin_length_x)* neighbor_id_vector.second;
     }
     else
     {
         // we are somewhere in the corners and don't know what to do
-        // throw exception?
+        // reject move?
+        return pos_structure_id;
     }
 
     const position_type new_pos ( add(sc.get_structure(new_id)->position(),
                                       add(neighbor_plane_par, neighbor_plane_inl)));
     // TODO do normal apply_boundary too?
-    return std::make_pair(new_id, new_pos);
+    return std::make_pair(new_pos, new_id);
 }
-
+/*
 template<>
 inline
 cyclic_transpose
-
 */
 
 ///// Functions for Cylinders

From ccf300e2febba8b759a7451c4b62da958b138a66 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 11:47:13 +0200
Subject: [PATCH 0846/1541] Structure should be parameterized with the traits
 of the world, not of the simulator

---
 CuboidalRegion.hpp              |  8 ++++----
 CylindricalSurface.hpp          |  8 ++++----
 EGFRDSimulatorFactory.hpp       |  2 +-
 ParticleSimulationStructure.hpp |  6 +++---
 PlanarSurface.hpp               |  8 ++++----
 Region.hpp                      |  2 +-
 SphericalSurface.hpp            | 24 ++++++++++++------------
 Structure.hpp                   |  2 +-
 Surface.hpp                     |  2 +-
 9 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index d61235e2..d9f8ad1f 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -8,11 +8,11 @@
 
 template<typename Ttraits_>
 class CuboidalRegion
-    : public BasicRegionImpl<Ttraits_, Box<typename Ttraits_::world_type::traits_type::length_type> >
+    : public BasicRegionImpl<Ttraits_, Box<typename Ttraits_::length_type> >
 {
 public:
-    typedef BasicRegionImpl<Ttraits_, Box<typename Ttraits_::world_type::traits_type::length_type> > base_type;
-    typedef typename base_type::traits_type traits_type;
+    typedef BasicRegionImpl<Ttraits_, Box<typename Ttraits_::length_type> > base_type;
+    typedef Ttraits_ traits_type;
 
     // name shorthands of types that we use.
     typedef typename base_type::structure_name_type     structure_name_type;
@@ -22,7 +22,7 @@ class CuboidalRegion
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
-    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef typename traits_type::species_type          species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 561b08db..3ed553ae 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -9,13 +9,13 @@
 
 template<typename Ttraits_>
 class CylindricalSurface
-    : public BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> >
+    : public BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::length_type> >
 {
     // The CylindricalSurface is the implementation of a Basic surface parameterized with a Cylinder
 
 public:
-    typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::world_type::traits_type::length_type> > base_type;
-    typedef typename base_type::traits_type traits_type;
+    typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::length_type> > base_type;
+    typedef Ttraits_ traits_type;
     typedef typename base_type::structure_name_type     structure_name_type;        // This is just the name of the structure
     typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
@@ -23,7 +23,7 @@ class CylindricalSurface
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
-    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef typename traits_type::species_type          species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
diff --git a/EGFRDSimulatorFactory.hpp b/EGFRDSimulatorFactory.hpp
index eb61d300..7ed636a0 100644
--- a/EGFRDSimulatorFactory.hpp
+++ b/EGFRDSimulatorFactory.hpp
@@ -22,7 +22,7 @@ class EGFRDSimulatorFactory: public ParticleSimulatorFactory<Ttraits_>
     typedef typename world_traits_type::rng_type        rng_type;
     typedef typename traits_type::network_rules_type    network_rules_type;
 
-    typedef CuboidalRegion<traits_type>                 cuboidal_region_type;
+    typedef CuboidalRegion<world_traits_type>           cuboidal_region_type;
 
 
 public:
diff --git a/ParticleSimulationStructure.hpp b/ParticleSimulationStructure.hpp
index 13f27adc..127b26b4 100644
--- a/ParticleSimulationStructure.hpp
+++ b/ParticleSimulationStructure.hpp
@@ -6,14 +6,14 @@
 template<typename Ttraits_>
 struct ImmutativeStructureVisitor;
 
-template<typename Ttraits_>
+template<typename Ttraits_>     // Note that Ttraits_ refers to a the World traits
 struct MutativeStructureVisitor;
 
 template<typename Ttraits_>
-struct ParticleSimulationStructure: public Structure<typename Ttraits_::world_type::traits_type>
+struct ParticleSimulationStructure: public Structure<Ttraits_>
 {
     typedef Ttraits_ traits_type;
-    typedef Structure<typename traits_type::world_type::traits_type> base_type;
+    typedef Structure<traits_type> base_type;
 
     typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index a5799ca7..11d215e6 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -8,13 +8,13 @@
 
 template<typename Ttraits_>
 class PlanarSurface
-    : public BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::world_type::traits_type::length_type> >
+    : public BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::length_type> >
 {
     // The planar surface is an implementation of a Basic surface parameterized with the plane
 
 public:
-    typedef BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::world_type::traits_type::length_type> > base_type;
-    typedef typename base_type::traits_type traits_type;
+    typedef BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::length_type> > base_type;
+    typedef Ttraits_ traits_type;
     typedef typename base_type::structure_name_type     structure_name_type;        // This is just the name of the structure
     typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
@@ -22,7 +22,7 @@ class PlanarSurface
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
-    typedef typename Ttraits_::world_type::species_type species_type;
+    typedef typename traits_type::species_type          species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
     typedef std::pair<position_type, length_type>       projected_type;
 
diff --git a/Region.hpp b/Region.hpp
index 6deedea3..c8b93885 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -59,7 +59,7 @@ class BasicRegionImpl: public Region<Ttraits_>
         return shape_;
     }
 
-    virtual bool operator==(Structure<typename Ttraits_::world_type::traits_type> const& rhs) const
+    virtual bool operator==(Structure<Ttraits_> const& rhs) const
     {
         BasicRegionImpl const* _rhs(dynamic_cast<BasicRegionImpl const*>(&rhs));
         return _rhs &&
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index afc69be6..a1f722a1 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -7,20 +7,20 @@
 
 template<typename Ttraits_>
 class SphericalSurface
-    : public BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::world_type::traits_type::length_type> >
+    : public BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::length_type> >
 {
 public:
-    typedef BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::world_type::traits_type::length_type> > base_type;
-    typedef typename base_type::traits_type traits_type;
-    typedef typename base_type::structure_name_type     structure_name_type;        // THis is just the name of the structure
-    typedef typename base_type::structure_id_type       structure_id_type;
-    typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::shape_type              shape_type;
-    typedef typename base_type::rng_type                rng_type;
-    typedef typename base_type::position_type           position_type;
-    typedef typename base_type::length_type             length_type;
-    typedef typename Ttraits_::world_type::species_type species_type;
-    typedef std::pair<position_type, position_type>     position_pair_type;
+    typedef BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::length_type> > base_type;
+    typedef Ttraits_ traits_type;
+    typedef typename base_type::structure_name_type         structure_name_type;        // THis is just the name of the structure
+    typedef typename base_type::structure_id_type           structure_id_type;
+    typedef typename base_type::structure_type_id_type      structure_type_id_type;
+    typedef typename base_type::shape_type                  shape_type;
+    typedef typename base_type::rng_type                    rng_type;
+    typedef typename base_type::position_type               position_type;
+    typedef typename base_type::length_type                 length_type;
+    typedef typename traits_type::species_type              species_type;
+    typedef std::pair<position_type, position_type>         position_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
diff --git a/Structure.hpp b/Structure.hpp
index 70ae2779..35508b59 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -26,7 +26,7 @@ class Structure
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::length_type               length_type;
     typedef typename traits_type::position_type             position_type;
-    typedef typename traits_type::base_type::species_type   species_type;
+    typedef typename traits_type::species_type              species_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
     typedef std::pair<position_type, length_type>           projected_type;
     typedef std::pair<position_type, position_type>         position_pair_type;
diff --git a/Surface.hpp b/Surface.hpp
index 52ec6c38..c49c6b61 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -68,7 +68,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return shape_;
     }
 
-    virtual bool operator==(Structure<typename Ttraits_::world_type::traits_type> const& rhs) const
+    virtual bool operator==(Structure<Ttraits_> const& rhs) const
     {
         BasicSurfaceImpl const* _rhs(dynamic_cast<BasicSurfaceImpl const*>(&rhs));
         return _rhs &&

From 3bb7d2efa0c1ddd4ed3992f1d887ab83e0be6997 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 11:51:50 +0200
Subject: [PATCH 0847/1541] moved definition of type of structures from
 simulator to particle container (which is also structure container).

---
 EGFRDSimulator.hpp    |  4 ++--
 ParticleContainer.hpp |  9 +++++++++
 ParticleSimulator.hpp | 37 +++++++++++++++++++++----------------
 3 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index 45613f3f..37fb404d 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -1440,7 +1440,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
         single_type* new_single(0);
         domain_id_type did(didgen_());
 
-        struct factory: ImmutativeStructureVisitor<traits_type>
+        struct factory: ImmutativeStructureVisitor<typename world_type::traits_type>
         {
             virtual ~factory() {}
 
@@ -1525,7 +1525,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
         pair_type* new_pair(0);
         domain_id_type did(didgen_());
 
-        struct factory: ImmutativeStructureVisitor<traits_type>
+        struct factory: ImmutativeStructureVisitor<typename world_type::traits_type>
         {
             virtual void operator()(spherical_surface_type const& structure) const
             {
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index c12bcf48..6327f982 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -6,6 +6,10 @@
 #include "generator.hpp"
 #include "utils/get_default_impl.hpp"
 #include "utils/unassignable_adapter.hpp"
+#include "CuboidalRegion.hpp"
+#include "PlanarSurface.hpp"
+#include "CylindricalSurface.hpp"
+#include "SphericalSurface.hpp"
 
 template<typename Ttraits_>
 class Transaction;
@@ -33,6 +37,11 @@ class ParticleContainer
 
     typedef typename particle_type::shape_type                  particle_shape_type;
     typedef Transaction<traits_type>                            transaction_type;
+    typedef CuboidalRegion<traits_type>                         cuboidal_region_type;
+    typedef PlanarSurface<traits_type>                          planar_surface_type;
+    typedef CylindricalSurface<traits_type>                     cylindrical_surface_type;
+    typedef SphericalSurface<traits_type>                       spherical_surface_type;
+
 
     typedef std::set<particle_id_type>                                              particle_id_set;
     typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;
diff --git a/ParticleSimulator.hpp b/ParticleSimulator.hpp
index c03de6d7..c3c3688a 100644
--- a/ParticleSimulator.hpp
+++ b/ParticleSimulator.hpp
@@ -11,6 +11,7 @@
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
 #include "SphericalSurface.hpp"
+#include "ParticleContainer.hpp"
 #include "NetworkRules.hpp"
 #include "NetworkRulesWrapper.hpp"
 #include "ReactionRuleInfo.hpp"
@@ -45,14 +46,17 @@ struct ParticleSimulatorTraitsBase
 template<typename Ttraits_>
 class ParticleSimulator;
 
+template<typename Ttraits_>
+class ParticleContainer;
+
 template<typename Ttraits_>
 struct ImmutativeStructureVisitor
 {
     typedef Ttraits_ traits_type;
-    typedef typename ParticleSimulator<traits_type>::spherical_surface_type     spherical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::planar_surface_type        planar_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cuboidal_region_type       cuboidal_region_type;
+    typedef typename ParticleContainer<traits_type>::spherical_surface_type     spherical_surface_type;
+    typedef typename ParticleContainer<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename ParticleContainer<traits_type>::planar_surface_type        planar_surface_type;
+    typedef typename ParticleContainer<traits_type>::cuboidal_region_type       cuboidal_region_type;
 
 
     virtual ~ImmutativeStructureVisitor() {}
@@ -70,10 +74,10 @@ template<typename Ttraits_>
 struct MutativeStructureVisitor
 {
     typedef Ttraits_ traits_type;
-    typedef typename ParticleSimulator<traits_type>::spherical_surface_type     spherical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
-    typedef typename ParticleSimulator<traits_type>::planar_surface_type        planar_surface_type;
-    typedef typename ParticleSimulator<traits_type>::cuboidal_region_type       cuboidal_region_type;
+    typedef typename ParticleContainer<traits_type>::spherical_surface_type     spherical_surface_type;
+    typedef typename ParticleContainer<traits_type>::cylindrical_surface_type   cylindrical_surface_type;
+    typedef typename ParticleContainer<traits_type>::planar_surface_type        planar_surface_type;
+    typedef typename ParticleContainer<traits_type>::cuboidal_region_type       cuboidal_region_type;
 
 
     virtual ~MutativeStructureVisitor() {}
@@ -93,22 +97,23 @@ class ParticleSimulator
 public:
     typedef Ttraits_                            traits_type;
     typedef typename traits_type::world_type    world_type;
+    typedef typename world_type::traits_type    world_traits_type;
 
     // shorthand typedefs
     typedef Sphere<typename world_type::length_type>    sphere_type;
     typedef Cylinder<typename world_type::length_type>  cylinder_type;
     typedef Box<typename world_type::length_type>       box_type;
     typedef Plane<typename world_type::length_type>     plane_type;
-    typedef ParticleSimulationStructure<traits_type>    particle_simulation_structure_type;
-    typedef Surface<traits_type>                        surface_type;
-    typedef Region<traits_type>                         region_type;
-    typedef SphericalSurface<traits_type>               spherical_surface_type;
-    typedef CylindricalSurface<traits_type>             cylindrical_surface_type;
-    typedef PlanarSurface<traits_type>                  planar_surface_type;
-    typedef CuboidalRegion<traits_type>                 cuboidal_region_type;
+    typedef ParticleSimulationStructure<world_traits_type>    particle_simulation_structure_type;
+    typedef Surface<world_traits_type>                  surface_type;
+    typedef Region<world_traits_type>                   region_type;
+    typedef SphericalSurface<world_traits_type>         spherical_surface_type;
+    typedef CylindricalSurface<world_traits_type>       cylindrical_surface_type;
+    typedef PlanarSurface<world_traits_type>            planar_surface_type;
+    typedef CuboidalRegion<world_traits_type>           cuboidal_region_type;
 
     typedef typename traits_type::network_rules_type    network_rules_type;
-    typedef typename world_type::traits_type::rng_type  rng_type;
+    typedef typename world_traits_type::rng_type        rng_type;
     typedef typename traits_type::time_type             time_type;
     typedef typename traits_type::reaction_record_type      reaction_record_type;
     typedef typename traits_type::reaction_recorder_type    reaction_recorder_type;

From 8344969af0895c03ba84aadc252a2d154c917d10 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 11:52:34 +0200
Subject: [PATCH 0848/1541] cleanup of layout of bindings_common

---
 binding/binding_common.hpp | 65 ++++++++++++++++++++------------------
 1 file changed, 34 insertions(+), 31 deletions(-)

diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index b1762cce..c4d9811b 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -41,10 +41,11 @@
 
 namespace binding {
 
-typedef ::not_found NotFound;
-typedef ::already_exists AlreadyExists;
-typedef ::illegal_state IllegalState;
+typedef ::not_found             NotFound;
+typedef ::already_exists        AlreadyExists;
+typedef ::illegal_state         IllegalState;
 typedef ::GSLRandomNumberGenerator GSLRandomNumberGenerator;
+
 typedef ::CyclicWorldTraits<Real, Real> WorldTraits;            // parameterize the World traits here -> determines many types!!
 typedef WorldTraits::particle_type      Particle;
 typedef WorldTraits::structure_id_type  StructureID;
@@ -54,46 +55,48 @@ typedef WorldTraits::structure_type     Structure;
 typedef StructureType::identifier_type  StructureTypeID;
 typedef WorldTraits::length_type        Length;
 typedef WorldTraits::position_type      Position;
-typedef ::World<WorldTraits> World;                             // plug in the WorldTraits type to get a fully specified World type.
+typedef ::World<WorldTraits>            World;                  // plug in the WorldTraits type to get a fully specified World type.
 
 typedef ::Model                                 Model;
 typedef ::ParticleModel                         ParticleModel;
 typedef ::NetworkRules                          NetworkRules;
 typedef NetworkRules::reaction_rule_generator   ReactionRuleGenerator;
 
-typedef World::transaction_type Transaction;
-typedef World::base_type::base_type ParticleContainer; 
-typedef ::TransactionImpl<ParticleContainer> TransactionImpl;
-typedef ::EGFRDSimulatorTraitsBase<World> EGFRDSimulatorTraits;
-typedef ::ParticleSimulator<EGFRDSimulatorTraits> ParticleSimulator;
-typedef ::BDSimulator<EGFRDSimulatorTraits> BDSimulator;
-typedef ::EGFRDSimulator<EGFRDSimulatorTraits> EGFRDSimulator;
-typedef ::MultiParticleContainer<EGFRDSimulatorTraits> MultiParticleContainer;
+typedef World::transaction_type                 Transaction;
+typedef World::base_type::base_type             ParticleContainer; 
+typedef ::TransactionImpl<ParticleContainer>    TransactionImpl;
+
+typedef ::EGFRDSimulatorTraitsBase<World>               EGFRDSimulatorTraits;
+typedef ::ParticleSimulator<EGFRDSimulatorTraits>       ParticleSimulator;
+typedef ::BDSimulator<EGFRDSimulatorTraits>             BDSimulator;
+typedef ::EGFRDSimulator<EGFRDSimulatorTraits>          EGFRDSimulator;
+typedef ::MultiParticleContainer<EGFRDSimulatorTraits>  MultiParticleContainer;
 
 typedef EGFRDSimulator::box_type        Box;
 typedef EGFRDSimulator::sphere_type     Sphere;
 typedef EGFRDSimulator::cylinder_type   Cylinder;
 typedef EGFRDSimulator::plane_type      Plane;
 
-typedef ::BDPropagator<EGFRDSimulatorTraits> BDPropagator;
-typedef ::newBDPropagator<EGFRDSimulatorTraits> newBDPropagator;
-typedef EGFRDSimulatorTraits::shell_id_type ShellID;
-typedef EGFRDSimulatorTraits::domain_id_type DomainID;
-typedef EGFRDSimulatorTraits::reaction_rule_type ReactionRuleInfo;
-typedef EGFRDSimulatorTraits::network_rules_type NetworkRulesWrapper;
-typedef EGFRDSimulator::domain_type Domain;
-typedef ::ShapedDomain<EGFRDSimulatorTraits> ShapedDomain;
-typedef EGFRDSimulator::spherical_shell_type SphericalShell;
-typedef EGFRDSimulator::cylindrical_shell_type CylindricalShell;
-typedef EGFRDSimulator::spherical_single_type::base_type Single;
-typedef EGFRDSimulator::spherical_pair_type::base_type Pair;
-typedef EGFRDSimulator::spherical_single_type SphericalSingle;
-typedef EGFRDSimulator::cylindrical_single_type CylindricalSingle;
-typedef EGFRDSimulator::spherical_pair_type SphericalPair;
-typedef EGFRDSimulator::cylindrical_pair_type CylindricalPair;
-typedef EGFRDSimulator::multi_type Multi;
-typedef ::MatrixSpace<SphericalShell, ShellID> SphericalShellContainer;
-typedef ::MatrixSpace<CylindricalShell, ShellID> CylindricalShellContainer;
+typedef ::BDPropagator<EGFRDSimulatorTraits>        BDPropagator;
+typedef ::newBDPropagator<EGFRDSimulatorTraits>     newBDPropagator;
+
+typedef EGFRDSimulatorTraits::shell_id_type     ShellID;
+typedef EGFRDSimulatorTraits::domain_id_type    DomainID;
+typedef EGFRDSimulatorTraits::reaction_rule_type    ReactionRuleInfo;
+typedef EGFRDSimulatorTraits::network_rules_type    NetworkRulesWrapper;
+typedef EGFRDSimulator::domain_type             Domain;
+typedef ::ShapedDomain<EGFRDSimulatorTraits>    ShapedDomain;
+typedef EGFRDSimulator::spherical_shell_type                SphericalShell;
+typedef EGFRDSimulator::cylindrical_shell_type              CylindricalShell;
+typedef EGFRDSimulator::spherical_single_type::base_type    Single;
+typedef EGFRDSimulator::spherical_pair_type::base_type      Pair;
+typedef EGFRDSimulator::spherical_single_type               SphericalSingle;
+typedef EGFRDSimulator::cylindrical_single_type             CylindricalSingle;
+typedef EGFRDSimulator::spherical_pair_type                 SphericalPair;
+typedef EGFRDSimulator::cylindrical_pair_type               CylindricalPair;
+typedef EGFRDSimulator::multi_type                          Multi;
+typedef ::MatrixSpace<SphericalShell, ShellID>      SphericalShellContainer;
+typedef ::MatrixSpace<CylindricalShell, ShellID>    CylindricalShellContainer;
 typedef ::StructureUtils<EGFRDSimulator> StructureUtils;
 typedef EGFRDSimulator::particle_simulation_structure_type ParticleSimulationStructure;
 

From e1175a25618bc04dbd63cefcae3befd62c4f088c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 11:56:50 +0200
Subject: [PATCH 0849/1541] replace minimal_distance to surface by
 check_surface_overlap

---
 CylindricalSurface.hpp |  4 ++--
 PlanarSurface.hpp      |  4 ++--
 SphericalSurface.hpp   |  4 ++--
 StructureUtils.hpp     |  3 ++-
 Surface.hpp            |  2 +-
 binding/Surface.hpp    |  2 +-
 gfrdbase.py            | 36 +++++++++++++++++++-----------------
 7 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 3ed553ae..3cf132b2 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -195,14 +195,14 @@ class CylindricalSurface
     {
         return base_type::distance(new_pos);
     }
-
+/*
     virtual length_type minimal_distance(length_type const& radius) const
     {
         length_type cylinder_radius = base_type::shape().radius();
         // Return minimal distance *to* surface.
         return (cylinder_radius + radius) * traits_type::MINIMAL_SEPARATION_FACTOR - cylinder_radius;
     }
-
+*/
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 11d215e6..5517e961 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -191,13 +191,13 @@ class PlanarSurface
             return base_type::distance(new_pos) + sigma;
         }
     }
-
+/*
     virtual length_type minimal_distance(length_type const& radius) const
     {
         // PlanarSurface has thickness of 0.
         return radius * traits_type::MINIMAL_SEPARATION_FACTOR;
     }
-
+*/
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index a1f722a1..cac79827 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -93,12 +93,12 @@ class SphericalSurface
     {
         return base_type::distance(new_pos);
     }
-
+/*
     virtual length_type minimal_distance(length_type const& radius) const
     {
         return 0.; // TODO
     }
-
+*/
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index 95b5d835..d2d090aa 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -118,11 +118,12 @@ struct StructureUtils
     {
         return structure.random_position(rng);
     }
-
+/*
     static length_type minimal_distance_from_surface(surface_type const& surface, length_type const& radius)
     {
         return surface.minimal_distance(radius);
     }
+*/
 };
 
 #endif /* STRUCTURE_UTILS_HPP */
diff --git a/Surface.hpp b/Surface.hpp
index c49c6b61..4c08888e 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -33,7 +33,7 @@ class Surface: public ParticleSimulationStructure<Ttraits_>
     Surface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id):
          base_type(name, sid, parent_struct_id) {}
 
-    virtual length_type minimal_distance(length_type const& radius) const = 0;
+//    virtual length_type minimal_distance(length_type const& radius) const = 0;
 };
 
 
diff --git a/binding/Surface.hpp b/binding/Surface.hpp
index b0944a59..ba26e5ff 100644
--- a/binding/Surface.hpp
+++ b/binding/Surface.hpp
@@ -17,7 +17,7 @@ inline boost::python::objects::class_base register_surface_class(char const *nam
     return class_<impl_type, bases<typename impl_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
             name, no_init)
-        .def("minimal_distance", &impl_type::minimal_distance)
+//        .def("minimal_distance", &impl_type::minimal_distance)
         ;
 }
 
diff --git a/gfrdbase.py b/gfrdbase.py
index abbe45eb..8d3702ac 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -250,26 +250,28 @@ def throw_in_particles(world, sid, n):
         position = structure.random_position(myrandom.rng)
         position = world.apply_boundary(position)
 
-        surfaces = get_neighbor_surfaces(world, position, structure.id, [])
-        if surfaces:
-            surface, distance = surfaces[0]
-        else:
-            surface, distance = None, 0
+#        surfaces = get_neighbor_surfaces(world, position, structure.id, [])
+#        if surfaces:
+#            surface, distance = surfaces[0]
+#        else:
+#            surface, distance = None, 0
 
         # Check overlap.
-        if not world.check_overlap((position, species.radius)):
+        if (not world.check_overlap((position, species.radius))) and \
+           (not world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
+                                           position, structure.id, species.radius)):
             create = True
-            # Check if not too close to a neighbouring structures for 
-            # particles added to the world, or added to a self-defined 
-            # box.
-            # FIXME replace by check_surface_overlap
-            if (isinstance(structure, _gfrd.CuboidalRegion) and \
-                surface and \
-                distance < surface.minimal_distance(species.radius)):
-                if __debug__:
-                    log.info('\t%d-th particle rejected. Too close to '
-                             'surface. I will keep trying.' % i)
-                create = False
+#            # Check if not too close to a neighbouring structures for 
+#            # particles added to the world, or added to a self-defined 
+#            # box.
+#            # FIXME replace by check_surface_overlap
+#            if (isinstance(structure, _gfrd.CuboidalRegion) and \
+#                surface and \
+#                distance < surface.minimal_distance(species.radius)):
+#                if __debug__:
+#                    log.info('\t%d-th particle rejected. Too close to '
+#                             'surface. I will keep trying.' % i)
+#                create = False
             if create:
                 # All checks passed. Create particle.
                 p = world.new_particle(sid, structure.id, position)

From 361ad2e353a0ce8903dd430552e8d99fb67cafba Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 14:15:30 +0200
Subject: [PATCH 0850/1541] made boundary conditions of structure part of
 StructureContainer. made sure that set_def_structure only accepts
 CuboidalRegion as argument. start implementation of specialized
 update_structure for different supported structures.

---
 StructureContainer.hpp | 132 ++++++++++++++++++++++++++---------------
 World.hpp              |  14 +++--
 2 files changed, 94 insertions(+), 52 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 84682595..650ffb3e 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -4,6 +4,9 @@
 #include <boost/lexical_cast.hpp>
 #include "exceptions.hpp"
 #include "linear_algebra.hpp"
+#include "CuboidalRegion.hpp"
+#include "PlanarSurface.hpp"
+#include "CylindricalSurface.hpp"
 
 
 template<typename Tobj_, typename Tdata_, std::size_t num_neighbors>
@@ -37,6 +40,10 @@ class ConnectivityContainer
 public:
     void set_neighbor_info(obj_type const& obj, size_type const n, obj_data_pair_type const& obj_data_pair)
     {
+        // check that the index is not too large
+        if ( n >= max )
+            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
+
         neighbor_mapping_[obj][n] = obj_data_pair;
     }
 
@@ -69,12 +76,13 @@ class ConnectivityContainer
 
 
 
-template <typename Tobj_, typename Tid_>
+template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer
 {
 public:
-    typedef Tobj_              structure_type;
-    typedef Tid_               structure_id_type;
+    typedef Tobj_               structure_type;
+    typedef Tid_                structure_id_type;
+    typedef Ttraits_            traits_type;
     typedef std::set<structure_id_type>                                             structure_id_set;
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >         structure_map;
@@ -85,6 +93,16 @@ class StructureContainer
             typename structure_map::const_iterator>                                 structure_iterator;
     typedef typename std::map<structure_id_type, structure_id_set>                  per_structure_substructure_id_set;
 
+    typedef ConnectivityContainer<structure_id_type, typename structure_type::position_type, 2> cylinders_boundaryconditions_type;
+    typedef ConnectivityContainer<structure_id_type, typename structure_type::position_type, 4> planes_boundaryconditions_type;
+    typedef ConnectivityContainer<structure_id_type, typename structure_type::position_type, 6> boxes_boundaryconditions_type;
+
+    typedef CuboidalRegion<traits_type>                             cuboidalregion_type;
+    typedef PlanarSurface<traits_type>                              planarsurface_type;
+    typedef CylindricalSurface<traits_type>                         cylindricalsurface_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<cuboidalregion_type> >       cuboidalreg_id_pair_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<planarsurface_type> >        planarsurf_id_pair_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<cylindricalsurface_type> >   cylindrsurf_id_pair_type;
 
 public:
     typedef sized_iterator_range<structure_iterator>                                structures_range;
@@ -93,42 +111,61 @@ class StructureContainer
 public:
     virtual ~StructureContainer() {};
 
+    // The constructor
     StructureContainer(structure_id_type default_structid) : default_structure_id_(default_structid)
     {
         structure_substructures_map_[default_structid] = structure_id_set();
     }
 
-/*    add_structure (CylindricalSurface)  // can I make this into a template function?
+    virtual bool update_structure (cylindrsurf_id_pair_type const& structid_cylinder)  // can I make this into a template function?
     {
         // add to Connectivity container for cylindrical surfaces
+        return false;
     }
-    add_structure (PlanarSurface)
+    virtual bool update_structure (planarsurf_id_pair_type const& structid_plane)
     {
-        // add to Connectivity container for planar surfaces
+        // call regular update method (this also checks if the structure was already present)
+        if ( update_structure_base(structid_plane))
+        {
+            // We now assume that the structure was not already in the boundary_conditions_thing
+            // add to Connectivity container for planar surfaces and set reflective boundary conditions.
+            return true;
+        }
+        // if the structure was already present, don't change anything
+        return false;
     }
-    add_structure (CuboidalRegion)
+    virtual bool update_structure (cuboidalreg_id_pair_type const& structid_cube)
     {
-        // add to Connectivity container for planar surfaces
+        // add to Connectivity container for cuboidal regions
+        if ( update_structure_base(structid_cube))
+        {
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,  structid_cube.second->shape().unit_z()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 1, std::make_pair(structid_cube.first, -structid_cube.second->shape().unit_z()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 2, std::make_pair(structid_cube.first,  structid_cube.second->shape().unit_y()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 3, std::make_pair(structid_cube.first, -structid_cube.second->shape().unit_y()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 4, std::make_pair(structid_cube.first,  structid_cube.second->shape().unit_x()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 5, std::make_pair(structid_cube.first, -structid_cube.second->shape().unit_x()));
+            return true;
+        }
+        return false;
     }
-    remove_structure (StructureID)
+/*    get_neighbor_info(PlanarSurface)
     {
-        // find StructureID in all ConnectivityContainers -> remove references
     }
-
 */
     virtual structure_id_type get_def_structure_id() const
     {
         return default_structure_id_;
     }
-    void set_def_structure(const boost::shared_ptr<structure_type> structure)
+    void set_def_structure(const boost::shared_ptr<cuboidalregion_type> cuboidalregion)
     {
         // check that the structure_type is the default structure_type
-        if ( structure->structure_id() != default_structure_id_)
+        if ( cuboidalregion->structure_id() != default_structure_id_)
         {
-            throw illegal_state("Default structure doesn't have right properties");
+            throw illegal_state("Default structure should have itself as parent.");
         }
-        structure->set_id(default_structure_id_);
-        update_structure(std::make_pair(default_structure_id_, structure));
+        cuboidalregion->set_id(default_structure_id_);
+        update_structure(std::make_pair(default_structure_id_, cuboidalregion));
     }
     virtual bool has_structure(structure_id_type const& id) const
     {
@@ -151,35 +188,10 @@ class StructureContainer
         structure_iterator(structure_map_.end(),   structures_second_selector_type()),
         structure_map_.size());
     }
-    virtual bool update_structure(structure_id_pair const& structid_pair)
-    {
-        typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
-        if (i != structure_map_.end())
-        // The item was already found in the map
-        {
-            if ((*i).second->structure_id() != structid_pair.second->structure_id())
-            // If the structure had a different parent structure
-            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hierarchy)
-            {
-                structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
-                structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
-            }
-            structure_map_[(*i).first] = structid_pair.second;
-            return false;
-        }
-
-        // The structure was not yet in the world.
-        // create a new item in the structure mapping
-        structure_map_[structid_pair.first] = structid_pair.second;
-        // add the id the mapping 'super_structure_id -> set of substructures'
-        structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
-        // create a new mapping from structure id -> set of substructures
-        structure_substructures_map_[structid_pair.first] = structure_id_set();
-        return true;
-    }
     virtual bool remove_structure(structure_id_type const& id)
     {
         // TODO
+        //  -find StructureID in all ConnectivityContainers -> remove references
         //  -get all the substructures of structure
         //  -only remove if no substructures
         return false;
@@ -203,6 +215,32 @@ class StructureContainer
         return visible_structures;
     }
 
+    bool update_structure_base(structure_id_pair const& structid_pair)
+    {
+        typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
+        if (i != structure_map_.end())
+        // The item was already found in the map
+        {
+            if ((*i).second->structure_id() != structid_pair.second->structure_id())
+            // If the structure had a different parent structure
+            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hierarchy)
+            {
+                structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
+                structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+            }
+            structure_map_[(*i).first] = structid_pair.second;
+            return false;
+        }
+
+        // The structure was not yet in the world.
+        // create a new item in the structure mapping
+        structure_map_[structid_pair.first] = structid_pair.second;
+        // add the id the mapping 'super_structure_id -> set of substructures'
+        structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
+        // create a new mapping from structure id -> set of substructures
+        structure_substructures_map_[structid_pair.first] = structure_id_set();
+        return true;
+    }
 private:
     // Get all the structure ids of the substructures
     structure_id_set get_substructure_ids(structure_id_type const& id) const
@@ -221,10 +259,10 @@ class StructureContainer
     per_structure_substructure_id_set   structure_substructures_map_;
     structure_id_type                   default_structure_id_;
 
-//    CylindricalSurfaceConnectivityContainer     // This contains a StructureID -> vector <(StructureID, index), 2> map
-//    PlanarSurfaceConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 4> map
-//    CuboidalReginConnectivityContainer          // This contains a StructureID -> vector <(StructureID, index), 6> map
-
+    // The next object describe the boundary conditions that are applied to the different types of structures.
+    cylinders_boundaryconditions_type   cylindrical_structs_bc_;
+    planes_boundaryconditions_type      planar_structs_bc_;
+    boxes_boundaryconditions_type       cuboidal_structs_bc_;
 };
 
 
@@ -235,7 +273,7 @@ class StructureContainer
 //// functions for Planes
 template<typename T_, typename Ttraits_ >
 inline std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type> const& sc,
+apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc,
                 ConnectivityContainer<typename Ttraits_::structure_id_type, typename Plane<T_>::position_type, 4> const& cc, // Plane<T_>::num_neighbors > const& cc,
                 std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
diff --git a/World.hpp b/World.hpp
index 840f72d1..b76d8f7d 100644
--- a/World.hpp
+++ b/World.hpp
@@ -232,6 +232,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename base_type::structure_id_set                            structure_id_set;
     typedef typename base_type::structure_types_range                       structure_types_range;
 
+    typedef typename base_type::cuboidal_region_type                cuboidal_region_type;
+    typedef typename base_type::planar_surface_type                 planar_surface_type;
+    typedef typename base_type::cylindrical_surface_type            cylindrical_surface_type;
+
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> > structure_map;          // note: this is a structure_map_type
@@ -420,17 +424,17 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         return base_type::structures_.get_def_structure_id();
     }
-    void set_def_structure(const boost::shared_ptr<structure_type> structure)
+    void set_def_structure(const boost::shared_ptr<cuboidal_region_type> cuboidal_region)
     {
         // check that the structure_type is the default structure_type
         if (!default_structure_type_id_ ||
-            (structure->sid() != default_structure_type_id_) )
+            (cuboidal_region->sid() != default_structure_type_id_) )
         {
-            throw illegal_state("Default structure doesn't have right properties");
+            throw illegal_state("Default structure is not of default StructureType");
         }
         // check that the structure_type that is defined in the structure exists!
-        structure_type_type const& structure_type(get_structure_type(structure->sid()));
-        base_type::structures_.set_def_structure(structure);
+        structure_type_type const& structure_type(get_structure_type(cuboidal_region->sid()));
+        base_type::structures_.set_def_structure(cuboidal_region);
     }
     // Get the closest surface(surface is a subclass of structures)
     // TODO change this to get all the surfaces within a certain distance of the particle.

From c02929674c183db85e18bfdbf3c82c44428a477c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 14:19:10 +0200
Subject: [PATCH 0851/1541] fixed some code layout in ParticleContainer and
 ParticleContainerBase

---
 ParticleContainer.hpp     | 2 +-
 ParticleContainerBase.hpp | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 6327f982..25f9d72a 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -56,7 +56,7 @@ class ParticleContainer
     typedef std::pair<structure_id_pair, length_type>                               structure_id_pair_and_distance;
     typedef unassignable_adapter<structure_id_pair_and_distance,
                                  get_default_impl::std::vector>                     structure_id_pair_and_distance_list;
-    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >     structure_map;
+    typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >         structure_map;
 
 private:
     typedef select_second<typename structure_map::value_type>                   structure_second_selector_type;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 59933bc2..18dba596 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -121,11 +121,11 @@ class ParticleContainerBase
     typedef std::pair<particle_id_pair, length_type>                    particle_id_pair_and_distance;
     typedef sized_iterator_range<typename particle_matrix_type::const_iterator> particle_id_pair_range;
 
-    typedef StructureContainer<structure_type, structure_id_type>       structure_container_type;
+    typedef StructureContainer<structure_type, structure_id_type, traits_type>       structure_container_type;
 
-    typedef typename base_type::particle_id_pair_and_distance_list                              particle_id_pair_and_distance_list;
-    typedef typename base_type::structure_id_pair_and_distance_list                             structure_id_pair_and_distance_list;
-    typedef typename base_type::structure_id_pair_and_distance                                  structure_id_pair_and_distance;
+    typedef typename base_type::particle_id_pair_and_distance_list      particle_id_pair_and_distance_list;
+    typedef typename base_type::structure_id_pair_and_distance_list     structure_id_pair_and_distance_list;
+    typedef typename base_type::structure_id_pair_and_distance          structure_id_pair_and_distance;
 
 
 public:

From 6de57ea236983e55fc3c6b3b05cf47124658590f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 14:42:48 +0200
Subject: [PATCH 0852/1541] implemented update_structure for
 planes/cylinders/cuboids

---
 StructureContainer.hpp | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 650ffb3e..bdcce912 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -119,7 +119,13 @@ class StructureContainer
 
     virtual bool update_structure (cylindrsurf_id_pair_type const& structid_cylinder)  // can I make this into a template function?
     {
-        // add to Connectivity container for cylindrical surfaces
+        if ( update_structure_base(structid_cylinder))
+        {
+            // add to Connectivity container for cylindrical surfaces
+            cylindrical_structs_bc_.set_neighbor_info(structid_cylinder.first, 0, std::make_pair(structid_cylinder.first, multiply(structid_cylinder.second->shape().unit_z(), -1.0) ));
+            cylindrical_structs_bc_.set_neighbor_info(structid_cylinder.first, 1, std::make_pair(structid_cylinder.first,          structid_cylinder.second->shape().unit_z() ));
+            return true;
+        }
         return false;
     }
     virtual bool update_structure (planarsurf_id_pair_type const& structid_plane)
@@ -129,6 +135,10 @@ class StructureContainer
         {
             // We now assume that the structure was not already in the boundary_conditions_thing
             // add to Connectivity container for planar surfaces and set reflective boundary conditions.
+            planar_structs_bc_.set_neighbor_info(structid_plane.first, 0, std::make_pair(structid_plane.first, multiply(structid_plane.second->shape().unit_y(), -1.0) ));
+            planar_structs_bc_.set_neighbor_info(structid_plane.first, 1, std::make_pair(structid_plane.first,          structid_plane.second->shape().unit_y() ));
+            planar_structs_bc_.set_neighbor_info(structid_plane.first, 2, std::make_pair(structid_plane.first,          structid_plane.second->shape().unit_x() ));
+            planar_structs_bc_.set_neighbor_info(structid_plane.first, 3, std::make_pair(structid_plane.first, multiply(structid_plane.second->shape().unit_x(), -1.0) ));
             return true;
         }
         // if the structure was already present, don't change anything
@@ -139,12 +149,12 @@ class StructureContainer
         // add to Connectivity container for cuboidal regions
         if ( update_structure_base(structid_cube))
         {
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,  structid_cube.second->shape().unit_z()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 1, std::make_pair(structid_cube.first, -structid_cube.second->shape().unit_z()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 2, std::make_pair(structid_cube.first,  structid_cube.second->shape().unit_y()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 3, std::make_pair(structid_cube.first, -structid_cube.second->shape().unit_y()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 4, std::make_pair(structid_cube.first,  structid_cube.second->shape().unit_x()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 5, std::make_pair(structid_cube.first, -structid_cube.second->shape().unit_x()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_z()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 1, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_z(), -1.0) ));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 2, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_y()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 3, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_y(), -1.0) ));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 4, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_x()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 5, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_x(), -1.0) ));
             return true;
         }
         return false;

From 2a59f923b3c5c01806775b4496d7695598d4eb51 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 18:53:47 +0200
Subject: [PATCH 0853/1541] added typedefs

---
 ParticleContainer.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 25f9d72a..2a8b9bf3 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -42,6 +42,9 @@ class ParticleContainer
     typedef CylindricalSurface<traits_type>                     cylindrical_surface_type;
     typedef SphericalSurface<traits_type>                       spherical_surface_type;
 
+    typedef std::pair<structure_id_type, boost::shared_ptr<cuboidal_region_type> >       cuboidalreg_id_pair_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<planar_surface_type> >        planarsurface_id_pair_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<cylindrical_surface_type> >   cylindrsurf_id_pair_type;
 
     typedef std::set<particle_id_type>                                              particle_id_set;
     typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;

From c1f8367e97654d074949de2e61189be9ff3dcd2b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 19:10:50 +0200
Subject: [PATCH 0854/1541] templatized the update/add_structure stuff

---
 Multi.hpp                     | 3 ++-
 ParticleContainer.hpp         | 2 +-
 ParticleContainerBase.hpp     | 3 ++-
 Transaction.hpp               | 3 ++-
 World.hpp                     | 6 ++++--
 binding/ParticleContainer.hpp | 6 +++---
 binding/World.hpp             | 2 +-
 7 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index bc8e8720..5d2f6977 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -107,7 +107,8 @@ class MultiParticleContainer
         return world_.get_structures();     // TODO now gets all structures in world, -> make structure local to Multi
     }
     // virtual structure_id_type add_structure(structure_type const& structure); // TODO add structure from the world to multi
-    virtual bool update_structure(structure_id_pair const& structid_pair)
+    template <typename Tstructid_pair_>
+    bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         return world_.update_structure(structid_pair);
     }
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 2a8b9bf3..f40a2bdb 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -101,7 +101,7 @@ class ParticleContainer
     
     virtual structures_range get_structures() const = 0;
 
-    virtual bool update_structure(structure_id_pair const& structid_pair) = 0;
+//    virtual bool update_structure(structure_id_pair const& structid_pair) = 0;
 
     virtual bool remove_structure(structure_id_type const& id) = 0;
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 18dba596..5047d062 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -329,7 +329,8 @@ class ParticleContainerBase
     {
         return structures_.get_structures_range();
     }
-    virtual bool update_structure(structure_id_pair const& structid_pair)
+    template <typename Tstructid_pair_>
+    bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         return structures_.update_structure(structid_pair);
     }
diff --git a/Transaction.hpp b/Transaction.hpp
index cac7c485..0c025033 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -214,7 +214,8 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_structures();
     }    
-    virtual bool update_structure(structure_id_pair const& structid_pair)
+    template <typename Tstructid_pair_>
+    bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         return pc_.update_structure(structid_pair);
     }
diff --git a/World.hpp b/World.hpp
index b76d8f7d..61b484f2 100644
--- a/World.hpp
+++ b/World.hpp
@@ -361,7 +361,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     ////// Structure stuff
     // Add a structure 
-    virtual structure_id_type add_structure(boost::shared_ptr<structure_type> structure)
+    template <typename Tstructure_>
+    structure_id_type add_structure(boost::shared_ptr<Tstructure_> structure)
     {
         // check that the structure_type that is defined in the structure exists!
         structure_type_type const& structure_type(get_structure_type(structure->sid()));
@@ -372,7 +373,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         return structure_id;
     }
     // update structure
-    virtual bool update_structure(structure_id_pair const& structid_pair)
+    template <typename Tstructid_pair_>
+    bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         if ( base_type::has_structure(structid_pair.first) )
         // The item was already found
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 1514aee8..849ccfdb 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -399,12 +399,12 @@ class ParticleContainerWrapper
     {
         return py_wrapper_type::get_override("get_structures")();
     }
-
+/*
     virtual bool update_structure(structure_id_pair const& structid_pair)
     {
         return py_wrapper_type::get_override("update_structure")(structid_pair);
     }
-
+*/
     virtual bool remove_structure(structure_id_type const& id)
     {
         return py_wrapper_type::get_override("remove_structure")(id);
@@ -588,7 +588,7 @@ inline boost::python::objects::class_base register_particle_container_class(
         // Structure stuff
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
-        .def("update_structure", pure_virtual(&impl_type::update_structure))
+//        .def("update_structure", pure_virtual(&impl_type::update_structure))
         .def("remove_structure", pure_virtual(&impl_type::remove_structure))
         .def("get_structure_ids", pure_virtual(&impl_type::get_structure_ids))
         .def("get_def_structure_id", pure_virtual(&impl_type::get_def_structure_id))
diff --git a/binding/World.hpp b/binding/World.hpp
index dde75ab9..8e671cf0 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -407,7 +407,7 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("get_particle_ids_on_struct", &impl_type::get_particle_ids_on_struct)
         .def("add_species", &impl_type::add_species)
         // Structure stuff
-        .def("add_structure", &impl_type::add_structure)
+//        .def("add_structure", &impl_type::add_structure)
         .def("set_def_structure", &impl_type::set_def_structure)
         // StructureType stuff
         .def("add_structure_type", &impl_type::add_structure_type)

From b524fc4a8737053befd0e24ead1453ee8d47ed2d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 19:34:12 +0200
Subject: [PATCH 0855/1541] pythonizing the various add_structure methods in
 WOrld

---
 binding/World.hpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/binding/World.hpp b/binding/World.hpp
index 8e671cf0..12eaf177 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -407,7 +407,9 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("get_particle_ids_on_struct", &impl_type::get_particle_ids_on_struct)
         .def("add_species", &impl_type::add_species)
         // Structure stuff
-//        .def("add_structure", &impl_type::add_structure)
+        .def("add_structure", &impl_type::template add_structure<typename impl_type::planar_surface_type>)
+        .def("add_structure", &impl_type::template add_structure<typename impl_type::cuboidal_region_type>)
+        .def("add_structure", &impl_type::template add_structure<typename impl_type::cylindrical_surface_type>)
         .def("set_def_structure", &impl_type::set_def_structure)
         // StructureType stuff
         .def("add_structure_type", &impl_type::add_structure_type)

From fa35e7e1df4ed14a83342f2c13f3a4ef7803d16e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 8 May 2012 19:34:35 +0200
Subject: [PATCH 0856/1541] Hacking away at Pythonizing update_structure in
 ParticleContainerBase -> posponed

---
 binding/ParticleContainer.hpp | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 849ccfdb..f2f81c3b 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -357,6 +357,11 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::structures_range                     structures_range;
     typedef typename wrapped_type::structure_types_range                structure_types_range;
 
+    typedef typename wrapped_type::cuboidalreg_id_pair_type             cuboidalreg_id_pair_type;
+    typedef typename wrapped_type::planarsurface_id_pair_type           planarsurface_id_pair_type;
+    typedef typename wrapped_type::cylindrsurf_id_pair_type             cylindrsurf_id_pair_type;
+
+
     typedef typename wrapped_type::transaction_type                     transaction_type;
 
 public:    
@@ -400,11 +405,28 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_structures")();
     }
 /*
-    virtual bool update_structure(structure_id_pair const& structid_pair)
+    virtual bool update_structure(cuboidalreg_id_pair_type const& structid_pair)
+    {
+        return py_wrapper_type::get_override("update_structure")(structid_pair);
+    }
+
+    virtual bool update_structure(planarsurface_id_pair_type const& structid_pair)
+    {
+        return py_wrapper_type::get_override("update_structure")(structid_pair);
+    }
+
+    virtual bool update_structure(cylindrsurf_id_pair_type const& structid_pair)
+    {
+        return py_wrapper_type::get_override("update_structure")(structid_pair);
+    }
+
+    template<typename Tstructid_pair_>
+    bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         return py_wrapper_type::get_override("update_structure")(structid_pair);
     }
 */
+    
     virtual bool remove_structure(structure_id_type const& id)
     {
         return py_wrapper_type::get_override("remove_structure")(id);
@@ -589,6 +611,9 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
 //        .def("update_structure", pure_virtual(&impl_type::update_structure))
+//        .def("update_structure", &impl_type::template update_structure<typename impl_type::cuboidalreg_id_pair_type>)
+//        .def("update_structure", &impl_type::template update_structure<typename impl_type::planarsurface_id_pair_type>)
+//        .def("update_structure", &impl_type::template update_structure<typename impl_type::cylindrsurf_id_pair_type>)
         .def("remove_structure", pure_virtual(&impl_type::remove_structure))
         .def("get_structure_ids", pure_virtual(&impl_type::get_structure_ids))
         .def("get_def_structure_id", pure_virtual(&impl_type::get_def_structure_id))

From 0d38764a9d3fc09c9623e30f5640de6c56afc5dd Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 9 May 2012 14:43:39 +0200
Subject: [PATCH 0857/1541] implemented the versions to get neighbor info for
 planar_surface/cylindrical_surface/cuboidal_region

---
 StructureContainer.hpp | 44 ++++++++++++++++++++++++++++--------------
 1 file changed, 29 insertions(+), 15 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index bdcce912..b16a7fb2 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -93,13 +93,16 @@ class StructureContainer
             typename structure_map::const_iterator>                                 structure_iterator;
     typedef typename std::map<structure_id_type, structure_id_set>                  per_structure_substructure_id_set;
 
-    typedef ConnectivityContainer<structure_id_type, typename structure_type::position_type, 2> cylinders_boundaryconditions_type;
-    typedef ConnectivityContainer<structure_id_type, typename structure_type::position_type, 4> planes_boundaryconditions_type;
-    typedef ConnectivityContainer<structure_id_type, typename structure_type::position_type, 6> boxes_boundaryconditions_type;
-
     typedef CuboidalRegion<traits_type>                             cuboidalregion_type;
     typedef PlanarSurface<traits_type>                              planarsurface_type;
     typedef CylindricalSurface<traits_type>                         cylindricalsurface_type;
+
+    typedef typename structure_type::position_type                      vector_type;
+    typedef std::pair<structure_id_type, vector_type>                   neighbor_id_vector_type;
+    typedef ConnectivityContainer<structure_id_type, vector_type, 2>    cylinders_boundaryconditions_type;
+    typedef ConnectivityContainer<structure_id_type, vector_type, 4>    planes_boundaryconditions_type;
+    typedef ConnectivityContainer<structure_id_type, vector_type, 6>    boxes_boundaryconditions_type;
+
     typedef std::pair<structure_id_type, boost::shared_ptr<cuboidalregion_type> >       cuboidalreg_id_pair_type;
     typedef std::pair<structure_id_type, boost::shared_ptr<planarsurface_type> >        planarsurf_id_pair_type;
     typedef std::pair<structure_id_type, boost::shared_ptr<cylindricalsurface_type> >   cylindrsurf_id_pair_type;
@@ -159,10 +162,19 @@ class StructureContainer
         }
         return false;
     }
-/*    get_neighbor_info(PlanarSurface)
+    virtual neighbor_id_vector_type get_neighbor_info(const boost::shared_ptr<planarsurface_type> structure, int n) const
     {
+        planar_structs_bc_.get_neighbor_info(structure->id(), n);
     }
-*/
+    virtual neighbor_id_vector_type get_neighbor_info(const boost::shared_ptr<cylindricalsurface_type> structure, int n) const
+    {
+        cylindrical_structs_bc_.get_neighbor_info(structure->id(), n);
+    }
+    virtual neighbor_id_vector_type get_neighbor_info(const boost::shared_ptr<cuboidalregion_type> structure, int n) const
+    {
+        cuboidal_structs_bc_.get_neighbor_info(structure->id(), n);
+    }
+
     virtual structure_id_type get_def_structure_id() const
     {
         return default_structure_id_;
@@ -284,7 +296,6 @@ class StructureContainer
 template<typename T_, typename Ttraits_ >
 inline std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type>
 apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc,
-                ConnectivityContainer<typename Ttraits_::structure_id_type, typename Plane<T_>::position_type, 4> const& cc, // Plane<T_>::num_neighbors > const& cc,
                 std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
@@ -293,8 +304,10 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
 // query the boundary conditions and connectivity.
 {
     // useful typedefs
-    typedef Ttraits_    traits_type;
-    typedef Plane<T_>   plane_type;
+    typedef Ttraits_                    traits_type;
+    typedef Plane<T_>                   plane_type;
+    typedef PlanarSurface<traits_type>  planar_surface_type;
+
     typedef typename plane_type::length_type            length_type;
     typedef typename plane_type::position_type          position_type;
     typedef typename traits_type::structure_id_type     structure_id_type;
@@ -303,7 +316,8 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
-    const plane_type origin_plane (sc.get_structure(pos_structure_id.second)->shape());
+    const boost::shared_ptr<planar_surface_type> planar_surface(sc.get_structure(pos_structure_id.second));
+    const plane_type origin_plane (planar_surface->shape());
     boost::array<length_type, 2> half_extends(origin_plane.half_extent());
     const length_type origin_length_x (2*half_extends[0]);
     const length_type origin_length_y (2*half_extends[1]);
@@ -330,7 +344,8 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     {
         // we are at the 'top' of the plane (side nr. 0)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
-        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 0));
+        // TODO just pass origin_structure instead of plane and structure_id separately.
+        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 0));
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_x * origin_plane.unit_x();
@@ -341,7 +356,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     {
         // we are at the 'bottom' of the plane (side nr. 1)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
-        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 1));
+        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 1));
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_x * origin_plane.unit_x();
@@ -352,7 +367,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     {
         // we are at the 'left' of the plane (side nr. 2)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
-        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 2));
+        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 2));
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_y * origin_plane.unit_y();
@@ -363,8 +378,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     {
         // we are at the 'right' of the plane (side nr. 3)
         // this is a unit vector pointing from the edge between the two planes to the center of the plane
-        const position_type neighbor_plane_unit_inline (cc.get_neighbor_info(pos_structure_id.second, 3).second);
-        const neighbor_id_vector_type neighbor_id_vector (cc.get_neighbor_info(pos_structure_id.second, 3));
+        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 3));
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_y * origin_plane.unit_y();

From ee80171b5b8c4c7fbc638dd590502ed784807168 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 9 May 2012 16:09:24 +0200
Subject: [PATCH 0858/1541] implemented apply_boundary for cylinders and boxes
 too

---
 StructureContainer.hpp | 83 +++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 81 insertions(+), 2 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index b16a7fb2..c67084c4 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -311,8 +311,6 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     typedef typename plane_type::length_type            length_type;
     typedef typename plane_type::position_type          position_type;
     typedef typename traits_type::structure_id_type     structure_id_type;
-    typedef typename traits_type::structure_type        structure_type;
-    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
     typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
@@ -403,9 +401,90 @@ cyclic_transpose
 */
 
 ///// Functions for Cylinders
+template<typename T_, typename Ttraits_ >
+inline std::pair<typename Cylinder<T_>::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc,
+                std::pair<typename Cylinder<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
+// The template needs to be parameterized with the appropriate shape (which then parameterizes the type
+// of the ConnectivityContainer that we use.
+// We supply the structure container as an argument so that we can get the structures that we need.
+// The connectivity container then needs to a part of the structure container such that we can also
+// query the boundary conditions and connectivity.
+{
+    // useful typedefs
+    typedef Ttraits_                        traits_type;
+    typedef Cylinder<T_>                    cylinder_type;
+    typedef CylindricalSurface<traits_type> cylindrical_surface_type;
+
+    typedef typename cylinder_type::length_type         length_type;
+    typedef typename cylinder_type::position_type       position_type;
+    typedef typename traits_type::structure_id_type     structure_id_type;
+    typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
+
+    // Note that we assume that the new position is in the cylinder (dot(pos, unit_r)==0)
+    const boost::shared_ptr<cylindrical_surface_type> cylindrical_surface(sc.get_structure(pos_structure_id.second));
+    const cylinder_type origin_cylinder (cylindrical_surface->shape());
+    const length_type half_length(origin_cylinder.half_length());
+
+    // TODO do cyclic transpose here first
+    const position_type pos_vector( subtract(pos_structure_id.first, origin_cylinder.position()) );
+    const length_type component_z ( dot_product(pos_vector, origin_cylinder.unit_z()) );
+
+    // declare the variables that will be written
+    structure_id_type new_id(pos_structure_id.second);
+    position_type neighbor_cylinder_inl;
+
+    if ( half_length < component_z ) 
+    {
+        // we are at the 'right' side of the cylinder (side nr. 0, side in the direction of the normal vector)
+        // get the unit vector pointing from the edge between the two planes to the center of the plane
+        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(cylindrical_surface, 0));
+        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
+
+        new_id = neighbor_id_vector.first;
+        neighbor_cylinder_inl = (component_z - half_length - half_length_new)* neighbor_id_vector.second;
+    }
+    else if ( component_z < -half_length ) 
+    {
+        // we are at the 'right' side of the cylinder (side nr. 0, side in the direction of the normal vector)
+        // get the unit vector pointing from the edge between the two planes to the center of the plane
+        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(cylindrical_surface, 1));
+        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
+
+        new_id = neighbor_id_vector.first;
+        neighbor_cylinder_inl = (-component_z - half_length - half_length_new)* neighbor_id_vector.second;
+    }
+    else
+    {
+        // we are still in the cylinder (did not pass any of the boundaries)
+        // don't have to do anything
+        return pos_structure_id;
+    }
+
+    const position_type new_pos ( add(sc.get_structure(new_id)->position(), neighbor_cylinder_inl));
+    // TODO do normal apply_boundary too?
+    return std::make_pair(new_pos, new_id);
+}
 
 //// Functions for Boxes
+template<typename T_, typename Ttraits_ >
+inline std::pair<typename Box<T_>::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc,
+                std::pair<typename Box<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
+// The template needs to be parameterized with the appropriate shape (which then parameterizes the type
+// of the ConnectivityContainer that we use.
+// We supply the structure container as an argument so that we can get the structures that we need.
+// The connectivity container then needs to a part of the structure container such that we can also
+// query the boundary conditions and connectivity.
+{
+    // useful typedefs
+    typedef Ttraits_                        traits_type;
+    typedef Box<T_>                         box_type;
+    typedef typename box_type::length_type  length_type;
 
+    const length_type world_size(sc.get_structure(pos_structure_id.second)->shape().Lx());
+    return std::make_pair(traits_type::apply_boundary(pos_structure_id.first, world_size), pos_structure_id.second);
+}
 
 #endif /* STRUCTURE_CONTAINER_HPP */
 

From 0ae1237c3dd4d0e173db0534c5a4f82a8b0b90c5 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 9 May 2012 16:28:59 +0200
Subject: [PATCH 0859/1541] fixed bug in apply_boundary for planar surfaces.

---
 StructureContainer.hpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index c67084c4..21226a5e 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -317,8 +317,6 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     const boost::shared_ptr<planar_surface_type> planar_surface(sc.get_structure(pos_structure_id.second));
     const plane_type origin_plane (planar_surface->shape());
     boost::array<length_type, 2> half_extends(origin_plane.half_extent());
-    const length_type origin_length_x (2*half_extends[0]);
-    const length_type origin_length_y (2*half_extends[1]);
 
     // TODO do cyclic transpose here first
     const position_type pos_vector( subtract(pos_structure_id.first, origin_plane.position()) );
@@ -347,7 +345,8 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_x * origin_plane.unit_x();
-        neighbor_plane_inl = (component_y - origin_length_y)* neighbor_id_vector.second;
+        neighbor_plane_inl = add(half_extends[1]                * origin_plane.unit_y(),
+                                 (component_y - half_extends[1])* neighbor_id_vector.second );
     }
     else if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
               (component_y < -half_extends[1] ) )
@@ -358,7 +357,8 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_x * origin_plane.unit_x();
-        neighbor_plane_inl = (-component_y - origin_length_y)* neighbor_id_vector.second;
+        neighbor_plane_inl = add(-half_extends[1]                * origin_plane.unit_y(),
+                                 (-component_y - half_extends[1])* neighbor_id_vector.second );
     }
     else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
               (component_x < -half_extends[0]) )
@@ -369,7 +369,8 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_y * origin_plane.unit_y();
-        neighbor_plane_inl = (-component_x - origin_length_x)* neighbor_id_vector.second;
+        neighbor_plane_inl = add(-half_extends[0]                * origin_plane.unit_x(),
+                                 (-component_x - half_extends[0])* neighbor_id_vector.second );
     }
     else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
               (half_extends[0] < component_x) )
@@ -380,7 +381,8 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
 
         new_id = neighbor_id_vector.first;
         neighbor_plane_par = component_y * origin_plane.unit_y();
-        neighbor_plane_inl = (component_x - origin_length_x)* neighbor_id_vector.second;
+        neighbor_plane_inl = add(half_extends[0]                * origin_plane.unit_x(),
+                                 (component_x - half_extends[0])* neighbor_id_vector.second );
     }
     else
     {
@@ -389,7 +391,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
         return pos_structure_id;
     }
 
-    const position_type new_pos ( add(sc.get_structure(new_id)->position(),
+    const position_type new_pos ( add(origin_plane.position(),
                                       add(neighbor_plane_par, neighbor_plane_inl)));
     // TODO do normal apply_boundary too?
     return std::make_pair(new_pos, new_id);
@@ -482,8 +484,10 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     typedef Box<T_>                         box_type;
     typedef typename box_type::length_type  length_type;
 
-    const length_type world_size(sc.get_structure(pos_structure_id.second)->shape().Lx());
-    return std::make_pair(traits_type::apply_boundary(pos_structure_id.first, world_size), pos_structure_id.second);
+//    const length_type world_size(sc.get_structure(pos_structure_id.second)->shape().Lx());
+//    return std::make_pair(traits_type::apply_boundary(pos_structure_id.first, world_size), pos_structure_id.second);
+    // TODO do normal apply_boundary too?
+    return pos_structure_id;
 }
 
 #endif /* STRUCTURE_CONTAINER_HPP */

From ca441e24db1d151e612e260765d7244352330dc6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 9 May 2012 18:04:07 +0200
Subject: [PATCH 0860/1541] cleanup of signatures of apply_boundary for
 structures also add surface to signature to differentiate between the various
 types (overloading)

---
 StructureContainer.hpp | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 21226a5e..6e89c3c8 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -295,8 +295,9 @@ class StructureContainer
 //// functions for Planes
 template<typename T_, typename Ttraits_ >
 inline std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc,
-                std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
+apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                const boost::shared_ptr<PlanarSurface<Ttraits_> > planar_surface,
+                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
 // We supply the structure container as an argument so that we can get the structures that we need.
@@ -306,7 +307,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     // useful typedefs
     typedef Ttraits_                    traits_type;
     typedef Plane<T_>                   plane_type;
-    typedef PlanarSurface<traits_type>  planar_surface_type;
+//    typedef PlanarSurface<traits_type>  planar_surface_type;
 
     typedef typename plane_type::length_type            length_type;
     typedef typename plane_type::position_type          position_type;
@@ -314,7 +315,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
-    const boost::shared_ptr<planar_surface_type> planar_surface(sc.get_structure(pos_structure_id.second));
+//    const boost::shared_ptr<planar_surface_type> planar_surface(sc.get_structure(pos_structure_id.second));
     const plane_type origin_plane (planar_surface->shape());
     boost::array<length_type, 2> half_extends(origin_plane.half_extent());
 
@@ -405,8 +406,10 @@ cyclic_transpose
 ///// Functions for Cylinders
 template<typename T_, typename Ttraits_ >
 inline std::pair<typename Cylinder<T_>::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc,
-                std::pair<typename Cylinder<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
+apply_boundary (std::pair<typename Cylinder<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                const boost::shared_ptr<CylindricalSurface<Ttraits_> > cylindrical_surface,
+                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
+
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
 // We supply the structure container as an argument so that we can get the structures that we need.
@@ -416,7 +419,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     // useful typedefs
     typedef Ttraits_                        traits_type;
     typedef Cylinder<T_>                    cylinder_type;
-    typedef CylindricalSurface<traits_type> cylindrical_surface_type;
+//    typedef CylindricalSurface<traits_type> cylindrical_surface_type;
 
     typedef typename cylinder_type::length_type         length_type;
     typedef typename cylinder_type::position_type       position_type;
@@ -424,7 +427,7 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
     typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
 
     // Note that we assume that the new position is in the cylinder (dot(pos, unit_r)==0)
-    const boost::shared_ptr<cylindrical_surface_type> cylindrical_surface(sc.get_structure(pos_structure_id.second));
+//    const boost::shared_ptr<cylindrical_surface_type> cylindrical_surface(sc.get_structure(pos_structure_id.second));
     const cylinder_type origin_cylinder (cylindrical_surface->shape());
     const length_type half_length(origin_cylinder.half_length());
 
@@ -471,8 +474,9 @@ apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename T
 //// Functions for Boxes
 template<typename T_, typename Ttraits_ >
 inline std::pair<typename Box<T_>::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc,
-                std::pair<typename Box<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id)
+apply_boundary (std::pair<typename Box<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                const boost::shared_ptr<CuboidalRegion<Ttraits_> > cuboidal_region,
+                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
 // We supply the structure container as an argument so that we can get the structures that we need.

From 5fed722851058cda5331c2942a42ad49fd724fa1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 9 May 2012 18:29:49 +0200
Subject: [PATCH 0861/1541] Basic implementation of testShell for
 CylindricalSurfaceCap

---
 shells.py | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 56 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 0b284ca1..ab32ddac 100755
--- a/shells.py
+++ b/shells.py
@@ -43,6 +43,7 @@
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
+    'CylindricalSurfaceCaptestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
     ]
@@ -1671,7 +1672,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
-            raise testShellError('(PlanarSurfaceInteration). %s' %
+            raise testShellError('(PlanarSurfaceInteraction). %s' %
                                  (str(e)))
 
 
@@ -1757,6 +1758,60 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, self.z_right(r/SAFETY), self.z_left(r/SAFETY)
 
+class CylindricalSurfaceCaptestShell(CylindricaltestShell, testInteractionSingle):
+
+    def __init__(self, single, target_structure, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testInteractionSingle.__init__(self, single, single.structure, target_structure)
+
+        # initialize scaling parameters
+        self.dzdr_right = numpy.inf
+        self.drdz_right = 0.0
+        self.r0_right   = self.pid_particle_pair[1].radius
+        self.z0_right   = 0.0
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = self.pid_particle_pair[1].radius      # TODO put to zero?
+        self.z0_left    = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR
+
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
+        except ShellmakingError as e:
+            raise testShellError('(CylindricalSurfaceCap). %s' %
+                                 (str(e)))
+
+    def get_orientation_vector(self):
+        # The orientation vector is collinear with the parent cylinder axis and
+        # pointing "inwards", i.e. towards the center point of the parent cylinder
+        # TODO Check that this works properly!
+        return self.reference_vector     # reference vector always points from the particle position
+                                         # projected onto the target surface towards particle pos.
+
+    def get_searchpoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_referencepoint(self):
+        return self.reference_point         # calculated in the __init__ of testInteractionSingle
+
+    def get_min_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR
+        dz_right = self.particle_surface_distance + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        return dr, dz_right, dz_left
+        
+    def get_max_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
+        return dr, dz_right, dz_left
+
+    def apply_safety(self, r, z_right, z_left):
+        return r, z_right/SAFETY, z_left
+
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):

From e32c3f3b0363ac3f4f28f8edcaa579e784993b07 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 9 May 2012 18:46:01 +0200
Subject: [PATCH 0862/1541] Basic implementation of CylindricalSurfaceCapSingle

Testing and debugging still to be done here.
---
 single.py | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)

diff --git a/single.py b/single.py
index e429e225..939cd4ce 100644
--- a/single.py
+++ b/single.py
@@ -27,6 +27,7 @@
     'NonInteractionSingle',
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
+    'CylindricalSurfaceCapSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'TransitionSingle',
@@ -949,6 +950,97 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
+class CylindricalSurfaceCapSingle(InteractionSingle):
+    """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
+       limited by a cap. The cap is a reactive surface to the particle
+       and defines the exit point from the cylinder.
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+        * Selected randomly when drawing displacement vector: none. # TODO What does this mean?
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        assert isinstance(testShell, CylindricalSurfaceCaptestShell)
+        InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+
+        self.zcap = self.shell.get_referencepoint()
+
+    def get_inner_dz_left(self):
+        # This is the distance that the particle can travel from its initial position
+        # towards the reactive cap.
+        # For the cap it is the center of particle that "reacts" with it.
+        # The testShell is taking this into account at construction to ensure that
+        # there is enough space around the cap in case of reaction.
+        # Note that the reference point of the shell is the cap position.
+        return self.shell.particle_surface_distance
+
+    def get_inner_dz_right(self):
+        # This is the distance that the particle can travel from its initial position
+        # towards the absorbing cylinder boundary opposite of the cap.
+        # Note that the reference point of the shell is the cap position,
+        # therefore we have to subtract particle_surface_distance here.
+        return self.shell.dz_right - self.shell.particle_surface_distance
+                                   - self.pid_particle_pair[1].radius
+        # TODO is shell.dz_right always positive?
+
+    def determine_next_event(self):
+        """Return an (event_time, event_type)-tuple.
+
+        """
+        return min(self.draw_reaction_time_tuple(),
+                   self.draw_iv_event_time_tuple())
+
+    def iv_greens_function(self):
+
+        # zcap = position of the cap relative to the initial particle position.
+        # zabs = position of the absorbing cylinder boundary opposite of the cap
+        dz_cap = -self.get_inner_dz_left()
+        dz_abs = self.get_inner_dz_right()
+
+        return GreensFunction1DRadAbs(self.D, self.v, self.interaction_ktot, 0.0, dz_cap, dz_abs)
+
+    def draw_new_position(self, dt, event_type):
+
+        oldpos = self.pid_particle_pair[1].position
+
+        if self.D == 0 or \
+                (event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0):
+            newpos = oldpos
+        else:
+            gf = self.iv_greens_function()
+
+            if event_type == EventType.IV_INTERACTION:
+                # The particle left the domain through the reactive boundary, i.e. bound to the cap.
+                dz = -self.get_inner_dz_left()
+                structure_id = self.target_structure.id
+
+            elif event_type == EventType.IV_ESCAPE:
+                # The particle left the domain through the absorbing boundary,
+                # i.e. opposite of the cap.
+                dz = self.get_inner_dz_right()
+                structure_id = self.origin_structure.id
+
+            else:
+                # Some other event took place and the particle didn't escape;
+                # as a consequence it stays on the origin structure.
+                dz = draw_r_wrapper(gf, dt, -self.get_inner_dz_left(), self.get_inner_dz_right()) # TODO Is this sampling correctly?
+                structure_id = self.origin_structure.id
+
+            # Add displacement to particle.position.
+            # The direction of the shell is leading (not direction of the structure)
+            # The convention is that shell.shape.unit_z points from the cap towards
+            # the particle's initial position.
+            dz_vector = self.shell.shape.unit_z * dz
+            newpos = oldpos + dz_vector
+
+        return newpos, structure_id
+
+    def __str__(self):
+        return 'CylindricalSurfaceCapSingle ' + Single.__str__(self)
+
+
 class TransitionSingle(Single, TransitionTools, Others):
     """TransitionSingles are used when a particle changes from
        one structure to another. The difference to an InteractionSingle

From 9cea392d2b26a40084779a12cf80d182c0870dae Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 9 May 2012 18:47:16 +0200
Subject: [PATCH 0863/1541] Implement CylindricalSurfaceCapSingle and its
 testShell into egfrd.py

---
 egfrd.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c260ca96..dccb0fb5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -85,7 +85,9 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
     elif isinstance(single.structure, PlanarSurface):
         raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
-        if isinstance(target_structure, CylindricalSurface):     # TODO differentiate between a sink and a cap
+        if isinstance(target_structure, DiskSurface):
+            return CylindricalSurfaceCaptestShell (single, target_structure, geometrycontainer, domains)
+        elif isinstance(target_structure, CylindricalSurface):
             return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported')
@@ -97,6 +99,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfaceCaptestShell):
+        return CylindricalSurfaceCapSingle   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
@@ -1534,8 +1538,8 @@ def make_new_domain(self, single):
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
-            if isinstance(surface, PlanarSurface):
-                # with a planar surface it is the center of mass that 'looks around'
+            if isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
+                # with a planar or disk surface it is the center of mass that 'looks around'
                 surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
             else:
                 # with a cylindrical surface it is the surface of the particle
@@ -1563,7 +1567,7 @@ def make_new_domain(self, single):
             elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
                 domain = self.try_transition(single, obj)
 
-            elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
+            elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface):
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
 

From eb6f272a347803097464acef2065fea314b049fe Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 10 May 2012 18:24:37 +0200
Subject: [PATCH 0864/1541] Fix indent error

---
 single.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 939cd4ce..08f77031 100644
--- a/single.py
+++ b/single.py
@@ -981,7 +981,7 @@ def get_inner_dz_right(self):
         # towards the absorbing cylinder boundary opposite of the cap.
         # Note that the reference point of the shell is the cap position,
         # therefore we have to subtract particle_surface_distance here.
-        return self.shell.dz_right - self.shell.particle_surface_distance
+        return self.shell.dz_right - self.shell.particle_surface_distance \
                                    - self.pid_particle_pair[1].radius
         # TODO is shell.dz_right always positive?
 

From 63548323f20dabbb69c5e4c4d36e18a999f34256 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 10 May 2012 19:40:37 +0200
Subject: [PATCH 0865/1541] Minor changes to adapt Disk implementation to
 current state

---
 DiskSurface.hpp         | 17 ++++++++++++-----
 Plane.hpp               |  2 +-
 StructureUtils.hpp      |  7 ++++---
 binding/DiskSurface.hpp |  3 ++-
 4 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 3330c39c..b12519b4 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -15,8 +15,9 @@ class DiskSurface
 
 public:
     typedef BasicSurfaceImpl<Ttraits_, Disk<typename Ttraits_::world_type::traits_type::length_type> > base_type;
-    typedef typename base_type::traits_type             traits_type;
-    typedef typename base_type::identifier_type         identifier_type;        // This is just the name of the structure
+    typedef typename base_type::traits_type             traits_type;    
+    typedef typename base_type::structure_name_type     structure_name_type;
+    typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
     typedef typename base_type::shape_type              shape_type;
     typedef typename base_type::rng_type                rng_type;
@@ -217,6 +218,12 @@ class DiskSurface
         else
             return false;
     }
+    
+    // This should replace above two methods. TODO Copied from CylindricalStructure up to now
+    virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
+    {
+        return base_type::distance(new_pos);
+    }
 
     virtual length_type minimal_distance(length_type const& radius) const
     {
@@ -235,9 +242,9 @@ class DiskSurface
     {
         visitor(*this);
     }
-
-    DiskSurface(identifier_type const& id, structure_type_id_type const& sid, shape_type const& shape)
-        : base_type(id, sid, shape) {}
+        
+    DiskSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
+        : base_type(name, sid, parent_struct_id, shape) {}
 };
 
 #endif /* DISK_SURFACE_HPP */
diff --git a/Plane.hpp b/Plane.hpp
index c69baf31..dd321595 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -207,7 +207,7 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    position_type new_pos;
    
    length_type intersect_parameter;
-   length_type l_edge, l_perp;
+   length_type l_perp;
    
    bool changeflag = false;
    
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index d5cdb623..189fd0e1 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -96,14 +96,15 @@ struct StructureUtils
     
     static disk_surface_type* create_disk_surface(
             structure_type_id_type const& sid,
-            structure_id_type const& id,
+            structure_name_type const& name,
             position_type const& center,
             length_type const& radius,
-            position_type const& unit_z)
+            position_type const& unit_z,
+            structure_id_type const& parent_struct_id)
     {
         BOOST_ASSERT(is_cartesian_versor(unit_z));
 
-        return new disk_surface_type(id, sid,
+        return new disk_surface_type(name, sid, parent_struct_id,
                 disk_type(center, radius, unit_z));
     }
 
diff --git a/binding/DiskSurface.hpp b/binding/DiskSurface.hpp
index 6f6efa35..e7364f85 100644
--- a/binding/DiskSurface.hpp
+++ b/binding/DiskSurface.hpp
@@ -15,8 +15,9 @@ inline boost::python::objects::class_base register_disk_surface_class(char const
 
     return class_<impl_type, bases<typename impl_type::base_type::base_type>,
            boost::shared_ptr<impl_type>, boost::noncopyable>(
-            name, init<typename impl_type::identifier_type,
+            name, init<typename impl_type::structure_name_type,
                        typename impl_type::structure_type_id_type,
+                       typename impl_type::structure_id_type,
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))

From 7d1c12e6cca1979016ac5f6ce38189af894afe22 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 9 May 2012 18:29:49 +0200
Subject: [PATCH 0866/1541] Basic implementation of testShell for
 CylindricalSurfaceCap

---
 shells.py | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 56 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 0b284ca1..ab32ddac 100755
--- a/shells.py
+++ b/shells.py
@@ -43,6 +43,7 @@
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
+    'CylindricalSurfaceCaptestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
     ]
@@ -1671,7 +1672,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
-            raise testShellError('(PlanarSurfaceInteration). %s' %
+            raise testShellError('(PlanarSurfaceInteraction). %s' %
                                  (str(e)))
 
 
@@ -1757,6 +1758,60 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, self.z_right(r/SAFETY), self.z_left(r/SAFETY)
 
+class CylindricalSurfaceCaptestShell(CylindricaltestShell, testInteractionSingle):
+
+    def __init__(self, single, target_structure, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testInteractionSingle.__init__(self, single, single.structure, target_structure)
+
+        # initialize scaling parameters
+        self.dzdr_right = numpy.inf
+        self.drdz_right = 0.0
+        self.r0_right   = self.pid_particle_pair[1].radius
+        self.z0_right   = 0.0
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = self.pid_particle_pair[1].radius      # TODO put to zero?
+        self.z0_left    = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR
+
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
+        except ShellmakingError as e:
+            raise testShellError('(CylindricalSurfaceCap). %s' %
+                                 (str(e)))
+
+    def get_orientation_vector(self):
+        # The orientation vector is collinear with the parent cylinder axis and
+        # pointing "inwards", i.e. towards the center point of the parent cylinder
+        # TODO Check that this works properly!
+        return self.reference_vector     # reference vector always points from the particle position
+                                         # projected onto the target surface towards particle pos.
+
+    def get_searchpoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_referencepoint(self):
+        return self.reference_point         # calculated in the __init__ of testInteractionSingle
+
+    def get_min_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR
+        dz_right = self.particle_surface_distance + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        return dr, dz_right, dz_left
+        
+    def get_max_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
+        return dr, dz_right, dz_left
+
+    def apply_safety(self, r, z_right, z_left):
+        return r, z_right/SAFETY, z_left
+
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):

From 0fd1b08ce7069367488bc01f29cd7fa0aa43aec0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 9 May 2012 18:46:01 +0200
Subject: [PATCH 0867/1541] Basic implementation of CylindricalSurfaceCapSingle

Testing and debugging still to be done here.
---
 single.py | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)

diff --git a/single.py b/single.py
index e429e225..939cd4ce 100644
--- a/single.py
+++ b/single.py
@@ -27,6 +27,7 @@
     'NonInteractionSingle',
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
+    'CylindricalSurfaceCapSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'TransitionSingle',
@@ -949,6 +950,97 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
+class CylindricalSurfaceCapSingle(InteractionSingle):
+    """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
+       limited by a cap. The cap is a reactive surface to the particle
+       and defines the exit point from the cylinder.
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+        * Selected randomly when drawing displacement vector: none. # TODO What does this mean?
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        assert isinstance(testShell, CylindricalSurfaceCaptestShell)
+        InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+
+        self.zcap = self.shell.get_referencepoint()
+
+    def get_inner_dz_left(self):
+        # This is the distance that the particle can travel from its initial position
+        # towards the reactive cap.
+        # For the cap it is the center of particle that "reacts" with it.
+        # The testShell is taking this into account at construction to ensure that
+        # there is enough space around the cap in case of reaction.
+        # Note that the reference point of the shell is the cap position.
+        return self.shell.particle_surface_distance
+
+    def get_inner_dz_right(self):
+        # This is the distance that the particle can travel from its initial position
+        # towards the absorbing cylinder boundary opposite of the cap.
+        # Note that the reference point of the shell is the cap position,
+        # therefore we have to subtract particle_surface_distance here.
+        return self.shell.dz_right - self.shell.particle_surface_distance
+                                   - self.pid_particle_pair[1].radius
+        # TODO is shell.dz_right always positive?
+
+    def determine_next_event(self):
+        """Return an (event_time, event_type)-tuple.
+
+        """
+        return min(self.draw_reaction_time_tuple(),
+                   self.draw_iv_event_time_tuple())
+
+    def iv_greens_function(self):
+
+        # zcap = position of the cap relative to the initial particle position.
+        # zabs = position of the absorbing cylinder boundary opposite of the cap
+        dz_cap = -self.get_inner_dz_left()
+        dz_abs = self.get_inner_dz_right()
+
+        return GreensFunction1DRadAbs(self.D, self.v, self.interaction_ktot, 0.0, dz_cap, dz_abs)
+
+    def draw_new_position(self, dt, event_type):
+
+        oldpos = self.pid_particle_pair[1].position
+
+        if self.D == 0 or \
+                (event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0):
+            newpos = oldpos
+        else:
+            gf = self.iv_greens_function()
+
+            if event_type == EventType.IV_INTERACTION:
+                # The particle left the domain through the reactive boundary, i.e. bound to the cap.
+                dz = -self.get_inner_dz_left()
+                structure_id = self.target_structure.id
+
+            elif event_type == EventType.IV_ESCAPE:
+                # The particle left the domain through the absorbing boundary,
+                # i.e. opposite of the cap.
+                dz = self.get_inner_dz_right()
+                structure_id = self.origin_structure.id
+
+            else:
+                # Some other event took place and the particle didn't escape;
+                # as a consequence it stays on the origin structure.
+                dz = draw_r_wrapper(gf, dt, -self.get_inner_dz_left(), self.get_inner_dz_right()) # TODO Is this sampling correctly?
+                structure_id = self.origin_structure.id
+
+            # Add displacement to particle.position.
+            # The direction of the shell is leading (not direction of the structure)
+            # The convention is that shell.shape.unit_z points from the cap towards
+            # the particle's initial position.
+            dz_vector = self.shell.shape.unit_z * dz
+            newpos = oldpos + dz_vector
+
+        return newpos, structure_id
+
+    def __str__(self):
+        return 'CylindricalSurfaceCapSingle ' + Single.__str__(self)
+
+
 class TransitionSingle(Single, TransitionTools, Others):
     """TransitionSingles are used when a particle changes from
        one structure to another. The difference to an InteractionSingle

From a1708f28a0ce4d6fb643da9a29db22da657f1a26 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 9 May 2012 18:47:16 +0200
Subject: [PATCH 0868/1541] Implement CylindricalSurfaceCapSingle and its
 testShell into egfrd.py

---
 egfrd.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c260ca96..dccb0fb5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -85,7 +85,9 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
     elif isinstance(single.structure, PlanarSurface):
         raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
-        if isinstance(target_structure, CylindricalSurface):     # TODO differentiate between a sink and a cap
+        if isinstance(target_structure, DiskSurface):
+            return CylindricalSurfaceCaptestShell (single, target_structure, geometrycontainer, domains)
+        elif isinstance(target_structure, CylindricalSurface):
             return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported')
@@ -97,6 +99,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfaceCaptestShell):
+        return CylindricalSurfaceCapSingle   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
@@ -1534,8 +1538,8 @@ def make_new_domain(self, single):
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
-            if isinstance(surface, PlanarSurface):
-                # with a planar surface it is the center of mass that 'looks around'
+            if isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
+                # with a planar or disk surface it is the center of mass that 'looks around'
                 surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
             else:
                 # with a cylindrical surface it is the surface of the particle
@@ -1563,7 +1567,7 @@ def make_new_domain(self, single):
             elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
                 domain = self.try_transition(single, obj)
 
-            elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface):
+            elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface):
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
 

From 49cdbeca135cd999b1587f31584a4f39765e1a50 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 10 May 2012 18:24:37 +0200
Subject: [PATCH 0869/1541] Fix indent error

---
 single.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 939cd4ce..08f77031 100644
--- a/single.py
+++ b/single.py
@@ -981,7 +981,7 @@ def get_inner_dz_right(self):
         # towards the absorbing cylinder boundary opposite of the cap.
         # Note that the reference point of the shell is the cap position,
         # therefore we have to subtract particle_surface_distance here.
-        return self.shell.dz_right - self.shell.particle_surface_distance
+        return self.shell.dz_right - self.shell.particle_surface_distance \
                                    - self.pid_particle_pair[1].radius
         # TODO is shell.dz_right always positive?
 

From 8e0f2a064dfc8b18a57e287f0483b5bb7150a053 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 10:46:43 +0200
Subject: [PATCH 0870/1541] Import DiskSurface into egfrd.py

---
 egfrd.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/egfrd.py b/egfrd.py
index dccb0fb5..1443af5f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -17,6 +17,7 @@
     ParticleContainer,
     CuboidalRegion,
     CylindricalSurface,
+    DiskSurface,
     PlanarSurface,
     Surface,
     _random_vector,

From dfae2d25b88d5cfc57f7138c24626b3d436daffb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 10:59:21 +0200
Subject: [PATCH 0871/1541] ... and also Disk

---
 egfrd.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/egfrd.py b/egfrd.py
index 1443af5f..d00152ae 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -22,6 +22,7 @@
     Surface,
     _random_vector,
     Cylinder,
+    Disk,
     Sphere,
     Plane,
     NetworkRulesWrapper,

From aa7cf8d1a33d4b4fa285c1be19f6408856dfcc19 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 12:18:27 +0200
Subject: [PATCH 0872/1541] General debugging of cap interaction implementation

---
 egfrd.py  | 31 +++++++++++++++++++++++--------
 shells.py | 26 ++++++++++++++++----------
 single.py | 14 ++++++++++----
 3 files changed, 49 insertions(+), 22 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d00152ae..c801c022 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -51,6 +51,7 @@
     CylindricalSurfacePairtestShell,
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
+    CylindricalSurfaceCaptestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
     )
@@ -1542,7 +1543,7 @@ def make_new_domain(self, single):
         for surface, surface_distance in surface_distances:
             if isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
                 # with a planar or disk surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 5 # HACK
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
@@ -2700,11 +2701,25 @@ def check_shape_overlap(self, shape1, shape2):
                 else:
                     raise RuntimeError('check_shape_overlap: planes and cylinders should be either parallel or perpendicular.')
 
-        # overlap criterium when both shells are cylindrical 
-        elif (type(shape1) is Cylinder) and (type(shape2) is Cylinder):
+        # overlap criterium when both shells are cylindrical or disks (= cylinders with half_length = 0.0)
+        elif (type(shape1) is Cylinder) and (type(shape2) is Cylinder) or \
+             (type(shape1) is Cylinder) and (type(shape2) is Disk) or \
+             (type(shape1) is Disk)     and (type(shape2) is Cylinder) or \
+             (type(shape1) is Disk)     and (type(shape2) is Disk) :
 
-            if math.sqrt(shape1.half_length**2 + shape1.radius**2) < self.world.distance(shape2, shape1.position) or \
-               math.sqrt(shape2.half_length**2 + shape2.radius**2) < self.world.distance(shape1, shape2.position):
+            # Disk has no property half_length, so check type before any calculation
+            if type(shape1) is Disk:
+                shape1_hl = 0.0
+            else:
+                shape1_hl = shape1.half_length
+
+            if type(shape2) is Disk:
+                shape2_hl = 0.0
+            else:
+                shape2_hl = shape2.half_length
+
+            if math.sqrt(shape1_hl**2 + shape1.radius**2) < self.world.distance(shape2, shape1.position) or \
+               math.sqrt(shape2_hl**2 + shape2.radius**2) < self.world.distance(shape1, shape2.position):
                 # if cylinder2 is outside the sphere surrounding the cylinder.
                 return 1
             else: 
@@ -2714,16 +2729,16 @@ def check_shape_overlap(self, shape1, shape2):
                 inter_pos = shape1_post - shape2_pos
 
                 relative_orientation = numpy.dot(shape1.unit_z, shape2.unit_z)
-                # if the unit_z of the plane is perpendicular to the axis of the cylinder.
+                # if the unit_z of cylinder1 is perpendicular to the axis of cylinder2.
                 if feq(relative_orientation, 0.0):
-                    return 1
+                    return 1                                      # TODO Why does this always return 1 ?
 
 
                 elif feq(abs(relative_orientation), 1.0):
                     inter_pos_z = shape2.unit_z * numpy.dot(inter_pos, shape2.unit_z)
                     inter_pos_r = inter_pos - inter_pos_z
                     overlap_r = length(inter_pos_r) - (shape1.radius + shape2.radius)
-                    overlap_z = length(inter_pos_z) - (shape1.half_length + shape2.half_length)
+                    overlap_z = length(inter_pos_z) - (shape1_hl + shape2_hl)
                     if (overlap_r < 0.0) and (overlap_z < 0.0):
                         return -(overlap_r * overlap_z)           # TODO: find better number for overlap measure
                     else:
diff --git a/shells.py b/shells.py
index ab32ddac..7bfac267 100755
--- a/shells.py
+++ b/shells.py
@@ -6,8 +6,10 @@
     Sphere,
     SphericalShell,
     Cylinder,
-    CylindricalShell,
+    CylindricalShell,    
     CylindricalSurface,
+    Disk,
+    DiskSurface,
     Plane,
     PlanarSurface,
     CuboidalRegion,
@@ -692,7 +694,7 @@ def get_radius_to_SphericalShape(shape, testShell, r):
     return min(r, r_new)
 
 # functions to size up a testShell to a Cylindrical shape object
-def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_left):
+def get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shape, testShell, r, z_right, z_left):
     # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
     # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
     # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
@@ -700,12 +702,16 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
     # Note that the 'shell' is querried from this domain earlier by the testShell.
     # -> the shell MUST be a Cylinder.
-    assert (type(shape) is Cylinder)
+    assert (type(shape) is Cylinder) or (type(shape) is Disk)
 
     # Laurens' algorithm (part2)
     shell_position = shape.position
     shell_radius = shape.radius 
-    shell_half_length = shape.half_length 
+
+    if type(shape) is Cylinder:
+        shell_half_length = shape.half_length 
+    else: # shape is Disk and has no property half_length
+        shell_half_length = 0.0
 
 
     # get the reference point and orientation of the domain to scale
@@ -985,10 +991,10 @@ def r1(x):
             z1_new = min(z1, z1_function(r_new))
 
         else:
-            raise RuntimeError('get_dr_dzright_dzleft_to_CylindricalShape: Bad situation for making cylinders against cylinders.')
+            raise RuntimeError('get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape: Bad situation for making cylinders against cylinders.')
 
     else:
-        raise NotImplementedError('get_dr_dzright_dzleft_to_CylindricalShape: Cylinders should be oriented parallel or perpendicular.')
+        raise NotImplementedError('get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape: Cylinders should be oriented parallel or perpendicular.')
 
     z2_new = min(z2, z2_function(r_new))
 
@@ -1305,9 +1311,9 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # or planar surfaces and parallel to the testCylinder axis
         for surface, distance in neighbor_surfaces:
             # TODO
-            if isinstance(surface, CylindricalSurface):
-                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_CylindricalShape(surface.shape, self,
-                                                                                              dr, dz_right, dz_left)
+            if isinstance(surface, CylindricalSurface) or isinstance(surface, DiskSurface):
+                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(surface.shape, self,
+                                                                                              dr, dz_right, dz_left)            
             elif isinstance(surface, PlanarSurface):
                 dr, dz_right, dz_left = get_dr_dzright_dzleft_to_PlanarShape(surface.shape, self,
                                                                                          dr, dz_right, dz_left)
@@ -1330,7 +1336,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
                     dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self,
                                                                                                 dr, dz_right, dz_left)
                 elif isinstance(shell_appearance.shape, Cylinder):
-                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_CylindricalShape(shell_appearance.shape, self,
+                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shell_appearance.shape, self,
                                                                                                   dr, dz_right, dz_left)
                 else:
                     assert False, "Wrong type of shell shape"
diff --git a/single.py b/single.py
index 08f77031..23f5dc19 100644
--- a/single.py
+++ b/single.py
@@ -3,9 +3,11 @@
     CylindricalShell,
     Sphere,
     Cylinder,
+    Disk,
     CuboidalRegion,
     PlanarSurface,
     CylindricalSurface,
+    DiskSurface,
     )
 from _greens_functions import *
 from greens_function_wrapper import *
@@ -965,7 +967,11 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         assert isinstance(testShell, CylindricalSurfaceCaptestShell)
         InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
-        self.zcap = self.shell.get_referencepoint()
+        self.zcap = self.testShell.get_referencepoint()
+
+    def getv(self):
+        return self.pid_particle_pair[1].v
+    v = property(getv)
 
     def get_inner_dz_left(self):
         # This is the distance that the particle can travel from its initial position
@@ -974,15 +980,15 @@ def get_inner_dz_left(self):
         # The testShell is taking this into account at construction to ensure that
         # there is enough space around the cap in case of reaction.
         # Note that the reference point of the shell is the cap position.
-        return self.shell.particle_surface_distance
+        return self.testShell.particle_surface_distance
 
     def get_inner_dz_right(self):
         # This is the distance that the particle can travel from its initial position
         # towards the absorbing cylinder boundary opposite of the cap.
         # Note that the reference point of the shell is the cap position,
         # therefore we have to subtract particle_surface_distance here.
-        return self.shell.dz_right - self.shell.particle_surface_distance \
-                                   - self.pid_particle_pair[1].radius
+        return self.testShell.dz_right - self.testShell.particle_surface_distance \
+                                       - self.pid_particle_pair[1].radius
         # TODO is shell.dz_right always positive?
 
     def determine_next_event(self):

From 738df684bac91a04414c0005a8bea31ec2c7be37 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 12:24:13 +0200
Subject: [PATCH 0873/1541] Rename CylindricalSurfaceCapSingle into
 CylindricalSurfaceCapInteraction

... as it should be called correctly!
---
 egfrd.py  | 8 ++++----
 shells.py | 6 +++---
 single.py | 8 ++++----
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c801c022..edd9f305 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -51,7 +51,7 @@
     CylindricalSurfacePairtestShell,
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
-    CylindricalSurfaceCaptestShell,
+    CylindricalSurfaceCapInteractiontestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
     )
@@ -89,7 +89,7 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
         raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(target_structure, DiskSurface):
-            return CylindricalSurfaceCaptestShell (single, target_structure, geometrycontainer, domains)
+            return CylindricalSurfaceCapInteractiontestShell (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, CylindricalSurface):
             return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
         else:
@@ -102,8 +102,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfaceCaptestShell):
-        return CylindricalSurfaceCapSingle   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
+        return CylindricalSurfaceCapInteraction   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
diff --git a/shells.py b/shells.py
index 7bfac267..5ff95fd3 100755
--- a/shells.py
+++ b/shells.py
@@ -45,7 +45,7 @@
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
-    'CylindricalSurfaceCaptestShell',
+    'CylindricalSurfaceCapInteractiontestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
     ]
@@ -1764,7 +1764,7 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, self.z_right(r/SAFETY), self.z_left(r/SAFETY)
 
-class CylindricalSurfaceCaptestShell(CylindricaltestShell, testInteractionSingle):
+class CylindricalSurfaceCapInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
@@ -1787,7 +1787,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
-            raise testShellError('(CylindricalSurfaceCap). %s' %
+            raise testShellError('(CylindricalSurfaceCapInteraction). %s' %
                                  (str(e)))
 
     def get_orientation_vector(self):
diff --git a/single.py b/single.py
index 23f5dc19..722c077b 100644
--- a/single.py
+++ b/single.py
@@ -29,7 +29,7 @@
     'NonInteractionSingle',
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
-    'CylindricalSurfaceCapSingle',
+    'CylindricalSurfaceCapInteraction',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'TransitionSingle',
@@ -952,7 +952,7 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
-class CylindricalSurfaceCapSingle(InteractionSingle):
+class CylindricalSurfaceCapInteraction(InteractionSingle):
     """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
        limited by a cap. The cap is a reactive surface to the particle
        and defines the exit point from the cylinder.
@@ -964,7 +964,7 @@ class CylindricalSurfaceCapSingle(InteractionSingle):
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
-        assert isinstance(testShell, CylindricalSurfaceCaptestShell)
+        assert isinstance(testShell, CylindricalSurfaceCapInteractiontestShell)
         InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
         self.zcap = self.testShell.get_referencepoint()
@@ -1044,7 +1044,7 @@ def draw_new_position(self, dt, event_type):
         return newpos, structure_id
 
     def __str__(self):
-        return 'CylindricalSurfaceCapSingle ' + Single.__str__(self)
+        return 'CylindricalSurfaceCapInteraction ' + Single.__str__(self)
 
 
 class TransitionSingle(Single, TransitionTools, Others):

From bff67fdc7d124b1f58aceb35c29eba26b697a28a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 14:12:07 +0200
Subject: [PATCH 0874/1541] Basic implementation of DiskSurfaceSingle +
 testShell

---
 egfrd.py  |  5 +++
 shells.py | 53 ++++++++++++++++++++++++++++++--
 single.py | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 147 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index edd9f305..8d02c35b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -49,6 +49,7 @@
     PlanarSurfaceTransitionPairtestShell,
     CylindricalSurfaceSingletestShell,
     CylindricalSurfacePairtestShell,
+    DiskSurfaceSingletestShell,
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceCapInteractiontestShell,
@@ -75,6 +76,10 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
         # first make the test shell
         testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
+    elif isinstance(structure, DiskSurface):
+        # first make the test shell
+        testSingle = DiskSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+        return DiskSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
 
 ### Interactions
 def try_default_testinteraction(single, target_structure, geometrycontainer, domains):
diff --git a/shells.py b/shells.py
index 5ff95fd3..dab412fb 100755
--- a/shells.py
+++ b/shells.py
@@ -42,6 +42,7 @@
     'PlanarSurfaceTransitionSingletestShell',
     'PlanarSurfaceTransitionPairtestShell',
     'CylindricalSurfaceSingletestShell',
+    'DiskSurfaceSingletestShell',
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
@@ -1598,6 +1599,52 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left/SAFETY
 
+class DiskSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
+
+    def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)
+        testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
+
+        # initialize scaling parameters
+        self.dzdr_right = numpy.inf
+        self.drdz_right = 0.0
+        self.r0_right   = self.pid_particle_pair[1].radius
+        self.z0_right   = 0.0
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = self.pid_particle_pair[1].radius      # TODO put to zero?
+        self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+
+        # sizing up the shell to a zero shell
+        self.dz_right = self.pid_particle_pair[1].radius
+        self.dz_left  = self.pid_particle_pair[1].radius
+        self.dr       = self.pid_particle_pair[1].radius        
+
+    def get_orientation_vector(self):
+        return self.structure.shape.unit_z
+        # just copy from disk structure; note that this defines the direction of dissociation!        
+
+    def get_searchpoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_referencepoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_min_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        dz_right = dz_left
+        return dr, dz_right, dz_left
+        
+    def get_max_dr_dzright_dzleft(self):
+        dr       = self.pid_particle_pair[1].radius
+        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dz_right = dz_left
+        return dr, dz_right, dz_left
+
+    def apply_safety(self, r, z_right, z_left):
+        return r, z_right/SAFETY, z_left/SAFETY
+
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, testSimplePair):
 
@@ -1778,7 +1825,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = self.pid_particle_pair[1].radius      # TODO put to zero?
-        self.z0_left    = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR
+        self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
@@ -1805,13 +1852,13 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left  = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR
+        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         dz_right = self.particle_surface_distance + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left  = self.pid_particle_pair[1].radius / 2.0 * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
         return dr, dz_right, dz_left
 
diff --git a/single.py b/single.py
index 722c077b..238fa84e 100644
--- a/single.py
+++ b/single.py
@@ -23,6 +23,7 @@
 
 __all__ = [
     'CylindricalSurfaceSingle',
+    'DiskSurfaceSingle',
     'PlanarSurfaceSingle',
     'SphericalSingle',
     'Single',
@@ -571,6 +572,97 @@ def __str__(self):
         return 'CylindricalSurface' + Single.__str__(self)
 
 
+class DiskSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
+    """1 Particle inside a (cylindrical) shell on a DiskSurface. 
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+        * Selected randomly when drawing displacement vector: none.
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules):
+
+        assert isinstance(testShell, DiskSurfaceSingletestShell)
+        hasCylindricalShell.__init__(self, testShell, domain_id)
+        NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
+
+    def get_inner_a(self):
+        return self.pid_particle_pair[1].radius
+
+    def greens_function(self):
+        # The domain is created around r0, so r0 corresponds to r=0 within the domain
+        # The Green's function should not be used for anything on the DiskSurface
+        # but is defined for completeness here. # TODO Do we really have to do that?
+        inner_half_length = self.get_inner_a()
+        return GreensFunction1DAbsAbs(0.0, 0.0, 0.0, -inner_half_length, inner_half_length)
+
+    # these return corrected dimensions, since we reserve more space for the NonInteractionSingle
+    # For explanation see NonInteractionSingles and Others in shells.py
+    def shell_list_for_single(self):
+        # The shell should always be larger that the bare minimum for a test shell
+        # Note that in case of a cylindrical shell this fits inside of the spherical multi shell
+        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        if self.shell.shape.half_length < min_half_length:
+            # This should only happen if the domain is just initialized.
+            position = self.shell.shape.position
+            # There should always be space to make the spherical multi shell.
+            radius = self.pid_particle_pair[1].radius * MULTI_SHELL_FACTOR
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
+            return [(self.shell_id, fake_shell), ]
+        else:
+            return self.shell_list
+
+    def shell_list_for_other(self):
+        min_half_length = self.pid_particle_pair[1].radius * math.sqrt(SINGLE_SHELL_FACTOR**2 - 1.0)
+        if self.shell.shape.half_length < min_half_length:
+            position = self.shell.shape.position
+            radius = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+            # Keep all the other shells outside the burst radius (which is spherical!)
+            # Note that this makes the cylindrical shell have a slightly smaller radius than the burst radius.
+            fake_shell = SphericalShell(self.domain_id, Sphere(position, radius))
+            return [(self.shell_id, fake_shell), ]
+        else:
+            # When the shell is larger than the burst volume -> return the real shell.
+            return self.shell_list
+
+    def create_updated_shell(self, position):
+        # TODO what should we do with the position now?
+        # maybe update the reference_point of the shell before updating the shell
+        try:
+            dr, dz_right, dz_left = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])
+            dz_right = min(dz_right, dz_left)       # make sure the domain is symmetric around the particle
+            dz_left  = dz_right                     # This is not necessary but it's assumed later
+            center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
+                                                                             self.testShell.get_orientation_vector(),
+                                                                             dr, dz_right, dz_left)
+            return self.create_new_shell(center, radius, half_length, self.domain_id)
+        except ShellmakingError as e:
+            raise Exception('DiskSurfaceSingle, create_updated_shell failed: %s' % str(e) )
+
+    def create_position_vector(self, z):
+        # Particles on DiskStructures are immobile; always keep them in the center of the structure
+        return self.structure.shape.position
+
+    def check(self):
+        assert ProtectiveDomain.check(self)
+        # check shell stuff
+        assert isinstance(self.testShell, DiskSurfaceSingletestShell)
+        assert isinstance(self.shell.shape, Cylinder)
+
+        if self.is_reset():
+            assert self.shell.shape.half_length == self.pid_particle_pair[1].radius
+
+        assert self.is_reset() ^ (self.dt != 0.0)
+        assert isinstance(self.structure, DiskSurface)
+        #assert self.greens_function
+        assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
+
+        return True
+
+    def __str__(self):
+        return 'DiskSurface' + Single.__str__(self)
+
+
 class InteractionSingle(Single, hasCylindricalShell, Others):
     """Interactions singles are used when a particle is close to a 
     surface.

From aaec1353e123e8f7d184536bdd041a216d685fba Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 16:49:11 +0200
Subject: [PATCH 0875/1541] Fix some scaling parameters for DiskSurfaceSingle

---
 egfrd.py  | 34 ++++++++++++++++++++++++----------
 shells.py | 17 ++++++++---------
 2 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8d02c35b..6d84f96c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -968,6 +968,14 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                         (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
                         vector = reactant_pos + vector_length * unit_vector2D
                         product_pos_list.append(vector)
+
+                elif isinstance(reactant_structure, DiskSurface):
+                    a = myrandom.choice(-1, 1)
+                    directions = [-a,a]
+                    # place the center of mass of the particle 'at contact' with the membrane
+                    vector_length = (product_radius + 0.0) * (MINIMAL_SEPARATION_FACTOR - 1.0)  # the thickness of the membrane is 0.0
+                    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
+                                        for direction in directions]
                 else:
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
@@ -2580,6 +2588,11 @@ def check_domain(self, domain):
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
+        elif isinstance(domain, DiskSurfaceSingle):
+            # Particles bound to DiskSurfaces ignore all rods for now
+            # TODO Only ignore parent structure
+            ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
+            associated = [domain.structure.id]
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
             ignores = []
@@ -2713,14 +2726,11 @@ def check_shape_overlap(self, shape1, shape2):
              (type(shape1) is Disk)     and (type(shape2) is Disk) :
 
             # Disk has no property half_length, so check type before any calculation
-            if type(shape1) is Disk:
-                shape1_hl = 0.0
-            else:
+            shape1_hl = 0.0
+            shape2_hl = 0.0
+            if type(shape1) is Cylinder:
                 shape1_hl = shape1.half_length
-
-            if type(shape2) is Disk:
-                shape2_hl = 0.0
-            else:
+            if type(shape2) is Cylinder:                
                 shape2_hl = shape2.half_length
 
             if math.sqrt(shape1_hl**2 + shape1.radius**2) < self.world.distance(shape2, shape1.position) or \
@@ -2734,7 +2744,7 @@ def check_shape_overlap(self, shape1, shape2):
                 inter_pos = shape1_post - shape2_pos
 
                 relative_orientation = numpy.dot(shape1.unit_z, shape2.unit_z)
-                # if the unit_z of cylinder1 is perpendicular to the axis of cylinder2.
+                # if the unit_z of cylinder1 (disk1) is perpendicular to the axis of cylinder2 (disk2).
                 if feq(relative_orientation, 0.0):
                     return 1                                      # TODO Why does this always return 1 ?
 
@@ -2744,8 +2754,12 @@ def check_shape_overlap(self, shape1, shape2):
                     inter_pos_r = inter_pos - inter_pos_z
                     overlap_r = length(inter_pos_r) - (shape1.radius + shape2.radius)
                     overlap_z = length(inter_pos_z) - (shape1_hl + shape2_hl)
-                    if (overlap_r < 0.0) and (overlap_z < 0.0):
-                        return -(overlap_r * overlap_z)           # TODO: find better number for overlap measure
+                    if (overlap_r <= 0.0) and (overlap_z <= 0.0):
+                        if (overlap_r == 0.0) or (overlap_z == 0.0):
+                            # Special treatment of "direct overlap", i.e. e.g. two overlapping disks
+                            return -1
+                        else:
+                            return -(overlap_r * overlap_z)        # TODO: find better number for overlap measure
                     else:
                         return 1
                 else:
diff --git a/shells.py b/shells.py
index dab412fb..7410f4c8 100755
--- a/shells.py
+++ b/shells.py
@@ -1566,7 +1566,6 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.r0_left    = self.pid_particle_pair[1].radius
         self.z0_left    = 0.0
 
-
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
@@ -1610,10 +1609,10 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.drdz_right = 0.0
         self.r0_right   = self.pid_particle_pair[1].radius
         self.z0_right   = 0.0
-        self.dzdr_left  = 0.0
-        self.drdz_left  = numpy.inf
-        self.r0_left    = self.pid_particle_pair[1].radius      # TODO put to zero?
-        self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        self.dzdr_left  = numpy.inf
+        self.drdz_left  = 0.0
+        self.r0_left    = self.pid_particle_pair[1].radius
+        self.z0_left    = 0.0
 
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
@@ -1632,14 +1631,14 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-        dz_right = dz_left
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) #  TODO Use SINGLE_SHELL_FACTOR instead?
+        dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
-        dz_right = dz_left
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
+        dz_left  = dz_right
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):

From 71e4668c353cc3327118488bdc8c1c1bf89f4487 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 16:50:28 +0200
Subject: [PATCH 0876/1541] Fix some scaling parameters for DiskSurfaceSingle

---
 shells.py | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/shells.py b/shells.py
index dab412fb..7410f4c8 100755
--- a/shells.py
+++ b/shells.py
@@ -1566,7 +1566,6 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.r0_left    = self.pid_particle_pair[1].radius
         self.z0_left    = 0.0
 
-
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
@@ -1610,10 +1609,10 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.drdz_right = 0.0
         self.r0_right   = self.pid_particle_pair[1].radius
         self.z0_right   = 0.0
-        self.dzdr_left  = 0.0
-        self.drdz_left  = numpy.inf
-        self.r0_left    = self.pid_particle_pair[1].radius      # TODO put to zero?
-        self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        self.dzdr_left  = numpy.inf
+        self.drdz_left  = 0.0
+        self.r0_left    = self.pid_particle_pair[1].radius
+        self.z0_left    = 0.0
 
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
@@ -1632,14 +1631,14 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-        dz_right = dz_left
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) #  TODO Use SINGLE_SHELL_FACTOR instead?
+        dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
-        dz_right = dz_left
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
+        dz_left  = dz_right
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):

From 8867ba20388efbc7496c7c93f612c71742faae99 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 May 2012 19:24:19 +0200
Subject: [PATCH 0877/1541] Modify fire_single_reaction to allow for
 dissociation from Disk

---
 egfrd.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6d84f96c..abffdb20 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -970,12 +970,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         product_pos_list.append(vector)
 
                 elif isinstance(reactant_structure, DiskSurface):
-                    a = myrandom.choice(-1, 1)
-                    directions = [-a,a]
-                    # place the center of mass of the particle 'at contact' with the membrane
-                    vector_length = (product_radius + 0.0) * (MINIMAL_SEPARATION_FACTOR - 1.0)  # the thickness of the membrane is 0.0
-                    product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
-                                        for direction in directions]
+                    vector_length = (2.0*product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # the thickness of the membrane is 0.0
+                    vector        = reactant_pos + vector_length * reactant_structure.shape.unit_z
+                    product_pos_list.append(vector)
+
                 else:
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')

From 9ed66ef8da29efcabc70a0172975959cb5728e4e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 11 May 2012 13:48:54 +0200
Subject: [PATCH 0878/1541] Moved ConnectityContainer to separate file
 ConnectivityContainer implements specific type of graph structure used to
 store the boundary conditions of the structures.

---
 ConnectivityContainer.hpp | 72 +++++++++++++++++++++++++++++++++++++++
 Makefile.am               |  1 +
 StructureContainer.hpp    | 68 +-----------------------------------
 3 files changed, 74 insertions(+), 67 deletions(-)
 create mode 100644 ConnectivityContainer.hpp

diff --git a/ConnectivityContainer.hpp b/ConnectivityContainer.hpp
new file mode 100644
index 00000000..c8533f69
--- /dev/null
+++ b/ConnectivityContainer.hpp
@@ -0,0 +1,72 @@
+#ifndef CONNECTIVITY_CONTAINER_HPP
+#define CONNECTIVITY_CONTAINER_HPP
+
+#include <boost/lexical_cast.hpp>
+#include "exceptions.hpp"
+
+
+template<typename Tobj_, typename Tdata_, std::size_t num_neighbors>
+class ConnectivityContainer
+// implements the datastructure of objects that each have exactly 'num_neighbors' neighbors and have Tdata_ data associated
+// with each edge from the one of the object to the other.
+// NOTE the edges to neighbors are MANDATORY and have a specific ORDER.
+
+// It allows you to check what structure you enter into when you leave the current one.
+{
+public:
+    typedef Tobj_          obj_type;               // is in our case the StructureID
+    typedef Tdata_         data_type;              // is the normal vector into the neighboring structure
+    typedef std::size_t    size_type;              // the type for the index in the array
+
+    typedef std::pair<obj_type, data_type>                                          obj_data_pair_type;
+
+protected:
+    // the structureID of the neighbor and the normal vector pointing from the
+    // intersection in the direction of the center of the neighbor
+    typedef boost::array<obj_data_pair_type, num_neighbors>                         obj_data_pair_array_type;
+    // the mapping from the structure and all its neighbors and how they are connected.
+    typedef std::map<obj_type, obj_data_pair_array_type>                            obj_neighbor_objdata_array_map;
+    typedef select_second<typename obj_neighbor_objdata_array_map::value_type>      obj_neighbor_objdata_second_selector_type;
+    typedef boost::transform_iterator<obj_neighbor_objdata_second_selector_type,
+            typename obj_neighbor_objdata_array_map::const_iterator>                obj_neighbor_objdata_array_iterator;
+
+public:
+    static const size_type max = num_neighbors;
+
+public:
+    void set_neighbor_info(obj_type const& obj, size_type const n, obj_data_pair_type const& obj_data_pair)
+    {
+        // check that the index is not too large
+        if ( n >= max )
+            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
+
+        neighbor_mapping_[obj][n] = obj_data_pair;
+    }
+
+    obj_data_pair_type get_neighbor_info(obj_type const& id, size_type const n) const
+    {
+        // check that the index is not too large
+        if ( n >= max )
+            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
+
+        typename obj_neighbor_objdata_array_map::const_iterator i(neighbor_mapping_.find(id));
+        if (neighbor_mapping_.end() == i)
+        {
+            throw not_found(std::string("Object not found(id=") + boost::lexical_cast<std::string>(id) + ")");
+        }
+        return (*i).second[n];
+    }
+
+    ConnectivityContainer() {}
+    // do we start with an empty container or do we construct it as a static object with n structures already connected.
+
+private:
+    // mapping StructureID -> array<(StructureID, vector3D), num_neighbors>
+    obj_neighbor_objdata_array_map  neighbor_mapping_;
+};
+
+
+////// Inline functions related to ConnectivityContainer
+
+#endif /* CONNECTIVITY_CONTAINER_HPP */
+
diff --git a/Makefile.am b/Makefile.am
index 695c67b6..9f73de72 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -51,6 +51,7 @@ noinst_HEADERS = \
 	BDSimulator.hpp\
 	bessel.hpp\
 	Box.hpp\
+    ConnectivityContainer.hpp\
 	ConsoleAppender.hpp\
 	Cylinder.hpp\
 	Defs.hpp\
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 6e89c3c8..db3e1ae1 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -4,78 +4,12 @@
 #include <boost/lexical_cast.hpp>
 #include "exceptions.hpp"
 #include "linear_algebra.hpp"
+#include "ConnectivityContainer.hpp"
 #include "CuboidalRegion.hpp"
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
 
 
-template<typename Tobj_, typename Tdata_, std::size_t num_neighbors>
-class ConnectivityContainer
-// implements the datastructure of objects that each have exactly 'num_neighbors' neighbors and have Tdata_ data associated
-// with each edge from the one of the object to the other.
-// NOTE the edges to neighbors are MANDATORY and have a specific ORDER.
-
-// It allows you to check what structure you enter into when you leave the current one.
-{
-public:
-    typedef Tobj_          obj_type;               // is in our case the StructureID
-    typedef Tdata_         data_type;              // is the normal vector into the neighboring structure
-    typedef std::size_t    size_type;              // the type for the index in the array
-
-    typedef std::pair<obj_type, data_type>                                          obj_data_pair_type;
-
-protected:
-    // the structureID of the neighbor and the normal vector pointing from the
-    // intersection in the direction of the center of the neighbor
-    typedef boost::array<obj_data_pair_type, num_neighbors>                         obj_data_pair_array_type;
-    // the mapping from the structure and all its neighbors and how they are connected.
-    typedef std::map<obj_type, obj_data_pair_array_type>                            obj_neighbor_objdata_array_map;
-    typedef select_second<typename obj_neighbor_objdata_array_map::value_type>      obj_neighbor_objdata_second_selector_type;
-    typedef boost::transform_iterator<obj_neighbor_objdata_second_selector_type,
-            typename obj_neighbor_objdata_array_map::const_iterator>                obj_neighbor_objdata_array_iterator;
-
-public:
-    static const size_type max = num_neighbors;
-
-public:
-    void set_neighbor_info(obj_type const& obj, size_type const n, obj_data_pair_type const& obj_data_pair)
-    {
-        // check that the index is not too large
-        if ( n >= max )
-            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
-
-        neighbor_mapping_[obj][n] = obj_data_pair;
-    }
-
-    obj_data_pair_type get_neighbor_info(obj_type const& id, size_type const n) const
-    {
-        // check that the index is not too large
-        if ( n >= max )
-            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
-
-        typename obj_neighbor_objdata_array_map::const_iterator i(neighbor_mapping_.find(id));
-        if (neighbor_mapping_.end() == i)
-        {
-            throw not_found(std::string("Object not found(id=") + boost::lexical_cast<std::string>(id) + ")");
-        }
-        return (*i).second[n];
-    }
-
-    ConnectivityContainer() {}
-    // do we start with an empty container or do we construct it as a static object with n structures already connected.
-
-private:
-    // mapping StructureID -> array<(StructureID, vector3D), num_neighbors>
-    obj_neighbor_objdata_array_map  neighbor_mapping_;
-};
-
-
-////// Inline functions related to ConnectivityContainer
-// TODO
-
-
-
-
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer
 {

From f2aa7913bd38c0bd1cb4bad8996062be786e5de0 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 9 May 2012 18:05:02 +0200
Subject: [PATCH 0879/1541] Multiple changes: -Implemented construction to
 allowing calling of the right apply_boundary function from a
 ParticleContainer -Bug fixed apply_boundary functions

---
 CuboidalRegion.hpp            |  13 ++++
 CylindricalSurface.hpp        |  14 ++++
 Multi.hpp                     |   7 ++
 ParticleContainer.hpp         |   6 +-
 ParticleContainerBase.hpp     |   9 ++-
 PlanarSurface.hpp             |  14 ++++
 SphericalSurface.hpp          |  13 ++++
 Structure.hpp                 |  11 +++-
 StructureContainer.hpp        | 120 +++++++++++++++++++++-------------
 Transaction.hpp               |   8 ++-
 binding/ParticleContainer.hpp |   7 ++
 11 files changed, 171 insertions(+), 51 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index d9f8ad1f..94389f3e 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -6,6 +6,10 @@
 #include "Box.hpp"
 #include "freeFunctions.hpp"
 
+template <typename Tobj_, typename Tid_, typename Ttraits_>
+class StructureContainer;
+
+
 template<typename Ttraits_>
 class CuboidalRegion
     : public BasicRegionImpl<Ttraits_, Box<typename Ttraits_::length_type> >
@@ -22,8 +26,10 @@ class CuboidalRegion
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
+    typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
     typedef typename traits_type::species_type          species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
+    typedef std::pair<typename traits_type::position_type, typename traits_type::structure_id_type> position_structid_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
@@ -126,6 +132,13 @@ class CuboidalRegion
         return base_type::distance(new_pos);
     }
 
+    // FIXME This is a mess but it works
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       structure_container_type const& structure_container) const
+    {
+        return structure_container.apply_boundary(*this, pos_struct_id);
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 3cf132b2..f4212171 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -7,6 +7,9 @@
 #include "freeFunctions.hpp"
 #include "geometry.hpp"
 
+template <typename Tobj_, typename Tid_, typename Ttraits_>
+class StructureContainer;
+
 template<typename Ttraits_>
 class CylindricalSurface
     : public BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::length_type> >
@@ -23,8 +26,11 @@ class CylindricalSurface
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
+    typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
+
     typedef typename traits_type::species_type          species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
+    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     // Gives a random position in the cylinder (1D)
@@ -203,6 +209,14 @@ class CylindricalSurface
         return (cylinder_radius + radius) * traits_type::MINIMAL_SEPARATION_FACTOR - cylinder_radius;
     }
 */
+
+    // FIXME This is a mess but it works
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       structure_container_type const& structure_container) const
+    {
+        return structure_container.apply_boundary(*this, pos_struct_id);
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/Multi.hpp b/Multi.hpp
index 5d2f6977..4de5eaf0 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -54,6 +54,7 @@ class MultiParticleContainer
     typedef typename world_type::particle_container_type::structure_id_set                  structure_id_set;
     typedef typename world_type::particle_container_type::particle_id_pair_and_distance_list    particle_id_pair_and_distance_list;
     typedef typename world_type::particle_container_type::structure_id_pair_and_distance_list   structure_id_pair_and_distance_list;
+    typedef typename world_type::particle_container_type::position_structid_pair_type       position_structid_pair_type;
 
     typedef typename Ttraits_::network_rules_type       network_rules_type;
     typedef typename Ttraits_::reaction_rule_type       reaction_rule_type;
@@ -265,6 +266,12 @@ class MultiParticleContainer
         return world_.apply_boundary(v);
     }
 
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       const boost::shared_ptr<structure_type> structure) const
+    {
+        return world_.apply_boundary(pos_struct_id, structure);
+    }
+
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
     {
         return world_.cyclic_transpose(p0, p1);
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index f40a2bdb..ca7b2f3d 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -37,6 +37,7 @@ class ParticleContainer
 
     typedef typename particle_type::shape_type                  particle_shape_type;
     typedef Transaction<traits_type>                            transaction_type;
+
     typedef CuboidalRegion<traits_type>                         cuboidal_region_type;
     typedef PlanarSurface<traits_type>                          planar_surface_type;
     typedef CylindricalSurface<traits_type>                     cylindrical_surface_type;
@@ -73,7 +74,7 @@ class ParticleContainer
 public:    
     typedef sized_iterator_range<structure_iterator>                            structures_range;
     typedef sized_iterator_range<structure_type_iterator>                       structure_types_range;
-
+    typedef std::pair<position_type, structure_id_type>                         position_structid_pair_type;
 
 
     virtual ~ParticleContainer() {};
@@ -146,6 +147,9 @@ class ParticleContainer
 
     virtual length_type apply_boundary(length_type const& v) const = 0;
 
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       const boost::shared_ptr<structure_type> structure) const = 0;
+
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const = 0;
 
     virtual length_type cyclic_transpose(length_type const& p0, length_type const& p1) const = 0;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 5047d062..4b757f30 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -121,11 +121,12 @@ class ParticleContainerBase
     typedef std::pair<particle_id_pair, length_type>                    particle_id_pair_and_distance;
     typedef sized_iterator_range<typename particle_matrix_type::const_iterator> particle_id_pair_range;
 
-    typedef StructureContainer<structure_type, structure_id_type, traits_type>       structure_container_type;
+    typedef StructureContainer<structure_type, structure_id_type, traits_type>  structure_container_type;
 
     typedef typename base_type::particle_id_pair_and_distance_list      particle_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance_list     structure_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance          structure_id_pair_and_distance;
+    typedef typename base_type::position_structid_pair_type             position_structid_pair_type;
 
 
 public:
@@ -177,6 +178,12 @@ class ParticleContainerBase
         return traits_type::apply_boundary(v, world_size());
     }
 
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       const boost::shared_ptr<structure_type> structure) const
+    {
+        return structure->apply_boundary(pos_struct_id, structures_);
+    }
+
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
     {
         return traits_type::cyclic_transpose(p0, p1, world_size());
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 5517e961..4ffc4318 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -6,6 +6,10 @@
 #include "Plane.hpp"
 #include "freeFunctions.hpp"
 
+template <typename Tobj_, typename Tid_, typename Ttraits_>
+class StructureContainer;
+
+
 template<typename Ttraits_>
 class PlanarSurface
     : public BasicSurfaceImpl<Ttraits_, Plane<typename Ttraits_::length_type> >
@@ -22,9 +26,11 @@ class PlanarSurface
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
+    typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
     typedef typename traits_type::species_type          species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
     typedef std::pair<position_type, length_type>       projected_type;
+    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     // Selects a random position in the plane
@@ -198,6 +204,14 @@ class PlanarSurface
         return radius * traits_type::MINIMAL_SEPARATION_FACTOR;
     }
 */
+    // FIXME This is a mess but it works
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       structure_container_type const& structure_container) const
+    {
+        return structure_container.apply_boundary(*this, pos_struct_id);
+    }
+
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index cac79827..a60f90f5 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -5,6 +5,9 @@
 #include "Sphere.hpp"
 #include "freeFunctions.hpp"
 
+template <typename Tobj_, typename Tid_, typename Ttraits_>
+class StructureContainer;
+
 template<typename Ttraits_>
 class SphericalSurface
     : public BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::length_type> >
@@ -19,8 +22,11 @@ class SphericalSurface
     typedef typename base_type::rng_type                    rng_type;
     typedef typename base_type::position_type               position_type;
     typedef typename base_type::length_type                 length_type;
+    typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
+
     typedef typename traits_type::species_type              species_type;
     typedef std::pair<position_type, position_type>         position_pair_type;
+    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     {
@@ -99,6 +105,13 @@ class SphericalSurface
         return 0.; // TODO
     }
 */
+    // FIXME This is a mess but it works
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       structure_container_type const& structure_container) const
+    {
+        return pos_struct_id;
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/Structure.hpp b/Structure.hpp
index 35508b59..fe809da9 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -12,9 +12,13 @@
 
 #include <sstream>
 #include "Vector3.hpp"
+#include "exceptions.hpp"
 #include "freeFunctions.hpp"
 #include "SpeciesTypeID.hpp"
 
+template <typename Tobj_, typename Tid, typename Ttraits_>
+class StructureContainer;
+
 template<typename Ttraits_>
 class Structure
 {
@@ -31,6 +35,8 @@ class Structure
     typedef std::pair<position_type, length_type>           projected_type;
     typedef std::pair<position_type, position_type>         position_pair_type;
     typedef std::pair<position_type, bool>                  position_flag_pair_type;
+    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
+    typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>   structure_container_type;
 
 public:
     virtual ~Structure() {}
@@ -120,7 +126,10 @@ class Structure
 	// Methods used for edge crossing (only for the planes so far)    
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
     virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const = 0;
-    
+
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       structure_container_type const& structure_container) const = 0;
+
 
     virtual std::size_t hash() const
     {
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index db3e1ae1..b8f2f2a8 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -9,6 +9,28 @@
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
 
+template <typename Tobj_, typename Tid_, typename Ttraits_>
+class StructureContainer;
+
+template<typename Ttraits_ >
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                PlanarSurface<Ttraits_> const& planar_surface,
+                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
+
+template<typename Ttraits_ >
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                CylindricalSurface<Ttraits_> const& cylindrical_surface,
+                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
+
+template<typename Ttraits_ >
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                CuboidalRegion<Ttraits_> const& cuboidal_region,
+                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
+
+
 
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer
@@ -31,6 +53,7 @@ class StructureContainer
     typedef PlanarSurface<traits_type>                              planarsurface_type;
     typedef CylindricalSurface<traits_type>                         cylindricalsurface_type;
 
+    typedef typename structure_type::position_type                      position_type;
     typedef typename structure_type::position_type                      vector_type;
     typedef std::pair<structure_id_type, vector_type>                   neighbor_id_vector_type;
     typedef ConnectivityContainer<structure_id_type, vector_type, 2>    cylinders_boundaryconditions_type;
@@ -43,7 +66,7 @@ class StructureContainer
 
 public:
     typedef sized_iterator_range<structure_iterator>                                structures_range;
-
+    typedef std::pair<position_type, structure_id_type>     position_structid_type;
 
 public:
     virtual ~StructureContainer() {};
@@ -96,17 +119,22 @@ class StructureContainer
         }
         return false;
     }
-    virtual neighbor_id_vector_type get_neighbor_info(const boost::shared_ptr<planarsurface_type> structure, int n) const
+    virtual neighbor_id_vector_type get_neighbor_info(planarsurface_type const& structure, int n) const
     {
-        planar_structs_bc_.get_neighbor_info(structure->id(), n);
+        planar_structs_bc_.get_neighbor_info(structure.id(), n);
     }
-    virtual neighbor_id_vector_type get_neighbor_info(const boost::shared_ptr<cylindricalsurface_type> structure, int n) const
+    virtual neighbor_id_vector_type get_neighbor_info(cylindricalsurface_type const& structure, int n) const
     {
-        cylindrical_structs_bc_.get_neighbor_info(structure->id(), n);
+        cylindrical_structs_bc_.get_neighbor_info(structure.id(), n);
     }
-    virtual neighbor_id_vector_type get_neighbor_info(const boost::shared_ptr<cuboidalregion_type> structure, int n) const
+    virtual neighbor_id_vector_type get_neighbor_info(cuboidalregion_type const& structure, int n) const
     {
-        cuboidal_structs_bc_.get_neighbor_info(structure->id(), n);
+        cuboidal_structs_bc_.get_neighbor_info(structure.id(), n);
+    }
+    template <typename Tstructure_>
+    position_structid_type apply_boundary(Tstructure_ const& structure, position_structid_type const& pos_struct_id) const
+    {
+        return ::apply_boundary(pos_struct_id, structure, *this);
     }
 
     virtual structure_id_type get_def_structure_id() const
@@ -226,11 +254,12 @@ class StructureContainer
 //////// Inline functions applicable to the StructureContainer
 
 
+
 //// functions for Planes
-template<typename T_, typename Ttraits_ >
-inline std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
-                const boost::shared_ptr<PlanarSurface<Ttraits_> > planar_surface,
+template<typename Ttraits_ >
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                PlanarSurface<Ttraits_> const& planar_surface,
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
@@ -240,7 +269,7 @@ apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::
 {
     // useful typedefs
     typedef Ttraits_                    traits_type;
-    typedef Plane<T_>                   plane_type;
+    typedef typename PlanarSurface<Ttraits_>::shape_type    plane_type;
 //    typedef PlanarSurface<traits_type>  planar_surface_type;
 
     typedef typename plane_type::length_type            length_type;
@@ -250,7 +279,7 @@ apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
 //    const boost::shared_ptr<planar_surface_type> planar_surface(sc.get_structure(pos_structure_id.second));
-    const plane_type origin_plane (planar_surface->shape());
+    const plane_type origin_plane (planar_surface.shape());
     boost::array<length_type, 2> half_extends(origin_plane.half_extent());
 
     // TODO do cyclic transpose here first
@@ -279,9 +308,9 @@ apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 0));
 
         new_id = neighbor_id_vector.first;
-        neighbor_plane_par = component_x * origin_plane.unit_x();
-        neighbor_plane_inl = add(half_extends[1]                * origin_plane.unit_y(),
-                                 (component_y - half_extends[1])* neighbor_id_vector.second );
+        neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
+        neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     half_extends[1]),
+                                 multiply(neighbor_id_vector.second, (component_y - half_extends[1]) ) );
     }
     else if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
               (component_y < -half_extends[1] ) )
@@ -291,9 +320,9 @@ apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 1));
 
         new_id = neighbor_id_vector.first;
-        neighbor_plane_par = component_x * origin_plane.unit_x();
-        neighbor_plane_inl = add(-half_extends[1]                * origin_plane.unit_y(),
-                                 (-component_y - half_extends[1])* neighbor_id_vector.second );
+        neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
+        neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     -half_extends[1] ),
+                                 multiply(neighbor_id_vector.second, (-component_y - half_extends[1]) ) );
     }
     else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
               (component_x < -half_extends[0]) )
@@ -303,9 +332,9 @@ apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 2));
 
         new_id = neighbor_id_vector.first;
-        neighbor_plane_par = component_y * origin_plane.unit_y();
-        neighbor_plane_inl = add(-half_extends[0]                * origin_plane.unit_x(),
-                                 (-component_x - half_extends[0])* neighbor_id_vector.second );
+        neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
+        neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     -half_extends[0]),
+                                 multiply(neighbor_id_vector.second, (-component_x - half_extends[0]) ) );
     }
     else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
               (half_extends[0] < component_x) )
@@ -315,9 +344,9 @@ apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 3));
 
         new_id = neighbor_id_vector.first;
-        neighbor_plane_par = component_y * origin_plane.unit_y();
-        neighbor_plane_inl = add(half_extends[0]                * origin_plane.unit_x(),
-                                 (component_x - half_extends[0])* neighbor_id_vector.second );
+        neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
+        neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     half_extends[0]),
+                                 multiply(neighbor_id_vector.second, (component_x - half_extends[0]) ) );
     }
     else
     {
@@ -331,17 +360,12 @@ apply_boundary (std::pair<typename Plane<T_>::position_type, typename Ttraits_::
     // TODO do normal apply_boundary too?
     return std::make_pair(new_pos, new_id);
 }
-/*
-template<>
-inline
-cyclic_transpose
-*/
 
 ///// Functions for Cylinders
-template<typename T_, typename Ttraits_ >
-inline std::pair<typename Cylinder<T_>::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (std::pair<typename Cylinder<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
-                const boost::shared_ptr<CylindricalSurface<Ttraits_> > cylindrical_surface,
+template<typename Ttraits_ >
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                CylindricalSurface<Ttraits_> const& cylindrical_surface,
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
 
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
@@ -352,7 +376,7 @@ apply_boundary (std::pair<typename Cylinder<T_>::position_type, typename Ttraits
 {
     // useful typedefs
     typedef Ttraits_                        traits_type;
-    typedef Cylinder<T_>                    cylinder_type;
+    typedef typename CylindricalSurface<Ttraits_>::shape_type    cylinder_type;
 //    typedef CylindricalSurface<traits_type> cylindrical_surface_type;
 
     typedef typename cylinder_type::length_type         length_type;
@@ -362,7 +386,7 @@ apply_boundary (std::pair<typename Cylinder<T_>::position_type, typename Ttraits
 
     // Note that we assume that the new position is in the cylinder (dot(pos, unit_r)==0)
 //    const boost::shared_ptr<cylindrical_surface_type> cylindrical_surface(sc.get_structure(pos_structure_id.second));
-    const cylinder_type origin_cylinder (cylindrical_surface->shape());
+    const cylinder_type origin_cylinder (cylindrical_surface.shape());
     const length_type half_length(origin_cylinder.half_length());
 
     // TODO do cyclic transpose here first
@@ -378,20 +402,22 @@ apply_boundary (std::pair<typename Cylinder<T_>::position_type, typename Ttraits
         // we are at the 'right' side of the cylinder (side nr. 0, side in the direction of the normal vector)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(cylindrical_surface, 0));
-        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
+//        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
 
         new_id = neighbor_id_vector.first;
-        neighbor_cylinder_inl = (component_z - half_length - half_length_new)* neighbor_id_vector.second;
+        neighbor_cylinder_inl = add( multiply(origin_cylinder.unit_z(),  half_length),
+                                     multiply(neighbor_id_vector.second, (component_z - half_length) ) );
     }
     else if ( component_z < -half_length ) 
     {
         // we are at the 'right' side of the cylinder (side nr. 0, side in the direction of the normal vector)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(cylindrical_surface, 1));
-        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
+//        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
 
         new_id = neighbor_id_vector.first;
-        neighbor_cylinder_inl = (-component_z - half_length - half_length_new)* neighbor_id_vector.second;
+        neighbor_cylinder_inl = add( multiply(origin_cylinder.unit_z() , -half_length),
+                                     multiply(neighbor_id_vector.second, (-component_z - half_length) ) );
     }
     else
     {
@@ -400,16 +426,16 @@ apply_boundary (std::pair<typename Cylinder<T_>::position_type, typename Ttraits
         return pos_structure_id;
     }
 
-    const position_type new_pos ( add(sc.get_structure(new_id)->position(), neighbor_cylinder_inl));
+    const position_type new_pos ( add(origin_cylinder.position(), neighbor_cylinder_inl) );
     // TODO do normal apply_boundary too?
     return std::make_pair(new_pos, new_id);
 }
 
 //// Functions for Boxes
-template<typename T_, typename Ttraits_ >
-inline std::pair<typename Box<T_>::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (std::pair<typename Box<T_>::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
-                const boost::shared_ptr<CuboidalRegion<Ttraits_> > cuboidal_region,
+template<typename Ttraits_ >
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                CuboidalRegion<Ttraits_> const& cuboidal_region,
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
@@ -419,8 +445,8 @@ apply_boundary (std::pair<typename Box<T_>::position_type, typename Ttraits_::st
 {
     // useful typedefs
     typedef Ttraits_                        traits_type;
-    typedef Box<T_>                         box_type;
-    typedef typename box_type::length_type  length_type;
+    typedef typename CuboidalRegion<Ttraits_>::shape_type    box_type;
+    typedef typename box_type::length_type          length_type;
 
 //    const length_type world_size(sc.get_structure(pos_structure_id.second)->shape().Lx());
 //    return std::make_pair(traits_type::apply_boundary(pos_structure_id.first, world_size), pos_structure_id.second);
diff --git a/Transaction.hpp b/Transaction.hpp
index 0c025033..b9cb17e5 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -91,7 +91,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     typedef typename particle_container_type::structure_types_range         structure_types_range;
     typedef typename particle_container_type::structure_id_set              structure_id_set;
     typedef typename particle_container_type::structure_id_pair             structure_id_pair;
-
+    typedef typename particle_container_type::position_structid_pair_type   position_structid_pair_type;
 
     // Particle Stuff
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
@@ -320,6 +320,12 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.apply_boundary(v);
     }
 
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       const boost::shared_ptr<structure_type> structure) const
+    {
+        return pc_.apply_boundary(pos_struct_id, structure);
+    }
+
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
     {
         return pc_.cyclic_transpose(p0, p1);
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index f2f81c3b..454a04e4 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -353,6 +353,7 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_pair_and_distance_list  structure_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
+    typedef typename wrapped_type::position_structid_pair_type          position_structid_pair_type;
     typedef typename wrapped_type::structure_id_set                     structure_id_set;
     typedef typename wrapped_type::structures_range                     structures_range;
     typedef typename wrapped_type::structure_types_range                structure_types_range;
@@ -562,6 +563,12 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("apply_boundary")(v);
     }
 
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       const boost::shared_ptr<structure_type> structure) const
+    {
+        return py_wrapper_type::get_override("apply_boundary")(pos_struct_id, structure);
+    }
+
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
     {
         return py_wrapper_type::get_override("cyclic_transpose")(p0, p1);

From 804d1b803b73fd808d18ed516243174c76879c09 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 10 May 2012 19:37:40 +0200
Subject: [PATCH 0880/1541] using 'apply_boundary' method in BDpropagator to
 get new structure_id and position.

---
 newBDPropagator.hpp | 46 ++++++++++++---------------------------------
 1 file changed, 12 insertions(+), 34 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 643d90cd..72ac8a7a 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -130,7 +130,7 @@ class newBDPropagator
         const length_type                             r0( pp_species.radius() );
         const position_type                           old_pos( pp.second.position() );
         const structure_id_type                       old_struct_id(pp.second.structure_id());
-        const boost::shared_ptr<const structure_type> pp_structure( tx_.get_structure( old_struct_id ) );
+        const boost::shared_ptr<structure_type> pp_structure( tx_.get_structure( old_struct_id ) );
         // declare variables to use
         position_type                   new_pos(old_pos);
         structure_id_type               new_structure_id( old_struct_id );
@@ -146,30 +146,10 @@ class newBDPropagator
                                                                             std::sqrt(2.0 * pp_species.D() * dt_),
                                                                             rng_) );
 
-            // TODO check if the new position is actually still in the structure
-            // else
-            // get 'connecting' structure and apply deflection. Should we do this recursively until the coordinate stays in the currents structure?
-            // This actually kinda similar to the boundary condition application.
-            new_pos = tx_.apply_boundary( add( old_pos, displacement ) );
-            if ( !(pp_structure->is_alongside(new_pos)) )
-            {
-                // TODO apply deflection and change structure_id with appropriate neighbor structure
-                //new_pos = ;
-                //new_structure_id = ;
-            }
-
-/*            const structure_id_type target_struct_id(pp_structure->get_target_structure(new_pos));
-
-            if (target_struct_id != pp_structure.id())
-            // The particle jumped to a new position outside of the current surface.
-            {
-                const structure_type target_structure(tx_.get_structure(target_struct_id));
-                new_structure_id = target_struct_id;
-                const position_flag_pair_type newpos_flag (target_structure->deflect(old_pos, displacement));
-                new_pos = newpos_flag.first;
-            }
-            // Else, just use the current information.
-*/
+            const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos, displacement), old_struct_id),
+                                                                              pp_structure));
+            new_pos = tx_.apply_boundary( pos_structid.first );
+            new_structure_id = pos_structid.second;
         }
 
         bool bounced( false );
@@ -900,17 +880,15 @@ class newBDPropagator
 
         if(species.D() != 0)
         {
-            const boost::shared_ptr<const structure_type> old_structure( tx_.get_structure( new_structure_id ) );
+            const boost::shared_ptr<structure_type> old_structure( tx_.get_structure( new_structure_id ) );
 
             const position_type displacement( old_structure->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
-            new_pos = tx_.apply_boundary( add( old_pos_struct_id.first, displacement ) );
-            if ( !(old_structure->is_alongside(new_pos)) )
-            {
-                // TODO apply deflection and change structure_id with appropriate neighbor structure
-                //new_pos = ;
-                //new_structure_id = ;
-            }
-        
+
+            const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos_struct_id.first, displacement), old_pos_struct_id.second),
+                                                                              old_structure));
+            new_pos = tx_.apply_boundary( pos_structid.first );
+            new_structure_id = pos_structid.second;
+
             // See if it overlaps with any particles
             const particle_shape_type new_shape(new_pos, species.radius());
             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles( 

From e354188b6ac4b0f183eaf2e0e54748daefc4319d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 14 May 2012 11:48:42 +0200
Subject: [PATCH 0881/1541] Used just the world 'apply_boundary' for the
 boundary conditions of the CuboidalRegion, since the world 'apply_boundary'
 has to be called anyway when we also apply the BC for the individual
 structures.

---
 CuboidalRegion.hpp        |  6 ++++--
 ParticleContainerBase.hpp |  9 ++++++++-
 StructureContainer.hpp    | 37 +------------------------------------
 newBDPropagator.hpp       |  4 ++--
 4 files changed, 15 insertions(+), 41 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 94389f3e..2c61e753 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -132,11 +132,13 @@ class CuboidalRegion
         return base_type::distance(new_pos);
     }
 
-    // FIXME This is a mess but it works
+    // The apply boundary for the cuboidal structure doesn't have to do anything because we'll apply the world
+    // boundary conditions later too.
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
     {
-        return structure_container.apply_boundary(*this, pos_struct_id);
+//        return structure_container.apply_boundary(*this, pos_struct_id);
+        return pos_struct_id;
     }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 4b757f30..157dc876 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -178,10 +178,17 @@ class ParticleContainerBase
         return traits_type::apply_boundary(v, world_size());
     }
 
+    // apply_boundary that takes the structure on which the particle lives into account
+    // This also applies the 'local' boundary conditions of the individual structures (reflecting, periodic, moving
+    // onto another adjacent structure etc).
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        const boost::shared_ptr<structure_type> structure) const
     {
-        return structure->apply_boundary(pos_struct_id, structures_);
+        // The generalized boundary condition application first:
+        // 1. applies the boundary of the structure/surface (go around the corner etc)
+        const position_structid_pair_type new_pos_struct_id(structure->apply_boundary(pos_struct_id, structures_));
+        // 2. Then also apply the boundary condition of the world
+        return std::make_pair(apply_boundary(new_pos_struct_id.first), new_pos_struct_id.second);
     }
 
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index b8f2f2a8..8108447e 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -24,13 +24,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
                 CylindricalSurface<Ttraits_> const& cylindrical_surface,
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
 
-template<typename Ttraits_ >
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
-                CuboidalRegion<Ttraits_> const& cuboidal_region,
-                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
-
-
 
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer
@@ -107,6 +100,7 @@ class StructureContainer
     virtual bool update_structure (cuboidalreg_id_pair_type const& structid_cube)
     {
         // add to Connectivity container for cuboidal regions
+        // NOTE this information is never queried!!
         if ( update_structure_base(structid_cube))
         {
             cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_z()));
@@ -127,10 +121,6 @@ class StructureContainer
     {
         cylindrical_structs_bc_.get_neighbor_info(structure.id(), n);
     }
-    virtual neighbor_id_vector_type get_neighbor_info(cuboidalregion_type const& structure, int n) const
-    {
-        cuboidal_structs_bc_.get_neighbor_info(structure.id(), n);
-    }
     template <typename Tstructure_>
     position_structid_type apply_boundary(Tstructure_ const& structure, position_structid_type const& pos_struct_id) const
     {
@@ -357,7 +347,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
 
     const position_type new_pos ( add(origin_plane.position(),
                                       add(neighbor_plane_par, neighbor_plane_inl)));
-    // TODO do normal apply_boundary too?
     return std::make_pair(new_pos, new_id);
 }
 
@@ -427,32 +416,8 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     }
 
     const position_type new_pos ( add(origin_cylinder.position(), neighbor_cylinder_inl) );
-    // TODO do normal apply_boundary too?
     return std::make_pair(new_pos, new_id);
 }
 
-//// Functions for Boxes
-template<typename Ttraits_ >
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
-                CuboidalRegion<Ttraits_> const& cuboidal_region,
-                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
-// The template needs to be parameterized with the appropriate shape (which then parameterizes the type
-// of the ConnectivityContainer that we use.
-// We supply the structure container as an argument so that we can get the structures that we need.
-// The connectivity container then needs to a part of the structure container such that we can also
-// query the boundary conditions and connectivity.
-{
-    // useful typedefs
-    typedef Ttraits_                        traits_type;
-    typedef typename CuboidalRegion<Ttraits_>::shape_type    box_type;
-    typedef typename box_type::length_type          length_type;
-
-//    const length_type world_size(sc.get_structure(pos_structure_id.second)->shape().Lx());
-//    return std::make_pair(traits_type::apply_boundary(pos_structure_id.first, world_size), pos_structure_id.second);
-    // TODO do normal apply_boundary too?
-    return pos_structure_id;
-}
-
 #endif /* STRUCTURE_CONTAINER_HPP */
 
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 72ac8a7a..0d399ad3 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -148,7 +148,7 @@ class newBDPropagator
 
             const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos, displacement), old_struct_id),
                                                                               pp_structure));
-            new_pos = tx_.apply_boundary( pos_structid.first );
+            new_pos = pos_structid.first;
             new_structure_id = pos_structid.second;
         }
 
@@ -886,7 +886,7 @@ class newBDPropagator
 
             const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos_struct_id.first, displacement), old_pos_struct_id.second),
                                                                               old_structure));
-            new_pos = tx_.apply_boundary( pos_structid.first );
+            new_pos = pos_structid.first;
             new_structure_id = pos_structid.second;
 
             // See if it overlaps with any particles

From 109b7e7bac6018b8fe573c1195902d21fe4e5674 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 14 May 2012 12:20:55 +0200
Subject: [PATCH 0882/1541] added clarifictions for the 'apply_boundary'
 functionality of the ParticleContainer and structures

---
 CuboidalRegion.hpp        | 1 -
 CylindricalSurface.hpp    | 2 +-
 ParticleContainerBase.hpp | 8 ++++++++
 PlanarSurface.hpp         | 2 +-
 SphericalSurface.hpp      | 3 ++-
 5 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 2c61e753..257358cc 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -137,7 +137,6 @@ class CuboidalRegion
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
     {
-//        return structure_container.apply_boundary(*this, pos_struct_id);
         return pos_struct_id;
     }
 
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index f4212171..d438c8d2 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -210,7 +210,7 @@ class CylindricalSurface
     }
 */
 
-    // FIXME This is a mess but it works
+    // FIXME This is a mess but it works. See ParticleContainerBase.hpp for explanation.
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
     {
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 157dc876..6945cf6b 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -181,6 +181,14 @@ class ParticleContainerBase
     // apply_boundary that takes the structure on which the particle lives into account
     // This also applies the 'local' boundary conditions of the individual structures (reflecting, periodic, moving
     // onto another adjacent structure etc).
+
+    // To call the right function for a particular Surface we:
+    // -first need to call the 'apply_boundary method of the structure in question with the StructureContainer as an argument (to get
+    //  the StructureContainer that we need to use ->structures don't know about the container they're in!)
+    // -second call the apply_boundary method of the structure_container using the structure (which is now of a fully speciefied type!!!)
+    //  as an argument (see for example PlanarSurface.hpp, NOT surface.hpp)
+    // -Use this fully defined type to call the right function through the template method 'apply_boundary' of the StructureContainer.
+    //  (See StructureContainer.hpp)
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        const boost::shared_ptr<structure_type> structure) const
     {
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 4ffc4318..4e197002 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -204,7 +204,7 @@ class PlanarSurface
         return radius * traits_type::MINIMAL_SEPARATION_FACTOR;
     }
 */
-    // FIXME This is a mess but it works
+    // FIXME This is a mess but it works. See ParticleContainerBase.hpp for explanation.
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
     {
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index a60f90f5..e4143ac1 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -105,10 +105,11 @@ class SphericalSurface
         return 0.; // TODO
     }
 */
-    // FIXME This is a mess but it works
+
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
     {
+        // The apply_boundary for a spherical surface is trivial (since there is no boundary!)
         return pos_struct_id;
     }
 

From f15e83cf8267ee50547f0cb91ebd9faf0fde4ffb Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 14 May 2012 12:21:47 +0200
Subject: [PATCH 0883/1541] some cleanup and clarification of the
 StructureContainer

---
 StructureContainer.hpp | 97 +++++++++++++++++++++++-------------------
 1 file changed, 54 insertions(+), 43 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 8108447e..7a358db1 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -9,9 +9,12 @@
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
 
+
+// Forward declaration of the StructureContainer to allow the forward declarations of the 'apply_boundary' functions
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer;
 
+// Forward declaration of the 'apply_boundary' functions needed in the definition of the StructureContainer below
 template<typename Ttraits_ >
 std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
@@ -25,6 +28,9 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
 
 
+
+
+
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer
 {
@@ -58,18 +64,16 @@ class StructureContainer
     typedef std::pair<structure_id_type, boost::shared_ptr<cylindricalsurface_type> >   cylindrsurf_id_pair_type;
 
 public:
-    typedef sized_iterator_range<structure_iterator>                                structures_range;
+    typedef sized_iterator_range<structure_iterator>        structures_range;
     typedef std::pair<position_type, structure_id_type>     position_structid_type;
 
+
+
 public:
+    // The destructor
     virtual ~StructureContainer() {};
 
-    // The constructor
-    StructureContainer(structure_id_type default_structid) : default_structure_id_(default_structid)
-    {
-        structure_substructures_map_[default_structid] = structure_id_set();
-    }
-
+    // Update_structure methods for the different kind of structures supported by the StructureContainer
     virtual bool update_structure (cylindrsurf_id_pair_type const& structid_cylinder)  // can I make this into a template function?
     {
         if ( update_structure_base(structid_cylinder))
@@ -100,7 +104,7 @@ class StructureContainer
     virtual bool update_structure (cuboidalreg_id_pair_type const& structid_cube)
     {
         // add to Connectivity container for cuboidal regions
-        // NOTE this information is never queried!!
+        // NOTE this information is never queried!! Maybe leave the neighbor info out?
         if ( update_structure_base(structid_cube))
         {
             cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_z()));
@@ -113,14 +117,19 @@ class StructureContainer
         }
         return false;
     }
+
+    // Methods to get the 'n-th' neighbor structure of a particular structure from the container.
+    // We pass the structure and not just the ID because with just the ID we can't differentiate between the various types of structures.
     virtual neighbor_id_vector_type get_neighbor_info(planarsurface_type const& structure, int n) const
     {
-        planar_structs_bc_.get_neighbor_info(structure.id(), n);
+        return planar_structs_bc_.get_neighbor_info(structure.id(), n);
     }
     virtual neighbor_id_vector_type get_neighbor_info(cylindricalsurface_type const& structure, int n) const
     {
-        cylindrical_structs_bc_.get_neighbor_info(structure.id(), n);
+        return cylindrical_structs_bc_.get_neighbor_info(structure.id(), n);
     }
+
+    // Template member function to call the right 'apply_boundary' function for the various types of structures.
     template <typename Tstructure_>
     position_structid_type apply_boundary(Tstructure_ const& structure, position_structid_type const& pos_struct_id) const
     {
@@ -141,6 +150,7 @@ class StructureContainer
         cuboidalregion->set_id(default_structure_id_);
         update_structure(std::make_pair(default_structure_id_, cuboidalregion));
     }
+
     virtual bool has_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
@@ -189,6 +199,15 @@ class StructureContainer
         return visible_structures;
     }
 
+    // The constructor
+    StructureContainer(structure_id_type default_structid) : default_structure_id_(default_structid)
+    {
+        structure_substructures_map_[default_structid] = structure_id_set();
+    }
+
+
+private:
+    // Update the datastructures that are general for all the structures.
     bool update_structure_base(structure_id_pair const& structid_pair)
     {
         typename structure_map::const_iterator i(structure_map_.find(structid_pair.first));
@@ -215,7 +234,7 @@ class StructureContainer
         structure_substructures_map_[structid_pair.first] = structure_id_set();
         return true;
     }
-private:
+
     // Get all the structure ids of the substructures
     structure_id_set get_substructure_ids(structure_id_type const& id) const
     {
@@ -228,6 +247,7 @@ class StructureContainer
         return (*i).second;
     }
 
+///// Member variables
 protected:
     structure_map                       structure_map_;     // mapping: structure_id -> structure
     per_structure_substructure_id_set   structure_substructures_map_;
@@ -243,8 +263,6 @@ class StructureContainer
 
 //////// Inline functions applicable to the StructureContainer
 
-
-
 //// functions for Planes
 template<typename Ttraits_ >
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
@@ -253,26 +271,25 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
-// We supply the structure container as an argument so that we can get the structures that we need.
-// The connectivity container then needs to a part of the structure container such that we can also
+// We supply the structure container as an argument so that we can get the structures that we need, and to
 // query the boundary conditions and connectivity.
 {
     // useful typedefs
-    typedef Ttraits_                    traits_type;
+    typedef Ttraits_        traits_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+
     typedef typename PlanarSurface<Ttraits_>::shape_type    plane_type;
-//    typedef PlanarSurface<traits_type>  planar_surface_type;
+    typedef typename plane_type::length_type                length_type;
+    typedef typename plane_type::position_type              position_type;
+
+    typedef std::pair<structure_id_type, position_type>     neighbor_id_vector_type;
 
-    typedef typename plane_type::length_type            length_type;
-    typedef typename plane_type::position_type          position_type;
-    typedef typename traits_type::structure_id_type     structure_id_type;
-    typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
-//    const boost::shared_ptr<planar_surface_type> planar_surface(sc.get_structure(pos_structure_id.second));
     const plane_type origin_plane (planar_surface.shape());
     boost::array<length_type, 2> half_extends(origin_plane.half_extent());
 
-    // TODO do cyclic transpose here first
+    // TODO do cyclic transpose here first?
     const position_type pos_vector( subtract(pos_structure_id.first, origin_plane.position()) );
     const length_type component_x ( dot_product(pos_vector, origin_plane.unit_x()) );
     const length_type component_y ( dot_product(pos_vector, origin_plane.unit_y()) );
@@ -293,8 +310,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
               (half_extends[1] < component_y) )
     {
         // we are at the 'top' of the plane (side nr. 0)
-        // get the unit vector pointing from the edge between the two planes to the center of the plane
-        // TODO just pass origin_structure instead of plane and structure_id separately.
+        // the 'vector' is the unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 0));
 
         new_id = neighbor_id_vector.first;
@@ -306,7 +322,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
               (component_y < -half_extends[1] ) )
     {
         // we are at the 'bottom' of the plane (side nr. 1)
-        // get the unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 1));
 
         new_id = neighbor_id_vector.first;
@@ -318,7 +333,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
               (component_x < -half_extends[0]) )
     {
         // we are at the 'left' of the plane (side nr. 2)
-        // get the unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 2));
 
         new_id = neighbor_id_vector.first;
@@ -330,7 +344,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
               (half_extends[0] < component_x) )
     {
         // we are at the 'right' of the plane (side nr. 3)
-        // this is a unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 3));
 
         new_id = neighbor_id_vector.first;
@@ -350,7 +363,8 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     return std::make_pair(new_pos, new_id);
 }
 
-///// Functions for Cylinders
+
+///// Functions for CylindricalSurfaces
 template<typename Ttraits_ >
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
@@ -359,26 +373,25 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
 
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
-// We supply the structure container as an argument so that we can get the structures that we need.
-// The connectivity container then needs to a part of the structure container such that we can also
-// query the boundary conditions and connectivity.
+// We supply the structure container as an argument so that we can get the structures that we need and
+// to query the boundary conditions and connectivity.
 {
     // useful typedefs
-    typedef Ttraits_                        traits_type;
-    typedef typename CylindricalSurface<Ttraits_>::shape_type    cylinder_type;
-//    typedef CylindricalSurface<traits_type> cylindrical_surface_type;
+    typedef Ttraits_        traits_type;
+    typedef typename traits_type::structure_id_type             structure_id_type;
+
+    typedef typename CylindricalSurface<Ttraits_>::shape_type   cylinder_type;
+    typedef typename cylinder_type::length_type                 length_type;
+    typedef typename cylinder_type::position_type               position_type;
+
+    typedef std::pair<structure_id_type, position_type>         neighbor_id_vector_type;
 
-    typedef typename cylinder_type::length_type         length_type;
-    typedef typename cylinder_type::position_type       position_type;
-    typedef typename traits_type::structure_id_type     structure_id_type;
-    typedef std::pair<structure_id_type, position_type> neighbor_id_vector_type;
 
     // Note that we assume that the new position is in the cylinder (dot(pos, unit_r)==0)
-//    const boost::shared_ptr<cylindrical_surface_type> cylindrical_surface(sc.get_structure(pos_structure_id.second));
     const cylinder_type origin_cylinder (cylindrical_surface.shape());
     const length_type half_length(origin_cylinder.half_length());
 
-    // TODO do cyclic transpose here first
+    // TODO do cyclic transpose here first?
     const position_type pos_vector( subtract(pos_structure_id.first, origin_cylinder.position()) );
     const length_type component_z ( dot_product(pos_vector, origin_cylinder.unit_z()) );
 
@@ -391,7 +404,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
         // we are at the 'right' side of the cylinder (side nr. 0, side in the direction of the normal vector)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(cylindrical_surface, 0));
-//        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
 
         new_id = neighbor_id_vector.first;
         neighbor_cylinder_inl = add( multiply(origin_cylinder.unit_z(),  half_length),
@@ -402,7 +414,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
         // we are at the 'right' side of the cylinder (side nr. 0, side in the direction of the normal vector)
         // get the unit vector pointing from the edge between the two planes to the center of the plane
         const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(cylindrical_surface, 1));
-//        const length_type half_length_new (sc.get_structure(new_id)->shape().half_length());
 
         new_id = neighbor_id_vector.first;
         neighbor_cylinder_inl = add( multiply(origin_cylinder.unit_z() , -half_length),

From 486327d2ea68d7ac209382554dce584aa238cee7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 13:50:32 +0200
Subject: [PATCH 0884/1541] Make CylindricalSurfaceInteraction ignore Disks

---
 egfrd.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index abffdb20..0a0dcfce 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2587,10 +2587,13 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
         elif isinstance(domain, DiskSurfaceSingle):
-            # Particles bound to DiskSurfaces ignore all rods for now
-            # TODO Only ignore parent structure
+            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore parent structure
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
             associated = [domain.structure.id]
+        elif isinstance(domain, CylindricalSurfaceInteraction):
+            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
+            ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
+            associated = [domain.origin_structure.id, domain.target_structure.id]
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
             ignores = []

From 4158422e3b7f7bb0f888a530ac71782fab7bdbaa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 14:44:48 +0200
Subject: [PATCH 0885/1541] Implement function that returns true if interction
 is allowed.

The function allows_interaction_from was implemented as a method to
structure.

It receives a position and returns "true" if an interaction with
the structure (be it Sphere, Cylinder, Disk or Plane) is allowed.

This can be used to define "valid" postiions from which particles
can interact with the different shapes.
---
 Box.hpp               |  10 +++
 Cylinder.hpp          |  15 ++++
 Disk.hpp              |  14 ++++
 Plane.hpp             | 170 ++++++++++++++++++++++--------------------
 Region.hpp            |   4 +
 Sphere.hpp            |   9 +++
 Structure.hpp         |   5 +-
 Surface.hpp           |   7 ++
 binding/Structure.hpp |   1 +
 9 files changed, 153 insertions(+), 82 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 93ff13ac..43cd9fc5 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -299,6 +299,16 @@ deflect_back(Box<T_> const& obj,
     return r;
 }
 
+template<typename T_>
+inline bool
+allows_interaction_from(Box<T_> const& obj,
+        typename Box<T_>::position_type const& r)
+{
+    // This function is not relevant for the box but has
+    // to return something for implementation reasons
+    return true;
+}
+
 template<typename T, typename Trng>
 inline typename Box<T>::position_type
 random_position(Box<T> const& shape, Trng& rng)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 08b53b65..f3304f38 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -222,6 +222,21 @@ deflect_back(Cylinder<T_> const& obj,
     return r;
 }
 
+template<typename T_>
+inline bool
+allows_interaction_from(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const& pos)
+// Returns true if a particle at position pos is supposed to interact with the cylinder
+{
+    typedef typename Cylinder<T_>::length_type length_type;
+
+    // The projection lies on the z-axis.
+    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    
+    // Only interact from points that are between the cylinder caps
+    // when projected onto the cylinder axis
+    return ( abs(r_z.second) <= obj.half_length() );
+}
+
 template<typename T, typename Trng>
 inline typename Cylinder<T>::position_type
 random_position(Cylinder<T> const& shape, Trng& rng)
diff --git a/Disk.hpp b/Disk.hpp
index 1a2d6263..b8bcba37 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -190,6 +190,20 @@ deflect_back(Disk<T_> const& obj,
     return r;
 }
 
+template<typename T_>
+inline bool
+allows_interaction_from(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
+// Returns true if a particle at position pos is supposed to interact with the disk
+{
+    typedef typename Disk<T_>::length_type length_type;
+
+    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    
+    // Return true if the projection of pos is within the disk's radius
+    return ( r_z.first <= obj.radius() );
+}
+
+
 template<typename T, typename Trng>
 inline typename Disk<T>::position_type
 random_position(Disk<T> const& shape, Trng& rng)
diff --git a/Plane.hpp b/Plane.hpp
index dd321595..f782692a 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -175,6 +175,90 @@ class Plane
     boost::array<length_type, 2> half_extent_;
 };
 
+template<typename T_>
+inline boost::array<typename Plane<T_>::length_type, 3>
+to_internal(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// The function calculates the coefficients to express 'pos' into the base of the plane 'obj'
+{
+    typedef typename Plane<T_>::position_type position_type;
+    position_type pos_vector(subtract(pos, obj.position()));
+
+    return array_gen<typename Plane<T_>::length_type>(
+        dot_product(pos_vector, obj.unit_x()),
+        dot_product(pos_vector, obj.unit_y()),
+        dot_product(pos_vector, obj.unit_z()));
+}
+
+template<typename T_>
+inline std::pair<typename Plane<T_>::position_type,
+                 typename Plane<T_>::length_type>
+projected_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Calculates the projection of 'pos' onto the plane 'obj' and also returns the coefficient
+// for the normal component (z) of 'pos' in the basis of the plane
+{
+    boost::array<typename Plane<T_>::length_type, 3> x_y_z(to_internal(obj, pos));
+    return std::make_pair(
+        add(add(obj.position(), multiply(obj.unit_x(), x_y_z[0])),
+                                multiply(obj.unit_y(), x_y_z[1])),
+        x_y_z[2]);
+}
+
+template<typename T_>
+inline std::pair<typename Plane<T_>::position_type,
+                 typename Plane<T_>::length_type>
+projected_point_on_surface(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Since the projected point on the plane, is already on the surface of the plane,
+// this function is just a wrapper of projected point.
+{
+    return projected_point(obj, pos);
+}
+
+template<typename T_>
+inline typename Plane<T_>::length_type
+distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Calculates the distance from 'pos' to plane 'obj' Note that when the plane is finite,
+// and also calculates the distance to the edge of the plane if necessary
+{
+    typedef typename Plane<T_>::length_type length_type;
+    boost::array<length_type, 3> const x_y_z(to_internal(obj, pos));
+
+    length_type const dx(subtract( abs(x_y_z[0]), obj.half_extent()[0]));
+    length_type const dy(subtract( abs(x_y_z[1]), obj.half_extent()[1]));
+
+    if (dx < 0 && dy < 0) {
+        // pos is positioned over the plane (projected point is in the plane and
+	    // not next to it).
+        return abs(x_y_z[2]);
+    }
+
+    if (dx > 0) // outside the plane in the x direction
+    {
+        if (dy > 0)
+        {
+            // outside the plane in both x and y direction
+            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(dy) +
+                             gsl_pow_2(x_y_z[2]));
+        }
+        else
+        {
+	    // outside the plane in x, but inside in y direction
+            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(x_y_z[2]));
+        }
+    }
+    else   // inside the plane in x direction
+    {
+        if (dy > 0)
+        {
+	    // outside the plane in y, but inside in x direction
+            return std::sqrt(gsl_pow_2(dy) + gsl_pow_2(x_y_z[2]));
+        }
+        else
+        {
+            // inside the plane in both x and y direction (see above)
+            return abs(x_y_z[2]);
+        }
+    }
+}
 
 template<typename T_>
 inline std::pair<typename Plane<T_>::position_type, bool>
@@ -304,88 +388,14 @@ deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, t
 }
 
 template<typename T_>
-inline boost::array<typename Plane<T_>::length_type, 3>
-to_internal(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// The function calculates the coefficients to express 'pos' into the base of the plane 'obj'
-{
-    typedef typename Plane<T_>::position_type position_type;
-    position_type pos_vector(subtract(pos, obj.position()));
-
-    return array_gen<typename Plane<T_>::length_type>(
-        dot_product(pos_vector, obj.unit_x()),
-        dot_product(pos_vector, obj.unit_y()),
-        dot_product(pos_vector, obj.unit_z()));
-}
-
-template<typename T_>
-inline std::pair<typename Plane<T_>::position_type,
-                 typename Plane<T_>::length_type>
-projected_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// Calculates the projection of 'pos' onto the plane 'obj' and also returns the coefficient
-// for the normal component (z) of 'pos' in the basis of the plane
+inline bool
+allows_interaction_from(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Returns true if a particle at position pos is supposed to interact with the plane
 {
     boost::array<typename Plane<T_>::length_type, 3> x_y_z(to_internal(obj, pos));
-    return std::make_pair(
-        add(add(obj.position(), multiply(obj.unit_x(), x_y_z[0])),
-                                multiply(obj.unit_y(), x_y_z[1])),
-        x_y_z[2]);
-}
-
-template<typename T_>
-inline std::pair<typename Plane<T_>::position_type,
-                 typename Plane<T_>::length_type>
-projected_point_on_surface(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// Since the projected point on the plane, is already on the surface of the plane,
-// this function is just a wrapper of projected point.
-{
-    return projected_point(obj, pos);
-}
-
-template<typename T_>
-inline typename Plane<T_>::length_type
-distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// Calculates the distance from 'pos' to plane 'obj' Note that when the plane is finite,
-// and also calculates the distance to the edge of the plane if necessary
-{
-    typedef typename Plane<T_>::length_type length_type;
-    boost::array<length_type, 3> const x_y_z(to_internal(obj, pos));
-
-    length_type const dx(subtract( abs(x_y_z[0]), obj.half_extent()[0]));
-    length_type const dy(subtract( abs(x_y_z[1]), obj.half_extent()[1]));
-
-    if (dx < 0 && dy < 0) {
-        // pos is positioned over the plane (projected point is in the plane and
-	    // not next to it).
-        return abs(x_y_z[2]);
-    }
-
-    if (dx > 0) // outside the plane in the x direction
-    {
-        if (dy > 0)
-        {
-            // outside the plane in both x and y direction
-            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(dy) +
-                             gsl_pow_2(x_y_z[2]));
-        }
-        else
-        {
-	    // outside the plane in x, but inside in y direction
-            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(x_y_z[2]));
-        }
-    }
-    else   // inside the plane in x direction
-    {
-        if (dy > 0)
-        {
-	    // outside the plane in y, but inside in x direction
-            return std::sqrt(gsl_pow_2(dy) + gsl_pow_2(x_y_z[2]));
-        }
-        else
-        {
-            // inside the plane in both x and y direction (see above)
-            return abs(x_y_z[2]);
-        }
-    }
+    
+    // Return true if projection of pos is within the confined plane
+    return ( abs(x_y_z[0]) <= obj.Lx() ) && ( abs(x_y_z[1]) <= obj.Ly() );
 }
 
 template<typename T, typename Trng>
diff --git a/Region.hpp b/Region.hpp
index f183c49f..c94c6bc0 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -121,6 +121,10 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::deflect_back(shape(), pos, u_z);
     }
     
+    virtual bool allows_interaction_from(position_type const& pos) const
+    {
+        return ::allows_interaction_from(shape(), pos);
+    }
 
     // The constructor
     BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
diff --git a/Sphere.hpp b/Sphere.hpp
index a982aa33..6ea486f2 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -122,6 +122,15 @@ deflect_back(Sphere<T_> const& obj,
     return r;
 }
 
+template<typename T_>
+inline bool
+allows_interaction_from(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
+// Returns true if a particle at position pos is supposed to interact with the sphere
+{
+    // By default any point outside the sphere can interact with it
+    return ( length(subtract(pos, obj.position())) >= obj.radius() ); 
+}
+
 template<typename T_>
 inline Sphere<T_> const& shape(Sphere<T_> const& shape)
 {
diff --git a/Structure.hpp b/Structure.hpp
index 2f8d1e57..d04ffa65 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -118,9 +118,10 @@ class Structure
     virtual projected_type projected_point(position_type const& pos) const = 0;
     virtual projected_type projected_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
-    virtual position_type const& position() const = 0;
+    virtual position_type const& position() const = 0;    
+    virtual bool allows_interaction_from(position_type const& pos) const = 0;
 
-	// Methods used for edge crossing (only for the planes so far)    
+    // Methods used for edge crossing (only for the planes so far)    
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
     virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const = 0;
     
diff --git a/Surface.hpp b/Surface.hpp
index 85dbd539..dc60a8cc 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -129,6 +129,13 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::deflect_back(shape(), pos, u_z);
     }
     
+    virtual bool allows_interaction_from(position_type const& pos) const
+    {
+        return ::allows_interaction_from(shape(), pos);
+        // returns true if a particle at position pos is supposed to
+        // be able to interact with the surface
+    }
+    
     // Constructor
     BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
         : base_type(name, sid, parent_struct_id), shape_(shape) {}
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 9b5fc973..fc6bbc46 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -46,6 +46,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("projected_point", &impl_type::projected_point)
+        .def("allows_interaction_from", &impl_type::allows_interaction_from)
         .def("deflect", &impl_type::deflect)
         .def("deflect_back", &impl_type::deflect_back)
         ;

From 87f597dd0581b37e0eff4b3d813b94a5818e36a3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 15:07:28 +0200
Subject: [PATCH 0886/1541] Make egfrd.py use new allows_interction_from
 function

---
 egfrd.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0a0dcfce..b3be0ec0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -970,7 +970,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         product_pos_list.append(vector)
 
                 elif isinstance(reactant_structure, DiskSurface):
-                    vector_length = (2.0*product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # the thickness of the membrane is 0.0
+                    vector_length = (5.0*product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # HACK remove factor 5.0 after testing
                     vector        = reactant_pos + vector_length * reactant_structure.shape.unit_z
                     product_pos_list.append(vector)
 
@@ -1548,17 +1548,17 @@ def make_new_domain(self, single):
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
                 pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
-                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR * 5 # HACK
+                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR * 5 # HACK  to be balanced
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
             if isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
                 # with a planar or disk surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 5 # HACK
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 5 # HACK to be balanced
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
-            if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):        # HACK
+            if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):        # HACK  to be balanced
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR * 2
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
 
@@ -1581,7 +1581,8 @@ def make_new_domain(self, single):
             elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
                 domain = self.try_transition(single, obj)
 
-            elif isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface):
+            elif ( isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface) ) \
+             and obj.allows_interaction_from(single_pos) :
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
 

From 8301c2e837e72d239b97ab05299cc2f7eb3254db Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 15:33:38 +0200
Subject: [PATCH 0887/1541] Fix some comments

---
 shells.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index 7410f4c8..1da4c186 100755
--- a/shells.py
+++ b/shells.py
@@ -694,7 +694,7 @@ def get_radius_to_SphericalShape(shape, testShell, r):
     # if the newly calculated dimensions are smaller than the current one, use them
     return min(r, r_new)
 
-# functions to size up a testShell to a Cylindrical shape object
+# functions to size up a testShell to a Cylindrical or Disk shape object
 def get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shape, testShell, r, z_right, z_left):
     # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
     # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
@@ -702,7 +702,7 @@ def get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shape, testShell, r, z_rig
     # smaller.
 
     # Note that the 'shell' is querried from this domain earlier by the testShell.
-    # -> the shell MUST be a Cylinder.
+    # -> the shell MUST be a Cylinder or Disk.
     assert (type(shape) is Cylinder) or (type(shape) is Disk)
 
     # Laurens' algorithm (part2)
@@ -1306,7 +1306,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # initialize the parameters to start the scaling of the cylinder
         min_dr, min_dz_right, min_dz_left = self.apply_safety(min_dr, min_dz_right, min_dz_left)
         dr, dz_right, dz_left             = max_dr, max_dz_right, max_dz_left
- 
+        
         # first check the maximum dr, dz_right, dz_left against the surfaces
         # NOTE: we assume that all relevant surfaces are cylindrical and parallel to the testCylinder
         # or planar surfaces and parallel to the testCylinder axis

From 573db34028f36501148fe27044a302559579a62a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 16:45:46 +0200
Subject: [PATCH 0888/1541] Add a function that returns the shortest distance
 to the edge of a shape for the projected point of a position.

This is to facilitate necessary calculations for shell scaling
on finite structures.
---
 Box.hpp               | 17 +++++++++++++++++
 Cylinder.hpp          | 23 +++++++++++++++++++++++
 Disk.hpp              | 24 +++++++++++++++++++++++-
 Plane.hpp             | 25 +++++++++++++++++++++++--
 Region.hpp            |  5 +++++
 Sphere.hpp            |  9 +++++++++
 Structure.hpp         |  1 +
 Surface.hpp           |  5 +++++
 binding/Structure.hpp |  1 +
 9 files changed, 107 insertions(+), 3 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 43cd9fc5..8634aab8 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -277,6 +277,23 @@ distance(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
     }
 }
 
+template<typename T_>
+inline typename Box<T_>::length_type
+min_dist_proj_to_edge(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
+// Calculates the distance from the projection of 'pos' to the closest edge of the box
+// if it is in the box; if not, it returns zero
+{
+    typedef typename Box<T_>::length_type length_type;
+    boost::array<length_type, 3> x_y_z(to_internal(obj, pos));
+    boost::array<length_type, 3> dx_dy_dz(subtract(abs(x_y_z), obj.half_extent()));
+
+    if (dx_dy_dz[0] < 0 && dx_dy_dz[1] < 0 && dx_dy_dz[2] < 0)
+        // pos is within the box
+        return std::min( std::min(-dx_dy_dz[0], -dx_dy_dz[1]), -dx_dy_dz[2]);
+    
+    else        return 0;
+}
+
 template<typename T_>
 inline std::pair<typename Box<T_>::position_type, bool>
 deflect(Box<T_> const& obj,
diff --git a/Cylinder.hpp b/Cylinder.hpp
index f3304f38..7066bf7e 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -200,6 +200,29 @@ distance(Cylinder<T_> const& obj,
     return distance;
 }
 
+template<typename T_>
+inline typename Cylinder<T_>::length_type
+min_dist_proj_to_edge(Cylinder<T_> const& obj,
+                typename Cylinder<T_>::position_type const& pos)
+// Calculates the distance from the projection of 'pos' to the closest cap of the cylinder
+// if it is within in the cylinder; if not, it returns zero
+{
+    typedef typename Cylinder<T_>::position_type position_type;
+    typedef typename Cylinder<T_>::length_type length_type;
+
+    /* First compute the (r,z) components of pos in a coordinate system 
+     * defined by the vectors unitR and unit_z, where unitR is
+     * choosen such that unitR and unit_z define a plane in which
+     * pos lies. */
+    const std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    /* Then compute distance to caps. */
+    const length_type dz(std::fabs(r_z.second) - obj.half_length());
+    
+    if (dz < 0)         return -dz;
+    else                return 0;
+
+}
+
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::position_type, bool>
 deflect(Cylinder<T_> const& obj,
diff --git a/Disk.hpp b/Disk.hpp
index b8bcba37..b471428b 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -153,7 +153,7 @@ distance(Disk<T_> const& obj,
     const length_type dr(r_z.first - obj.radius());
     length_type distance;
 
-    if (r_z.first > obj.radius())
+    if (dr > 0)
     {
         // pos is not above the disk.
         // Compute distance to edge.
@@ -168,6 +168,28 @@ distance(Disk<T_> const& obj,
     return distance;
 }
 
+template<typename T_>
+inline typename Disk<T_>::length_type
+min_dist_proj_to_edge(Disk<T_> const& obj,
+                typename Disk<T_>::position_type const& pos)
+// Calculates the distance from the projection of 'pos' to the edge of the disk
+// if it is within in the disk; if not, it returns zero
+{
+    typedef typename Disk<T_>::position_type position_type;
+    typedef typename Disk<T_>::length_type length_type;
+
+    /* First compute the (r,z) components of pos in a coordinate system 
+     * defined by the vectors unitR and unit_z, where unitR is
+     * choosen such that unitR and unit_z define a plane in which
+     * pos lies. */
+    const std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    /* Then compute distance to radial edge. */
+    const length_type dr(r_z.first - obj.radius());
+
+    if (dr < 0)         return -dr;
+    else                return 0;
+}
+
 template<typename T_>
 inline std::pair<typename Disk<T_>::position_type, bool>
 deflect(Disk<T_> const& obj,
diff --git a/Plane.hpp b/Plane.hpp
index f782692a..f73a8abf 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -217,7 +217,7 @@ template<typename T_>
 inline typename Plane<T_>::length_type
 distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 // Calculates the distance from 'pos' to plane 'obj' Note that when the plane is finite,
-// and also calculates the distance to the edge of the plane if necessary
+// it also calculates the distance to the edge of the plane if necessary
 {
     typedef typename Plane<T_>::length_type length_type;
     boost::array<length_type, 3> const x_y_z(to_internal(obj, pos));
@@ -227,7 +227,7 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 
     if (dx < 0 && dy < 0) {
         // pos is positioned over the plane (projected point is in the plane and
-	    // not next to it).
+	// not next to it).
         return abs(x_y_z[2]);
     }
 
@@ -260,6 +260,27 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
     }
 }
 
+template<typename T_>
+inline typename Plane<T_>::length_type
+min_dist_proj_to_edge(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+// Calculates the distance from the projection of 'pos' to the closest edge of the plane
+// if it is in the plane; if not, it returns zero
+{
+    typedef typename Plane<T_>::length_type length_type;
+    boost::array<length_type, 3> const x_y_z(to_internal(obj, pos));
+
+    length_type const dx(subtract( abs(x_y_z[0]), obj.half_extent()[0]));
+    length_type const dy(subtract( abs(x_y_z[1]), obj.half_extent()[1]));
+
+    if (dx < 0.0 && dy < 0.0)
+        // pos is positioned over the plane (projected point is in the plane and
+        // not next to it).
+        return std::min( -dx, -dy);
+
+    else        return 0.0;
+    
+}
+
 template<typename T_>
 inline std::pair<typename Plane<T_>::position_type, bool>
 deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typename Plane<T_>::position_type const& d)
diff --git a/Region.hpp b/Region.hpp
index c94c6bc0..69bed751 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -106,6 +106,11 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::distance(shape(), pos);
     }
     
+    virtual length_type min_dist_proj_to_edge(position_type const& pos) const
+    {
+        return ::min_dist_proj_to_edge(shape(), pos);
+    }
+    
     virtual position_type const& position() const
     {
         return shape_.position();
diff --git a/Sphere.hpp b/Sphere.hpp
index 6ea486f2..5eca1a4e 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -102,6 +102,15 @@ distance(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
     return distance(pos, obj.position()) - obj.radius();
 }
 
+template<typename T_>
+inline typename Sphere<T_>::length_type
+min_dist_proj_to_edge(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
+// Calculates the distance from the projection of 'pos' to the edge of the sphere.
+// Since the projection is always at the sphere center, this is just the radius.
+{
+    return obj.radius();
+}
+
 template<typename T_>
 inline std::pair<typename Sphere<T_>::position_type, bool>
 deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typename Sphere<T_>::position_type const& d)
diff --git a/Structure.hpp b/Structure.hpp
index d04ffa65..229ed281 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -118,6 +118,7 @@ class Structure
     virtual projected_type projected_point(position_type const& pos) const = 0;
     virtual projected_type projected_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
+    virtual length_type min_dist_proj_to_edge(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;    
     virtual bool allows_interaction_from(position_type const& pos) const = 0;
 
diff --git a/Surface.hpp b/Surface.hpp
index dc60a8cc..a01bb25c 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -114,6 +114,11 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return ::distance(shape(), pos);
     }
     
+    virtual length_type min_dist_proj_to_edge(position_type const& pos) const
+    {
+        return ::min_dist_proj_to_edge(shape(), pos);
+    }
+    
     virtual position_type const& position() const
     {
         return shape_.position();
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index fc6bbc46..6b6b0f3c 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -46,6 +46,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("projected_point", &impl_type::projected_point)
+        .def("min_dist_proj_to_edge", &impl_type::min_dist_proj_to_edge)
         .def("allows_interaction_from", &impl_type::allows_interaction_from)
         .def("deflect", &impl_type::deflect)
         .def("deflect_back", &impl_type::deflect_back)

From 9d9fb5a63ab05f952f124e649f58ec0916c605a2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 18:01:14 +0200
Subject: [PATCH 0889/1541] Shell size cutoff for
 CylindricalSingle/-Pair/-Interaction

Making use of the newly implemented min_dist_proj_to_edge() method.
---
 shells.py | 28 ++++++++++++++++++----------
 1 file changed, 18 insertions(+), 10 deletions(-)

diff --git a/shells.py b/shells.py
index 1da4c186..4bae508c 100755
--- a/shells.py
+++ b/shells.py
@@ -1591,8 +1591,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = self.pid_particle_pair[1].radius
-        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-        dz_left = dz_right
+        dz_right_edge = self.structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
+        dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_left       = dz_right
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1693,8 +1695,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-        dz_left = dz_right
+        dz_right_edge = self.structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
+        dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_left       = dz_right
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1801,10 +1805,12 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         # TODO clarify
-        dz_right = ((-(self.particle_surface_distance + self.target_structure.shape.radius) + \
-                     math.sqrt(2*(self.get_searchradius()**2) - (self.particle_surface_distance + self.target_structure.shape.radius)**2)) / 2.0)
-        dz_left  = dz_right
-        dr       = ((self.particle_surface_distance + self.target_structure.shape.radius) + dz_right)
+        dz_right_edge = self.target_structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
+        dz_right_sr   = ((-(self.particle_surface_distance + self.target_structure.shape.radius) + \
+                       math.sqrt(2*(self.get_searchradius()**2) - (self.particle_surface_distance + self.target_structure.shape.radius)**2)) / 2.0)
+        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_left       = dz_right
+        dr            = ((self.particle_surface_distance + self.target_structure.shape.radius) + dz_right)
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1919,8 +1925,10 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left  = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-        dz_right = dz_left
+        dz_left_edge = self.origin_structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
+        dz_left_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+        dz_left      = min(dz_left_sr, dz_left_edge)
+        dz_right     = dz_left
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):

From 08e7431703d9c399a82821ebcd8e85950f017f16 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 18:28:51 +0200
Subject: [PATCH 0890/1541] Finite cutoff for shell scaling for
 PlanarSurfaceSingle/-Pair/-Interaction/MixedPair

---
 shells.py | 42 +++++++++++++++++++++++++++---------------
 1 file changed, 27 insertions(+), 15 deletions(-)

diff --git a/shells.py b/shells.py
index 4bae508c..db5bdaea 100755
--- a/shells.py
+++ b/shells.py
@@ -1490,8 +1490,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dz_right = self.pid_particle_pair[1].radius
-        dz_left = dz_right
-        dr = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
+        dz_left  = dz_right
+        dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
+        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dr       = min(dr_sr, dr_edge)
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1542,8 +1544,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dz_right = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_left = dz_right
-        dr = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
+        dz_left  = dz_right
+        dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
+        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dr       = min(dr_sr, dr_edge)
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1591,7 +1595,7 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = self.pid_particle_pair[1].radius
-        dz_right_edge = self.structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
+        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         dz_right      = min(dz_right_sr, dz_right_edge)
         dz_left       = dz_right
@@ -1638,6 +1642,7 @@ def get_min_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
+        # Radius is not scaled here so we do not to check for distance to shape edge
         dr       = self.pid_particle_pair[1].radius
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
         dz_left  = dz_right
@@ -1695,7 +1700,7 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_right_edge = self.structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
+        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         dz_right      = min(dz_right_sr, dz_right_edge)
         dz_left       = dz_right
@@ -1752,8 +1757,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved
-        dr       = (self.get_searchradius()/math.sqrt(2))
-        dz_right = dr + self.particle_surface_distance          # Note that we assume that dr >> particle_surface_distance
+        dr_sr    = (self.get_searchradius()/math.sqrt(2))
+        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dr       = min(dr_sr, dr_edge)
+        dz_right = dr + self.particle_surface_distance          # Note that we assume that dr >> particle_surface_distance        
         dz_left  = self.pid_particle_pair[1].radius             # so that the cylinder always fits inside the search_radius
         return dr, dz_right, dz_left
 
@@ -1805,7 +1812,7 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         # TODO clarify
-        dz_right_edge = self.target_structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
+        dz_right_edge = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
         dz_right_sr   = ((-(self.particle_surface_distance + self.target_structure.shape.radius) + \
                        math.sqrt(2*(self.get_searchradius()**2) - (self.particle_surface_distance + self.target_structure.shape.radius)**2)) / 2.0)
         dz_right      = min(dz_right_sr, dz_right_edge)
@@ -1864,7 +1871,9 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
-        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
+        dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
+        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dz_right      = min(dz_right_sr, dz_right_edge)
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1925,10 +1934,10 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_left_edge = self.origin_structure.min_dist_proj_to_edge(self.pid_particle_pair[1].position)
-        dz_left_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-        dz_left      = min(dz_left_sr, dz_left_edge)
-        dz_right     = dz_left
+        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_left       = dz_right
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -2039,7 +2048,10 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved
-        dr       = self.get_searchradius()/math.sqrt(2)
+        dr_sr    = self.get_searchradius()/math.sqrt(2)
+        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dr       = min(dr_sr, dr_edge)
+
         dz_left  = self.pid_particle_pair1[1].radius
 
         # now adjust dz_right such that they obey the scaling laws and are still with the search_radius

From a2cc77d2c4f99665c5367d2d64125c79ea8610cf Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 14 May 2012 17:20:01 +0200
Subject: [PATCH 0891/1541] Implemented cyclic_transpose analogously to the
 apply_boundary function to structures.

---
 CuboidalRegion.hpp            |   6 ++
 CylindricalSurface.hpp        |   6 ++
 Multi.hpp                     |   6 ++
 ParticleContainer.hpp         |   3 +
 ParticleContainerBase.hpp     |   7 +++
 PlanarSurface.hpp             |   5 ++
 SphericalSurface.hpp          |   6 ++
 Structure.hpp                 |   2 +
 StructureContainer.hpp        | 101 ++++++++++++++++++++++++++++++++++
 Transaction.hpp               |   6 ++
 binding/ParticleContainer.hpp |   7 +++
 11 files changed, 155 insertions(+)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 257358cc..cbe16433 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -140,6 +140,12 @@ class CuboidalRegion
         return pos_struct_id;
     }
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         structure_container_type const& structure_container) const
+    {
+        return pos_struct_id;       // The cyclic_transpose does nothing because we'll apply world cyclic transpose later.
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index d438c8d2..6ac4a8e7 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -217,6 +217,12 @@ class CylindricalSurface
         return structure_container.apply_boundary(*this, pos_struct_id);
     }
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         structure_container_type const& structure_container) const
+    {
+        return pos_struct_id;       // for now we do not support connected cylindrical surfaces.
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/Multi.hpp b/Multi.hpp
index 4de5eaf0..4abab505 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -282,6 +282,12 @@ class MultiParticleContainer
         return world_.cyclic_transpose(p0, p1);
     }
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         const boost::shared_ptr<structure_type> structure) const
+    {
+        return world_.cyclic_transpose(pos_struct_id, structure);
+    }
+
     particle_id_pair_range get_particles_range() const
     {
         return particle_id_pair_range(particles_.begin(), particles_.end(),
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index ca7b2f3d..42a29b3e 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -154,6 +154,9 @@ class ParticleContainer
 
     virtual length_type cyclic_transpose(length_type const& p0, length_type const& p1) const = 0;
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         const boost::shared_ptr<structure_type> structure) const = 0;
+
 };
 
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 6945cf6b..b00c29de 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -209,6 +209,13 @@ class ParticleContainerBase
         return traits_type::cyclic_transpose(p0, p1, world_size());
     }
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         const boost::shared_ptr<structure_type> structure) const
+    {
+        const position_type pos (cyclic_transpose(pos_struct_id.first, structure->position()));
+        return structure->cyclic_transpose(std::make_pair(pos, pos_struct_id.second), structures_);
+    }
+
     // THIS SEEMS STRANGE TO PUT THIS HERE. 
     template<typename T1_>
     T1_ calculate_pair_CoM(
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 4e197002..611875da 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -211,6 +211,11 @@ class PlanarSurface
         return structure_container.apply_boundary(*this, pos_struct_id);
     }
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         structure_container_type const& structure_container) const
+    {
+        return structure_container.cyclic_transpose(*this, pos_struct_id);
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index e4143ac1..df831bb1 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -113,6 +113,12 @@ class SphericalSurface
         return pos_struct_id;
     }
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         structure_container_type const& structure_container) const
+    {
+        return pos_struct_id;       // Two spherical surface cannot be connected (there is no boundary!)
+    }
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/Structure.hpp b/Structure.hpp
index fe809da9..e47ee5e2 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -129,6 +129,8 @@ class Structure
 
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const = 0;
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         structure_container_type const& structure_container) const = 0;
 
 
     virtual std::size_t hash() const
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 7a358db1..fb64cb2c 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -21,6 +21,12 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
                 PlanarSurface<Ttraits_> const& planar_surface,
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
 
+template<typename Ttraits_ >
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+cyclic_transpose (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                  PlanarSurface<Ttraits_> const& planar_surface,
+                  StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
+
 template<typename Ttraits_ >
 std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
@@ -135,6 +141,11 @@ class StructureContainer
     {
         return ::apply_boundary(pos_struct_id, structure, *this);
     }
+    template <typename Tstructure_>
+    position_structid_type cyclic_transpose(Tstructure_ const& structure, position_structid_type const& pos_struct_id) const
+    {
+        return ::cyclic_transpose(pos_struct_id, structure, *this);
+    }
 
     virtual structure_id_type get_def_structure_id() const
     {
@@ -363,6 +374,96 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     return std::make_pair(new_pos, new_id);
 }
 
+template<typename Ttraits_ >
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+cyclic_transpose (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                  PlanarSurface<Ttraits_> const& planar_surface,
+                  StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
+{
+    // useful typedefs
+    typedef Ttraits_        traits_type;
+    typedef typename traits_type::structure_id_type         structure_id_type;
+
+    typedef typename PlanarSurface<Ttraits_>::shape_type    plane_type;
+    typedef typename plane_type::length_type                length_type;
+    typedef typename plane_type::position_type              position_type;
+
+    typedef std::pair<structure_id_type, position_type>     neighbor_id_vector_type;
+
+
+
+    if ( pos_structure_id.second == planar_surface.id() )
+        return pos_structure_id;
+
+    position_type new_pos_par;
+    position_type new_pos_inl;
+
+    int side_nr;
+    neighbor_id_vector_type neighbor_id_vector;
+    for (side_nr = 0; side_nr < 4; ++side_nr)
+    {
+        neighbor_id_vector = sc.get_neighbor_info(planar_surface, side_nr);
+        if ( neighbor_id_vector.first == pos_structure_id.second )
+            // we have found the correct side
+            break;
+    }
+    // TODO use iterator so that we can check whether match was found or that we escaped by reaching the end of the list.
+
+    const plane_type plane (planar_surface.shape());
+    boost::array<length_type, 2> half_extends(plane.half_extent());
+    switch ( side_nr )
+    {
+        case 0:     // top side
+        {
+            const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
+                                                                          multiply(plane.unit_y(),
+                                                                                   half_extends[1]) ) ));
+            const length_type plane_par (dot_product(pos, plane.unit_x()));     // TODO replace by subtraction?
+            const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
+            new_pos_par = multiply(plane.unit_x(), plane_par);
+            new_pos_inl = multiply(plane.unit_y(), half_extends[1] + plane_inl);
+            break;
+        }
+        case 1:     // botom
+        {
+            const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
+                                                                          multiply(plane.unit_y(),
+                                                                                   -half_extends[1]) ) ));
+            const length_type plane_par (dot_product(pos, plane.unit_x()));     // TODO replace by subtraction?
+            const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
+            new_pos_par = multiply(plane.unit_x(), plane_par);
+            new_pos_inl = multiply(plane.unit_y(), -(half_extends[1] + plane_inl) );
+            break;
+        }
+        case 2:     // left
+        {
+            const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
+                                                                          multiply(plane.unit_x(),
+                                                                                   -half_extends[0]) ) ));
+            const length_type plane_par (dot_product(pos, plane.unit_y()));     // TODO replace by subtraction?
+            const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
+            new_pos_par = multiply(plane.unit_y(), plane_par);
+            new_pos_inl = multiply(plane.unit_x(), -(half_extends[0] + plane_inl) );
+            break;
+        }
+        case 3:     // right
+        {
+            const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
+                                                                          multiply(plane.unit_x(),
+                                                                                   half_extends[0]) ) ));
+            const length_type plane_par (dot_product(pos, plane.unit_y()));     // TODO replace by subtraction?
+            const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
+            new_pos_par = multiply(plane.unit_y(), plane_par);
+            new_pos_inl = multiply(plane.unit_x(), half_extends[0] + plane_inl );
+            break;
+        }
+    }
+    const position_type new_pos ( add(plane.position(),
+                                      add(new_pos_par, new_pos_inl)));
+    return std::make_pair(new_pos, planar_surface.id());
+}
+
+
 
 ///// Functions for CylindricalSurfaces
 template<typename Ttraits_ >
diff --git a/Transaction.hpp b/Transaction.hpp
index b9cb17e5..b06f7cd7 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -336,6 +336,12 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.cyclic_transpose(p0, p1);
     }
 
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         const boost::shared_ptr<structure_type> structure) const
+    {
+        return pc_.cyclic_transpose(pos_struct_id, structure);
+    }
+
     virtual ~TransactionImpl() {}
 
     TransactionImpl(particle_container_type& pc): pc_(pc) {}
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 454a04e4..b79652e6 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -578,6 +578,13 @@ class ParticleContainerWrapper
     {
         return py_wrapper_type::get_override("cyclic_transpose")(p0, p1);
     }
+
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         const boost::shared_ptr<structure_type> structure) const
+    {
+        return py_wrapper_type::get_override("cyclic_transpose")(pos_struct_id, structure);
+    }
+
 };
 
 

From f8ef5a70ac7606be216c1e7e21fbd7925c68e179 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 May 2012 18:36:15 +0200
Subject: [PATCH 0892/1541] Remove check for CapInteraction again

...because the shell is asymmetric and always very close to one
of the edges => distance to closest edge is not the right length
to scale down to.

We have to come up with sth. smarter here.
---
 shells.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index db5bdaea..3f978747 100755
--- a/shells.py
+++ b/shells.py
@@ -1871,9 +1871,7 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
-        dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
-        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint())
-        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):

From 77edac99678736731ee123237e6a9cad2b1fbc53 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 14 May 2012 18:39:26 +0200
Subject: [PATCH 0893/1541] added const to signature of 'apply_boundary' in
 ParticleContainer classes

---
 Multi.hpp                     | 4 ++--
 ParticleContainer.hpp         | 4 ++--
 ParticleContainerBase.hpp     | 4 ++--
 Transaction.hpp               | 4 ++--
 binding/ParticleContainer.hpp | 4 ++--
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 4abab505..007f3bd4 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -267,7 +267,7 @@ class MultiParticleContainer
     }
 
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<structure_type> structure) const
+                                                       const boost::shared_ptr<const structure_type> structure) const
     {
         return world_.apply_boundary(pos_struct_id, structure);
     }
@@ -283,7 +283,7 @@ class MultiParticleContainer
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<structure_type> structure) const
+                                                         const boost::shared_ptr<const structure_type> structure) const
     {
         return world_.cyclic_transpose(pos_struct_id, structure);
     }
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 42a29b3e..e321396e 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -148,14 +148,14 @@ class ParticleContainer
     virtual length_type apply_boundary(length_type const& v) const = 0;
 
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<structure_type> structure) const = 0;
+                                                       const boost::shared_ptr<const structure_type> structure) const = 0;
 
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const = 0;
 
     virtual length_type cyclic_transpose(length_type const& p0, length_type const& p1) const = 0;
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<structure_type> structure) const = 0;
+                                                         const boost::shared_ptr<const structure_type> structure) const = 0;
 
 };
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index b00c29de..d4f6fd8f 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -190,7 +190,7 @@ class ParticleContainerBase
     // -Use this fully defined type to call the right function through the template method 'apply_boundary' of the StructureContainer.
     //  (See StructureContainer.hpp)
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<structure_type> structure) const
+                                                       const boost::shared_ptr<const structure_type> structure) const
     {
         // The generalized boundary condition application first:
         // 1. applies the boundary of the structure/surface (go around the corner etc)
@@ -210,7 +210,7 @@ class ParticleContainerBase
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<structure_type> structure) const
+                                                         const boost::shared_ptr<const structure_type> structure) const
     {
         const position_type pos (cyclic_transpose(pos_struct_id.first, structure->position()));
         return structure->cyclic_transpose(std::make_pair(pos, pos_struct_id.second), structures_);
diff --git a/Transaction.hpp b/Transaction.hpp
index b06f7cd7..893b7b46 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -321,7 +321,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     }
 
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<structure_type> structure) const
+                                                       const boost::shared_ptr<const structure_type> structure) const
     {
         return pc_.apply_boundary(pos_struct_id, structure);
     }
@@ -337,7 +337,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<structure_type> structure) const
+                                                         const boost::shared_ptr<const structure_type> structure) const
     {
         return pc_.cyclic_transpose(pos_struct_id, structure);
     }
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index b79652e6..ec9fc251 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -564,7 +564,7 @@ class ParticleContainerWrapper
     }
 
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<structure_type> structure) const
+                                                       const boost::shared_ptr<const structure_type> structure) const
     {
         return py_wrapper_type::get_override("apply_boundary")(pos_struct_id, structure);
     }
@@ -580,7 +580,7 @@ class ParticleContainerWrapper
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<structure_type> structure) const
+                                                         const boost::shared_ptr<const structure_type> structure) const
     {
         return py_wrapper_type::get_override("cyclic_transpose")(pos_struct_id, structure);
     }

From 8dc8938cf89264f8c4633000293b4e1ab9834e24 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 14 May 2012 18:40:21 +0200
Subject: [PATCH 0894/1541] small fixes to how the newBDPropagator uses the
 'apply_boundary' and 'cyclic_transpose' methods from the world.

---
 newBDPropagator.hpp | 49 +++++++++++++++------------------------------
 1 file changed, 16 insertions(+), 33 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 0d399ad3..a07f7f8d 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -126,10 +126,10 @@ class newBDPropagator
 
         //// 1.?
         // Get info of the particle
-        const species_type                            pp_species(tx_.get_species(pp.second.sid()));
-        const length_type                             r0( pp_species.radius() );
-        const position_type                           old_pos( pp.second.position() );
-        const structure_id_type                       old_struct_id(pp.second.structure_id());
+        const species_type                      pp_species(tx_.get_species(pp.second.sid()));
+        const length_type                       r0( pp_species.radius() );
+        const position_type                     old_pos( pp.second.position() );
+        const structure_id_type                 old_struct_id(pp.second.structure_id());
         const boost::shared_ptr<structure_type> pp_structure( tx_.get_structure( old_struct_id ) );
         // declare variables to use
         position_type                   new_pos(old_pos);
@@ -167,12 +167,9 @@ class newBDPropagator
             bounced = overlap_particles->at(j++).second < r0;
         
         //// 3.2 Check for core overlaps structures
-        /* If the particle has not bounced with another particle and lives in the bulk: 
-           check for core overlap with a surface. */
+        /* If the particle has not bounced with another particle check for overlap with a surface. */
         boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures;
         int structures_in_overlap(0);
-
-        // Check for overlap with nearest surface.
         if (!bounced)
         {
             // Get all the structures within the reaction volume (and that may consequently also be in the core)
@@ -515,23 +512,12 @@ class newBDPropagator
                                 prod0_struct_id = pp.second.structure_id();         // same structure as the reactant
                                 prod1_struct_id = pp.second.structure_id();         // ditto
                             }
-                            pos0pos1.first  = tx_.apply_boundary( pos0pos1.first );
-                            pos0pos1.second = tx_.apply_boundary( pos0pos1.second );
-
-                            // check that the positions do not cross any edges.
+                            // TODO clean this up
                             const boost::shared_ptr<const structure_type> prod0_structure(reactant_structure);
                             const boost::shared_ptr<const structure_type> prod1_structure(tx_.get_structure(prod1_struct_id));
-                            if ( !(prod0_structure->is_alongside(pos0pos1.first)))
-                            {
-                                // TODO deflect pos0pos1.first with right neigboring structure
-                            }
-                            if ( !(prod1_structure->is_alongside(pos0pos1.second)))
-                            {
-                                // TODO deflect pos0pos1.second with right neigboring structure
-                            }
-
-                            pos0pos1_pair = std::make_pair(std::make_pair(pos0pos1.first, prod0_struct_id),
-                                                           std::make_pair(pos0pos1.second, prod1_struct_id));
+                            const position_structid_pair_type pos_structid0 (tx_.apply_boundary( std::make_pair(pos0pos1.second, prod1_struct_id), prod1_structure ));
+                            const position_structid_pair_type pos_structid1 (tx_.apply_boundary( std::make_pair(pos0pos1.first,  prod0_struct_id), prod0_structure ));
+                            pos0pos1_pair = std::make_pair(pos_structid0, pos_structid1);
 
 
                             ////// Check for overlaps
@@ -661,9 +647,9 @@ class newBDPropagator
                         if ((s0.structure_type_id() == s1.structure_type_id()) &&
                             (reactant0_structure_id != reactant1_structure_id))
                         {
-                            // deflect_back one of the coordinates.
-                            // TODO unit_z() is not accessible!
-//                            reactant1_pos = reactant0_structure->deflect_back(reactant1_pos, reactant1_structure->shape().unit_z());
+                            const position_structid_pair_type pos_cyclic1 (tx_.cyclic_transpose(std::make_pair(reactant1_pos, reactant1_structure_id),
+                                                                                                reactant0_structure));
+                            reactant1_pos = pos_cyclic1.first;
                         }
 
                         // calculate the product position (CoM of the two particles)
@@ -708,13 +694,10 @@ class newBDPropagator
                         {
                             if (reactant0_structure_id != reactant1_structure_id)
                             {
+                                const position_structid_pair_type bla (tx_.apply_boundary(std::make_pair(product_pos, reactant0_structure_id), reactant0_structure));
                                 // deflect the product coordinate and get right structure_id.
-                                std::pair<position_type, bool> bla = reactant1_structure->deflect(reactant0_pos, subtract(product_pos, reactant0_pos));
-                                if (bla.second)
-                                {
-                                    product_pos = bla.first;
-                                    product_structure_id = reactant1_structure_id;
-                                }
+                                product_pos = bla.first;
+                                product_structure_id = bla.second;
 
                             }
                         }
@@ -885,7 +868,7 @@ class newBDPropagator
             const position_type displacement( old_structure->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
 
             const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos_struct_id.first, displacement), old_pos_struct_id.second),
-                                                                              old_structure));
+                                                                               old_structure));
             new_pos = pos_structid.first;
             new_structure_id = pos_structid.second;
 

From 6c8a070391841caade79929b27bd1b05a09cb1e9 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 May 2012 14:13:43 +0200
Subject: [PATCH 0895/1541] fixed bug, cannot construct superclass using
 uninitiazed member variables. ->First construct superclass and initialize
 later.

---
 ParticleContainerBase.hpp |  8 ++++----
 StructureContainer.hpp    | 13 ++++++++++---
 World.hpp                 |  9 +++++++--
 3 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index d4f6fd8f..08f96fe9 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -130,11 +130,11 @@ class ParticleContainerBase
 
 
 public:
-//    ParticleContainerBase(length_type world_size, size_type size)
-//        : pmat_(world_size, size) {}
-    ParticleContainerBase(length_type world_size, size_type size, structure_id_type default_structid)
-        : pmat_(world_size, size), structures_(default_structid) {}
     // constructors
+    ParticleContainerBase(length_type world_size, size_type size)
+        : pmat_(world_size, size), structures_() {}
+//    ParticleContainerBase(length_type world_size, size_type size, structure_id_type default_structid)
+//        : pmat_(world_size, size), structures_(default_structid) {}
 
     virtual size_type num_particles() const
     {
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index fb64cb2c..42fc5241 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -210,12 +210,19 @@ class StructureContainer
         return visible_structures;
     }
 
-    // The constructor
-    StructureContainer(structure_id_type default_structid) : default_structure_id_(default_structid)
+    void initialize(structure_id_type const& default_structid)
     {
+        default_structure_id_ = default_structid;
         structure_substructures_map_[default_structid] = structure_id_set();
     }
 
+    // The constructor
+//    StructureContainer() {}
+//    StructureContainer(structure_id_type default_structid) : default_structure_id_(default_structid)
+//    {
+//        structure_substructures_map_[default_structid] = structure_id_set();
+//    }
+
 
 private:
     // Update the datastructures that are general for all the structures.
@@ -227,7 +234,7 @@ class StructureContainer
         {
             if ((*i).second->structure_id() != structid_pair.second->structure_id())
             // If the structure had a different parent structure
-            // Note that all the substructures of the structures are kept (they are aldo moved moved through the hierarchy)
+            // Note that all the substructures of the structures are kept (they are also moved moved through the hierarchy)
             {
                 structure_substructures_map_[(*i).second->structure_id()].erase((*i).first);
                 structure_substructures_map_[structid_pair.second->structure_id()].insert(structid_pair.first);
diff --git a/World.hpp b/World.hpp
index 61b484f2..fba0e7f2 100644
--- a/World.hpp
+++ b/World.hpp
@@ -255,8 +255,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
 public:
     // The constructor
+//    World(length_type world_size = 1., size_type size = 1)
+//        : base_type(world_size, size, structidgen_()) {}
     World(length_type world_size = 1., size_type size = 1)
-        : base_type(world_size, size, structidgen_()) {}
+        : base_type(world_size, size)
+    {
+        base_type::structures_.initialize(structidgen_());
+    }
 
     // To create new particles
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
@@ -367,7 +372,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         // check that the structure_type that is defined in the structure exists!
         structure_type_type const& structure_type(get_structure_type(structure->sid()));
 
-        structure_id_type structure_id(structidgen_());
+        const structure_id_type structure_id(structidgen_());
         structure->set_id(structure_id);
         update_structure(std::make_pair(structure_id, structure));
         return structure_id;

From be144c0b2e370b7291bb7716dd731c2c5c0dbb4d Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 May 2012 16:27:27 +0200
Subject: [PATCH 0896/1541] small fix to surface_overlap_checker

---
 ParticleContainerBase.hpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 08f96fe9..12190d69 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -23,6 +23,8 @@ struct ParticleContainerUtils
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef std::pair<particle_id_pair, length_type>            particle_id_pair_and_distance;
 
+    // This distance_comparator orders two tuples based on the second part of the tuple
+    // example (obj1, distance1) < (obj2, distance2) if distance1 < distance2
     template<typename Tobject_and_distance_list_>
     struct distance_comparator:
             public std::binary_function<
@@ -43,7 +45,8 @@ struct ParticleContainerUtils
     };
 
 
-
+    // The overlap checker is sorted list of tuples (object, distance) which is sorted on
+    // the second part of the tuple (the distance).
     template<typename Tobject_and_distance_list_, typename Tset_>
     struct overlap_checker
     {
@@ -275,6 +278,7 @@ class ParticleContainerBase
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
         const structure_id_set visible_structures (structures_.get_visible_structures(current));
 
+        // get and temporarily store all the visibles structures (upto now we only had their IDs)
         structure_map temp_map;
         for (typename structure_id_set::const_iterator i(visible_structures.begin()),
                                                        e(visible_structures.end());
@@ -283,12 +287,14 @@ class ParticleContainerBase
             temp_map[(*i)] = get_structure(*i);
         }
 
+        // calculate the distances and store the surface,distance tuple in the overlap checker if smaller that the particle radius.
         for (typename structure_map::const_iterator i(temp_map.begin()),
                                                     e(temp_map.end());
              i != e; ++i)
         {
-            const position_type cyc_pos(cyclic_transpose(s.position(), ((*i).second)->position())); //
-            const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), old_pos, sigma));
+            const position_type cyc_pos     (cyclic_transpose(s.position(), ((*i).second)->position()));
+            const position_type cyc_old_pos (cyclic_transpose(old_pos,      ((*i).second)->position()));
+            const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), cyc_old_pos, sigma));
             if (dist < s.radius())
             {
                 checker(i, dist);
@@ -373,6 +379,7 @@ class ParticleContainerBase
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
         const structure_id_set visible_structures (structures_.get_visible_structures(current_struct_id));
 
+        // get and temporarily store all the visibles structures (upto now we only had their IDs)
         structure_map temp_map;
         for (typename structure_id_set::const_iterator i(visible_structures.begin()),
                                                        e(visible_structures.end());
@@ -381,6 +388,7 @@ class ParticleContainerBase
             temp_map[(*i)] = get_structure(*i);
         }
 
+        // calculate the distances and store the surface,distance tuple in the overlap checker (in a list is sorted by distance).
         for (typename structure_map::const_iterator i(temp_map.begin()),
                                                     e(temp_map.end());
              i != e; ++i)

From 1af984ae915aa70e61a01c8ec00a3faaadbf763a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 May 2012 16:33:52 +0200
Subject: [PATCH 0897/1541] cleanup of throw_in_particles

---
 gfrdbase.py | 50 ++++++++++++++++++++------------------------------
 1 file changed, 20 insertions(+), 30 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 8d3702ac..4bbb4398 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -242,44 +242,30 @@ def throw_in_particles(world, sid, n):
         log.info('\n\tthrowing in %s particles of type %s to %s' %
                  (n, name, structure_type.id))
 
-    # This is messy, but it works.
     i = 0
     while i < int(n):
+        # This is messy, but it works.
         myrandom.shuffle(structure_list)
         structure = world.get_structure(structure_list[0])
         position = structure.random_position(myrandom.rng)
         position = world.apply_boundary(position)
 
-#        surfaces = get_neighbor_surfaces(world, position, structure.id, [])
-#        if surfaces:
-#            surface, distance = surfaces[0]
-#        else:
-#            surface, distance = None, 0
-
-        # Check overlap.
-        if (not world.check_overlap((position, species.radius))) and \
-           (not world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
-                                           position, structure.id, species.radius)):
-            create = True
-#            # Check if not too close to a neighbouring structures for 
-#            # particles added to the world, or added to a self-defined 
-#            # box.
-#            # FIXME replace by check_surface_overlap
-#            if (isinstance(structure, _gfrd.CuboidalRegion) and \
-#                surface and \
-#                distance < surface.minimal_distance(species.radius)):
-#                if __debug__:
-#                    log.info('\t%d-th particle rejected. Too close to '
-#                             'surface. I will keep trying.' % i)
-#                create = False
-            if create:
-                # All checks passed. Create particle.
-                p = world.new_particle(sid, structure.id, position)
-                i += 1
-                if __debug__:
-                    log.info('(%s,\n %s' % (p[0], p[1]))
+        # Check overlap. TODO put in 'if' statement for improved efficiency?
+        particle_overlaps = world.check_overlap((position, species.radius))
+        surface_overlaps  = world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
+                                                        position, structure.id, species.radius)
+
+        if (not particle_overlaps) and (not surface_overlaps):
+            # All checks passed. Create particle.
+            p = world.new_particle(sid, structure.id, position)
+            i += 1
+            if __debug__:
+                log.info('particle accepted: (%s,\n %s)' % (p[0], p[1]))
         elif __debug__:
-            log.info('\t%d-th particle rejected. I will keep trying.' % i)
+            if particle_overlaps:
+                log.info('\t%d-th particle rejected. Too close to particle. I will keep trying.' % i)
+            if surface_overlaps:
+                log.info('\t%d-th particle rejected. Too close to surface. I will keep trying.' % i)
 
 def place_particle(world, sid, position):
     """Place a particle of a certain Species at a specific position in 
@@ -299,6 +285,8 @@ def place_particle(world, sid, position):
     species = world.get_species(sid)
     radius = species.radius
 
+    # FIXME This is a mess!!
+
     # check that particle doesn't overlap with other particles.
     if world.check_overlap((position, radius)):
         raise NoSpace, 'Placing particle failed: overlaps with other particle.'
@@ -339,6 +327,8 @@ def place_particle(world, sid, position):
                  (name, world.get_structure(structure_id).name, position))
 
     particle = world.new_particle(sid, structure_id, position)
+    if __debug__:
+        log.info('(%s,\n %s' % (particle[0], particle[1]))
     return particle
 
 

From 9ae99a2edac86a97b6dc4b0b5c1b84ad56c6ba71 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 May 2012 18:16:24 +0200
Subject: [PATCH 0898/1541] Fix a small error in shells.py

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 3f978747..1d022250 100755
--- a/shells.py
+++ b/shells.py
@@ -1492,7 +1492,7 @@ def get_max_dr_dzright_dzleft(self):
         dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
         dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
-        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
         dr       = min(dr_sr, dr_edge)
         return dr, dz_right, dz_left
 

From 7a1ff3c652be3446599b972b4501fdd02dda8e10 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 15 May 2012 18:20:48 +0200
Subject: [PATCH 0899/1541] small fix to 'place_particle' now using the
 check_surface_overlap instead of deprecated 'minimal_distance'

---
 gfrdbase.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 4bbb4398..a6e4b893 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -300,13 +300,12 @@ def place_particle(world, sid, position):
     # Check if not too close to a neighbouring structures for particles 
     # added to the world, or added to a self-defined box.
     if species.structure_type_id == world.get_def_structure_type_id():
-        if(surface and
-           distance < surface.minimal_distance(species.radius)):
+        structure_id = world.get_def_structure_id()
+        if world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
+                                       position, structure_id, radius):#(surface and distance < surface.minimal_distance(species.radius)):
             raise RuntimeError('Placing particle failed: %s %s. '
                                'Too close to surface: %s.' %
                                (sid, position, distance))
-        else:
-            structure_id = world.get_def_structure_id()
     else:
         # If the particle lives on a surface then the position should be in the closest surface.
         # The closest surface should also be of the structure_type associated with the species.
@@ -327,8 +326,10 @@ def place_particle(world, sid, position):
                  (name, world.get_structure(structure_id).name, position))
 
     particle = world.new_particle(sid, structure_id, position)
+
     if __debug__:
         log.info('(%s,\n %s' % (particle[0], particle[1]))
+
     return particle
 
 

From d34dc8fc0f046334ab53894f1cb414c744ab5c28 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 16 May 2012 14:25:56 +0200
Subject: [PATCH 0900/1541] Remove artificially increased displacement at
 unbinding from disk

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index b3be0ec0..a2767bb3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -970,7 +970,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         product_pos_list.append(vector)
 
                 elif isinstance(reactant_structure, DiskSurface):
-                    vector_length = (5.0*product_radius + 0.0) * MINIMAL_SEPARATION_FACTOR  # HACK remove factor 5.0 after testing
+                    vector_length = 1.0*product_radius * MINIMAL_SEPARATION_FACTOR
                     vector        = reactant_pos + vector_length * reactant_structure.shape.unit_z
                     product_pos_list.append(vector)
 

From 336c01e0453daef6ae7569699322b7543862e55e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 16 May 2012 16:04:00 +0200
Subject: [PATCH 0901/1541] Introduced enumeration type for the 'sides' or
 interfaces of a shape/structure

---
 Box.hpp                |  1 +
 CuboidalRegion.hpp     |  9 +++++++--
 Cylinder.hpp           |  1 +
 CylindricalSurface.hpp |  8 +++++++-
 PlanarSurface.hpp      |  9 ++++++---
 Plane.hpp              |  1 +
 Region.hpp             |  3 +++
 Sphere.hpp             |  1 +
 SphericalSurface.hpp   | 23 +++++++++++++----------
 Surface.hpp            |  4 +++-
 10 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 19531b10..023cf61b 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -18,6 +18,7 @@ class Box
     typedef T_ value_type;
     typedef Vector3<T_> position_type;
     typedef T_ length_type;
+    typedef enum side_enum_type {TOP=0, BOTTOM=1, LEFT=2, RIGHT=3, FRONT=4, BACK=5} side_enum_type;  // The typedef is a little bit C style but doesn't matter for C++
 
 public:
     Box(position_type const& position = position_type())
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index cbe16433..83529edd 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -26,10 +26,15 @@ class CuboidalRegion
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
-    typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
+    typedef typename base_type::side_enum_type          side_enum_type;
     typedef typename traits_type::species_type          species_type;
+
+    typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
+
     typedef std::pair<position_type, position_type>     position_pair_type;
-    typedef std::pair<typename traits_type::position_type, typename traits_type::structure_id_type> position_structid_pair_type;
+    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
+
+
 
     virtual position_type random_position(rng_type& rng) const
     {
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 812a46d2..c46e9cc3 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -14,6 +14,7 @@ class Cylinder
     typedef T_ value_type;
     typedef Vector3<T_> position_type;
     typedef T_ length_type;
+    typedef enum side_enum_type {LEFT=0, RIGHT=1} side_enum_type;  // The typedef is a little bit C style but doesn't matter for C++
 
 public:
     // constructors
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 6ac4a8e7..5ba3c231 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -19,6 +19,8 @@ class CylindricalSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Cylinder<typename Ttraits_::length_type> > base_type;
     typedef Ttraits_ traits_type;
+
+    // name shorthands of types that we use.
     typedef typename base_type::structure_name_type     structure_name_type;        // This is just the name of the structure
     typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
@@ -26,12 +28,16 @@ class CylindricalSurface
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
+    typedef typename base_type::side_enum_type          side_enum_type;
+    typedef typename traits_type::species_type          species_type;
+
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
-    typedef typename traits_type::species_type          species_type;
     typedef std::pair<position_type, position_type>     position_pair_type;
     typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
 
+
+
     virtual position_type random_position(rng_type& rng) const
     // Gives a random position in the cylinder (1D)
     {
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 611875da..28ebee8b 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -26,12 +26,15 @@ class PlanarSurface
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
-    typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
+    typedef typename base_type::side_enum_type          side_enum_type;
     typedef typename traits_type::species_type          species_type;
-    typedef std::pair<position_type, position_type>     position_pair_type;
-    typedef std::pair<position_type, length_type>       projected_type;
+
+    typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
+
+    typedef std::pair<position_type, position_type>         position_pair_type;
     typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
+
     virtual position_type random_position(rng_type& rng) const
     // Selects a random position in the plane
     {
diff --git a/Plane.hpp b/Plane.hpp
index d7f45e4e..faa82be6 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -18,6 +18,7 @@ class Plane
     typedef T_ value_type;
     typedef Vector3<T_> position_type;
     typedef T_ length_type;
+    typedef enum side_enum_type {TOP=0, BOTTOM=1, LEFT=2, RIGHT=3} side_enum_type;  // The typedef is a little bit C style but doesn't matter for C++
 
 public:
     Plane(position_type const& position = position_type())
diff --git a/Region.hpp b/Region.hpp
index c8b93885..6ffaa3df 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -38,7 +38,10 @@ class BasicRegionImpl: public Region<Ttraits_>
 {
 public:
     typedef Region<Ttraits_>                            base_type;
+
     typedef Tshape_                                     shape_type;
+    typedef typename shape_type::side_enum_type         side_enum_type;     // Defines the type of enum to use for the sides of the region
+
     typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
diff --git a/Sphere.hpp b/Sphere.hpp
index b5e52c9e..6e40c5b9 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -12,6 +12,7 @@ class Sphere
     typedef T_ value_type;
     typedef Vector3<T_> position_type;
     typedef T_ length_type;
+    typedef enum side_enum_type {} side_enum_type;  // The typedef is a little bit C style but doesn't matter for C++
 
 public:
     Sphere()
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index df831bb1..7b4f6b73 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -15,18 +15,21 @@ class SphericalSurface
 public:
     typedef BasicSurfaceImpl<Ttraits_, Sphere<typename Ttraits_::length_type> > base_type;
     typedef Ttraits_ traits_type;
-    typedef typename base_type::structure_name_type         structure_name_type;        // THis is just the name of the structure
-    typedef typename base_type::structure_id_type           structure_id_type;
-    typedef typename base_type::structure_type_id_type      structure_type_id_type;
-    typedef typename base_type::shape_type                  shape_type;
-    typedef typename base_type::rng_type                    rng_type;
-    typedef typename base_type::position_type               position_type;
-    typedef typename base_type::length_type                 length_type;
+    typedef typename base_type::structure_name_type     structure_name_type;        // THis is just the name of the structure
+    typedef typename base_type::structure_id_type       structure_id_type;
+    typedef typename base_type::structure_type_id_type  structure_type_id_type;
+    typedef typename base_type::shape_type              shape_type;
+    typedef typename base_type::rng_type                rng_type;
+    typedef typename base_type::position_type           position_type;
+    typedef typename base_type::length_type             length_type;
+    typedef typename base_type::side_enum_type          side_enum_type;
+    typedef typename traits_type::species_type          species_type;
+
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
-    typedef typename traits_type::species_type              species_type;
-    typedef std::pair<position_type, position_type>         position_pair_type;
-    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
+    typedef std::pair<position_type, position_type>     position_pair_type;
+    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
+
 
     virtual position_type random_position(rng_type& rng) const
     {
diff --git a/Surface.hpp b/Surface.hpp
index 4c08888e..1c2c0e9f 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -45,7 +45,9 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
 {
 public:
     typedef Surface<Ttraits_> base_type;
-    typedef Tshape_ shape_type;
+
+    typedef Tshape_                                     shape_type;
+    typedef typename shape_type::side_enum_type         side_enum_type;     // Defines the type of enum to use for the sides of the surface
 
     typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_id_type       structure_id_type;

From 16262cf6611a895db861a612af45805b9e93a956 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 16 May 2012 16:44:46 +0200
Subject: [PATCH 0902/1541] cleaning up type names and readability of
 StructureContainer

---
 StructureContainer.hpp | 45 +++++++++++++++++++++++-------------------
 1 file changed, 25 insertions(+), 20 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 42fc5241..f4ffe3be 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -54,20 +54,25 @@ class StructureContainer
             typename structure_map::const_iterator>                                 structure_iterator;
     typedef typename std::map<structure_id_type, structure_id_set>                  per_structure_substructure_id_set;
 
-    typedef CuboidalRegion<traits_type>                             cuboidalregion_type;
-    typedef PlanarSurface<traits_type>                              planarsurface_type;
-    typedef CylindricalSurface<traits_type>                         cylindricalsurface_type;
-
     typedef typename structure_type::position_type                      position_type;
     typedef typename structure_type::position_type                      vector_type;
-    typedef std::pair<structure_id_type, vector_type>                   neighbor_id_vector_type;
-    typedef ConnectivityContainer<structure_id_type, vector_type, 2>    cylinders_boundaryconditions_type;
-    typedef ConnectivityContainer<structure_id_type, vector_type, 4>    planes_boundaryconditions_type;
-    typedef ConnectivityContainer<structure_id_type, vector_type, 6>    boxes_boundaryconditions_type;
 
-    typedef std::pair<structure_id_type, boost::shared_ptr<cuboidalregion_type> >       cuboidalreg_id_pair_type;
-    typedef std::pair<structure_id_type, boost::shared_ptr<planarsurface_type> >        planarsurf_id_pair_type;
-    typedef std::pair<structure_id_type, boost::shared_ptr<cylindricalsurface_type> >   cylindrsurf_id_pair_type;
+    typedef CylindricalSurface<traits_type>                                             cylindrical_surface_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<cylindrical_surface_type> >  cylindrical_surface_id_pair_type;
+    typedef typename cylindrical_surface_type::side_enum_type                           cylindrical_surface_side_type;
+    typedef ConnectivityContainer<structure_id_type, vector_type, 2>                    cylindrical_surface_bc_type;  // FIXME number of neighbors should be the length of the side enumerator
+
+    typedef PlanarSurface<traits_type>                                                  planar_surface_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<planar_surface_type> >       planar_surface_id_pair_type;
+    typedef typename planar_surface_type::side_enum_type                                planar_surface_side_type;
+    typedef ConnectivityContainer<structure_id_type, vector_type, 4>                    planar_surface_bc_type;
+
+    typedef CuboidalRegion<traits_type>                                                 cuboidal_region_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<cuboidal_region_type> >      cuboidal_region_id_pair_type;
+    typedef typename cuboidal_region_type::side_enum_type                               cuboidal_region_side_type;
+    typedef ConnectivityContainer<structure_id_type, vector_type, 6>                    cuboidal_region_bc_type;
+
+    typedef std::pair<structure_id_type, vector_type>                   neighbor_id_vector_type;    // FIXME this is actually a datatype of the ConnectivityContainer.
 
 public:
     typedef sized_iterator_range<structure_iterator>        structures_range;
@@ -80,7 +85,7 @@ class StructureContainer
     virtual ~StructureContainer() {};
 
     // Update_structure methods for the different kind of structures supported by the StructureContainer
-    virtual bool update_structure (cylindrsurf_id_pair_type const& structid_cylinder)  // can I make this into a template function?
+    virtual bool update_structure (cylindrical_surface_id_pair_type const& structid_cylinder)  // can I make this into a template function?
     {
         if ( update_structure_base(structid_cylinder))
         {
@@ -91,7 +96,7 @@ class StructureContainer
         }
         return false;
     }
-    virtual bool update_structure (planarsurf_id_pair_type const& structid_plane)
+    virtual bool update_structure (planar_surface_id_pair_type const& structid_plane)
     {
         // call regular update method (this also checks if the structure was already present)
         if ( update_structure_base(structid_plane))
@@ -107,7 +112,7 @@ class StructureContainer
         // if the structure was already present, don't change anything
         return false;
     }
-    virtual bool update_structure (cuboidalreg_id_pair_type const& structid_cube)
+    virtual bool update_structure (cuboidal_region_id_pair_type const& structid_cube)
     {
         // add to Connectivity container for cuboidal regions
         // NOTE this information is never queried!! Maybe leave the neighbor info out?
@@ -126,11 +131,11 @@ class StructureContainer
 
     // Methods to get the 'n-th' neighbor structure of a particular structure from the container.
     // We pass the structure and not just the ID because with just the ID we can't differentiate between the various types of structures.
-    virtual neighbor_id_vector_type get_neighbor_info(planarsurface_type const& structure, int n) const
+    virtual neighbor_id_vector_type get_neighbor_info(planar_surface_type const& structure, int n) const
     {
         return planar_structs_bc_.get_neighbor_info(structure.id(), n);
     }
-    virtual neighbor_id_vector_type get_neighbor_info(cylindricalsurface_type const& structure, int n) const
+    virtual neighbor_id_vector_type get_neighbor_info(cylindrical_surface_type const& structure, int n) const
     {
         return cylindrical_structs_bc_.get_neighbor_info(structure.id(), n);
     }
@@ -151,7 +156,7 @@ class StructureContainer
     {
         return default_structure_id_;
     }
-    void set_def_structure(const boost::shared_ptr<cuboidalregion_type> cuboidalregion)
+    void set_def_structure(const boost::shared_ptr<cuboidal_region_type> cuboidalregion)
     {
         // check that the structure_type is the default structure_type
         if ( cuboidalregion->structure_id() != default_structure_id_)
@@ -272,9 +277,9 @@ class StructureContainer
     structure_id_type                   default_structure_id_;
 
     // The next object describe the boundary conditions that are applied to the different types of structures.
-    cylinders_boundaryconditions_type   cylindrical_structs_bc_;
-    planes_boundaryconditions_type      planar_structs_bc_;
-    boxes_boundaryconditions_type       cuboidal_structs_bc_;
+    cylindrical_surface_bc_type cylindrical_structs_bc_;
+    planar_surface_bc_type      planar_structs_bc_;
+    cuboidal_region_bc_type     cuboidal_structs_bc_;
 };
 
 

From 8fbe09e1ca387328b714cfe75b2217f061ee4470 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 16 May 2012 19:03:55 +0200
Subject: [PATCH 0903/1541] corrected exceptions thrown

---
 ConnectivityContainer.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ConnectivityContainer.hpp b/ConnectivityContainer.hpp
index c8533f69..f81746b4 100644
--- a/ConnectivityContainer.hpp
+++ b/ConnectivityContainer.hpp
@@ -38,7 +38,7 @@ class ConnectivityContainer
     {
         // check that the index is not too large
         if ( n >= max )
-            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
+            throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
 
         neighbor_mapping_[obj][n] = obj_data_pair;
     }
@@ -47,7 +47,7 @@ class ConnectivityContainer
     {
         // check that the index is not too large
         if ( n >= max )
-            throw not_found(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
+            throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
 
         typename obj_neighbor_objdata_array_map::const_iterator i(neighbor_mapping_.find(id));
         if (neighbor_mapping_.end() == i)

From 890eba60e471328ab9e60e6bb2c5ade567b3f548 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Wed, 16 May 2012 19:04:25 +0200
Subject: [PATCH 0904/1541] implemented 'connect_structures' for cylindrical
 structures.

---
 StructureContainer.hpp | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index f4ffe3be..3e0737f2 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -54,6 +54,7 @@ class StructureContainer
             typename structure_map::const_iterator>                                 structure_iterator;
     typedef typename std::map<structure_id_type, structure_id_set>                  per_structure_substructure_id_set;
 
+    typedef typename structure_type::length_type                        length_type;
     typedef typename structure_type::position_type                      position_type;
     typedef typename structure_type::position_type                      vector_type;
 
@@ -139,6 +140,32 @@ class StructureContainer
     {
         return cylindrical_structs_bc_.get_neighbor_info(structure.id(), n);
     }
+    virtual bool connect_structures(planar_surface_type const& structure1, planar_surface_side_type const& side1,
+                                    planar_surface_type const& structure2, planar_surface_side_type const& side2)
+    {
+        // TODO if the structure are not the same, check that the planes actually touch at the right edge.
+        return true;
+    }
+    virtual bool connect_structures(cylindrical_surface_type const& structure1, cylindrical_surface_side_type const& side1,
+                                    cylindrical_surface_type const& structure2, cylindrical_surface_side_type const& side2)
+    {
+        if ( structure1.id() != structure2.id() )
+        {
+            throw unsupported("Two different cylinders cannot be connected (yet...).");
+        }
+        const length_type factor( (side1 == 1) ? 1.0 : -1.0);
+        if ( side1 == side2 )
+        {
+            cylindrical_structs_bc_.set_neighbor_info(structure1.id(), side1, std::make_pair(structure2.id(), multiply( structure2.shape().unit_z(), -factor ) ) );
+            cylindrical_structs_bc_.set_neighbor_info(structure2.id(), side2, std::make_pair(structure1.id(), multiply( structure1.shape().unit_z(), -factor ) ) );
+        }
+        else
+        {
+            cylindrical_structs_bc_.set_neighbor_info(structure1.id(), side1, std::make_pair(structure2.id(), multiply( structure2.shape().unit_z(), factor  ) ) );
+            cylindrical_structs_bc_.set_neighbor_info(structure2.id(), side2, std::make_pair(structure1.id(), multiply( structure1.shape().unit_z(), -factor ) ) );
+        }
+        return true;
+    }
 
     // Template member function to call the right 'apply_boundary' function for the various types of structures.
     template <typename Tstructure_>

From ebf56beb2fcd1e65970ed8b69e37dc125e495646 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 18 May 2012 18:00:42 +0200
Subject: [PATCH 0905/1541] implemented 'connect_structures' method

---
 StructureContainer.hpp | 39 +++++++++++++++++++++++++++++++++++----
 World.hpp              |  9 +++++++++
 binding/World.hpp      |  2 ++
 3 files changed, 46 insertions(+), 4 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 3e0737f2..28a51913 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -140,14 +140,45 @@ class StructureContainer
     {
         return cylindrical_structs_bc_.get_neighbor_info(structure.id(), n);
     }
-    virtual bool connect_structures(planar_surface_type const& structure1, planar_surface_side_type const& side1,
-                                    planar_surface_type const& structure2, planar_surface_side_type const& side2)
+//    virtual bool connect_structures(planar_surface_type const& structure1, planar_surface_side_type const& side1,
+//                                    planar_surface_type const& structure2, planar_surface_side_type const& side2)
+    virtual bool connect_structures(planar_surface_type const& structure1, int const& side1,
+                                    planar_surface_type const& structure2, int const& side2)
     {
         // TODO if the structure are not the same, check that the planes actually touch at the right edge.
+        vector_type structure1_vector;
+        vector_type structure2_vector;
+        // FIXME cleanup code below
+        switch (side1)
+        {
+            case 0: structure1_vector = multiply(structure1.shape().unit_y(), -1.0);
+                break;
+            case 1: structure1_vector = structure1.shape().unit_y();
+                break;
+            case 2: structure1_vector = structure1.shape().unit_x();
+                break;
+            case 3: structure1_vector = multiply(structure1.shape().unit_x(), -1.0);
+                break;
+        }
+        switch (side2)
+        {
+            case 0: structure2_vector = multiply(structure2.shape().unit_y(), -1.0);
+                break;
+            case 1: structure2_vector = structure2.shape().unit_y();
+                break;
+            case 2: structure2_vector = structure2.shape().unit_x();
+                break;
+            case 3: structure2_vector = multiply(structure2.shape().unit_x(), -1.0);
+                break;
+        }
+        planar_structs_bc_.set_neighbor_info(structure1.id(), side1, std::make_pair(structure2.id(), structure2_vector) );
+        planar_structs_bc_.set_neighbor_info(structure2.id(), side2, std::make_pair(structure1.id(), structure1_vector) );
         return true;
     }
-    virtual bool connect_structures(cylindrical_surface_type const& structure1, cylindrical_surface_side_type const& side1,
-                                    cylindrical_surface_type const& structure2, cylindrical_surface_side_type const& side2)
+//    virtual bool connect_structures(cylindrical_surface_type const& structure1, cylindrical_surface_side_type const& side1,
+//                                    cylindrical_surface_type const& structure2, cylindrical_surface_side_type const& side2)
+    virtual bool connect_structures(cylindrical_surface_type const& structure1, int const& side1,
+                                    cylindrical_surface_type const& structure2, int const& side2)
     {
         if ( structure1.id() != structure2.id() )
         {
diff --git a/World.hpp b/World.hpp
index fba0e7f2..cc4a5d45 100644
--- a/World.hpp
+++ b/World.hpp
@@ -234,7 +234,9 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     typedef typename base_type::cuboidal_region_type                cuboidal_region_type;
     typedef typename base_type::planar_surface_type                 planar_surface_type;
+    typedef typename planar_surface_type::side_enum_type            planar_surface_side_type;
     typedef typename base_type::cylindrical_surface_type            cylindrical_surface_type;
+    typedef typename cylindrical_surface_type::side_enum_type       cylindrical_surface_side_type;
 
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
@@ -415,6 +417,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         //  -only remove if no particles
         return base_type::remove_structure(id);
     }
+    template <typename Tstructure_, typename Tside_enum_>
+    bool connect_structures(Tstructure_ const& structure1, Tside_enum_ const& side1,
+                            Tstructure_ const& structure2, Tside_enum_ const& side2)
+    {
+        return base_type::structures_.connect_structures(structure1, side1, structure2, side2);
+    }
+
     // Get all the structure ids by structure_type id
     structure_id_set get_structure_ids(structure_type_id_type const& sid) const
     {
diff --git a/binding/World.hpp b/binding/World.hpp
index 12eaf177..b42c262a 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -410,6 +410,8 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("add_structure", &impl_type::template add_structure<typename impl_type::planar_surface_type>)
         .def("add_structure", &impl_type::template add_structure<typename impl_type::cuboidal_region_type>)
         .def("add_structure", &impl_type::template add_structure<typename impl_type::cylindrical_surface_type>)
+        .def("connect_structures", &impl_type::template connect_structures<typename impl_type::planar_surface_type,      int>)
+        .def("connect_structures", &impl_type::template connect_structures<typename impl_type::cylindrical_surface_type, int>)
         .def("set_def_structure", &impl_type::set_def_structure)
         // StructureType stuff
         .def("add_structure_type", &impl_type::add_structure_type)

From db00b80107e18d24ad50f1ed5130a4f776dd4174 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 18 May 2012 18:03:33 +0200
Subject: [PATCH 0906/1541] updated 'create_box' to include 'connecting' the
 planes

---
 gfrdbase.py | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index a6e4b893..c90b8ca1 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -104,7 +104,7 @@ def get_all_surfaces(world, pos, ignores=[]):
             distance = world.distance(surface.shape, pos_transposed)
             surface_distances.append((surface, distance))
 
-    return surface_distances
+    return sorted(surface_distances, key=lambda surface_dist: surface_dist[1])
 
 def create_world(m, matrix_size=10):
     """Create a world object.
@@ -200,10 +200,10 @@ def create_box(world, structure_type, center, size):
     name = 'box'
     def_struct_id = world.get_def_structure_id()
     
-    front  = model.create_planar_surface(sid, name+'_front', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
-    back   = model.create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
-    right  = model.create_planar_surface(sid, name+'_right', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
-    left   = model.create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
+    front  = model.create_planar_surface(sid, name+'_front', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
+    back   = model.create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
+    right  = model.create_planar_surface(sid, name+'_right', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
+    left   = model.create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
     top    = model.create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
     bottom = model.create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
     world.add_structure(front)
@@ -212,6 +212,18 @@ def create_box(world, structure_type, center, size):
     world.add_structure(left)
     world.add_structure(top)
     world.add_structure(bottom)
+    world.connect_structures( front, 0, top, 1)
+    world.connect_structures( front, 1, bottom, 2)
+    world.connect_structures( front, 2, left, 1)
+    world.connect_structures( front, 3, right, 2)
+    world.connect_structures(  back, 0, right, 3)
+    world.connect_structures(  back, 1, left, 0)
+    world.connect_structures(  back, 2, bottom, 3)
+    world.connect_structures(  back, 3, top, 0)
+    world.connect_structures(   top, 2, left, 3)
+    world.connect_structures(   top, 3, right, 0)
+    world.connect_structures(bottom, 0, right, 1)
+    world.connect_structures(bottom, 1, left, 2)
 
 
 def create_network_rules_wrapper(model):

From 268b42974d6898bd5e66544d25cadcd23495ab72 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 May 2012 18:22:41 +0200
Subject: [PATCH 0907/1541] introduced check_surface_overlap with ignore field

---
 Multi.hpp                     |  6 ++++++
 ParticleContainer.hpp         |  3 +++
 ParticleContainerBase.hpp     | 19 +++++++++++++++++--
 Transaction.hpp               |  6 ++++++
 binding/ParticleContainer.hpp |  9 +++++++++
 5 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 007f3bd4..1ceb9793 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -240,6 +240,12 @@ class MultiParticleContainer
         return world_.check_surface_overlap(s, old_pos, current, sigma);
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore) const
+    {
+        return world_.check_surface_overlap(s, old_pos, current, sigma, ignore);
+    }
+
     virtual particle_id_pair_generator* get_particles() const
     {
         return make_range_generator<particle_id_pair>(particles_);
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index e321396e..8951f4db 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -118,6 +118,9 @@ class ParticleContainer
     virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const = 0;
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore) const = 0;
+
     // Particle stuff
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
             position_type const& pos) = 0;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 12190d69..664fbe03 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -272,10 +272,26 @@ class ParticleContainerBase
         return oc.result();
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore) const
+    {
+        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
+        surface_overlap_checker(s, old_pos, current, sigma, checker);
+        return checker.result();
+    }
+
     virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
+        surface_overlap_checker(s, old_pos, current, sigma, checker);
+        return checker.result();
+    }
+
+    template<typename Tfun_>
+    void surface_overlap_checker(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                        length_type const& sigma, Tfun_& checker ) const
+    {
         const structure_id_set visible_structures (structures_.get_visible_structures(current));
 
         // get and temporarily store all the visibles structures (upto now we only had their IDs)
@@ -287,7 +303,7 @@ class ParticleContainerBase
             temp_map[(*i)] = get_structure(*i);
         }
 
-        // calculate the distances and store the surface,distance tuple in the overlap checker if smaller that the particle radius.
+        // calculate the distances and store the surface,distance tuple in the overlap checker if smaller than the particle radius.
         for (typename structure_map::const_iterator i(temp_map.begin()),
                                                     e(temp_map.end());
              i != e; ++i)
@@ -300,7 +316,6 @@ class ParticleContainerBase
                 checker(i, dist);
             }
         }
-        return checker.result();
     }
 
     particle_id_pair get_particle(particle_id_type const& id, bool& found) const
diff --git a/Transaction.hpp b/Transaction.hpp
index 893b7b46..27fd1f29 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -175,6 +175,12 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.check_surface_overlap(s, old_pos, current, sigma);
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore) const
+    {
+        return pc_.check_surface_overlap(s, old_pos, current, sigma, ignore);
+    }
+
     virtual Transaction<traits_type>* create_transaction()
     {
         return new TransactionImpl<particle_container_type>(*this);
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index ec9fc251..e0775296 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -535,6 +535,14 @@ class ParticleContainerWrapper
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
 
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore) const
+    {
+        return py_wrapper_type::get_override("check_surface_overlap")(
+                s, old_pos, current, sigma, ignore)
+               .template unchecked<structure_id_pair_and_distance_list*>();
+    }
+
     virtual particle_id_pair_generator* get_particles() const
     {
         return py_wrapper_type::get_override("__iter__")()
@@ -641,6 +649,7 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
+        .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&, typename impl_type::length_type const&, typename impl_type::structure_id_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
         .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&, typename impl_type::length_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
         .def("create_transaction", pure_virtual(&impl_type::create_transaction),
                 return_value_policy<manage_new_object>())

From f33fb39b30fddcec1afbf335e26eee307e439cc4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 21 May 2012 18:44:58 +0200
Subject: [PATCH 0908/1541] Basic impl. of testMixedPair1DCap and
 MixedPair1DCaptestShell

This will be used by MixedPair1DCap which is the domain for
a 1D particle interacting with an immobile disk-bound cap-particle.
---
 shells.py | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 78 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 1d022250..c42c96fc 100755
--- a/shells.py
+++ b/shells.py
@@ -33,6 +33,7 @@
     'testSimplePair',
     'testPlanarSurfaceTransitionPair',
     'testMixedPair2D3D',
+    'testMixedPair1DCap',
     'hasSphericalShell',
     'hasCylindricalShell',   
     'SphericalSingletestShell',
@@ -49,6 +50,7 @@
     'CylindricalSurfaceCapInteractiontestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
+    'MixedPair1DCaptestShell',
     ]
 
 # These are exceptions that are raise when trying to make a new domain
@@ -365,6 +367,26 @@ def get_scaling_factor(self):
                                                 # normal to the plane
         return math.sqrt(self.D_r/D_2)
 
+class testMixedPair1DCap(testPair):
+
+    def __init__(self, cap_single, single1D):
+
+        if __debug__: 
+                assert isinstance(cap_single.structure, DiskSurface)
+                assert isinstance(single1D.structure, CylindricalSurface) 
+        testSimplePair.__init__(self, cap_single, single1D)
+          # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
+          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
+
+        # for clarity:
+        self.cap_structure = cap_single.structure  # equal to self.structure1
+        self.structure1D   = single1D.structure    # equal to self.structure2  
+
+        # Make sure cap particle is immobile; this is required for testSimplePair routines
+        # to give the proper results for this case.
+        assert self.pid_particle_pair1[1].D == 0
+        assert self.pid_particle_pair1[1].v == 0
+
 class testPlanarSurfaceTransitionPair(testPair):
 
     # This is essentially a copy of testSimplePair; however, the latter does
@@ -2112,5 +2134,60 @@ def apply_safety(self, r, z_right, z_left):
         SAFETY = 1.1
         return r/SAFETY, self.z_right(r/SAFETY), z_left
 
+class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):
+
+    def __init__(self, cap_single, single1D, target_structure, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testMixedPair1DCap.__init__(self, cap_single, single1D)
+
+        # initialize scaling parameters
+        self.dzdr_right = numpy.inf
+        self.drdz_right = 0.0
+        self.r0_right   = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        self.z0_right   = 0.0
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)      # TODO put to zero?
+        self.z0_left    = self.pid_particle_pair1[1].radius * SINGLE_SHELL_FACTOR
+          # pid_particle_pair1[1] is the cap-bound particle
+
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id]) # TODO Do we need target_structure (for the ignore list)?
+        except ShellmakingError as e:
+            raise testShellError('(MixedPair1DCap). %s' %
+                                 (str(e)))
+
+    def get_orientation_vector(self):
+        # The orientation vector is collinear with the parent cylinder axis and
+        # pointing "inwards", i.e. towards the center point of the parent cylinder
+        # TODO Check that this works properly!
+        return self.reference_vector     # reference vector always points from the particle position
+                                         # projected onto the target surface towards particle pos.
+
+    def get_searchpoint(self):
+        return self.com
+
+    def get_referencepoint(self):
+        return self.com
+
+    def get_min_dr_dzright_dzleft(self):
+        dr       = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        dz_left  = self.pid_particle_pair1[1].radius * SINGLE_SHELL_FACTOR
+        dz_right = self.get_min_pair_size() # TODO make sure this does the right thing!
+        return dr, dz_right, dz_left
+        
+    def get_max_dr_dzright_dzleft(self):
+        dr       = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        dz_left  = self.pid_particle_pair1[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+        return dr, dz_right, dz_left
+
+    def apply_safety(self, r, z_right, z_left):
+        return r, z_right/SAFETY, z_left
+
 #####
-#class MixedPair3D1DtestShell(CylindricaltestShell, Others):
+#class MixedPair3D1DtestShell(CylindricaltestShell, Others):
\ No newline at end of file

From a759ce6bd733b2864c43ccd8afd715c8eb46d23c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 May 2012 19:06:52 +0200
Subject: [PATCH 0909/1541] replaced the old_pos with a displacement vector as
 an argument to the surface_overlap method

---
 Multi.hpp                     |  8 ++++----
 ParticleContainer.hpp         |  4 ++--
 ParticleContainerBase.hpp     | 14 ++++++++------
 Transaction.hpp               |  8 ++++----
 binding/ParticleContainer.hpp |  8 ++++----
 gfrdbase.py                   |  5 +++--
 6 files changed, 25 insertions(+), 22 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 1ceb9793..07c30b4d 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -234,16 +234,16 @@ class MultiParticleContainer
         return checker.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
-        return world_.check_surface_overlap(s, old_pos, current, sigma);
+        return world_.check_surface_overlap(s, displacement, current, sigma);
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
-        return world_.check_surface_overlap(s, old_pos, current, sigma, ignore);
+        return world_.check_surface_overlap(s, displacement, current, sigma, ignore);
     }
 
     virtual particle_id_pair_generator* get_particles() const
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 8951f4db..a8c0e307 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -115,10 +115,10 @@ class ParticleContainer
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const = 0;
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma) const = 0;
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const = 0;
 
     // Particle stuff
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 664fbe03..60caef42 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -65,6 +65,7 @@ struct ParticleContainerUtils
                     result_ = new list_type();
                 }
                 result_->push_back(std::make_pair(*i, dist));
+                std::cout << "add to result: " << (*i).first << ", distance: " << dist << std::endl;
             }
         }
 
@@ -272,24 +273,24 @@ class ParticleContainerBase
         return oc.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
-        surface_overlap_checker(s, old_pos, current, sigma, checker);
+        surface_overlap_checker(s, displacement, current, sigma, checker);
         return checker.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
-        surface_overlap_checker(s, old_pos, current, sigma, checker);
+        surface_overlap_checker(s, displacement, current, sigma, checker);
         return checker.result();
     }
 
     template<typename Tfun_>
-    void surface_overlap_checker(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    void surface_overlap_checker(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                         length_type const& sigma, Tfun_& checker ) const
     {
         const structure_id_set visible_structures (structures_.get_visible_structures(current));
@@ -309,10 +310,11 @@ class ParticleContainerBase
              i != e; ++i)
         {
             const position_type cyc_pos     (cyclic_transpose(s.position(), ((*i).second)->position()));
-            const position_type cyc_old_pos (cyclic_transpose(old_pos,      ((*i).second)->position()));
+            const position_type cyc_old_pos (subtract(cyc_pos, displacement));
             const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), cyc_old_pos, sigma));
             if (dist < s.radius())
             {
+                std::cout << "add to checker: " << (*i).first << std::endl;
                 checker(i, dist);
             }
         }
diff --git a/Transaction.hpp b/Transaction.hpp
index 27fd1f29..f2515c6a 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -169,16 +169,16 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.check_overlap(s, ignore1, ignore2);
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
-        return pc_.check_surface_overlap(s, old_pos, current, sigma);
+        return pc_.check_surface_overlap(s, displacement, current, sigma);
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
-        return pc_.check_surface_overlap(s, old_pos, current, sigma, ignore);
+        return pc_.check_surface_overlap(s, displacement, current, sigma, ignore);
     }
 
     virtual Transaction<traits_type>* create_transaction()
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index e0775296..f8d95427 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -527,19 +527,19 @@ class ParticleContainerWrapper
                .template unchecked<particle_id_pair_and_distance_list*>();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
         return py_wrapper_type::get_override("check_surface_overlap")(
-                s, old_pos, current, sigma)
+                s, displacement, current, sigma)
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
         return py_wrapper_type::get_override("check_surface_overlap")(
-                s, old_pos, current, sigma, ignore)
+                s, displacement, current, sigma, ignore)
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
 
diff --git a/gfrdbase.py b/gfrdbase.py
index c90b8ca1..f0926196 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -246,6 +246,7 @@ def throw_in_particles(world, sid, n):
     species = world.get_species(sid)
     structure_type = world.get_structure_type(species.structure_type_id)
     structure_list = list(world.get_structure_ids(structure_type))
+    print structure_list
 
     if __debug__:
         name = world.model.get_species_type_by_id(sid)["name"]
@@ -265,7 +266,7 @@ def throw_in_particles(world, sid, n):
         # Check overlap. TODO put in 'if' statement for improved efficiency?
         particle_overlaps = world.check_overlap((position, species.radius))
         surface_overlaps  = world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
-                                                        position, structure.id, species.radius)
+                                                        [0,0,0], structure.id, species.radius)
 
         if (not particle_overlaps) and (not surface_overlaps):
             # All checks passed. Create particle.
@@ -314,7 +315,7 @@ def place_particle(world, sid, position):
     if species.structure_type_id == world.get_def_structure_type_id():
         structure_id = world.get_def_structure_id()
         if world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
-                                       position, structure_id, radius):#(surface and distance < surface.minimal_distance(species.radius)):
+                                       [0,0,0], structure_id, radius):#(surface and distance < surface.minimal_distance(species.radius)):
             raise RuntimeError('Placing particle failed: %s %s. '
                                'Too close to surface: %s.' %
                                (sid, position, distance))

From 9d21ddd9b531d7eab0e9f491544c537fb26e30d7 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 May 2012 19:11:40 +0200
Subject: [PATCH 0910/1541] Revert "replaced the old_pos with a displacement
 vector as an argument to the surface_overlap method"

This reverts commit a759ce6bd733b2864c43ccd8afd715c8eb46d23c.
---
 Multi.hpp                     |  8 ++++----
 ParticleContainer.hpp         |  4 ++--
 ParticleContainerBase.hpp     | 14 ++++++--------
 Transaction.hpp               |  8 ++++----
 binding/ParticleContainer.hpp |  8 ++++----
 gfrdbase.py                   |  5 ++---
 6 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 07c30b4d..1ceb9793 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -234,16 +234,16 @@ class MultiParticleContainer
         return checker.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
-        return world_.check_surface_overlap(s, displacement, current, sigma);
+        return world_.check_surface_overlap(s, old_pos, current, sigma);
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
-        return world_.check_surface_overlap(s, displacement, current, sigma, ignore);
+        return world_.check_surface_overlap(s, old_pos, current, sigma, ignore);
     }
 
     virtual particle_id_pair_generator* get_particles() const
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index a8c0e307..8951f4db 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -115,10 +115,10 @@ class ParticleContainer
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const = 0;
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const = 0;
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const = 0;
 
     // Particle stuff
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 60caef42..664fbe03 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -65,7 +65,6 @@ struct ParticleContainerUtils
                     result_ = new list_type();
                 }
                 result_->push_back(std::make_pair(*i, dist));
-                std::cout << "add to result: " << (*i).first << ", distance: " << dist << std::endl;
             }
         }
 
@@ -273,24 +272,24 @@ class ParticleContainerBase
         return oc.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
-        surface_overlap_checker(s, displacement, current, sigma, checker);
+        surface_overlap_checker(s, old_pos, current, sigma, checker);
         return checker.result();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
-        surface_overlap_checker(s, displacement, current, sigma, checker);
+        surface_overlap_checker(s, old_pos, current, sigma, checker);
         return checker.result();
     }
 
     template<typename Tfun_>
-    void surface_overlap_checker(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    void surface_overlap_checker(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                         length_type const& sigma, Tfun_& checker ) const
     {
         const structure_id_set visible_structures (structures_.get_visible_structures(current));
@@ -310,11 +309,10 @@ class ParticleContainerBase
              i != e; ++i)
         {
             const position_type cyc_pos     (cyclic_transpose(s.position(), ((*i).second)->position()));
-            const position_type cyc_old_pos (subtract(cyc_pos, displacement));
+            const position_type cyc_old_pos (cyclic_transpose(old_pos,      ((*i).second)->position()));
             const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), cyc_old_pos, sigma));
             if (dist < s.radius())
             {
-                std::cout << "add to checker: " << (*i).first << std::endl;
                 checker(i, dist);
             }
         }
diff --git a/Transaction.hpp b/Transaction.hpp
index f2515c6a..27fd1f29 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -169,16 +169,16 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.check_overlap(s, ignore1, ignore2);
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
-        return pc_.check_surface_overlap(s, displacement, current, sigma);
+        return pc_.check_surface_overlap(s, old_pos, current, sigma);
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
-        return pc_.check_surface_overlap(s, displacement, current, sigma, ignore);
+        return pc_.check_surface_overlap(s, old_pos, current, sigma, ignore);
     }
 
     virtual Transaction<traits_type>* create_transaction()
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index f8d95427..e0775296 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -527,19 +527,19 @@ class ParticleContainerWrapper
                .template unchecked<particle_id_pair_and_distance_list*>();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const
     {
         return py_wrapper_type::get_override("check_surface_overlap")(
-                s, displacement, current, sigma)
+                s, old_pos, current, sigma)
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
 
-    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& displacement, structure_id_type const& current,
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
         return py_wrapper_type::get_override("check_surface_overlap")(
-                s, displacement, current, sigma, ignore)
+                s, old_pos, current, sigma, ignore)
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
 
diff --git a/gfrdbase.py b/gfrdbase.py
index f0926196..c90b8ca1 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -246,7 +246,6 @@ def throw_in_particles(world, sid, n):
     species = world.get_species(sid)
     structure_type = world.get_structure_type(species.structure_type_id)
     structure_list = list(world.get_structure_ids(structure_type))
-    print structure_list
 
     if __debug__:
         name = world.model.get_species_type_by_id(sid)["name"]
@@ -266,7 +265,7 @@ def throw_in_particles(world, sid, n):
         # Check overlap. TODO put in 'if' statement for improved efficiency?
         particle_overlaps = world.check_overlap((position, species.radius))
         surface_overlaps  = world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
-                                                        [0,0,0], structure.id, species.radius)
+                                                        position, structure.id, species.radius)
 
         if (not particle_overlaps) and (not surface_overlaps):
             # All checks passed. Create particle.
@@ -315,7 +314,7 @@ def place_particle(world, sid, position):
     if species.structure_type_id == world.get_def_structure_type_id():
         structure_id = world.get_def_structure_id()
         if world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
-                                       [0,0,0], structure_id, radius):#(surface and distance < surface.minimal_distance(species.radius)):
+                                       position, structure_id, radius):#(surface and distance < surface.minimal_distance(species.radius)):
             raise RuntimeError('Placing particle failed: %s %s. '
                                'Too close to surface: %s.' %
                                (sid, position, distance))

From 5b6c8389f193902448e2811a3fce787b86c5b43f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Mon, 21 May 2012 19:50:58 +0200
Subject: [PATCH 0911/1541] Bugfix for overlap check with planar surfaces. If
 the old and new position are cylic transposed, they need to be transposed in
 the same way. Otherwise we may introduce a jump between the positions of
 approximately half the simulation box size.

---
 ParticleContainerBase.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 664fbe03..2d447b3a 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -308,9 +308,11 @@ class ParticleContainerBase
                                                     e(temp_map.end());
              i != e; ++i)
         {
-            const position_type cyc_pos     (cyclic_transpose(s.position(), ((*i).second)->position()));
-            const position_type cyc_old_pos (cyclic_transpose(old_pos,      ((*i).second)->position()));
-            const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), cyc_old_pos, sigma));
+            const position_type cyc_old_pos (cyclic_transpose(old_pos, s.position()));      // The old position transposed towards the new position (which may also be modified by periodic BC's)
+            const position_type displacement (subtract(s.position(), cyc_old_pos));         // the relative displacement from the 'old' position towards the real new position
+            const position_type cyc_pos     (cyclic_transpose(s.position(), ((*i).second)->position()));    // new position transposed to the structure in question
+            const position_type cyc_old_pos2 (subtract(cyc_pos, displacement));             // calculate the old_pos relative to the transposed new position.
+            const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), cyc_old_pos2, sigma));
             if (dist < s.radius())
             {
                 checker(i, dist);

From 0a73d193d8aa55a23b7c0967523186a866579bbe Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 May 2012 11:37:35 +0200
Subject: [PATCH 0912/1541] moved 'set_def_structure' to World since
 'update_structure' also needs to be called in World.

---
 StructureContainer.hpp | 15 ++-------------
 World.hpp              | 13 ++++++++++---
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 28a51913..7ab56af3 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -115,10 +115,10 @@ class StructureContainer
     }
     virtual bool update_structure (cuboidal_region_id_pair_type const& structid_cube)
     {
-        // add to Connectivity container for cuboidal regions
-        // NOTE this information is never queried!! Maybe leave the neighbor info out?
         if ( update_structure_base(structid_cube))
         {
+            // add to Connectivity container for cuboidal regions
+            // NOTE this information is never queried!! Maybe leave the neighbor info out?
             cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_z()));
             cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 1, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_z(), -1.0) ));
             cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 2, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_y()));
@@ -214,17 +214,6 @@ class StructureContainer
     {
         return default_structure_id_;
     }
-    void set_def_structure(const boost::shared_ptr<cuboidal_region_type> cuboidalregion)
-    {
-        // check that the structure_type is the default structure_type
-        if ( cuboidalregion->structure_id() != default_structure_id_)
-        {
-            throw illegal_state("Default structure should have itself as parent.");
-        }
-        cuboidalregion->set_id(default_structure_id_);
-        update_structure(std::make_pair(default_structure_id_, cuboidalregion));
-    }
-
     virtual bool has_structure(structure_id_type const& id) const
     {
         typename structure_map::const_iterator i(structure_map_.find(id));
diff --git a/World.hpp b/World.hpp
index cc4a5d45..d47dc618 100644
--- a/World.hpp
+++ b/World.hpp
@@ -257,8 +257,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
 public:
     // The constructor
-//    World(length_type world_size = 1., size_type size = 1)
-//        : base_type(world_size, size, structidgen_()) {}
     World(length_type world_size = 1., size_type size = 1)
         : base_type(world_size, size)
     {
@@ -442,15 +440,24 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     }
     void set_def_structure(const boost::shared_ptr<cuboidal_region_type> cuboidal_region)
     {
+        const structure_id_type default_struct_id(get_def_structure_id());
+
         // check that the structure_type is the default structure_type
         if (!default_structure_type_id_ ||
             (cuboidal_region->sid() != default_structure_type_id_) )
         {
             throw illegal_state("Default structure is not of default StructureType");
         }
+        if ( cuboidal_region->structure_id() != default_struct_id)
+        {
+            throw illegal_state("Default structure should have itself as parent.");
+        }
+
         // check that the structure_type that is defined in the structure exists!
         structure_type_type const& structure_type(get_structure_type(cuboidal_region->sid()));
-        base_type::structures_.set_def_structure(cuboidal_region);
+
+        cuboidal_region->set_id(default_struct_id);
+        update_structure(std::make_pair(default_struct_id, cuboidal_region));
     }
     // Get the closest surface(surface is a subclass of structures)
     // TODO change this to get all the surfaces within a certain distance of the particle.

From 41afc689e9729097c37e387f8f68dbc059c97c63 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 May 2012 15:08:37 +0200
Subject: [PATCH 0913/1541] Small fix, cyclic transpose needs to be performed
 before appling structure boundary conditions.

---
 ParticleContainerBase.hpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 2d447b3a..04a70f04 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -195,9 +195,13 @@ class ParticleContainerBase
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        const boost::shared_ptr<const structure_type> structure) const
     {
+        // cyclic transpose the position with the structure
+        const position_structid_pair_type cyc_pos_struct_id (std::make_pair(cyclic_transpose(pos_struct_id.first, structure->position()),
+                                                                            pos_struct_id.second));
+
         // The generalized boundary condition application first:
         // 1. applies the boundary of the structure/surface (go around the corner etc)
-        const position_structid_pair_type new_pos_struct_id(structure->apply_boundary(pos_struct_id, structures_));
+        const position_structid_pair_type new_pos_struct_id(structure->apply_boundary(cyc_pos_struct_id, structures_));
         // 2. Then also apply the boundary condition of the world
         return std::make_pair(apply_boundary(new_pos_struct_id.first), new_pos_struct_id.second);
     }
@@ -215,8 +219,9 @@ class ParticleContainerBase
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          const boost::shared_ptr<const structure_type> structure) const
     {
-        const position_type pos (cyclic_transpose(pos_struct_id.first, structure->position()));
-        return structure->cyclic_transpose(std::make_pair(pos, pos_struct_id.second), structures_);
+        const position_structid_pair_type cyc_pos_struct_id (std::make_pair(cyclic_transpose(pos_struct_id.first, structure->position()),
+                                                                            pos_struct_id.second));
+        return structure->cyclic_transpose(cyc_pos_struct_id, structures_);
     }
 
     // THIS SEEMS STRANGE TO PUT THIS HERE. 
@@ -310,7 +315,7 @@ class ParticleContainerBase
         {
             const position_type cyc_old_pos (cyclic_transpose(old_pos, s.position()));      // The old position transposed towards the new position (which may also be modified by periodic BC's)
             const position_type displacement (subtract(s.position(), cyc_old_pos));         // the relative displacement from the 'old' position towards the real new position
-            const position_type cyc_pos     (cyclic_transpose(s.position(), ((*i).second)->position()));    // new position transposed to the structure in question
+            const position_type cyc_pos      (cyclic_transpose(s.position(), ((*i).second)->position()));    // new position transposed to the structure in question
             const position_type cyc_old_pos2 (subtract(cyc_pos, displacement));             // calculate the old_pos relative to the transposed new position.
             const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), cyc_old_pos2, sigma));
             if (dist < s.radius())

From 7105fc223292b0f0ffd4908dbd21282dae449837 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 May 2012 15:13:42 +0200
Subject: [PATCH 0914/1541] Moved check that two particles reacting are only
 one hierarchical level apart, to 'attempt_pair_reaction'

---
 newBDPropagator.hpp | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index a07f7f8d..21e33c1f 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -174,10 +174,10 @@ class newBDPropagator
         {
             // Get all the structures within the reaction volume (and that may consequently also be in the core)
             boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_tmp(
-                tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0));
+                tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, new_structure_id, r0, old_struct_id));
             overlap_structures.swap(overlap_structures_tmp);
             int structures_in_overlap(overlap_structures ? overlap_structures->size(): 0);
-
+ 
             j = 0;
             while(!bounced && j < structures_in_overlap)
                 bounced = overlap_structures->at(j++).second < r0;
@@ -272,8 +272,8 @@ class newBDPropagator
             species_type s0(pp_species);
             species_type s1(tx_.get_species(overlap_particle.first.second.sid()));
                 
-            /* If the structure_types of the reactants are not equal, one of the reactants has to come from the bulk,
-               and we let this be s1, the particle from the surface is named s0. */
+/*            // If the structure_types of the reactants are not equal, one of the reactants has to come from the bulk,
+            // and we let this be s1, the particle from the surface is named s0.
             if(s0.structure_type_id() != s1.structure_type_id())
             {
                 if( !(s0.structure_type_id() == tx_.get_def_structure_type_id() || s1.structure_type_id() == tx_.get_def_structure_type_id())  )
@@ -284,7 +284,7 @@ class newBDPropagator
                 if(s0.structure_type_id() == tx_.get_def_structure_type_id())
                     std::swap(s0,s1);       // ??????
             }
-            
+*/            
             const boost::shared_ptr<const structure_type> s1_struct( tx_.get_structure( overlap_particle.first.second.structure_id()) );
             accumulated_prob += k_total(s0.id(), s1.id()) * dt_ /
                                 ( 2. * s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ); 
@@ -639,8 +639,8 @@ class newBDPropagator
                         boost::shared_ptr<structure_type>   reactant1_structure (tx_.get_structure( reactant1_structure_id ));
                         position_type                       reactant0_pos (pp0.second.position());
                         position_type                       reactant1_pos (pp1.second.position());
-                        const species_type                  product_species(tx_.get_species(products[0]));
 
+                        const species_type                  product_species(tx_.get_species(products[0]));
                         structure_id_type                   product_structure_id(reactant0_structure_id);
 
                         // If the particles lived on adjacent structures of the same type
@@ -674,11 +674,15 @@ class newBDPropagator
                                 product_structure_id = reactant0_structure_id;                          // -> lesser structure is structure0
                                 product_structure = reactant0_structure;
                             }
-                            else                                                                        // pp0 lives on the parent structure of pp1
+                            else if ( reactant1_structure->structure_id() == reactant0_structure_id )   // pp0 lives on the parent structure of pp1
                             {
                                 product_structure_id = reactant1_structure_id;                          // -> lesser structure is structure1
                                 product_structure = reactant1_structure;
                             }
+                            else
+                            {
+                                throw propagation_error("Particles can only be one hierarchical level apart.");
+                            }
 
                             projected_type const position_on_surface( product_structure-> projected_point(
                                     tx_.cyclic_transpose( product_pos, product_structure->position() )));       // TODO check of cyclic transpose is still needed.
@@ -788,7 +792,7 @@ class newBDPropagator
                     case 0:
                     {
 
-                        remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
+                        remove_particle(pp.first);
                         break;
                     }
                     // When one product particle
@@ -817,7 +821,7 @@ class newBDPropagator
                         {
                             throw propagation_error("no space due to near surface");
                         }
-                        // check for overlap with particles outside of the progator (e.g. the eGFRD simulator)
+                        // check for overlap with particles outside of the propagator (e.g. the eGFRD simulator)
                         if (vc_)
                         {
                             if (!(*vc_)(new_shape, pp.first))

From 69c3d5cf4fe9b6952a7795afc13742177a8f3f2a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 May 2012 15:16:04 +0200
Subject: [PATCH 0915/1541] some changed comments

---
 StructureContainer.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 7ab56af3..b9aeadd3 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -356,10 +356,10 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
 
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
+    // and that the position is already transposed for the plane.
     const plane_type origin_plane (planar_surface.shape());
     boost::array<length_type, 2> half_extends(origin_plane.half_extent());
 
-    // TODO do cyclic transpose here first?
     const position_type pos_vector( subtract(pos_structure_id.first, origin_plane.position()) );
     const length_type component_x ( dot_product(pos_vector, origin_plane.unit_x()) );
     const length_type component_y ( dot_product(pos_vector, origin_plane.unit_y()) );
@@ -423,8 +423,8 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     }
     else
     {
-        // we are somewhere in the corners and don't know what to do
-        // reject move?
+        // we are somewhere in the corners and don't know what to do ->reject move
+        // We return the unmodified position, it will bounce later.
         return pos_structure_id;
     }
 
@@ -551,7 +551,6 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     const cylinder_type origin_cylinder (cylindrical_surface.shape());
     const length_type half_length(origin_cylinder.half_length());
 
-    // TODO do cyclic transpose here first?
     const position_type pos_vector( subtract(pos_structure_id.first, origin_cylinder.position()) );
     const length_type component_z ( dot_product(pos_vector, origin_cylinder.unit_z()) );
 

From ce206e7071ea819be0dd6c40abde8fe6d69c9236 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 May 2012 15:45:43 +0200
Subject: [PATCH 0916/1541] comment on previous merge

---
 visualization/vtklogger.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index b77c8020..07bfcd8e 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -411,6 +411,7 @@ def process_cylinders(self, cylinders=[], color_list=[]):
             # Pre-process disks which are put into the same
             # list as cylinders but lack the half_length property
             # TODO Give disks a different color!
+            # TODO Why the 'try' here?
             try:
                 if isinstance(cylinder.shape, Disk):
                     disk = cylinder

From 823b05789836f62e6327231ed4de3219e6f5513b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 22 May 2012 18:13:57 +0200
Subject: [PATCH 0917/1541] Basic impl. of MixedPair1DCap

... which is basically the same as CylindricalSurfacePair
with immobile CoM (D_R=0, v_R=0) and using the IV Green's function
to calculate the solution of the mobile particle.
---
 pair.py | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/pair.py b/pair.py
index 67c220ca..252f804b 100644
--- a/pair.py
+++ b/pair.py
@@ -23,6 +23,7 @@
     'SimplePair',
     'MixedPair2D3D',
     'MixedPair1D3D',
+    'MixedPair1DCap',
     ]
 
 
@@ -1023,3 +1024,86 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1D, struc
     def calc_r_scaling_factor(cls, D1, D2):
         return math.sqrt((D1 + D2)/D2)
 
+
+class MixedPair1DCap(Pair, hasCylindricalShell):
+
+    def __init__(self, domain_id, shell_id, testShell, rrs):
+
+        assert isinstance(testShell, MixedPair1DCaptestShell)
+        hasCylindricalShell.__init__(self, testShell, domain_id)
+        Pair.__init__(self, domain_id, shell_id, rrs)
+
+        assert isinstance(self.testShell, MixedPair1DCaptestShell)
+        self.cap_structure = self.testShell.cap_structure # equal to self.structure1
+        self.structure1D   = self.testShell.structure1D   # equal to self.structure2
+
+        # NOTE: self.pid_particle_pair1 is the cap particle
+        # and should be immobile
+        assert self.pid_particle_pair1[1].D == 0
+        assert self.pid_particle_pair1[1].v == 0
+
+        self.LD_MAX = numpy.inf # TODO what is that for?
+
+   def get_shell_size(self): # TODO Is that even used?
+        return self.shell.shape.half_length
+
+    def get_v_tot(self):
+        # 'direction' signifies the direction of the IV with respect to the surface unit_z
+        # (which defines the direction of positive drift)
+        # Assuming self.pid_particle_pair1[1].v == 0 here
+        direction = cmp(numpy.dot (self.iv, self.structure1D.shape.unit_z), 0)
+        return self.pid_particle_pair2[1].v * direction
+
+    # NOTE the v_tot and v_r are now positive in the direction of the IV!
+    v_tot = property(get_v_tot)
+    
+    v_r = property(get_v_tot)
+
+    def get_v_R(self):
+        # With our transform D_R and v_R are zero if one of the particles is immobile
+        return 0.0
+    v_R = property(get_v_R)
+
+    def com_greens_function(self):
+        # The Green's function used should be irrelevant, because D_R=0 and v_R=0
+        return GreensFunction1DAbsAbs(self.D_R, self.v_R, 0.0, -self.a_R, self.a_R)
+        # TODO Plug in D_R = 0 and v_R = 0 directly here?
+
+    def iv_greens_function(self, r0):
+        return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
+
+    def choose_pair_greens_function(self, r0, t):
+        # Todo
+        return self.iv_greens_function(r0)
+
+    @ classmethod
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
+    # here we assume that the com and iv are really in the structure and no adjustments have to be
+    # made
+
+        pos1 = self.pid_particle_pair1[1].position # cap particle stays in place in this case
+        pos2 = pos1 + iv
+
+        return pos1, pos2, structure1.id, structure2.id
+
+    def create_com_vector(self, z):
+        # The CoM vector is not relevant for this domain, thus...
+        pass
+
+    def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
+        if __debug__:
+            log.debug("create_interparticle_vector: r=%g, dt=%g", r, dt)
+
+        # note that r0 = length (old_iv)
+        new_iv = (r/r0) * old_iv
+
+        # project the new_iv down on the unit vectors of the surface to prevent the particle from
+        # leaving the surface due to numerical problem
+        unit_z = self.structure1D.shape.unit_z
+        new_iv_z = unit_z * numpy.dot(new_iv, unit_z)
+
+        return new_iv_z
+
+    def __str__(self):
+        return 'MixedPair1DCap' + Pair.__str__(self)
+

From 2f479dd92620258808757c5049da591cbe751b3b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 May 2012 18:25:39 +0200
Subject: [PATCH 0918/1541] Adjusted Disk and DiskSurface to work with
 newBDPropagator. Also, made small adjustments to make treatment of surfaces
 in particlecontainer and python binding more complete.

---
 Disk.hpp                      | 43 +++++++++++++--------
 DiskSurface.hpp               | 73 +++++++++++++++++++++--------------
 ParticleContainer.hpp         | 10 +++--
 ParticleContainerBase.hpp     |  5 +++
 StructureContainer.hpp        | 72 ++++++++++++++++++++++++----------
 World.hpp                     |  4 +-
 binding/ParticleContainer.hpp | 28 ++++++++++----
 binding/World.hpp             |  2 +
 8 files changed, 160 insertions(+), 77 deletions(-)

diff --git a/Disk.hpp b/Disk.hpp
index 1a2d6263..908bb58e 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -10,9 +10,10 @@ template<typename T_>
 class Disk
 {
 public:
-    typedef T_ value_type;
+    typedef T_          value_type;
     typedef Vector3<T_> position_type;
-    typedef T_ length_type;
+    typedef T_          length_type;
+    typedef enum side_enum_type {} side_enum_type;  // The typedef is a little bit C style but doesn't matter for C++
 
 public:
     // constructors
@@ -74,9 +75,9 @@ class Disk
 
 /////// Member variables
 private:
-    position_type position_;    // centre.
-    length_type radius_;
-    position_type unit_z_;      // Z-unit_z. should be normalized.
+    position_type   position_;    // centre.
+    length_type     radius_;
+    position_type   unit_z_;      // Z-unit_z. should be normalized.
 };
 
 
@@ -90,14 +91,24 @@ inline std::basic_ostream<Tstrm_>& operator<<(std::basic_ostream<Tstrm_>& strm,
 }
 
 template<typename T_>
-inline std::pair<typename Disk<T_>::length_type,
-                 typename Disk<T_>::length_type>
+inline bool
+is_alongside(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
+// The function checks if the projection of the position 'pos' is 'inside' the object.
+{
+    boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
+
+    return ( r_z[0] <= obj.radius() );
+}
+
+
+template<typename T_>
+inline boost::array<typename Disk<T_>::length_type, 2>
 to_internal(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
 {
     // Same as for the cylinder:
     // Return pos relative to position of the disk.
-    typedef typename Disk<T_>::position_type position_type;
-    typedef typename Disk<T_>::length_type length_type;
+    typedef typename Disk<T_>::position_type    position_type;
+    typedef typename Disk<T_>::length_type      length_type;
 
     const position_type pos_vector(subtract(pos, obj.position()));
     // z can be < 0
@@ -105,7 +116,7 @@ to_internal(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
     // r is always >= 0
     const length_type r(length(pos_vector - multiply(obj.unit_z(), z)));
 
-    return std::make_pair(r, z);
+    return array_gen<typename Disk<T_>::length_type>(r, z);
 }
 
 template<typename T_>
@@ -119,9 +130,9 @@ projected_point(Disk<T_> const& obj,
     // The disk is in principle a 1D object:
     // Projecting onto the disk means projecting onto its center.
     // The distance is the z-component returned by to_internal().
-    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
     
-    return std::make_pair( obj.position(), r_z.second);
+    return std::make_pair( obj.position(), r_z[1]);
 }
 
 // The same as in case of the plane: projected_point_on_surface = projected_point
@@ -146,14 +157,14 @@ distance(Disk<T_> const& obj,
      * defined by the vectors unitR and unit_z, where unitR is
      * choosen such that unitR and unit_z define a plane in which
      * pos lies. */
-    const std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    const boost::array<length_type, 2> r_z(to_internal(obj, pos));
 
     /* Then compute distance to cylinder with zero length. */
-    const length_type dz(std::fabs(r_z.second));
-    const length_type dr(r_z.first - obj.radius());
+    const length_type dz(std::fabs(r_z[1]));
+    const length_type dr(r_z[0] - obj.radius());
     length_type distance;
 
-    if (r_z.first > obj.radius())
+    if (dr > 0)
     {
         // pos is not above the disk.
         // Compute distance to edge.
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index b12519b4..141fd3c2 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -7,15 +7,19 @@
 #include "freeFunctions.hpp"
 #include "geometry.hpp"
 
+template <typename Tobj_, typename Tid_, typename Ttraits_>
+class StructureContainer;
+
+
 template<typename Ttraits_>
 class DiskSurface
-    : public BasicSurfaceImpl<Ttraits_, Disk<typename Ttraits_::world_type::traits_type::length_type> >
+    : public BasicSurfaceImpl<Ttraits_, Disk<typename Ttraits_::length_type> >
 {
     // The DiskSurface is the implementation of a Basic surface parameterized with a Disk
 
 public:
-    typedef BasicSurfaceImpl<Ttraits_, Disk<typename Ttraits_::world_type::traits_type::length_type> > base_type;
-    typedef typename base_type::traits_type             traits_type;    
+    typedef BasicSurfaceImpl<Ttraits_, Disk<typename Ttraits_::length_type> > base_type;
+    typedef Ttraits_    traits_type;
     typedef typename base_type::structure_name_type     structure_name_type;
     typedef typename base_type::structure_id_type       structure_id_type;
     typedef typename base_type::structure_type_id_type  structure_type_id_type;
@@ -23,8 +27,13 @@ class DiskSurface
     typedef typename base_type::rng_type                rng_type;
     typedef typename base_type::position_type           position_type;
     typedef typename base_type::length_type             length_type;
-    typedef typename Ttraits_::world_type::species_type species_type;
-    typedef std::pair<position_type, position_type>     position_pair_type;
+    typedef typename base_type::side_enum_type          side_enum_type;
+    typedef typename traits_type::species_type          species_type;
+
+    typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
+
+    typedef std::pair<position_type, position_type>         position_pair_type;
+    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
     virtual position_type random_position(rng_type& rng) const
     // Gives a "random position" in the disk, which is always its center,
@@ -43,7 +52,7 @@ class DiskSurface
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
     // BD displacement = zero vector because there is only one legal position on the disk
     {
-        return multiply(base_type::shape().unit_z(), 0.0);
+        return multiply(base_type::shape().unit_z(), 0.0);  // TODO is there not cheaper way to pass a zero vector?
     }
 
     virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
@@ -118,6 +127,7 @@ class DiskSurface
         // This function produces a position for a particle unbinding from the disk onto the rod.
         // It should lie within the reaction volume around the disk.
         // TODO: We have to make a distinction between sink and cap already here!
+        // FIXME WTF is all this calculation!! The dissociation vector is supposed to be super simple!
         Real X( rng.uniform(0.,1.) );
         length_type const rod_radius = base_type::shape().radius();
         position_type const unit_z = base_type::shape().unit_z();
@@ -198,33 +208,23 @@ class DiskSurface
         
         return pp01;
     }
-
-    /* Determine if particle has crossed the 'surface' of the structure. */
-    virtual bool bounced(position_type const& old_pos, position_type const& new_pos, 
-        length_type const& dist_to_surface, length_type const& particle_radius) const
-    {       
-        // TODO Remove this after merge with newest development version!
-        if( dist_to_surface < particle_radius )
-            return true;
-        else
-            return false;
-    }
-    
-    virtual bool in_reaction_volume( length_type const& dist_to_surface, length_type const& particle_radius, length_type const& rl ) const
-    {
-        // TODO Remove this after merge with newest development version!
-        if( dist_to_surface - particle_radius <= rl )
-            return true;
-        else
-            return false;
-    }
-    
-    // This should replace above two methods. TODO Copied from CylindricalStructure up to now
+   
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
-        return base_type::distance(new_pos);
+        const length_type disk_radius (base_type::shape().radius());
+        const boost::array<length_type, 2> new_pos_rz(::to_internal(base_type::shape(), new_pos));
+        const boost::array<length_type, 2> old_pos_rz(::to_internal(base_type::shape(), old_pos));
+        if (new_pos_rz[1] * old_pos_rz[1] < 0 &&
+            ( (new_pos_rz[0] < disk_radius ) || (old_pos_rz[0] < disk_radius) ) )
+        {
+            return -1.0 * base_type::distance(new_pos) + sigma;
+        }
+        else
+        {
+            return base_type::distance(new_pos) + sigma;
+        }
     }
-
+/*
     virtual length_type minimal_distance(length_type const& radius) const
     {
         // TODO
@@ -232,6 +232,19 @@ class DiskSurface
         // Return minimal distance *to* surface.
         return (cylinder_radius + radius) * traits_type::MINIMAL_SEPARATION_FACTOR - cylinder_radius;
     }
+*/
+    // FIXME This is a mess but it works. See ParticleContainerBase.hpp for explanation.
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
+                                                       structure_container_type const& structure_container) const
+    {
+        return pos_struct_id;   // This seems a little strange, but we assume that particles are immobile on the disk
+    }
+
+    virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
+                                                         structure_container_type const& structure_container) const
+    {
+        return pos_struct_id;   // Disks can also not be connected, so no cyclic transpose.
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 8951f4db..8d2cfac7 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -10,6 +10,7 @@
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
 #include "SphericalSurface.hpp"
+#include "DiskSurface.hpp"
 
 template<typename Ttraits_>
 class Transaction;
@@ -41,11 +42,14 @@ class ParticleContainer
     typedef CuboidalRegion<traits_type>                         cuboidal_region_type;
     typedef PlanarSurface<traits_type>                          planar_surface_type;
     typedef CylindricalSurface<traits_type>                     cylindrical_surface_type;
+    typedef DiskSurface<traits_type>                            disk_surface_type;
     typedef SphericalSurface<traits_type>                       spherical_surface_type;
 
-    typedef std::pair<structure_id_type, boost::shared_ptr<cuboidal_region_type> >       cuboidalreg_id_pair_type;
-    typedef std::pair<structure_id_type, boost::shared_ptr<planar_surface_type> >        planarsurface_id_pair_type;
-    typedef std::pair<structure_id_type, boost::shared_ptr<cylindrical_surface_type> >   cylindrsurf_id_pair_type;
+//    typedef std::pair<structure_id_type, boost::shared_ptr<cuboidal_region_type> >       cuboidal_region_id_pair_type;
+//    typedef std::pair<structure_id_type, boost::shared_ptr<planar_surface_type> >        planar_surface_id_pair_type;
+//    typedef std::pair<structure_id_type, boost::shared_ptr<cylindrical_surface_type> >   cylindrsurf_id_pair_type;
+//    typedef std::pair<structure_id_type, boost::shared_ptr<disk_surface_type> >          disk_surface_id_pair_type;
+//    typedef std::pair<structure_id_type, boost::shared_ptr<spherical_surface_type> >     spherical_surface_id_pair_type;
 
     typedef std::set<particle_id_type>                                              particle_id_set;
     typedef std::pair<const particle_id_type, particle_type>                        particle_id_pair;
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 04a70f04..9e3d2284 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -125,6 +125,11 @@ class ParticleContainerBase
     typedef sized_iterator_range<typename particle_matrix_type::const_iterator> particle_id_pair_range;
 
     typedef StructureContainer<structure_type, structure_id_type, traits_type>  structure_container_type;
+    typedef typename structure_container_type::spherical_surface_type           spherical_surface_type;
+    typedef typename structure_container_type::disk_surface_type                disk_surface_type;
+    typedef typename structure_container_type::cylindrical_surface_type         cylindrical_surface_type;
+    typedef typename structure_container_type::planar_surface_type              planar_surface_type;
+    typedef typename structure_container_type::cuboidal_region_type             cuboidal_region_type;
 
     typedef typename base_type::particle_id_pair_and_distance_list      particle_id_pair_and_distance_list;
     typedef typename base_type::structure_id_pair_and_distance_list     structure_id_pair_and_distance_list;
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index b9aeadd3..47cf2eab 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -8,7 +8,8 @@
 #include "CuboidalRegion.hpp"
 #include "PlanarSurface.hpp"
 #include "CylindricalSurface.hpp"
-
+#include "DiskSurface.hpp"
+#include "SphericalSurface.hpp"
 
 // Forward declaration of the StructureContainer to allow the forward declarations of the 'apply_boundary' functions
 template <typename Tobj_, typename Tid_, typename Ttraits_>
@@ -33,6 +34,12 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
                 CylindricalSurface<Ttraits_> const& cylindrical_surface,
                 StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
 
+template<typename Ttraits_ >
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+cyclic_transpose (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                  CylindricalSurface<Ttraits_> const& cylindrical_surface,
+                  StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc);
+
 
 
 
@@ -58,6 +65,15 @@ class StructureContainer
     typedef typename structure_type::position_type                      position_type;
     typedef typename structure_type::position_type                      vector_type;
 
+    typedef std::pair<structure_id_type, vector_type>                   neighbor_id_vector_type;    // FIXME this is actually a datatype of the ConnectivityContainer.
+
+public:
+    typedef SphericalSurface<traits_type>                                               spherical_surface_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<spherical_surface_type> >    spherical_surface_id_pair_type;
+
+    typedef DiskSurface<traits_type>                                                    disk_surface_type;
+    typedef std::pair<structure_id_type, boost::shared_ptr<disk_surface_type> >         disk_surface_id_pair_type;
+
     typedef CylindricalSurface<traits_type>                                             cylindrical_surface_type;
     typedef std::pair<structure_id_type, boost::shared_ptr<cylindrical_surface_type> >  cylindrical_surface_id_pair_type;
     typedef typename cylindrical_surface_type::side_enum_type                           cylindrical_surface_side_type;
@@ -73,8 +89,6 @@ class StructureContainer
     typedef typename cuboidal_region_type::side_enum_type                               cuboidal_region_side_type;
     typedef ConnectivityContainer<structure_id_type, vector_type, 6>                    cuboidal_region_bc_type;
 
-    typedef std::pair<structure_id_type, vector_type>                   neighbor_id_vector_type;    // FIXME this is actually a datatype of the ConnectivityContainer.
-
 public:
     typedef sized_iterator_range<structure_iterator>        structures_range;
     typedef std::pair<position_type, structure_id_type>     position_structid_type;
@@ -86,7 +100,31 @@ class StructureContainer
     virtual ~StructureContainer() {};
 
     // Update_structure methods for the different kind of structures supported by the StructureContainer
-    virtual bool update_structure (cylindrical_surface_id_pair_type const& structid_cylinder)  // can I make this into a template function?
+    virtual bool update_structure (spherical_surface_id_pair_type const& structid_sphere)  // can I make this into a template function?
+    {
+        return update_structure_base(structid_sphere);  // No connecting needs to be done
+    }
+    virtual bool update_structure (disk_surface_id_pair_type const& structid_disk)
+    {
+        return update_structure_base(structid_disk);
+    }
+    virtual bool update_structure (cuboidal_region_id_pair_type const& structid_cube)
+    {
+        if ( update_structure_base(structid_cube))
+        {
+            // add to Connectivity container for cuboidal regions
+            // NOTE this information is never queried!! Maybe leave the neighbor info out?
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_z()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 1, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_z(), -1.0) ));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 2, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_y()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 3, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_y(), -1.0) ));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 4, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_x()));
+            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 5, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_x(), -1.0) ));
+            return true;
+        }
+        return false;
+    }
+    virtual bool update_structure (cylindrical_surface_id_pair_type const& structid_cylinder)
     {
         if ( update_structure_base(structid_cylinder))
         {
@@ -113,22 +151,6 @@ class StructureContainer
         // if the structure was already present, don't change anything
         return false;
     }
-    virtual bool update_structure (cuboidal_region_id_pair_type const& structid_cube)
-    {
-        if ( update_structure_base(structid_cube))
-        {
-            // add to Connectivity container for cuboidal regions
-            // NOTE this information is never queried!! Maybe leave the neighbor info out?
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 0, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_z()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 1, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_z(), -1.0) ));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 2, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_y()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 3, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_y(), -1.0) ));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 4, std::make_pair(structid_cube.first,          structid_cube.second->shape().unit_x()));
-            cuboidal_structs_bc_.set_neighbor_info(structid_cube.first, 5, std::make_pair(structid_cube.first, multiply(structid_cube.second->shape().unit_x(), -1.0) ));
-            return true;
-        }
-        return false;
-    }
 
     // Methods to get the 'n-th' neighbor structure of a particular structure from the container.
     // We pass the structure and not just the ID because with just the ID we can't differentiate between the various types of structures.
@@ -210,6 +232,8 @@ class StructureContainer
         return ::cyclic_transpose(pos_struct_id, structure, *this);
     }
 
+
+    /////////////////// Methods that are general for all the structures.
     virtual structure_id_type get_def_structure_id() const
     {
         return default_structure_id_;
@@ -589,5 +613,13 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     return std::make_pair(new_pos, new_id);
 }
 
+template<typename Ttraits_ >
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+cyclic_transpose (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
+                  CylindricalSurface<Ttraits_> const& cylindrical_surface,
+                  StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
+{
+    // This is not used and not implemented yet.
+}
 #endif /* STRUCTURE_CONTAINER_HPP */
 
diff --git a/World.hpp b/World.hpp
index d47dc618..50a155f4 100644
--- a/World.hpp
+++ b/World.hpp
@@ -234,8 +234,10 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
 
     typedef typename base_type::cuboidal_region_type                cuboidal_region_type;
     typedef typename base_type::planar_surface_type                 planar_surface_type;
-    typedef typename planar_surface_type::side_enum_type            planar_surface_side_type;
     typedef typename base_type::cylindrical_surface_type            cylindrical_surface_type;
+    typedef typename base_type::disk_surface_type                   disk_surface_type;
+    typedef typename base_type::spherical_surface_type              spherical_surface_type;
+    typedef typename planar_surface_type::side_enum_type            planar_surface_side_type;
     typedef typename cylindrical_surface_type::side_enum_type       cylindrical_surface_side_type;
 
 protected:
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index e0775296..cb637f68 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -358,9 +358,11 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::structures_range                     structures_range;
     typedef typename wrapped_type::structure_types_range                structure_types_range;
 
-    typedef typename wrapped_type::cuboidalreg_id_pair_type             cuboidalreg_id_pair_type;
-    typedef typename wrapped_type::planarsurface_id_pair_type           planarsurface_id_pair_type;
-    typedef typename wrapped_type::cylindrsurf_id_pair_type             cylindrsurf_id_pair_type;
+//    typedef typename wrapped_type::cuboidal_region_id_pair_type         cuboidal_region_id_pair_type;
+//    typedef typename wrapped_type::planar_surface_id_pair_type          planar_surface_id_pair_type;
+//    typedef typename wrapped_type::cylindrsurf_id_pair_type             cylindrsurf_id_pair_type;
+//    typedef typename wrapped_type::disk_surface_id_pair_type            disk_surface_id_pair_type;
+//    typedef typename wrapped_type::spherical_surface_id_pair_type       spherical_surface_id_pair_type;
 
 
     typedef typename wrapped_type::transaction_type                     transaction_type;
@@ -406,12 +408,12 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_structures")();
     }
 /*
-    virtual bool update_structure(cuboidalreg_id_pair_type const& structid_pair)
+    virtual bool update_structure(cuboidal_region_id_pair_type const& structid_pair)
     {
         return py_wrapper_type::get_override("update_structure")(structid_pair);
     }
 
-    virtual bool update_structure(planarsurface_id_pair_type const& structid_pair)
+    virtual bool update_structure(planar_surface_id_pair_type const& structid_pair)
     {
         return py_wrapper_type::get_override("update_structure")(structid_pair);
     }
@@ -421,6 +423,16 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("update_structure")(structid_pair);
     }
 
+    virtual bool update_structure(disk_surface_id_pair_type const& structid_pair)
+    {
+        return py_wrapper_type::get_override("update_structure")(structid_pair);
+    }
+
+    virtual bool update_structure(spherical_surface_id_pair_type const& structid_pair)
+    {
+        return py_wrapper_type::get_override("update_structure")(structid_pair);
+    }
+
     template<typename Tstructid_pair_>
     bool update_structure(Tstructid_pair_ const& structid_pair)
     {
@@ -633,9 +645,11 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
 //        .def("update_structure", pure_virtual(&impl_type::update_structure))
-//        .def("update_structure", &impl_type::template update_structure<typename impl_type::cuboidalreg_id_pair_type>)
-//        .def("update_structure", &impl_type::template update_structure<typename impl_type::planarsurface_id_pair_type>)
+//        .def("update_structure", &impl_type::template update_structure<typename impl_type::cuboidal_region_id_pair_type>)
+//        .def("update_structure", &impl_type::template update_structure<typename impl_type::planar_surface_id_pair_type>)
 //        .def("update_structure", &impl_type::template update_structure<typename impl_type::cylindrsurf_id_pair_type>)
+//        .def("update_structure", &impl_type::template update_structure<typename impl_type::disk_surface_id_pair_type>)
+//        .def("update_structure", &impl_type::template update_structure<typename impl_type::spherical_surface_id_pair_type>)
         .def("remove_structure", pure_virtual(&impl_type::remove_structure))
         .def("get_structure_ids", pure_virtual(&impl_type::get_structure_ids))
         .def("get_def_structure_id", pure_virtual(&impl_type::get_def_structure_id))
diff --git a/binding/World.hpp b/binding/World.hpp
index 3ec085f1..6325ba1a 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -410,6 +410,8 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("add_structure", &impl_type::template add_structure<typename impl_type::planar_surface_type>)
         .def("add_structure", &impl_type::template add_structure<typename impl_type::cuboidal_region_type>)
         .def("add_structure", &impl_type::template add_structure<typename impl_type::cylindrical_surface_type>)
+        .def("add_structure", &impl_type::template add_structure<typename impl_type::disk_surface_type>)
+        .def("add_structure", &impl_type::template add_structure<typename impl_type::spherical_surface_type>)
         .def("connect_structures", &impl_type::template connect_structures<typename impl_type::planar_surface_type,      int>)
         .def("connect_structures", &impl_type::template connect_structures<typename impl_type::cylindrical_surface_type, int>)
         .def("set_def_structure", &impl_type::set_def_structure)

From 19eb08b7f481130b7db3d3c4a877000575b55616 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 22 May 2012 18:26:10 +0200
Subject: [PATCH 0919/1541] Changes to pair switchboxes in egfrd.py

---
 egfrd.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a2767bb3..6aeee84c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -55,6 +55,7 @@
     CylindricalSurfaceCapInteractiontestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
+    MixedPair1DCaptestShell,
     )
 
 import logging
@@ -145,9 +146,13 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
         return MixedPair2D3DtestShell(single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
         return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+    elif (isinstance(single1.structure, DiskSurface) and isinstance(single2.structure, CylindricalSurface)):
+        return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
+    elif (isinstance(single2.structure, DiskSurface) and isinstance(single1.structure, CylindricalSurface)):
+        return MixedPair1DCaptestShell(single2, single1, geometrycontainer, domains)
     else:
-        # a 1D/3D pair was supposed to be formed -> unsupported
-        raise testShellError('(MixedPair). combination of structure not supported')
+        # another mixed pair was supposed to be formed -> unsupported
+        raise testShellError('(MixedPair). combination of structures not supported')
         
 def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
     # Either SphericalPair, PlanarSurfacePair, or CylindricalSurfacePair.
@@ -159,10 +164,11 @@ def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
         return PlanarSurfaceTransitionPair (domain_id, shell_id, testShell, reaction_rules)
     elif isinstance(testShell, CylindricalSurfacePairtestShell):
         return CylindricalSurfacePair      (domain_id, shell_id, testShell, reaction_rules)
-    # or MixedPair (3D/2D)
+    # or MixedPair (3D/2D or 1D/Cap)
     elif isinstance(testShell, MixedPair2D3DtestShell):
         return MixedPair2D3D               (domain_id, shell_id, testShell, reaction_rules)
-
+    elif isinstance(testShell, MixedPair1DCaptestShell):
+        return MixedPair1DCap              (domain_id, shell_id, testShell, reaction_rules)
 
 class DomainEvent(Event):
     __slot__ = ['data']

From 5a1e63eeca248c5754239877f303c3deaa163919 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 22 May 2012 18:26:53 +0200
Subject: [PATCH 0920/1541] small optimization to PlanarSurface

---
 PlanarSurface.hpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 28ebee8b..1348befd 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -109,14 +109,13 @@ class PlanarSurface
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         Real X( rng.uniform(0.,1.) );
-        
         length_type diss_vec_length( X*rl );
 
-        position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
-
-        unit_z = normalize ( unit_z );
+//        position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
+//
+//        unit_z = normalize ( unit_z );
 
-        return multiply( unit_z, (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
+        return multiply( base_type::shape().unit_z(), (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
     }
 
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 

From a999dd6ad9290eed27624ba49d9b38aa166355d2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 22 May 2012 18:29:04 +0200
Subject: [PATCH 0921/1541] Fix an indent error

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 252f804b..fda3a0ab 100644
--- a/pair.py
+++ b/pair.py
@@ -1044,7 +1044,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         self.LD_MAX = numpy.inf # TODO what is that for?
 
-   def get_shell_size(self): # TODO Is that even used?
+    def get_shell_size(self): # TODO Is that even used?
         return self.shell.shape.half_length
 
     def get_v_tot(self):

From 1d98bf45e327f09fe2db4f1de2cf96446d6ce55a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 23 May 2012 12:11:16 +0200
Subject: [PATCH 0922/1541] Fix an indent

---
 Region.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Region.hpp b/Region.hpp
index 5663316c..a4698c89 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -132,7 +132,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     virtual bool allows_interaction_from(position_type const& pos) const
     {
         return ::allows_interaction_from(shape(), pos);
-	}
+    }
 
     virtual bool is_alongside(position_type const& pos) const
     {

From d4c5f9e568df48114d7c19c064824edacbd6b9b4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 23 May 2012 17:29:09 +0200
Subject: [PATCH 0923/1541] Change std::pair to boost::array as return type for
 to_internal in Disk.hpp

---
 Disk.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Disk.hpp b/Disk.hpp
index 92ce617a..2e30cc6e 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -193,9 +193,9 @@ min_dist_proj_to_edge(Disk<T_> const& obj,
      * defined by the vectors unitR and unit_z, where unitR is
      * choosen such that unitR and unit_z define a plane in which
      * pos lies. */
-    const std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    const boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
     /* Then compute distance to radial edge. */
-    const length_type dr(r_z.first - obj.radius());
+    const length_type dr(r_z[0] - obj.radius());
 
     if (dr < 0)         return -dr;
     else                return 0;
@@ -230,10 +230,10 @@ allows_interaction_from(Disk<T_> const& obj, typename Disk<T_>::position_type co
 {
     typedef typename Disk<T_>::length_type length_type;
 
-    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+    const boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
     
     // Return true if the projection of pos is within the disk's radius
-    return ( r_z.first <= obj.radius() );
+    return ( r_z[0] <= obj.radius() );
 }
 
 

From fba6dcc9718503a340268f89dfe9c9df61aee7db Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 23 May 2012 17:29:49 +0200
Subject: [PATCH 0924/1541] Minor indent fix

---
 pair.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index fda3a0ab..cc978a1b 100644
--- a/pair.py
+++ b/pair.py
@@ -636,7 +636,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
             assert(2.0*abs(pos1_orth*pos2_orth) < (l_iv*l_iv))  # That should never fail!
             iv_safety = 1.0/( 1.0 - 2.0*abs(pos1_orth*pos2_orth)/(l_iv*l_iv) )
             # Recalculate the interparticle vector and new positions
-            iv_rescaled = iv_safety * iv            
+            iv_rescaled = iv_safety * iv
             pos1 = com - iv_rescaled * (D1 / D_tot)
             pos2 = com + iv_rescaled * (D2 / D_tot)
 

From 5cc0064cb632c29af48ac5f65338fc420afed5fc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 24 May 2012 12:06:58 +0200
Subject: [PATCH 0925/1541] Fix sampling error of drawR at BURST event for
 CylindricalSurfaceCapSingle

Order of arguments in draw_r_wrapper is different from standard order.
Now args are passed correctly.
---
 single.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 238fa84e..2a6f1e68 100644
--- a/single.py
+++ b/single.py
@@ -1123,7 +1123,9 @@ def draw_new_position(self, dt, event_type):
             else:
                 # Some other event took place and the particle didn't escape;
                 # as a consequence it stays on the origin structure.
-                dz = draw_r_wrapper(gf, dt, -self.get_inner_dz_left(), self.get_inner_dz_right()) # TODO Is this sampling correctly?
+                # NOTE: draw_r_wrapper(): attention, order of arguments inverted!
+                # Last two arguments are a, sigma (in this order!)
+                dz = draw_r_wrapper(gf, dt, self.get_inner_dz_right(), -self.get_inner_dz_left())
                 structure_id = self.origin_structure.id
 
             # Add displacement to particle.position.

From 417501c2481f3a327af44be50c3ab79af5c42d5c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 24 May 2012 13:41:02 +0200
Subject: [PATCH 0926/1541] small order change in 'make_new_domain' +
 typographic changes.

---
 egfrd.py | 49 +++++++++++++++++++++++++++----------------------
 1 file changed, 27 insertions(+), 22 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6aeee84c..9863482f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -105,13 +105,13 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
 
 def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, interaction_rules):
     if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
-        return CylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return CylindricalSurfaceInteraction    (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
-        return PlanarSurfaceInteraction      (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
-        return CylindricalSurfaceCapInteraction   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return CylindricalSurfaceCapInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
-        return CylindricalSurfaceSink        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return CylindricalSurfaceSink           (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
 ### Transitions
 def try_default_testtransition(single, target_structure, geometrycontainer, domains):
@@ -130,30 +130,30 @@ def try_default_testtransition(single, target_structure, geometrycontainer, doma
 def create_default_transition(domain_id, shell_id, testShell, reaction_rules):
     if isinstance(testShell, PlanarSurfaceTransitionSingletestShell):
         return PlanarSurfaceTransitionSingle       (domain_id, shell_id, testShell, reaction_rules)
-    
+
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
     if single1.structure == single2.structure:
         if isinstance(single1.structure, CuboidalRegion):
-            return SphericalPairtestShell(single1, single2, geometrycontainer, domains)
+            return SphericalPairtestShell           (single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, PlanarSurface):
-            return PlanarSurfacePairtestShell(single1, single2, geometrycontainer, domains)
+            return PlanarSurfacePairtestShell       (single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, CylindricalSurface):
-            return CylindricalSurfacePairtestShell(single1, single2, geometrycontainer, domains)
+            return CylindricalSurfacePairtestShell  (single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
-        return PlanarSurfaceTransitionPairtestShell(single1, single2, geometrycontainer, domains) 
+        return PlanarSurfaceTransitionPairtestShell (single1, single2, geometrycontainer, domains) 
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell(single1, single2, geometrycontainer, domains) 
+        return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+        return MixedPair2D3DtestShell               (single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, DiskSurface) and isinstance(single2.structure, CylindricalSurface)):
-        return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
+        return MixedPair1DCaptestShell              (single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, DiskSurface) and isinstance(single1.structure, CylindricalSurface)):
-        return MixedPair1DCaptestShell(single2, single1, geometrycontainer, domains)
+        return MixedPair1DCaptestShell              (single2, single1, geometrycontainer, domains)
     else:
         # another mixed pair was supposed to be formed -> unsupported
         raise testShellError('(MixedPair). combination of structures not supported')
-        
+
 def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
     # Either SphericalPair, PlanarSurfacePair, or CylindricalSurfacePair.
     if   isinstance(testShell, SphericalPairtestShell):
@@ -1554,18 +1554,20 @@ def make_new_domain(self, single):
             if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                 # distance from the center of the particles/domains
                 pair_distance = self.world.distance(single_pos, domain.shell.shape.position)
-                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR * 5 # HACK  to be balanced
+                pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:
-            if isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
+            if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):
+                # a transition going from one plane to the next can be initiated from a distance    TODO still not sure this is the right place
+                surface_horizon = single_radius * SINGLE_SHELL_FACTOR * 2        # HACK  to be balanced
+            elif isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
                 # with a planar or disk surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0) * 5 # HACK to be balanced
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR
-            if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):        # HACK  to be balanced
-                surface_horizon = single_radius * SINGLE_SHELL_FACTOR * 2
+
             pair_interaction_partners.append((surface, surface_distance - surface_horizon))
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
@@ -1587,8 +1589,8 @@ def make_new_domain(self, single):
             elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
                 domain = self.try_transition(single, obj)
 
-            elif ( isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface) ) \
-             and obj.allows_interaction_from(single_pos) :
+            elif ( isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface) ) and \
+                 obj.allows_interaction_from(single_pos) :
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
 
@@ -2340,6 +2342,7 @@ def form_multi(self, single, multi_partners):
             assert ((isinstance(partner, NonInteractionSingle) and partner.is_reset()) or \
                     isinstance(partner, Multi) or \
                     isinstance(partner, PlanarSurface) or \
+                    isinstance(partner, DiskSurface) or \
                     isinstance(partner, CylindricalSurface)), \
                     'multi_partner %s was not of proper type' % (partner)
 
@@ -2594,7 +2597,7 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
         elif isinstance(domain, DiskSurfaceSingle):
-            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore parent structure
+            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring structure
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
             associated = [domain.structure.id]
         elif isinstance(domain, CylindricalSurfaceInteraction):
@@ -2688,6 +2691,7 @@ def check_shape_overlap(self, shape1, shape2):
             distance = self.world.distance(shape1, shape2.position)
             return distance - shape2.radius
 
+        # overlap criterium when one of the shapes is a cylinder and the other is a plane
         elif ((type(shape1) is Cylinder) and (type(shape2) is Plane)) or \
              ((type(shape2) is Cylinder) and (type(shape1) is Plane)):
 
@@ -2727,6 +2731,7 @@ def check_shape_overlap(self, shape1, shape2):
                 else:
                     raise RuntimeError('check_shape_overlap: planes and cylinders should be either parallel or perpendicular.')
 
+        # FIXME FIXME separate Disk overlap criterium in separate check (probably clearer/faster than combining)
         # overlap criterium when both shells are cylindrical or disks (= cylinders with half_length = 0.0)
         elif (type(shape1) is Cylinder) and (type(shape2) is Cylinder) or \
              (type(shape1) is Cylinder) and (type(shape2) is Disk) or \

From e9003b0a180be2f3146b2caf81ad160bf49ead1f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 24 May 2012 13:42:41 +0200
Subject: [PATCH 0927/1541] Revert "Fix some comments"

This reverts commit 8301c2e837e72d239b97ab05299cc2f7eb3254db.
---
 shells.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index c42c96fc..bb8f32f0 100755
--- a/shells.py
+++ b/shells.py
@@ -716,7 +716,7 @@ def get_radius_to_SphericalShape(shape, testShell, r):
     # if the newly calculated dimensions are smaller than the current one, use them
     return min(r, r_new)
 
-# functions to size up a testShell to a Cylindrical or Disk shape object
+# functions to size up a testShell to a Cylindrical shape object
 def get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shape, testShell, r, z_right, z_left):
     # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
     # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
@@ -724,7 +724,7 @@ def get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shape, testShell, r, z_rig
     # smaller.
 
     # Note that the 'shell' is querried from this domain earlier by the testShell.
-    # -> the shell MUST be a Cylinder or Disk.
+    # -> the shell MUST be a Cylinder.
     assert (type(shape) is Cylinder) or (type(shape) is Disk)
 
     # Laurens' algorithm (part2)
@@ -1328,7 +1328,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # initialize the parameters to start the scaling of the cylinder
         min_dr, min_dz_right, min_dz_left = self.apply_safety(min_dr, min_dz_right, min_dz_left)
         dr, dz_right, dz_left             = max_dr, max_dz_right, max_dz_left
-        
+ 
         # first check the maximum dr, dz_right, dz_left against the surfaces
         # NOTE: we assume that all relevant surfaces are cylindrical and parallel to the testCylinder
         # or planar surfaces and parallel to the testCylinder axis
@@ -2190,4 +2190,4 @@ def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left
 
 #####
-#class MixedPair3D1DtestShell(CylindricaltestShell, Others):
\ No newline at end of file
+#class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From 9222efacb57f2ab14a1923bbf65e3ed26cd1c815 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 24 May 2012 14:14:23 +0200
Subject: [PATCH 0928/1541] reverted double use of
 'get_dr_dzright_dzleft_to_CylindricalShape' for Cylinders and Disks
 Implemented a wrapper to execute the 'get_dr_dzright_dzleft_to_DiskShape' as
 a special case of a Cylinder.

---
 shells.py | 55 +++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 18 deletions(-)

diff --git a/shells.py b/shells.py
index bb8f32f0..50a48580 100755
--- a/shells.py
+++ b/shells.py
@@ -717,7 +717,7 @@ def get_radius_to_SphericalShape(shape, testShell, r):
     return min(r, r_new)
 
 # functions to size up a testShell to a Cylindrical shape object
-def get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shape, testShell, r, z_right, z_left):
+def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_left):
     # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
     # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
     # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
@@ -725,16 +725,12 @@ def get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shape, testShell, r, z_rig
 
     # Note that the 'shell' is querried from this domain earlier by the testShell.
     # -> the shell MUST be a Cylinder.
-    assert (type(shape) is Cylinder) or (type(shape) is Disk)
+    assert (type(shape) is Cylinder)
 
     # Laurens' algorithm (part2)
     shell_position = shape.position
     shell_radius = shape.radius 
-
-    if type(shape) is Cylinder:
-        shell_half_length = shape.half_length 
-    else: # shape is Disk and has no property half_length
-        shell_half_length = 0.0
+    shell_half_length = shape.half_length 
 
 
     # get the reference point and orientation of the domain to scale
@@ -1014,10 +1010,10 @@ def r1(x):
             z1_new = min(z1, z1_function(r_new))
 
         else:
-            raise RuntimeError('get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape: Bad situation for making cylinders against cylinders.')
+            raise RuntimeError('get_dr_dzright_dzleft_to_CylindricalShape: Bad situation for making cylinders against cylinders.')
 
     else:
-        raise NotImplementedError('get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape: Cylinders should be oriented parallel or perpendicular.')
+        raise NotImplementedError('get_dr_dzright_dzleft_to_CylindricalShape: Cylinders should be oriented parallel or perpendicular.')
 
     z2_new = min(z2, z2_function(r_new))
 
@@ -1113,6 +1109,31 @@ def get_radius_to_PlanarShape(shape, testShell, r):
     # if the newly calculated dimensions are smaller than the current one, use them
     return min(r, r_new)
 
+def get_dr_dzright_dzleft_to_DiskShape(shape, testShell, r, z_right, z_left):
+    # This function returns the dr, dz_right, dz_left for the cylindrical 'testShell' using the disk 'shape' as its closest
+    # neighbor. Note that it returns the minimum of the newly calculated parameters and the old parameters. The 'testShell' can
+    # therefore only become smaller.
+
+    assert (type(shape) is Disk)
+
+    # For now just consider the Disk as a special case of a cylinder
+    # TODO implement properly, I'm sure things can be more optimal
+    return (Cylinder(shape.position, shape.radius, shape.unit_z, 0.0), testShell, r, z_right, z_left)
+
+def get_radius_to_DiskShape(shape, testShell, r):
+    # This function returns the radius for the spherical 'testShell' using the disk 'shape' as its closest
+    # neighbor. Note that it returns the minimum of the newly calculated radius and the old radius. The 'testShell' can
+    # therefore only become smaller.
+
+    assert (type(shape) is Disk)
+
+    # Do simple distance calculation to disk
+    scale_point = testShell.center
+    r_new = testShell.world.distance(shape, scale_point)
+
+    # if the newly calculated dimensions are smaller than the current one, use them
+    return min(r, r_new)
+
 
 #######################################################
 #######################################################
@@ -1334,12 +1355,12 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # or planar surfaces and parallel to the testCylinder axis
         for surface, distance in neighbor_surfaces:
             # TODO
-            if isinstance(surface, CylindricalSurface) or isinstance(surface, DiskSurface):
-                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(surface.shape, self,
-                                                                                              dr, dz_right, dz_left)            
+            if isinstance(surface, CylindricalSurface):
+                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_CylindricalShape(surface.shape, self, dr, dz_right, dz_left)            
             elif isinstance(surface, PlanarSurface):
-                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_PlanarShape(surface.shape, self,
-                                                                                         dr, dz_right, dz_left)
+                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_PlanarShape(surface.shape, self, dr, dz_right, dz_left)
+            elif isinstance(surface, DiskSurface):
+                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_DiskShape(surface.shape, self, dr, dz_right, dz_left)            
             else:
                 assert False, "Wrong type of surface used"
 
@@ -1356,11 +1377,9 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:
                 if isinstance(shell_appearance.shape, Sphere):
-                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self,
-                                                                                                dr, dz_right, dz_left)
+                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(shell_appearance.shape, self, dr, dz_right, dz_left)
                 elif isinstance(shell_appearance.shape, Cylinder):
-                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_Cylindrical_or_DiskShape(shell_appearance.shape, self,
-                                                                                                  dr, dz_right, dz_left)
+                    dr, dz_right, dz_left = get_dr_dzright_dzleft_to_CylindricalShape(shell_appearance.shape, self, dr, dz_right, dz_left)
                 else:
                     assert False, "Wrong type of shell shape"
 

From c907b3f5bc837553774a7ec3ee2984ded89faee6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 24 May 2012 14:56:21 +0200
Subject: [PATCH 0929/1541] removed 'get_closest_surface' (depricated)

---
 Multi.hpp                     | 20 ++++++++++----------
 ParticleContainer.hpp         |  3 ---
 Transaction.hpp               |  5 -----
 World.hpp                     | 26 --------------------------
 binding/ParticleContainer.hpp |  7 -------
 5 files changed, 10 insertions(+), 51 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 1ceb9793..0f4db054 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -50,7 +50,6 @@ class MultiParticleContainer
     typedef typename world_type::particle_container_type::structures_range                  structures_range;
     typedef typename world_type::particle_container_type::particle_id_pair                  particle_id_pair;
     typedef typename world_type::particle_container_type::structure_id_pair                 structure_id_pair;
-    typedef typename world_type::particle_container_type::structure_id_and_distance_pair    structure_id_and_distance_pair;
     typedef typename world_type::particle_container_type::structure_id_set                  structure_id_set;
     typedef typename world_type::particle_container_type::particle_id_pair_and_distance_list    particle_id_pair_and_distance_list;
     typedef typename world_type::particle_container_type::structure_id_pair_and_distance_list   structure_id_pair_and_distance_list;
@@ -125,10 +124,6 @@ class MultiParticleContainer
     {
         return world_.get_def_structure_id();
     }
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
-    {        
-        return world_.get_closest_surface( pos, ignore );   // TODO loop only over 'local' surfaces
-    }
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const
     {
@@ -342,12 +337,17 @@ class MultiParticleContainer
         BOOST_FOREACH(particle_id_pair pp, get_particles_range())
         {
             species_type const s( get_species(pp.second.sid()) );
-            structure_id_and_distance_pair const strc_id_and_dist( 
-                get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
+            const boost::scoped_ptr<const structure_id_pair_and_distance_list> close_struct_id_distance (
+                get_close_structures(pp.second.position(), pp.second.structure_id(), pp.second.structure_id()) );
+            const std::pair<boost::shared_ptr<structure_type>, length_type> strc_and_dist (
+                close_struct_id_distance ? std::make_pair(close_struct_id_distance->at(0).first.second, close_struct_id_distance->at(0).second)
+                                         : std::make_pair(get_structure(pp.second.structure_id()), std::numeric_limits<length_type>::max()));
+//            structure_id_and_distance_pair const strc_id_and_dist( 
+//                get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
                 
-            if( strc_id_and_dist.second < 2.0 * s.radius() && s.structure_type_id() == get_def_structure_type_id() )
+            if( strc_and_dist.second < 2.0 * s.radius() && s.structure_type_id() == get_def_structure_type_id() )
             {
-                structure_type_id_type const strc_sid( get_structure( strc_id_and_dist.first )->sid() );
+                structure_type_id_type const strc_sid( strc_and_dist.first->sid() );
                 reaction_rules const& rrules(rules.query_reaction_rule( s.id(), strc_sid ));
                 if (::size(rrules) == 0)
                     continue;
@@ -355,7 +355,7 @@ class MultiParticleContainer
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
-                    Real const k( get_structure( strc_id_and_dist.first )->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
+                    Real const k( strc_and_dist.first->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
 
                     if ( k_max < k )
                         k_max = k;
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 8d2cfac7..84cb61bf 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -60,7 +60,6 @@ class ParticleContainer
     typedef std::set<structure_id_type>                                             structure_id_set;
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
     typedef abstract_limited_generator<structure_id_pair>                           structure_id_pair_generator;
-    typedef std::pair<structure_id_type, length_type>                               structure_id_and_distance_pair; // TODO remove
     typedef std::pair<structure_id_pair, length_type>                               structure_id_pair_and_distance;
     typedef unassignable_adapter<structure_id_pair_and_distance,
                                  get_default_impl::std::vector>                     structure_id_pair_and_distance_list;
@@ -114,8 +113,6 @@ class ParticleContainer
 
     virtual structure_id_type get_def_structure_id() const = 0;
 
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const = 0;
-
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const = 0;
 
diff --git a/Transaction.hpp b/Transaction.hpp
index 27fd1f29..e9e4968e 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -71,7 +71,6 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
 
     typedef std::pair<const particle_id_type, particle_type>    particle_id_pair;
     typedef abstract_limited_generator<particle_id_pair>        particle_id_pair_generator;
-    typedef std::pair<structure_id_type, length_type>           structure_id_and_distance_pair;
 
 private:
     typedef std::map<typename particle_id_pair::first_type,
@@ -237,10 +236,6 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_def_structure_id();
     }    
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
-    {
-        return pc_.get_closest_surface( pos, ignore );
-    }
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const
     {
diff --git a/World.hpp b/World.hpp
index 50a155f4..4fcb3ed2 100644
--- a/World.hpp
+++ b/World.hpp
@@ -226,7 +226,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename base_type::particle_id_pair                            particle_id_pair;      // defines the pid_particle_pair tuple
     typedef typename base_type::structure_id_pair                           structure_id_pair;
     typedef std::pair<position_type, length_type>                           projected_type;
-    typedef typename particle_container_type::structure_id_and_distance_pair structure_id_and_distance_pair;
 
     typedef typename base_type::particle_id_set                             particle_id_set;
     typedef typename base_type::structure_id_set                            structure_id_set;
@@ -461,31 +460,6 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         cuboidal_region->set_id(default_struct_id);
         update_structure(std::make_pair(default_struct_id, cuboidal_region));
     }
-    // Get the closest surface(surface is a subclass of structures)
-    // TODO change this to get all the surfaces within a certain distance of the particle.
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
-    {       
-        length_type const world_size( base_type::world_size() );
-        length_type ret_dist( std::numeric_limits<length_type>::max() );
-        structure_id_type ret_id( ignore );
-
-        BOOST_FOREACH(boost::shared_ptr<structure_type> const structure, base_type::get_structures())
-        {
-            if( structure->id() == ignore)
-                continue;
-            
-            position_type const cyc_pos(cyclic_transpose(pos, structure->position(), world_size));
-            length_type const dist( fabs( structure->projected_point_on_surface( cyc_pos ).second ) );
-                
-            if( dist < ret_dist )
-            {
-                ret_dist = dist;
-                ret_id = structure->id();
-            }  
-        }
-        
-        return structure_id_and_distance_pair( ret_id , ret_dist );
-    }
     // Get all the particle ids of the particles on a structure
     particle_id_set get_particle_ids_on_struct(structure_id_type const& struct_id) const
     {
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index cb637f68..742f927c 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -352,7 +352,6 @@ class ParticleContainerWrapper
     typedef typename wrapped_type::structure_id_pair_generator          structure_id_pair_generator;
     typedef typename wrapped_type::particle_id_pair_and_distance_list   particle_id_pair_and_distance_list;
     typedef typename wrapped_type::structure_id_pair_and_distance_list  structure_id_pair_and_distance_list;
-    typedef typename wrapped_type::structure_id_and_distance_pair       structure_id_and_distance_pair;
     typedef typename wrapped_type::position_structid_pair_type          position_structid_pair_type;
     typedef typename wrapped_type::structure_id_set                     structure_id_set;
     typedef typename wrapped_type::structures_range                     structures_range;
@@ -455,10 +454,6 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("get_def_structure_id")();
     }
 
-    virtual structure_id_and_distance_pair get_closest_surface(position_type const& pos, structure_id_type const& ignore) const
-    {
-        return py_wrapper_type::get_override("get_closest_surface")(pos, ignore);
-    }
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const
     {
@@ -619,7 +614,6 @@ inline boost::python::objects::class_base register_particle_container_class(
     // registering converters from standard boost templates.
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair>();
     peer::converters::register_tuple_converter<typename impl_type::structure_id_pair>();
-    peer::converters::register_tuple_converter<typename impl_type::structure_id_and_distance_pair>();   // TODO remove later.
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair_and_distance>();
     peer::converters::register_tuple_converter<typename impl_type::structure_id_pair_and_distance>();
 
@@ -653,7 +647,6 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("remove_structure", pure_virtual(&impl_type::remove_structure))
         .def("get_structure_ids", pure_virtual(&impl_type::get_structure_ids))
         .def("get_def_structure_id", pure_virtual(&impl_type::get_def_structure_id))
-        .def("get_closest_surface", pure_virtual(&impl_type::get_closest_surface))
         .def("get_close_structures", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::position_type const& pos, typename impl_type::structure_id_type const&, typename impl_type::structure_id_type const&) const)&impl_type::get_close_structures), return_value_policy<return_by_value>())
         // Particle stuff
         .def("new_particle", pure_virtual(&impl_type::new_particle))

From 3f1ae1bcfe0750cff2e9e4a0f4e621256c8b871e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 24 May 2012 18:33:01 +0200
Subject: [PATCH 0930/1541] Change of signature of projected_point and
 namechange projected_point -> project_point 'Project_point' returns the point
 projected on the surface + the projection distance, and the distance to the
 nearest edge of the surface. If the projected point is ouside the range of
 the surface the distance is positive, if it's inside the domain of the
 surface it's negative (it lies inside the surface).

---
 Box.hpp                         | 23 ++++++++++++++++++++---
 Cylinder.hpp                    | 23 +++++++++++++----------
 Disk.hpp                        | 16 ++++++++++------
 Plane.hpp                       | 26 ++++++++++++++------------
 Region.hpp                      | 22 ++++++++++++----------
 Sphere.hpp                      | 16 ++++++++++------
 Structure.hpp                   |  7 ++++---
 Surface.hpp                     | 23 ++++++++++++-----------
 binding/Structure.hpp           |  3 ++-
 egfrd.py                        |  2 +-
 newBDPropagator.hpp             |  7 ++++---
 shells.py                       |  6 +++---
 test/CylindricalSurface_test.py |  4 ++--
 test/PlanarSurface_test.py      |  4 ++--
 14 files changed, 109 insertions(+), 73 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 5e9cd5ca..8f455cbc 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -216,15 +216,32 @@ to_internal(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
 
 template<typename T_>
 inline std::pair<typename Box<T_>::position_type,
-                 typename Box<T_>::length_type>
-projected_point(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
+                 std::pair<typename Box<T_>::length_type,
+                           typename Box<T_>::length_type> >
+project_point(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
 {
     // Todo. If we ever need it.
     // The projection of a point on a box.
     return std::make_pair(typename Box<T_>::position_type(),
-                          typename Box<T_>::length_type());
+                          std::make_pair(typename Box<T_>::length_type(),
+                                         typename Box<T_>::length_type()) );
 }
 
+template<typename T_>
+inline std::pair<typename Box<T_>::position_type,
+                 std::pair<typename Box<T_>::length_type,
+                           typename Box<T_>::length_type> >
+project_point_on_surface(Box<T_> const& obj,
+                typename Box<T_>::position_type const& pos)
+{
+    // Todo. If we ever need it.
+    // The projection of a point on a box.
+    return std::make_pair(typename Box<T_>::position_type(),
+                          std::make_pair(typename Box<T_>::length_type(),
+                                         typename Box<T_>::length_type()) );
+}
+
+
 template<typename T_>
 inline typename Box<T_>::length_type
 distance(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index ad1eece9..712ffc1e 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -137,35 +137,38 @@ to_internal(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const&
 
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::position_type,
-                 typename Cylinder<T_>::length_type>
-projected_point(Cylinder<T_> const& obj,
-                typename Cylinder<T_>::position_type const& pos)
+                 std::pair<typename Cylinder<T_>::length_type,
+                           typename Cylinder<T_>::length_type> >
+project_point(Cylinder<T_> const& obj,
+              typename Cylinder<T_>::position_type const& pos)
 {
     typedef typename Cylinder<T_>::length_type length_type;
 
     // The projection lies on the z-axis.
     std::pair<length_type, length_type> r_z(to_internal(obj, pos));
-    return std::make_pair(
-        add(obj.position(), multiply(obj.unit_z(), r_z.second)),
-        r_z.first);
+    return std::make_pair( add(obj.position(), multiply(obj.unit_z(), r_z.second)),
+                           std::make_pair(r_z.first,
+                                          0.0) );   // TODO
 }
 
 //Almost equal to projected point method, but for the substraction of the cylinder radius from the radial distance r.
 //And projected point now lies on the surface, not on the central axis.
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::position_type,
-                 typename Cylinder<T_>::length_type>
-projected_point_on_surface(Cylinder<T_> const& obj,
+                 std::pair<typename Cylinder<T_>::length_type,
+                           typename Cylinder<T_>::length_type> >
+project_point_on_surface(Cylinder<T_> const& obj,
                 typename Cylinder<T_>::position_type const& pos)
 {
     typedef typename Cylinder<T_>::length_type length_type;
     typedef typename Cylinder<T_>::position_type position_type;
 
     std::pair<length_type, length_type> r_z(to_internal(obj, pos));
-    position_type within_surface( add(obj.position(), multiply(obj.unit_z(), r_z.second)) );
+    position_type within_surface( add(obj.position(), multiply(obj.unit_z(), r_z.second)) );    //????
 
     return std::make_pair( add(within_surface, multiply( normalize( subtract( pos, within_surface ) ), obj.radius() )),
-        r_z.first - obj.radius() );
+                           std::make_pair(r_z.first - obj.radius(),
+                                          0.0) );   // TODO
 }
 
 template<typename T_>
diff --git a/Disk.hpp b/Disk.hpp
index 2e30cc6e..98c786de 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -121,8 +121,9 @@ to_internal(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
 
 template<typename T_>
 inline std::pair<typename Disk<T_>::position_type,
-                 typename Disk<T_>::length_type>
-projected_point(Disk<T_> const& obj,
+                 std::pair<typename Disk<T_>::length_type,
+                           typename Disk<T_>::length_type> >
+project_point(Disk<T_> const& obj,
                 typename Disk<T_>::position_type const& pos)
 {
     typedef typename Disk<T_>::length_type length_type;
@@ -132,17 +133,20 @@ projected_point(Disk<T_> const& obj,
     // The distance is the z-component returned by to_internal().
     boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
     
-    return std::make_pair( obj.position(), r_z[1]);
+    return std::make_pair( obj.position(),
+                           std::make_pair(r_z[1],
+                                          0.0) );       //TODO
 }
 
 // The same as in case of the plane: projected_point_on_surface = projected_point
 template<typename T_>
 inline std::pair<typename Disk<T_>::position_type,
-                 typename Disk<T_>::length_type>
-projected_point_on_surface(Disk<T_> const& obj,
+                 std::pair<typename Disk<T_>::length_type,
+                           typename Disk<T_>::length_type> >
+project_point_on_surface(Disk<T_> const& obj,
                 typename Disk<T_>::position_type const& pos)
 {
-    return projected_point(obj, pos);
+    return project_point(obj, pos);
 }
 
 template<typename T_>
diff --git a/Plane.hpp b/Plane.hpp
index d56df026..4a561d47 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -192,8 +192,9 @@ to_internal(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 
 template<typename T_>
 inline std::pair<typename Plane<T_>::position_type,
-                 typename Plane<T_>::length_type>
-projected_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+                 std::pair<typename Plane<T_>::length_type,
+                           typename Plane<T_>::length_type> >
+project_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 // Calculates the projection of 'pos' onto the plane 'obj' and also returns the coefficient
 // for the normal component (z) of 'pos' in the basis of the plane
 {
@@ -201,17 +202,18 @@ projected_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& p
     return std::make_pair(
         add(add(obj.position(), multiply(obj.unit_x(), x_y_z[0])),
                                 multiply(obj.unit_y(), x_y_z[1])),
-        x_y_z[2]);
+        std::make_pair(x_y_z[2], 0.0) );    //TODO
 }
 
 template<typename T_>
 inline std::pair<typename Plane<T_>::position_type,
-                 typename Plane<T_>::length_type>
-projected_point_on_surface(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
+                 std::pair<typename Plane<T_>::length_type,
+                           typename Plane<T_>::length_type> >
+project_point_on_surface(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 // Since the projected point on the plane, is already on the surface of the plane,
 // this function is just a wrapper of projected point.
 {
-    return projected_point(obj, pos);
+    return project_point(obj, pos);
 }
 
 template<typename T_>
@@ -342,7 +344,7 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
         // that ranges out of the target plane.
         // Project all points that are supposed to be in the plane into it,
         // just to be sure.
-        intersect_pt = projected_point( obj, add(r0, multiply(d, intersect_parameter)) ).first;
+        intersect_pt = project_point( obj, add(r0, multiply(d, intersect_parameter)) ).first;
         d_out = multiply(d, subtract(1.0, intersect_parameter));
         
         // Calculate the length of the component of d_out perpendicular to the edge
@@ -366,7 +368,7 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
         
         // Construct the new position vector, make sure it's in the plane to
         // avoid trouble with periodic boundary conditions
-        new_pos = projected_point(obj, add(intersect_pt, add(d_edge, d_perp)) ).first;        
+        new_pos = project_point(obj, add(intersect_pt, add(d_edge, d_perp)) ).first;        
         changeflag = true;
    }
    
@@ -389,9 +391,9 @@ deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, t
      // Type abbreviations
     typedef typename Plane<T_>::length_type length_type;
     typedef typename Plane<T_>::position_type position_type;
-    typedef std::pair<position_type, length_type> projected_type;
+    typedef std::pair<position_type, std::pair<length_type, length_type> > projected_type;
     
-    projected_type r_proj(projected_point(obj, r));
+    projected_type r_proj(project_point(obj, r));
     position_type  dc(subtract(r_proj.first, obj.position()));
                    // vector pointing towards the projection of r on plane obj
                    // from the center of the latter
@@ -408,9 +410,9 @@ deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, t
     else
         u_perp = multiply(u_z, -1.0);
     
-    r_new = add(r_proj.first, multiply(u_perp, abs(r_proj.second)) );
+    r_new = add(r_proj.first, multiply(u_perp, abs(r_proj.second.first)) );
     
-    return projected_point(obj, r_new).first;
+    return project_point(obj, r_new).first;
 }
 
 template<typename T_>
diff --git a/Region.hpp b/Region.hpp
index a4698c89..a2e555e6 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -42,12 +42,14 @@ class BasicRegionImpl: public Region<Ttraits_>
     typedef Tshape_                                     shape_type;
     typedef typename shape_type::side_enum_type         side_enum_type;     // Defines the type of enum to use for the sides of the region
 
-    typedef typename base_type::structure_name_type     structure_name_type;
-    typedef typename base_type::structure_id_type       structure_id_type;
-    typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::length_type             length_type;
-    typedef typename base_type::position_type           position_type;
-    typedef std::pair<position_type, bool>              position_flag_pair_type;
+    typedef typename base_type::structure_name_type         structure_name_type;
+    typedef typename base_type::structure_id_type           structure_id_type;
+    typedef typename base_type::structure_type_id_type      structure_type_id_type;
+    typedef typename base_type::length_type                 length_type;
+    typedef typename base_type::position_type               position_type;
+    typedef std::pair<position_type, bool>                  position_flag_pair_type;
+    typedef std::pair<length_type, length_type>             components_pair_type;
+    typedef std::pair<position_type, components_pair_type>  projected_type;
 
 public:
     virtual ~BasicRegionImpl() {}
@@ -94,14 +96,14 @@ class BasicRegionImpl: public Region<Ttraits_>
         return out.str();
     }
 
-    virtual std::pair<position_type, length_type> projected_point(position_type const& pos) const
+    virtual projected_type project_point(position_type const& pos) const
     {
-        return ::projected_point(shape(), pos);
+        return ::project_point(shape(), pos);
     }
     
-    virtual std::pair<position_type, length_type> projected_point_on_surface(position_type const& pos) const
+    virtual projected_type project_point_on_surface(position_type const& pos) const
     {
-        return ::projected_point(shape(), pos);
+        return ::project_point_on_surface(shape(), pos);
     }
     
     virtual length_type distance(position_type const& pos) const
diff --git a/Sphere.hpp b/Sphere.hpp
index 536476df..76ccc074 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -92,26 +92,30 @@ to_internal(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos
 
 template<typename T_>
 inline std::pair<typename Sphere<T_>::position_type,
-                 typename Sphere<T_>::length_type>
-projected_point(Sphere<T_> const& obj,
+                 std::pair<typename Sphere<T_>::length_type,
+                           typename Sphere<T_>::length_type> >
+project_point(Sphere<T_> const& obj,
                 typename Sphere<T_>::position_type const& pos)
 {
     // Todo. If we ever need it.
     // The projection of a point on a sphere.
     return std::make_pair(typename Sphere<T_>::position_type(),
-                          typename Sphere<T_>::length_type());
+                          std::make_pair(typename Sphere<T_>::length_type(),
+                                         typename Sphere<T_>::length_type()) );
 }
 
 template<typename T_>
 inline std::pair<typename Sphere<T_>::position_type,
-                 typename Sphere<T_>::length_type>
-projected_point_on_surface(Sphere<T_> const& obj,
+                 std::pair<typename Sphere<T_>::length_type,
+                           typename Sphere<T_>::length_type> >
+project_point_on_surface(Sphere<T_> const& obj,
                 typename Sphere<T_>::position_type const& pos)
 {
     // Todo. If we ever need it.
     // The projection of a point on a sphere.
     return std::make_pair(typename Sphere<T_>::position_type(),
-                          typename Sphere<T_>::length_type());
+                          std::make_pair(typename Sphere<T_>::length_type(),
+                                         typename Sphere<T_>::length_type()) );
 }
 
 template<typename T_>
diff --git a/Structure.hpp b/Structure.hpp
index 6ab52464..d072cd1c 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -32,7 +32,8 @@ class Structure
     typedef typename traits_type::position_type             position_type;
     typedef typename traits_type::species_type              species_type;
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
-    typedef std::pair<position_type, length_type>           projected_type;
+    typedef std::pair<length_type, length_type>             components_pair_type;
+    typedef std::pair<position_type, components_pair_type>  projected_type;
     typedef std::pair<position_type, position_type>         position_pair_type;
     typedef std::pair<position_type, bool>                  position_flag_pair_type;
     typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
@@ -118,8 +119,8 @@ class Structure
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const = 0;
     
     // general method for getting some measures/info
-    virtual projected_type projected_point(position_type const& pos) const = 0;
-    virtual projected_type projected_point_on_surface(position_type const& pos) const = 0;
+    virtual projected_type project_point(position_type const& pos) const = 0;
+    virtual projected_type project_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
     virtual length_type min_dist_proj_to_edge(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;    
diff --git a/Surface.hpp b/Surface.hpp
index 058cd5e5..f840b751 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -50,13 +50,14 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     typedef Tshape_                                     shape_type;
     typedef typename shape_type::side_enum_type         side_enum_type;     // Defines the type of enum to use for the sides of the surface
 
-    typedef typename base_type::structure_name_type     structure_name_type;
-    typedef typename base_type::structure_id_type       structure_id_type;
-    typedef typename base_type::structure_type_id_type  structure_type_id_type;
-    typedef typename base_type::length_type             length_type;
-    typedef typename base_type::position_type           position_type;
-    typedef std::pair<position_type, length_type>       projected_type;
-    typedef std::pair<position_type, bool>              position_flag_pair_type;
+    typedef typename base_type::structure_name_type         structure_name_type;
+    typedef typename base_type::structure_id_type           structure_id_type;
+    typedef typename base_type::structure_type_id_type      structure_type_id_type;
+    typedef typename base_type::length_type                 length_type;
+    typedef typename base_type::position_type               position_type;
+    typedef std::pair<length_type, length_type>             components_pair_type;
+    typedef std::pair<position_type, components_pair_type>  projected_type;
+    typedef std::pair<position_type, bool>                  position_flag_pair_type;
 
 public:
     virtual ~BasicSurfaceImpl() {}
@@ -101,14 +102,14 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         return out.str();
     }
 
-    virtual projected_type projected_point(position_type const& pos) const
+    virtual projected_type project_point(position_type const& pos) const
     {
-        return ::projected_point(shape(), pos);
+        return ::project_point(shape(), pos);
     }
     
-    virtual projected_type projected_point_on_surface(position_type const& pos) const
+    virtual projected_type project_point_on_surface(position_type const& pos) const
     {
-        return ::projected_point_on_surface(shape(), pos);
+        return ::project_point_on_surface(shape(), pos);
     }
     
     virtual length_type distance(position_type const& pos) const
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 6b6b0f3c..99685929 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -17,6 +17,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
     // registering converters from standard boost templates
     // registers the projected_point/projected_distance tuple defined in ../Structure.hpp
     peer::converters::register_tuple_converter<typename impl_type::projected_type>();
+    peer::converters::register_tuple_converter<typename impl_type::components_pair_type>();
     peer::converters::register_tuple_converter<typename impl_type::position_flag_pair_type>();
 
     // defining the python class
@@ -45,7 +46,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("random_position", &impl_type::random_position)
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)
-        .def("projected_point", &impl_type::projected_point)
+        .def("project_point", &impl_type::project_point)
         .def("min_dist_proj_to_edge", &impl_type::min_dist_proj_to_edge)
         .def("allows_interaction_from", &impl_type::allows_interaction_from)
         .def("deflect", &impl_type::deflect)
diff --git a/egfrd.py b/egfrd.py
index 9863482f..dad95659 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1326,7 +1326,7 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
 
             # 1.5 get new position and structure_id of particle
             transposed_pos       = self.world.cyclic_transpose(reactant_pos, product_structure.shape.position)
-            product_pos, _       = product_structure.projected_point(transposed_pos)
+            product_pos, _       = product_structure.project_point(transposed_pos)
             product_pos          = self.world.apply_boundary(product_pos)        # not sure this is still necessary
             product_structure_id = product_structure.id
 
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 21e33c1f..76444bd4 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -59,7 +59,8 @@ class newBDPropagator
     typedef std::pair<position_type, position_type>                             position_pair_type;
     typedef std::pair<position_type, structure_id_type>                         position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type> posstructid_posstructid_pair_type;
-    typedef std::pair<position_type, length_type>                               projected_type;
+    typedef std::pair<length_type, length_type>                                 component_pair_type;
+    typedef std::pair<position_type, component_pair_type>                       projected_type;
 
 public:
     // The constructor
@@ -684,7 +685,7 @@ class newBDPropagator
                                 throw propagation_error("Particles can only be one hierarchical level apart.");
                             }
 
-                            projected_type const position_on_surface( product_structure-> projected_point(
+                            projected_type const position_on_surface( product_structure-> project_point(
                                     tx_.cyclic_transpose( product_pos, product_structure->position() )));       // TODO check of cyclic transpose is still needed.
 
                             // check that the projected point is not outside of the product surface.
@@ -801,7 +802,7 @@ class newBDPropagator
                         const species_type product_species(tx_.get_species(products[0]));
 
                         // Get the new position of the particle on the structure
-                        const position_type product_pos( tx_.apply_boundary( structure->projected_point( pp.second.position() ).first ) );
+                        const position_type product_pos( tx_.apply_boundary( structure->project_point( pp.second.position() ).first ) );
 
 
                         ///// Check for overlaps   
diff --git a/shells.py b/shells.py
index 50a48580..d716e190 100755
--- a/shells.py
+++ b/shells.py
@@ -175,10 +175,10 @@ def __init__(self, single, origin_structure, target_structure):
         ### initialize some constants that are common for the testInteractionSingle domains.
 
         # calculate the Projected_point and distance to the target_structure
-        # Cyclic transpose needed when calling target_structure.projected_point!
+        # Cyclic transpose needed when calling target_structure.project_point!
         pos_transposed = self.world.cyclic_transpose(self.pid_particle_pair[1].position,
                                                      self.target_structure.shape.position)
-        self.reference_point, projection_length = self.target_structure.projected_point(pos_transposed)
+        self.reference_point, _ = self.target_structure.project_point(pos_transposed)
 
         # projection_distance can be negative in case of plane
         # note that the distance is to the center of the cylinder in case of cylinders
@@ -343,7 +343,7 @@ def do_transform(self):
 
         # and then projected onto the plane to make sure the CoM is in the surface
         com = self.world.cyclic_transpose(com, self.structure2D.shape.position)
-        com, _ = self.structure2D.projected_point (com)
+        com, _ = self.structure2D.project_point (com)
         com = self.world.apply_boundary(com)
 
 
diff --git a/test/CylindricalSurface_test.py b/test/CylindricalSurface_test.py
index 2faeb5fa..f91f6d0c 100755
--- a/test/CylindricalSurface_test.py
+++ b/test/CylindricalSurface_test.py
@@ -43,8 +43,8 @@ def test_random_positions(self):
 
     def test_projected_point(self):
         d = self.cylinder_at_position(self.r1)
-        assert (d.projected_point([5, 2, 2])[0] == [5, 5, 2]).all()
-        assert d.projected_point([5, 2, 2])[1] == 3
+        assert (d.project_point([5, 2, 2])[0] == [5, 5, 2]).all()
+        assert d.project_point([5, 2, 2])[1][0] == 3
 
     def test_distance_to_cylinder(self):
         d = self.cylinder_at_position(self.r1)
diff --git a/test/PlanarSurface_test.py b/test/PlanarSurface_test.py
index b7a67bae..b2543741 100755
--- a/test/PlanarSurface_test.py
+++ b/test/PlanarSurface_test.py
@@ -45,8 +45,8 @@ def test_random_positions(self):
 
     def test_projected_point(self):
         m = self.membrane_at_position(self.r1, self.r2)
-        assert (m.projected_point([2, 2, 2])[0] == [2, 2, 5]).all()
-        assert m.projected_point([2, 2, 2])[1] == -3
+        assert (m.project_point([2, 2, 2])[0] == [2, 2, 5]).all()
+        assert m.project_point([2, 2, 2])[1][0] == -3
 
     def test_distance_to_plane(self):
         m1 = self.membrane_at_position(self.r1, self.r2)

From 57d4b4dad41c170523521aba131b41d31f6ee56a Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Thu, 24 May 2012 20:14:24 +0200
Subject: [PATCH 0931/1541] extended 'project_point' to provide the distance
 from the projected point to the 'edge' of the shape.

---
 Box.hpp      | 13 +++++++++++--
 Cylinder.hpp | 35 +++++++++++++++++++++--------------
 Disk.hpp     | 38 +++++++++++++++++++++-----------------
 Plane.hpp    | 15 +++++++++++----
 Sphere.hpp   | 19 +++++++++++--------
 5 files changed, 75 insertions(+), 45 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 8f455cbc..f6a6fbd4 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -220,11 +220,20 @@ inline std::pair<typename Box<T_>::position_type,
                            typename Box<T_>::length_type> >
 project_point(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
 {
-    // Todo. If we ever need it.
+    typedef typename Box<T_>::length_type length_type;
+
+    const boost::array<length_type, 3> x_y_z(to_internal(obj, pos));
+    const boost::array<length_type, 3> dx_dy_dz(subtract(abs(x_y_z), obj.half_extent()));
+    const length_type min_dist ( (dx_dy_dz[0] <= 0 &&
+                                  dx_dy_dz[1] <= 0 &&
+                                  dx_dy_dz[2] <= 0) ? std::max(dx_dy_dz[0], std::max(dx_dy_dz[1], dx_dy_dz[2]) )
+                                                    : 1.0 );      // TODO make this is proper distance if we need it
+
+    // TODO the projection of the point is not very well defined.
     // The projection of a point on a box.
     return std::make_pair(typename Box<T_>::position_type(),
                           std::make_pair(typename Box<T_>::length_type(),
-                                         typename Box<T_>::length_type()) );
+                                         min_dist) );
 }
 
 template<typename T_>
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 712ffc1e..75a64cc2 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -5,6 +5,7 @@
 #include <cmath>
 #include "Vector3.hpp"
 #include "Shape.hpp"
+#include "linear_algebra.hpp"
 
 // Todo. Make sure cylinder is never larger than 1 cellsize or something.  
 template<typename T_>
@@ -123,14 +124,13 @@ inline std::pair<typename Cylinder<T_>::length_type,
 to_internal(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const& pos)
 {
     // Return pos relative to position of cylinder. 
-    typedef typename Cylinder<T_>::position_type position_type;
-    typedef typename Cylinder<T_>::length_type length_type;
+    typedef typename Cylinder<T_>::position_type    position_type;
+    typedef typename Cylinder<T_>::length_type      length_type;
 
     const position_type pos_vector(subtract(pos, obj.position()));
-    // z can be < 0
-    const length_type z(dot_product(pos_vector, obj.unit_z()));
-    // r is always >= 0
-    const length_type r(length(pos_vector - multiply(obj.unit_z(), z)));
+
+    const length_type z(dot_product(pos_vector, obj.unit_z()));             // z can be < 0
+    const length_type r(length(subtract(pos_vector, multiply(obj.unit_z(), z))));    // r is always >= 0
 
     return std::make_pair(r, z);
 }
@@ -139,16 +139,16 @@ template<typename T_>
 inline std::pair<typename Cylinder<T_>::position_type,
                  std::pair<typename Cylinder<T_>::length_type,
                            typename Cylinder<T_>::length_type> >
-project_point(Cylinder<T_> const& obj,
-              typename Cylinder<T_>::position_type const& pos)
+project_point(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const& pos)
 {
     typedef typename Cylinder<T_>::length_type length_type;
 
     // The projection lies on the z-axis.
     std::pair<length_type, length_type> r_z(to_internal(obj, pos));
+
     return std::make_pair( add(obj.position(), multiply(obj.unit_z(), r_z.second)),
                            std::make_pair(r_z.first,
-                                          0.0) );   // TODO
+                                          subtract(abs(r_z.second), obj.half_length())) );
 }
 
 //Almost equal to projected point method, but for the substraction of the cylinder radius from the radial distance r.
@@ -163,12 +163,19 @@ project_point_on_surface(Cylinder<T_> const& obj,
     typedef typename Cylinder<T_>::length_type length_type;
     typedef typename Cylinder<T_>::position_type position_type;
 
-    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
-    position_type within_surface( add(obj.position(), multiply(obj.unit_z(), r_z.second)) );    //????
+    // Here we do not call 'to_internal' for efficiency
+    const position_type pos_vector(subtract(pos, obj.position()));
+
+    const length_type   z ( dot_product(pos_vector, obj.unit_z()) );
+    const position_type z_vector (multiply(obj.unit_z(), z));
+    const position_type r_vector (subtract(pos_vector, z_vector));
+    const length_type   r (length(r_vector));
+
+    const position_type projected_point( add(obj.position(), z_vector) );
 
-    return std::make_pair( add(within_surface, multiply( normalize( subtract( pos, within_surface ) ), obj.radius() )),
-                           std::make_pair(r_z.first - obj.radius(),
-                                          0.0) );   // TODO
+    return std::make_pair( add(projected_point, multiply( normalize(r_vector), obj.radius() )),
+                           std::make_pair(subtract(r, obj.radius()),
+                                          subtract(abs(z), obj.half_length())) );
 }
 
 template<typename T_>
diff --git a/Disk.hpp b/Disk.hpp
index 98c786de..37c30fbf 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -5,6 +5,7 @@
 #include <cmath>
 #include "Vector3.hpp"
 #include "Shape.hpp"
+#include "linear_algebra.hpp"
 
 template<typename T_>
 class Disk
@@ -111,10 +112,9 @@ to_internal(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
     typedef typename Disk<T_>::length_type      length_type;
 
     const position_type pos_vector(subtract(pos, obj.position()));
-    // z can be < 0
-    const length_type z(dot_product(pos_vector, obj.unit_z()));
-    // r is always >= 0
-    const length_type r(length(pos_vector - multiply(obj.unit_z(), z)));
+    
+    const length_type z( dot_product(pos_vector, obj.unit_z()) );               // z can be < 0
+    const length_type r( length(subtract(pos_vector, multiply(obj.unit_z(), z))) );// r is always >= 0
 
     return array_gen<typename Disk<T_>::length_type>(r, z);
 }
@@ -123,19 +123,24 @@ template<typename T_>
 inline std::pair<typename Disk<T_>::position_type,
                  std::pair<typename Disk<T_>::length_type,
                            typename Disk<T_>::length_type> >
-project_point(Disk<T_> const& obj,
-                typename Disk<T_>::position_type const& pos)
+project_point(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
+// Calculates the projection of 'pos' onto the disk 'obj' and also returns the coefficient
+// for the normal component (z) of 'pos' in the basis of the disk and the distance of the
+// projected point to the 'edge' of the disk. Here a positive number means the projected
+// point is outside the disk, and a negative numbers means it is 'inside' the disk.
 {
-    typedef typename Disk<T_>::length_type length_type;
+    typedef typename Disk<T_>::length_type   length_type;
+    typedef typename Disk<T_>::position_type position_type;
 
-    // The disk is in principle a 1D object:
-    // Projecting onto the disk means projecting onto its center.
-    // The distance is the z-component returned by to_internal().
-    boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
-    
-    return std::make_pair( obj.position(),
-                           std::make_pair(r_z[1],
-                                          0.0) );       //TODO
+    // Here we do not call 'to_internal' for efficiency
+    const position_type pos_vector(subtract(pos, obj.position()));
+
+    const length_type   z ( dot_product(pos_vector, obj.unit_z()) );
+    const position_type r_vector (subtract(pos_vector, multiply(obj.unit_z(), z)));
+    const length_type   r (length(r_vector));
+
+    return std::make_pair( add(obj.position(), r_vector),
+                           std::make_pair(z, r - obj.radius()) );
 }
 
 // The same as in case of the plane: projected_point_on_surface = projected_point
@@ -143,8 +148,7 @@ template<typename T_>
 inline std::pair<typename Disk<T_>::position_type,
                  std::pair<typename Disk<T_>::length_type,
                            typename Disk<T_>::length_type> >
-project_point_on_surface(Disk<T_> const& obj,
-                typename Disk<T_>::position_type const& pos)
+project_point_on_surface(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
 {
     return project_point(obj, pos);
 }
diff --git a/Plane.hpp b/Plane.hpp
index 4a561d47..c71d61f7 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -198,11 +198,18 @@ project_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos
 // Calculates the projection of 'pos' onto the plane 'obj' and also returns the coefficient
 // for the normal component (z) of 'pos' in the basis of the plane
 {
+    typedef typename Plane<T_>::length_type length_type;
+
     boost::array<typename Plane<T_>::length_type, 3> x_y_z(to_internal(obj, pos));
-    return std::make_pair(
-        add(add(obj.position(), multiply(obj.unit_x(), x_y_z[0])),
-                                multiply(obj.unit_y(), x_y_z[1])),
-        std::make_pair(x_y_z[2], 0.0) );    //TODO
+
+    const length_type dx(subtract( abs(x_y_z[0]), obj.half_extent()[0]));
+    const length_type dy(subtract( abs(x_y_z[1]), obj.half_extent()[1]));
+    const length_type min_dist ( (dx <= 0 && dy <= 0) ? std::max(dx, dy)
+                                                      : 1.0 );      // TODO make this is proper distance if we need it
+
+    return std::make_pair( add(add(obj.position(), multiply(obj.unit_x(), x_y_z[0])),
+                               multiply(obj.unit_y(), x_y_z[1])),
+                           std::make_pair(x_y_z[2], min_dist) );
 }
 
 template<typename T_>
diff --git a/Sphere.hpp b/Sphere.hpp
index 76ccc074..50a82ab7 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -4,6 +4,7 @@
 #include <ostream>
 #include "Vector3.hpp"
 #include "Shape.hpp"
+#include "linear_algebra.hpp"
 
 template<typename T_>
 class Sphere
@@ -86,22 +87,24 @@ inline typename Sphere<T_>::length_type
 to_internal(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
 // The function calculates the coefficients to express 'pos' into the base of the sphere 'obj'
 {
+    typedef typename Sphere<T_>::position_type position_type;
+    position_type pos_vector(subtract(pos, obj.position()));
+
     // Todo. If we ever need it.
-    return typename Sphere<T_>::length_type();
+    return length(pos_vector);
 }
 
 template<typename T_>
 inline std::pair<typename Sphere<T_>::position_type,
                  std::pair<typename Sphere<T_>::length_type,
                            typename Sphere<T_>::length_type> >
-project_point(Sphere<T_> const& obj,
-                typename Sphere<T_>::position_type const& pos)
+project_point(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
 {
-    // Todo. If we ever need it.
-    // The projection of a point on a sphere.
-    return std::make_pair(typename Sphere<T_>::position_type(),
-                          std::make_pair(typename Sphere<T_>::length_type(),
-                                         typename Sphere<T_>::length_type()) );
+    typename Sphere<T_>::length_type r(to_internal(obj, pos));
+
+    // The projection of a point on a sphere is always the centerpoint of the sphere.
+    return std::make_pair(obj.position(),
+                          std::make_pair(r, 0.0) );
 }
 
 template<typename T_>

From 4b834e50ef7a84a7018bf71b13a130887fdc2743 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 11:35:33 +0200
Subject: [PATCH 0932/1541] replaced 'is_alongside' by 'project_point' and
 removed redundant 'is_alongside'

---
 Box.hpp             |  9 ---------
 Cylinder.hpp        | 14 --------------
 Disk.hpp            | 11 -----------
 Plane.hpp           | 14 --------------
 Region.hpp          |  5 -----
 Sphere.hpp          |  9 ---------
 Structure.hpp       |  1 -
 Surface.hpp         |  5 -----
 newBDPropagator.hpp | 11 ++++++-----
 9 files changed, 6 insertions(+), 73 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index f6a6fbd4..3b6bfec9 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -191,15 +191,6 @@ class Box
     boost::array<length_type, 3> half_extent_;
 };
 
-template<typename T_>
-inline bool
-is_alongside(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
-// The function checks if the projection of the position 'pos' is 'inside' the object.
-{
-    // Todo. If we ever need it.
-    return true;
-}
-
 template<typename T_>
 inline boost::array<typename Box<T_>::length_type, 3>
 to_internal(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 75a64cc2..d3be9a22 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -104,20 +104,6 @@ inline std::basic_ostream<Tstrm_>& operator<<(std::basic_ostream<Tstrm_>& strm,
     return strm;
 }
 
-template<typename T_>
-inline bool
-is_alongside(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const& pos)
-// The function checks if the projection of the position 'pos' is 'inside' the object.
-{
-    typedef typename Cylinder<T_>::position_type    position_type;
-    typedef typename Cylinder<T_>::length_type      length_type;
-
-    const position_type pos_vector(subtract(pos, obj.position()));
-
-    return (abs(dot_product(pos_vector, obj.unit_z())) <= obj.half_length());
-}
-
-
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::length_type,
                  typename Cylinder<T_>::length_type>
diff --git a/Disk.hpp b/Disk.hpp
index 37c30fbf..05267465 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -91,17 +91,6 @@ inline std::basic_ostream<Tstrm_>& operator<<(std::basic_ostream<Tstrm_>& strm,
     return strm;
 }
 
-template<typename T_>
-inline bool
-is_alongside(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
-// The function checks if the projection of the position 'pos' is 'inside' the object.
-{
-    boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
-
-    return ( r_z[0] <= obj.radius() );
-}
-
-
 template<typename T_>
 inline boost::array<typename Disk<T_>::length_type, 2>
 to_internal(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
diff --git a/Plane.hpp b/Plane.hpp
index c71d61f7..03f790e9 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -433,20 +433,6 @@ allows_interaction_from(Plane<T_> const& obj, typename Plane<T_>::position_type
     return ( abs(x_y_z[0]) <= obj.Lx() ) && ( abs(x_y_z[1]) <= obj.Ly() );
 }
 
-template<typename T_>
-inline bool
-is_alongside(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// The function checks if the projection of the position 'pos' is 'inside' the object.
-{
-    typedef typename Plane<T_>::position_type position_type;
-
-    boost::array<typename Plane<T_>::length_type, 2> half_extends(obj.half_extent());
-    position_type pos_vector(subtract(pos, obj.position()));
-
-    return ((abs(dot_product(pos_vector, obj.unit_x())) < half_extends[0]) &&
-            (abs(dot_product(pos_vector, obj.unit_y())) < half_extends[1]));
-}
-
 template<typename T, typename Trng>
 inline typename Plane<T>::position_type
 random_position(Plane<T> const& shape, Trng& rng)
diff --git a/Region.hpp b/Region.hpp
index a2e555e6..cacf44b7 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -136,11 +136,6 @@ class BasicRegionImpl: public Region<Ttraits_>
         return ::allows_interaction_from(shape(), pos);
     }
 
-    virtual bool is_alongside(position_type const& pos) const
-    {
-        return ::is_alongside(shape(), pos);
-    }
-
     // The constructor
     BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
         : base_type(name, sid, parent_struct_id), shape_(shape) {}
diff --git a/Sphere.hpp b/Sphere.hpp
index 50a82ab7..3e7f8bb6 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -73,15 +73,6 @@ inline std::basic_ostream<Tstrm_, Ttraits_>& operator<<(std::basic_ostream<Tstrm
     return strm;
 }
 
-template<typename T_>
-inline bool
-is_alongside(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
-// The function checks if the projection of the position 'pos' is 'inside' the object.
-// This is always true because the projection is always onto the center of the sphere.
-{
-    return true;
-}
-
 template<typename T_>
 inline typename Sphere<T_>::length_type
 to_internal(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
diff --git a/Structure.hpp b/Structure.hpp
index d072cd1c..bfb95e91 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -104,7 +104,6 @@ class Structure
     // Methods used in the 'new' BDPropagator
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const = 0;
-    virtual bool is_alongside(position_type const& pos) const = 0;
 
 
     // TODO this are just functions->move somewhere else
diff --git a/Surface.hpp b/Surface.hpp
index f840b751..bd541d4f 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -143,11 +143,6 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
         // returns true if a particle at position pos is supposed to
         // be able to interact with the surface
     }
-    
-    virtual bool is_alongside(position_type const& pos) const
-    {
-        return ::is_alongside(shape(), pos);
-    }
 
     // Constructor
     BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 76444bd4..b86d4cd4 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -224,11 +224,12 @@ class newBDPropagator
         while(j < structures_in_overlap)
         {
             const structure_id_pair_and_distance & overlap_struct( overlap_structures->at(j) );
+            const projected_type new_pos_projected (overlap_struct.first.second->project_point(new_pos));
 
             // For an interaction the structure must be:
             if( (overlap_struct.first.second->sid() != current_struct->sid()) &&    // - of a different structure_type
                 (overlap_struct.second < r0 + reaction_length_) &&                  // - within the reaction volume
-                (overlap_struct.first.second->is_alongside(new_pos)))               // - 'alongside' of the particle
+                (new_pos_projected.second.second < 0) )                             // - 'alongside' of the particle
             {
                 accumulated_prob += k_total( pp.second.sid(), overlap_struct.first.second->sid() ) * dt_ / 
                                     overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ );
@@ -244,7 +245,7 @@ class newBDPropagator
                     try
                     {
                         LOG_DEBUG(("fire surface interaction"));
-                        if(attempt_interaction(pp, overlap_struct.first.second ))
+                        if(attempt_interaction(pp, new_pos_projected.first, overlap_struct.first.second ))
                             return true;
                     }   
                     catch (propagation_error const& reason)
@@ -689,7 +690,7 @@ class newBDPropagator
                                     tx_.cyclic_transpose( product_pos, product_structure->position() )));       // TODO check of cyclic transpose is still needed.
 
                             // check that the projected point is not outside of the product surface.
-                            if ( !(product_structure->is_alongside( position_on_surface.first)) )
+                            if ( position_on_surface.second.second > 0 )
                                 throw propagation_error("position product particle was not in surface.");
 
                             product_pos = tx_.apply_boundary( position_on_surface.first );
@@ -761,7 +762,7 @@ class newBDPropagator
     }
 
         
-    const bool attempt_interaction(particle_id_pair const& pp, boost::shared_ptr<structure_type> const& structure)
+    const bool attempt_interaction(particle_id_pair const& pp, position_type const& pos_in_struct, boost::shared_ptr<structure_type> const& structure)
     // This handles the 'reaction' (interaction) between a particle and a structure.
     // Returns True if the interaction was succesfull
     {
@@ -802,7 +803,7 @@ class newBDPropagator
                         const species_type product_species(tx_.get_species(products[0]));
 
                         // Get the new position of the particle on the structure
-                        const position_type product_pos( tx_.apply_boundary( structure->project_point( pp.second.position() ).first ) );
+                        const position_type product_pos( tx_.apply_boundary(pos_in_struct) );
 
 
                         ///// Check for overlaps   

From 19e565238f8e91a244be4147c8276873a236079f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 12:19:10 +0200
Subject: [PATCH 0933/1541] replaced 'allows_interaction_from' by info in
 'project_point' and removed redundant 'allows_interaction_from'

---
 Box.hpp               | 10 ----------
 Cylinder.hpp          | 15 ---------------
 Disk.hpp              | 14 --------------
 Plane.hpp             | 11 -----------
 Region.hpp            |  5 -----
 Sphere.hpp            |  9 ---------
 Structure.hpp         |  1 -
 Surface.hpp           |  7 -------
 binding/Structure.hpp |  1 -
 egfrd.py              |  3 +--
 shells.py             |  5 ++++-
 11 files changed, 5 insertions(+), 76 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 3b6bfec9..08e35d7a 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -343,16 +343,6 @@ deflect_back(Box<T_> const& obj,
     return r;
 }
 
-template<typename T_>
-inline bool
-allows_interaction_from(Box<T_> const& obj,
-        typename Box<T_>::position_type const& r)
-{
-    // This function is not relevant for the box but has
-    // to return something for implementation reasons
-    return true;
-}
-
 template<typename T, typename Trng>
 inline typename Box<T>::position_type
 random_position(Box<T> const& shape, Trng& rng)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index d3be9a22..e32508fd 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -256,21 +256,6 @@ deflect_back(Cylinder<T_> const& obj,
     return r;
 }
 
-template<typename T_>
-inline bool
-allows_interaction_from(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const& pos)
-// Returns true if a particle at position pos is supposed to interact with the cylinder
-{
-    typedef typename Cylinder<T_>::length_type length_type;
-
-    // The projection lies on the z-axis.
-    std::pair<length_type, length_type> r_z(to_internal(obj, pos));
-    
-    // Only interact from points that are between the cylinder caps
-    // when projected onto the cylinder axis
-    return ( abs(r_z.second) <= obj.half_length() );
-}
-
 template<typename T, typename Trng>
 inline typename Cylinder<T>::position_type
 random_position(Cylinder<T> const& shape, Trng& rng)
diff --git a/Disk.hpp b/Disk.hpp
index 05267465..5b669f17 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -220,20 +220,6 @@ deflect_back(Disk<T_> const& obj,
     return r;
 }
 
-template<typename T_>
-inline bool
-allows_interaction_from(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
-// Returns true if a particle at position pos is supposed to interact with the disk
-{
-    typedef typename Disk<T_>::length_type length_type;
-
-    const boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
-    
-    // Return true if the projection of pos is within the disk's radius
-    return ( r_z[0] <= obj.radius() );
-}
-
-
 template<typename T, typename Trng>
 inline typename Disk<T>::position_type
 random_position(Disk<T> const& shape, Trng& rng)
diff --git a/Plane.hpp b/Plane.hpp
index 03f790e9..fe7e1608 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -422,17 +422,6 @@ deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, t
     return project_point(obj, r_new).first;
 }
 
-template<typename T_>
-inline bool
-allows_interaction_from(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// Returns true if a particle at position pos is supposed to interact with the plane
-{
-    boost::array<typename Plane<T_>::length_type, 3> x_y_z(to_internal(obj, pos));
-    
-    // Return true if projection of pos is within the confined plane
-    return ( abs(x_y_z[0]) <= obj.Lx() ) && ( abs(x_y_z[1]) <= obj.Ly() );
-}
-
 template<typename T, typename Trng>
 inline typename Plane<T>::position_type
 random_position(Plane<T> const& shape, Trng& rng)
diff --git a/Region.hpp b/Region.hpp
index cacf44b7..9365bce8 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -130,11 +130,6 @@ class BasicRegionImpl: public Region<Ttraits_>
     {
         return ::deflect_back(shape(), pos, u_z);
     }
-    
-    virtual bool allows_interaction_from(position_type const& pos) const
-    {
-        return ::allows_interaction_from(shape(), pos);
-    }
 
     // The constructor
     BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
diff --git a/Sphere.hpp b/Sphere.hpp
index 3e7f8bb6..8a6d2840 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -148,15 +148,6 @@ deflect_back(Sphere<T_> const& obj,
     return r;
 }
 
-template<typename T_>
-inline bool
-allows_interaction_from(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
-// Returns true if a particle at position pos is supposed to interact with the sphere
-{
-    // By default any point outside the sphere can interact with it
-    return ( length(subtract(pos, obj.position())) >= obj.radius() ); 
-}
-
 template<typename T_>
 inline Sphere<T_> const& shape(Sphere<T_> const& shape)
 {
diff --git a/Structure.hpp b/Structure.hpp
index bfb95e91..0f491322 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -123,7 +123,6 @@ class Structure
     virtual length_type distance(position_type const& pos) const = 0;
     virtual length_type min_dist_proj_to_edge(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;    
-    virtual bool allows_interaction_from(position_type const& pos) const = 0;
 
     // Methods used for edge crossing (only for the planes so far)    
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
diff --git a/Surface.hpp b/Surface.hpp
index bd541d4f..b5f22433 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -136,13 +136,6 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     {
         return ::deflect_back(shape(), pos, u_z);
     }
-    
-    virtual bool allows_interaction_from(position_type const& pos) const
-    {
-        return ::allows_interaction_from(shape(), pos);
-        // returns true if a particle at position pos is supposed to
-        // be able to interact with the surface
-    }
 
     // Constructor
     BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 99685929..aa58afdf 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -48,7 +48,6 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("project_point", &impl_type::project_point)
         .def("min_dist_proj_to_edge", &impl_type::min_dist_proj_to_edge)
-        .def("allows_interaction_from", &impl_type::allows_interaction_from)
         .def("deflect", &impl_type::deflect)
         .def("deflect_back", &impl_type::deflect_back)
         ;
diff --git a/egfrd.py b/egfrd.py
index dad95659..cb7a73e5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1589,8 +1589,7 @@ def make_new_domain(self, single):
             elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
                 domain = self.try_transition(single, obj)
 
-            elif ( isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface) ) and \
-                 obj.allows_interaction_from(single_pos) :
+            elif ( isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface) ):
                 # try making an Interaction
                 domain = self.try_interaction (single, obj)
 
diff --git a/shells.py b/shells.py
index d716e190..800ce6da 100755
--- a/shells.py
+++ b/shells.py
@@ -178,8 +178,11 @@ def __init__(self, single, origin_structure, target_structure):
         # Cyclic transpose needed when calling target_structure.project_point!
         pos_transposed = self.world.cyclic_transpose(self.pid_particle_pair[1].position,
                                                      self.target_structure.shape.position)
-        self.reference_point, _ = self.target_structure.project_point(pos_transposed)
+        self.reference_point, (_, dist_to_surface_edge) = self.target_structure.project_point(pos_transposed)
+        if dist_to_surface_edge >= 0:
+            raise testShellError('(testInteractionSingle). Projected point of particle is not in surface.')
 
+        self.min_dist_proj_to_edge = abs(dist_to_surface_edge)
         # projection_distance can be negative in case of plane
         # note that the distance is to the center of the cylinder in case of cylinders
         self.particle_surface_distance = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)

From 95b3e5a338f57867eff08e9e12fa5d00440edde3 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 14:03:26 +0200
Subject: [PATCH 0934/1541] replaced 'min_dist_proj_to_edge' by info from
 'project_point' and removed redundant 'min_dist_proj_to_edge'

---
 Box.hpp               | 17 -----------------
 Cylinder.hpp          | 23 -----------------------
 Disk.hpp              | 22 ----------------------
 Plane.hpp             | 21 ---------------------
 Region.hpp            |  7 +------
 Sphere.hpp            |  9 ---------
 Structure.hpp         |  1 -
 Surface.hpp           |  7 +------
 binding/Structure.hpp |  1 -
 shells.py             | 34 ++++++++++++++++++++--------------
 10 files changed, 22 insertions(+), 120 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 08e35d7a..426c4581 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -304,23 +304,6 @@ distance(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
     }
 }
 
-template<typename T_>
-inline typename Box<T_>::length_type
-min_dist_proj_to_edge(Box<T_> const& obj, typename Box<T_>::position_type const& pos)
-// Calculates the distance from the projection of 'pos' to the closest edge of the box
-// if it is in the box; if not, it returns zero
-{
-    typedef typename Box<T_>::length_type length_type;
-    boost::array<length_type, 3> x_y_z(to_internal(obj, pos));
-    boost::array<length_type, 3> dx_dy_dz(subtract(abs(x_y_z), obj.half_extent()));
-
-    if (dx_dy_dz[0] < 0 && dx_dy_dz[1] < 0 && dx_dy_dz[2] < 0)
-        // pos is within the box
-        return std::min( std::min(-dx_dy_dz[0], -dx_dy_dz[1]), -dx_dy_dz[2]);
-    
-    else        return 0;
-}
-
 template<typename T_>
 inline std::pair<typename Box<T_>::position_type, bool>
 deflect(Box<T_> const& obj,
diff --git a/Cylinder.hpp b/Cylinder.hpp
index e32508fd..0bbdeb83 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -211,29 +211,6 @@ distance(Cylinder<T_> const& obj,
     return distance;
 }
 
-template<typename T_>
-inline typename Cylinder<T_>::length_type
-min_dist_proj_to_edge(Cylinder<T_> const& obj,
-                typename Cylinder<T_>::position_type const& pos)
-// Calculates the distance from the projection of 'pos' to the closest cap of the cylinder
-// if it is within in the cylinder; if not, it returns zero
-{
-    typedef typename Cylinder<T_>::position_type position_type;
-    typedef typename Cylinder<T_>::length_type length_type;
-
-    /* First compute the (r,z) components of pos in a coordinate system 
-     * defined by the vectors unitR and unit_z, where unitR is
-     * choosen such that unitR and unit_z define a plane in which
-     * pos lies. */
-    const std::pair<length_type, length_type> r_z(to_internal(obj, pos));
-    /* Then compute distance to caps. */
-    const length_type dz(std::fabs(r_z.second) - obj.half_length());
-    
-    if (dz < 0)         return -dz;
-    else                return 0;
-
-}
-
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::position_type, bool>
 deflect(Cylinder<T_> const& obj,
diff --git a/Disk.hpp b/Disk.hpp
index 5b669f17..56d0d58d 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -176,28 +176,6 @@ distance(Disk<T_> const& obj,
     return distance;
 }
 
-template<typename T_>
-inline typename Disk<T_>::length_type
-min_dist_proj_to_edge(Disk<T_> const& obj,
-                typename Disk<T_>::position_type const& pos)
-// Calculates the distance from the projection of 'pos' to the edge of the disk
-// if it is within in the disk; if not, it returns zero
-{
-    typedef typename Disk<T_>::position_type position_type;
-    typedef typename Disk<T_>::length_type length_type;
-
-    /* First compute the (r,z) components of pos in a coordinate system 
-     * defined by the vectors unitR and unit_z, where unitR is
-     * choosen such that unitR and unit_z define a plane in which
-     * pos lies. */
-    const boost::array<typename Disk<T_>::length_type, 2> r_z(to_internal(obj, pos));
-    /* Then compute distance to radial edge. */
-    const length_type dr(r_z[0] - obj.radius());
-
-    if (dr < 0)         return -dr;
-    else                return 0;
-}
-
 template<typename T_>
 inline std::pair<typename Disk<T_>::position_type, bool>
 deflect(Disk<T_> const& obj,
diff --git a/Plane.hpp b/Plane.hpp
index fe7e1608..40d9fb81 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -270,27 +270,6 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
     }
 }
 
-template<typename T_>
-inline typename Plane<T_>::length_type
-min_dist_proj_to_edge(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
-// Calculates the distance from the projection of 'pos' to the closest edge of the plane
-// if it is in the plane; if not, it returns zero
-{
-    typedef typename Plane<T_>::length_type length_type;
-    boost::array<length_type, 3> const x_y_z(to_internal(obj, pos));
-
-    length_type const dx(subtract( abs(x_y_z[0]), obj.half_extent()[0]));
-    length_type const dy(subtract( abs(x_y_z[1]), obj.half_extent()[1]));
-
-    if (dx < 0.0 && dy < 0.0)
-        // pos is positioned over the plane (projected point is in the plane and
-        // not next to it).
-        return std::min( -dx, -dy);
-
-    else        return 0.0;
-    
-}
-
 ///// Function below are inline functions that can be applied on Plane objects.
 
 template<typename T_>
diff --git a/Region.hpp b/Region.hpp
index 9365bce8..7e5e9ea6 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -110,12 +110,7 @@ class BasicRegionImpl: public Region<Ttraits_>
     {
         return ::distance(shape(), pos);
     }
-    
-    virtual length_type min_dist_proj_to_edge(position_type const& pos) const
-    {
-        return ::min_dist_proj_to_edge(shape(), pos);
-    }
-    
+
     virtual position_type const& position() const
     {
         return ::shape_position(shape());
diff --git a/Sphere.hpp b/Sphere.hpp
index 8a6d2840..4028df92 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -119,15 +119,6 @@ distance(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
     return distance(pos, obj.position()) - obj.radius();
 }
 
-template<typename T_>
-inline typename Sphere<T_>::length_type
-min_dist_proj_to_edge(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& pos)
-// Calculates the distance from the projection of 'pos' to the edge of the sphere.
-// Since the projection is always at the sphere center, this is just the radius.
-{
-    return obj.radius();
-}
-
 template<typename T_>
 inline std::pair<typename Sphere<T_>::position_type, bool>
 deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typename Sphere<T_>::position_type const& d)
diff --git a/Structure.hpp b/Structure.hpp
index 0f491322..1edeb21a 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -121,7 +121,6 @@ class Structure
     virtual projected_type project_point(position_type const& pos) const = 0;
     virtual projected_type project_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
-    virtual length_type min_dist_proj_to_edge(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;    
 
     // Methods used for edge crossing (only for the planes so far)    
diff --git a/Surface.hpp b/Surface.hpp
index b5f22433..9812e187 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -116,12 +116,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     {
         return ::distance(shape(), pos);
     }
-    
-    virtual length_type min_dist_proj_to_edge(position_type const& pos) const
-    {
-        return ::min_dist_proj_to_edge(shape(), pos);
-    }
-    
+
     virtual position_type const& position() const
     {
         return ::shape_position(shape());
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index aa58afdf..b6e8ab13 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -47,7 +47,6 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("random_vector", &impl_type::random_vector)
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("project_point", &impl_type::project_point)
-        .def("min_dist_proj_to_edge", &impl_type::min_dist_proj_to_edge)
         .def("deflect", &impl_type::deflect)
         .def("deflect_back", &impl_type::deflect_back)
         ;
diff --git a/shells.py b/shells.py
index 800ce6da..6713baca 100755
--- a/shells.py
+++ b/shells.py
@@ -1536,8 +1536,9 @@ def get_max_dr_dzright_dzleft(self):
         dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
         dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
-        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
-        dr       = min(dr_sr, dr_edge)
+#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dr       = min(dr_sr, dr_edge)
+        dr = dr_sr
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1590,8 +1591,9 @@ def get_max_dr_dzright_dzleft(self):
         dz_right = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         dz_left  = dz_right
         dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
-        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
-        dr       = min(dr_sr, dr_edge)
+#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dr       = min(dr_sr, dr_edge)
+        dr = dr_sr
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -1639,9 +1641,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = self.pid_particle_pair[1].radius
-        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-        dz_right      = min(dz_right_sr, dz_right_edge)
+#        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_right      = dz_right_sr
         dz_left       = dz_right
         return dr, dz_right, dz_left
 
@@ -1744,9 +1747,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-        dz_right      = min(dz_right_sr, dz_right_edge)
+#        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_right      = dz_right_sr
         dz_left       = dz_right
         return dr, dz_right, dz_left
 
@@ -1802,7 +1806,7 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved
         dr_sr    = (self.get_searchradius()/math.sqrt(2))
-        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dr_edge  = self.min_dist_proj_to_edge
         dr       = min(dr_sr, dr_edge)
         dz_right = dr + self.particle_surface_distance          # Note that we assume that dr >> particle_surface_distance        
         dz_left  = self.pid_particle_pair[1].radius             # so that the cylinder always fits inside the search_radius
@@ -1856,7 +1860,7 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         # TODO clarify
-        dz_right_edge = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
+        dz_right_edge = self.min_dist_proj_to_edge
         dz_right_sr   = ((-(self.particle_surface_distance + self.target_structure.shape.radius) + \
                        math.sqrt(2*(self.get_searchradius()**2) - (self.particle_surface_distance + self.target_structure.shape.radius)**2)) / 2.0)
         dz_right      = min(dz_right_sr, dz_right_edge)
@@ -1976,9 +1980,10 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint())
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-        dz_right      = min(dz_right_sr, dz_right_edge)
+#        dz_right      = min(dz_right_sr, dz_right_edge)
+        dz_right      = dz_right_sr
         dz_left       = dz_right
         return dr, dz_right, dz_left
 
@@ -2091,8 +2096,9 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved
         dr_sr    = self.get_searchradius()/math.sqrt(2)
-        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
-        dr       = min(dr_sr, dr_edge)
+#        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dr       = min(dr_sr, dr_edge)
+        dr       = dr_sr
 
         dz_left  = self.pid_particle_pair1[1].radius
 

From b32bf2ff0e102ce5656abcf6fe6bf23598804510 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 14:53:26 +0200
Subject: [PATCH 0935/1541] removed 'structure' as argument to the
 'apply_boundary' method and made method availble in Python.

---
 Multi.hpp                     |  5 ++---
 ParticleContainer.hpp         |  3 +--
 ParticleContainerBase.hpp     |  4 ++--
 Transaction.hpp               |  5 ++---
 binding/ParticleContainer.hpp |  8 +++++---
 newBDPropagator.hpp           | 12 +++++-------
 6 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 0f4db054..d6a1911e 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -267,10 +267,9 @@ class MultiParticleContainer
         return world_.apply_boundary(v);
     }
 
-    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<const structure_type> structure) const
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id) const
     {
-        return world_.apply_boundary(pos_struct_id, structure);
+        return world_.apply_boundary(pos_struct_id);
     }
 
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 84cb61bf..6aab321b 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -151,8 +151,7 @@ class ParticleContainer
 
     virtual length_type apply_boundary(length_type const& v) const = 0;
 
-    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<const structure_type> structure) const = 0;
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id) const = 0;
 
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const = 0;
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 9e3d2284..a5565ece 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -197,10 +197,10 @@ class ParticleContainerBase
     //  as an argument (see for example PlanarSurface.hpp, NOT surface.hpp)
     // -Use this fully defined type to call the right function through the template method 'apply_boundary' of the StructureContainer.
     //  (See StructureContainer.hpp)
-    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<const structure_type> structure) const
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id) const
     {
         // cyclic transpose the position with the structure
+        const boost::shared_ptr<const structure_type> structure (get_structure(pos_struct_id.second));
         const position_structid_pair_type cyc_pos_struct_id (std::make_pair(cyclic_transpose(pos_struct_id.first, structure->position()),
                                                                             pos_struct_id.second));
 
diff --git a/Transaction.hpp b/Transaction.hpp
index e9e4968e..1e0ef2a9 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -321,10 +321,9 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
         return pc_.apply_boundary(v);
     }
 
-    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<const structure_type> structure) const
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id) const
     {
-        return pc_.apply_boundary(pos_struct_id, structure);
+        return pc_.apply_boundary(pos_struct_id);
     }
 
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 742f927c..45aaf331 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -578,10 +578,9 @@ class ParticleContainerWrapper
         return py_wrapper_type::get_override("apply_boundary")(v);
     }
 
-    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
-                                                       const boost::shared_ptr<const structure_type> structure) const
+    virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id) const
     {
-        return py_wrapper_type::get_override("apply_boundary")(pos_struct_id, structure);
+        return py_wrapper_type::get_override("apply_boundary")(pos_struct_id);
     }
 
     virtual position_type cyclic_transpose(position_type const& p0, position_type const& p1) const
@@ -616,6 +615,7 @@ inline boost::python::objects::class_base register_particle_container_class(
     peer::converters::register_tuple_converter<typename impl_type::structure_id_pair>();
     peer::converters::register_tuple_converter<typename impl_type::particle_id_pair_and_distance>();
     peer::converters::register_tuple_converter<typename impl_type::structure_id_pair_and_distance>();
+    peer::converters::register_tuple_converter<typename impl_type::position_structid_pair_type>();
 
     // register the converters that are defined above (not sure what this does)
     particle_id_pair_and_distance_list_converter<typename impl_type::particle_id_pair_and_distance_list>::__register();
@@ -663,8 +663,10 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("distance", pure_virtual(&impl_type::distance))
         .def("apply_boundary", pure_virtual((typename impl_type::position_type(impl_type::*)(typename impl_type::position_type const&) const)&impl_type::apply_boundary))
         .def("apply_boundary", pure_virtual((typename impl_type::length_type(impl_type::*)(typename impl_type::length_type const&) const)&impl_type::apply_boundary))
+        .def("apply_boundary", pure_virtual((typename impl_type::position_structid_pair_type(impl_type::*)(typename impl_type::position_structid_pair_type const&) const)&impl_type::apply_boundary))
         .def("cyclic_transpose", pure_virtual((typename impl_type::position_type(impl_type::*)(typename impl_type::position_type const&, typename impl_type::position_type const&) const)&impl_type::cyclic_transpose))
         .def("cyclic_transpose", pure_virtual((typename impl_type::length_type(impl_type::*)(typename impl_type::length_type const&, typename impl_type::length_type const&) const)&impl_type::cyclic_transpose))
+//        .def("cyclic_transpose", pure_virtual((typename impl_type::position_structid_pair_type(impl_type::*)(typename impl_type::position_structid_pair_type const&, typename impl_type::structure_id_pair const&) const)&impl_type::cyclic_transpose))
         .def("__contains__", pure_virtual(&impl_type::has_particle))
         .def("__iter__", pure_virtual(&impl_type::get_particles),
                 return_value_policy<return_by_value>())
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b86d4cd4..cfe2939d 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -147,8 +147,7 @@ class newBDPropagator
                                                                             std::sqrt(2.0 * pp_species.D() * dt_),
                                                                             rng_) );
 
-            const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos, displacement), old_struct_id),
-                                                                              pp_structure));
+            const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos, displacement), old_struct_id )));
             new_pos = pos_structid.first;
             new_structure_id = pos_structid.second;
         }
@@ -517,8 +516,8 @@ class newBDPropagator
                             // TODO clean this up
                             const boost::shared_ptr<const structure_type> prod0_structure(reactant_structure);
                             const boost::shared_ptr<const structure_type> prod1_structure(tx_.get_structure(prod1_struct_id));
-                            const position_structid_pair_type pos_structid0 (tx_.apply_boundary( std::make_pair(pos0pos1.second, prod1_struct_id), prod1_structure ));
-                            const position_structid_pair_type pos_structid1 (tx_.apply_boundary( std::make_pair(pos0pos1.first,  prod0_struct_id), prod0_structure ));
+                            const position_structid_pair_type pos_structid0 (tx_.apply_boundary( std::make_pair(pos0pos1.second, prod1_struct_id) ));
+                            const position_structid_pair_type pos_structid1 (tx_.apply_boundary( std::make_pair(pos0pos1.first,  prod0_struct_id) ));
                             pos0pos1_pair = std::make_pair(pos_structid0, pos_structid1);
 
 
@@ -700,7 +699,7 @@ class newBDPropagator
                         {
                             if (reactant0_structure_id != reactant1_structure_id)
                             {
-                                const position_structid_pair_type bla (tx_.apply_boundary(std::make_pair(product_pos, reactant0_structure_id), reactant0_structure));
+                                const position_structid_pair_type bla (tx_.apply_boundary(std::make_pair(product_pos, reactant0_structure_id)));
                                 // deflect the product coordinate and get right structure_id.
                                 product_pos = bla.first;
                                 product_structure_id = bla.second;
@@ -873,8 +872,7 @@ class newBDPropagator
 
             const position_type displacement( old_structure->bd_displacement(species.v() * dt_, std::sqrt(2.0 * species.D() * dt_), rng_) );
 
-            const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos_struct_id.first, displacement), old_pos_struct_id.second),
-                                                                               old_structure));
+            const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos_struct_id.first, displacement), old_pos_struct_id.second) ));
             new_pos = pos_structid.first;
             new_structure_id = pos_structid.second;
 

From 8b7af66b79623f3981105b91e802e623a7322e0c Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 17:13:40 +0200
Subject: [PATCH 0936/1541] modified signature of 'cyclic_transpose' and made
 method available in Python

---
 Multi.hpp                     | 2 +-
 ParticleContainer.hpp         | 2 +-
 ParticleContainerBase.hpp     | 6 +++---
 Transaction.hpp               | 2 +-
 binding/ParticleContainer.hpp | 4 ++--
 newBDPropagator.hpp           | 2 +-
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index d6a1911e..82585f6d 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -283,7 +283,7 @@ class MultiParticleContainer
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<const structure_type> structure) const
+                                                         structure_type const& structure) const
     {
         return world_.cyclic_transpose(pos_struct_id, structure);
     }
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 6aab321b..5bf5c44e 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -158,7 +158,7 @@ class ParticleContainer
     virtual length_type cyclic_transpose(length_type const& p0, length_type const& p1) const = 0;
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<const structure_type> structure) const = 0;
+                                                         structure_type const& structure) const = 0;
 
 };
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index a5565ece..f11d9881 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -222,11 +222,11 @@ class ParticleContainerBase
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<const structure_type> structure) const
+                                                         structure_type const& structure) const
     {
-        const position_structid_pair_type cyc_pos_struct_id (std::make_pair(cyclic_transpose(pos_struct_id.first, structure->position()),
+        const position_structid_pair_type cyc_pos_struct_id (std::make_pair(cyclic_transpose(pos_struct_id.first, structure.position()),
                                                                             pos_struct_id.second));
-        return structure->cyclic_transpose(cyc_pos_struct_id, structures_);
+        return structure.cyclic_transpose(cyc_pos_struct_id, structures_);
     }
 
     // THIS SEEMS STRANGE TO PUT THIS HERE. 
diff --git a/Transaction.hpp b/Transaction.hpp
index 1e0ef2a9..fcd3cf53 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -337,7 +337,7 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<const structure_type> structure) const
+                                                         structure_type const& structure) const
     {
         return pc_.cyclic_transpose(pos_struct_id, structure);
     }
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 45aaf331..3aa41e80 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -594,7 +594,7 @@ class ParticleContainerWrapper
     }
 
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
-                                                         const boost::shared_ptr<const structure_type> structure) const
+                                                         structure_type const& structure) const
     {
         return py_wrapper_type::get_override("cyclic_transpose")(pos_struct_id, structure);
     }
@@ -666,7 +666,7 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("apply_boundary", pure_virtual((typename impl_type::position_structid_pair_type(impl_type::*)(typename impl_type::position_structid_pair_type const&) const)&impl_type::apply_boundary))
         .def("cyclic_transpose", pure_virtual((typename impl_type::position_type(impl_type::*)(typename impl_type::position_type const&, typename impl_type::position_type const&) const)&impl_type::cyclic_transpose))
         .def("cyclic_transpose", pure_virtual((typename impl_type::length_type(impl_type::*)(typename impl_type::length_type const&, typename impl_type::length_type const&) const)&impl_type::cyclic_transpose))
-//        .def("cyclic_transpose", pure_virtual((typename impl_type::position_structid_pair_type(impl_type::*)(typename impl_type::position_structid_pair_type const&, typename impl_type::structure_id_pair const&) const)&impl_type::cyclic_transpose))
+        .def("cyclic_transpose", pure_virtual((typename impl_type::position_structid_pair_type(impl_type::*)(typename impl_type::position_structid_pair_type const&, typename impl_type::structure_type const&) const)&impl_type::cyclic_transpose))
         .def("__contains__", pure_virtual(&impl_type::has_particle))
         .def("__iter__", pure_virtual(&impl_type::get_particles),
                 return_value_policy<return_by_value>())
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index cfe2939d..4a336433 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -649,7 +649,7 @@ class newBDPropagator
                             (reactant0_structure_id != reactant1_structure_id))
                         {
                             const position_structid_pair_type pos_cyclic1 (tx_.cyclic_transpose(std::make_pair(reactant1_pos, reactant1_structure_id),
-                                                                                                reactant0_structure));
+                                                                                                (*reactant0_structure) ));
                             reactant1_pos = pos_cyclic1.first;
                         }
 

From 7d0f7ba45eb62903bf9bae7c4022a3a3e30a416b Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 17:17:56 +0200
Subject: [PATCH 0937/1541] removed some useless code.

---
 PlanarSurface.hpp | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 1348befd..c0d35566 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -111,10 +111,6 @@ class PlanarSurface
         Real X( rng.uniform(0.,1.) );
         length_type diss_vec_length( X*rl );
 
-//        position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
-//
-//        unit_z = normalize ( unit_z );
-
         return multiply( base_type::shape().unit_z(), (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
     }
 

From d462caa341780b54f29d7ab8db5ba0b605284b6e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 25 May 2012 17:22:59 +0200
Subject: [PATCH 0938/1541] Further cleanup and debugging of MixedPair1DCap

---
 egfrd.py  |   6 +--
 pair.py   |  67 ++++++++++++++++--------
 shells.py | 150 +++++++++++++++++++++++++++++++++++++++++-------------
 3 files changed, 163 insertions(+), 60 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6aeee84c..6e4ae686 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -146,9 +146,9 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
         return MixedPair2D3DtestShell(single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
         return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
-    elif (isinstance(single1.structure, DiskSurface) and isinstance(single2.structure, CylindricalSurface)):
+    elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
         return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
-    elif (isinstance(single2.structure, DiskSurface) and isinstance(single1.structure, CylindricalSurface)):
+    elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):
         return MixedPair1DCaptestShell(single2, single1, geometrycontainer, domains)
     else:
         # another mixed pair was supposed to be formed -> unsupported
@@ -2601,7 +2601,7 @@ def check_domain(self, domain):
             # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
             ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
             associated = [domain.origin_structure.id, domain.target_structure.id]
-        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
+        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D) or isinstance(domain, MixedPair1DCap):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.origin_structure.id, domain.target_structure.id]
diff --git a/pair.py b/pair.py
index cc978a1b..59164b6b 100644
--- a/pair.py
+++ b/pair.py
@@ -1026,6 +1026,13 @@ def calc_r_scaling_factor(cls, D1, D2):
 
 
 class MixedPair1DCap(Pair, hasCylindricalShell):
+    # This domain is for the interaction of a particle drifting and diffusing on a cylinder (1D particle)
+    # and another (static) particle which is bound to a cap of the same cylinder.
+    # Since the cap particle is immobile, we effectively have a one-particle problem
+    # and the CoM is not used. The displacement of the 1D particle is sampled via iv_greens_function.
+    # However, we have to make this a pair domain because we have two particles involved which
+    # can decay (fire single reactions) independently.
+    # TODO: Is the new pos. of the cap particle sampled correctly in case of a decay event?
 
     def __init__(self, domain_id, shell_id, testShell, rrs):
 
@@ -1034,29 +1041,46 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         Pair.__init__(self, domain_id, shell_id, rrs)
 
         assert isinstance(self.testShell, MixedPair1DCaptestShell)
-        self.cap_structure = self.testShell.cap_structure # equal to self.structure1
-        self.structure1D   = self.testShell.structure1D   # equal to self.structure2
 
-        # NOTE: self.pid_particle_pair1 is the cap particle
-        # and should be immobile
-        assert self.pid_particle_pair1[1].D == 0
-        assert self.pid_particle_pair1[1].v == 0
+        # Some useful definitions:
+        self.particle1D    = self.testShell.particle1D
+        self.structure1D   = self.testShell.structure1D
+        self.cap_particle  = self.testShell.cap_particle
+        self.cap_structure = self.testShell.cap_structure
+
+        # The latter is defined for completeness and used by check_domain() in egfrd.py:
+        self.origin_structure = self.structure1D
+        self.target_structure = self.cap_structure
+
+        # The cap_particle should be immobile; check to be sure:
+        assert self.cap_particle.D == 0
+        assert self.cap_particle.v == 0
+        # D_r and D_R are inherited from Pair class;
+        # This results in D_r = particle1D.D and D_R = 0
 
         self.LD_MAX = numpy.inf # TODO what is that for?
 
-    def get_shell_size(self): # TODO Is that even used?
+    def get_shell_size(self):   # TODO Is that even used?
         return self.shell.shape.half_length
 
+    def get_a_r(self):
+      
+        ref_pt = self.testShell.get_referencepoint()
+        assert ( all(self.cap_structure.shape.position - ref_pt == 0) )
+
+        return abs(self.testShell.dz_right) - self.particle1D.radius
+    a_r = property(get_a_r)
+    a_R = property(get_a_r)
+
     def get_v_tot(self):
         # 'direction' signifies the direction of the IV with respect to the surface unit_z
-        # (which defines the direction of positive drift)
-        # Assuming self.pid_particle_pair1[1].v == 0 here
+        # (which defines the direction of positive drift).
+        # Assuming self.pid_particle_pair2[1].v == 0 here, i.e. relative drift = drift of 1D part.
         direction = cmp(numpy.dot (self.iv, self.structure1D.shape.unit_z), 0)
-        return self.pid_particle_pair2[1].v * direction
+        return self.particle1D.v * direction
 
     # NOTE the v_tot and v_r are now positive in the direction of the IV!
-    v_tot = property(get_v_tot)
-    
+    v_tot = property(get_v_tot)    
     v_r = property(get_v_tot)
 
     def get_v_R(self):
@@ -1065,9 +1089,8 @@ def get_v_R(self):
     v_R = property(get_v_R)
 
     def com_greens_function(self):
-        # The Green's function used should be irrelevant, because D_R=0 and v_R=0
+        # The Green's function used is largely irrelevant, because D_R=0 and v_R=0        
         return GreensFunction1DAbsAbs(self.D_R, self.v_R, 0.0, -self.a_R, self.a_R)
-        # TODO Plug in D_R = 0 and v_R = 0 directly here?
 
     def iv_greens_function(self, r0):
         return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
@@ -1078,17 +1101,19 @@ def choose_pair_greens_function(self, r0, t):
 
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
-    # here we assume that the com and iv are really in the structure and no adjustments have to be
-    # made
+    # here we assume that structure1 = structure1D and structure2 = cap_structure
+    # and that com has been correctly initialized with the initial (and constant) position
+    # of the cap particle.
 
-        pos1 = self.pid_particle_pair1[1].position # cap particle stays in place in this case
-        pos2 = pos1 + iv
+        pos2 = com          # cap particle (no. 2) stays in place
+        pos1 = pos2 - iv    # IV always points from particle1 to particle2      
 
         return pos1, pos2, structure1.id, structure2.id
+        # TODO Does this give the correct new positions in case of a single reaction of cap_particle ?
 
-    def create_com_vector(self, z):
-        # The CoM vector is not relevant for this domain, thus...
-        pass
+    def create_com_vector(self, z):        
+    # This returns the displacement of the com, which is zero here.
+        return 0.0
 
     def create_interparticle_vector(self, gf, r, dt, r0, old_iv): 
         if __debug__:
diff --git a/shells.py b/shells.py
index c42c96fc..7d6b2752 100755
--- a/shells.py
+++ b/shells.py
@@ -369,23 +369,55 @@ def get_scaling_factor(self):
 
 class testMixedPair1DCap(testPair):
 
-    def __init__(self, cap_single, single1D):
+    def __init__(self, single1D, cap_single):
 
         if __debug__: 
-                assert isinstance(cap_single.structure, DiskSurface)
                 assert isinstance(single1D.structure, CylindricalSurface) 
-        testSimplePair.__init__(self, cap_single, single1D)
-          # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
-          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
-
-        # for clarity:
-        self.cap_structure = cap_single.structure  # equal to self.structure1
-        self.structure1D   = single1D.structure    # equal to self.structure2  
+                assert isinstance(cap_single.structure, DiskSurface)
+        testPair.__init__(self, single1D, cap_single)
+          # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 1D particle
+          #              and self.single2/self.pid_particle_pair2/self.structure2 for the cap particle
+
+        # for clarity define:
+        self.single1D       = single1D
+        self.particle1D     = self.pid_particle_pair1[1]
+        self.structure1D    = single1D.structure    # equal to self.structure1  
+        self.cap_single     = cap_single
+        self.cap_particle   = self.pid_particle_pair2[1]        
+        self.cap_structure  = cap_single.structure  # equal to self.structure2
+        # This will be inherited by MixedPair1DCaptestShell and MixedPair1DCap.
+        # Note that we have to use pid_particle_pair1(2) in the methods defined below
+        # because they are called at the initialization of testPair().
 
         # Make sure cap particle is immobile; this is required for testSimplePair routines
         # to give the proper results for this case.
-        assert self.pid_particle_pair1[1].D == 0
-        assert self.pid_particle_pair1[1].v == 0
+        assert self.cap_particle.D == 0
+        assert self.cap_particle.v == 0
+
+    def get_sigma(self):
+        # Copied from SimplePair
+        radius1 = self.pid_particle_pair1[1].radius
+        radius2 = self.pid_particle_pair2[1].radius
+        return radius1 + radius2
+    sigma = property(get_sigma)
+
+    def do_transform(self):
+
+        pos1 = self.pid_particle_pair1[1].position
+        pos2 = self.pid_particle_pair2[1].position
+        D_1 = self.pid_particle_pair1[1].D
+        D_2 = self.pid_particle_pair2[1].D
+
+        # In the MixedPair1DCap only the 1D particle moves. We therefore use
+        # iv to sample its position and com for the position of the static
+        # cap particle; this is initialized here:
+        com = pos2
+        com = self.world.apply_boundary(pos2)
+        
+        pos2t = self.world.cyclic_transpose(pos2, pos1)
+        iv = pos2t - pos1
+
+        return com, iv
 
 class testPlanarSurfaceTransitionPair(testPair):
 
@@ -1632,7 +1664,13 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
-        # initialize scaling parameters
+        # Initialize scaling parameters
+        # - the reference point is at the cap disk position
+        # - the right scaling point is for the scaling "inwards", i.e. onto the rod
+        # - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
+        # - dz_left stays constant and is equal to the cap-bound particle radius
+        # - dz_right can be scaled, minimum is set accordingly
+        # - dr stays constant and is determined by the maximal particle radius involved
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
         self.r0_right   = self.pid_particle_pair[1].radius
@@ -1758,9 +1796,9 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             raise testShellError('(PlanarSurfaceInteraction). %s' %
                                  (str(e)))
 
-
     def get_orientation_vector(self):
-        return self.reference_vector      # calculated in the __init__ of testInteractionSingle
+        return self.reference_vector     # from testInteractionSingle; reference vector always points from the
+                                         # particle position projected onto the target surface towards particle pos.
 
     def get_searchpoint(self):
 #        return self.pid_particle_pair[1].position   # since the shell is scaled equally in all directions
@@ -1851,7 +1889,13 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
-        # initialize scaling parameters
+        # Initialize scaling parameters
+        # - the reference point is at the cap disk position
+        # - the right scaling point is for the scaling "inwards", i.e. onto the rod
+        # - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
+        # - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
+        # - dz_right can be scaled, minimum is set accordingly
+        # - dr stays constant and is determined by the maximal particle radius involved
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
         self.r0_right   = self.pid_particle_pair[1].radius
@@ -1875,8 +1919,8 @@ def get_orientation_vector(self):
         # The orientation vector is collinear with the parent cylinder axis and
         # pointing "inwards", i.e. towards the center point of the parent cylinder
         # TODO Check that this works properly!
-        return self.reference_vector     # reference vector always points from the particle position
-                                         # projected onto the target surface towards particle pos.
+        return self.reference_vector     # from testInteractionSingle; reference vector always points from the
+                                         # particle position projected onto the target surface towards particle pos.
 
     def get_searchpoint(self):
         return self.pid_particle_pair[1].position
@@ -2136,27 +2180,36 @@ def apply_safety(self, r, z_right, z_left):
 
 class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):
 
-    def __init__(self, cap_single, single1D, target_structure, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?
+    def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testMixedPair1DCap.__init__(self, cap_single, single1D)
-
-        # initialize scaling parameters
+        testMixedPair1DCap.__init__(self, single1D, cap_single)
+
+        # NOTE: The following is already defined by testMixedPair1DCap:
+        # - self.single1D, self.structure1D, self.particle1D
+        # - self.cap_single, self.cap_structure, self.cap_particle
+
+        # Initialize scaling parameters
+        # - the reference point is at the cap disk position
+        # - the right scaling point is for the scaling "inwards", i.e. onto the rod
+        # - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
+        # - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
+        # - dz_right can be scaled, minimum is set accordingly
+        # - dr stays constant and is determined by the maximal particle radius involved
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        self.r0_right   = max(self.cap_particle.radius, self.particle1D.radius)
         self.z0_right   = 0.0
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
-        self.r0_left    = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)      # TODO put to zero?
-        self.z0_left    = self.pid_particle_pair1[1].radius * SINGLE_SHELL_FACTOR
-          # pid_particle_pair1[1] is the cap-bound particle
+        self.r0_left    = max(self.cap_particle.radius, self.particle1D.radius)      # TODO put to zero?
+        self.z0_left    = self.cap_particle.radius * SINGLE_SHELL_FACTOR
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id]) # TODO Do we need target_structure (for the ignore list)?
+                            self.determine_possible_shell(self.structure1D.id, [self.single1D.domain_id, self.cap_single.domain_id], [self.cap_structure.id])
         except ShellmakingError as e:
             raise testShellError('(MixedPair1DCap). %s' %
                                  (str(e)))
@@ -2164,30 +2217,55 @@ def __init__(self, cap_single, single1D, target_structure, geometrycontainer, do
     def get_orientation_vector(self):
         # The orientation vector is collinear with the parent cylinder axis and
         # pointing "inwards", i.e. towards the center point of the parent cylinder
-        # TODO Check that this works properly!
-        return self.reference_vector     # reference vector always points from the particle position
-                                         # projected onto the target surface towards particle pos.
+        direction = cmp(numpy.dot(self.structure1D.shape.unit_z, self.structure1D.shape.position - self.cap_structure.shape.position), 0)
+        return  direction * self.structure1D.shape.unit_z
 
     def get_searchpoint(self):
-        return self.com
+        return self.particle1D.position
 
-    def get_referencepoint(self):
-        return self.com
+    def get_referencepoint(self):        
+        return self.cap_structure.shape.position
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_left  = self.pid_particle_pair1[1].radius * SINGLE_SHELL_FACTOR
+        dr       = max(self.particle1D.radius, self.cap_particle.radius)
+        dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR
         dz_right = self.get_min_pair_size() # TODO make sure this does the right thing!
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        dr       = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-        dz_left  = self.pid_particle_pair1[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dr       = max(self.particle1D.radius, self.cap_particle.radius)
+        dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left
 
+    def get_min_pair_size(self):
+        # This calculates the minimal 'size' of a simple pair.
+        # Note that the 'size' is interpreted differently dependent on the type of pair. When the pair is a
+        # SphericalPair          -> size = radius
+        # PlanarSurfacePair      -> size = radius
+        # CylindricalSurfacePair -> size = half_length
+
+        D_1 = self.particle1D.D
+        D_2 = self.cap_particle.D
+        radius1 = self.particle1D.radius
+        radius2 = self.cap_particle.radius
+
+        dist_from_com1 = self.r0 * D_1 / self.D_tot      # particle distance from CoM
+        dist_from_com2 = self.r0 * D_2 / self.D_tot
+        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
+        iv_shell_size2 = dist_from_com2 + radius2
+
+        # also fix the minimum shellsize for the CoM domain
+        com_shell_size = max(radius1, radius2)
+
+        # calculate total radii including the margin for the burst volume for the particles
+        shell_size = max(iv_shell_size1 + com_shell_size + radius1 * SINGLE_SHELL_FACTOR,
+                         iv_shell_size2 + com_shell_size + radius2 * SINGLE_SHELL_FACTOR)
+
+        return shell_size
+
 #####
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):
\ No newline at end of file

From e14a7b8ecc60bf2c24dc2656da5bb241affbc81f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 19:18:39 +0200
Subject: [PATCH 0939/1541] Two things: -call the structure version of
 'apply_boundary' after determining new positions of particles. -allow domains
 that are in a structure to extend out of the structure, but interaction and
 MixedPair domains not.

---
 egfrd.py    |  6 +++---
 gfrdbase.py |  7 ++++---
 shells.py   | 28 ++++++++++++++++------------
 3 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index cb7a73e5..c83867b4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1802,7 +1802,7 @@ def process_single_event(self, single, ignore):
             if single.getD() != 0 and single.dt > 0.0:
                 # If the particle had the possibility to diffuse
                 newpos, struct_id = single.draw_new_position(single.dt, single.event_type)
-                newpos = self.world.apply_boundary(newpos)
+                newpos, struct_id = self.world.apply_boundary((newpos,struct_id))
             else:
                 # no change in position has taken place
                 newpos    = pid_particle_pair[1].position
@@ -1933,8 +1933,8 @@ def process_pair_event(self, pair, ignore):
         ### 3.1 Get new position and current structures of particles
         if pair.dt > 0.0:
             newpos1, newpos2, struct1_id, struct2_id = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
-            newpos1 = self.world.apply_boundary(newpos1)
-            newpos2 = self.world.apply_boundary(newpos2)
+            newpos1, struct1_id = self.world.apply_boundary((newpos1, struct1_id))
+            newpos2, struct2_id = self.world.apply_boundary((newpos2, struct2_id))
 
             # check that the particles do not overlap with any other particles in the world
             assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
diff --git a/gfrdbase.py b/gfrdbase.py
index c90b8ca1..f659dc73 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -260,16 +260,16 @@ def throw_in_particles(world, sid, n):
         myrandom.shuffle(structure_list)
         structure = world.get_structure(structure_list[0])
         position = structure.random_position(myrandom.rng)
-        position = world.apply_boundary(position)
+        position, structure_id = world.apply_boundary((position, structure.id))
 
         # Check overlap. TODO put in 'if' statement for improved efficiency?
         particle_overlaps = world.check_overlap((position, species.radius))
         surface_overlaps  = world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
-                                                        position, structure.id, species.radius)
+                                                        position, structure_id, species.radius)
 
         if (not particle_overlaps) and (not surface_overlaps):
             # All checks passed. Create particle.
-            p = world.new_particle(sid, structure.id, position)
+            p = world.new_particle(sid, structure_id, position)
             i += 1
             if __debug__:
                 log.info('particle accepted: (%s,\n %s)' % (p[0], p[1]))
@@ -337,6 +337,7 @@ def place_particle(world, sid, position):
         log.info('\n\tplacing particle of type %s to structure \"%s\" at position %s' %
                  (name, world.get_structure(structure_id).name, position))
 
+    position, structure_id = world.apply_boundary((position, structure_id))
     particle = world.new_particle(sid, structure_id, position)
 
     if __debug__:
diff --git a/shells.py b/shells.py
index 6713baca..c2b70a44 100755
--- a/shells.py
+++ b/shells.py
@@ -346,9 +346,13 @@ def do_transform(self):
 
         # and then projected onto the plane to make sure the CoM is in the surface
         com = self.world.cyclic_transpose(com, self.structure2D.shape.position)
-        com, _ = self.structure2D.project_point (com)
-        com = self.world.apply_boundary(com)
+        com, (_, dist) = self.structure2D.project_point (com)
+        if dist >= 0:
+            raise testShellError('(testMixedPair2D3D). Projected point of CoM is not in surface.')
+        else:
+            self.min_dist_proj_to_edge = -dist      # FIXME this is a bit of a hack, find better place to put this.
 
+        com = self.world.apply_boundary(com)
 
         # calculate the interparticle vector
         pos2t = self.world.cyclic_transpose(pos2, pos1)
@@ -1536,7 +1540,7 @@ def get_max_dr_dzright_dzleft(self):
         dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
         dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
-#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint()) # TODO rethink this
 #        dr       = min(dr_sr, dr_edge)
         dr = dr_sr
         return dr, dz_right, dz_left
@@ -1591,7 +1595,7 @@ def get_max_dr_dzright_dzleft(self):
         dz_right = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
         dz_left  = dz_right
         dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
-#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint()) # TODO rethink this
 #        dr       = min(dr_sr, dr_edge)
         dr = dr_sr
         return dr, dz_right, dz_left
@@ -1641,7 +1645,7 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = self.pid_particle_pair[1].radius
-#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink this
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
 #        dz_right      = min(dz_right_sr, dz_right_edge)
         dz_right      = dz_right_sr
@@ -1683,6 +1687,7 @@ def get_referencepoint(self):
         return self.pid_particle_pair[1].position
 
     def get_min_dr_dzright_dzleft(self):
+        # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
         dr       = self.pid_particle_pair[1].radius
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) #  TODO Use SINGLE_SHELL_FACTOR instead?
         dz_left  = dz_right
@@ -1696,7 +1701,7 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
-        return r, z_right/SAFETY, z_left/SAFETY
+        return r, z_right/SAFETY, z_left/SAFETY     # TODO this should just be r, z_right, z_left
 
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, testSimplePair):
@@ -1747,7 +1752,7 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
-#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
 #        dz_right      = min(dz_right_sr, dz_right_edge)
         dz_right      = dz_right_sr
@@ -1919,6 +1924,7 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        # TODO include max distance to other side of rod?
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
         return dr, dz_right, dz_left
 
@@ -1980,7 +1986,7 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.pid_particle_pair[1].radius
-#        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint())
+#        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint()) # TODO rethink
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
 #        dz_right      = min(dz_right_sr, dz_right_edge)
         dz_right      = dz_right_sr
@@ -2096,10 +2102,8 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         # TODO this can be improved
         dr_sr    = self.get_searchradius()/math.sqrt(2)
-#        dr_edge  = self.target_structure.min_dist_proj_to_edge(self.get_referencepoint())
-#        dr       = min(dr_sr, dr_edge)
-        dr       = dr_sr
-
+        dr_edge  = self.min_dist_proj_to_edge
+        dr       = min(dr_sr, dr_edge)
         dz_left  = self.pid_particle_pair1[1].radius
 
         # now adjust dz_right such that they obey the scaling laws and are still with the search_radius

From 25d87765414620701dc2ca755ae2ca3ac930f663 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 25 May 2012 19:40:54 +0200
Subject: [PATCH 0940/1541] forgotten update when changing projected_point to
 project_point

---
 Disk.hpp              | 2 +-
 binding/Structure.hpp | 2 +-
 pair.py               | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Disk.hpp b/Disk.hpp
index 56d0d58d..ab3f4c2f 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -132,7 +132,7 @@ project_point(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
                            std::make_pair(z, r - obj.radius()) );
 }
 
-// The same as in case of the plane: projected_point_on_surface = projected_point
+// The same as in case of the plane: project_point_on_surface = project_point
 template<typename T_>
 inline std::pair<typename Disk<T_>::position_type,
                  std::pair<typename Disk<T_>::length_type,
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index b6e8ab13..f17a894f 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -15,7 +15,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
     typedef Timpl impl_type;
 
     // registering converters from standard boost templates
-    // registers the projected_point/projected_distance tuple defined in ../Structure.hpp
+    // registers the projected_point/(projected_distance, dist_to_edge) tuple defined in ../Structure.hpp
     peer::converters::register_tuple_converter<typename impl_type::projected_type>();
     peer::converters::register_tuple_converter<typename impl_type::components_pair_type>();
     peer::converters::register_tuple_converter<typename impl_type::position_flag_pair_type>();
diff --git a/pair.py b/pair.py
index fda3a0ab..f02fc6c9 100644
--- a/pair.py
+++ b/pair.py
@@ -622,8 +622,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # These components also are used to calculate the safety factor for
         # interparticle vector enlargement in case that the two particles
         # indeed are on two different planes.
-        _, pos1_orth = structure2.projected_point(pos1)
-        _, pos2_orth = structure2.projected_point(pos2)
+        _, (pos1_orth, _) = structure2.project_point(pos1)
+        _, (pos2_orth, _) = structure2.project_point(pos2)
 
         if( pos1_orth * pos2_orth < 0.0 ) :
             # The particles will end up on different planes, i.e.

From b4045ec8eee5c669098bb222d65f413611b5c78f Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 29 May 2012 11:42:34 +0200
Subject: [PATCH 0941/1541] replaced 'deflect_back' by 'cyclic_transpose' for a
 plane and disabled deflect_back functions.

---
 Box.hpp               | 4 ++--
 Cylinder.hpp          | 4 ++--
 Disk.hpp              | 4 ++--
 Plane.hpp             | 4 ++--
 Region.hpp            | 4 ++--
 Sphere.hpp            | 4 ++--
 Structure.hpp         | 2 +-
 Surface.hpp           | 4 ++--
 binding/Structure.hpp | 2 +-
 shells.py             | 3 ++-
 10 files changed, 18 insertions(+), 17 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 426c4581..8fc49132 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -315,7 +315,7 @@ deflect(Box<T_> const& obj,
     // For now it just returns original pos. + displacement. The changeflage = false.
     return std::make_pair( add(r0, d), false );
 }
-
+/*
 template<typename T_>
 inline typename Box<T_>::position_type
 deflect_back(Box<T_> const& obj,
@@ -325,7 +325,7 @@ deflect_back(Box<T_> const& obj,
     // Return the vector r without any changes
     return r;
 }
-
+*/
 template<typename T, typename Trng>
 inline typename Box<T>::position_type
 random_position(Box<T> const& shape, Trng& rng)
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 0bbdeb83..81f3a0dd 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -222,7 +222,7 @@ deflect(Cylinder<T_> const& obj,
     // For now it just returns original pos. + displacement. The changeflage = false.
     return std::make_pair( add(r0, d), false );
 }
-
+/*
 template<typename T_>
 inline typename Cylinder<T_>::position_type
 deflect_back(Cylinder<T_> const& obj,
@@ -232,7 +232,7 @@ deflect_back(Cylinder<T_> const& obj,
     // Return the vector r without any changes
     return r;
 }
-
+*/
 template<typename T, typename Trng>
 inline typename Cylinder<T>::position_type
 random_position(Cylinder<T> const& shape, Trng& rng)
diff --git a/Disk.hpp b/Disk.hpp
index ab3f4c2f..ee620a75 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -187,7 +187,7 @@ deflect(Disk<T_> const& obj,
     // For now it just returns original pos. + displacement. The changeflage = false.
     return std::make_pair( add(r0, d), false );
 }
-
+/*
 template<typename T_>
 inline typename Disk<T_>::position_type
 deflect_back(Disk<T_> const& obj,
@@ -197,7 +197,7 @@ deflect_back(Disk<T_> const& obj,
     // Return the vector r without any changes
     return r;
 }
-
+*/
 template<typename T, typename Trng>
 inline typename Disk<T>::position_type
 random_position(Disk<T> const& shape, Trng& rng)
diff --git a/Plane.hpp b/Plane.hpp
index 40d9fb81..dec3d91c 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -362,7 +362,7 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    // for now this returns the new position without changes
    return std::make_pair( new_pos, changeflag );
 }
-
+/*
 template<typename T_>
 inline typename Plane<T_>::position_type
 deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, typename Plane<T_>::position_type const& u_z)
@@ -400,7 +400,7 @@ deflect_back(Plane<T_> const& obj, typename Plane<T_>::position_type const& r, t
     
     return project_point(obj, r_new).first;
 }
-
+*/
 template<typename T, typename Trng>
 inline typename Plane<T>::position_type
 random_position(Plane<T> const& shape, Trng& rng)
diff --git a/Region.hpp b/Region.hpp
index 7e5e9ea6..07dd66de 100644
--- a/Region.hpp
+++ b/Region.hpp
@@ -120,12 +120,12 @@ class BasicRegionImpl: public Region<Ttraits_>
     {
         return ::deflect(shape(), pos0, displacement);
     }
-    
+/*    
     virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const
     {
         return ::deflect_back(shape(), pos, u_z);
     }
-
+*/
     // The constructor
     BasicRegionImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
         : base_type(name, sid, parent_struct_id), shape_(shape) {}
diff --git a/Sphere.hpp b/Sphere.hpp
index 4028df92..41d0de1c 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -128,7 +128,7 @@ deflect(Sphere<T_> const& obj, typename Sphere<T_>::position_type const& r0, typ
     // For now it just returns the new position. The changeflag = 0.
     return std::make_pair( add(r0, d), false );
 }
-
+/*
 template<typename T_>
 inline typename Sphere<T_>::position_type
 deflect_back(Sphere<T_> const& obj,
@@ -138,7 +138,7 @@ deflect_back(Sphere<T_> const& obj,
     // Return the vector r without any changes
     return r;
 }
-
+*/
 template<typename T_>
 inline Sphere<T_> const& shape(Sphere<T_> const& shape)
 {
diff --git a/Structure.hpp b/Structure.hpp
index 1edeb21a..c15d1779 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -125,7 +125,7 @@ class Structure
 
     // Methods used for edge crossing (only for the planes so far)    
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
-    virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const = 0;
+//    virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const = 0;
 
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const = 0;
diff --git a/Surface.hpp b/Surface.hpp
index 9812e187..e01afc84 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -126,12 +126,12 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     {
         return ::deflect(shape(), pos0, displacement);
     }
-    
+/*    
     virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const
     {
         return ::deflect_back(shape(), pos, u_z);
     }
-
+*/
     // Constructor
     BasicSurfaceImpl(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
         : base_type(name, sid, parent_struct_id), shape_(shape) {}
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index f17a894f..469b167c 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -48,7 +48,7 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("project_point", &impl_type::project_point)
         .def("deflect", &impl_type::deflect)
-        .def("deflect_back", &impl_type::deflect_back)
+//        .def("deflect_back", &impl_type::deflect_back)
         ;
 }
 
diff --git a/shells.py b/shells.py
index c2b70a44..f7f15675 100755
--- a/shells.py
+++ b/shells.py
@@ -424,7 +424,8 @@ def do_transform(self):
         # As an indermediate step project position of single2 into plane of single1 and add its
         # orthogonal component rotated by 90 deg. to transform the whole problem into a single 2D plane
         pos1 = self.pid_particle_pair1[1].position
-        pos2 = self.structure1.deflect_back(self.pid_particle_pair2[1].position, self.structure2.shape.unit_z)
+#        pos2 = self.structure1.deflect_back(self.pid_particle_pair2[1].position, self.structure2.shape.unit_z)
+        pos2, _ = self.world.cyclic_transpose((self.pid_particle_pair2[1].position, self.pid_particle_pair2[1].structure_id), self.structure1)
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 

From 1ee525e069c3dffc2a9f2a5b1c3307a92db749a8 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 29 May 2012 12:02:49 +0200
Subject: [PATCH 0942/1541] preparation to replacing 'deflect' by the more
 general 'apply_boundary'

---
 pair.py            | 4 ++--
 transitiontools.py | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pair.py b/pair.py
index f02fc6c9..99374c7b 100644
--- a/pair.py
+++ b/pair.py
@@ -522,7 +522,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         assert isinstance(testShell, PlanarSurfaceTransitionPairtestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        self.LD_MAX = numpy.inf # TODO was 20. Why?
+        self.LD_MAX = numpy.inf # TODO was 20. Why? Because of convergence issues! Maybe not really an issue here though
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
         
         self.structure1 = self.testShell.structure1
@@ -649,7 +649,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # bogus parameters for these by subtracting the center position of structure1 from pos1 and pos2.
         s1_ctr = structure1.shape.position
 
-        new_pos1, changeflag1 = structure2.deflect(s1_ctr, pos1 - s1_ctr)
+        new_pos1, changeflag1 = structure2.deflect(s1_ctr, pos1 - s1_ctr)   #TODO replace by world.apply_boundary
         new_pos2, changeflag2 = structure2.deflect(s1_ctr, pos2 - s1_ctr)
         
         # adjust the structure_ids of the particles
diff --git a/transitiontools.py b/transitiontools.py
index cceb7c8d..58294815 100644
--- a/transitiontools.py
+++ b/transitiontools.py
@@ -45,7 +45,7 @@ def __init__(self, testShell, start_position):
     def process_new_position_vector(self, old_pos, displacement):
                 
         # Construct the new position using the deflection function of the target surface            
-        new_pos, changeflag = self.target_structure.deflect(old_pos, displacement)        
+        new_pos, changeflag = self.target_structure.deflect(old_pos, displacement)       #TODO replace by world.apply_boundary 
                 
         if changeflag==0 :
             # The new position is still in the old surface;

From 381b0004d4845318a160c3d0e61a2518aaa989e6 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Tue, 29 May 2012 15:08:02 +0200
Subject: [PATCH 0943/1541] fixed 'apply_boundary' for planes such that a
 position 'in the corner' gets processed twice.

---
 StructureContainer.hpp | 112 ++++++++++++++++++++++-------------------
 1 file changed, 60 insertions(+), 52 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 47cf2eab..c84f2d95 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -377,7 +377,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     typedef typename plane_type::position_type              position_type;
 
     typedef std::pair<structure_id_type, position_type>     neighbor_id_vector_type;
-
+    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
     // and that the position is already transposed for the plane.
@@ -393,68 +393,76 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     position_type neighbor_plane_par;
     position_type neighbor_plane_inl;
 
-    if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
-         (-half_extends[1] < component_y) && ( component_y < half_extends[1]) )
+    if ( abs(component_x) <= half_extends[0] && abs(component_y) <= half_extends[1] )
     {
         // we are still in the plane (did not pass any of the boundaries)
         // don't have to do anything
         return pos_structure_id;
     }
-    else if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
-              (half_extends[1] < component_y) )
+    else
     {
-        // we are at the 'top' of the plane (side nr. 0)
-        // the 'vector' is the unit vector pointing from the edge between the two planes to the center of the plane
-        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 0));
+        // We are outside of the plane.
+        if ( half_extends[1]*abs(component_x) < half_extends[0]*abs(component_y) )
+        {
+            // Top or bottom (and may also be in one of the corners)
+            if ( half_extends[1] < component_y )
+            {
+                // we are at the 'top' of the plane (side nr. 0)
+                // the 'vector' is the unit vector pointing from the edge between the two planes to the center of the plane
+                const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 0));
+
+                new_id = neighbor_id_vector.first;
+                neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
+                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     half_extends[1]),
+                                         multiply(neighbor_id_vector.second, (component_y - half_extends[1]) ) );
+            }
+            else if ( component_y < -half_extends[1] )
+            {
+                // we are at the 'bottom' of the plane (side nr. 1)
+                const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 1));
 
-        new_id = neighbor_id_vector.first;
-        neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
-        neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     half_extends[1]),
-                                 multiply(neighbor_id_vector.second, (component_y - half_extends[1]) ) );
-    }
-    else if ( (-half_extends[0] < component_x) && ( component_x < half_extends[0]) &&
-              (component_y < -half_extends[1] ) )
-    {
-        // we are at the 'bottom' of the plane (side nr. 1)
-        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 1));
+                new_id = neighbor_id_vector.first;
+                neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
+                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     -half_extends[1] ),
+                                         multiply(neighbor_id_vector.second, (-component_y - half_extends[1]) ) );
+            }
+        }
+        else // half_extends[1]*abs(component_x) >= half_extends[0]*abs(component_y)
+        {
+            if ( component_x < -half_extends[0] )
+            {
+                // we are at the 'left' of the plane (side nr. 2)
+                const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 2));
 
-        new_id = neighbor_id_vector.first;
-        neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
-        neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     -half_extends[1] ),
-                                 multiply(neighbor_id_vector.second, (-component_y - half_extends[1]) ) );
-    }
-    else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
-              (component_x < -half_extends[0]) )
-    {
-        // we are at the 'left' of the plane (side nr. 2)
-        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 2));
+                new_id = neighbor_id_vector.first;
+                neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
+                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     -half_extends[0]),
+                                         multiply(neighbor_id_vector.second, (-component_x - half_extends[0]) ) );
+            }
+            else if ( half_extends[0] < component_x )
+            {
+                // we are at the 'right' of the plane (side nr. 3)
+                const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 3));
 
-        new_id = neighbor_id_vector.first;
-        neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
-        neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     -half_extends[0]),
-                                 multiply(neighbor_id_vector.second, (-component_x - half_extends[0]) ) );
-    }
-    else if ( (-half_extends[1] < component_y) && ( component_y < half_extends[1]) &&
-              (half_extends[0] < component_x) )
-    {
-        // we are at the 'right' of the plane (side nr. 3)
-        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 3));
+                new_id = neighbor_id_vector.first;
+                neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
+                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     half_extends[0]),
+                                         multiply(neighbor_id_vector.second, (component_x - half_extends[0]) ) );
+            }
+        }
 
-        new_id = neighbor_id_vector.first;
-        neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
-        neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     half_extends[0]),
-                                 multiply(neighbor_id_vector.second, (component_x - half_extends[0]) ) );
-    }
-    else
-    {
-        // we are somewhere in the corners and don't know what to do ->reject move
-        // We return the unmodified position, it will bounce later.
-        return pos_structure_id;
-    }
+        const position_type new_pos ( add(origin_plane.position(), add(neighbor_plane_par, neighbor_plane_inl)));
 
-    const position_type new_pos ( add(origin_plane.position(),
-                                      add(neighbor_plane_par, neighbor_plane_inl)));
-    return std::make_pair(new_pos, new_id);
+        // Check if we are in one of the corners. If yes -> do another round of border crossing from neighboring plane.
+        if ( abs(component_x) > half_extends[0] && abs(component_y) > half_extends[1] )
+        {
+            return sc.get_structure(new_id)->apply_boundary(std::make_pair(new_pos, new_id), sc);
+        }
+        else
+        {
+            return std::make_pair(new_pos, new_id);
+        }
+    }
 }
 
 template<typename Ttraits_ >

From ba3d7bc83614c742891664863ba274f04f640131 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 1 Jun 2012 16:16:05 +0200
Subject: [PATCH 0944/1541] small fixes and comments

---
 PlanarSurface.hpp | 2 +-
 egfrd.py          | 3 ---
 shells.py         | 2 +-
 3 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index c0d35566..81e45230 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -156,7 +156,7 @@ class PlanarSurface
         length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );   
         
         position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
-        unit_z = normalize ( unit_z );
+        unit_z = normalize ( unit_z );  // TODO unit_z is already defined, don't have to do a cross product
         
         //unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
         
diff --git a/egfrd.py b/egfrd.py
index c83867b4..48b44df3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1382,9 +1382,6 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, reactant1_struc
 
         # Note that the reactant_structure_ids are the ids of the structures on which the particles were located at the time of the reaction.
 
-        if __debug__:
-            assert isinstance(pair, Pair)
-
         # 0. get reactant info
         pid_particle_pair1     = pair.pid_particle_pair1
         pid_particle_pair2     = pair.pid_particle_pair2
diff --git a/shells.py b/shells.py
index f7f15675..f78f3def 100755
--- a/shells.py
+++ b/shells.py
@@ -1126,7 +1126,7 @@ def get_dr_dzright_dzleft_to_DiskShape(shape, testShell, r, z_right, z_left):
 
     # For now just consider the Disk as a special case of a cylinder
     # TODO implement properly, I'm sure things can be more optimal
-    return (Cylinder(shape.position, shape.radius, shape.unit_z, 0.0), testShell, r, z_right, z_left)
+    return get_dr_dzright_dzleft_to_CylindricalShape(Cylinder(shape.position, shape.radius, shape.unit_z, 0.0), testShell, r, z_right, z_left)
 
 def get_radius_to_DiskShape(shape, testShell, r):
     # This function returns the radius for the spherical 'testShell' using the disk 'shape' as its closest

From 02226817ed76cdc55c2560973007a8e95bbe045e Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 1 Jun 2012 17:20:08 +0200
Subject: [PATCH 0945/1541] highly experiment implementation of particle
 species change when changing structures.

---
 Makefile.am       |  3 +++
 PlanarSurface.hpp | 15 +++++++++++++++
 Structure.hpp     |  7 +++++++
 3 files changed, 25 insertions(+)

diff --git a/Makefile.am b/Makefile.am
index c63ed762..1447d1b5 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -119,6 +119,8 @@ noinst_HEADERS = \
 	SphericalBesselGenerator.hpp\
 	SphericalBesselTable.hpp\
 	Structure.hpp\
+    StructureFunctions.cpp\
+    StructureFunctions.hpp\
     StructureID.hpp\
     StructureContainer.hpp\
 	StructureUtils.hpp\
@@ -193,6 +195,7 @@ _gfrd_la_SOURCES=\
 	SpeciesType.cpp\
 	SphericalBesselGenerator.cpp\
 	StructureType.cpp\
+    StructureFunctions.cpp\
 	utils.cpp
 
 _greens_functions_la_SOURCES=\
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 81e45230..944864a0 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -5,6 +5,7 @@
 #include "Surface.hpp"
 #include "Plane.hpp"
 #include "freeFunctions.hpp"
+#include "StructureFunctions.hpp"
 
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer;
@@ -28,6 +29,7 @@ class PlanarSurface
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::side_enum_type          side_enum_type;
     typedef typename traits_type::species_type          species_type;
+    typedef typename traits_type::structure_type        structure_type;
 
     typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
 
@@ -215,6 +217,19 @@ class PlanarSurface
         return structure_container.cyclic_transpose(*this, pos_struct_id);
     }
 
+    ///// TESTING
+    virtual position_structid_pair_type singlereaction_stuff(structure_type const& target_structure, position_type const& position) const
+    {
+        return target_structure.singlereaction_stuff2(*this, position);
+    }
+
+    template <typename Tstruct_>
+    position_structid_pair_type singlereaction_stuff2(Tstruct_ const& origin_structure, position_type const& position) const
+    {
+        return ::get_pos(origin_structure, *this, position);
+    }
+    ///// END TESTING
+
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/Structure.hpp b/Structure.hpp
index c15d1779..b7cde53d 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -28,6 +28,7 @@ class Structure
     typedef typename traits_type::rng_type                  rng_type;
     typedef typename traits_type::structure_name_type       structure_name_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
+    typedef typename traits_type::structure_type            structure_type;
     typedef typename traits_type::length_type               length_type;
     typedef typename traits_type::position_type             position_type;
     typedef typename traits_type::species_type              species_type;
@@ -131,6 +132,12 @@ class Structure
                                                        structure_container_type const& structure_container) const = 0;
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
+    ///// TESTING
+    virtual position_structid_pair_type singlereaction_stuff(structure_type const& target_structure, position_type const& position) const = 0;
+    template <typename Tstruct_>
+    position_structid_pair_type singlereaction_stuff2(Tstruct_ const& origin_structure, position_type const& position) const;
+    ///// END TESTING
+
 
 
     virtual std::size_t hash() const

From 731e941c2dfff826264a12b97e38a10c91575c47 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 1 Jun 2012 17:22:02 +0200
Subject: [PATCH 0946/1541] add file with notes

---
 test.hpp | 235 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 235 insertions(+)
 create mode 100644 test.hpp

diff --git a/test.hpp b/test.hpp
new file mode 100644
index 00000000..8915a565
--- /dev/null
+++ b/test.hpp
@@ -0,0 +1,235 @@
+// Get_info
+// info is:
+// -reaction volume
+// -product position(s)/structure_id(s)
+
+// In BD, the local situation is checked by determining the overlaps.
+// -the reactant particle can overlap with other particles
+//  The overlapping particles can be on: -the current structure
+//                                       -the parent structure (or the parent of the parent)
+//                                       -a peer structure
+//                                       -a child structure (or the child of a child)
+// -the reactant particle can overlap with other surface.
+//  the overlapping surfaces are always: -the current structure (where the particle lives)
+//                                       -the parent structure (the parent always encompasses the child surface)
+//  the overlapping surface can also be: -a peer structure
+//                                       -a child structure
+
+// For the particles we can therefore have three situations. The other particles is:
+// -at the same hierarchical level -> need to decide on reaction rule where to place the particle
+// -below the current level        -> the structure of the new particle is the structure of 'the other' particle
+// -above the current level        -> the structure of the new particle is the current structure (same as previous but particles swapped)
+
+
+// particles are in the local vicinity
+// get the reaction rule for the situation
+// check that the reaction rule defines an implemented mechanism/function
+// -the product species must be able to live on one of the reactant surfaces ( product_species.STid == particle1.structure.sid/particle2.structure.sid )
+// -when calling the right function, the signature for the reaction must exist.
+//  (for example: P(region) + P(cylinder) -> P(region) is not supported, whereas P(region) + P(cylinder) -> P(cylinder) is.
+// call the right function
+
+if (particles on connected structures of same structure_type)
+    // transition/edge_crossing
+else
+    // particles live on same/different structure_types that are not connected
+    determine ordering of structures on which particles live // assume this to be unimportant or unambiguous
+    get_product_info -> (position, structure_id)
+
+
+// Here we assume that the peers/parent conditions are checked in the functions themselves. The relationship between the structure is assumed to be unambiguous or unimportant.
+get_pair_product (cuboidal_region_type const& reactant1_region,       cuboidal_region_type const& reactant2_region, cuboidal_region_type const& product_region);            // OK, structures must be peers
+get_pair_product (planar_surface_type const& reactant1_plane,         planar_surface_type const& reactant2_plane,   planar_surface_type const& product_plane);              // OK, structures must be peers
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK, structures must be peers
+get_pair_product (disk_surface_type const& reactant1_disk,            disk_surface_type const& reactant2_disk, ...);                                                        // Illegal
+
+
+get_pair_product (planar_surface_type const& reactant1_plane,         cuboidal_region_type const& reactant2_region, planar_surface_type const& product_plane);         // Ok, plane must be below region
+get_pair_product (cuboidal_region_type const& reactant1_region,       planar_surface_type const& reactant2_plane,   planar_surface_type const& product_plane);         // OK, plane must be below region
+
+
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, cuboidal_region_type const& reactant2_region,       cylindrical_surface_type const& product_cylinder);// Ok,cylinder must be below region
+get_pair_product (cuboidal_region_type const& reactant1_region,       cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK,cylinder must be below region
+
+
+get_pair_product (disk_surface_type const& reactant1_disk,            cuboidal_region_type const& reactant2_region, disk_surface_type const& product_disk);     // Ok, disk must be below region (Cap/Sink + Bulk -> Cap/Sink)
+get_pair_product (cuboidal_region_type const& reactant1_region,       disk_surface_type const& reactant2_disk,      disk_surface_type const& product_disk);     // Ok, disk must be below region
+
+
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, planar_surface_type const& reactant2_plane,         ...);         // Illegal, maybe later ok if the structures are peers
+get_pair_product (planar_surface_type const& reactant1_plane,         cylindrical_surface_type const& reactant2_cylinder, ...);         // Illegal
+
+
+get_pair_product (disk_surface_type const& reactant1_disk,            planar_surface_type const& reactant2_plane, ...);                 // Illegal, maybe later ok if the structures are peers
+get_pair_product (planar_surface_type const& reactant1_plane,         disk_surface_type const& reactant2_disk,    ...);                 // Illegal
+
+
+get_pair_product (disk_surface_type const& reactant1_disk,            cylindrical_surface_type const& reactant2_cylinder, disk_surface_type const& product_disk);   // OK, disk must be below cylinder or peer of cylinder
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, disk_surface_type const& reactant2_disk, disk_surface_type const& product_disk);  // OK, disk must be below cylinder or peer of cylinder
+
+
+
+
+
+
+
+// check if the local situation allows the reaction rule to be executed
+reactant_structure = get_structure(reactant.structure_id())
+if ( product_species.sid() == reactant_structure.parent_structure.sid() )
+{
+    // The reactant_species lives on the reactant structure
+    // Then the reaction rule A(struct_a) -> B(struct_b) where struct_b is the parent of struct_a can be executed (dissociation)
+    //  because the parent structure is of the type denoted in the reaction rule.
+    get_info_to_parent(reactant_structure, parent_structure)
+}
+else if ( )
+{
+    // The reaction rule A(struct_a) -> B(struct_b) where struct_a and struct_b are peers can be executed (transfer).
+}
+else if ( )
+{
+    // The reaction A(struct_a) + struct_b -> B(struct_b), where struct_b 
+}
+
+// Single_reactions from a structure to another structure
+// When the target structure is the parent structure of the source structure
+// The structures are the structures that the particle lives on
+
+// These are functions for a single particle that moves from one structure to another
+// Note the two structures need to be 'close'. This means that:
+// -the target structure is the parent of the source structure (the parent always surrounds the child and is therefore always close)
+// -the target structure is the child of the source structure and is 'close'
+// -the target structure and source structures are peers and 'close'
+// -the two structure are actually the very same structure.
+
+// What to do:
+// The two structures are of the same type and are actually the same structure -> no changes (simple decay)
+// The two structures are of the same type (but are not the same) -> direct 'transfer' from one structure to the other (hopping or whatever)
+// The two structures are of different types -> association/dissociation reaction
+// We assume that the relationship between the structures is clear/unambigous or can be determined by the function itself.
+get_single_product (cuboidal_region_type const& region,       cuboidal_region_type const& parent_region);       // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+get_single_product (planar_surface_type const& plane,         planar_surface_type const& parent_plane);         // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+get_single_product (cylindrical_surface_type const& cylinder, cylindrical_surface_type const& parent_cylinder); // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+get_single_product (disk_surface_type const& disk,            disk_surface_type const& parent_disk);            // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+
+get_single_product (planar_surface_type const& plane,         cuboidal_region_type const& parent_region);       // OK, dissociation (region must be parent of plane)
+get_single_product (cuboidal_region_type const& region,       planar_surface_type const& parent_plane);         // OK, association
+
+get_single_product (cylindrical_surface_type const& cylinder, cuboidal_region_type const& parent_region);       // OK, dissociation (region must be parent of cylinder)
+get_single_product (cuboidal_region_type const& region,       cylindrical_surface_type const& parent_cylinder); // OK, association
+
+get_single_product (disk_surface_type const& disk,            cuboidal_region_type const& parent_region);       // OK, dissociation (Cap -> Bulk)
+get_single_product (cuboidal_region_type const& region,       disk_surface_type const& parent_disk);            // Illegal for now (association from bulk)
+
+get_single_product (cylindrical_surface_type const& cylinder, planar_surface_type const& parent_plane);         // Illegal
+get_single_product (planar_surface_type const& plane,         cylindrical_surface_type const& parent_cylinder); // Illegal
+get_single_product (disk_surface_type const& disk,            planar_surface_type const& parent_plane);         // Illegal
+get_single_product (planar_surface_type const& plane,         disk_surface_type const& parent_disk);            // Illegal
+
+get_single_product (disk_surface_type const& disk,            cylindrical_surface_type const& parent_cylinder); // OK Sink/Cap -> Cylinder
+get_single_product (cylindrical_surface_type const& cylinder, disk_surface_type const& parent_disk);            // OK Cylinder -> Sink/Cap
+
+
+
+
+
+
+get_product_pair (cuboidal_region_type const& reactant_region,       cuboidal_region_type const& product1_region, cuboidal_region_type const& product2_region);            // OK, structures must be the same
+get_product_pair (planar_surface_type const& reactant_plane,         planar_surface_type const& product1_plane,   planar_surface_type const& product2_plane);              // OK, structures must be the same
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, cylindrical_surface_type const& product1_cylinder, cylindrical_surface_type const& product2_cylinder);// OK, structures must be the same
+get_product_pair (disk_surface_type const& reactant_disk,            disk_surface_type const& product1_disk, disk_surface_type const& product2_disk);                      // Illegal
+                
+                
+get_product_pair (planar_surface_type const& reactant_plane,         cuboidal_region_type const& product1_region, planar_surface_type const& product_plane);         // Ok, plane must be below region
+get_product_pair (cuboidal_region_type const& reactant_region,       planar_surface_type const& product1_plane,   planar_surface_type const& product_plane);         // OK, plane must be below region
+                
+                
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, cuboidal_region_type const& reactant2_region,       cylindrical_surface_type const& product_cylinder);// Ok,cylinder must be below region
+get_product_pair (cuboidal_region_type const& reactant_region,       cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK,cylinder must be below region
+                
+                
+get_product_pair (disk_surface_type const& reactant_disk,            cuboidal_region_type const& reactant2_region, disk_surface_type const& product_disk);     // Ok, disk must be below region (Cap/Sink + Bulk -> Cap/Sink)
+get_product_pair (cuboidal_region_type const& reactant_region,       disk_surface_type const& reactant2_disk,      disk_surface_type const& product_disk);     // Ok, disk must be below region
+                
+                
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, planar_surface_type const& reactant2_plane,         ...);         // Illegal, maybe later ok if the structures are peers
+get_product_pair (planar_surface_type const& reactant_plane,         cylindrical_surface_type const& reactant2_cylinder, ...);         // Illegal
+                
+                
+get_product_pair (disk_surface_type const& reactant_disk,            planar_surface_type const& reactant2_plane, ...);                 // Illegal, maybe later ok if the structures are peers
+get_product_pair (planar_surface_type const& reactant_plane,         disk_surface_type const& reactant2_disk,    ...);                 // Illegal
+                
+                
+get_product_pair (disk_surface_type const& reactant_disk,            cylindrical_surface_type const& reactant2_cylinder, disk_surface_type const& product_disk);   // OK, disk must be below cylinder or peer of cylinder
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, disk_surface_type const& reactant2_disk, disk_surface_type const& product_disk);  // OK, disk must be below cylinder or peer of cylinder
+
+
+
+class Structure
+{
+    virtual position_type method(structure_type const& target_structure, position_type const& position) = 0;
+}
+
+class PlanarSurface : Structure
+{
+
+    virtual position_type method(structure_type const& target_structure, position_type const& position)
+    {
+        return target_structure.get_pos(*this, position);
+    }
+
+    template <Tstruct_>
+    virtual position_type get_pos(Tstruct_ const& origin_structure, position_type const& position)
+    {
+        return ::get_pos(origin_structure, *this, position);
+    }
+
+}
+
+class CylindricalSurface
+{
+
+    virtual position_type method(structure_type const& target_structure, position_type const& position)
+    {
+        return target_structure.get_pos(*this, position);
+    }
+
+    template <Tstruct_>
+    virtual position_type get_pos(Tstruct_ const& origin_structure, position_type const& position)
+    {
+        return ::get_pos(origin_structure, *this, position);
+    }
+
+}
+
+#include "PlanarSurface.hpp"
+#include "CylindricalSurface.hpp"
+#include "DiskSurface.hpp"
+
+template <Ttraits_>
+position_type get_pos(PlanarSurface<Ttraits_> const& origin_structure,
+                      PlanarSurface<Ttraits_> const& target_structure, typename Ttraits_::position_type const& old_pos)
+{
+    typedef typename Ttraits_::structure_id_type structure_id_type;
+    typedef typename Ttraits_::position_type     position_type;
+
+    const structure_id_type id();
+    return std::make_pair(target_structure.project_point(old_pos), target_structure.id());
+}
+
+get_pos(cylinder_surface_type, cylinder_surface_type)
+{
+    throw exception;
+}
+template <Ttraits_>
+inline PlanarSurface<Ttraits_>::position_structid_pair_type
+get_pos(CylindricalSurface<Ttraits_> origin_structure,
+        planar_surface_type);
+
+
+get_pos(planar_surface_type, cylinder_surface_type);
+
+
+newBDthing
+    new_pos = source_structure.method(target_structure, old_pos);
+

From a248f420ab4d2219e26c1809273e878b0c16ed69 Mon Sep 17 00:00:00 2001
From: Laurens Bossen <bossen@amolf.nl>
Date: Fri, 1 Jun 2012 17:22:02 +0200
Subject: [PATCH 0947/1541] added new files and file with notes

---
 StructureFunctions.cpp |  34 ++++++
 StructureFunctions.hpp |  20 ++++
 test.hpp               | 235 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 289 insertions(+)
 create mode 100644 StructureFunctions.cpp
 create mode 100644 StructureFunctions.hpp
 create mode 100644 test.hpp

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
new file mode 100644
index 00000000..f984627a
--- /dev/null
+++ b/StructureFunctions.cpp
@@ -0,0 +1,34 @@
+#ifndef STRUCTFUNC_CPP
+#define STRUCTFUNC_CPP
+
+#include "StructureFunctions.hpp"
+#include "PlanarSurface.hpp"
+#include "CylindricalSurface.hpp"
+#include "DiskSurface.hpp"
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits::position_type, typename Ttraits::structure_id_type>
+get_pos(PlanarSurface<Ttraits_> const& origin_structure,
+        PlanarSurface<Ttraits_> const& target_structure, typename Ttraits_::position_type const& old_pos)
+{
+    typedef typename Ttraits_::structure_id_type structure_id_type;
+    typedef typename Ttraits_::position_type     position_type;
+
+    const structure_id_type id();
+    return std::make_pair(target_structure.project_point(old_pos), target_structure.id());
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits::position_type, typename Ttraits::structure_id_type>
+get_pos(CylindricalSurface<Ttraits_> origin_structure,
+        CylindricalSurface<Ttraits_> target_structure, typename Ttraits_::position_type const& old_pos)
+{
+    typedef typename Ttraits_::structure_id_type structure_id_type;
+    typedef typename Ttraits_::position_type     position_type;
+
+    return std::make_pair(position_type(), structure_id_type())
+}
+
+
+#endif /* STRUCTUREFUNCTIONS_CPP */
+
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
new file mode 100644
index 00000000..8f02ef23
--- /dev/null
+++ b/StructureFunctions.hpp
@@ -0,0 +1,20 @@
+#ifndef STRUCTFUNC_HPP
+#define STRUCTFUNC_HPP
+
+template <typename Ttraits_>
+class PlanarSurface;
+template <typename Ttraits_>
+class CylindricalSurface;
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos(PlanarSurface<Ttraits_> const& origin_structure,
+        PlanarSurface<Ttraits_> const& target_structure, typename Ttraits_::position_type const& old_pos);
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos(CylindricalSurface<Ttraits_> origin_structure,
+        CylindricalSurface<Ttraits_> target_structure, typename Ttraits_::position_type const& old_pos);
+
+#endif /* STRUCTUREFUNCTIONS_HPP */
+
diff --git a/test.hpp b/test.hpp
new file mode 100644
index 00000000..8915a565
--- /dev/null
+++ b/test.hpp
@@ -0,0 +1,235 @@
+// Get_info
+// info is:
+// -reaction volume
+// -product position(s)/structure_id(s)
+
+// In BD, the local situation is checked by determining the overlaps.
+// -the reactant particle can overlap with other particles
+//  The overlapping particles can be on: -the current structure
+//                                       -the parent structure (or the parent of the parent)
+//                                       -a peer structure
+//                                       -a child structure (or the child of a child)
+// -the reactant particle can overlap with other surface.
+//  the overlapping surfaces are always: -the current structure (where the particle lives)
+//                                       -the parent structure (the parent always encompasses the child surface)
+//  the overlapping surface can also be: -a peer structure
+//                                       -a child structure
+
+// For the particles we can therefore have three situations. The other particles is:
+// -at the same hierarchical level -> need to decide on reaction rule where to place the particle
+// -below the current level        -> the structure of the new particle is the structure of 'the other' particle
+// -above the current level        -> the structure of the new particle is the current structure (same as previous but particles swapped)
+
+
+// particles are in the local vicinity
+// get the reaction rule for the situation
+// check that the reaction rule defines an implemented mechanism/function
+// -the product species must be able to live on one of the reactant surfaces ( product_species.STid == particle1.structure.sid/particle2.structure.sid )
+// -when calling the right function, the signature for the reaction must exist.
+//  (for example: P(region) + P(cylinder) -> P(region) is not supported, whereas P(region) + P(cylinder) -> P(cylinder) is.
+// call the right function
+
+if (particles on connected structures of same structure_type)
+    // transition/edge_crossing
+else
+    // particles live on same/different structure_types that are not connected
+    determine ordering of structures on which particles live // assume this to be unimportant or unambiguous
+    get_product_info -> (position, structure_id)
+
+
+// Here we assume that the peers/parent conditions are checked in the functions themselves. The relationship between the structure is assumed to be unambiguous or unimportant.
+get_pair_product (cuboidal_region_type const& reactant1_region,       cuboidal_region_type const& reactant2_region, cuboidal_region_type const& product_region);            // OK, structures must be peers
+get_pair_product (planar_surface_type const& reactant1_plane,         planar_surface_type const& reactant2_plane,   planar_surface_type const& product_plane);              // OK, structures must be peers
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK, structures must be peers
+get_pair_product (disk_surface_type const& reactant1_disk,            disk_surface_type const& reactant2_disk, ...);                                                        // Illegal
+
+
+get_pair_product (planar_surface_type const& reactant1_plane,         cuboidal_region_type const& reactant2_region, planar_surface_type const& product_plane);         // Ok, plane must be below region
+get_pair_product (cuboidal_region_type const& reactant1_region,       planar_surface_type const& reactant2_plane,   planar_surface_type const& product_plane);         // OK, plane must be below region
+
+
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, cuboidal_region_type const& reactant2_region,       cylindrical_surface_type const& product_cylinder);// Ok,cylinder must be below region
+get_pair_product (cuboidal_region_type const& reactant1_region,       cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK,cylinder must be below region
+
+
+get_pair_product (disk_surface_type const& reactant1_disk,            cuboidal_region_type const& reactant2_region, disk_surface_type const& product_disk);     // Ok, disk must be below region (Cap/Sink + Bulk -> Cap/Sink)
+get_pair_product (cuboidal_region_type const& reactant1_region,       disk_surface_type const& reactant2_disk,      disk_surface_type const& product_disk);     // Ok, disk must be below region
+
+
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, planar_surface_type const& reactant2_plane,         ...);         // Illegal, maybe later ok if the structures are peers
+get_pair_product (planar_surface_type const& reactant1_plane,         cylindrical_surface_type const& reactant2_cylinder, ...);         // Illegal
+
+
+get_pair_product (disk_surface_type const& reactant1_disk,            planar_surface_type const& reactant2_plane, ...);                 // Illegal, maybe later ok if the structures are peers
+get_pair_product (planar_surface_type const& reactant1_plane,         disk_surface_type const& reactant2_disk,    ...);                 // Illegal
+
+
+get_pair_product (disk_surface_type const& reactant1_disk,            cylindrical_surface_type const& reactant2_cylinder, disk_surface_type const& product_disk);   // OK, disk must be below cylinder or peer of cylinder
+get_pair_product (cylindrical_surface_type const& reactant1_cylinder, disk_surface_type const& reactant2_disk, disk_surface_type const& product_disk);  // OK, disk must be below cylinder or peer of cylinder
+
+
+
+
+
+
+
+// check if the local situation allows the reaction rule to be executed
+reactant_structure = get_structure(reactant.structure_id())
+if ( product_species.sid() == reactant_structure.parent_structure.sid() )
+{
+    // The reactant_species lives on the reactant structure
+    // Then the reaction rule A(struct_a) -> B(struct_b) where struct_b is the parent of struct_a can be executed (dissociation)
+    //  because the parent structure is of the type denoted in the reaction rule.
+    get_info_to_parent(reactant_structure, parent_structure)
+}
+else if ( )
+{
+    // The reaction rule A(struct_a) -> B(struct_b) where struct_a and struct_b are peers can be executed (transfer).
+}
+else if ( )
+{
+    // The reaction A(struct_a) + struct_b -> B(struct_b), where struct_b 
+}
+
+// Single_reactions from a structure to another structure
+// When the target structure is the parent structure of the source structure
+// The structures are the structures that the particle lives on
+
+// These are functions for a single particle that moves from one structure to another
+// Note the two structures need to be 'close'. This means that:
+// -the target structure is the parent of the source structure (the parent always surrounds the child and is therefore always close)
+// -the target structure is the child of the source structure and is 'close'
+// -the target structure and source structures are peers and 'close'
+// -the two structure are actually the very same structure.
+
+// What to do:
+// The two structures are of the same type and are actually the same structure -> no changes (simple decay)
+// The two structures are of the same type (but are not the same) -> direct 'transfer' from one structure to the other (hopping or whatever)
+// The two structures are of different types -> association/dissociation reaction
+// We assume that the relationship between the structures is clear/unambigous or can be determined by the function itself.
+get_single_product (cuboidal_region_type const& region,       cuboidal_region_type const& parent_region);       // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+get_single_product (planar_surface_type const& plane,         planar_surface_type const& parent_plane);         // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+get_single_product (cylindrical_surface_type const& cylinder, cylindrical_surface_type const& parent_cylinder); // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+get_single_product (disk_surface_type const& disk,            disk_surface_type const& parent_disk);            // OK, hopping (Illegal for now) or simple decay (structure are the same one)
+
+get_single_product (planar_surface_type const& plane,         cuboidal_region_type const& parent_region);       // OK, dissociation (region must be parent of plane)
+get_single_product (cuboidal_region_type const& region,       planar_surface_type const& parent_plane);         // OK, association
+
+get_single_product (cylindrical_surface_type const& cylinder, cuboidal_region_type const& parent_region);       // OK, dissociation (region must be parent of cylinder)
+get_single_product (cuboidal_region_type const& region,       cylindrical_surface_type const& parent_cylinder); // OK, association
+
+get_single_product (disk_surface_type const& disk,            cuboidal_region_type const& parent_region);       // OK, dissociation (Cap -> Bulk)
+get_single_product (cuboidal_region_type const& region,       disk_surface_type const& parent_disk);            // Illegal for now (association from bulk)
+
+get_single_product (cylindrical_surface_type const& cylinder, planar_surface_type const& parent_plane);         // Illegal
+get_single_product (planar_surface_type const& plane,         cylindrical_surface_type const& parent_cylinder); // Illegal
+get_single_product (disk_surface_type const& disk,            planar_surface_type const& parent_plane);         // Illegal
+get_single_product (planar_surface_type const& plane,         disk_surface_type const& parent_disk);            // Illegal
+
+get_single_product (disk_surface_type const& disk,            cylindrical_surface_type const& parent_cylinder); // OK Sink/Cap -> Cylinder
+get_single_product (cylindrical_surface_type const& cylinder, disk_surface_type const& parent_disk);            // OK Cylinder -> Sink/Cap
+
+
+
+
+
+
+get_product_pair (cuboidal_region_type const& reactant_region,       cuboidal_region_type const& product1_region, cuboidal_region_type const& product2_region);            // OK, structures must be the same
+get_product_pair (planar_surface_type const& reactant_plane,         planar_surface_type const& product1_plane,   planar_surface_type const& product2_plane);              // OK, structures must be the same
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, cylindrical_surface_type const& product1_cylinder, cylindrical_surface_type const& product2_cylinder);// OK, structures must be the same
+get_product_pair (disk_surface_type const& reactant_disk,            disk_surface_type const& product1_disk, disk_surface_type const& product2_disk);                      // Illegal
+                
+                
+get_product_pair (planar_surface_type const& reactant_plane,         cuboidal_region_type const& product1_region, planar_surface_type const& product_plane);         // Ok, plane must be below region
+get_product_pair (cuboidal_region_type const& reactant_region,       planar_surface_type const& product1_plane,   planar_surface_type const& product_plane);         // OK, plane must be below region
+                
+                
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, cuboidal_region_type const& reactant2_region,       cylindrical_surface_type const& product_cylinder);// Ok,cylinder must be below region
+get_product_pair (cuboidal_region_type const& reactant_region,       cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK,cylinder must be below region
+                
+                
+get_product_pair (disk_surface_type const& reactant_disk,            cuboidal_region_type const& reactant2_region, disk_surface_type const& product_disk);     // Ok, disk must be below region (Cap/Sink + Bulk -> Cap/Sink)
+get_product_pair (cuboidal_region_type const& reactant_region,       disk_surface_type const& reactant2_disk,      disk_surface_type const& product_disk);     // Ok, disk must be below region
+                
+                
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, planar_surface_type const& reactant2_plane,         ...);         // Illegal, maybe later ok if the structures are peers
+get_product_pair (planar_surface_type const& reactant_plane,         cylindrical_surface_type const& reactant2_cylinder, ...);         // Illegal
+                
+                
+get_product_pair (disk_surface_type const& reactant_disk,            planar_surface_type const& reactant2_plane, ...);                 // Illegal, maybe later ok if the structures are peers
+get_product_pair (planar_surface_type const& reactant_plane,         disk_surface_type const& reactant2_disk,    ...);                 // Illegal
+                
+                
+get_product_pair (disk_surface_type const& reactant_disk,            cylindrical_surface_type const& reactant2_cylinder, disk_surface_type const& product_disk);   // OK, disk must be below cylinder or peer of cylinder
+get_product_pair (cylindrical_surface_type const& reactant_cylinder, disk_surface_type const& reactant2_disk, disk_surface_type const& product_disk);  // OK, disk must be below cylinder or peer of cylinder
+
+
+
+class Structure
+{
+    virtual position_type method(structure_type const& target_structure, position_type const& position) = 0;
+}
+
+class PlanarSurface : Structure
+{
+
+    virtual position_type method(structure_type const& target_structure, position_type const& position)
+    {
+        return target_structure.get_pos(*this, position);
+    }
+
+    template <Tstruct_>
+    virtual position_type get_pos(Tstruct_ const& origin_structure, position_type const& position)
+    {
+        return ::get_pos(origin_structure, *this, position);
+    }
+
+}
+
+class CylindricalSurface
+{
+
+    virtual position_type method(structure_type const& target_structure, position_type const& position)
+    {
+        return target_structure.get_pos(*this, position);
+    }
+
+    template <Tstruct_>
+    virtual position_type get_pos(Tstruct_ const& origin_structure, position_type const& position)
+    {
+        return ::get_pos(origin_structure, *this, position);
+    }
+
+}
+
+#include "PlanarSurface.hpp"
+#include "CylindricalSurface.hpp"
+#include "DiskSurface.hpp"
+
+template <Ttraits_>
+position_type get_pos(PlanarSurface<Ttraits_> const& origin_structure,
+                      PlanarSurface<Ttraits_> const& target_structure, typename Ttraits_::position_type const& old_pos)
+{
+    typedef typename Ttraits_::structure_id_type structure_id_type;
+    typedef typename Ttraits_::position_type     position_type;
+
+    const structure_id_type id();
+    return std::make_pair(target_structure.project_point(old_pos), target_structure.id());
+}
+
+get_pos(cylinder_surface_type, cylinder_surface_type)
+{
+    throw exception;
+}
+template <Ttraits_>
+inline PlanarSurface<Ttraits_>::position_structid_pair_type
+get_pos(CylindricalSurface<Ttraits_> origin_structure,
+        planar_surface_type);
+
+
+get_pos(planar_surface_type, cylinder_surface_type);
+
+
+newBDthing
+    new_pos = source_structure.method(target_structure, old_pos);
+

From d2676b0885ceae5a60cfc80bf50d99123038a516 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 6 Jun 2012 16:17:49 +0200
Subject: [PATCH 0948/1541] Basic implementation of structure handling dispatch
 switchbox, taking care of mutual inclusion / forward declaration

---
 CuboidalRegion.hpp     | 15 ++++++++++
 CylindricalSurface.hpp | 16 ++++++++++
 DiskSurface.hpp        | 15 ++++++++++
 PlanarSurface.hpp      | 12 ++++----
 Plane.hpp              |  2 +-
 SphericalSurface.hpp   | 15 ++++++++++
 Structure.hpp          |  8 ++---
 StructureFunctions.cpp | 67 ++++++++++++++++++++++++++++++++++--------
 StructureFunctions.hpp | 43 +++++++++++++++++++++++----
 9 files changed, 164 insertions(+), 29 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 83529edd..fb02229d 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -5,6 +5,7 @@
 #include "Region.hpp"
 #include "Box.hpp"
 #include "freeFunctions.hpp"
+#include "StructureFunctions.hpp"
 
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer;
@@ -28,6 +29,7 @@ class CuboidalRegion
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::side_enum_type          side_enum_type;
     typedef typename traits_type::species_type          species_type;
+    typedef typename traits_type::structure_type        structure_type;
 
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
@@ -150,6 +152,19 @@ class CuboidalRegion
     {
         return pos_struct_id;       // The cyclic_transpose does nothing because we'll apply world cyclic transpose later.
     }
+    
+    ///// TESTING TESTING TESTING TESTING TESTING
+    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    {
+        return target_structure.single_reaction_helper(*this, position);
+    }
+
+    template <typename Tstruct_>
+    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    {
+        return ::get_pos_sid_pair(origin_structure, *this, position);
+    }
+    ///// END TESTING TESTING TESTING TESTING TESTING
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 5ba3c231..7f0964ad 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -5,8 +5,10 @@
 #include "Surface.hpp"
 #include "Cylinder.hpp"
 #include "freeFunctions.hpp"
+#include "StructureFunctions.hpp"
 #include "geometry.hpp"
 
+
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer;
 
@@ -30,6 +32,7 @@ class CylindricalSurface
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::side_enum_type          side_enum_type;
     typedef typename traits_type::species_type          species_type;
+    typedef typename traits_type::structure_type        structure_type;
 
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
@@ -228,6 +231,19 @@ class CylindricalSurface
     {
         return pos_struct_id;       // for now we do not support connected cylindrical surfaces.
     }
+    
+    ///// TESTING TESTING TESTING TESTING TESTING
+    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    {
+        return target_structure.single_reaction_helper(*this, position);
+    }
+
+    template <typename Tstruct_>
+    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    {
+        return ::get_pos_sid_pair(origin_structure, *this, position);
+    }
+    ///// END TESTING TESTING TESTING TESTING TESTING
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 141fd3c2..b0006162 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -5,6 +5,7 @@
 #include "Surface.hpp"
 #include "Disk.hpp"
 #include "freeFunctions.hpp"
+#include "StructureFunctions.hpp"
 #include "geometry.hpp"
 
 template <typename Tobj_, typename Tid_, typename Ttraits_>
@@ -29,6 +30,7 @@ class DiskSurface
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::side_enum_type          side_enum_type;
     typedef typename traits_type::species_type          species_type;
+    typedef typename traits_type::structure_type        structure_type;
 
     typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
 
@@ -246,6 +248,19 @@ class DiskSurface
         return pos_struct_id;   // Disks can also not be connected, so no cyclic transpose.
     }
 
+    ///// TESTING TESTING TESTING TESTING TESTING
+    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    {
+        return target_structure.single_reaction_helper(*this, position);
+    }
+
+    template <typename Tstruct_>
+    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    {
+        return ::get_pos_sid_pair(origin_structure, *this, position);
+    }
+    ///// END TESTING TESTING TESTING TESTING TESTING
+    
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 944864a0..906a4412 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -217,18 +217,18 @@ class PlanarSurface
         return structure_container.cyclic_transpose(*this, pos_struct_id);
     }
 
-    ///// TESTING
-    virtual position_structid_pair_type singlereaction_stuff(structure_type const& target_structure, position_type const& position) const
+    ///// TESTING TESTING TESTING TESTING TESTING
+    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.singlereaction_stuff2(*this, position);
+        return target_structure.single_reaction_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type singlereaction_stuff2(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
-        return ::get_pos(origin_structure, *this, position);
+        return ::get_pos_sid_pair(origin_structure, *this, position);
     }
-    ///// END TESTING
+    ///// END TESTING TESTING TESTING TESTING TESTING
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/Plane.hpp b/Plane.hpp
index dec3d91c..3620bcbd 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -313,7 +313,7 @@ deflect(Plane<T_> const& obj, typename Plane<T_>::position_type const& r0, typen
    if(dot_product(d, u_z) != 0.0)
       intersect_parameter = divide( dot_product(subtract(center_pt, r0), u_z), dot_product(d, u_z) );
    else
-      intersect_parameter = (length_type)INT_MAX;       // infinity, displacement is parallel to edge
+      intersect_parameter = (length_type)1e100;       // infinity, displacement is parallel to edge
       
    // Check whether the displacement actually crosses the plane;
    // If not, just return original position plus displacement;
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 7b4f6b73..12d88c85 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -4,6 +4,7 @@
 #include "Surface.hpp"
 #include "Sphere.hpp"
 #include "freeFunctions.hpp"
+#include "StructureFunctions.hpp"
 
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer;
@@ -24,6 +25,7 @@ class SphericalSurface
     typedef typename base_type::length_type             length_type;
     typedef typename base_type::side_enum_type          side_enum_type;
     typedef typename traits_type::species_type          species_type;
+    typedef typename traits_type::structure_type        structure_type;
 
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
@@ -122,6 +124,19 @@ class SphericalSurface
         return pos_struct_id;       // Two spherical surface cannot be connected (there is no boundary!)
     }
 
+    ///// TESTING TESTING TESTING TESTING TESTING
+    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    {
+        return target_structure.single_reaction_helper(*this, position);
+    }
+
+    template <typename Tstruct_>
+    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    {
+        return ::get_pos_sid_pair(origin_structure, *this, position);
+    }
+    ///// END TESTING TESTING TESTING TESTING TESTING
+    
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
         visitor(*this);
diff --git a/Structure.hpp b/Structure.hpp
index b7cde53d..3ea98ae3 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -132,11 +132,11 @@ class Structure
                                                        structure_container_type const& structure_container) const = 0;
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
-    ///// TESTING
-    virtual position_structid_pair_type singlereaction_stuff(structure_type const& target_structure, position_type const& position) const = 0;
+    ///// TESTING TESTING TESTING TESTING TESTING
+    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_type singlereaction_stuff2(Tstruct_ const& origin_structure, position_type const& position) const;
-    ///// END TESTING
+    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const;
+    ///// END TESTING TESTING TESTING TESTING TESTING
 
 
 
diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index f984627a..5aed571c 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -1,33 +1,74 @@
 #ifndef STRUCTFUNC_CPP
 #define STRUCTFUNC_CPP
 
-#include "StructureFunctions.hpp"
-#include "PlanarSurface.hpp"
+//#include "StructureFunctions.hpp" // TODO Why the hell does this not work, man???
+#include "CuboidalRegion.hpp"
+#include "SphericalSurface.hpp"
 #include "CylindricalSurface.hpp"
 #include "DiskSurface.hpp"
+#include "PlanarSurface.hpp"
+
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits::position_type, typename Ttraits::structure_id_type>
-get_pos(PlanarSurface<Ttraits_> const& origin_structure,
-        PlanarSurface<Ttraits_> const& target_structure, typename Ttraits_::position_type const& old_pos)
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_> const&         origin_structure,
+                  CuboidalRegion<Ttraits_> const&         target_structure,
+                  typename Ttraits_::position_type const& old_pos       )
 {
     typedef typename Ttraits_::structure_id_type structure_id_type;
     typedef typename Ttraits_::position_type     position_type;
 
-    const structure_id_type id();
-    return std::make_pair(target_structure.project_point(old_pos), target_structure.id());
-}
+    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_> const&       origin_structure,
+                  SphericalSurface<Ttraits_> const&       target_structure, 
+                  typename Ttraits_::position_type const& old_pos       )
+{
+    typedef typename Ttraits_::structure_id_type structure_id_type;
+    typedef typename Ttraits_::position_type     position_type;
+
+    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+};
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits::position_type, typename Ttraits::structure_id_type>
-get_pos(CylindricalSurface<Ttraits_> origin_structure,
-        CylindricalSurface<Ttraits_> target_structure, typename Ttraits_::position_type const& old_pos)
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CylindricalSurface<Ttraits_> const&     origin_structure,
+                  CylindricalSurface<Ttraits_> const&     target_structure, 
+                  typename Ttraits_::position_type const& old_pos       )
 {
     typedef typename Ttraits_::structure_id_type structure_id_type;
     typedef typename Ttraits_::position_type     position_type;
 
-    return std::make_pair(position_type(), structure_id_type())
-}
+    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CylindricalSurface<Ttraits_> const&     origin_structure,
+                  DiskSurface<Ttraits_> const&            target_structure,
+                  typename Ttraits_::position_type const& old_pos       )
+{
+    typedef typename Ttraits_::structure_id_type structure_id_type;
+    typedef typename Ttraits_::position_type     position_type;
+
+    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_> const&          origin_structure,
+                  PlanarSurface<Ttraits_> const&          target_structure,
+                  typename Ttraits_::position_type const& old_pos       )
+{
+    typedef typename Ttraits_::structure_id_type structure_id_type;
+    typedef typename Ttraits_::position_type     position_type;
+
+    const structure_id_type id(); // TODO what was this meant to be?
+    return std::make_pair(target_structure.project_point(old_pos), target_structure.id());
+};
 
 
 #endif /* STRUCTUREFUNCTIONS_CPP */
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 8f02ef23..012d8a69 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -1,20 +1,53 @@
 #ifndef STRUCTFUNC_HPP
 #define STRUCTFUNC_HPP
 
+
 template <typename Ttraits_>
-class PlanarSurface;
+class CuboidalRegion;
+
+template <typename Ttraits_>
+class SphericalSurface;
+
 template <typename Ttraits_>
 class CylindricalSurface;
 
+template <typename Ttraits_>
+class DiskSurface;
+
+template <typename Ttraits_>
+class PlanarSurface;
+
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_> const& origin_structure,
+                  CuboidalRegion<Ttraits_> const& target_structure,
+                  typename Ttraits_::position_type const& old_pos       );
+        
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos(PlanarSurface<Ttraits_> const& origin_structure,
-        PlanarSurface<Ttraits_> const& target_structure, typename Ttraits_::position_type const& old_pos);
+get_pos_sid_pair( SphericalSurface<Ttraits_> const& origin_structure,
+                  SphericalSurface<Ttraits_> const& target_structure,
+                  typename Ttraits_::position_type const& old_pos       );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos(CylindricalSurface<Ttraits_> origin_structure,
-        CylindricalSurface<Ttraits_> target_structure, typename Ttraits_::position_type const& old_pos);
+get_pos_sid_pair( CylindricalSurface<Ttraits_> const& origin_structure,
+                  CylindricalSurface<Ttraits_> const& target_structure,
+                  typename Ttraits_::position_type const& old_pos       );
+        
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CylindricalSurface<Ttraits_> const& origin_structure,
+                  DiskSurface<Ttraits_> const& target_structure, 
+                  typename Ttraits_::position_type const& old_pos       );
+        
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_> const& origin_structure,
+                  PlanarSurface<Ttraits_> const& target_structure, 
+                  typename Ttraits_::position_type const& old_pos       );
 
+                  
 #endif /* STRUCTUREFUNCTIONS_HPP */
 

From 25d9a7ffa2d03057532ec570ec025b45cf8a733d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 14 Jun 2012 18:36:58 +0200
Subject: [PATCH 0949/1541] Extend commenting of newBDPropagator.hpp

---
 newBDPropagator.hpp | 61 ++++++++++++++++++++++++++++-----------------
 1 file changed, 38 insertions(+), 23 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 4a336433..f55a9288 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -89,18 +89,20 @@ class newBDPropagator
         shuffle(rng, queue_);
     }
 
-
-    //// MAIN 'step' method 
+    /****************************/
+    /**** MAIN 'step' method ****/
+    /****************************/
     // This method is called to process the change of position and putative reaction of every particle.
     // The method only treats one particle at a time and returns 'True' as long as there are still particles
     //    in the container that need to be processed.
     bool operator()()
     {
+      
+        /*** 0. TREAT QUEUE ***/
         // if there are no more particle to treat -> end
         if (queue_.empty())
             return false;        
 
-        //// 0.
         // Get the next particle from the queue
         particle_id_type pid(queue_.back());
         queue_.pop_back();
@@ -125,7 +127,7 @@ class newBDPropagator
         }
         
 
-        //// 1.?
+        /*** 1. COLLECT INFO ***/
         // Get info of the particle
         const species_type                      pp_species(tx_.get_species(pp.second.sid()));
         const length_type                       r0( pp_species.radius() );
@@ -136,7 +138,7 @@ class newBDPropagator
         position_type                   new_pos(old_pos);
         structure_id_type               new_structure_id( old_struct_id );
 
-        //// 2. New position
+        /*** 2. DISPLACEMENT TRIAL ***/
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particle bounces, and is returned
            to it's original position. For a particle with D = 0, new_pos = old_pos */        
@@ -152,6 +154,7 @@ class newBDPropagator
             new_structure_id = pos_structid.second;
         }
 
+        /*** 3. CHECK OVERLAPS ***/
         bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
@@ -160,13 +163,13 @@ class newBDPropagator
                 tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
         int particles_in_overlap(overlap_particles ? overlap_particles->size(): 0);
 
-        //// 3.1 Check for core overlaps with particles
+        //// 3.1 CHECK FOR CORE OVERLAPS WITH PARTICLES
         /* Check if the particle at new_pos overlaps with any particle cores. */        
         int j( 0 );
         while(!bounced && j < particles_in_overlap)
             bounced = overlap_particles->at(j++).second < r0;
         
-        //// 3.2 Check for core overlaps structures
+        //// 3.2 CHECK FOR CORE OVERLAPS WITH STRUCTURES
         /* If the particle has not bounced with another particle check for overlap with a surface. */
         boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures;
         int structures_in_overlap(0);
@@ -183,7 +186,7 @@ class newBDPropagator
                 bounced = overlap_structures->at(j++).second < r0;
         }
          
-        //// 4. Finalize the position
+        /*** 4. TREAT BOUNCING => CHECK FOR POTENTIAL REACTIONS / INTERACTIONS ***/
         /* If particle is bounced, restore old position and check reaction_volume for reaction partners at old_pos. */
         if(bounced)
         {
@@ -209,14 +212,15 @@ class newBDPropagator
         }
         
 
-        //// 5.
+        /*** 5. REACTIONS & INTERACTIONS ***/
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
         Real accumulated_prob (0);
         Real rnd( rng_() );
         
         const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
-        /* First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction. */
+        //// 5.1 INTERACTIONS WITH STRUCTURES
+        // First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction.
         // TODO also interaction should be allowed when a particle is on a cylinder.
         // TODO don't check only the closest but check all overlapping surfaces.
         j = 0;
@@ -233,13 +237,13 @@ class newBDPropagator
                 accumulated_prob += k_total( pp.second.sid(), overlap_struct.first.second->sid() ) * dt_ / 
                                     overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ );
         
-                if(accumulated_prob >= 1.)
+                if(accumulated_prob >= 1.) // sth. is wrong in this case
                 {
                     LOG_WARNING(("the acceptance probability of an interaction/reaction exeeded one; %f.",
                                  accumulated_prob));
                 } 
                 
-                if( accumulated_prob > rnd )
+                if( accumulated_prob > rnd ) // OK, try to fire the interaction
                 {            
                     try
                     {
@@ -260,10 +264,10 @@ class newBDPropagator
                 }
             }
 
-            j++;
+            j++; // next overlapping structure index
         }
         
-        ////
+        //// 5.1 REACTIONS WITH OTHER PARTICLES
         /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
         while(j < particles_in_overlap)
@@ -319,8 +323,9 @@ class newBDPropagator
             
             j++;
         }
-                               
-        /* If the particle did neither react, interact or bounce, update it to it's new position. */
+        
+        /*** 6. DEFAULT CASE: ACCEPT DISPLACEMENT TRIAL ***/
+        // If the particle did neither react, interact or bounce, update it to it's new position.
         if(!bounced)
         {   
             const particle_id_pair particle_to_update( pp.first, 
@@ -345,15 +350,20 @@ class newBDPropagator
         return true;
     }
 
-
+    /*** HELPER METHODS ***/
     // Getter of rejected_move
     std::size_t get_rejected_move_count() const
     {
         return rejected_move_count_;
     }
 
-////// Private methods
+
+/***************************/
+/***** PRIVATE METHODS *****/
+/***************************/
 private:
+ 
+    /*** SINGLE REACTIONS ***/
     bool attempt_single_reaction(particle_id_pair const& pp)
     // Handles all monomolecular reactions
     {
@@ -595,6 +605,7 @@ class newBDPropagator
     }
 
 
+    /*** PAIR REACTIONS ***/
     const bool attempt_pair_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1,
                                      species_type const& s0, species_type const& s1)
     // This handles the reaction between a pair of particles.
@@ -760,7 +771,8 @@ class newBDPropagator
         throw illegal_state("Pair reaction failed, no reaction selected when reaction was supposed to happen.");
     }
 
-        
+
+    /*** INTERACTIONS ***/
     const bool attempt_interaction(particle_id_pair const& pp, position_type const& pos_in_struct, boost::shared_ptr<structure_type> const& structure)
     // This handles the 'reaction' (interaction) between a particle and a structure.
     // Returns True if the interaction was succesfull
@@ -856,7 +868,8 @@ class newBDPropagator
         throw illegal_state("Surface interaction failed, no interaction selected when interaction was supposed to happen.");
     }
     
-
+    
+    /*** COMMON HELPER FUNCTIONS ***/
     const position_structid_pair_type make_move(species_type const& species, position_structid_pair_type const& old_pos_struct_id,
                                                 particle_id_type const& ignore) const
     // generates a move for a particle and checks if the move was allowed.
@@ -934,7 +947,6 @@ class newBDPropagator
         return std::make_pair(temp_posstruct0, temp_posstruct1);
     }
 
-
     /* Function returns the accumulated intrinsic reaction rate between to species. */
     /* Note that the species_id_type is equal to the structure_type_id_type for structure_types */
     const Real k_total(species_id_type const& s0_id, species_id_type const& s1_id) const
@@ -951,7 +963,6 @@ class newBDPropagator
         return k_tot;
     }
 
-
     void remove_particle(particle_id_type const& pid)
     // Removes a particle from the propagator and particle container.
     // Note that if the particle is no longer in the local list (we just popped it off and treating it currently), it will
@@ -969,7 +980,9 @@ class newBDPropagator
     }
 
 
-////// Member variables
+/****************************/
+/***** MEMBER VARIABLES *****/
+/****************************/
 private:
     particle_container_type&    tx_;            // The 'ParticleContainer' object that contains the particles.
     network_rules_type const&   rules_;
@@ -984,8 +997,10 @@ class newBDPropagator
     static Logger&              log_;
 };
 
+/*** LOGGER ***/
 template<typename Ttraits_>
 Logger& newBDPropagator<Ttraits_>::log_(Logger::get_logger("ecell.newBDPropagator"));
 
+
 #endif /* NEW_BD_PROPAGATOR_HPP */
 

From 4496beffcabe77f06e010a42d01959d05fa2c501 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 14 Jun 2012 19:30:21 +0200
Subject: [PATCH 0950/1541] Further comments...

---
 newBDPropagator.hpp | 88 ++++++++++++++++++++++++++-------------------
 1 file changed, 52 insertions(+), 36 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index f55a9288..cdc7bd56 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -363,7 +363,9 @@ class newBDPropagator
 /***************************/
 private:
  
+    /************************/
     /*** SINGLE REACTIONS ***/
+    /************************/
     bool attempt_single_reaction(particle_id_pair const& pp)
     // Handles all monomolecular reactions
     {
@@ -391,24 +393,27 @@ class newBDPropagator
 
                 switch (::size(products))
                 {
-                    // When no product particles
+                    /*** NO PRODUCT / DECAY ***/
                     case 0:
                     {
-                        remove_particle(pp.first);  // pp was just popped of the local queue so only has to be removed from the upstream particlecontainer.
+                        remove_particle(pp.first);  // pp was just popped off the local queue so only has to be removed from the upstream particlecontainer.
                         break;
                     }
 
-                    // When one product particle
+                    /*** ONE PRODUCT ***/
                     case 1:
                     {
                         const position_type                             reactant_pos(pp.second.position());
                         const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure(pp.second.structure_id()) );
                         const species_type                              product_species(tx_.get_species(products[0]));
+                        // note that get_structure([..].structure_id()) gives back the parent_structure
 
-                        // default values for the position and structure of the product
+                        // set default values for the position and structure of the product
                         position_structid_pair_type     product_pos_struct_id (std::make_pair(reactant_pos, pp.second.structure_id()));
                         
-                        /* If the product particle does NOT live on the same structure type as the reactant => structure -> superstructure dissociation. */
+                        //// 1 - CREATE NEW POSITION AND STRUCTURE ID                        
+                        // If the product particle does NOT live on the same structure type as the reactant => structure -> superstructure dissociation.
+                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         if( product_species.structure_type_id() != reactant_structure->sid() )
                         {
                             // get dissociation position and structure
@@ -424,8 +429,7 @@ class newBDPropagator
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
 
-
-                        ////// Check for overlaps
+                        //// 2- CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos_struct_id.first, product_species.radius());
                         // check for overlap with particles that are inside the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
@@ -450,11 +454,11 @@ class newBDPropagator
                             }
                         }
 
-
-                        // Process changes
+                        //// 3 - PROCESS CHANGES
                         remove_particle(pp.first);
                         // Make new particle on right surface
                         const particle_id_pair product_particle( tx_.new_particle(product_species.id(), product_pos_struct_id.second, product_pos_struct_id.first) );
+                        
                         // Record changes
                         if (rrec_)
                         {
@@ -465,14 +469,16 @@ class newBDPropagator
                         break;
                     }
 
-                    // When two product particles
+                    /*** TWO PRODUCTS ***/
                     case 2:
                     {
                         const position_type                             reactant_pos(pp.second.position());
                         const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
                         const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure( reactant_structure->structure_id() ) );
                         
+                        //// 0 - SOME NECESSARY DEFINITONS
                         // We set: species 0 lives on the current structure; species 1 lives in the parent structure (if applicable).
+                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         species_type product0_species(tx_.get_species(products[0]));
                         species_type product1_species(tx_.get_species(products[1]));
                         if( product0_species.structure_type_id() != product1_species.structure_type_id() )
@@ -490,6 +496,7 @@ class newBDPropagator
                         structure_id_type prod1_struct_id;
                         posstructid_posstructid_pair_type pos0pos1_pair;
 
+                        //// 1 - GENERATE POSITIONS AND STRUCTURE IDs & CHECK FOR OVERLAPS
                         /* Create positions (np0, np1) for the reaction products. 
                         The iv between the products lies within the reaction volume. */
                         int i (max_retry_count_);
@@ -500,13 +507,12 @@ class newBDPropagator
                             {
                                 throw propagation_error("no space due to particle or surface");
                             }
-                            
-
-                            //// Generate positions and structure_id for product particles after reaction
-
-                            /* If the product particles do NOT live on the same structure => structure -> structure + parent_structure dissociation.
-                               Else, the products live on the same structure AND on the same structure as the reactant. 
-                               => standard geminate dissociation. */
+                        
+                            //// 1a - GENERATE POSITIONS AND STRUCTURE IDs FOR PRODUCT PARTICLES AFTER REACTION
+                            // If the product particles do NOT live on the same structure => structure -> structure + parent_structure dissociation.
+                            // Else, the products live on the same structure AND on the same structure as the reactant. 
+                            // => standard geminate dissociation.
+                            // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                             if( product0_species.structure_type_id() != product1_species.structure_type_id() )
                             {
                                 // TODO include structure_id in return_type of dissociation_positions
@@ -531,7 +537,7 @@ class newBDPropagator
                             pos0pos1_pair = std::make_pair(pos_structid0, pos_structid1);
 
 
-                            ////// Check for overlaps
+                            //// 1b - CHECK FOR OVERLAPS
                             const particle_shape_type new_shape0(pos0pos1_pair.first.first, product0_species.radius());
                             // check overlap with particle in the propagator
                             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product0(
@@ -564,7 +570,7 @@ class newBDPropagator
                             break;
                         }
 
-                        /* After dissociation both particles are allowed to move. */
+                        //// 2 - GENERATE PARTICLE MOVES AFTER DISSOCIATION
                         pos0pos1_pair = make_pair_move(product0_species, product1_species, pos0pos1_pair, pp.first);
 
                         // check overlap with particle outside of propagator (for example in eGFRD simulator)
@@ -577,7 +583,7 @@ class newBDPropagator
                             }
                         }
 
-                        // Process changes
+                        //// 3 - PROCESS CHANGES
                         remove_particle(pp.first);
                         const particle_id_pair product0_particle(tx_.new_particle(product0_species.id(), pos0pos1_pair.first.second,  pos0pos1_pair.first.first));
                         const particle_id_pair product1_particle(tx_.new_particle(product1_species.id(), pos0pos1_pair.second.second, pos0pos1_pair.second.first));
@@ -593,6 +599,8 @@ class newBDPropagator
                         }
                         break;
                     }
+                    
+                    /*** HIGHER PRODUCT NUMBERS - not supported ***/
                     default:
                         throw not_implemented("monomolecular reactions that produce more than two products are not supported");
                 }
@@ -604,8 +612,9 @@ class newBDPropagator
         return false;
     }
 
-
+    /**********************/
     /*** PAIR REACTIONS ***/
+    /**********************/
     const bool attempt_pair_reaction(particle_id_pair const& pp0, particle_id_pair const& pp1,
                                      species_type const& s0, species_type const& s1)
     // This handles the reaction between a pair of particles.
@@ -635,14 +644,14 @@ class newBDPropagator
 
                 switch (::size(products))
                 {
-                    // When no products
+                    /*** NO PRODUCTS / DECAY ***/
                     case 0:
                     {
                         remove_particle(pp0.first);
                         remove_particle(pp1.first);
                         break;
                     }
-                    // When one product particle
+                    /*** ONE PRODUCT ***/
                     case 1:
                     {
                         const structure_id_type             reactant0_structure_id (pp0.second.structure_id());
@@ -655,7 +664,10 @@ class newBDPropagator
                         const species_type                  product_species(tx_.get_species(products[0]));
                         structure_id_type                   product_structure_id(reactant0_structure_id);
 
+                        
+                        //// 1 - GENERATE NEW POSITION AND STRUCTURE ID
                         // If the particles lived on adjacent structures of the same type
+                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         if ((s0.structure_type_id() == s1.structure_type_id()) &&
                             (reactant0_structure_id != reactant1_structure_id))
                         {
@@ -677,6 +689,7 @@ class newBDPropagator
                         // For unequal structure types, project product_pos on the 'lesser' structure.
                         // The 'lesser' structure is the structure that is the lowest in the hierarchy of the two.
                         // Note that this means that a reaction can only cross ONE hierarchical level of structures.
+                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         if( s0.structure_type_id() != s1.structure_type_id() )
                         {
 
@@ -718,8 +731,7 @@ class newBDPropagator
                             }
                         }
 
-
-                        //// Check for overlaps
+                        //// 2 - CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos, product_species.radius());
                         // check for overlap with particles that are inside the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
@@ -744,8 +756,7 @@ class newBDPropagator
                             }
                         }
 
-
-                        // Process changes
+                        //// 3 - PROCESS CHANGES
                         remove_particle(pp0.first);
                         remove_particle(pp1.first);
                         // Make new particle on right structure
@@ -759,7 +770,8 @@ class newBDPropagator
                         }
                         break;
                     }
-                    // When number of products was not '0' or '1'
+                    
+                    /*** HIGHER PRODUCT NUMBERS - not supported ***/
                     default:
                         throw not_implemented("bimolecular reactions that produce more than one product are not supported");
                 }
@@ -771,8 +783,9 @@ class newBDPropagator
         throw illegal_state("Pair reaction failed, no reaction selected when reaction was supposed to happen.");
     }
 
-
+    /********************/
     /*** INTERACTIONS ***/
+    /********************/
     const bool attempt_interaction(particle_id_pair const& pp, position_type const& pos_in_struct, boost::shared_ptr<structure_type> const& structure)
     // This handles the 'reaction' (interaction) between a particle and a structure.
     // Returns True if the interaction was succesfull
@@ -801,23 +814,24 @@ class newBDPropagator
 
                 switch (::size(products))
                 {
-                    // When no products
+                    /*** NO PRODUCTS ***/
                     case 0:
                     {
 
                         remove_particle(pp.first);
                         break;
                     }
-                    // When one product particle
+                    /*** ONE PRODUCT ***/
                     case 1:
                     {
                         const species_type product_species(tx_.get_species(products[0]));
 
-                        // Get the new position of the particle on the structure
+                        //// 1 - GET NEW POSITION ON THE TARGET STRUCTURE
+                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         const position_type product_pos( tx_.apply_boundary(pos_in_struct) );
 
 
-                        ///// Check for overlaps   
+                        //// 2 - CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos, product_species.radius());
                         // check for overlap with particles that are in the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
@@ -843,7 +857,7 @@ class newBDPropagator
                             }
                         }
 
-                        // Process changes
+                        //// 3 - PROCESS CHANGES
                         remove_particle(pp.first);
                         // Make new particle in interaction structure 
                         const particle_id_pair product_particle( tx_.new_particle(product_species.id(), structure->id(), product_pos) );
@@ -856,7 +870,8 @@ class newBDPropagator
                         }
                         break;
                     }
-                    // When number of products was not '0' or '1'
+                    
+                    /*** HIGHER PRODUCT NUMBERS - not supported ***/
                     default:
                         throw not_implemented("structure interactions that produce more than one product are not supported");
                 }
@@ -868,8 +883,9 @@ class newBDPropagator
         throw illegal_state("Surface interaction failed, no interaction selected when interaction was supposed to happen.");
     }
     
-    
+    /*******************************/
     /*** COMMON HELPER FUNCTIONS ***/
+    /*******************************/
     const position_structid_pair_type make_move(species_type const& species, position_structid_pair_type const& old_pos_struct_id,
                                                 particle_id_type const& ignore) const
     // generates a move for a particle and checks if the move was allowed.

From 4421149d573e00a4ac99ae4d53cad46122e899fd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 14 Jun 2012 20:36:39 +0200
Subject: [PATCH 0951/1541] Comment a place with an issue...

---
 newBDPropagator.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index cdc7bd56..ad59b2fa 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -406,7 +406,6 @@ class newBDPropagator
                         const position_type                             reactant_pos(pp.second.position());
                         const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure(pp.second.structure_id()) );
                         const species_type                              product_species(tx_.get_species(products[0]));
-                        // note that get_structure([..].structure_id()) gives back the parent_structure
 
                         // set default values for the position and structure of the product
                         position_structid_pair_type     product_pos_struct_id (std::make_pair(reactant_pos, pp.second.structure_id()));
@@ -422,7 +421,7 @@ class newBDPropagator
                             const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
                             const position_type product_pos (tx_.apply_boundary( add( reactant_pos, displacement ) ));
                             // When dissociating, the new structure is the parent structure (is this always true?)
-                            const structure_id_type product_structure_id (reactant_structure->structure_id());
+                            const structure_id_type product_structure_id (reactant_structure->structure_id()); // TODO WHY IS THAT NOT parent_structure_id() ?
 
                             product_pos_struct_id = std::make_pair(product_pos, product_structure_id);
                             // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?

From 9592dc0dfdddb422e5bd20974fdd0388bb827fd9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 10:04:27 +0200
Subject: [PATCH 0952/1541] New exception 'illegal_propagation_attempt'

... to handle unsupported interaction trials etc. via exceptions.
---
 exceptions.hpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/exceptions.hpp b/exceptions.hpp
index 3cd58dcd..abc0d9ed 100644
--- a/exceptions.hpp
+++ b/exceptions.hpp
@@ -96,6 +96,18 @@ class propagation_error: public std::runtime_error
     std::string str_;
 };
 
+class illegal_propagation_attempt: public std::runtime_error
+{
+public:
+    illegal_propagation_attempt(std::string const& msg): std::runtime_error(msg) {}
+    // TODO: remove string output once everything works
+
+    virtual ~illegal_propagation_attempt() throw() {}
+
+private:
+    std::string str_;
+};
+
 class not_implemented: public std::exception
 {
 public:

From 54751e94cb61e029b5875794b335f435fb92df53 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 11:59:51 +0200
Subject: [PATCH 0953/1541] Revise commenting of newBDpropagator

---
 newBDPropagator.hpp | 40 ++++++++++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 12 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index ad59b2fa..f19bf5c3 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -98,7 +98,7 @@ class newBDPropagator
     bool operator()()
     {
       
-        /*** 0. TREAT QUEUE ***/
+        /*** 1. TREAT QUEUE ***/
         // if there are no more particle to treat -> end
         if (queue_.empty())
             return false;        
@@ -111,9 +111,9 @@ class newBDPropagator
         LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
         
 
-
-        /* Consider decay reactions first. Particles can move after decay, but this is done
-           inside the 'attempt_single_reaction' function. */
+        /*** 2. TRY SINGLE (DECAY) REACTION ***/
+        // Consider decay reactions first. Particles can move after decay, but this is done
+        // inside the 'attempt_single_reaction' function.
         try
         {
             if (attempt_single_reaction(pp))
@@ -127,7 +127,7 @@ class newBDPropagator
         }
         
 
-        /*** 1. COLLECT INFO ***/
+        /*** 3. COLLECT INFO ***/
         // Get info of the particle
         const species_type                      pp_species(tx_.get_species(pp.second.sid()));
         const length_type                       r0( pp_species.radius() );
@@ -154,7 +154,7 @@ class newBDPropagator
             new_structure_id = pos_structid.second;
         }
 
-        /*** 3. CHECK OVERLAPS ***/
+        /*** 4. CHECK OVERLAPS ***/
         bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
@@ -186,7 +186,7 @@ class newBDPropagator
                 bounced = overlap_structures->at(j++).second < r0;
         }
          
-        /*** 4. TREAT BOUNCING => CHECK FOR POTENTIAL REACTIONS / INTERACTIONS ***/
+        /*** 5. TREAT BOUNCING => CHECK FOR POTENTIAL REACTIONS / INTERACTIONS ***/
         /* If particle is bounced, restore old position and check reaction_volume for reaction partners at old_pos. */
         if(bounced)
         {
@@ -212,7 +212,7 @@ class newBDPropagator
         }
         
 
-        /*** 5. REACTIONS & INTERACTIONS ***/
+        /*** 6. REACTIONS & INTERACTIONS ***/
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
         Real accumulated_prob (0);
@@ -221,6 +221,7 @@ class newBDPropagator
         const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
         //// 5.1 INTERACTIONS WITH STRUCTURES
         // First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction.
+        // TODO TODO TODO THIS SHOULD BE REWORKED USING THE NEW STRUCTURE FUNCTIONS! TODO TODO TODO
         // TODO also interaction should be allowed when a particle is on a cylinder.
         // TODO don't check only the closest but check all overlapping surfaces.
         j = 0;
@@ -267,7 +268,7 @@ class newBDPropagator
             j++; // next overlapping structure index
         }
         
-        //// 5.1 REACTIONS WITH OTHER PARTICLES
+        //// 6.1 REACTIONS WITH OTHER PARTICLES
         /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
         while(j < particles_in_overlap)
@@ -297,7 +298,7 @@ class newBDPropagator
             if (accumulated_prob >= 1.)
             {
                 LOG_WARNING((
-                    "the accumulated acceptance probability inside a reaction volume exeeded one; %f.",
+                    "the accumulated acceptance probability inside a reaction volume exeededs one; %f.",
                     accumulated_prob));
             } 
             
@@ -324,7 +325,7 @@ class newBDPropagator
             j++;
         }
         
-        /*** 6. DEFAULT CASE: ACCEPT DISPLACEMENT TRIAL ***/
+        /*** 7. DEFAULT CASE: ACCEPT DISPLACEMENT TRIAL ***/
         // If the particle did neither react, interact or bounce, update it to it's new position.
         if(!bounced)
         {   
@@ -362,7 +363,7 @@ class newBDPropagator
 /***** PRIVATE METHODS *****/
 /***************************/
 private:
- 
+     
     /************************/
     /*** SINGLE REACTIONS ***/
     /************************/
@@ -611,6 +612,21 @@ class newBDPropagator
         return false;
     }
 
+
+    /* The following are the methods that pick up the information from overlap situations
+       with both particles and structures. Then they query the reaction rules to figure out
+       with what precisely the particle is interacting. This is used to determine the outcome
+       of the interaction, which can fail for several reasons:
+       
+       - There is no interaction / reaction rule that supports this interaction.
+       - The reaction / interaction is not supported for the combination of structures involved
+       - The new particle position is not in the target structure
+             (TODO this should possibly be checked by structure functions)
+       - There is no space for the product (due to overlaps)
+       - The number of products as read from the reaction rule is unsupported for the current
+         type of reaction / interaction
+    */
+    
     /**********************/
     /*** PAIR REACTIONS ***/
     /**********************/

From a93d00f82652d00accecf0dbf9c9a74ac842068c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 12:00:24 +0200
Subject: [PATCH 0954/1541] Complete declaration + definition of interaction
 StructureFunctions + implement exception throwing as a default action

For now, all functions by default throw the exception
illegal_propagation_attempt
---
 StructureFunctions.cpp | 397 +++++++++++++++++++++++++++++++++++++----
 StructureFunctions.hpp | 166 +++++++++++++++--
 2 files changed, 514 insertions(+), 49 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 5aed571c..1429ecbe 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -7,69 +7,404 @@
 #include "CylindricalSurface.hpp"
 #include "DiskSurface.hpp"
 #include "PlanarSurface.hpp"
+#include "exceptions.hpp"
 
 
+/****************************/
+/*** INTERACTION HANDLERS ***/
+/****************************/
+
+/******************************/
+/* Coming from CuboidalRegion */
+/******************************/
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+/********************************/
+/* Coming from SphericalSurface */
+/********************************/
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+/**********************************/
+/* Coming from CylindricalSurface */
+/**********************************/
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_> const&         origin_structure,
-                  CuboidalRegion<Ttraits_> const&         target_structure,
-                  typename Ttraits_::position_type const& old_pos       )
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
 {
-    typedef typename Ttraits_::structure_id_type structure_id_type;
-    typedef typename Ttraits_::position_type     position_type;
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
 
-    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
 };
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_> const&       origin_structure,
-                  SphericalSurface<Ttraits_> const&       target_structure, 
-                  typename Ttraits_::position_type const& old_pos       )
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
 {
-    typedef typename Ttraits_::structure_id_type structure_id_type;
-    typedef typename Ttraits_::position_type     position_type;
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
 
-    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
 };
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_> const&     origin_structure,
-                  CylindricalSurface<Ttraits_> const&     target_structure, 
-                  typename Ttraits_::position_type const& old_pos       )
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
 {
-    typedef typename Ttraits_::structure_id_type structure_id_type;
-    typedef typename Ttraits_::position_type     position_type;
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
 
-    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
 };
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_> const&     origin_structure,
-                  DiskSurface<Ttraits_> const&            target_structure,
-                  typename Ttraits_::position_type const& old_pos       )
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
 {
-    typedef typename Ttraits_::structure_id_type structure_id_type;
-    typedef typename Ttraits_::position_type     position_type;
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
 
-    return std::make_pair(position_type(), structure_id_type()); // TODO returns nothing meaningful for now
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
 };
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_> const&          origin_structure,
-                  PlanarSurface<Ttraits_> const&          target_structure,
-                  typename Ttraits_::position_type const& old_pos       )
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
 {
-    typedef typename Ttraits_::structure_id_type structure_id_type;
-    typedef typename Ttraits_::position_type     position_type;
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
 
-    const structure_id_type id(); // TODO what was this meant to be?
-    return std::make_pair(target_structure.project_point(old_pos), target_structure.id());
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
 };
 
+/***************************/
+/* Coming from DiskSurface */
+/***************************/
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+/*****************************/
+/* Coming from PlanarSurface */
+/*****************************/
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+
 
 #endif /* STRUCTUREFUNCTIONS_CPP */
 
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 012d8a69..7718f246 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -2,6 +2,7 @@
 #define STRUCTFUNC_HPP
 
 
+// Forward declaration of structures
 template <typename Ttraits_>
 class CuboidalRegion;
 
@@ -18,35 +19,164 @@ template <typename Ttraits_>
 class PlanarSurface;
 
 
+/****************************/
+/*** INTERACTION HANDLERS ***/
+/****************************/
+
+/* Coming from CuboidalRegion */
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+                  template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+/* Coming from SphericalSurface */
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_> const& origin_structure,
-                  CuboidalRegion<Ttraits_> const& target_structure,
-                  typename Ttraits_::position_type const& old_pos       );
-        
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+/* Coming from CylindricalSurface */
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_> const& origin_structure,
-                  SphericalSurface<Ttraits_> const& target_structure,
-                  typename Ttraits_::position_type const& old_pos       );
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_> const& origin_structure,
-                  CylindricalSurface<Ttraits_> const& target_structure,
-                  typename Ttraits_::position_type const& old_pos       );
-        
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_> const& origin_structure,
-                  DiskSurface<Ttraits_> const& target_structure, 
-                  typename Ttraits_::position_type const& old_pos       );
-        
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos          );
+
+/* Coming from DiskSurface */
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+/* Coming from PlanarSurface */
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
+                  
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_> const& origin_structure,
-                  PlanarSurface<Ttraits_> const& target_structure, 
-                  typename Ttraits_::position_type const& old_pos       );
+get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure, 
+                  typename Ttraits_::position_type      const& old_pos          );
 
                   
 #endif /* STRUCTUREFUNCTIONS_HPP */

From 087667598fa633bf3171f333b36f7be9d337de36 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 12:15:06 +0200
Subject: [PATCH 0955/1541] Give structure functions a more meaningful name

---
 CuboidalRegion.hpp     | 6 +++---
 CylindricalSurface.hpp | 6 +++---
 DiskSurface.hpp        | 6 +++---
 PlanarSurface.hpp      | 6 +++---
 SphericalSurface.hpp   | 6 +++---
 Structure.hpp          | 4 ++--
 6 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index fb02229d..1e38fc22 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -154,13 +154,13 @@ class CuboidalRegion
     }
     
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.single_reaction_helper(*this, position);
+        return target_structure.interaction_info_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 7f0964ad..3e8d775d 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -233,13 +233,13 @@ class CylindricalSurface
     }
     
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.single_reaction_helper(*this, position);
+        return target_structure.interaction_info_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index b0006162..9cd1ef6d 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -249,13 +249,13 @@ class DiskSurface
     }
 
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.single_reaction_helper(*this, position);
+        return target_structure.interaction_info_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 906a4412..0abb622f 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -218,13 +218,13 @@ class PlanarSurface
     }
 
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.single_reaction_helper(*this, position);
+        return target_structure.interaction_info_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 12d88c85..eca13a71 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -125,13 +125,13 @@ class SphericalSurface
     }
 
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.single_reaction_helper(*this, position);
+        return target_structure.interaction_info_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/Structure.hpp b/Structure.hpp
index 3ea98ae3..7439f7cb 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -133,9 +133,9 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type single_reaction_info(structure_type const& target_structure, position_type const& position) const = 0;
+    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_type single_reaction_helper(Tstruct_ const& origin_structure, position_type const& position) const;
+    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const;
     ///// END TESTING TESTING TESTING TESTING TESTING
 
 

From 5fde612d0e0173409593acc8b0b3ce322b7df247 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 12:27:24 +0200
Subject: [PATCH 0956/1541] Make also length_type accessible in structure
 functions

---
 StructureFunctions.cpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 1429ecbe..c721b436 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -25,6 +25,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -40,6 +41,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -55,6 +57,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -70,6 +73,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -85,6 +89,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -103,6 +108,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -118,6 +124,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -133,6 +140,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -148,6 +156,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -163,6 +172,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -181,6 +191,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -196,6 +207,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -211,6 +223,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -226,6 +239,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -241,6 +255,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -259,6 +274,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -274,6 +290,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -289,6 +306,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -304,6 +322,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -319,6 +338,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -337,6 +357,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -352,6 +373,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -367,6 +389,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -382,6 +405,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
@@ -397,6 +421,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");

From 8e9dfc633503be96df7327bc44658e5d9dc23b10 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 12:48:29 +0200
Subject: [PATCH 0957/1541] Implement interaction handling for binding from the
 bulk

I.e., for interactions:

  CuboidalRegion -> CylindricalSurface
  CuboidalRegion -> PlanarSurface
---
 StructureFunctions.cpp | 54 +++++++++++++++++++++++++++++++++++++-----
 1 file changed, 48 insertions(+), 6 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index c721b436..9d8a8d59 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -17,6 +17,7 @@
 /******************************/
 /* Coming from CuboidalRegion */
 /******************************/
+// CuboidalRegion -> CuboidalRegion
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
@@ -33,6 +34,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// CuboidalRegion -> SphericalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
@@ -49,6 +51,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// CuboidalRegion -> CylindricalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
@@ -59,12 +62,22 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    structure_id_type   new_id(    target_structure.id );
+    position_type       new_pos(   target_structure->project_point(old_pos).first );
+    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
+    
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // interaction not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for interaction.");
     
-    return std::make_pair(position_type(), structure_id_type());
 };
 
+// CuboidalRegion -> DiskSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
@@ -81,6 +94,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// CuboidalRegion -> PlanarSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
@@ -91,15 +105,24 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    structure_id_type   new_id(    target_structure.id );
+    position_type       new_pos(   target_structure->project_point(old_pos).first );
+    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
     
-    return std::make_pair(position_type(), structure_id_type());
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // interaction not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for interaction.");
 };
 
 /********************************/
 /* Coming from SphericalSurface */
 /********************************/
+// SphericalSurface -> CuboidalRegion
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
@@ -116,6 +139,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// SphericalSurface -> SphericalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
@@ -132,6 +156,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// SphericalSurface -> CylindricalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
@@ -148,6 +173,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// SphericalSurface -> DiskSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
@@ -164,6 +190,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// SphericalSurface -> PlanarSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
@@ -183,6 +210,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 /**********************************/
 /* Coming from CylindricalSurface */
 /**********************************/
+// CylindricalSurface -> CuboidalRegion
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
@@ -199,6 +227,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// CylindricalSurface -> CylindricalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
@@ -215,6 +244,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// CylindricalSurface -> SphericalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
@@ -231,6 +261,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// CylindricalSurface -> DiskSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
@@ -247,6 +278,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// CylindricalSurface -> PlanarSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
@@ -266,6 +298,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 /***************************/
 /* Coming from DiskSurface */
 /***************************/
+// DiskSurface -> CuboidalRegion
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
@@ -282,6 +315,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// DiskSurface -> SphericalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
@@ -298,6 +332,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// DiskSurface -> CylindricalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
@@ -314,6 +349,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// DiskSurface -> DiskSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
@@ -330,6 +366,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// DiskSurface -> PlanarSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
@@ -349,6 +386,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 /*****************************/
 /* Coming from PlanarSurface */
 /*****************************/
+// PlanarSurface -> CuboidalRegion
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
@@ -365,6 +403,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// PlanarSurface -> SphericalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
@@ -381,6 +420,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// PlanarSurface -> CylindricalSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
@@ -397,6 +437,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// PlanarSurface -> DiskSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
@@ -413,6 +454,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     return std::make_pair(position_type(), structure_id_type());
 };
 
+// PlanarSurface -> PlanarSurface
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,

From bb9bf12f6261cde836d46f0f78c2fbbb8771e4c5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 13:21:52 +0200
Subject: [PATCH 0958/1541] Same thing for binding from Cylinder to Disk

---
 StructureFunctions.cpp | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 9d8a8d59..bd14b2c8 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -272,10 +272,19 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    structure_id_type   new_id(    target_structure.id );
+    position_type       new_pos(   target_structure->project_point(old_pos).first );
+    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
     
-    return std::make_pair(position_type(), structure_id_type());
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+    // TODO: Assert that DiskSurface is a substructure of CylindricalSurface ?
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // interaction not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for interaction.");
 };
 
 // CylindricalSurface -> PlanarSurface

From 8a9ff549305bd46d8cfe11934d67bb26904c8b8e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Jun 2012 13:22:05 +0200
Subject: [PATCH 0959/1541] Some better commenting

---
 StructureFunctions.hpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 7718f246..2ef087da 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -23,7 +23,9 @@ class PlanarSurface;
 /*** INTERACTION HANDLERS ***/
 /****************************/
 
+/******************************/
 /* Coming from CuboidalRegion */
+/******************************/
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
@@ -54,7 +56,9 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos          );
 
+/********************************/
 /* Coming from SphericalSurface */
+/********************************/
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
@@ -85,7 +89,9 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos          );
 
+/**********************************/
 /* Coming from CylindricalSurface */
+/**********************************/
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
@@ -116,7 +122,9 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos          );
 
+/***************************/
 /* Coming from DiskSurface */
+/***************************/
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
@@ -147,7 +155,9 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos          );
                   
+/*****************************/
 /* Coming from PlanarSurface */
+/*****************************/
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,

From a04a1596102d080e5470e258648ce3f63440c5f4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 20 Jun 2012 16:10:33 +0200
Subject: [PATCH 0960/1541] Declare structure functions that yield two new
 positions / sid's

---
 StructureFunctions.hpp | 216 ++++++++++++++++++++++++++++++++++++-
 test.hpp               | 235 -----------------------------------------
 2 files changed, 213 insertions(+), 238 deletions(-)
 delete mode 100644 test.hpp

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 2ef087da..c20a394b 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -19,9 +19,18 @@ template <typename Ttraits_>
 class PlanarSurface;
 
 
-/****************************/
-/*** INTERACTION HANDLERS ***/
-/****************************/
+/******************************************************************************************/
+
+// Now declare the structure functions.
+// There are two types: 1) yielding one new position and structure id
+//                      2) yielding two new positions and structure ids
+//                         (for single reactions with two products)
+
+/******************************************************************************************/
+
+/************************/
+/*** ONE NEW POSITION ***/
+/************************/
 
 /******************************/
 /* Coming from CuboidalRegion */
@@ -189,5 +198,206 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::position_type      const& old_pos          );
 
                   
+/******************************************************************************************/
+
+
+/*************************/
+/*** TWO NEW POSITIONS ***/
+/*************************/
+
+/******************************/
+/* Coming from CuboidalRegion */
+/******************************/
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+                  template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+/********************************/
+/* Coming from SphericalSurface */
+/********************************/
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+/**********************************/
+/* Coming from CylindricalSurface */
+/**********************************/
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          );
+
+/***************************/
+/* Coming from DiskSurface */
+/***************************/
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+/*****************************/
+/* Coming from PlanarSurface */
+/*****************************/
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+                  
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure, 
+                       typename Ttraits_::position_type      const& old_pos          );
+
+                       
+/******************************************************************************************************/
+
+                  
 #endif /* STRUCTUREFUNCTIONS_HPP */
 
diff --git a/test.hpp b/test.hpp
deleted file mode 100644
index 8915a565..00000000
--- a/test.hpp
+++ /dev/null
@@ -1,235 +0,0 @@
-// Get_info
-// info is:
-// -reaction volume
-// -product position(s)/structure_id(s)
-
-// In BD, the local situation is checked by determining the overlaps.
-// -the reactant particle can overlap with other particles
-//  The overlapping particles can be on: -the current structure
-//                                       -the parent structure (or the parent of the parent)
-//                                       -a peer structure
-//                                       -a child structure (or the child of a child)
-// -the reactant particle can overlap with other surface.
-//  the overlapping surfaces are always: -the current structure (where the particle lives)
-//                                       -the parent structure (the parent always encompasses the child surface)
-//  the overlapping surface can also be: -a peer structure
-//                                       -a child structure
-
-// For the particles we can therefore have three situations. The other particles is:
-// -at the same hierarchical level -> need to decide on reaction rule where to place the particle
-// -below the current level        -> the structure of the new particle is the structure of 'the other' particle
-// -above the current level        -> the structure of the new particle is the current structure (same as previous but particles swapped)
-
-
-// particles are in the local vicinity
-// get the reaction rule for the situation
-// check that the reaction rule defines an implemented mechanism/function
-// -the product species must be able to live on one of the reactant surfaces ( product_species.STid == particle1.structure.sid/particle2.structure.sid )
-// -when calling the right function, the signature for the reaction must exist.
-//  (for example: P(region) + P(cylinder) -> P(region) is not supported, whereas P(region) + P(cylinder) -> P(cylinder) is.
-// call the right function
-
-if (particles on connected structures of same structure_type)
-    // transition/edge_crossing
-else
-    // particles live on same/different structure_types that are not connected
-    determine ordering of structures on which particles live // assume this to be unimportant or unambiguous
-    get_product_info -> (position, structure_id)
-
-
-// Here we assume that the peers/parent conditions are checked in the functions themselves. The relationship between the structure is assumed to be unambiguous or unimportant.
-get_pair_product (cuboidal_region_type const& reactant1_region,       cuboidal_region_type const& reactant2_region, cuboidal_region_type const& product_region);            // OK, structures must be peers
-get_pair_product (planar_surface_type const& reactant1_plane,         planar_surface_type const& reactant2_plane,   planar_surface_type const& product_plane);              // OK, structures must be peers
-get_pair_product (cylindrical_surface_type const& reactant1_cylinder, cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK, structures must be peers
-get_pair_product (disk_surface_type const& reactant1_disk,            disk_surface_type const& reactant2_disk, ...);                                                        // Illegal
-
-
-get_pair_product (planar_surface_type const& reactant1_plane,         cuboidal_region_type const& reactant2_region, planar_surface_type const& product_plane);         // Ok, plane must be below region
-get_pair_product (cuboidal_region_type const& reactant1_region,       planar_surface_type const& reactant2_plane,   planar_surface_type const& product_plane);         // OK, plane must be below region
-
-
-get_pair_product (cylindrical_surface_type const& reactant1_cylinder, cuboidal_region_type const& reactant2_region,       cylindrical_surface_type const& product_cylinder);// Ok,cylinder must be below region
-get_pair_product (cuboidal_region_type const& reactant1_region,       cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK,cylinder must be below region
-
-
-get_pair_product (disk_surface_type const& reactant1_disk,            cuboidal_region_type const& reactant2_region, disk_surface_type const& product_disk);     // Ok, disk must be below region (Cap/Sink + Bulk -> Cap/Sink)
-get_pair_product (cuboidal_region_type const& reactant1_region,       disk_surface_type const& reactant2_disk,      disk_surface_type const& product_disk);     // Ok, disk must be below region
-
-
-get_pair_product (cylindrical_surface_type const& reactant1_cylinder, planar_surface_type const& reactant2_plane,         ...);         // Illegal, maybe later ok if the structures are peers
-get_pair_product (planar_surface_type const& reactant1_plane,         cylindrical_surface_type const& reactant2_cylinder, ...);         // Illegal
-
-
-get_pair_product (disk_surface_type const& reactant1_disk,            planar_surface_type const& reactant2_plane, ...);                 // Illegal, maybe later ok if the structures are peers
-get_pair_product (planar_surface_type const& reactant1_plane,         disk_surface_type const& reactant2_disk,    ...);                 // Illegal
-
-
-get_pair_product (disk_surface_type const& reactant1_disk,            cylindrical_surface_type const& reactant2_cylinder, disk_surface_type const& product_disk);   // OK, disk must be below cylinder or peer of cylinder
-get_pair_product (cylindrical_surface_type const& reactant1_cylinder, disk_surface_type const& reactant2_disk, disk_surface_type const& product_disk);  // OK, disk must be below cylinder or peer of cylinder
-
-
-
-
-
-
-
-// check if the local situation allows the reaction rule to be executed
-reactant_structure = get_structure(reactant.structure_id())
-if ( product_species.sid() == reactant_structure.parent_structure.sid() )
-{
-    // The reactant_species lives on the reactant structure
-    // Then the reaction rule A(struct_a) -> B(struct_b) where struct_b is the parent of struct_a can be executed (dissociation)
-    //  because the parent structure is of the type denoted in the reaction rule.
-    get_info_to_parent(reactant_structure, parent_structure)
-}
-else if ( )
-{
-    // The reaction rule A(struct_a) -> B(struct_b) where struct_a and struct_b are peers can be executed (transfer).
-}
-else if ( )
-{
-    // The reaction A(struct_a) + struct_b -> B(struct_b), where struct_b 
-}
-
-// Single_reactions from a structure to another structure
-// When the target structure is the parent structure of the source structure
-// The structures are the structures that the particle lives on
-
-// These are functions for a single particle that moves from one structure to another
-// Note the two structures need to be 'close'. This means that:
-// -the target structure is the parent of the source structure (the parent always surrounds the child and is therefore always close)
-// -the target structure is the child of the source structure and is 'close'
-// -the target structure and source structures are peers and 'close'
-// -the two structure are actually the very same structure.
-
-// What to do:
-// The two structures are of the same type and are actually the same structure -> no changes (simple decay)
-// The two structures are of the same type (but are not the same) -> direct 'transfer' from one structure to the other (hopping or whatever)
-// The two structures are of different types -> association/dissociation reaction
-// We assume that the relationship between the structures is clear/unambigous or can be determined by the function itself.
-get_single_product (cuboidal_region_type const& region,       cuboidal_region_type const& parent_region);       // OK, hopping (Illegal for now) or simple decay (structure are the same one)
-get_single_product (planar_surface_type const& plane,         planar_surface_type const& parent_plane);         // OK, hopping (Illegal for now) or simple decay (structure are the same one)
-get_single_product (cylindrical_surface_type const& cylinder, cylindrical_surface_type const& parent_cylinder); // OK, hopping (Illegal for now) or simple decay (structure are the same one)
-get_single_product (disk_surface_type const& disk,            disk_surface_type const& parent_disk);            // OK, hopping (Illegal for now) or simple decay (structure are the same one)
-
-get_single_product (planar_surface_type const& plane,         cuboidal_region_type const& parent_region);       // OK, dissociation (region must be parent of plane)
-get_single_product (cuboidal_region_type const& region,       planar_surface_type const& parent_plane);         // OK, association
-
-get_single_product (cylindrical_surface_type const& cylinder, cuboidal_region_type const& parent_region);       // OK, dissociation (region must be parent of cylinder)
-get_single_product (cuboidal_region_type const& region,       cylindrical_surface_type const& parent_cylinder); // OK, association
-
-get_single_product (disk_surface_type const& disk,            cuboidal_region_type const& parent_region);       // OK, dissociation (Cap -> Bulk)
-get_single_product (cuboidal_region_type const& region,       disk_surface_type const& parent_disk);            // Illegal for now (association from bulk)
-
-get_single_product (cylindrical_surface_type const& cylinder, planar_surface_type const& parent_plane);         // Illegal
-get_single_product (planar_surface_type const& plane,         cylindrical_surface_type const& parent_cylinder); // Illegal
-get_single_product (disk_surface_type const& disk,            planar_surface_type const& parent_plane);         // Illegal
-get_single_product (planar_surface_type const& plane,         disk_surface_type const& parent_disk);            // Illegal
-
-get_single_product (disk_surface_type const& disk,            cylindrical_surface_type const& parent_cylinder); // OK Sink/Cap -> Cylinder
-get_single_product (cylindrical_surface_type const& cylinder, disk_surface_type const& parent_disk);            // OK Cylinder -> Sink/Cap
-
-
-
-
-
-
-get_product_pair (cuboidal_region_type const& reactant_region,       cuboidal_region_type const& product1_region, cuboidal_region_type const& product2_region);            // OK, structures must be the same
-get_product_pair (planar_surface_type const& reactant_plane,         planar_surface_type const& product1_plane,   planar_surface_type const& product2_plane);              // OK, structures must be the same
-get_product_pair (cylindrical_surface_type const& reactant_cylinder, cylindrical_surface_type const& product1_cylinder, cylindrical_surface_type const& product2_cylinder);// OK, structures must be the same
-get_product_pair (disk_surface_type const& reactant_disk,            disk_surface_type const& product1_disk, disk_surface_type const& product2_disk);                      // Illegal
-                
-                
-get_product_pair (planar_surface_type const& reactant_plane,         cuboidal_region_type const& product1_region, planar_surface_type const& product_plane);         // Ok, plane must be below region
-get_product_pair (cuboidal_region_type const& reactant_region,       planar_surface_type const& product1_plane,   planar_surface_type const& product_plane);         // OK, plane must be below region
-                
-                
-get_product_pair (cylindrical_surface_type const& reactant_cylinder, cuboidal_region_type const& reactant2_region,       cylindrical_surface_type const& product_cylinder);// Ok,cylinder must be below region
-get_product_pair (cuboidal_region_type const& reactant_region,       cylindrical_surface_type const& reactant2_cylinder, cylindrical_surface_type const& product_cylinder);// OK,cylinder must be below region
-                
-                
-get_product_pair (disk_surface_type const& reactant_disk,            cuboidal_region_type const& reactant2_region, disk_surface_type const& product_disk);     // Ok, disk must be below region (Cap/Sink + Bulk -> Cap/Sink)
-get_product_pair (cuboidal_region_type const& reactant_region,       disk_surface_type const& reactant2_disk,      disk_surface_type const& product_disk);     // Ok, disk must be below region
-                
-                
-get_product_pair (cylindrical_surface_type const& reactant_cylinder, planar_surface_type const& reactant2_plane,         ...);         // Illegal, maybe later ok if the structures are peers
-get_product_pair (planar_surface_type const& reactant_plane,         cylindrical_surface_type const& reactant2_cylinder, ...);         // Illegal
-                
-                
-get_product_pair (disk_surface_type const& reactant_disk,            planar_surface_type const& reactant2_plane, ...);                 // Illegal, maybe later ok if the structures are peers
-get_product_pair (planar_surface_type const& reactant_plane,         disk_surface_type const& reactant2_disk,    ...);                 // Illegal
-                
-                
-get_product_pair (disk_surface_type const& reactant_disk,            cylindrical_surface_type const& reactant2_cylinder, disk_surface_type const& product_disk);   // OK, disk must be below cylinder or peer of cylinder
-get_product_pair (cylindrical_surface_type const& reactant_cylinder, disk_surface_type const& reactant2_disk, disk_surface_type const& product_disk);  // OK, disk must be below cylinder or peer of cylinder
-
-
-
-class Structure
-{
-    virtual position_type method(structure_type const& target_structure, position_type const& position) = 0;
-}
-
-class PlanarSurface : Structure
-{
-
-    virtual position_type method(structure_type const& target_structure, position_type const& position)
-    {
-        return target_structure.get_pos(*this, position);
-    }
-
-    template <Tstruct_>
-    virtual position_type get_pos(Tstruct_ const& origin_structure, position_type const& position)
-    {
-        return ::get_pos(origin_structure, *this, position);
-    }
-
-}
-
-class CylindricalSurface
-{
-
-    virtual position_type method(structure_type const& target_structure, position_type const& position)
-    {
-        return target_structure.get_pos(*this, position);
-    }
-
-    template <Tstruct_>
-    virtual position_type get_pos(Tstruct_ const& origin_structure, position_type const& position)
-    {
-        return ::get_pos(origin_structure, *this, position);
-    }
-
-}
-
-#include "PlanarSurface.hpp"
-#include "CylindricalSurface.hpp"
-#include "DiskSurface.hpp"
-
-template <Ttraits_>
-position_type get_pos(PlanarSurface<Ttraits_> const& origin_structure,
-                      PlanarSurface<Ttraits_> const& target_structure, typename Ttraits_::position_type const& old_pos)
-{
-    typedef typename Ttraits_::structure_id_type structure_id_type;
-    typedef typename Ttraits_::position_type     position_type;
-
-    const structure_id_type id();
-    return std::make_pair(target_structure.project_point(old_pos), target_structure.id());
-}
-
-get_pos(cylinder_surface_type, cylinder_surface_type)
-{
-    throw exception;
-}
-template <Ttraits_>
-inline PlanarSurface<Ttraits_>::position_structid_pair_type
-get_pos(CylindricalSurface<Ttraits_> origin_structure,
-        planar_surface_type);
-
-
-get_pos(planar_surface_type, cylinder_surface_type);
-
-
-newBDthing
-    new_pos = source_structure.method(target_structure, old_pos);
-

From 903a11cb839c450bce62e9afce834f36c41f3eef Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 20 Jun 2012 16:27:50 +0200
Subject: [PATCH 0961/1541] Define structure functions that yield two new
 positions / sid's

... which again, for now, throw an exception as a default.

Specific functionality will be successively filled in next.
---
 StructureFunctions.cpp | 515 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 512 insertions(+), 3 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index bd14b2c8..3732e1e5 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -10,9 +10,18 @@
 #include "exceptions.hpp"
 
 
-/****************************/
-/*** INTERACTION HANDLERS ***/
-/****************************/
+/******************************************************************************************/
+
+// Define the structure functions and the actions performed in each case.
+// There are two types: 1) yielding one new position and structure id
+//                      2) yielding two new positions and structure ids
+//                         (for single reactions with two products)
+
+/******************************************************************************************/
+
+/************************/
+/*** ONE NEW POSITION ***/
+/************************/
 
 /******************************/
 /* Coming from CuboidalRegion */
@@ -481,6 +490,506 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 };
 
 
+/******************************************************************************************/
+
+
+/*************************/
+/*** TWO NEW POSITIONS ***/
+/*************************/
+
+/******************************/
+/* Coming from CuboidalRegion */
+/******************************/
+// CuboidalRegion -> CuboidalRegion
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CuboidalRegion -> SphericalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CuboidalRegion -> CylindricalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+    
+};
+
+// CuboidalRegion -> DiskSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CuboidalRegion -> PlanarSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+/********************************/
+/* Coming from SphericalSurface */
+/********************************/
+// SphericalSurface -> CuboidalRegion
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// SphericalSurface -> SphericalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// SphericalSurface -> CylindricalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// SphericalSurface -> DiskSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// SphericalSurface -> PlanarSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+/**********************************/
+/* Coming from CylindricalSurface */
+/**********************************/
+// CylindricalSurface -> CuboidalRegion
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CylindricalSurface -> CylindricalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CylindricalSurface -> SphericalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CylindricalSurface -> DiskSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CylindricalSurface -> PlanarSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+/***************************/
+/* Coming from DiskSurface */
+/***************************/
+// DiskSurface -> CuboidalRegion
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// DiskSurface -> SphericalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// DiskSurface -> CylindricalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// DiskSurface -> DiskSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// DiskSurface -> PlanarSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+/*****************************/
+/* Coming from PlanarSurface */
+/*****************************/
+// PlanarSurface -> CuboidalRegion
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       CuboidalRegion<Ttraits_>              const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// PlanarSurface -> SphericalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       SphericalSurface<Ttraits_>            const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// PlanarSurface -> CylindricalSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       CylindricalSurface<Ttraits_>          const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// PlanarSurface -> DiskSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       DiskSurface<Ttraits_>                 const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// PlanarSurface -> PlanarSurface
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
+                       PlanarSurface<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type      const& old_pos          )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+/******************************************************************************************************/
+
 
 #endif /* STRUCTUREFUNCTIONS_CPP */
 

From 5a0c57367fd0f03275c6d9253eb0168f71527d57 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 22 Jun 2012 11:47:39 +0200
Subject: [PATCH 0962/1541] Default implementation for one particle single
 reactions + decay without structure change

---
 StructureFunctions.cpp | 147 +++++++++++++++++++++++------------------
 1 file changed, 82 insertions(+), 65 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 3732e1e5..f2bdffeb 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -36,11 +36,15 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
     
-    return std::make_pair(position_type(), structure_id_type());
+    // Currently only species change and decay are supported
+    if(origin_structure.id == target_structure.id){
+     
+          return std::make_pair( old_pos, origin_structure.id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
 };
 
 // CuboidalRegion -> SphericalSurface
@@ -55,7 +59,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -80,9 +84,9 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
      
           return std::make_pair( new_pos, new_id );
     }
-    else // interaction not allowed
+    else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for interaction.");
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
     
 };
 
@@ -98,7 +102,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -123,9 +127,9 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
      
           return std::make_pair( new_pos, new_id );
     }
-    else // interaction not allowed
+    else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for interaction.");
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
 };
 
 /********************************/
@@ -143,7 +147,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -160,7 +164,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -177,7 +181,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -194,7 +198,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -211,7 +215,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -231,7 +235,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -247,10 +251,14 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
+    // Currently only species change and decay are supported
+    if(origin_structure.id == target_structure.id){
+     
+          return std::make_pair( old_pos, origin_structure.id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
 };
 
 // CylindricalSurface -> SphericalSurface
@@ -265,7 +273,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -291,9 +299,9 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
      
           return std::make_pair( new_pos, new_id );
     }
-    else // interaction not allowed
+    else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for interaction.");
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
 };
 
 // CylindricalSurface -> PlanarSurface
@@ -308,7 +316,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -328,7 +336,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -345,7 +353,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -362,7 +370,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -378,10 +386,14 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
+    // Currently only species change and decay are supported
+    if(origin_structure.id == target_structure.id){
+     
+          return std::make_pair( old_pos, origin_structure.id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");    
 };
 
 // DiskSurface -> PlanarSurface
@@ -396,7 +408,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -416,7 +428,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -433,7 +445,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -450,7 +462,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -467,7 +479,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -483,10 +495,15 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
+    // Currently only species change and decay are supported
+    // TODO Implement transitions from one plane to another
+    if(origin_structure.id == target_structure.id){
+     
+          return std::make_pair( old_pos, origin_structure.id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
 };
 
 
@@ -513,7 +530,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -532,7 +549,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -551,7 +568,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -571,7 +588,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -590,7 +607,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -612,7 +629,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -631,7 +648,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -650,7 +667,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -669,7 +686,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -688,7 +705,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -710,7 +727,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -729,7 +746,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -748,7 +765,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -767,7 +784,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -786,7 +803,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -808,7 +825,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -827,7 +844,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -846,7 +863,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -865,7 +882,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -884,7 +901,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -906,7 +923,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -925,7 +942,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -944,7 +961,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -963,7 +980,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -982,7 +999,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Interaction between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );

From cde4d89f8dc5a1f791c64efe17fb7985cc0f1ed0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 22 Jun 2012 12:07:25 +0200
Subject: [PATCH 0963/1541] Also allow for binding from Cube to Disk

---
 StructureFunctions.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index f2bdffeb..3e699fa5 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -101,10 +101,18 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    structure_id_type   new_id(    target_structure.id );
+    position_type       new_pos(   target_structure->project_point(old_pos).first );
+    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
     
-    return std::make_pair(position_type(), structure_id_type());
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
 };
 
 // CuboidalRegion -> PlanarSurface

From accbfa66530b556eb19a134ef36670cd37680c80 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 22 Jun 2012 12:13:56 +0200
Subject: [PATCH 0964/1541] Cross-call function with different origin and
 target structure type

---
 StructureFunctions.cpp | 18 ++++++------------
 1 file changed, 6 insertions(+), 12 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 3e699fa5..642ec207 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -241,11 +241,9 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
-    return std::make_pair(position_type(), structure_id_type());
+    // Call corresponding function for type combination (Cube, Cylinder, position)
+    return get_pos_sid_pair( target_structure, origin_structure, old_pos);
 };
 
 // CylindricalSurface -> CylindricalSurface
@@ -343,10 +341,8 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
+    // Call corresponding function for type combination (Cube, Disk, position)
+    return get_pos_sid_pair( target_structure, origin_structure, old_pos);
 };
 
 // DiskSurface -> SphericalSurface
@@ -435,10 +431,8 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
+    // Call corresponding function for type combination (Cube, Plane, position)
+    return get_pos_sid_pair( target_structure, origin_structure, old_pos);
 };
 
 // PlanarSurface -> SphericalSurface

From c62f8f9b686e14f68b7e424d36dbdeea702da5e0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 27 Jun 2012 18:31:55 +0200
Subject: [PATCH 0965/1541] Revert last change and use the functions with
 target_structure = cube for unbinding in the first place.

The right choice of origin and target structure in case of a mixed pair
reaction will have to be made before the functions with origin_structure = cube
will be called to process the CoM.
---
 StructureFunctions.cpp | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 642ec207..cd9db911 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -242,8 +242,10 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
     
-    // Call corresponding function for type combination (Cube, Cylinder, position)
-    return get_pos_sid_pair( target_structure, origin_structure, old_pos);
+    // Return trivial data, i.e. the position at which the single reaction happens
+    // and the id of the target structure; the position still has to be post-processed
+    // via target_structure functions making use of the species radius etc.
+    return std::make_pair(old_pos, target_structure.id);
 };
 
 // CylindricalSurface -> CylindricalSurface
@@ -341,8 +343,10 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    // Call corresponding function for type combination (Cube, Disk, position)
-    return get_pos_sid_pair( target_structure, origin_structure, old_pos);
+    // Return trivial data, i.e. the position at which the single reaction happens
+    // and the id of the target structure; the position still has to be post-processed
+    // via target_structure functions making use of the species radius etc.
+    return std::make_pair(old_pos, target_structure.id);
 };
 
 // DiskSurface -> SphericalSurface
@@ -431,8 +435,10 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    // Call corresponding function for type combination (Cube, Plane, position)
-    return get_pos_sid_pair( target_structure, origin_structure, old_pos);
+    // Return trivial data, i.e. the position at which the single reaction happens
+    // and the id of the target structure; the position still has to be post-processed
+    // via target_structure functions making use of the species radius etc.
+    return std::make_pair(old_pos, target_structure.id);
 };
 
 // PlanarSurface -> SphericalSurface

From 8e184766664ea33e22e5a9420bccc7a6dccf6e3f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 29 Jun 2012 18:31:00 +0200
Subject: [PATCH 0966/1541] Rename StructureFunction methods of structures once
 again

---
 CuboidalRegion.hpp     | 6 +++---
 CylindricalSurface.hpp | 6 +++---
 DiskSurface.hpp        | 6 +++---
 PlanarSurface.hpp      | 6 +++---
 SphericalSurface.hpp   | 6 +++---
 Structure.hpp          | 4 ++--
 6 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 1e38fc22..9fa3a425 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -154,13 +154,13 @@ class CuboidalRegion
     }
     
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.interaction_info_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 3e8d775d..89b77c29 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -233,13 +233,13 @@ class CylindricalSurface
     }
     
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.interaction_info_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 9cd1ef6d..1fc779fc 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -249,13 +249,13 @@ class DiskSurface
     }
 
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.interaction_info_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 0abb622f..758aab0b 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -218,13 +218,13 @@ class PlanarSurface
     }
 
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.interaction_info_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index eca13a71..f69a5656 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -125,13 +125,13 @@ class SphericalSurface
     }
 
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
-        return target_structure.interaction_info_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position);
     }
 
     template <typename Tstruct_>
-    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
diff --git a/Structure.hpp b/Structure.hpp
index 7439f7cb..dca91b78 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -133,9 +133,9 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
     ///// TESTING TESTING TESTING TESTING TESTING
-    virtual position_structid_pair_type interaction_info(structure_type const& target_structure, position_type const& position) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_type interaction_info_helper(Tstruct_ const& origin_structure, position_type const& position) const;
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const;
     ///// END TESTING TESTING TESTING TESTING TESTING
 
 

From f8609582e9f69f9ba41e4e5e1633535d8ad0b17e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 29 Jun 2012 18:31:30 +0200
Subject: [PATCH 0967/1541] Test-implement structure function for single
 reaction with one prod. into newBDPropagator

---
 StructureFunctions.hpp |  2 +-
 newBDPropagator.hpp    | 44 ++++++++++++++++++++++++++++++++----------
 2 files changed, 35 insertions(+), 11 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index c20a394b..3d4a086a 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -41,7 +41,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos          );
 
-                  template <typename Ttraits_>
+template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index f19bf5c3..07ab1f40 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -19,6 +19,7 @@
 #include "utils/random.hpp"
 #include "utils/get_default_impl.hpp"
 #include "Logger.hpp"
+#include "StructureFunctions.hpp"
 
 #include <iostream>
 
@@ -41,9 +42,9 @@ class newBDPropagator
     typedef typename particle_container_type::structure_type        structure_type;
     typedef typename particle_container_type::structure_id_type     structure_id_type;    
 
-    typedef typename particle_container_type::particle_id_pair_generator         particle_id_pair_generator;
-    typedef typename particle_container_type::particle_id_pair_and_distance      particle_id_pair_and_distance;
-    typedef typename particle_container_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
+    typedef typename particle_container_type::particle_id_pair_generator          particle_id_pair_generator;
+    typedef typename particle_container_type::particle_id_pair_and_distance       particle_id_pair_and_distance;
+    typedef typename particle_container_type::particle_id_pair_and_distance_list  particle_id_pair_and_distance_list;
     typedef typename particle_container_type::structure_id_pair_and_distance      structure_id_pair_and_distance;
     typedef typename particle_container_type::structure_id_pair_and_distance_list structure_id_pair_and_distance_list;
     typedef typename traits_type::world_type::traits_type::rng_type rng_type;
@@ -404,14 +405,36 @@ class newBDPropagator
                     /*** ONE PRODUCT ***/
                     case 1:
                     {
-                        const position_type                             reactant_pos(pp.second.position());
+                        const position_type                             reactant_pos( pp.second.position() );
                         const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure(pp.second.structure_id()) );
-                        const species_type                              product_species(tx_.get_species(products[0]));
-
-                        // set default values for the position and structure of the product
-                        position_structid_pair_type     product_pos_struct_id (std::make_pair(reactant_pos, pp.second.structure_id()));
+                        const structure_id_type                         reactant_structure_id( pp.second.structure_id() );
+                        const species_type                              product_species( tx_.get_species(products[0]) );
+                        
+                        // Set default values for the position and structure of the product
+                        // As a default, the product stays on the structure of origin
+                        boost::shared_ptr<const structure_type> product_structure( reactant_structure );
+                        position_structid_pair_type             product_pos_struct_id (std::make_pair(reactant_pos, reactant_structure_id));
                         
-                        //// 1 - CREATE NEW POSITION AND STRUCTURE ID                        
+                        //// 1 - CREATE NEW POSITION AND STRUCTURE ID                                                
+                        if( product_species.structure_type_id() != reactant_structure->sid() )
+                        {
+                            // Get target structure id
+                            const structure_id_type product_structure_id(reactant_structure->structure_id()); // the parent structure
+                                  // TODO Allow for unbinding Disk->Cube; in that case the prod. structure is not the parent one!
+                            const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
+                            // Produce new position and structure id                            
+                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos) );
+                            // Care for exit point from structures, which depends on product radius; TODO This is ugly and corrupts the sense of StructureFunctions!
+                            const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
+                            const position_type product_pos( add(new_pos_sid_pair.first, displacement) );
+                            
+                            product_pos_struct_id = std::make_pair(product_pos, new_pos_sid_pair.second);
+                            // Apply boundary conditions
+                            product_pos_struct_id = tx_.apply_boundary( product_pos_struct_id );
+                            // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
+                            product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
+                        }
+                        /* OLD VERSION
                         // If the product particle does NOT live on the same structure type as the reactant => structure -> superstructure dissociation.
                         // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         if( product_species.structure_type_id() != reactant_structure->sid() )
@@ -422,12 +445,13 @@ class newBDPropagator
                             const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
                             const position_type product_pos (tx_.apply_boundary( add( reactant_pos, displacement ) ));
                             // When dissociating, the new structure is the parent structure (is this always true?)
-                            const structure_id_type product_structure_id (reactant_structure->structure_id()); // TODO WHY IS THAT NOT parent_structure_id() ?
+                            const structure_id_type product_structure_id (reactant_structure->structure_id());
 
                             product_pos_struct_id = std::make_pair(product_pos, product_structure_id);
                             // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
+                        */
 
                         //// 2- CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos_struct_id.first, product_species.radius());

From f49196092c8e9b1a03af0d32077d1f74ca21559f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 29 Jun 2012 19:05:24 +0200
Subject: [PATCH 0968/1541] Test-define structure_container_type in
 newBDPropagator

---
 newBDPropagator.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 07ab1f40..56f609b4 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -19,7 +19,6 @@
 #include "utils/random.hpp"
 #include "utils/get_default_impl.hpp"
 #include "Logger.hpp"
-#include "StructureFunctions.hpp"
 
 #include <iostream>
 
@@ -29,6 +28,7 @@ class newBDPropagator
 public:
     typedef Ttraits_ traits_type;
     typedef typename Ttraits_::world_type::particle_container_type  particle_container_type;
+    typedef typename Ttraits_::world_type::structure_container_type structure_container_type;
 
     // shorthand typedef that we use
     typedef typename particle_container_type::length_type           length_type;

From b98923e1e90d6e6f94b30462510d503d4fad2e3e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 12:52:46 +0200
Subject: [PATCH 0969/1541] Slightly improve commenting and readability

---
 ParticleContainerBase.hpp | 17 ++++++++++++++++-
 ParticleSimulator.hpp     |  6 +++---
 World.hpp                 | 10 ++++++++--
 3 files changed, 27 insertions(+), 6 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index f11d9881..29f5f210 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -378,28 +378,43 @@ class ParticleContainerBase
         return pmat_.erase(id);
     }
 
-    ///// Structure stuff
+    ///// Structure methods
+    ///// The following are mostly wrappers of the methods defined in StructureContainer
+    ///// and handle structure connectivity and boundary application.
+    
+    // Check for whether a container contains a structure with a certain ID
     virtual bool has_structure(structure_id_type const& id) const
     {
         return structures_.has_structure(id);
     }
+    
+    // Getter structure_id -> structure
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const
     {
         return structures_.get_structure(id);
     }
+    
+    // Get range of structures in container
     virtual structures_range get_structures() const
     {
         return structures_.get_structures_range();
     }
+    
+    // Update structure wrapper
     template <typename Tstructid_pair_>
     bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         return structures_.update_structure(structid_pair);
     }
+    
+    // Remove structure wrapper
     virtual bool remove_structure(structure_id_type const& id)
     {
         return structures_.remove_structure(id);
     }
+    
+    // Get all structures close to a position pos, taking care of structure types
+    // and an ignore parameter
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const
     {
diff --git a/ParticleSimulator.hpp b/ParticleSimulator.hpp
index 6d5f3f90..908ff58c 100644
--- a/ParticleSimulator.hpp
+++ b/ParticleSimulator.hpp
@@ -125,9 +125,9 @@ class ParticleSimulator
     typedef typename traits_type::network_rules_type    network_rules_type;
     typedef typename world_traits_type::rng_type        rng_type;
     typedef typename traits_type::time_type             time_type;
-    typedef typename traits_type::reaction_record_type      reaction_record_type;
-    typedef typename traits_type::reaction_recorder_type    reaction_recorder_type;
-    typedef typename traits_type::volume_clearer_type volume_clearer_type;
+    typedef typename traits_type::reaction_record_type   reaction_record_type;
+    typedef typename traits_type::reaction_recorder_type reaction_recorder_type;
+    typedef typename traits_type::volume_clearer_type    volume_clearer_type;
 
 public:
     virtual ~ParticleSimulator() {}
diff --git a/World.hpp b/World.hpp
index 4fcb3ed2..4e815214 100644
--- a/World.hpp
+++ b/World.hpp
@@ -378,7 +378,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         update_structure(std::make_pair(structure_id, structure));
         return structure_id;
     }
-    // update structure
+    
+    // Update structure
     template <typename Tstructid_pair_>
     bool update_structure(Tstructid_pair_ const& structid_pair)
     {
@@ -408,7 +409,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         particleonstruct_pool_[structid_pair.first] = particle_id_set();
         return true;
     }
-    // remove structure
+    
+    // Remove structure
     virtual bool remove_structure(structure_id_type const& id)
     {
         // TODO
@@ -434,11 +436,14 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
         return (*i).second;
     }
+    
     // Get and set the default structure of the World
+    // The getter
     virtual structure_id_type get_def_structure_id() const
     {
         return base_type::structures_.get_def_structure_id();
     }
+    // The setter
     void set_def_structure(const boost::shared_ptr<cuboidal_region_type> cuboidal_region)
     {
         const structure_id_type default_struct_id(get_def_structure_id());
@@ -460,6 +465,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         cuboidal_region->set_id(default_struct_id);
         update_structure(std::make_pair(default_struct_id, cuboidal_region));
     }
+    
     // Get all the particle ids of the particles on a structure
     particle_id_set get_particle_ids_on_struct(structure_id_type const& struct_id) const
     {

From c1c8092972a21748a5ec5621be3b9ddf8434521c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 15:54:29 +0200
Subject: [PATCH 0970/1541] Extend commenting and some cleanup of Structure and
 structures

---
 CuboidalRegion.hpp     |  55 ++++++++++++--------
 CylindricalSurface.hpp | 109 +++++++++++++++++++++------------------
 DiskSurface.hpp        | 112 +++++++++++++++++++++++------------------
 PlanarSurface.hpp      |  70 +++++++++++++++-----------
 SphericalSurface.hpp   |  44 ++++++++--------
 Structure.hpp          |  11 ++--
 6 files changed, 225 insertions(+), 176 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 9fa3a425..68d1548f 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -37,7 +37,7 @@ class CuboidalRegion
     typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
 
 
-
+    /*** Simple structure-specific sampling functions ***/
     virtual position_type random_position(rng_type& rng) const
     {
         return ::random_position(base_type::shape(),
@@ -60,35 +60,21 @@ class CuboidalRegion
             rng.normal(0., r),
             rng.normal(0., r));
     }
-
-    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, 
-                                    Real const& D01, Real const& v) const
-    {
-         return drawR_gbd_3D(rnd, r01, dt, D01);
-    }
-
-    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
-                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
-    {
-         return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
-    }
-
-    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
-                                                Real const& D01, Real const& v ) const
-    {
-        return random_vector( drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v ), rng );
-    }
     
+    /*** New BD scheme functions ***/
+    // Rate for binding to particle on the structure
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01 ) const
     {
         return k / ( 4 * M_PI * r01 * r01 );    
     }
     
+    // Rate for binding to the structure
     virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
         return Real(); //No reaction rates with bulk;
     }
 
+    // Reaction volume for binding to particle in the structure
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
         length_type const r01l( r01 + rl );
@@ -98,16 +84,19 @@ class CuboidalRegion
         return 4.0/3.0 * M_PI * ( r01l_cb - r01_cb );
     }
     
+    // Reaction volume for binding to the structure
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
         return Real(); //No surface interaction with the bulk
     }
 
+    // Vector of dissociation from the structure into the bulk
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         return position_type(); //No surface dissociation 'from' the bulk
     }
 
+    // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
         length_type const& rl ) const
     {
@@ -128,17 +117,20 @@ class CuboidalRegion
                                     op + m * s1.D() / D01 );
     }
     
+    // Positions created at dissociation of one particle on the structure into two particles, one of which ends up in the bulk
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
         position_type const& op_surf, length_type const& rl ) const
     {
         return position_pair_type(); //No special geminate dissociation 'from' the bulk
     }
     
+    // Used by newBDPropagator
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         return base_type::distance(new_pos);
     }
 
+    /*** Boundary condition handling ***/
     // The apply boundary for the cuboidal structure doesn't have to do anything because we'll apply the world
     // boundary conditions later too.
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
@@ -153,18 +145,37 @@ class CuboidalRegion
         return pos_struct_id;       // The cyclic_transpose does nothing because we'll apply world cyclic transpose later.
     }
     
-    ///// TESTING TESTING TESTING TESTING TESTING
+    /*** Despatch switchbox for structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position);
     }
-
+    // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
-    ///// END TESTING TESTING TESTING TESTING TESTING
+    
+    /*** Formerly used functions of the Morelli scheme ***/
+    // DEPRECATED
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, 
+                                    Real const& D01, Real const& v) const
+    {
+         return drawR_gbd_3D(rnd, r01, dt, D01);
+    }
+    // DEPRECATED
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
+    {
+         return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
+    }
+    // DEPRECATED
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
+    {
+        return random_vector( drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v ), rng );
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 89b77c29..ff271b25 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -40,79 +40,46 @@ class CylindricalSurface
     typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
 
 
-
-    virtual position_type random_position(rng_type& rng) const
-    // Gives a random position in the cylinder (1D)
+    /*** Simple structure-specific sampling functions ***/
+    // Produce a random position in the cylinder (1D)
+    virtual position_type random_position(rng_type& rng) const    
     {
         return ::random_position(base_type::shape(), boost::bind(&rng_type::uniform, rng, -1., 1.));
     }
 
+    // Produce a random vector along the axis of the cylinder
     virtual position_type random_vector(length_type const& r, rng_type& rng) const
-    // Gives a random vector in the axis of the cylinder
     {
         return multiply(base_type::shape().unit_z(),
                 (rng.uniform_int(0, 1) * 2 - 1) * r);
     }
 
+    // BD displacement for BD on the axis of the cylinder
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
-    // BD displacement for BD on the line of the cylinder?
     {
         return multiply(base_type::shape().unit_z(), rng.normal(mean, r));
     }
-
-    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
-    {
-        return drawR_gbd_1D(rnd, r01, dt, D01, v);
-    }
-
-    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
-                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
-    {
-        /*
-            The I_bd factors used for calculating the acceptance probability are dependent on the direction 
-            of the overlap step (r = r_1 - r_0), compared to the direction of the drift. 
-            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0).
-            Since the I_bd terms calulated here are for the backward move, we have to invert their drifts.
-            When the particle comes from the left (r > 0) we have to invert its drift again.
-
-            ---Code below is used for drift dependent backstep.
-
-            Real numerator = g_bd_1D(ipv, r01, dt, D0, -v0);
-            Real denominator = g_bd_1D(ipv, r01, dt, D0, v0)*exp( ipv/abs_ipv*(abs_ipv - r01)*v/D01 );
-            Real correction = numerator/denominator;
-            if( ipv < 0 )
-                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, -v0) + I_bd_1D(r01, dt, D1, v1) ) );
-            else
-                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, -v1) ) );
-
-            Also change v -> -v in drawR for the dissociation move.
-        */
-
-        return 0.5*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
-  
-    }
-
-    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
-                                                Real const& D01, Real const& v ) const
-    {
-        return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
-    }
     
+    /*** New BD scheme functions ***/
+    // Rate for binding to particle on the structure
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
     {
         return k;
     }
     
+    // Rate for binding to the structure
     virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
         return k / ( 2 * M_PI * (base_type::shape().radius() + r0 ) );
     }
 
+    // Reaction volume for binding to particle in the structure
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
         return rl;
     }
 
+    // Reaction volume for binding to the structure
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
         length_type rc( base_type::shape().radius() + r0 ); 
@@ -123,6 +90,7 @@ class CylindricalSurface
         return M_PI * ( rcl_sq - rc_sq );
     }
     
+    // Vector of dissociation from the structure into the bulk
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         Real X( rng.uniform(0.,1.) );
@@ -141,6 +109,7 @@ class CylindricalSurface
         return multiply( v, diss_vec_length); 
     }
 
+    // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
         length_type const& rl ) const
     {
@@ -157,6 +126,7 @@ class CylindricalSurface
                                     op + m * s1.D() / D01 );
     }
     
+    // Positions created at dissociation of one particle on the structure into two particles, one of which ends up in the bulk
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
         position_type const& op_surf, length_type const& rl ) const
     {
@@ -206,19 +176,23 @@ class CylindricalSurface
         
         return pp01;
     }
+    
+    // Used by newBDPropagator
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         return base_type::distance(new_pos);
     }
-/*
+    
+    /* TODO what is that?
     virtual length_type minimal_distance(length_type const& radius) const
     {
         length_type cylinder_radius = base_type::shape().radius();
         // Return minimal distance *to* surface.
         return (cylinder_radius + radius) * traits_type::MINIMAL_SEPARATION_FACTOR - cylinder_radius;
     }
-*/
+    */
 
+    /*** Boundary condition handling ***/
     // FIXME This is a mess but it works. See ParticleContainerBase.hpp for explanation.
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
@@ -232,18 +206,57 @@ class CylindricalSurface
         return pos_struct_id;       // for now we do not support connected cylindrical surfaces.
     }
     
-    ///// TESTING TESTING TESTING TESTING TESTING
+    /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position);
     }
-
+    // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
-    ///// END TESTING TESTING TESTING TESTING TESTING
+    
+    /*** Formerly used functions of the Morelli scheme ***/
+    // DEPRECATED
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
+    {
+        return drawR_gbd_1D(rnd, r01, dt, D01, v);
+    }
+    // DEPRECATED
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
+    {
+        /*
+            The I_bd factors used for calculating the acceptance probability are dependent on the direction 
+            of the overlap step (r = r_1 - r_0), compared to the direction of the drift. 
+            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0).
+            Since the I_bd terms calulated here are for the backward move, we have to invert their drifts.
+            When the particle comes from the left (r > 0) we have to invert its drift again.
+
+            ---Code below is used for drift dependent backstep.
+
+            Real numerator = g_bd_1D(ipv, r01, dt, D0, -v0);
+            Real denominator = g_bd_1D(ipv, r01, dt, D0, v0)*exp( ipv/abs_ipv*(abs_ipv - r01)*v/D01 );
+            Real correction = numerator/denominator;
+            if( ipv < 0 )
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, -v0) + I_bd_1D(r01, dt, D1, v1) ) );
+            else
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, -v1) ) );
+
+            Also change v -> -v in drawR for the dissociation move.
+        */
+
+        return 0.5*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
+  
+    }
+    // DEPRECATED
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
+    {
+        return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 1fc779fc..9d8be40c 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -37,67 +37,29 @@ class DiskSurface
     typedef std::pair<position_type, position_type>         position_pair_type;
     typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
-    virtual position_type random_position(rng_type& rng) const
-    // Gives a "random position" in the disk, which is always its center,
-    // the only "legal" position
+    
+    /*** Simple structure-specific sampling functions ***/
+    // Produce a "random position" in the disk, which is always its center (the only legal pos.)
+    virtual position_type random_position(rng_type& rng) const        
     {
         return ::random_position(base_type::shape(), boost::bind(&rng_type::uniform, rng, -1., 1.));
         // return base_type::shape().position(); // TODO maybe this variant is better
     }
 
-    virtual position_type random_vector(length_type const& r, rng_type& rng) const
-    // Gives a "random vector" on the disk; returns the same as random_position()
+    // Procude a "random vector" on the disk; returns the same as random_position()
+    virtual position_type random_vector(length_type const& r, rng_type& rng) const    
     {
         return base_type::shape().position();
     }
 
-    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
     // BD displacement = zero vector because there is only one legal position on the disk
+    virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
     {
         return multiply(base_type::shape().unit_z(), 0.0);  // TODO is there not cheaper way to pass a zero vector?
     }
-
-    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
-    {
-         // TODO: This is part of the old BD scheme and should be removed at some point
-        return drawR_gbd_1D(rnd, r01, dt, D01, v);
-    }
-
-    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
-                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
-    {
-        // TODO: This is part of the old BD scheme and should be removed at some point
-        /*
-            The I_bd factors used for calculating the acceptance probability are dependent on the direction 
-            of the overlap step (r = r_1 - r_0), compared to the direction of the drift. 
-            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0).
-            Since the I_bd terms calulated here are for the backward move, we have to invert their drifts.
-            When the particle comes from the left (r > 0) we have to invert its drift again.
-
-            ---Code below is used for drift dependent backstep.
-
-            Real numerator = g_bd_1D(ipv, r01, dt, D0, -v0);
-            Real denominator = g_bd_1D(ipv, r01, dt, D0, v0)*exp( ipv/abs_ipv*(abs_ipv - r01)*v/D01 );
-            Real correction = numerator/denominator;
-            if( ipv < 0 )
-                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, -v0) + I_bd_1D(r01, dt, D1, v1) ) );
-            else
-                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, -v1) ) );
-
-            Also change v -> -v in drawR for the dissociation move.
-        */
-
-        return 0.5*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
-  
-    }
-
-    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
-                                                Real const& D01, Real const& v ) const
-    {
-        // TODO: This is part of the old BD scheme and should be removed at some point
-        return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
-    }
     
+    /*** New BD scheme functions ***/
+    // Rate for binding to particle on the structure
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
     {
         // This rate does not make sense on the ("zero-dimensional") disk object
@@ -106,17 +68,20 @@ class DiskSurface
         return 0.0;
     }
     
+    // Rate for binding to the structure
     virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
         return k;
     }
 
+    // Reaction volume for binding to particle in the structure
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
         // The disk can only hold 1 particle; this function therefore never should be called.
         return rl;
     }
 
+    // Reaction volume for binding to the structure
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {        
         // The reaction volume for a particle on the rod interacting with a disk;
@@ -124,6 +89,7 @@ class DiskSurface
         return rl;
     }
     
+    // Vector of dissociation from the structure into the bulk
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         // This function produces a position for a particle unbinding from the disk onto the rod.
@@ -146,6 +112,7 @@ class DiskSurface
         return multiply( v, diss_vec_length); 
     }
 
+    // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
         length_type const& rl ) const
     {
@@ -155,6 +122,7 @@ class DiskSurface
         return position_pair_type( base_type::shape().position(), base_type::shape().position() );
     }
     
+    // Positions created at dissociation of one particle on the structure into two particles, one of which ends up in the bulk
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
         position_type const& op_surf, length_type const& rl ) const
     {
@@ -211,6 +179,7 @@ class DiskSurface
         return pp01;
     }
    
+    // Used by newBDPropagator
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         const length_type disk_radius (base_type::shape().radius());
@@ -235,6 +204,7 @@ class DiskSurface
         return (cylinder_radius + radius) * traits_type::MINIMAL_SEPARATION_FACTOR - cylinder_radius;
     }
 */
+    /*** Boundary condition handling ***/
     // FIXME This is a mess but it works. See ParticleContainerBase.hpp for explanation.
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
@@ -248,18 +218,60 @@ class DiskSurface
         return pos_struct_id;   // Disks can also not be connected, so no cyclic transpose.
     }
 
-    ///// TESTING TESTING TESTING TESTING TESTING
+    /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position);
     }
-
+    // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
+    }    
+    
+    /*** Formerly used functions of the Morelli scheme ***/
+    // DEPRECATED
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
+    {
+         // TODO: This is part of the old BD scheme and should be removed at some point
+        return drawR_gbd_1D(rnd, r01, dt, D01, v);
+    }
+    // DEPRECATED
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
+    {
+        // TODO: This is part of the old BD scheme and should be removed at some point
+        /*
+            The I_bd factors used for calculating the acceptance probability are dependent on the direction 
+            of the overlap step (r = r_1 - r_0), compared to the direction of the drift. 
+            The I_bd factors are defined for a particle creating an overlap comming from the right (r < 0).
+            Since the I_bd terms calulated here are for the backward move, we have to invert their drifts.
+            When the particle comes from the left (r > 0) we have to invert its drift again.
+
+            ---Code below is used for drift dependent backstep.
+
+            Real numerator = g_bd_1D(ipv, r01, dt, D0, -v0);
+            Real denominator = g_bd_1D(ipv, r01, dt, D0, v0)*exp( ipv/abs_ipv*(abs_ipv - r01)*v/D01 );
+            Real correction = numerator/denominator;
+            if( ipv < 0 )
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, -v0) + I_bd_1D(r01, dt, D1, v1) ) );
+            else
+                return correction*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, -v1) ) );
+
+            Also change v -> -v in drawR for the dissociation move.
+        */
+
+        return 0.5*( k_a * dt / ( I_bd_1D(r01, dt, D0, v0) + I_bd_1D(r01, dt, D1, v1) ) );
+  
+    }
+    // DEPRECATED
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
+    {
+        // TODO: This is part of the old BD scheme and should be removed at some point
+        return random_vector(drawR_gbd(rng.uniform(0., 1.), r01, dt, D01, v), rng);
     }
-    ///// END TESTING TESTING TESTING TESTING TESTING
     
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 758aab0b..43c70eff 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -37,14 +37,15 @@ class PlanarSurface
     typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
 
+    /*** Simple structure-specific sampling functions ***/
+    // Draw a random position in the plane
     virtual position_type random_position(rng_type& rng) const
-    // Selects a random position in the plane
     {
         return ::random_position(base_type::shape(), boost::bind(&rng_type::uniform, rng, -1., 1.));
     }
 
+    // Create a random vector in the plane
     virtual position_type random_vector(length_type const& r, rng_type& rng) const
-    // Provides a random vector in the plane
     {
         return multiply(
             normalize(
@@ -55,8 +56,8 @@ class PlanarSurface
                         base_type::shape().units()[1], rng.uniform(-1., 1.)))), r);
     }
 
+    // Calculate a bd displacement for particles diffusing in the plane
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const
-    // Calculated a bd displacement for particles diffusing in the plane?
     {
         length_type const x(rng.normal(0., r)), y(rng.normal(0., r));
         return add(
@@ -64,35 +65,20 @@ class PlanarSurface
             multiply(base_type::shape().unit_y(), y));
     }
 
-    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
-    {
-        //TODO: use the 2D BD function instead of the 3D one - failed on very hard integral.
-        return drawR_gbd_3D(rnd, r01, dt, D01);
-    }
-
-    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
-                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
-    {
-        //TODO: use the 2D BD function instead of the 3D one. - Solution known
-        return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
-    }
-
-    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
-                                                Real const& D01, Real const& v ) const
-    {
-        return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng ); 
-    }
-
+    /*** New BD scheme functions ***/
+    // Rate for binding to particle on the structure
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
     {
-        return k / (2 * M_PI * r01);    
+        return k / (2 * M_PI * r01); 
     }
-    
+
+    // Rate for binding to the structure
     virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const
     {
-        return k;    
+        return k;
     }
 
+    // Reaction volume for binding to particle in the structure
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
         length_type r01l( r01 + rl );
@@ -102,12 +88,14 @@ class PlanarSurface
         return M_PI * ( r01l_sq - r01_sq );
     }
     
+    // Reaction volume for binding to the structure
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
         //factor 2 because surface has two possible reaction sides due to cyclic BCn.
-        return 2*rl;
+        return 2*rl; // FIXME because we reject the above constraint at some point
     }
     
+    // Vector of dissociation from the structure into the bulk
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         Real X( rng.uniform(0.,1.) );
@@ -116,6 +104,7 @@ class PlanarSurface
         return multiply( base_type::shape().unit_z(), (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
     }
 
+    // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
         length_type const& rl ) const
     {
@@ -136,6 +125,7 @@ class PlanarSurface
                                     op + m * s1.D() / D01 );
     }
     
+    // Positions created at dissociation of one particle on the structure into two particles, one of which ends up in the bulk
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
         position_type const& op_surf, length_type const& rl ) const
     {
@@ -181,6 +171,7 @@ class PlanarSurface
         
     }
     
+    // Used by newBDPropagator
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const
     {
         const boost::array<length_type, 2> half_lengths(base_type::shape().half_extent());
@@ -204,6 +195,7 @@ class PlanarSurface
         return radius * traits_type::MINIMAL_SEPARATION_FACTOR;
     }
 */
+    /*** Boundary condition handling ***/
     // FIXME This is a mess but it works. See ParticleContainerBase.hpp for explanation.
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
@@ -217,18 +209,38 @@ class PlanarSurface
         return structure_container.cyclic_transpose(*this, pos_struct_id);
     }
 
-    ///// TESTING TESTING TESTING TESTING TESTING
+    /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position);
     }
-
+    // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
-    ///// END TESTING TESTING TESTING TESTING TESTING
+    
+    /*** Formerly used functions of the Morelli scheme ***/
+    // DEPRECATED
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
+    {
+        //TODO: use the 2D BD function instead of the 3D one - failed on very hard integral.
+        return drawR_gbd_3D(rnd, r01, dt, D01);
+    }
+    // DEPRECATED
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
+    {
+        //TODO: use the 2D BD function instead of the 3D one. - Solution known
+        return k_a * dt / ((I_bd_3D(r01, dt, D0) + I_bd_3D(r01, dt, D1)) * 4.0 * M_PI);
+    }
+    // DEPRECATED
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
+    {
+        return random_vector( drawR_gbd(rng(), r01, dt, D01, v), rng );
+    }
 
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index f69a5656..cf448b59 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -33,6 +33,7 @@ class SphericalSurface
     typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
 
 
+    /*** Simple structure-specific sampling functions ***/
     virtual position_type random_position(rng_type& rng) const
     {
         return position_type(); // TODO
@@ -48,23 +49,7 @@ class SphericalSurface
         return position_type(); // TODO
     }
 
-    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
-    {    
-        return length_type(); // TODO
-    }
-
-    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
-                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
-    {    
-        return Real(); //TODO
-    }
-
-    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
-                                                Real const& D01, Real const& v ) const
-    {
-        return position_type(); //TODO
-    }
-
+    /*** New BD scheme functions ***/
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
     {
         return Real(); //TODO
@@ -111,6 +96,7 @@ class SphericalSurface
     }
 */
 
+    /*** Boundary condition handling ***/
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id,
                                                        structure_container_type const& structure_container) const
     {
@@ -124,18 +110,36 @@ class SphericalSurface
         return pos_struct_id;       // Two spherical surface cannot be connected (there is no boundary!)
     }
 
-    ///// TESTING TESTING TESTING TESTING TESTING
+    /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position);
     }
-
+    // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position);
     }
-    ///// END TESTING TESTING TESTING TESTING TESTING
+    
+    /*** Formerly used functions of the Morelli scheme ***/
+    // DEPRECATED
+    virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
+    {    
+        return length_type(); // TODO
+    }
+    // DEPRECATED
+    virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, 
+                                Real const& D0, Real const& D1, Real const& v0, Real const& v1) const
+    {    
+        return Real(); //TODO
+    }
+    // DEPRECATED
+    virtual position_type dissociation_vector( rng_type& rng, length_type const& r01, Real const& dt, 
+                                                Real const& D01, Real const& v ) const
+    {
+        return position_type(); //TODO
+    }
     
     virtual void accept(ImmutativeStructureVisitor<traits_type> const& visitor) const
     {
diff --git a/Structure.hpp b/Structure.hpp
index dca91b78..cad04cab 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -97,7 +97,7 @@ class Structure
     virtual position_type random_vector(length_type const& r, rng_type& rng) const = 0;
 
 
-    // Methods used in the 'old' BDPropagator
+    // Methods used in the 'old' BDPropagator // DEPRECATED
     virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
     virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
     virtual Real p_acceptance(Real const& k_a, Real const& dt, length_type const& r01, position_type const& ipv, Real const& D0, Real const& D1, Real const& v0, Real const& v1) const = 0;
@@ -106,7 +106,6 @@ class Structure
     virtual position_type bd_displacement(length_type const& mean, length_type const& r, rng_type& rng) const = 0;
     virtual length_type newBD_distance(position_type const& new_pos, length_type const& radius, position_type const& old_pos, length_type const& sigma) const = 0;
 
-
     // TODO this are just functions->move somewhere else
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const = 0;
     virtual Real get_1D_rate_surface( Real const& k, length_type const& r0 ) const = 0;
@@ -118,13 +117,13 @@ class Structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const = 0;
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const = 0;
     
-    // general method for getting some measures/info
+    // General method for getting some measures/info
     virtual projected_type project_point(position_type const& pos) const = 0;
     virtual projected_type project_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;    
 
-    // Methods used for edge crossing (only for the planes so far)    
+    // Methods used for edge crossing (only for the planes so far)
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
 //    virtual position_type deflect_back(position_type const& pos, position_type const& u_z) const = 0;
 
@@ -132,12 +131,10 @@ class Structure
                                                        structure_container_type const& structure_container) const = 0;
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
-    ///// TESTING TESTING TESTING TESTING TESTING
+    // Structure functions despatch switchbox
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const = 0;
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const;
-    ///// END TESTING TESTING TESTING TESTING TESTING
-
 
 
     virtual std::size_t hash() const

From 83597f84f0928cfe61a33ce5d2525c970fbd2731 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 16:44:12 +0200
Subject: [PATCH 0971/1541] Include new length_type parameter 'offset' into
 structure functions (and despactch methods in structure classes, accordingly)

---
 CuboidalRegion.hpp     |   8 +-
 CylindricalSurface.hpp |   8 +-
 DiskSurface.hpp        |   8 +-
 PlanarSurface.hpp      |   8 +-
 SphericalSurface.hpp   |   8 +-
 Structure.hpp          |   4 +-
 StructureFunctions.cpp | 250 ++++++++++++++++++++++++----------------
 StructureFunctions.hpp | 252 ++++++++++++++++++++++++-----------------
 8 files changed, 323 insertions(+), 223 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 68d1548f..f1d56c40 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -146,15 +146,15 @@ class CuboidalRegion
     }
     
     /*** Despatch switchbox for structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index ff271b25..663717eb 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -207,15 +207,15 @@ class CylindricalSurface
     }
     
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 9d8be40c..b8077560 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -219,15 +219,15 @@ class DiskSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
     }    
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 43c70eff..920960d6 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -210,15 +210,15 @@ class PlanarSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index cf448b59..b602efe1 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -111,15 +111,15 @@ class SphericalSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/Structure.hpp b/Structure.hpp
index cad04cab..a02c5eee 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -132,9 +132,9 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
     // Structure functions despatch switchbox
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position) const;
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const;
 
 
     virtual std::size_t hash() const
diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index cd9db911..4dbc71de 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -31,7 +31,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -52,7 +53,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -69,7 +71,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -95,7 +98,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -120,7 +124,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -148,7 +153,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -165,7 +171,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -182,7 +189,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -199,7 +207,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -216,7 +225,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -236,7 +246,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -253,7 +264,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -274,7 +286,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -291,7 +304,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -317,7 +331,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -337,7 +352,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -354,7 +370,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -371,7 +388,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -388,7 +406,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -409,7 +428,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -429,7 +449,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -446,7 +467,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -463,7 +485,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -480,7 +503,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -497,7 +521,8 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          )
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset           )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -529,9 +554,10 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -548,9 +574,10 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -567,9 +594,10 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -587,9 +615,10 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -606,9 +635,10 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -628,9 +658,10 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -647,9 +678,10 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -666,9 +698,10 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -685,9 +718,10 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -704,9 +738,10 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -726,9 +761,10 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -745,9 +781,10 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -764,9 +801,10 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -783,9 +821,10 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -802,9 +841,10 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -824,9 +864,10 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -843,9 +884,10 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -862,9 +904,10 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -881,9 +924,10 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -900,9 +944,10 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -922,9 +967,10 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -941,9 +987,10 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -960,9 +1007,10 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -979,9 +1027,10 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -998,9 +1047,10 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          )
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 3d4a086a..2208ca49 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -39,31 +39,36 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 /********************************/
 /* Coming from SphericalSurface */
@@ -72,31 +77,36 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 /**********************************/
 /* Coming from CylindricalSurface */
@@ -105,31 +115,36 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 /***************************/
 /* Coming from DiskSurface */
@@ -138,31 +153,36 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 /*****************************/
 /* Coming from PlanarSurface */
@@ -171,31 +191,36 @@ template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
-                  typename Ttraits_::position_type      const& old_pos          );
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset          );
 
                   
 /******************************************************************************************/
@@ -211,37 +236,42 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
-                  template <typename Ttraits_>
+template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 /********************************/
 /* Coming from SphericalSurface */
@@ -249,37 +279,42 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>              const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 /**********************************/
 /* Coming from CylindricalSurface */
@@ -287,37 +322,42 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>            const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 /***************************/
 /* Coming from DiskSurface */
@@ -325,37 +365,42 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>          const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 /*****************************/
 /* Coming from PlanarSurface */
@@ -363,37 +408,42 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                 const& origin_struc
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       CuboidalRegion<Ttraits_>              const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       CuboidalRegion<Ttraits_>               const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       SphericalSurface<Ttraits_>            const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       CylindricalSurface<Ttraits_>          const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       DiskSurface<Ttraits_>                 const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       DiskSurface<Ttraits_>                  const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                       PlanarSurface<Ttraits_>               const& target_structure, 
-                       typename Ttraits_::position_type      const& old_pos          );
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       PlanarSurface<Ttraits_>                const& target_structure, 
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::length_type         const& offset              );
 
                        
 /******************************************************************************************************/

From 982e62211e341090a706d5b30ed93998a0c9116f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 18:44:42 +0200
Subject: [PATCH 0972/1541] New function surface_dissociation_unit_vector( rng
 )

... which gives the direction of dissociation only, without
displacement length.
---
 CuboidalRegion.hpp     |  6 ++++++
 CylindricalSurface.hpp | 20 +++++++++++++++++++-
 DiskSurface.hpp        |  8 +++++++-
 PlanarSurface.hpp      |  8 +++++++-
 SphericalSurface.hpp   |  5 +++++
 Structure.hpp          |  1 +
 6 files changed, 45 insertions(+), 3 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index f1d56c40..7ccc4db8 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -95,6 +95,12 @@ class CuboidalRegion
     {
         return position_type(); //No surface dissociation 'from' the bulk
     }
+    
+    // Normed direction of dissociation from the structure to parent structure
+    virtual position_type surface_dissociation_unit_vector( rng_type& rng ) const
+    {
+        return position_type(); //No surface dissociation 'from' the bulk
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 663717eb..fc1afb3e 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -97,17 +97,35 @@ class CylindricalSurface
         length_type const rod_radius = base_type::shape().radius();
         position_type const unit_z = base_type::shape().unit_z();
 
+        // Calculate the length of the vector first
         length_type const rrl( rod_radius + r0 + rl );
         length_type const rrl_sq( gsl_pow_2(rrl) );
         length_type const rr_sq( gsl_pow_2(rod_radius + r0) );
         
         length_type const diss_vec_length( sqrt( X * (rrl_sq - rr_sq) + rr_sq ) );
 
-        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);        
+        // Create a 3D vector with totally random orientation
+        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);
+        // Subtract the part parallel to the axis to get the orthogonal components and normalize
+        // This creates a normed random vector orthogonal to the cylinder axis
         v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
          
+        // Return the created vector with the right length
         return multiply( v, diss_vec_length); 
     }
+    
+    // Normed direction of dissociation from the structure to parent structure
+    virtual position_type surface_dissociation_unit_vector( rng_type& rng ) const
+    {
+        position_type const unit_z = base_type::shape().unit_z();
+        // Create a 3D vector with totally random orientation
+        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);
+        // Subtract the part parallel to the axis to get the orthogonal components and normalize
+        // This creates a normed random vector orthogonal to the cylinder axis
+        v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
+        
+        return v;
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index b8077560..1bec4583 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -94,7 +94,7 @@ class DiskSurface
     {
         // This function produces a position for a particle unbinding from the disk onto the rod.
         // It should lie within the reaction volume around the disk.
-        // TODO: We have to make a distinction between sink and cap already here!
+        // TODO: THIS IS THE CODE COPIED FROM CylindricalSurface
         // FIXME WTF is all this calculation!! The dissociation vector is supposed to be super simple!
         Real X( rng.uniform(0.,1.) );
         length_type const rod_radius = base_type::shape().radius();
@@ -111,6 +111,12 @@ class DiskSurface
          
         return multiply( v, diss_vec_length); 
     }
+    
+    // Normed direction of dissociation from the structure to parent structure
+    virtual position_type surface_dissociation_unit_vector( rng_type& rng ) const
+    {
+        return base_type::shape().unit_z();
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 920960d6..205f1a98 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -95,7 +95,7 @@ class PlanarSurface
         return 2*rl; // FIXME because we reject the above constraint at some point
     }
     
-    // Vector of dissociation from the structure into the bulk
+    // Vector of dissociation from the structure to parent structure
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
     {
         Real X( rng.uniform(0.,1.) );
@@ -103,6 +103,12 @@ class PlanarSurface
 
         return multiply( base_type::shape().unit_z(), (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
     }
+    
+    // Normed direction of dissociation from the structure to parent structure
+    virtual position_type surface_dissociation_unit_vector( rng_type& rng ) const
+    {
+        return base_type::shape().unit_z();
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index b602efe1..d6fbba05 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -74,6 +74,11 @@ class SphericalSurface
     {
         return position_type(); //TODO  
     }
+        
+    virtual position_type surface_dissociation_unit_vector( rng_type& rng ) const
+    {
+        return position_type(); //TODO  
+    }
     
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const
     {
diff --git a/Structure.hpp b/Structure.hpp
index a02c5eee..1b650aba 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -114,6 +114,7 @@ class Structure
     
     // Methods used to calculate dissociation positions
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const = 0;
+    virtual position_type surface_dissociation_unit_vector( rng_type& rng ) const = 0;
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const = 0;
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, position_type const& op_surf, length_type const& rl ) const = 0;
     

From 692832417d8c417d388d365197055dcf2e2a3e1c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 18:45:59 +0200
Subject: [PATCH 0973/1541] Catch illegal_propagation_attempt exeption in
 newBDSimulator

---
 newBDPropagator.hpp | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 56f609b4..e5ecc358 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -126,6 +126,12 @@ class newBDPropagator
             ++rejected_move_count_;
             return true;
         }
+        catch (illegal_propagation_attempt const& reason)
+        {
+            log_.info("first-order reaction: illegal propagation attempt (reason: %s)", reason.what());
+            ++rejected_move_count_;
+            return true;
+        }
         
 
         /*** 3. COLLECT INFO ***/
@@ -418,13 +424,15 @@ class newBDPropagator
                         //// 1 - CREATE NEW POSITION AND STRUCTURE ID                                                
                         if( product_species.structure_type_id() != reactant_structure->sid() )
                         {
-                            // Get target structure id
+                            // Get target structure; if not staying on the origin structure, the particle is
+                            // assumed to go to its parent structure, which in most cases is the bulk;
+                            // For a disk bound particle it can be both the bulk and the cylinder
                             const structure_id_type product_structure_id(reactant_structure->structure_id()); // the parent structure
-                                  // TODO Allow for unbinding Disk->Cube; in that case the prod. structure is not the parent one!
+                            //const structure_id_type product_structure_id(tx_.get_def_structure_id());
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
-                            // Produce new position and structure id                            
-                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos) );
-                            // Care for exit point from structures, which depends on product radius; TODO This is ugly and corrupts the sense of StructureFunctions!
+                            // Produce new position and structure id
+                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, 0.0) );
+                            // Care for exit point from structures, which depends on product radius
                             const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
                             const position_type product_pos( add(new_pos_sid_pair.first, displacement) );
                             

From a449ab16b5459932f6854d41c2bf2441783b48a8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 19:19:46 +0200
Subject: [PATCH 0974/1541] Also the rng has to be passed to the structure
 functions to handle random dissociation directions (relevant for cylinder)

---
 CuboidalRegion.hpp     |  10 +--
 CylindricalSurface.hpp |  10 +--
 DiskSurface.hpp        |  10 +--
 PlanarSurface.hpp      |  10 +--
 SphericalSurface.hpp   |  10 +--
 Structure.hpp          |   4 +-
 StructureFunctions.cpp | 150 +++++++++++++++++++++++++++--------------
 StructureFunctions.hpp | 150 +++++++++++++++++++++++++++--------------
 newBDPropagator.hpp    |   2 +-
 9 files changed, 233 insertions(+), 123 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 7ccc4db8..45e9b156 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -152,15 +152,17 @@ class CuboidalRegion
     }
     
     /*** Despatch switchbox for structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                        length_type const& offset, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index fc1afb3e..2d46a5ac 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -225,15 +225,17 @@ class CylindricalSurface
     }
     
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, 
+                                                         length_type const& offset, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                        length_type const& offset, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 1bec4583..0737c460 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -225,15 +225,17 @@ class DiskSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                        length_type const& offset, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
     }    
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 205f1a98..f6fbae01 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -216,15 +216,17 @@ class PlanarSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                        length_type const& offset, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index d6fbba05..8a6ede69 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -116,15 +116,17 @@ class SphericalSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                        length_type const& offset, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/Structure.hpp b/Structure.hpp
index 1b650aba..caac74d6 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -133,9 +133,9 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
     // Structure functions despatch switchbox
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset, rng_type const& rng) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset) const;
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset, rng_type const& rng) const;
 
 
     virtual std::size_t hash() const
diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 4dbc71de..624dc0f9 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -32,7 +32,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -54,7 +55,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -72,7 +74,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -99,7 +102,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -125,7 +129,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -154,7 +159,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -172,7 +178,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -190,7 +197,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -208,7 +216,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -226,7 +235,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -247,7 +257,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -265,7 +276,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -287,7 +299,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -305,7 +318,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -332,7 +346,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -353,7 +368,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -371,7 +387,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -389,7 +406,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -407,7 +425,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -429,7 +448,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -450,7 +470,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -468,7 +489,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -486,7 +508,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -504,7 +527,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -522,7 +546,8 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset           )
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -557,7 +582,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -577,7 +603,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -597,7 +624,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -618,7 +646,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -638,7 +667,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -661,7 +691,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -681,7 +712,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -701,7 +733,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -721,7 +754,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -741,7 +775,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -764,7 +799,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -784,7 +820,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -804,7 +841,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -824,7 +862,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -844,7 +883,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -867,7 +907,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -887,7 +928,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -907,7 +949,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -927,7 +970,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -947,7 +991,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -970,7 +1015,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -990,7 +1036,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -1010,7 +1057,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -1030,7 +1078,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
@@ -1050,7 +1099,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              )
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 2208ca49..273de8fb 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -40,35 +40,40 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 /********************************/
 /* Coming from SphericalSurface */
@@ -78,35 +83,40 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 /**********************************/
 /* Coming from CylindricalSurface */
@@ -116,35 +126,40 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 /***************************/
 /* Coming from DiskSurface */
@@ -154,35 +169,40 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 /*****************************/
 /* Coming from PlanarSurface */
@@ -192,35 +212,40 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset          );
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::rng_type           const& rng              );
 
                   
 /******************************************************************************************/
@@ -239,7 +264,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -247,7 +273,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -255,7 +282,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -263,7 +291,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -271,7 +300,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 /********************************/
 /* Coming from SphericalSurface */
@@ -282,7 +312,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -290,7 +321,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -298,7 +330,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -306,7 +339,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -314,7 +348,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 /**********************************/
 /* Coming from CylindricalSurface */
@@ -325,7 +360,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -333,7 +369,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -341,7 +378,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -349,7 +387,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -357,7 +396,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 /***************************/
 /* Coming from DiskSurface */
@@ -368,7 +408,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -376,7 +417,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -384,7 +426,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -392,7 +435,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -400,7 +444,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 /*****************************/
 /* Coming from PlanarSurface */
@@ -411,7 +456,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -419,7 +465,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -427,7 +474,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -435,7 +483,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
 inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
@@ -443,7 +492,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset              );
+                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::rng_type            const& rng                 );
 
                        
 /******************************************************************************************************/
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index e5ecc358..c8900b65 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -431,7 +431,7 @@ class newBDPropagator
                             //const structure_id_type product_structure_id(tx_.get_def_structure_id());
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
                             // Produce new position and structure id
-                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, 0.0) );
+                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, 0.0, rng_) );
                             // Care for exit point from structures, which depends on product radius
                             const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
                             const position_type product_pos( add(new_pos_sid_pair.first, displacement) );

From 6e3ceb7eb9bb66cc15344fc54f5a785a1b225045 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 19:31:16 +0200
Subject: [PATCH 0975/1541] ... and of course it also needs the reaction_length
 for the same purpose.

---
 CuboidalRegion.hpp     |  8 +++----
 CylindricalSurface.hpp |  8 +++----
 DiskSurface.hpp        |  8 +++----
 PlanarSurface.hpp      |  8 +++----
 SphericalSurface.hpp   |  8 +++----
 Structure.hpp          |  4 ++--
 StructureFunctions.cpp | 50 ++++++++++++++++++++++++++++++++++++++++++
 StructureFunctions.hpp | 50 ++++++++++++++++++++++++++++++++++++++++++
 newBDPropagator.hpp    |  7 ++----
 9 files changed, 124 insertions(+), 27 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 45e9b156..6f63713f 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -153,16 +153,16 @@ class CuboidalRegion
     
     /*** Despatch switchbox for structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 2d46a5ac..59a9aa27 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -226,16 +226,16 @@ class CylindricalSurface
     
     /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, 
-                                                         length_type const& offset, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 0737c460..6fe1e6c4 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -226,16 +226,16 @@ class DiskSurface
 
     /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }    
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index f6fbae01..eddaaa6c 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -217,16 +217,16 @@ class PlanarSurface
 
     /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 8a6ede69..8ca7a1a4 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -117,16 +117,16 @@ class SphericalSurface
 
     /*** Despatch switchbox for the structure functions ***/
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_helper(*this, position, offset, rng);
+        return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rng);
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/Structure.hpp b/Structure.hpp
index caac74d6..bcdb5116 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -133,9 +133,9 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
     // Structure functions despatch switchbox
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset, rng_type const& rng) const;
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const;
 
 
     virtual std::size_t hash() const
diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 624dc0f9..f6aa1db2 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -33,6 +33,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -56,6 +57,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -75,6 +77,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -103,6 +106,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -130,6 +134,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -160,6 +165,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -179,6 +185,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -198,6 +205,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -217,6 +225,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -236,6 +245,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -258,6 +268,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -277,6 +288,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -300,6 +312,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -319,6 +332,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -347,6 +361,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -369,6 +384,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -388,6 +404,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -407,6 +424,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -426,6 +444,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -449,6 +468,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -471,6 +491,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -490,6 +511,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -509,6 +531,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -528,6 +551,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -547,6 +571,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -583,6 +608,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -604,6 +630,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -625,6 +652,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -647,6 +675,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -668,6 +697,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -692,6 +722,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -713,6 +744,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -734,6 +766,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -755,6 +788,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -776,6 +810,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -800,6 +835,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -821,6 +857,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -842,6 +879,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -863,6 +901,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -884,6 +923,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -908,6 +948,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -929,6 +970,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -950,6 +992,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -971,6 +1014,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -992,6 +1036,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -1016,6 +1061,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -1037,6 +1083,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -1058,6 +1105,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -1079,6 +1127,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
@@ -1100,6 +1149,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 273de8fb..457360b5 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -41,6 +41,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -49,6 +50,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -57,6 +59,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -65,6 +68,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -73,6 +77,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 /********************************/
@@ -84,6 +89,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -92,6 +98,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -100,6 +107,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -108,6 +116,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -116,6 +125,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 /**********************************/
@@ -127,6 +137,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -135,6 +146,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -143,6 +155,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -151,6 +164,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -159,6 +173,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 /***************************/
@@ -170,6 +185,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -178,6 +194,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -186,6 +203,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -194,6 +212,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -202,6 +221,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 /*****************************/
@@ -213,6 +233,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -221,6 +242,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -229,6 +251,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
@@ -237,6 +260,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
@@ -245,6 +269,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              );
 
                   
@@ -265,6 +290,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -274,6 +300,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -283,6 +310,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -292,6 +320,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -301,6 +330,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 /********************************/
@@ -313,6 +343,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -322,6 +353,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -331,6 +363,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -340,6 +373,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -349,6 +383,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 /**********************************/
@@ -361,6 +396,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -370,6 +406,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -379,6 +416,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -388,6 +426,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -397,6 +436,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 /***************************/
@@ -409,6 +449,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -418,6 +459,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -427,6 +469,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -436,6 +479,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -445,6 +489,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 /*****************************/
@@ -457,6 +502,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        CuboidalRegion<Ttraits_>               const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -466,6 +512,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        SphericalSurface<Ttraits_>             const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -475,6 +522,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        CylindricalSurface<Ttraits_>           const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
@@ -484,6 +532,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
@@ -493,6 +542,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        PlanarSurface<Ttraits_>                const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
                        typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
                        
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index c8900b65..27b65587 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -431,12 +431,9 @@ class newBDPropagator
                             //const structure_id_type product_structure_id(tx_.get_def_structure_id());
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
                             // Produce new position and structure id
-                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, 0.0, rng_) );
-                            // Care for exit point from structures, which depends on product radius
-                            const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
-                            const position_type product_pos( add(new_pos_sid_pair.first, displacement) );
+                            const length_type dissoc_offset = product_species.radius();
+                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, dissoc_offset, rng_, reaction_length_) );
                             
-                            product_pos_struct_id = std::make_pair(product_pos, new_pos_sid_pair.second);
                             // Apply boundary conditions
                             product_pos_struct_id = tx_.apply_boundary( product_pos_struct_id );
                             // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?

From 429c137bcc2df587840b9162be6c0b8997600e0c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 20:01:37 +0200
Subject: [PATCH 0976/1541] Outsource particle unbinding into structure
 functions

... i.e. calculate surface_dissociation_vector in the specific
functions treating the unbinding (single) reactions.
---
 StructureFunctions.cpp | 40 ++++++++++++++++++++++++----------------
 newBDPropagator.hpp    |  4 ++--
 2 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index f6aa1db2..876f451d 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -7,6 +7,7 @@
 #include "CylindricalSurface.hpp"
 #include "DiskSurface.hpp"
 #include "PlanarSurface.hpp"
+#include "linear_algebra.hpp"
 #include "exceptions.hpp"
 
 
@@ -275,10 +276,11 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
     
-    // Return trivial data, i.e. the position at which the single reaction happens
-    // and the id of the target structure; the position still has to be post-processed
-    // via target_structure functions making use of the species radius etc.
-    return std::make_pair(old_pos, target_structure.id);
+    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type new_pos( add(old_pos, displacement) );    
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id);
 };
 
 // CylindricalSurface -> CylindricalSurface
@@ -391,10 +393,11 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    // Return trivial data, i.e. the position at which the single reaction happens
-    // and the id of the target structure; the position still has to be post-processed
-    // via target_structure functions making use of the species radius etc.
-    return std::make_pair(old_pos, target_structure.id);
+    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type new_pos( add(old_pos, displacement) );
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id);
 };
 
 // DiskSurface -> SphericalSurface
@@ -431,10 +434,15 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
     
-    return std::make_pair(position_type(), structure_id_type());
+    // When a particle is dissociation from a disk to the cylinder, the direction is randomized
+    Real r( rng.uniform(0.,1.));    
+    Real rs( r < 0.5 ? -1.0 : +1.0 );
+    position_type new_pos( add(old_pos, multiply(rs, displacement)) );
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id);
 };
 
 // DiskSurface -> DiskSurface
@@ -498,10 +506,11 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    // Return trivial data, i.e. the position at which the single reaction happens
-    // and the id of the target structure; the position still has to be post-processed
-    // via target_structure functions making use of the species radius etc.
-    return std::make_pair(old_pos, target_structure.id);
+    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type new_pos( add(old_pos, displacement) );
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id);
 };
 
 // PlanarSurface -> SphericalSurface
@@ -579,7 +588,6 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     // Currently only species change and decay are supported
-    // TODO Implement transitions from one plane to another
     if(origin_structure.id == target_structure.id){
      
           return std::make_pair( old_pos, origin_structure.id );
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 27b65587..b7654b86 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -431,8 +431,8 @@ class newBDPropagator
                             //const structure_id_type product_structure_id(tx_.get_def_structure_id());
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
                             // Produce new position and structure id
-                            const length_type dissoc_offset = product_species.radius();
-                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, dissoc_offset, rng_, reaction_length_) );
+                            const length_type dissoc_offset( product_species.radius() );
+                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, dissoc_offset, reaction_length_, rng_) );
                             
                             // Apply boundary conditions
                             product_pos_struct_id = tx_.apply_boundary( product_pos_struct_id );

From 61cd17a2b8d1454035cfd04660a26127d6eb09f5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Jul 2012 20:03:37 +0200
Subject: [PATCH 0977/1541] Some cleanup in newBDPropagator

---
 newBDPropagator.hpp | 24 ++----------------------
 1 file changed, 2 insertions(+), 22 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b7654b86..43ac87bf 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -428,35 +428,15 @@ class newBDPropagator
                             // assumed to go to its parent structure, which in most cases is the bulk;
                             // For a disk bound particle it can be both the bulk and the cylinder
                             const structure_id_type product_structure_id(reactant_structure->structure_id()); // the parent structure
-                            //const structure_id_type product_structure_id(tx_.get_def_structure_id());
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
                             // Produce new position and structure id
-                            const length_type dissoc_offset( product_species.radius() );
-                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos, dissoc_offset, reaction_length_, rng_) );
-                            
+                            const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos,
+                                                                                                                      product_species.radius(), reaction_length_, rng_) );                            
                             // Apply boundary conditions
                             product_pos_struct_id = tx_.apply_boundary( product_pos_struct_id );
                             // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
-                        /* OLD VERSION
-                        // If the product particle does NOT live on the same structure type as the reactant => structure -> superstructure dissociation.
-                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
-                        if( product_species.structure_type_id() != reactant_structure->sid() )
-                        {
-                            // get dissociation position and structure
-                            // TODO merge the structure_id thing into the 'surface_dissociation_vector' method.
-                            // TODO when dissociating from the 'cap' structure, we go up two levels instead of one.
-                            const position_type displacement( reactant_structure->surface_dissociation_vector(rng_, product_species.radius(), reaction_length_ ) );
-                            const position_type product_pos (tx_.apply_boundary( add( reactant_pos, displacement ) ));
-                            // When dissociating, the new structure is the parent structure (is this always true?)
-                            const structure_id_type product_structure_id (reactant_structure->structure_id());
-
-                            product_pos_struct_id = std::make_pair(product_pos, product_structure_id);
-                            // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
-                            product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
-                        }
-                        */
 
                         //// 2- CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos_struct_id.first, product_species.radius());

From 240c8a675ac07b4b076b98080cf79f278fe404ab Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Jul 2012 15:55:03 +0200
Subject: [PATCH 0978/1541] Despatch switchbox for structure functions that
 return info for two new particles

---
 CuboidalRegion.hpp     | 21 ++++++++++++++++++---
 CylindricalSurface.hpp | 21 ++++++++++++++++++---
 DiskSurface.hpp        | 21 ++++++++++++++++++---
 PlanarSurface.hpp      | 19 +++++++++++++++++--
 SphericalSurface.hpp   | 19 +++++++++++++++++--
 Structure.hpp          | 32 +++++++++++++++++++-------------
 6 files changed, 107 insertions(+), 26 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 6f63713f..2497561c 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -33,8 +33,9 @@ class CuboidalRegion
 
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
-    typedef std::pair<position_type, position_type>     position_pair_type;
-    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
+    typedef std::pair<position_type, position_type>                               position_pair_type;
+    typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
+    typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
 
     /*** Simple structure-specific sampling functions ***/
@@ -151,7 +152,8 @@ class CuboidalRegion
         return pos_struct_id;       // The cyclic_transpose does nothing because we'll apply world cyclic transpose later.
     }
     
-    /*** Despatch switchbox for structure functions ***/
+    /*** Despatch switchbox for the structure functions ***/
+    // 1 - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -164,6 +166,19 @@ class CuboidalRegion
     {
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    // 2 - Two new positions
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+    }
+    // the associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+    }
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 59a9aa27..022f0c91 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -36,8 +36,9 @@ class CylindricalSurface
 
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
-    typedef std::pair<position_type, position_type>     position_pair_type;
-    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
+    typedef std::pair<position_type, position_type>                               position_pair_type;
+    typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
+    typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
 
     /*** Simple structure-specific sampling functions ***/
@@ -225,7 +226,8 @@ class CylindricalSurface
     }
     
     /*** Despatch switchbox for the structure functions ***/
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, 
+    // 1 - One new position
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
@@ -237,6 +239,19 @@ class CylindricalSurface
     {
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    // 2 - Two new positions
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+    }
+    // the associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+    }
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 6fe1e6c4..b0b6e250 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -34,8 +34,9 @@ class DiskSurface
 
     typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
 
-    typedef std::pair<position_type, position_type>         position_pair_type;
-    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
+    typedef std::pair<position_type, position_type>                               position_pair_type;
+    typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
+    typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
     
     /*** Simple structure-specific sampling functions ***/
@@ -225,6 +226,7 @@ class DiskSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
+    // 1 - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -236,7 +238,20 @@ class DiskSurface
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-    }    
+    }
+    // 2 - Two new positions
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+    }
+    // the associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+    }
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index eddaaa6c..39ef32a6 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -33,8 +33,9 @@ class PlanarSurface
 
     typedef StructureContainer<Structure<traits_type>, structure_id_type, traits_type>    structure_container_type;
 
-    typedef std::pair<position_type, position_type>         position_pair_type;
-    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
+    typedef std::pair<position_type, position_type>                               position_pair_type;
+    typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
+    typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
 
     /*** Simple structure-specific sampling functions ***/
@@ -216,6 +217,7 @@ class PlanarSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
+    // 1 - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -228,6 +230,19 @@ class PlanarSurface
     {
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    // 2 - Two new positions
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+    }
+    // the associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+    }
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 8ca7a1a4..2b8fc2c2 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -29,8 +29,9 @@ class SphericalSurface
 
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>    structure_container_type;
 
-    typedef std::pair<position_type, position_type>     position_pair_type;
-    typedef std::pair<position_type, structure_id_type> position_structid_pair_type;
+    typedef std::pair<position_type, position_type>                               position_pair_type;
+    typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
+    typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
 
     /*** Simple structure-specific sampling functions ***/
@@ -116,6 +117,7 @@ class SphericalSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
+    // 1 - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -128,6 +130,19 @@ class SphericalSurface
     {
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    // 2 - Two new positions
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+    }
+    // the associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+    }
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/Structure.hpp b/Structure.hpp
index bcdb5116..c2110db1 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -25,19 +25,20 @@ class Structure
 public:
     typedef Ttraits_ traits_type;
     // shorthands for types that we use
-    typedef typename traits_type::rng_type                  rng_type;
-    typedef typename traits_type::structure_name_type       structure_name_type;
-    typedef typename traits_type::structure_id_type         structure_id_type;
-    typedef typename traits_type::structure_type            structure_type;
-    typedef typename traits_type::length_type               length_type;
-    typedef typename traits_type::position_type             position_type;
-    typedef typename traits_type::species_type              species_type;
-    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
-    typedef std::pair<length_type, length_type>             components_pair_type;
-    typedef std::pair<position_type, components_pair_type>  projected_type;
-    typedef std::pair<position_type, position_type>         position_pair_type;
-    typedef std::pair<position_type, bool>                  position_flag_pair_type;
-    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
+    typedef typename traits_type::rng_type                                        rng_type;
+    typedef typename traits_type::structure_name_type                             structure_name_type;
+    typedef typename traits_type::structure_id_type                               structure_id_type;
+    typedef typename traits_type::structure_type                                  structure_type;
+    typedef typename traits_type::length_type                                     length_type;
+    typedef typename traits_type::position_type                                   position_type;
+    typedef typename traits_type::species_type                                    species_type;
+    typedef typename traits_type::structure_type_id_type                          structure_type_id_type;
+    typedef std::pair<length_type, length_type>                                   components_pair_type;
+    typedef std::pair<position_type, components_pair_type>                        projected_type;
+    typedef std::pair<position_type, position_type>                               position_pair_type;
+    typedef std::pair<position_type, bool>                                        position_flag_pair_type;
+    typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
+    typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
     typedef StructureContainer<typename traits_type::structure_type, structure_id_type, traits_type>   structure_container_type;
 
 public:
@@ -133,9 +134,14 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
     // Structure functions despatch switchbox
+    // Producing one new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const;
+    // Producing two new positions
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    template <typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const;
 
 
     virtual std::size_t hash() const

From 083414b8275fcf60fc8e2ce32ee0cf0e6766f1fc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Jul 2012 16:29:30 +0200
Subject: [PATCH 0979/1541] Pass species arguments to double-sampling structure
 functions

---
 CuboidalRegion.hpp     |  8 ++---
 CylindricalSurface.hpp |  8 ++---
 DiskSurface.hpp        |  8 ++---
 PlanarSurface.hpp      |  8 ++---
 SphericalSurface.hpp   |  8 ++---
 Structure.hpp          | 16 +++++----
 StructureFunctions.cpp | 75 ++++++++++++++++++++++++++++--------------
 StructureFunctions.hpp | 75 ++++++++++++++++++++++++++++--------------
 8 files changed, 130 insertions(+), 76 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 2497561c..680d7b26 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -168,16 +168,16 @@ class CuboidalRegion
     }
     // 2 - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 022f0c91..8ba9d19e 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -241,16 +241,16 @@ class CylindricalSurface
     }
     // 2 - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index b0b6e250..695e3e84 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -241,16 +241,16 @@ class DiskSurface
     }
     // 2 - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 39ef32a6..3eb7559f 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -232,16 +232,16 @@ class PlanarSurface
     }
     // 2 - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 2b8fc2c2..25b23f38 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -132,16 +132,16 @@ class SphericalSurface
     }
     // 2 - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return target_structure.get_pos_sid_pair_pair_helper(*this, position, offset, reaction_length, rng);
+        return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // the associated helper function
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, offset, reaction_length, rng);
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/Structure.hpp b/Structure.hpp
index c2110db1..980d564b 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -134,14 +134,18 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
     // Structure functions despatch switchbox
-    // Producing one new position
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    // 1 - Producing one new position
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const;
-    // Producing two new positions
-    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const;
+    // 2 - Producing two new positions
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
+                                                                   species_type const& s1, species_type const& s2, length_type const& rl, rng_type const& rng) const = 0;
     template <typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position, length_type const& offset, length_type const& rl, rng_type const& rng) const;
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+                                                                   species_type const& s1, species_type const& s2, length_type const& rl, rng_type const& rng) const;
 
 
     virtual std::size_t hash() const
diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 876f451d..57e6f24b 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -615,7 +615,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -637,7 +638,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -659,7 +661,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -682,7 +685,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -704,7 +708,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -729,7 +734,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -751,7 +757,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -773,7 +780,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -795,7 +803,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -817,7 +826,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -842,7 +852,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -864,7 +875,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -886,7 +898,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -908,7 +921,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -930,7 +944,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -955,7 +970,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -977,7 +993,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -999,7 +1016,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1021,7 +1039,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1043,7 +1062,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1068,7 +1088,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1090,7 +1111,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1112,7 +1134,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1134,7 +1157,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1156,7 +1180,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 457360b5..9c4574a3 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -289,7 +289,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -299,7 +300,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -309,7 +311,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -319,7 +322,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -329,7 +333,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -342,7 +347,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -352,7 +358,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -362,7 +369,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -372,7 +380,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -382,7 +391,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -395,7 +405,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -405,7 +416,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -415,7 +427,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -425,7 +438,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -435,7 +449,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -448,7 +463,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -458,7 +474,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -468,7 +485,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -478,7 +496,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -488,7 +507,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -501,7 +521,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -511,7 +532,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -521,7 +543,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 
@@ -531,7 +554,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
                   
@@ -541,7 +565,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure, 
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::length_type         const& offset,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                 );
 

From fd02455dc8bbb7c4be2cc20ca00b6ca320781814 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Jul 2012 16:54:14 +0200
Subject: [PATCH 0980/1541] Structure functions for pair back-reaction on a
 single structure type

---
 StructureFunctions.cpp | 62 ++++++++++++++++++++++++++++++++----------
 1 file changed, 47 insertions(+), 15 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 57e6f24b..98e72db5 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -624,11 +624,21 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
+    // Currently we do not allow for pair forward/backward reactions between two different cubes
+    if(origin_structure.id == target_structure.id){
+     
+        structure_id_type new_sid( origin_structure.id );
+        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s1, s2, old_pos, reaction_length) );
+        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+        // the type of origin_structure and the properties of the two product species
+        // (the displacements from old_pos are weighted by the diffusion constants)
+            
+        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
+                                    std::make_pair(new_positions.second, new_sid)    );          
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
 };
 
 // CuboidalRegion -> SphericalSurface
@@ -884,11 +894,21 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
+    // Currently we do not allow for pair forward/backward reactions between two different cylinders
+    if(origin_structure.id == target_structure.id){
+     
+        structure_id_type new_sid( origin_structure.id );
+        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s1, s2, old_pos, reaction_length) );
+        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+        // the type of origin_structure and the properties of the two product species
+        // (the displacements from old_pos are weighted by the diffusion constants)
+            
+        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
+                                    std::make_pair(new_positions.second, new_sid)    );          
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
 };
 
 // CylindricalSurface -> SphericalSurface
@@ -1189,11 +1209,23 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
+    // As a default we produce two new positions on the same plane; in principle the particles can end up
+    // on different planes, but this should be treated afterwards via apply_boundary.
+    // TODO: Move apply_boundary into structure functions?
+    if(origin_structure.id == target_structure.id){
+     
+        structure_id_type new_sid( origin_structure.id );
+        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s1, s2, old_pos, reaction_length) );
+        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+        // the type of origin_structure and the properties of the two product species
+        // (the displacements from old_pos are weighted by the diffusion constants)
+            
+        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
+                                    std::make_pair(new_positions.second, new_sid)    );          
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
 };
 
 /******************************************************************************************************/

From 2a5eb9b3a7730c1e38150b53b14e2f07ff1f6865 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Jul 2012 17:44:35 +0200
Subject: [PATCH 0981/1541] Structure functions for unbinding to two different
 structures

... and some convenient renaming.
---
 CylindricalSurface.hpp |   2 +
 PlanarSurface.hpp      |   2 +
 StructureFunctions.cpp | 151 ++++++++++++++++++++++-------------------
 3 files changed, 87 insertions(+), 68 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 8ba9d19e..458b87c0 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -186,8 +186,10 @@ class CylindricalSurface
                                 
         position_pair_type pp01;
         
+        // This is the particle that ends up on the structure
         pp01.first = subtract( op_surf, unit_z * (z * D_surf_D01) );
         
+        // This is the particle that ends up in the bulk
         pp01.second = add( op_surf, 
                         add( unit_x * x,
                           add( unit_y * y, 
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 3eb7559f..0f57f047 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -165,10 +165,12 @@ class PlanarSurface
         
         position_pair_type pp01;
         
+        // This is the particle that will end up on the surface
         pp01.first = subtract( op_surf, 
                        add( base_type::shape().unit_x() * (x * D_surf_D01),
                               base_type::shape().unit_y() * (y * D_surf_D01) ) );
         
+        // This is the particle that will end up in the bulk
         pp01.second = add( op_surf, 
                        add( base_type::shape().unit_x() * (x * D_bulk_D01),
                          add( base_type::shape().unit_y() * (y * D_bulk_D01),
diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 98e72db5..767d9340 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -615,8 +615,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -628,7 +628,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
     if(origin_structure.id == target_structure.id){
      
         structure_id_type new_sid( origin_structure.id );
-        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s1, s2, old_pos, reaction_length) );
+        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
         // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
         // the type of origin_structure and the properties of the two product species
         // (the displacements from old_pos are weighted by the diffusion constants)
@@ -648,8 +648,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -671,8 +671,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -695,8 +695,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -718,8 +718,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -744,8 +744,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -767,8 +767,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -790,8 +790,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -813,8 +813,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -836,8 +836,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -862,8 +862,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -871,11 +871,15 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
+    std::pair<position_type, position_type> new_positions( origin_structure->special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+    // the types of origin_structure and target_structure and the properties of the two product species
+    // (the displacements from old_pos are weighted by the diffusion constants);
+    // the first pair entry is the particle staying on the surface, the second entry the particle
+    // that goes into the bulk
+            
+    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id),
+                                std::make_pair(new_positions.second, target_structure.id)    );  
 };
 
 // CylindricalSurface -> CylindricalSurface
@@ -885,8 +889,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -898,7 +902,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
     if(origin_structure.id == target_structure.id){
      
         structure_id_type new_sid( origin_structure.id );
-        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s1, s2, old_pos, reaction_length) );
+        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
         // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
         // the type of origin_structure and the properties of the two product species
         // (the displacements from old_pos are weighted by the diffusion constants)
@@ -918,8 +922,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -941,8 +945,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -964,8 +968,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -990,8 +994,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -999,11 +1003,15 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
+    std::pair<position_type, position_type> new_positions( origin_structure->special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+    // the types of origin_structure and target_structure and the properties of the two product species
+    // (the displacements from old_pos are weighted by the diffusion constants);
+    // the first pair entry is the particle staying on the surface, the second entry the particle
+    // that goes into the bulk
+            
+    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id),
+                                std::make_pair(new_positions.second, target_structure.id)    );
 };
 
 // DiskSurface -> SphericalSurface
@@ -1013,8 +1021,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1036,8 +1044,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1045,6 +1053,9 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
+    // TODO TODO TODO
+    // IMPLEMENT THE UNBINDING FROM THE DISK ACTING AS A SINK!
+    
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
@@ -1059,8 +1070,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1082,8 +1093,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1108,20 +1119,24 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
     
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
+    std::pair<position_type, position_type> new_positions( origin_structure->special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+    // the types of origin_structure and target_structure and the properties of the two product species
+    // (the displacements from old_pos are weighted by the diffusion constants);
+    // the first pair entry is the particle staying on the surface, the second entry the particle
+    // that goes into the bulk
+            
+    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id),
+                                std::make_pair(new_positions.second, target_structure.id)    );    
 };
 
 // PlanarSurface -> SphericalSurface
@@ -1131,8 +1146,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1154,8 +1169,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1177,8 +1192,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1200,8 +1215,8 @@ inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_:
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            const& rng                )
 {
@@ -1215,7 +1230,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
     if(origin_structure.id == target_structure.id){
      
         structure_id_type new_sid( origin_structure.id );
-        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s1, s2, old_pos, reaction_length) );
+        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
         // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
         // the type of origin_structure and the properties of the two product species
         // (the displacements from old_pos are weighted by the diffusion constants)

From 562d6c389e90c37b7ff8b76d7a883559930fec51 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Jul 2012 19:16:52 +0200
Subject: [PATCH 0982/1541] Use structure functions to determine new positions
 and structure IDs for single reactions with two products

---
 Structure.hpp       |  4 +--
 newBDPropagator.hpp | 70 +++++++++++++++++++++++----------------------
 2 files changed, 38 insertions(+), 36 deletions(-)

diff --git a/Structure.hpp b/Structure.hpp
index 980d564b..b28e0b15 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -142,10 +142,10 @@ class Structure
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const;
     // 2 - Producing two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   species_type const& s1, species_type const& s2, length_type const& rl, rng_type const& rng) const = 0;
+                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                   species_type const& s1, species_type const& s2, length_type const& rl, rng_type const& rng) const;
+                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const;
 
 
     virtual std::size_t hash() const
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 43ac87bf..218b24ea 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -480,31 +480,43 @@ class newBDPropagator
 
                     /*** TWO PRODUCTS ***/
                     case 2:
-                    {
+                    {                        
+                        //// 0 - SOME NECESSARY DEFINITONS
                         const position_type                             reactant_pos(pp.second.position());
                         const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
                         const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure( reactant_structure->structure_id() ) );
                         
-                        //// 0 - SOME NECESSARY DEFINITONS
-                        // We set: species 0 lives on the current structure; species 1 lives in the parent structure (if applicable).
-                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
+                        // The following will store the new positions and structure IDs
+                        position_pair_type                              pos0pos1;
+                        structure_id_type                               prod0_struct_id;
+                        structure_id_type                               prod1_struct_id;
+                        posstructid_posstructid_pair_type               pos0pos1_pair;
+                        
+                        // Determine the structures on which the products will end up.
+                        // By default we set both product structure to reactant_structure.
+                        const boost::shared_ptr<const structure_type> prod0_structure(reactant_structure);
+                        const boost::shared_ptr<const structure_type> prod1_structure(reactant_structure);
+                        // Now check whether one of the products actually leaves reactant_structure according to the reaction rules.
                         species_type product0_species(tx_.get_species(products[0]));
                         species_type product1_species(tx_.get_species(products[1]));
+                        // If the products live on different structures, one must be the parent of the other.
+                        // In the latter case we have to bring them into the right order.
+                        // We set: species 0 lives on the current structure; species 1 lives in the parent structure (if applicable).
+                        // Compare the structure type IDs of the product species to determine where products will end up:
                         if( product0_species.structure_type_id() != product1_species.structure_type_id() )
                         {
                             if( !(product0_species.structure_type_id() == parent_structure->sid() || 
                                   product1_species.structure_type_id() == parent_structure->sid())  )
-                                throw not_implemented("One of product species should live on parent structure.");
+                                throw not_implemented("One of the product species should live on parent structure.");
                                              
                             if ( !(product0_species.structure_type_id() == reactant_structure->sid()) )
                                 std::swap(product0_species, product1_species);
+                            
+                            // If the exception was not thrown, everything should be OK now.
+                            // Change the default setting for product1
+                            const boost::shared_ptr<const structure_type> prod1_structure(parent_structure);
                         }
 
-                        position_pair_type pos0pos1;
-                        structure_id_type prod0_struct_id;
-                        structure_id_type prod1_struct_id;
-                        posstructid_posstructid_pair_type pos0pos1_pair;
-
                         //// 1 - GENERATE POSITIONS AND STRUCTURE IDs & CHECK FOR OVERLAPS
                         /* Create positions (np0, np1) for the reaction products. 
                         The iv between the products lies within the reaction volume. */
@@ -519,30 +531,20 @@ class newBDPropagator
                         
                             //// 1a - GENERATE POSITIONS AND STRUCTURE IDs FOR PRODUCT PARTICLES AFTER REACTION
                             // If the product particles do NOT live on the same structure => structure -> structure + parent_structure dissociation.
-                            // Else, the products live on the same structure AND on the same structure as the reactant. 
-                            // => standard geminate dissociation.
-                            // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
-                            if( product0_species.structure_type_id() != product1_species.structure_type_id() )
-                            {
-                                // TODO include structure_id in return_type of dissociation_positions
-                                pos0pos1 = reactant_structure-> special_geminate_dissociation_positions( rng_, product0_species, product1_species,
-                                                                                                         reactant_pos, reaction_length_ );
-                                prod0_struct_id = pp.second.structure_id();             // The 'original' structure
-                                prod1_struct_id = reactant_structure->structure_id();   // The parent structure
-                            }
-                            else
-                            {
-                                // TODO include structure_id in return_type of dissociation_positions
-                                pos0pos1 = reactant_structure-> geminate_dissociation_positions( rng_, product0_species, product1_species,
-                                                                                                 reactant_pos, reaction_length_ );
-                                prod0_struct_id = pp.second.structure_id();         // same structure as the reactant
-                                prod1_struct_id = pp.second.structure_id();         // ditto
-                            }
-                            // TODO clean this up
-                            const boost::shared_ptr<const structure_type> prod0_structure(reactant_structure);
-                            const boost::shared_ptr<const structure_type> prod1_structure(tx_.get_structure(prod1_struct_id));
-                            const position_structid_pair_type pos_structid0 (tx_.apply_boundary( std::make_pair(pos0pos1.second, prod1_struct_id) ));
-                            const position_structid_pair_type pos_structid1 (tx_.apply_boundary( std::make_pair(pos0pos1.first,  prod0_struct_id) ));
+                            // Else, the products live on the same structure AND on the same structure as the reactant.
+                            // This is all taken care of by the structure functions get_pos_sid_pair_pair; the latter has to be called
+                            // with the right order of parameters, i.e. passing first the species of the particle staying on the reactant_structure,
+                            // then the species of the particle staying on the parent_structure.
+                            
+                            // Produce two new positions and structure IDs
+                            // Note that reactant_structure = prod0_structure here.
+                            pos0pos1_pair = reactant_structure->get_pos_sid_pair_pair(*prod1_structure, reactant_pos, product0_species, product1_species, reaction_length_, rng_ );
+                            // Remember the new structure IDs
+                            prod0_struct_id = pos0pos1_pair.first.second;
+                            prod1_struct_id = pos0pos1_pair.second.second;
+                            // Apply the boundary conditions
+                            const position_structid_pair_type pos_structid0 (tx_.apply_boundary( pos0pos1_pair.second ));
+                            const position_structid_pair_type pos_structid1 (tx_.apply_boundary( pos0pos1_pair.first  ));
                             pos0pos1_pair = std::make_pair(pos_structid0, pos_structid1);
 
 

From 375aef24c4ae647330c48ab39d91ac9d1eb32d35 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Jul 2012 19:50:03 +0200
Subject: [PATCH 0983/1541] Minor cleanup

---
 newBDPropagator.hpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 218b24ea..4d988718 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -487,7 +487,6 @@ class newBDPropagator
                         const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure( reactant_structure->structure_id() ) );
                         
                         // The following will store the new positions and structure IDs
-                        position_pair_type                              pos0pos1;
                         structure_id_type                               prod0_struct_id;
                         structure_id_type                               prod1_struct_id;
                         posstructid_posstructid_pair_type               pos0pos1_pair;
@@ -543,8 +542,8 @@ class newBDPropagator
                             prod0_struct_id = pos0pos1_pair.first.second;
                             prod1_struct_id = pos0pos1_pair.second.second;
                             // Apply the boundary conditions
-                            const position_structid_pair_type pos_structid0 (tx_.apply_boundary( pos0pos1_pair.second ));
-                            const position_structid_pair_type pos_structid1 (tx_.apply_boundary( pos0pos1_pair.first  ));
+                            const position_structid_pair_type pos_structid0 (tx_.apply_boundary( pos0pos1_pair.first  ));
+                            const position_structid_pair_type pos_structid1 (tx_.apply_boundary( pos0pos1_pair.second ));
                             pos0pos1_pair = std::make_pair(pos_structid0, pos_structid1);
 
 

From ef622d3973f1eb1a5512fef854049efff366bb87 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 13:29:19 +0200
Subject: [PATCH 0984/1541] Triple-switchbox despatching for functions with two
 origin surfaces

---
 CuboidalRegion.hpp     | 35 +++++++++++++++++++++++++++++++++--
 CylindricalSurface.hpp | 35 +++++++++++++++++++++++++++++++++--
 DiskSurface.hpp        | 35 +++++++++++++++++++++++++++++++++--
 PlanarSurface.hpp      | 35 +++++++++++++++++++++++++++++++++--
 SphericalSurface.hpp   | 35 +++++++++++++++++++++++++++++++++--
 Structure.hpp          | 12 +++++++++++-
 6 files changed, 176 insertions(+), 11 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 680d7b26..ae365579 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -153,7 +153,7 @@ class CuboidalRegion
     }
     
     /*** Despatch switchbox for the structure functions ***/
-    // 1 - One new position
+    // *** 1 *** - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -164,9 +164,10 @@ class CuboidalRegion
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
-    // 2 - Two new positions
+    // *** 2 *** - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -177,8 +178,38 @@ class CuboidalRegion
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+    }
+    // two associated helper functions this time
+    template <typename Tstruct1_>
+    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+    }
+    template <typename Tstruct1_, typename Tstruct2_>
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if(origin_structure1.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+        
+        else if(origin_structure2.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+        
+        else
+            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+    }
+    
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 458b87c0..da60ec90 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -228,7 +228,7 @@ class CylindricalSurface
     }
     
     /*** Despatch switchbox for the structure functions ***/
-    // 1 - One new position
+    // *** 1 *** - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -239,9 +239,10 @@ class CylindricalSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
-    // 2 - Two new positions
+    // *** 2 *** - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -252,8 +253,38 @@ class CylindricalSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+    }
+    // two associated helper functions this time
+    template <typename Tstruct1_>
+    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+    }
+    template <typename Tstruct1_, typename Tstruct2_>
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if(origin_structure1.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+        
+        else if(origin_structure2.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+        
+        else
+            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+    }
+
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 695e3e84..ab589e87 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -226,7 +226,7 @@ class DiskSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    // 1 - One new position
+    // *** 1 *** - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -237,9 +237,10 @@ class DiskSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
-    // 2 - Two new positions
+    // *** 2 *** - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -250,8 +251,38 @@ class DiskSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+    }
+    // two associated helper functions this time
+    template <typename Tstruct1_>
+    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+    }
+    template <typename Tstruct1_, typename Tstruct2_>
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if(origin_structure1.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+        
+        else if(origin_structure2.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+        
+        else
+            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+    }
+
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 0f57f047..482b8a9f 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -219,7 +219,7 @@ class PlanarSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    // 1 - One new position
+    // *** 1 *** - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -230,9 +230,10 @@ class PlanarSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
-    // 2 - Two new positions
+    // *** 2 *** - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -243,9 +244,39 @@ class PlanarSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+    }
+    // two associated helper functions this time
+    template <typename Tstruct1_>
+    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+    }
+    template <typename Tstruct1_, typename Tstruct2_>
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if(origin_structure1.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+        
+        else if(origin_structure2.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+        
+        else
+            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+    }
     
+
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
     virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 25b23f38..758ae7a9 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -117,7 +117,7 @@ class SphericalSurface
     }
 
     /*** Despatch switchbox for the structure functions ***/
-    // 1 - One new position
+    // *** 1 *** - One new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -128,9 +128,10 @@ class SphericalSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
-    // 2 - Two new positions
+    // *** 2 *** - Two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -141,8 +142,38 @@ class SphericalSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
+        // Despatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+    }
+    // two associated helper functions this time
+    template <typename Tstruct1_>
+    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+    }
+    template <typename Tstruct1_, typename Tstruct2_>
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if(origin_structure1.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+        
+        else if(origin_structure2.id == *this->id)
+            // Despatch to function with well-defined typing
+            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+        
+        else
+            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+    }
+    
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/Structure.hpp b/Structure.hpp
index b28e0b15..7073690c 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -123,7 +123,7 @@ class Structure
     virtual projected_type project_point(position_type const& pos) const = 0;
     virtual projected_type project_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
-    virtual position_type const& position() const = 0;    
+    virtual position_type const& position() const = 0;
 
     // Methods used for edge crossing (only for the planes so far)
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
@@ -146,6 +146,16 @@ class Structure
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                    species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const;
+    // 3 - Pair reactions => two origin structures => triple switchbox
+    // Overloading method call structure.get_pos_sid_pair
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+    template <typename Tstruct1_>
+    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;    
+    template <typename Tstruct1_, typename Tstruct2_>
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
 
 
     virtual std::size_t hash() const

From 4809dbefb5b8d1322de57d2722fb7a4e46848acc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 15:26:29 +0200
Subject: [PATCH 0985/1541] Outsource structure hierarchy check for pair
 reactions into structure functions

... by defining an additional double dynamic dispatch.

Triple dispatch stays, might be useful later.
---
 CuboidalRegion.hpp     | 70 +++++++++++++++++++++++++++++++++++++++---
 CylindricalSurface.hpp | 70 +++++++++++++++++++++++++++++++++++++++---
 DiskSurface.hpp        | 70 +++++++++++++++++++++++++++++++++++++++---
 PlanarSurface.hpp      | 70 +++++++++++++++++++++++++++++++++++++++---
 SphericalSurface.hpp   | 70 +++++++++++++++++++++++++++++++++++++++---
 Structure.hpp          | 16 ++++++++--
 newBDPropagator.hpp    | 56 +++++++++++++++++++++------------
 7 files changed, 374 insertions(+), 48 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index ae365579..03d405ef 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -152,8 +152,10 @@ class CuboidalRegion
         return pos_struct_id;       // The cyclic_transpose does nothing because we'll apply world cyclic transpose later.
     }
     
-    /*** Despatch switchbox for the structure functions ***/
+    
+    // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
+    // This requires a double dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -164,10 +166,12 @@ class CuboidalRegion
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    
     // *** 2 *** - Two new positions
+    // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -178,10 +182,66 @@ class CuboidalRegion
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
+    // introducing another double dynamic dispatch.
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+    }
+    // two associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.
+          
+          if( this->structure_type_id() != origin_structure1->structure_type_id() )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+        
+    }
+    
+    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+    // NOTE: This is yet unused, but possibly useful in the future.
+    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+    // a triple dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -199,11 +259,11 @@ class CuboidalRegion
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
         
         else if(origin_structure2.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
         
         else
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index da60ec90..1dfbbd85 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -227,8 +227,10 @@ class CylindricalSurface
         return pos_struct_id;       // for now we do not support connected cylindrical surfaces.
     }
     
-    /*** Despatch switchbox for the structure functions ***/
+    
+    // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
+    // This requires a double dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -239,10 +241,12 @@ class CylindricalSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    
     // *** 2 *** - Two new positions
+    // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -253,10 +257,66 @@ class CylindricalSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
+    // introducing another double dynamic dispatch.
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+    }
+    // two associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.
+          
+          if( this->structure_type_id() != origin_structure1->structure_type_id() )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+        
+    }
+    
+    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+    // NOTE: This is yet unused, but possibly useful in the future.
+    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+    // a triple dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -274,11 +334,11 @@ class CylindricalSurface
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
         
         else if(origin_structure2.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
         
         else
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index ab589e87..976a7ad7 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -225,8 +225,10 @@ class DiskSurface
         return pos_struct_id;   // Disks can also not be connected, so no cyclic transpose.
     }
 
-    /*** Despatch switchbox for the structure functions ***/
+
+    // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
+    // This requires a double dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -237,10 +239,12 @@ class DiskSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    
     // *** 2 *** - Two new positions
+    // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -251,10 +255,66 @@ class DiskSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
+    // introducing another double dynamic dispatch.
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+    }
+    // two associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.
+          
+          if( this->structure_type_id() != origin_structure1->structure_type_id() )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+        
+    }
+    
+    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+    // NOTE: This is yet unused, but possibly useful in the future.
+    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+    // a triple dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -272,11 +332,11 @@ class DiskSurface
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
         
         else if(origin_structure2.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
         
         else
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 482b8a9f..d8de69d2 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -218,8 +218,10 @@ class PlanarSurface
         return structure_container.cyclic_transpose(*this, pos_struct_id);
     }
 
-    /*** Despatch switchbox for the structure functions ***/
+
+    // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
+    // This requires a double dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -230,10 +232,12 @@ class PlanarSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    
     // *** 2 *** - Two new positions
+    // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -244,10 +248,66 @@ class PlanarSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
+    // introducing another double dynamic dispatch.
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+    }
+    // two associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.
+          
+          if( this->structure_type_id() != origin_structure1->structure_type_id() )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+        
+    }
+    
+    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+    // NOTE: This is yet unused, but possibly useful in the future.
+    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+    // a triple dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -265,11 +325,11 @@ class PlanarSurface
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
         
         else if(origin_structure2.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
         
         else
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 758ae7a9..49bdd1df 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -116,8 +116,10 @@ class SphericalSurface
         return pos_struct_id;       // Two spherical surface cannot be connected (there is no boundary!)
     }
 
-    /*** Despatch switchbox for the structure functions ***/
+
+    // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
+    // This requires a double dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -128,10 +130,12 @@ class SphericalSurface
     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
     }
+    
     // *** 2 *** - Two new positions
+    // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -142,10 +146,66 @@ class SphericalSurface
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
-        // Despatch to function with well-defined typing
+        // Dispatch to function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
     }
+    
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
+    // introducing another double dynamic dispatch.
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+    }
+    // two associated helper function
+    template <typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.
+          
+          if( this->structure_type_id() != origin_structure1->structure_type_id() )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+        
+    }
+    
+    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+    // NOTE: This is yet unused, but possibly useful in the future.
+    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+    // a triple dynamic dispatch.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
@@ -163,11 +223,11 @@ class SphericalSurface
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
         
         else if(origin_structure2.id == *this->id)
-            // Despatch to function with well-defined typing
+            // Dispatch to function with well-defined typing
             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
         
         else
diff --git a/Structure.hpp b/Structure.hpp
index 7073690c..c2b7eaa2 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -133,7 +133,7 @@ class Structure
                                                        structure_container_type const& structure_container) const = 0;
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
-    // Structure functions despatch switchbox
+    // Structure functions dynamic dispatch
     // 1 - Producing one new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
@@ -146,18 +146,28 @@ class Structure
     template <typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                    species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const;
-    // 3 - Pair reactions => two origin structures => triple switchbox
+    // 3 - Pair reactions => two origin structures
     // Overloading method call structure.get_pos_sid_pair
+    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+    template <typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;                                                                    
+    // 4 - Generalized functions for pair reactions => two origin structures and one target_structure
+    // This introduces a triple dynamic dispatch, overloading method call structure.get_pos_sid_pair once more.
+    // NOTE: As yet these methods are unused but might prove useful in the future.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
     template <typename Tstruct1_>
     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;    
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
     template <typename Tstruct1_, typename Tstruct2_>
     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
 
 
+
+
     virtual std::size_t hash() const
     {
 #if defined(HAVE_TR1_FUNCTIONAL)
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 4d988718..fd7fce72 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -31,30 +31,32 @@ class newBDPropagator
     typedef typename Ttraits_::world_type::structure_container_type structure_container_type;
 
     // shorthand typedef that we use
-    typedef typename particle_container_type::length_type           length_type;
-    typedef typename particle_container_type::position_type         position_type;
-    typedef typename particle_container_type::species_type          species_type;
-    typedef typename particle_container_type::species_id_type       species_id_type;
-    typedef typename particle_container_type::particle_id_type      particle_id_type;
-    typedef typename particle_container_type::particle_type         particle_type;
-    typedef typename particle_container_type::particle_id_pair      particle_id_pair;
-    typedef typename particle_container_type::particle_shape_type   particle_shape_type;
-    typedef typename particle_container_type::structure_type        structure_type;
-    typedef typename particle_container_type::structure_id_type     structure_id_type;    
+    typedef typename particle_container_type::length_type               length_type;
+    typedef typename particle_container_type::position_type             position_type;
+    typedef typename particle_container_type::species_type              species_type;
+    typedef typename particle_container_type::species_id_type           species_id_type;
+    typedef typename particle_container_type::particle_id_type          particle_id_type;
+    typedef typename particle_container_type::particle_type             particle_type;
+    typedef typename particle_container_type::particle_id_pair          particle_id_pair;
+    typedef typename particle_container_type::particle_shape_type       particle_shape_type;
+    typedef typename particle_container_type::structure_type            structure_type;
+    typedef typename particle_container_type::structure_id_type         structure_id_type;
+    typedef typename particle_container_type::structure_type_id_type    structure_type_id_type;
 
     typedef typename particle_container_type::particle_id_pair_generator          particle_id_pair_generator;
     typedef typename particle_container_type::particle_id_pair_and_distance       particle_id_pair_and_distance;
     typedef typename particle_container_type::particle_id_pair_and_distance_list  particle_id_pair_and_distance_list;
     typedef typename particle_container_type::structure_id_pair_and_distance      structure_id_pair_and_distance;
     typedef typename particle_container_type::structure_id_pair_and_distance_list structure_id_pair_and_distance_list;
-    typedef typename traits_type::world_type::traits_type::rng_type rng_type;
-    typedef typename traits_type::time_type                         time_type;
-    typedef typename traits_type::network_rules_type                network_rules_type;
-    typedef typename network_rules_type::reaction_rules             reaction_rules;
-    typedef typename network_rules_type::reaction_rule_type         reaction_rule_type;
-    typedef typename traits_type::reaction_record_type              reaction_record_type;
-    typedef typename traits_type::reaction_recorder_type            reaction_recorder_type;
-    typedef typename traits_type::volume_clearer_type               volume_clearer_type;
+    
+    typedef typename traits_type::world_type::traits_type::rng_type     rng_type;
+    typedef typename traits_type::time_type                             time_type;
+    typedef typename traits_type::network_rules_type                    network_rules_type;
+    typedef typename network_rules_type::reaction_rules                 reaction_rules;
+    typedef typename network_rules_type::reaction_rule_type             reaction_rule_type;
+    typedef typename traits_type::reaction_record_type                  reaction_record_type;
+    typedef typename traits_type::reaction_recorder_type                reaction_recorder_type;
+    typedef typename traits_type::volume_clearer_type                   volume_clearer_type;
 
     typedef std::vector<particle_id_type>                                       particle_id_vector_type;
     typedef std::pair<position_type, position_type>                             position_pair_type;
@@ -687,11 +689,12 @@ class newBDPropagator
                         position_type                       reactant1_pos (pp1.second.position());
 
                         const species_type                  product_species(tx_.get_species(products[0]));
+                        const structure_type_id_type        product_sid( product_species.structure_type_id() );
                         structure_id_type                   product_structure_id(reactant0_structure_id);
 
                         
                         //// 1 - GENERATE NEW POSITION AND STRUCTURE ID
-                        // If the particles lived on adjacent structures of the same type
+                        // If the reactants live on adjacent structures of the same type
                         // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         if ((s0.structure_type_id() == s1.structure_type_id()) &&
                             (reactant0_structure_id != reactant1_structure_id))
@@ -711,10 +714,22 @@ class newBDPropagator
                                                     (s0.D() + s1.D()))) );
 //                        position_type product_pos (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D());
 
+                        // Create a new position and structure_id for the center of mass.
+                        // This function automatically checks which of the two reactant structures is lower in hierarchy and makes this the
+                        // target structure. It also checks whether that structure has the right structure_type_id as queried from the reaction
+                        // rules before and passed via product_sid.
+                        const length_type offset(0.0);
+                        const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair(*reactant1_structure, product_sid, product_pos, offset, reaction_length_, rng_ ) );
+                        // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above
+                        // in some cases might end up out of the target_structure (e.g. in case the two reactants are coming from adjacent planes
+                        tx_.apply_boundary(product_pos_struct_id);
+                          // TODO cyclic_transpose ?
+
+                        
+                        /* OLD VERSION
                         // For unequal structure types, project product_pos on the 'lesser' structure.
                         // The 'lesser' structure is the structure that is the lowest in the hierarchy of the two.
                         // Note that this means that a reaction can only cross ONE hierarchical level of structures.
-                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
                         if( s0.structure_type_id() != s1.structure_type_id() )
                         {
 
@@ -755,6 +770,7 @@ class newBDPropagator
 
                             }
                         }
+                        */                        
 
                         //// 2 - CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos, product_species.radius());

From bce034d09bbd5324b2d0690470ff413cb2c89da4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 15:51:15 +0200
Subject: [PATCH 0986/1541] Some cleanup for BD pair reactions

---
 newBDPropagator.hpp | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index fd7fce72..c8cd0b35 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -689,13 +689,14 @@ class newBDPropagator
                         position_type                       reactant1_pos (pp1.second.position());
 
                         const species_type                  product_species(tx_.get_species(products[0]));
-                        const structure_type_id_type        product_sid( product_species.structure_type_id() );
+                        const structure_type_id_type        product_structure_type_id(product_species.structure_type_id());
                         structure_id_type                   product_structure_id(reactant0_structure_id);
+                        position_type                       product_pos(reactant0_pos);
 
                         
                         //// 1 - GENERATE NEW POSITION AND STRUCTURE ID
                         // If the reactants live on adjacent structures of the same type
-                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
+                        // TODO Can we outsource this also into the structure functions?
                         if ((s0.structure_type_id() == s1.structure_type_id()) &&
                             (reactant0_structure_id != reactant1_structure_id))
                         {
@@ -705,26 +706,31 @@ class newBDPropagator
                         }
 
                         // calculate the product position (CoM of the two particles)
-                        position_type product_pos( tx_.apply_boundary(
+                        position_type reactants_CoM( tx_.apply_boundary(
                                                     divide(
                                                     add(multiply(reactant0_pos, s1.D()),
                                                         multiply(tx_.cyclic_transpose(
                                                             reactant1_pos,
                                                             reactant0_pos), s0.D())),
                                                     (s0.D() + s1.D()))) );
-//                        position_type product_pos (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D());
+//                        position_type reactants_CoM (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D()); // TODO What is that?
 
                         // Create a new position and structure_id for the center of mass.
                         // This function automatically checks which of the two reactant structures is lower in hierarchy and makes this the
                         // target structure. It also checks whether that structure has the right structure_type_id as queried from the reaction
                         // rules before and passed via product_sid.
                         const length_type offset(0.0);
-                        const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair(*reactant1_structure, product_sid, product_pos, offset, reaction_length_, rng_ ) );
+                        const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair(*reactant1_structure, product_structure_type_id,
+                                                                                                                       reactants_CoM, offset, reaction_length_, rng_ ) );
                         // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above
                         // in some cases might end up out of the target_structure (e.g. in case the two reactants are coming from adjacent planes
                         tx_.apply_boundary(product_pos_struct_id);
-                          // TODO cyclic_transpose ?
+                          // TODO cyclic_transpose ?                          
 
+                        // Store the newly created particle info
+                        product_pos          = product_pos_struct_id.first;
+                        product_structure_id = product_pos_struct_id.second;
+                        
                         
                         /* OLD VERSION
                         // For unequal structure types, project product_pos on the 'lesser' structure.

From 9a36d2ee0e9d6c0baf14137149018b7d43bab422 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 15:55:44 +0200
Subject: [PATCH 0987/1541] More commenting

---
 newBDPropagator.hpp | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index c8cd0b35..773ef013 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -716,17 +716,21 @@ class newBDPropagator
 //                        position_type reactants_CoM (tx_.calculate_pair_CoM(pp0.second.position(), pp1.second.position()), s0.D(), s1.D()); // TODO What is that?
 
                         // Create a new position and structure_id for the center of mass.
-                        // This function automatically checks which of the two reactant structures is lower in hierarchy and makes this the
-                        // target structure. It also checks whether that structure has the right structure_type_id as queried from the reaction
+                        // The function get_pos_sid_pair here automatically checks which of the two reactant structures is lower in hierarchy and makes
+                        // this the target structure. It also checks whether that structure has the right structure_type_id as queried from the reaction
                         // rules before and passed via product_sid.
+                        // get_pos_sid_pair should result in projecting the CoM onto the lower level origin structure in this case. If both reactant
+                        // structures are the same, no projection should occur. This is handled correctly by the structure functions defined for equal
+                        // origin_structure types.
                         const length_type offset(0.0);
                         const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair(*reactant1_structure, product_structure_type_id,
                                                                                                                        reactants_CoM, offset, reaction_length_, rng_ ) );
                         // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above
                         // in some cases might end up out of the target_structure (e.g. in case the two reactants are coming from adjacent planes
                         tx_.apply_boundary(product_pos_struct_id);
-                          // TODO cyclic_transpose ?                          
-
+                          // TODO cyclic_transpose ?
+                          // TODO check whether the new position is in the target structure?
+                          
                         // Store the newly created particle info
                         product_pos          = product_pos_struct_id.first;
                         product_structure_id = product_pos_struct_id.second;

From cd3e1af9a09d3902db6acb4cc5e6e2708d96150e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 15:56:09 +0200
Subject: [PATCH 0988/1541] Remove old version of BD pair reaction handling

---
 newBDPropagator.hpp | 46 ---------------------------------------------
 1 file changed, 46 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 773ef013..730a34dc 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -735,52 +735,6 @@ class newBDPropagator
                         product_pos          = product_pos_struct_id.first;
                         product_structure_id = product_pos_struct_id.second;
                         
-                        
-                        /* OLD VERSION
-                        // For unequal structure types, project product_pos on the 'lesser' structure.
-                        // The 'lesser' structure is the structure that is the lowest in the hierarchy of the two.
-                        // Note that this means that a reaction can only cross ONE hierarchical level of structures.
-                        if( s0.structure_type_id() != s1.structure_type_id() )
-                        {
-
-                            boost::shared_ptr<structure_type> product_structure;
-                            if ( reactant0_structure->structure_id() == reactant1_structure_id )        // if pp1 lives on the parent structure of pp0
-                            {
-                                product_structure_id = reactant0_structure_id;                          // -> lesser structure is structure0
-                                product_structure = reactant0_structure;
-                            }
-                            else if ( reactant1_structure->structure_id() == reactant0_structure_id )   // pp0 lives on the parent structure of pp1
-                            {
-                                product_structure_id = reactant1_structure_id;                          // -> lesser structure is structure1
-                                product_structure = reactant1_structure;
-                            }
-                            else
-                            {
-                                throw propagation_error("Particles can only be one hierarchical level apart.");
-                            }
-
-                            projected_type const position_on_surface( product_structure-> project_point(
-                                    tx_.cyclic_transpose( product_pos, product_structure->position() )));       // TODO check of cyclic transpose is still needed.
-
-                            // check that the projected point is not outside of the product surface.
-                            if ( position_on_surface.second.second > 0 )
-                                throw propagation_error("position product particle was not in surface.");
-
-                            product_pos = tx_.apply_boundary( position_on_surface.first );
-                        }
-                        else
-                        // The structure_types are the same
-                        {
-                            if (reactant0_structure_id != reactant1_structure_id)
-                            {
-                                const position_structid_pair_type bla (tx_.apply_boundary(std::make_pair(product_pos, reactant0_structure_id)));
-                                // deflect the product coordinate and get right structure_id.
-                                product_pos = bla.first;
-                                product_structure_id = bla.second;
-
-                            }
-                        }
-                        */                        
 
                         //// 2 - CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos, product_species.radius());

From 8bafae88ab46c7c335eaaff1130968fc6cfc3772 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 15:59:30 +0200
Subject: [PATCH 0989/1541] Comments

---
 newBDPropagator.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 730a34dc..72210872 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -517,6 +517,7 @@ class newBDPropagator
                             // Change the default setting for product1
                             const boost::shared_ptr<const structure_type> prod1_structure(parent_structure);
                         }
+                        // TODO Can we not outsource this part to the structure functions, too?
 
                         //// 1 - GENERATE POSITIONS AND STRUCTURE IDs & CHECK FOR OVERLAPS
                         /* Create positions (np0, np1) for the reaction products. 

From 15f8f62adb42641a95df8cb8ccb232fb8ce8f522 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 16:27:59 +0200
Subject: [PATCH 0990/1541] More commenting

---
 newBDPropagator.hpp | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 72210872..2ee3452a 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -150,7 +150,9 @@ class newBDPropagator
         /*** 2. DISPLACEMENT TRIAL ***/
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particle bounces, and is returned
-           to it's original position. For a particle with D = 0, new_pos = old_pos */        
+           to it's original position. For a particle with D = 0, new_pos = old_pos 
+           Note that apply_boundary takes care of instant transitions between structures of the same
+           structure_type. */        
         if (pp_species.D() != 0.0)
         {
             // get a new position, dependent on the structure the particle lives on.
@@ -230,9 +232,9 @@ class newBDPropagator
         const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
         //// 5.1 INTERACTIONS WITH STRUCTURES
         // First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction.
-        // TODO TODO TODO THIS SHOULD BE REWORKED USING THE NEW STRUCTURE FUNCTIONS! TODO TODO TODO
-        // TODO also interaction should be allowed when a particle is on a cylinder.
-        // TODO don't check only the closest but check all overlapping surfaces.
+        // TODO Rework this using the new structure functions?
+        // TODO Also an interaction should be allowed when a particle is on a cylinder. // Is that not yet the case???
+        // TODO Don't check only the closest but check all overlapping surfaces.
         j = 0;
         while(j < structures_in_overlap)
         {
@@ -249,7 +251,7 @@ class newBDPropagator
         
                 if(accumulated_prob >= 1.) // sth. is wrong in this case
                 {
-                    LOG_WARNING(("the acceptance probability of an interaction/reaction exeeded one; %f.",
+                    LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one; %f.",
                                  accumulated_prob));
                 } 
                 

From 6d023f76b3154625ffbb88f34c6a6ef5701ae62e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Jul 2012 18:50:40 +0200
Subject: [PATCH 0991/1541] Some further cleanup

---
 CuboidalRegion.hpp         |  2 +-
 CylindricalSurface.hpp     |  2 +-
 DiskSurface.hpp            |  2 +-
 Makefile.am                | 13 ++++++-------
 PlanarSurface.hpp          |  2 +-
 SphericalSurface.hpp       |  2 +-
 Structure.hpp              |  6 +++---
 binding/binding_common.hpp | 16 ++++++++--------
 8 files changed, 22 insertions(+), 23 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 03d405ef..c6d9f3cc 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -255,7 +255,7 @@ class CuboidalRegion
         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
     }
     template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 1dfbbd85..013f4216 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -330,7 +330,7 @@ class CylindricalSurface
         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
     }
     template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 976a7ad7..927135ee 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -328,7 +328,7 @@ class DiskSurface
         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
     }
     template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
diff --git a/Makefile.am b/Makefile.am
index 1447d1b5..ec557bb3 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -47,11 +47,11 @@ noinst_HEADERS = \
 	BasicNetworkRulesImpl.hpp\
 	GreensFunction3DRadInf.hpp\
 	BDPropagator.hpp\
-    newBDPropagator.hpp\
+	newBDPropagator.hpp\
 	BDSimulator.hpp\
 	bessel.hpp\
 	Box.hpp\
-    ConnectivityContainer.hpp\
+	ConnectivityContainer.hpp\
 	ConsoleAppender.hpp\
 	Cylinder.hpp\
 	Disk.hpp\
@@ -119,10 +119,9 @@ noinst_HEADERS = \
 	SphericalBesselGenerator.hpp\
 	SphericalBesselTable.hpp\
 	Structure.hpp\
-    StructureFunctions.cpp\
-    StructureFunctions.hpp\
-    StructureID.hpp\
-    StructureContainer.hpp\
+	StructureFunctions.hpp\
+	StructureID.hpp\
+	StructureContainer.hpp\
 	StructureUtils.hpp\
 	StructureType.hpp\
 	Surface.hpp\
@@ -195,7 +194,7 @@ _gfrd_la_SOURCES=\
 	SpeciesType.cpp\
 	SphericalBesselGenerator.cpp\
 	StructureType.cpp\
-    StructureFunctions.cpp\
+	StructureFunctions.cpp\
 	utils.cpp
 
 _greens_functions_la_SOURCES=\
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index d8de69d2..eff2cc3a 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -321,7 +321,7 @@ class PlanarSurface
         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
     }
     template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 49bdd1df..81155758 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -219,7 +219,7 @@ class SphericalSurface
         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
     }
     template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         if(origin_structure1.id == *this->id)
diff --git a/Structure.hpp b/Structure.hpp
index c2b7eaa2..1a59c7e6 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -149,7 +149,7 @@ class Structure
     // 3 - Pair reactions => two origin structures
     // Overloading method call structure.get_pos_sid_pair
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
     template <typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                     length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;                                                                    
@@ -157,12 +157,12 @@ class Structure
     // This introduces a triple dynamic dispatch, overloading method call structure.get_pos_sid_pair once more.
     // NOTE: As yet these methods are unused but might prove useful in the future.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
     template <typename Tstruct1_>
     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
     template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ origin_structure2, position_type const& position,
+    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
 
 
diff --git a/binding/binding_common.hpp b/binding/binding_common.hpp
index 0611ff90..5907128e 100644
--- a/binding/binding_common.hpp
+++ b/binding/binding_common.hpp
@@ -82,12 +82,12 @@ typedef EGFRDSimulator::plane_type      Plane;
 typedef ::BDPropagator<EGFRDSimulatorTraits>        BDPropagator;
 typedef ::newBDPropagator<EGFRDSimulatorTraits>     newBDPropagator;
 
-typedef EGFRDSimulatorTraits::shell_id_type     ShellID;
-typedef EGFRDSimulatorTraits::domain_id_type    DomainID;
+typedef EGFRDSimulatorTraits::shell_id_type         ShellID;
+typedef EGFRDSimulatorTraits::domain_id_type        DomainID;
 typedef EGFRDSimulatorTraits::reaction_rule_type    ReactionRuleInfo;
 typedef EGFRDSimulatorTraits::network_rules_type    NetworkRulesWrapper;
-typedef EGFRDSimulator::domain_type             Domain;
-typedef ::ShapedDomain<EGFRDSimulatorTraits>    ShapedDomain;
+typedef EGFRDSimulator::domain_type                         Domain;
+typedef ::ShapedDomain<EGFRDSimulatorTraits>                ShapedDomain;
 typedef EGFRDSimulator::spherical_shell_type                SphericalShell;
 typedef EGFRDSimulator::cylindrical_shell_type              CylindricalShell;
 typedef EGFRDSimulator::spherical_single_type::base_type    Single;
@@ -97,10 +97,10 @@ typedef EGFRDSimulator::cylindrical_single_type             CylindricalSingle;
 typedef EGFRDSimulator::spherical_pair_type                 SphericalPair;
 typedef EGFRDSimulator::cylindrical_pair_type               CylindricalPair;
 typedef EGFRDSimulator::multi_type                          Multi;
-typedef ::MatrixSpace<SphericalShell, ShellID>      SphericalShellContainer;
-typedef ::MatrixSpace<CylindricalShell, ShellID>    CylindricalShellContainer;
-typedef ::StructureUtils<EGFRDSimulator> StructureUtils;
-typedef EGFRDSimulator::particle_simulation_structure_type ParticleSimulationStructure;
+typedef ::MatrixSpace<SphericalShell, ShellID>              SphericalShellContainer;
+typedef ::MatrixSpace<CylindricalShell, ShellID>            CylindricalShellContainer;
+typedef ::StructureUtils<EGFRDSimulator>                    StructureUtils;
+typedef EGFRDSimulator::particle_simulation_structure_type  ParticleSimulationStructure;
 
 typedef EGFRDSimulator::surface_type                Surface;
 typedef EGFRDSimulator::region_type                 Region;

From 25d73c9941cce85952945bbaf6755dc95113d1e5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 6 Jul 2012 14:00:43 +0200
Subject: [PATCH 0992/1541] Test-exposing structure function helpers to python
 structure object

---
 binding/Structure.hpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 469b167c..6778cf67 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -48,6 +48,12 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("project_point", &impl_type::project_point)
         .def("deflect", &impl_type::deflect)
+        .def("get_pos_sid_pair_helper", &impl_type::template get_pos_sid_pair_helper<typename impl_type::structure_type>)
+        .def("get_pos_sid_pair_pair_helper", &impl_type::template get_pos_sid_pair_pair_helper<typename impl_type::structure_type>)
+        .def("get_pos_sid_pair_helper_two_origins", &impl_type::template get_pos_sid_pair_helper_two_origins<typename impl_type::structure_type>)
+        .def("get_pos_sid_pair_helper1", &impl_type::template get_pos_sid_pair_helper1<typename impl_type::structure_type>)
+        .def("get_pos_sid_pair_helper2", &impl_type::template get_pos_sid_pair_helper2<typename impl_type::structure_type, typename impl_type::structure_type>)
+
 //        .def("deflect_back", &impl_type::deflect_back)
         ;
 }

From 501a0b386a45c838cfdec133e3875c10ef2ce019 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Jul 2012 18:19:36 +0200
Subject: [PATCH 0993/1541] Replace template by explicit declaration for each
 derived Structure

Extremenly ugly, but it f****** finally works!
---
 CuboidalRegion.hpp     | 180 +++++++++++-----------
 CylindricalSurface.hpp | 172 ++++++++++-----------
 DiskSurface.hpp        | 180 +++++++++++-----------
 PlanarSurface.hpp      | 180 +++++++++++-----------
 SphericalSurface.hpp   | 180 +++++++++++-----------
 Structure.hpp          | 329 ++++++++++++++++++++++++++++++++++++++---
 StructureFunctions.hpp | 201 +++++++++++++++++++++++++
 binding/Structure.hpp  |  10 +-
 8 files changed, 963 insertions(+), 469 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index c6d9f3cc..02e0bc21 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -161,14 +161,14 @@ class CuboidalRegion
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
+//     }
     
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -177,14 +177,14 @@ class CuboidalRegion
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
+//     }
     
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
@@ -194,81 +194,81 @@ class CuboidalRegion
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
-    // two associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.
-          
-          if( this->structure_type_id() != origin_structure1->structure_type_id() )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-        
-    }
+//     // two associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//           // The types of both origin structures now are determined.
+//           // As a next step, determine which one is the target structure and call the right
+//           // structure function with the other one as origin structure.
+//           
+//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
+//           // if the two pair reactants come from different types of structure
+//           {
+// 
+//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+//               {
+//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+//               }
+//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+//               {
+//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//               }
+//               else
+//               {
+//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+//                   // TODO In principle this constraint could be dropped; the target structure should be determined
+//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+//               }  
+//         }
+//         else
+//         // the reactants live on the same structure type, i.e. the product will also end up on 
+//         {
+//             // Call transition function with origin_structure = target_structure = *this
+//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//             // Note that apply_boundary should place the product particle on the right one of the two structures
+//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+//             // structure_type_id's are the same!).
+//         }
+//         
+//     }
     
-    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
-    // NOTE: This is yet unused, but possibly useful in the future.
-    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
-    // a triple dynamic dispatch.
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-    }
-    // two associated helper functions this time
-    template <typename Tstruct1_>
-    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-    }
-    template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        if(origin_structure1.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-        
-        else if(origin_structure2.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-        
-        else
-            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
-    }
+//     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+//     // NOTE: This is yet unused, but possibly useful in the future.
+//     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+//     // a triple dynamic dispatch.
+//     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+//     }
+//     // two associated helper functions this time
+//     template <typename Tstruct1_>
+//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+//     }
+//     template <typename Tstruct1_, typename Tstruct2_>
+//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         if(origin_structure1.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+//         
+//         else if(origin_structure2.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+//         
+//         else
+//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+//     }
     
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 013f4216..fb5f8c44 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -236,14 +236,14 @@ class CylindricalSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
+//     }
     
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -252,14 +252,14 @@ class CylindricalSurface
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
+//     }
     
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
@@ -269,81 +269,81 @@ class CylindricalSurface
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
-    // two associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.
-          
-          if( this->structure_type_id() != origin_structure1->structure_type_id() )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-        
-    }
+//     // two associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//           // The types of both origin structures now are determined.
+//           // As a next step, determine which one is the target structure and call the right
+//           // structure function with the other one as origin structure.
+//           
+//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
+//           // if the two pair reactants come from different types of structure
+//           {
+// 
+//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+//               {
+//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+//               }
+//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+//               {
+//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//               }
+//               else
+//               {
+//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+//                   // TODO In principle this constraint could be dropped; the target structure should be determined
+//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+//               }  
+//         }
+//         else
+//         // the reactants live on the same structure type, i.e. the product will also end up on 
+//         {
+//             // Call transition function with origin_structure = target_structure = *this
+//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//             // Note that apply_boundary should place the product particle on the right one of the two structures
+//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+//             // structure_type_id's are the same!).
+//         }
+//         
+//     }
     
     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
     // NOTE: This is yet unused, but possibly useful in the future.
     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
     // a triple dynamic dispatch.
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-    }
-    // two associated helper functions this time
-    template <typename Tstruct1_>
-    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-    }
-    template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        if(origin_structure1.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-        
-        else if(origin_structure2.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-        
-        else
-            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
-    }
+//     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+//     }
+//     // two associated helper functions this time
+//     template <typename Tstruct1_>
+//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+//     }
+//     template <typename Tstruct1_, typename Tstruct2_>
+//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         if(origin_structure1.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+//         
+//         else if(origin_structure2.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+//         
+//         else
+//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+//     }
 
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 927135ee..3d094381 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -234,14 +234,14 @@ class DiskSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
+//     }
     
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -250,14 +250,14 @@ class DiskSurface
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
+//     }
     
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
@@ -267,81 +267,81 @@ class DiskSurface
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
-    // two associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.
-          
-          if( this->structure_type_id() != origin_structure1->structure_type_id() )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-        
-    }
+//     // two associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//           // The types of both origin structures now are determined.
+//           // As a next step, determine which one is the target structure and call the right
+//           // structure function with the other one as origin structure.
+//           
+//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
+//           // if the two pair reactants come from different types of structure
+//           {
+// 
+//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+//               {
+//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+//               }
+//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+//               {
+//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//               }
+//               else
+//               {
+//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+//                   // TODO In principle this constraint could be dropped; the target structure should be determined
+//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+//               }  
+//         }
+//         else
+//         // the reactants live on the same structure type, i.e. the product will also end up on 
+//         {
+//             // Call transition function with origin_structure = target_structure = *this
+//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//             // Note that apply_boundary should place the product particle on the right one of the two structures
+//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+//             // structure_type_id's are the same!).
+//         }
+//         
+//     }
     
-    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
-    // NOTE: This is yet unused, but possibly useful in the future.
-    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
-    // a triple dynamic dispatch.
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-    }
-    // two associated helper functions this time
-    template <typename Tstruct1_>
-    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-    }
-    template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        if(origin_structure1.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-        
-        else if(origin_structure2.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-        
-        else
-            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
-    }
+//     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+//     // NOTE: This is yet unused, but possibly useful in the future.
+//     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+//     // a triple dynamic dispatch.
+//     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+//     }
+//     // two associated helper functions this time
+//     template <typename Tstruct1_>
+//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+//     }
+//     template <typename Tstruct1_, typename Tstruct2_>
+//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         if(origin_structure1.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+//         
+//         else if(origin_structure2.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+//         
+//         else
+//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+//     }
 
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index eff2cc3a..4fc5d3cd 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -227,14 +227,14 @@ class PlanarSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
+//     }
     
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -243,14 +243,14 @@ class PlanarSurface
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
+//     }
     
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
@@ -260,81 +260,81 @@ class PlanarSurface
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
-    // two associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.
-          
-          if( this->structure_type_id() != origin_structure1->structure_type_id() )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-        
-    }
+//     // two associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//           // The types of both origin structures now are determined.
+//           // As a next step, determine which one is the target structure and call the right
+//           // structure function with the other one as origin structure.
+//           
+//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
+//           // if the two pair reactants come from different types of structure
+//           {
+// 
+//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+//               {
+//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+//               }
+//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+//               {
+//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//               }
+//               else
+//               {
+//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+//                   // TODO In principle this constraint could be dropped; the target structure should be determined
+//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+//               }  
+//         }
+//         else
+//         // the reactants live on the same structure type, i.e. the product will also end up on 
+//         {
+//             // Call transition function with origin_structure = target_structure = *this
+//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//             // Note that apply_boundary should place the product particle on the right one of the two structures
+//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+//             // structure_type_id's are the same!).
+//         }
+//         
+//     }
     
-    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
-    // NOTE: This is yet unused, but possibly useful in the future.
-    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
-    // a triple dynamic dispatch.
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-    }
-    // two associated helper functions this time
-    template <typename Tstruct1_>
-    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-    }
-    template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        if(origin_structure1.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-        
-        else if(origin_structure2.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-        
-        else
-            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
-    }
+//     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+//     // NOTE: This is yet unused, but possibly useful in the future.
+//     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+//     // a triple dynamic dispatch.
+//     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+//     }
+//     // two associated helper functions this time
+//     template <typename Tstruct1_>
+//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+//     }
+//     template <typename Tstruct1_, typename Tstruct2_>
+//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         if(origin_structure1.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+//         
+//         else if(origin_structure2.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+//         
+//         else
+//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+//     }
     
 
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 81155758..4947da2e 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -125,14 +125,14 @@ class SphericalSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
+//     }
     
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -141,14 +141,14 @@ class SphericalSurface
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
-    // the associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-    {
-        // Dispatch to function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-    }
+//     // the associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
+//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         // Dispatch to function with well-defined typing
+//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
+//     }
     
     // *** 3 *** - Pair reactions => two origin structures => triple switchbox
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
@@ -158,81 +158,81 @@ class SphericalSurface
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
-    // two associated helper function
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                    position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.
-          
-          if( this->structure_type_id() != origin_structure1->structure_type_id() )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-        
-    }
+//     // two associated helper function
+//     template <typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
+//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//           // The types of both origin structures now are determined.
+//           // As a next step, determine which one is the target structure and call the right
+//           // structure function with the other one as origin structure.
+//           
+//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
+//           // if the two pair reactants come from different types of structure
+//           {
+// 
+//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
+//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+//               {
+//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+//               }
+//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
+//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+//               {
+//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//               }
+//               else
+//               {
+//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+//                   // TODO In principle this constraint could be dropped; the target structure should be determined
+//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+//               }  
+//         }
+//         else
+//         // the reactants live on the same structure type, i.e. the product will also end up on 
+//         {
+//             // Call transition function with origin_structure = target_structure = *this
+//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+//             // Note that apply_boundary should place the product particle on the right one of the two structures
+//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+//             // structure_type_id's are the same!).
+//         }
+//         
+//     }
     
-    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
-    // NOTE: This is yet unused, but possibly useful in the future.
-    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
-    // a triple dynamic dispatch.
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-    }
-    // two associated helper functions this time
-    template <typename Tstruct1_>
-    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-    }
-    template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        if(origin_structure1.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-        
-        else if(origin_structure2.id == *this->id)
-            // Dispatch to function with well-defined typing
-            return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-        
-        else
-            throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
-    }
+//     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+//     // NOTE: This is yet unused, but possibly useful in the future.
+//     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+//     // a triple dynamic dispatch.
+//     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
+//     }
+//     // two associated helper functions this time
+//     template <typename Tstruct1_>
+//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+//     }
+//     template <typename Tstruct1_, typename Tstruct2_>
+//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         if(origin_structure1.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+//         
+//         else if(origin_structure2.id == *this->id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+//         
+//         else
+//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+//     }
     
     
     /*** Formerly used functions of the Morelli scheme ***/
diff --git a/Structure.hpp b/Structure.hpp
index 1a59c7e6..6ee60eb9 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -15,10 +15,29 @@
 #include "exceptions.hpp"
 #include "freeFunctions.hpp"
 #include "SpeciesTypeID.hpp"
+#include "StructureFunctions.hpp"
 
+// Forward declarations
 template <typename Tobj_, typename Tid, typename Ttraits_>
 class StructureContainer;
 
+template<typename T_>
+class CuboidalRegion;
+
+template<typename T_>
+class CylindricalSurface;
+
+template<typename T_>
+class SphericalSurface;
+
+template<typename T_>
+class DiskSurface;
+
+template<typename T_>
+class PlanarSurface;
+
+
+
 template<typename Ttraits_>
 class Structure
 {
@@ -136,34 +155,308 @@ class Structure
     // Structure functions dynamic dispatch
     // 1 - Producing one new position
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const;
+                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;                                                         
+    position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
+    position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
+    position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
+    position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
+    position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };
+    
     // 2 - Producing two new positions
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
-    template <typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const;
+        
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
+        
     // 3 - Pair reactions => two origin structures
     // Overloading method call structure.get_pos_sid_pair
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    template <typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;                                                                    
+    
+    // TODO This is just so ugly, outsource this somehow!
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {          
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.          
+          
+          structure_id_type      os1_id( origin_structure1.id() );
+          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
+          structure_type_id_type os1_sid( origin_structure1.sid() );
+          
+          structure_id_type      this_id( this->id() );
+          structure_id_type      this_parent_id( this->structure_id() );
+          structure_type_id_type this_sid( this->sid() );
+          
+          if( this->sid() != os1_sid )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+    } 
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {          
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.          
+          
+          structure_id_type      os1_id( origin_structure1.id() );
+          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
+          structure_type_id_type os1_sid( origin_structure1.sid() );
+          
+          structure_id_type      this_id( this->id() );
+          structure_id_type      this_parent_id( this->structure_id() );
+          structure_type_id_type this_sid( this->sid() );
+          
+          if( this->sid() != os1_sid )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+    } 
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {          
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.          
+          
+          structure_id_type      os1_id( origin_structure1.id() );
+          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
+          structure_type_id_type os1_sid( origin_structure1.sid() );
+          
+          structure_id_type      this_id( this->id() );
+          structure_id_type      this_parent_id( this->structure_id() );
+          structure_type_id_type this_sid( this->sid() );
+          
+          if( this->sid() != os1_sid )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+    } 
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {          
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.          
+          
+          structure_id_type      os1_id( origin_structure1.id() );
+          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
+          structure_type_id_type os1_sid( origin_structure1.sid() );
+          
+          structure_id_type      this_id( this->id() );
+          structure_id_type      this_parent_id( this->structure_id() );
+          structure_type_id_type this_sid( this->sid() );
+          
+          if( this->sid() != os1_sid )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+    } 
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {          
+          // The types of both origin structures now are determined.
+          // As a next step, determine which one is the target structure and call the right
+          // structure function with the other one as origin structure.          
+          
+          structure_id_type      os1_id( origin_structure1.id() );
+          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
+          structure_type_id_type os1_sid( origin_structure1.sid() );
+          
+          structure_id_type      this_id( this->id() );
+          structure_id_type      this_parent_id( this->structure_id() );
+          structure_type_id_type this_sid( this->sid() );
+          
+          if( this->sid() != os1_sid )
+          // if the two pair reactants come from different types of structure
+          {
+
+              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
+              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
+              {
+                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
+                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+              }
+              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
+              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
+              {
+                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
+                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+              }
+              else
+              {
+                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
+                  // TODO In principle this constraint could be dropped; the target structure should be determined
+                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
+              }  
+        }
+        else
+        // the reactants live on the same structure type, i.e. the product will also end up on 
+        {
+            // Call transition function with origin_structure = target_structure = *this
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            // Note that apply_boundary should place the product particle on the right one of the two structures
+            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
+            // structure_type_id's are the same!).
+        }
+    } 
+    
+    
+    // TODO Outsource the ugly stuff above at least partly into this!
+    bool is_parent_of_or_same_as(structure_type s)
+    {    
+        return true;
+    }
+                                                                    
     // 4 - Generalized functions for pair reactions => two origin structures and one target_structure
     // This introduces a triple dynamic dispatch, overloading method call structure.get_pos_sid_pair once more.
     // NOTE: As yet these methods are unused but might prove useful in the future.
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    template <typename Tstruct1_>
-    position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
-    template <typename Tstruct1_, typename Tstruct2_>
-    position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+//     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+//     template <typename Tstruct1_>
+//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+//     template <typename Tstruct1_, typename Tstruct2_>
+//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
 
 
 
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 9c4574a3..97d73259 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -3,6 +3,9 @@
 
 
 // Forward declaration of structures
+template <typename Ttraits_>
+class Structure;
+
 template <typename Ttraits_>
 class CuboidalRegion;
 
@@ -32,6 +35,130 @@ class PlanarSurface;
 /*** ONE NEW POSITION ***/
 /************************/
 
+/******************************/
+/* Some Defaults declarations */
+/******************************/
+// These are actually never called but have to be there for type consistency reasons
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+                  Structure<Ttraits_>                   const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+                  Structure<Ttraits_>                   const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+                  Structure<Ttraits_>                   const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+                  Structure<Ttraits_>                   const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( PlanarSurface<Ttraits_>              const& origin_structure,
+                  Structure<Ttraits_>                   const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+                  CuboidalRegion<Ttraits_>              const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+                  DiskSurface<Ttraits_>                 const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+                  PlanarSurface<Ttraits_>               const& target_structure,
+                  typename Ttraits_::position_type      const& old_pos,
+                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& reaction_length,
+                  typename Ttraits_::rng_type           const& rng              )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
 /******************************/
 /* Coming from CuboidalRegion */
 /******************************/
@@ -280,6 +407,80 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 /*** TWO NEW POSITIONS ***/
 /*************************/
 
+/******************************/
+/* Some Defaults declarations */
+/******************************/
+// These are actually never called but have to be there for type consistency reasons
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+                       Structure<Ttraits_>                    const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::length_type         const& reaction_length,
+                       typename Ttraits_::rng_type            const& rng                 )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+                       Structure<Ttraits_>                    const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::length_type         const& reaction_length,
+                       typename Ttraits_::rng_type            const& rng                 )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+                       Structure<Ttraits_>                    const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::length_type         const& reaction_length,
+                       typename Ttraits_::rng_type            const& rng                 )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+                       Structure<Ttraits_>                    const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::length_type         const& reaction_length,
+                       typename Ttraits_::rng_type            const& rng                 )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
+template <typename Ttraits_>
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+                       Structure<Ttraits_>                    const& target_structure,
+                       typename Ttraits_::position_type       const& old_pos,
+                       typename Ttraits_::species_type        const& s1,
+                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::length_type         const& reaction_length,
+                       typename Ttraits_::rng_type            const& rng                 )
+{
+    throw illegal_propagation_attempt("Calling structure function without type specification!");
+}
+
 /******************************/
 /* Coming from CuboidalRegion */
 /******************************/
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 6778cf67..658fa147 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -48,11 +48,11 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("project_point", &impl_type::project_point)
         .def("deflect", &impl_type::deflect)
-        .def("get_pos_sid_pair_helper", &impl_type::template get_pos_sid_pair_helper<typename impl_type::structure_type>)
-        .def("get_pos_sid_pair_pair_helper", &impl_type::template get_pos_sid_pair_pair_helper<typename impl_type::structure_type>)
-        .def("get_pos_sid_pair_helper_two_origins", &impl_type::template get_pos_sid_pair_helper_two_origins<typename impl_type::structure_type>)
-        .def("get_pos_sid_pair_helper1", &impl_type::template get_pos_sid_pair_helper1<typename impl_type::structure_type>)
-        .def("get_pos_sid_pair_helper2", &impl_type::template get_pos_sid_pair_helper2<typename impl_type::structure_type, typename impl_type::structure_type>)
+//         .def("get_pos_sid_pair_helper", &impl_type::template get_pos_sid_pair_helper<typename impl_type::structure_type>)
+//         .def("get_pos_sid_pair_pair_helper", &impl_type::template get_pos_sid_pair_pair_helper<typename impl_type::structure_type>)
+//         .def("get_pos_sid_pair_helper_two_origins", &impl_type::template get_pos_sid_pair_helper_two_origins<typename impl_type::structure_type>)
+//         .def("get_pos_sid_pair_helper1", &impl_type::template get_pos_sid_pair_helper1<typename impl_type::structure_type>)
+//         .def("get_pos_sid_pair_helper2", &impl_type::template get_pos_sid_pair_helper2<typename impl_type::structure_type, typename impl_type::structure_type>)
 
 //        .def("deflect_back", &impl_type::deflect_back)
         ;

From 3cb5cba1d7f39a7616520b683bd5ea24209d3a63 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Jul 2012 18:22:22 +0200
Subject: [PATCH 0994/1541] Minor cleanup in binding

---
 binding/Structure.hpp | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 658fa147..469b167c 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -48,12 +48,6 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("bd_displacement", &impl_type::bd_displacement)
         .def("project_point", &impl_type::project_point)
         .def("deflect", &impl_type::deflect)
-//         .def("get_pos_sid_pair_helper", &impl_type::template get_pos_sid_pair_helper<typename impl_type::structure_type>)
-//         .def("get_pos_sid_pair_pair_helper", &impl_type::template get_pos_sid_pair_pair_helper<typename impl_type::structure_type>)
-//         .def("get_pos_sid_pair_helper_two_origins", &impl_type::template get_pos_sid_pair_helper_two_origins<typename impl_type::structure_type>)
-//         .def("get_pos_sid_pair_helper1", &impl_type::template get_pos_sid_pair_helper1<typename impl_type::structure_type>)
-//         .def("get_pos_sid_pair_helper2", &impl_type::template get_pos_sid_pair_helper2<typename impl_type::structure_type, typename impl_type::structure_type>)
-
 //        .def("deflect_back", &impl_type::deflect_back)
         ;
 }

From 3af8abf8d03f9e65201882c0c50644625eab5c08 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 16 Jul 2012 12:20:19 +0200
Subject: [PATCH 0995/1541] Compactify second dispatch for the case with two
 origin structures

... and some more commenting.
---
 Structure.hpp | 340 +++++++++++++-------------------------------------
 1 file changed, 88 insertions(+), 252 deletions(-)

diff --git a/Structure.hpp b/Structure.hpp
index 6ee60eb9..f058172a 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -152,10 +152,18 @@ class Structure
                                                        structure_container_type const& structure_container) const = 0;
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
+                                                         
     // Structure functions dynamic dispatch
+    // 
+    // FIXME For now the second dispatch requires the helper functions to be defined here for each structure type separately.
+    // This is because C++ does not allow virtual templates. The current solution is functional, but ugly, and may be replaced
+    // by a more elegant solution in the future.
+    
     // 1 - Producing one new position
+    // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;                                                         
+                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    // Second dispatch
     position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
                                                         { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
@@ -170,12 +178,12 @@ class Structure
                                                         { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
     position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
-                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };
-    
+                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
     // 2 - Producing two new positions
+    // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
-        
+    // Second dispatch
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
                                                                   { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
@@ -190,265 +198,91 @@ class Structure
                                                                   { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
-                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
-        
+                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };        
     // 3 - Pair reactions => two origin structures
-    // Overloading method call structure.get_pos_sid_pair
+    // The following functions handle the case of two origin structures.
+    // First again the (C++) structure types have to be determined by a double dispatch.
+    // As a next step, the helper function has to determine which of the two structures
+    // is the target structure.
+    // For now, the target structure is either:
+    //   - the lower hierarchy level structure, i.e. one of the origin structures has
+    //     to be the daughter structure of the other and the particle will end up on
+    //     the daughter structure; or:
+    //   - in case of equal structure type id's it can end up on either origin structure
+    //     and apply_boundary will handle the right placement afterwards.
+       
+    // First dispatch, overloading method call structure.get_pos_sid_pair
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    
-    // TODO This is just so ugly, outsource this somehow!
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;    
+    // Second dispatch; FIXME Can this be beautified somehow?
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                     length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {          
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.          
-          
-          structure_id_type      os1_id( origin_structure1.id() );
-          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
-          structure_type_id_type os1_sid( origin_structure1.sid() );
-          
-          structure_id_type      this_id( this->id() );
-          structure_id_type      this_parent_id( this->structure_id() );
-          structure_type_id_type this_sid( this->sid() );
-          
-          if( this->sid() != os1_sid )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-    } 
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    {                          
+        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
+        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+    }
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                     length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {          
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.          
-          
-          structure_id_type      os1_id( origin_structure1.id() );
-          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
-          structure_type_id_type os1_sid( origin_structure1.sid() );
-          
-          structure_id_type      this_id( this->id() );
-          structure_id_type      this_parent_id( this->structure_id() );
-          structure_type_id_type this_sid( this->sid() );
-          
-          if( this->sid() != os1_sid )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-    } 
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    {                          
+        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
+        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+    }
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                     length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {          
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.          
-          
-          structure_id_type      os1_id( origin_structure1.id() );
-          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
-          structure_type_id_type os1_sid( origin_structure1.sid() );
-          
-          structure_id_type      this_id( this->id() );
-          structure_id_type      this_parent_id( this->structure_id() );
-          structure_type_id_type this_sid( this->sid() );
-          
-          if( this->sid() != os1_sid )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-    } 
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    {                          
+        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
+        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+    }
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                     length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {          
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.          
-          
-          structure_id_type      os1_id( origin_structure1.id() );
-          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
-          structure_type_id_type os1_sid( origin_structure1.sid() );
-          
-          structure_id_type      this_id( this->id() );
-          structure_id_type      this_parent_id( this->structure_id() );
-          structure_type_id_type this_sid( this->sid() );
-          
-          if( this->sid() != os1_sid )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-    } 
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    {                          
+        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
+        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+    }
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                     length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {          
-          // The types of both origin structures now are determined.
-          // As a next step, determine which one is the target structure and call the right
-          // structure function with the other one as origin structure.          
-          
-          structure_id_type      os1_id( origin_structure1.id() );
-          structure_id_type      os1_parent_id( origin_structure1.structure_id() );
-          structure_type_id_type os1_sid( origin_structure1.sid() );
+    {                          
+        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
+        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+    }
+    
+    // Some further helper functions used by get_pos_sid_pair_helper_two_origins
+    bool is_parent_of_or_has_same_sid_as(structure_type const& s) const
+    {    
+          structure_id_type       s_parent_id( s.structure_id() );
+          structure_type_id_type  s_sid( s.sid() );
+          structure_id_type       this_id( this->id() );
+          structure_type_id_type  this_sid( this->sid() );
           
-          structure_id_type      this_id( this->id() );
-          structure_id_type      this_parent_id( this->structure_id() );
+          return ( s_parent_id == this_id || s_sid == this_sid );          
+    }
+    
+    bool has_valid_target_sid(structure_type_id_type const& target_sid) const
+    {
           structure_type_id_type this_sid( this->sid() );
           
-          if( this->sid() != os1_sid )
-          // if the two pair reactants come from different types of structure
-          {
-
-              if ( (os1_parent_id == this_id) && (os1_sid == target_sid) )
-              // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-              {
-                  // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-                  return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-              }
-              else if ( (this_parent_id == os1_id) && (this_sid == target_sid) )
-              // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-              {
-                  // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-                  return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-              }
-              else
-              {
-                  throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-                  // TODO In principle this constraint could be dropped; the target structure should be determined
-                  // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-              }  
-        }
-        else
-        // the reactants live on the same structure type, i.e. the product will also end up on 
-        {
-            // Call transition function with origin_structure = target_structure = *this
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            // Note that apply_boundary should place the product particle on the right one of the two structures
-            // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-            // structure_type_id's are the same!).
-        }
-    } 
-    
-    
-    // TODO Outsource the ugly stuff above at least partly into this!
-    bool is_parent_of_or_same_as(structure_type s)
-    {    
-        return true;
+          return ( this_sid == target_sid );
     }
-                                                                    
-    // 4 - Generalized functions for pair reactions => two origin structures and one target_structure
-    // This introduces a triple dynamic dispatch, overloading method call structure.get_pos_sid_pair once more.
-    // NOTE: As yet these methods are unused but might prove useful in the future.
+
+//     // TODO
+//     // 4 - Generalized functions for pair reactions => two origin structures and one target_structure
+//     // This introduces a triple dynamic dispatch, overloading method call structure.get_pos_sid_pair once more.
+//     // NOTE: As yet these methods are unused but might prove useful in the future.
 //     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
 //                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
 //     template <typename Tstruct1_>
@@ -457,6 +291,8 @@ class Structure
 //     template <typename Tstruct1_, typename Tstruct2_>
 //     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
 //                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+//     
+//     NOTE: The template based variant will not work! The helper methods have to be defined for each structure type separately
 
 
 

From 19bcf0172b66dcf79bbc3180d413a8a362795e3d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 16 Jul 2012 12:36:23 +0200
Subject: [PATCH 0996/1541] Cleanup in derived structure classes

---
 CuboidalRegion.hpp     |  95 ++------------------------------------
 CylindricalSurface.hpp | 101 ++++-------------------------------------
 DiskSurface.hpp        |  93 ++-----------------------------------
 PlanarSurface.hpp      |  93 ++-----------------------------------
 SphericalSurface.hpp   |  93 ++-----------------------------------
 Structure.hpp          |  27 +++++++++--
 6 files changed, 47 insertions(+), 455 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 02e0bc21..f1fe7fc5 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -161,83 +161,20 @@ class CuboidalRegion
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-//     }
-    
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-//     }
-    
-    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
-    // introducing another double dynamic dispatch.
+    }    
+    // *** 3 *** - Pair reactions => two origin structures
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }
-//     // two associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//           // The types of both origin structures now are determined.
-//           // As a next step, determine which one is the target structure and call the right
-//           // structure function with the other one as origin structure.
-//           
-//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
-//           // if the two pair reactants come from different types of structure
-//           {
-// 
-//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-//               {
-//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-//               }
-//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-//               {
-//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//               }
-//               else
-//               {
-//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-//                   // TODO In principle this constraint could be dropped; the target structure should be determined
-//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-//               }  
-//         }
-//         else
-//         // the reactants live on the same structure type, i.e. the product will also end up on 
-//         {
-//             // Call transition function with origin_structure = target_structure = *this
-//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//             // Note that apply_boundary should place the product particle on the right one of the two structures
-//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-//             // structure_type_id's are the same!).
-//         }
-//         
-//     }
-    
+    }    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
@@ -247,29 +184,7 @@ class CuboidalRegion
 //     {
 //         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
 //     }
-//     // two associated helper functions this time
-//     template <typename Tstruct1_>
-//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-//     }
-//     template <typename Tstruct1_, typename Tstruct2_>
-//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         if(origin_structure1.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-//         
-//         else if(origin_structure2.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-//         
-//         else
-//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
-//     }
-    
+
     
     /*** Formerly used functions of the Morelli scheme ***/
     // DEPRECATED
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index fb5f8c44..d9127192 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -236,113 +236,28 @@ class CylindricalSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-//     }
-    
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-//     }
-    
-    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
-    // introducing another double dynamic dispatch.
+    }    
+    // *** 3 *** - Pair reactions => two origin structures
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }
-//     // two associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//           // The types of both origin structures now are determined.
-//           // As a next step, determine which one is the target structure and call the right
-//           // structure function with the other one as origin structure.
-//           
-//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
-//           // if the two pair reactants come from different types of structure
-//           {
-// 
-//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-//               {
-//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-//               }
-//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-//               {
-//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//               }
-//               else
-//               {
-//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-//                   // TODO In principle this constraint could be dropped; the target structure should be determined
-//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-//               }  
-//         }
-//         else
-//         // the reactants live on the same structure type, i.e. the product will also end up on 
-//         {
-//             // Call transition function with origin_structure = target_structure = *this
-//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//             // Note that apply_boundary should place the product particle on the right one of the two structures
-//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-//             // structure_type_id's are the same!).
-//         }
-//         
-//     }
-    
-    // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
-    // NOTE: This is yet unused, but possibly useful in the future.
-    // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
-    // a triple dynamic dispatch.
+    }    
+//     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
+//     // NOTE: This is yet unused, but possibly useful in the future.
+//     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
+//     // a triple dynamic dispatch.
 //     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
 //                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
 //     {
 //         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-//     }
-//     // two associated helper functions this time
-//     template <typename Tstruct1_>
-//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-//     }
-//     template <typename Tstruct1_, typename Tstruct2_>
-//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         if(origin_structure1.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-//         
-//         else if(origin_structure2.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-//         
-//         else
-//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
 //     }
 
     
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 3d094381..45272dd3 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -234,83 +234,20 @@ class DiskSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-//     }
-    
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-//     }
-    
-    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
-    // introducing another double dynamic dispatch.
+    }    
+    // *** 3 *** - Pair reactions => two origin structures
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }
-//     // two associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//           // The types of both origin structures now are determined.
-//           // As a next step, determine which one is the target structure and call the right
-//           // structure function with the other one as origin structure.
-//           
-//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
-//           // if the two pair reactants come from different types of structure
-//           {
-// 
-//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-//               {
-//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-//               }
-//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-//               {
-//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//               }
-//               else
-//               {
-//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-//                   // TODO In principle this constraint could be dropped; the target structure should be determined
-//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-//               }  
-//         }
-//         else
-//         // the reactants live on the same structure type, i.e. the product will also end up on 
-//         {
-//             // Call transition function with origin_structure = target_structure = *this
-//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//             // Note that apply_boundary should place the product particle on the right one of the two structures
-//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-//             // structure_type_id's are the same!).
-//         }
-//         
-//     }
-    
+    }    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
@@ -319,28 +256,6 @@ class DiskSurface
 //                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
 //     {
 //         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-//     }
-//     // two associated helper functions this time
-//     template <typename Tstruct1_>
-//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-//     }
-//     template <typename Tstruct1_, typename Tstruct2_>
-//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         if(origin_structure1.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-//         
-//         else if(origin_structure2.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-//         
-//         else
-//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
 //     }
 
     
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 4fc5d3cd..8ab70b9c 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -227,83 +227,20 @@ class PlanarSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-//     }
-    
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-//     }
-    
-    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
-    // introducing another double dynamic dispatch.
+    }    
+    // *** 3 *** - Pair reactions => two origin structures
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }
-//     // two associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//           // The types of both origin structures now are determined.
-//           // As a next step, determine which one is the target structure and call the right
-//           // structure function with the other one as origin structure.
-//           
-//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
-//           // if the two pair reactants come from different types of structure
-//           {
-// 
-//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-//               {
-//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-//               }
-//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-//               {
-//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//               }
-//               else
-//               {
-//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-//                   // TODO In principle this constraint could be dropped; the target structure should be determined
-//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-//               }  
-//         }
-//         else
-//         // the reactants live on the same structure type, i.e. the product will also end up on 
-//         {
-//             // Call transition function with origin_structure = target_structure = *this
-//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//             // Note that apply_boundary should place the product particle on the right one of the two structures
-//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-//             // structure_type_id's are the same!).
-//         }
-//         
-//     }
-    
+    }    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
@@ -312,28 +249,6 @@ class PlanarSurface
 //                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
 //     {
 //         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-//     }
-//     // two associated helper functions this time
-//     template <typename Tstruct1_>
-//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-//     }
-//     template <typename Tstruct1_, typename Tstruct2_>
-//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         if(origin_structure1.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-//         
-//         else if(origin_structure2.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-//         
-//         else
-//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
 //     }
     
 
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 4947da2e..1eebe1ff 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -125,83 +125,20 @@ class SphericalSurface
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair(origin_structure, *this, position, offset, reaction_length, rng);
-//     }
-    
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }
-//     // the associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-//                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         // Dispatch to function with well-defined typing
-//         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s1, s2, reaction_length, rng);
-//     }
-    
-    // *** 3 *** - Pair reactions => two origin structures => triple switchbox
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...) and
-    // introducing another double dynamic dispatch.
+    }    
+    // *** 3 *** - Pair reactions => two origin structures
+    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }
-//     // two associated helper function
-//     template <typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper_two_origins(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid,
-//                                                                     position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//           // The types of both origin structures now are determined.
-//           // As a next step, determine which one is the target structure and call the right
-//           // structure function with the other one as origin structure.
-//           
-//           if( this->structure_type_id() != origin_structure1->structure_type_id() )
-//           // if the two pair reactants come from different types of structure
-//           {
-// 
-//               if ( (origin_structure1->structure_id() == this->id) && (origin_structure1->structure_type_id() == target_sid) )
-//               // *this is the parent of origin_structure1, i.e. target_structure is origin_structure1
-//               {
-//                   // Call transition function with *this as origin_structure and origin_structure1 as target_structure
-//                   return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-//               }
-//               else if ( (this->structure_id() == origin_structure1->id) && (this->structure_type_id() == target_sid) )
-//               // origin_structure1 is the parent of *this, i.e. target_structure is *this (= origin_structure2)
-//               {
-//                   // Call transition function with origin_structure1 as origin_structure and *this as target_structure
-//                   return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//               }
-//               else
-//               {
-//                   throw propagation_error("Particles can be at most one hierarchical level apart for a pair reaction.");
-//                   // TODO In principle this constraint could be dropped; the target structure should be determined
-//                   // already by comparing structure_type_id's with target_sid (which is fed in from the reaction rules).
-//               }  
-//         }
-//         else
-//         // the reactants live on the same structure type, i.e. the product will also end up on 
-//         {
-//             // Call transition function with origin_structure = target_structure = *this
-//             return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-//             // Note that apply_boundary should place the product particle on the right one of the two structures
-//             // afterwards in case that *this->id != origin_structure1->id (right now we postulate only that the
-//             // structure_type_id's are the same!).
-//         }
-//         
-//     }
-    
+    }    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
@@ -210,28 +147,6 @@ class SphericalSurface
 //                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
 //     {
 //         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
-//     }
-//     // two associated helper functions this time
-//     template <typename Tstruct1_>
-//     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
-//     }
-//     template <typename Tstruct1_, typename Tstruct2_>
-//     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-//     {
-//         if(origin_structure1.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
-//         
-//         else if(origin_structure2.id == *this->id)
-//             // Dispatch to function with well-defined typing
-//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
-//         
-//         else
-//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
 //     }
     
     
diff --git a/Structure.hpp b/Structure.hpp
index f058172a..405a3296 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -287,14 +287,31 @@ class Structure
 //                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
 //     template <typename Tstruct1_>
 //     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
+//     }
 //     template <typename Tstruct1_, typename Tstruct2_>
 //     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//     {
+//         structure_id_type    this_id( this->id );
+//         structure_id_type    os1_id( origin_structure1.id );
+//         structure_id_type    os2_id( origin_structure2.id );
+//
+//         if(os1_id == this_id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure2, *this, position, offset, reaction_length, rng);
+//         
+//         else if(os2_id == this_id)
+//             // Dispatch to function with well-defined typing
+//             return ::get_pos_sid_pair(origin_structure1, *this, position, offset, reaction_length, rng);
+//         
+//         else
+//             throw propagation_error("Target structure must be one of the origin structures for pair reaction.");
+//     }
 //     
-//     NOTE: The template based variant will not work! The helper methods have to be defined for each structure type separately
-
-
+//     NOTE: The template based variant will not work! The helper methods have to be defined for each structure type separately or in a smarter way!
 
 
     virtual std::size_t hash() const

From d79119fdb40efee3691804128931041e9aa36556 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 16 Jul 2012 12:44:05 +0200
Subject: [PATCH 0997/1541] Make some helper functions inline

---
 Structure.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Structure.hpp b/Structure.hpp
index 405a3296..14835391 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -262,7 +262,7 @@ class Structure
     }
     
     // Some further helper functions used by get_pos_sid_pair_helper_two_origins
-    bool is_parent_of_or_has_same_sid_as(structure_type const& s) const
+    inline bool is_parent_of_or_has_same_sid_as(structure_type const& s) const
     {    
           structure_id_type       s_parent_id( s.structure_id() );
           structure_type_id_type  s_sid( s.sid() );
@@ -272,7 +272,7 @@ class Structure
           return ( s_parent_id == this_id || s_sid == this_sid );          
     }
     
-    bool has_valid_target_sid(structure_type_id_type const& target_sid) const
+    inline bool has_valid_target_sid(structure_type_id_type const& target_sid) const
     {
           structure_type_id_type this_sid( this->sid() );
           

From 243149e997247e666fd650c7d029c32df5fb1ee8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 16 Jul 2012 12:46:52 +0200
Subject: [PATCH 0998/1541] Comments

---
 Structure.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Structure.hpp b/Structure.hpp
index 14835391..04b74847 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -157,7 +157,7 @@ class Structure
     // 
     // FIXME For now the second dispatch requires the helper functions to be defined here for each structure type separately.
     // This is because C++ does not allow virtual templates. The current solution is functional, but ugly, and may be replaced
-    // by a more elegant solution in the future.
+    // by a more elegant solution in the future, by defining a template here and correctly performing instantiation elsewhere.
     
     // 1 - Producing one new position
     // First dispatch

From f884203c698fb0019195beb22390ef8134404c8d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Jul 2012 18:22:02 +0200
Subject: [PATCH 0999/1541] Introduce a flag and ifs to force the scheme into
 BD

---
 egfrd.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4cae3cce..f2b4fb05 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -225,7 +225,10 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         
         self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # The maximum step size in the newBD algorithm is determined as DSSF * sigma_min.
                                                 # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
-                                                # reaction volume sticks out of the multi.
+                                                # reaction volume sticks out of the multi. 
+
+        self.BD_ONLY_FLAG = True                # Will force the algorithm into Multi-creation, i.e. always to use BD
+                                                # This is for testing only! Keep this 'False' for normal sims!
 
         # used datastructrures
         self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
@@ -1574,9 +1577,10 @@ def make_new_domain(self, single):
         domain = None
         for obj, hor_overlap in pair_interaction_partners:
 
-            if hor_overlap > 0.0 or domain:
+            if hor_overlap > 0.0 or domain or self.BD_ONLY_FLAG :
                 # there are no more potential partners (everything is out of range)
                 # or a domain was formed successfully previously
+                # or the user wants to force the system into BD mode = Multi creation
                 break
 
             if isinstance(obj, NonInteractionSingle):
@@ -1636,7 +1640,7 @@ def make_new_domain(self, single):
                 log.debug('Single or Multi: closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
 
             # If the closest partner is within the multi horizon we do Multi, otherwise Single
-            if closest_overlap > 0.0: 
+            if closest_overlap > 0.0 and not self.BD_ONLY_FLAG : 
                 # just make a normal NonInteractionSingle
                 self.update_single(single)
             else:

From fdd8e0f9744b29f8ced471137a4e981d2afd9f12 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Jul 2012 19:14:49 +0200
Subject: [PATCH 1000/1541] Set default for BD_ONLY_FLAG to False

... cause we want to do eGFRD in the end!
---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index f2b4fb05..1e0c0b35 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -227,7 +227,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
                                                 # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
                                                 # reaction volume sticks out of the multi. 
 
-        self.BD_ONLY_FLAG = True                # Will force the algorithm into Multi-creation, i.e. always to use BD
+        self.BD_ONLY_FLAG = False               # Will force the algorithm into Multi-creation, i.e. always to use BD
                                                 # This is for testing only! Keep this 'False' for normal sims!
 
         # used datastructrures

From 944aed2629de1eb7a0987674337dfb5efc794634 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Jul 2012 17:06:33 +0200
Subject: [PATCH 1001/1541] Slightly beautify second dispatch for pair
 reactions

... by re-outsourcing redundant code from helper functions into a
template within the base class and calling it from intermediate
helper functions defined for each structure type within each derived
class.
---
 CuboidalRegion.hpp     | 29 +++++++++++++++++-
 CylindricalSurface.hpp | 29 +++++++++++++++++-
 DiskSurface.hpp        | 29 +++++++++++++++++-
 PlanarSurface.hpp      | 29 +++++++++++++++++-
 SphericalSurface.hpp   | 29 +++++++++++++++++-
 Structure.hpp          | 68 +++++++++++++++---------------------------
 6 files changed, 164 insertions(+), 49 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index f1fe7fc5..cb113476 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -174,7 +174,34 @@ class CuboidalRegion
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index d9127192..7647d2db 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -249,7 +249,34 @@ class CylindricalSurface
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 45272dd3..a555ee28 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -247,7 +247,34 @@ class DiskSurface
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 8ab70b9c..7cc7a4b1 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -240,7 +240,34 @@ class PlanarSurface
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 1eebe1ff..9ee03afe 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -138,7 +138,34 @@ class SphericalSurface
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {                          
+        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+    }
+    
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
 //     // NOTE: This is yet unused, but possibly useful in the future.
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
diff --git a/Structure.hpp b/Structure.hpp
index 04b74847..dc7fe5d0 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -214,53 +214,33 @@ class Structure
     // First dispatch, overloading method call structure.get_pos_sid_pair
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;    
-    // Second dispatch; FIXME Can this be beautified somehow?
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {                          
-        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
-        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
-    }
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {                          
-        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
-        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
-    }
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {                          
-        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
-        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
-    }
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {                          
-        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
-        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
-    }
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                    length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {                          
+    // Second dispatch; the helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+    // The template function that defines the actual final dispatch procedure.
+    // Note that this is not virtual + overriden, but inherited by each derived structure class.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
         if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng); // other_origin_structure is target        
+            // other_origin_structure is target
+            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng);
+            
         else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
-            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng); // this (other_origin_structure) is target
+            // this structure is target
+            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng);
+            
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
-    }
-    
+    }    
     // Some further helper functions used by get_pos_sid_pair_helper_two_origins
     inline bool is_parent_of_or_has_same_sid_as(structure_type const& s) const
     {    

From 84e70f75b2fe5302f9cef81d130c9e15240d38b1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Jul 2012 17:15:20 +0200
Subject: [PATCH 1002/1541] Same changes to structure.hpp for the two other
 dispatches

---
 Structure.hpp | 75 +++++++++++++++++++++++++++++----------------------
 1 file changed, 43 insertions(+), 32 deletions(-)

diff --git a/Structure.hpp b/Structure.hpp
index dc7fe5d0..9c376d2d 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -157,48 +157,59 @@ class Structure
     // 
     // FIXME For now the second dispatch requires the helper functions to be defined here for each structure type separately.
     // This is because C++ does not allow virtual templates. The current solution is functional, but ugly, and may be replaced
-    // by a more elegant solution in the future, by defining a template here and correctly performing instantiation elsewhere.
+    // by a more elegant solution in the future.
     
     // 1 - Producing one new position
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     // Second dispatch
-    position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
-                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
-    position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
-                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
-    position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
-                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
-    position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
-                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
-    position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+    // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;                                                  
+    // The template function that defines the actual final dispatch procedure.
+    // Note that this is not virtual + overriden, but inherited by each derived structure class.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
-                                                        { return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); };    
+    {
+        // Redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+    };
     // 2 - Producing two new positions
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
     // Second dispatch
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
-                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
-                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
-                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
-                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+    // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+    // The template function that defines the actual final dispatch procedure.
+    // Note that this is not virtual + overriden, but inherited by each derived structure class.
+    template<typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
-                                                                  { return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); };        
+    {
+        // Redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+    };
+    
     // 3 - Pair reactions => two origin structures
     // The following functions handle the case of two origin structures.
     // First again the (C++) structure types have to be determined by a double dispatch.
@@ -214,7 +225,8 @@ class Structure
     // First dispatch, overloading method call structure.get_pos_sid_pair
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;    
-    // Second dispatch; the helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
+    // Second dispatch
+    // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
@@ -250,8 +262,7 @@ class Structure
           structure_type_id_type  this_sid( this->sid() );
           
           return ( s_parent_id == this_id || s_sid == this_sid );          
-    }
-    
+    }    
     inline bool has_valid_target_sid(structure_type_id_type const& target_sid) const
     {
           structure_type_id_type this_sid( this->sid() );

From bceb0e0625f8b54d2c39b6bf804a9a6ec74a114b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Jul 2012 17:23:11 +0200
Subject: [PATCH 1003/1541] Namefixes

---
 Structure.hpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/Structure.hpp b/Structure.hpp
index 9c376d2d..e44affe0 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -153,13 +153,13 @@ class Structure
     virtual position_structid_pair_type cyclic_transpose(position_structid_pair_type const& pos_struct_id,
                                                          structure_container_type const& structure_container) const = 0;
                                                          
-    // Structure functions dynamic dispatch
+    // *** Structure functions dynamic dispatch ***
     // 
     // FIXME For now the second dispatch requires the helper functions to be defined here for each structure type separately.
     // This is because C++ does not allow virtual templates. The current solution is functional, but ugly, and may be replaced
     // by a more elegant solution in the future.
     
-    // 1 - Producing one new position
+    // *** 1 *** - Producing one new position
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
@@ -178,13 +178,13 @@ class Structure
     // The template function that defines the actual final dispatch procedure.
     // Note that this is not virtual + overriden, but inherited by each derived structure class.
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        // Redirect to structure function with well-defined typing
+        // redirect to structure function with well-defined typing
         return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
     };
-    // 2 - Producing two new positions
+    // *** 2 *** - Producing two new positions
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
@@ -203,14 +203,14 @@ class Structure
     // The template function that defines the actual final dispatch procedure.
     // Note that this is not virtual + overriden, but inherited by each derived structure class.
     template<typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper(Tstruct_ const& origin_structure, position_type const& position,
-                                                                  species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        // Redirect to structure function with well-defined typing
+        // redirect to structure function with well-defined typing
         return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
-    // 3 - Pair reactions => two origin structures
+    // *** 3 *** - Pair reactions => two origin structures
     // The following functions handle the case of two origin structures.
     // First again the (C++) structure types have to be determined by a double dispatch.
     // As a next step, the helper function has to determine which of the two structures
@@ -271,7 +271,7 @@ class Structure
     }
 
 //     // TODO
-//     // 4 - Generalized functions for pair reactions => two origin structures and one target_structure
+//     // *** 4 *** - Generalized functions for pair reactions => two origin structures and one target_structure
 //     // This introduces a triple dynamic dispatch, overloading method call structure.get_pos_sid_pair once more.
 //     // NOTE: As yet these methods are unused but might prove useful in the future.
 //     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,

From 2852b53411d0f1a3da7500675becdc9112fe0ee8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Jul 2012 17:25:46 +0200
Subject: [PATCH 1004/1541] The necessary changes to the derived structure
 classes

---
 CuboidalRegion.hpp     | 58 +++++++++++++++++++++++++++++++++++++++++-
 CylindricalSurface.hpp | 58 +++++++++++++++++++++++++++++++++++++++++-
 DiskSurface.hpp        | 58 +++++++++++++++++++++++++++++++++++++++++-
 PlanarSurface.hpp      | 58 +++++++++++++++++++++++++++++++++++++++++-
 SphericalSurface.hpp   | 58 +++++++++++++++++++++++++++++++++++++++++-
 5 files changed, 285 insertions(+), 5 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index cb113476..76919143 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -156,18 +156,74 @@ class CuboidalRegion
     // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
     // This requires a double dynamic dispatch.
+    // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }                                                                                                               
+                                                        
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
+    // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 7647d2db..af2cfcf5 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -231,18 +231,74 @@ class CylindricalSurface
     // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
     // This requires a double dynamic dispatch.
+    // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }                                                                                                               
+                                                        
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
+    // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index a555ee28..1e72f9cf 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -229,18 +229,74 @@ class DiskSurface
     // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
     // This requires a double dynamic dispatch.
+    // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }                                                                                                               
+                                                        
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
+    // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 7cc7a4b1..ee60762a 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -222,18 +222,74 @@ class PlanarSurface
     // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
     // This requires a double dynamic dispatch.
+    // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }                                                                                                               
+                                                        
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
+    // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 9ee03afe..7c0a8d2e 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -120,18 +120,74 @@ class SphericalSurface
     // *** Dynamic dispatch for the structure functions *** //
     // *** 1 *** - One new position
     // This requires a double dynamic dispatch.
+    // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
+    // Second dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }
+    virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+    }                                                                                                               
+                                                        
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
+    // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
-    }    
+    }
+    // Second dispatch
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+    {
+        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+    }
+    
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,

From fbad0ebd3bc13d85c46757e78d1ddce9c7c93c9f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Jul 2012 17:43:25 +0200
Subject: [PATCH 1005/1541] Forgot a 'const' ...

---
 CuboidalRegion.hpp     | 10 +++++-----
 CylindricalSurface.hpp | 10 +++++-----
 DiskSurface.hpp        | 10 +++++-----
 PlanarSurface.hpp      | 10 +++++-----
 SphericalSurface.hpp   | 10 +++++-----
 5 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 76919143..de2345d6 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -199,27 +199,27 @@ class CuboidalRegion
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index af2cfcf5..54e55eff 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -274,27 +274,27 @@ class CylindricalSurface
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 1e72f9cf..f3dae84c 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -272,27 +272,27 @@ class DiskSurface
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index ee60762a..0e1aff7d 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -265,27 +265,27 @@ class PlanarSurface
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 7c0a8d2e..7c52d6be 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -163,27 +163,27 @@ class SphericalSurface
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng)
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }

From 90f03bb40b25f4c1734fc64960436ff32fb342ab Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Jul 2012 18:02:29 +0200
Subject: [PATCH 1006/1541] Some useful naming cleanup

---
 CuboidalRegion.hpp     | 20 ++++++++++----------
 CylindricalSurface.hpp | 20 ++++++++++----------
 DiskSurface.hpp        | 20 ++++++++++----------
 PlanarSurface.hpp      | 20 ++++++++++----------
 SphericalSurface.hpp   | 20 ++++++++++----------
 Structure.hpp          | 28 +++++++++++++++-------------
 egfrd.py               |  2 +-
 7 files changed, 66 insertions(+), 64 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index de2345d6..ff75c5ff 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -232,30 +232,30 @@ class CuboidalRegion
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 54e55eff..94c76f33 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -307,30 +307,30 @@ class CylindricalSurface
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index f3dae84c..9eed9dbe 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -305,30 +305,30 @@ class DiskSurface
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 0e1aff7d..956d68d6 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -298,30 +298,30 @@ class PlanarSurface
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 7c52d6be..3889b045 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -196,30 +196,30 @@ class SphericalSurface
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(other_origin_structure, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/Structure.hpp b/Structure.hpp
index e44affe0..3800ee72 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -158,7 +158,7 @@ class Structure
     // FIXME For now the second dispatch requires the helper functions to be defined here for each structure type separately.
     // This is because C++ does not allow virtual templates. The current solution is functional, but ugly, and may be replaced
     // by a more elegant solution in the future.
-    
+    // 
     // *** 1 *** - Producing one new position
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
@@ -174,7 +174,7 @@ class Structure
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;                                                  
+                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     // The template function that defines the actual final dispatch procedure.
     // Note that this is not virtual + overriden, but inherited by each derived structure class.
     template<typename Tstruct_>
@@ -223,33 +223,35 @@ class Structure
     //     and apply_boundary will handle the right placement afterwards.
        
     // First dispatch, overloading method call structure.get_pos_sid_pair
+    // This is called as a method of origin_structure1 with origin_structure2 as an argument.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;    
     // Second dispatch
     // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+    // It is called as a method of origin_structure2 by origin_structure1 with origin_structure1 as an argument
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
     // The template function that defines the actual final dispatch procedure.
     // Note that this is not virtual + overriden, but inherited by each derived structure class.
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& other_origin_structure, structure_type_id_type const& target_sid, position_type const& CoM,
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
     {
-        if( this->is_parent_of_or_has_same_sid_as(other_origin_structure) && other_origin_structure.has_valid_target_sid(target_sid) )
-            // other_origin_structure is target
-            return ::get_pos_sid_pair(*this, other_origin_structure, CoM, offset, reaction_length, rng);
+        if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
-        else if( other_origin_structure.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+        else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return ::get_pos_sid_pair(other_origin_structure, *this, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }    
diff --git a/egfrd.py b/egfrd.py
index 1e0c0b35..0cc563f0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -227,7 +227,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
                                                 # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
                                                 # reaction volume sticks out of the multi. 
 
-        self.BD_ONLY_FLAG = False               # Will force the algorithm into Multi-creation, i.e. always to use BD
+        self.BD_ONLY_FLAG = True               # Will force the algorithm into Multi-creation, i.e. always to use BD # TESTING
                                                 # This is for testing only! Keep this 'False' for normal sims!
 
         # used datastructrures

From 8f6a7b089c7becfc9fd2ce7614c41861d72fe65a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Jul 2012 18:05:29 +0200
Subject: [PATCH 1007/1541] Erroneously changed BDFlag in egfrd.py => revert

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 0cc563f0..1e0c0b35 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -227,7 +227,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
                                                 # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
                                                 # reaction volume sticks out of the multi. 
 
-        self.BD_ONLY_FLAG = True               # Will force the algorithm into Multi-creation, i.e. always to use BD # TESTING
+        self.BD_ONLY_FLAG = False               # Will force the algorithm into Multi-creation, i.e. always to use BD
                                                 # This is for testing only! Keep this 'False' for normal sims!
 
         # used datastructrures

From 91862601766c7a70d28f588b3fb037ededf1fa9e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Jul 2012 14:48:01 +0200
Subject: [PATCH 1008/1541] An assert statement in projection function of Disk

---
 Disk.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/Disk.hpp b/Disk.hpp
index dddd2bda..2fee12fb 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -127,7 +127,8 @@ project_point(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
     const length_type   z ( dot_product(pos_vector, obj.unit_z()) );
     const position_type r_vector (subtract(pos_vector, multiply(obj.unit_z(), z)));
     const length_type   r (length(r_vector));
-
+    assert(r >= 0.0 );
+    
     return std::make_pair( add(obj.position(), r_vector),
                            std::make_pair(z, r - obj.radius()) );
 }

From 0936acf87688ea353c98ac0e01adc233de362f86 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Jul 2012 14:48:52 +0200
Subject: [PATCH 1009/1541] Small cleanup in structure functions

---
 StructureFunctions.cpp | 1 -
 StructureFunctions.hpp | 6 +++---
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 767d9340..943b00c7 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -347,7 +347,6 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
         // the distance of the projection of old_pos on target_structure to target_structure
     
     if(proj_dist < 0){ // if projection of old_pos is in structure
-    // TODO: Assert that DiskSurface is a substructure of CylindricalSurface ?
      
           return std::make_pair( new_pos, new_id );
     }
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 97d73259..ca59baba 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -35,9 +35,9 @@ class PlanarSurface;
 /*** ONE NEW POSITION ***/
 /************************/
 
-/******************************/
-/* Some Defaults declarations */
-/******************************/
+/*****************************/
+/* Some default declarations */
+/*****************************/
 // These are actually never called but have to be there for type consistency reasons
 template <typename Ttraits_>
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>

From bd434d8b95d783904f7a90b619f5fb1bc4b9f79a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Jul 2012 14:49:13 +0200
Subject: [PATCH 1010/1541] Some more informative log output in a part of
 newBDpropagator

---
 newBDPropagator.hpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 2ee3452a..497182a3 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -253,26 +253,27 @@ class newBDPropagator
                 {
                     LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one; %f.",
                                  accumulated_prob));
-                } 
+                }
                 
                 if( accumulated_prob > rnd ) // OK, try to fire the interaction
                 {            
                     try
                     {
-                        LOG_DEBUG(("fire surface interaction"));
+                        LOG_DEBUG( ("fire surface interaction with surface %s.",
+                                    boost::lexical_cast<std::string>(overlap_struct.first.first).c_str()) );
                         if(attempt_interaction(pp, new_pos_projected.first, overlap_struct.first.second ))
                             return true;
                     }   
                     catch (propagation_error const& reason)
                     {
-                        log_.info("surface interaction rejected (reason: %s)", reason.what());
+                        log_.info("surface interaction rejected (reason: %s).", reason.what());
                         ++rejected_move_count_;
                     }
                 }
-                else                
+                else
                 {
-                    LOG_DEBUG(("Particle attempted an interaction with the non-interactive surface %s.", 
-                               boost::lexical_cast<std::string>(overlap_struct.first.first).c_str()));
+                    LOG_DEBUG( ("Particle attempted an interaction with the non-interactive surface %s.", 
+                                boost::lexical_cast<std::string>(overlap_struct.first.first).c_str()) );
                 }
             }
 

From 8fda02eb16303f352b4966851b310b5459f76c2c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Jul 2012 15:26:45 +0200
Subject: [PATCH 1011/1541] Ignore origin structure for BD structure binding

---
 newBDPropagator.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 497182a3..6a848751 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -836,7 +836,7 @@ class newBDPropagator
                         const species_type product_species(tx_.get_species(products[0]));
 
                         //// 1 - GET NEW POSITION ON THE TARGET STRUCTURE
-                        // TODO TODO TODO Rework this using structure functions! TODO TODO TODO
+                        // TODO Rework this using structure functions?
                         const position_type product_pos( tx_.apply_boundary(pos_in_struct) );
 
 
@@ -850,9 +850,11 @@ class newBDPropagator
                             throw propagation_error("no space");
                         }
                         // check overlap with structures.
-                        // No need to include old structure as ignore because going down the structure hierarchy anyway.
+                        // first get the structure_id of the old structure...
+                        const structure_id_type old_struct_id(pp.second.structure_id());
+                        // ...and ignore the latter when checking for overlaps
                         const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
-                                tx_.check_surface_overlap(new_shape, product_pos, structure->id(), product_species.radius()));
+                                tx_.check_surface_overlap(new_shape, product_pos, structure->id(), product_species.radius(), old_struct_id));
                         if (overlap_structures && overlap_structures->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");

From fee92edcc1ba6c15927dd6a79dfc5c6180fe6c5d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Jul 2012 17:26:50 +0200
Subject: [PATCH 1012/1541] Templates have to be in derived classes,
 unfortunately...

... because otherwise the type of *this is not determined correctly!

This makes it more ugly again but at least outsources the definition
of the dispatch handling into one unique function for each derived
class.
---
 CuboidalRegion.hpp     |  33 +++++-
 CylindricalSurface.hpp |  33 +++++-
 DiskSurface.hpp        |  48 ++++++++-
 PlanarSurface.hpp      |  33 +++++-
 SphericalSurface.hpp   |  33 +++++-
 Structure.hpp          |  41 +------
 StructureFunctions.hpp | 240 ++++++++++++++++++++---------------------
 7 files changed, 300 insertions(+), 161 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index ff75c5ff..40db98fb 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -187,7 +187,15 @@ class CuboidalRegion
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
-    }                                                                                                               
+    }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+    };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -223,6 +231,14 @@ class CuboidalRegion
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+    };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
@@ -256,6 +272,21 @@ class CuboidalRegion
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+    }    
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            
+        else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 94c76f33..bd8f8279 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -262,7 +262,15 @@ class CylindricalSurface
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
-    }                                                                                                               
+    }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+    };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -298,6 +306,14 @@ class CylindricalSurface
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+    };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
@@ -331,6 +347,21 @@ class CylindricalSurface
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+    }    
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            
+        else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 9eed9dbe..b15be4b4 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -11,6 +11,21 @@
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer;
 
+template<typename T_>
+class CuboidalRegion;
+
+template<typename T_>
+class CylindricalSurface;
+
+template<typename T_>
+class SphericalSurface;
+
+template<typename T_>
+class DiskSurface;
+
+template<typename T_>
+class PlanarSurface;
+
 
 template<typename Ttraits_>
 class DiskSurface
@@ -260,7 +275,15 @@ class DiskSurface
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
-    }                                                                                                               
+    }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+    };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -296,6 +319,14 @@ class DiskSurface
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+    };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
@@ -329,6 +360,21 @@ class DiskSurface
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+    }    
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            
+        else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 956d68d6..36290ea2 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -253,7 +253,15 @@ class PlanarSurface
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
-    }                                                                                                               
+    }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+    };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -289,6 +297,14 @@ class PlanarSurface
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+    };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
@@ -322,6 +338,21 @@ class PlanarSurface
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+    }    
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            
+        else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 3889b045..bdd4c485 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -151,7 +151,15 @@ class SphericalSurface
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
-    }                                                                                                               
+    }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+    };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
@@ -187,6 +195,14 @@ class SphericalSurface
     {
         return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
     }
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+    {
+        // redirect to structure function with well-defined typing
+        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+    };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
@@ -220,6 +236,21 @@ class SphericalSurface
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+    }    
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+    {
+        if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            
+        else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            
+        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/Structure.hpp b/Structure.hpp
index 3800ee72..6e57bb17 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -175,15 +175,6 @@ class Structure
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
-    // The template function that defines the actual final dispatch procedure.
-    // Note that this is not virtual + overriden, but inherited by each derived structure class.
-    template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
-    {
-        // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
-    };
     // *** 2 *** - Producing two new positions
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
@@ -200,15 +191,6 @@ class Structure
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
-    // The template function that defines the actual final dispatch procedure.
-    // Note that this is not virtual + overriden, but inherited by each derived structure class.
-    template<typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
-    {
-        // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
-    };
     
     // *** 3 *** - Pair reactions => two origin structures
     // The following functions handle the case of two origin structures.
@@ -239,24 +221,11 @@ class Structure
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
-    // The template function that defines the actual final dispatch procedure.
-    // Note that this is not virtual + overriden, but inherited by each derived structure class.
+    
+    // Some further helper functions used by template<typename Tstruct_> get_pos_sid_pair_helper_two_origins_any(...),
+    // which is the final dispatch template defined in each of the derived classes and makes use of the two following checker functions:
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
-    {
-        if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
-            // origin_structure1 is target
-            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
-            
-        else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
-            // this structure is target
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
-    }    
-    // Some further helper functions used by get_pos_sid_pair_helper_two_origins
-    inline bool is_parent_of_or_has_same_sid_as(structure_type const& s) const
+    inline bool is_parent_of_or_has_same_sid_as(Tstruct_ const& s) const
     {    
           structure_id_type       s_parent_id( s.structure_id() );
           structure_type_id_type  s_sid( s.sid() );
@@ -264,7 +233,7 @@ class Structure
           structure_type_id_type  this_sid( this->sid() );
           
           return ( s_parent_id == this_id || s_sid == this_sid );          
-    }    
+    }
     inline bool has_valid_target_sid(structure_type_id_type const& target_sid) const
     {
           structure_type_id_type this_sid( this->sid() );
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index ca59baba..bf2aa22d 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -38,126 +38,126 @@ class PlanarSurface;
 /*****************************/
 /* Some default declarations */
 /*****************************/
-// These are actually never called but have to be there for type consistency reasons
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                  Structure<Ttraits_>                   const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                  Structure<Ttraits_>                   const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  Structure<Ttraits_>                   const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  Structure<Ttraits_>                   const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_>              const& origin_structure,
-                  Structure<Ttraits_>                   const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
+// // These are actually never called but have to be there for type consistency reasons
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
+//                   Structure<Ttraits_>                   const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
+//                   Structure<Ttraits_>                   const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
+//                   Structure<Ttraits_>                   const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
+//                   Structure<Ttraits_>                   const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( PlanarSurface<Ttraits_>              const& origin_structure,
+//                   Structure<Ttraits_>                   const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+//                   CuboidalRegion<Ttraits_>              const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+//                   SphericalSurface<Ttraits_>            const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+//                   CylindricalSurface<Ttraits_>          const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+//                   DiskSurface<Ttraits_>                 const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
+//                   PlanarSurface<Ttraits_>               const& target_structure,
+//                   typename Ttraits_::position_type      const& old_pos,
+//                   typename Ttraits_::length_type        const& offset,
+//                   typename Ttraits_::length_type        const& reaction_length,
+//                   typename Ttraits_::rng_type           const& rng              )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
 
 /******************************/
 /* Coming from CuboidalRegion */

From 4fb700f20239e49b66fa4b803097e696ca4cd9b2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Jul 2012 18:42:00 +0200
Subject: [PATCH 1013/1541] More changes to overcome another new 'undefined
 symbol' error

---
 CuboidalRegion.hpp     |  38 ++++++------
 CylindricalSurface.hpp |  38 ++++++------
 DiskSurface.hpp        |  38 ++++++------
 PlanarSurface.hpp      |  38 ++++++------
 SphericalSurface.hpp   |  38 ++++++------
 Structure.hpp          |  14 ++++-
 StructureFunctions.cpp | 103 +++++++++++++++----------------
 StructureFunctions.hpp | 133 +++++++++++++++++++++--------------------
 8 files changed, 227 insertions(+), 213 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 40db98fb..05b8f50b 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -166,27 +166,27 @@ class CuboidalRegion
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -194,7 +194,7 @@ class CuboidalRegion
                                                             length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
@@ -209,27 +209,27 @@ class CuboidalRegion
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -237,7 +237,7 @@ class CuboidalRegion
                                                                       species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
@@ -251,27 +251,27 @@ class CuboidalRegion
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -280,11 +280,11 @@ class CuboidalRegion
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index bd8f8279..87a6bf5f 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -241,27 +241,27 @@ class CylindricalSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -269,7 +269,7 @@ class CylindricalSurface
                                                             length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
@@ -284,27 +284,27 @@ class CylindricalSurface
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -312,7 +312,7 @@ class CylindricalSurface
                                                                       species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
@@ -326,27 +326,27 @@ class CylindricalSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -355,11 +355,11 @@ class CylindricalSurface
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index b15be4b4..21f5923f 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -254,27 +254,27 @@ class DiskSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -282,7 +282,7 @@ class DiskSurface
                                                             length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
@@ -297,27 +297,27 @@ class DiskSurface
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -325,7 +325,7 @@ class DiskSurface
                                                                       species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
@@ -339,27 +339,27 @@ class DiskSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -368,11 +368,11 @@ class DiskSurface
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 36290ea2..badfb780 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -232,27 +232,27 @@ class PlanarSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -260,7 +260,7 @@ class PlanarSurface
                                                             length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
@@ -275,27 +275,27 @@ class PlanarSurface
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -303,7 +303,7 @@ class PlanarSurface
                                                                       species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
@@ -317,27 +317,27 @@ class PlanarSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -346,11 +346,11 @@ class PlanarSurface
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index bdd4c485..4649dd7c 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -130,27 +130,27 @@ class SphericalSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_helper_any(origin_structure, position, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -158,7 +158,7 @@ class SphericalSurface
                                                             length_type const& offset, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair(origin_structure, *this, position, offset, rl, rng); 
+        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
@@ -173,27 +173,27 @@ class SphericalSurface
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
-        return this->get_pos_sid_pair_pair_helper_any(origin_structure, position, s_orig, s_targ, rl, rng);
+        return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -201,7 +201,7 @@ class SphericalSurface
                                                                       species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
     {
         // redirect to structure function with well-defined typing
-        return ::get_pos_sid_pair_pair(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
@@ -215,27 +215,27 @@ class SphericalSurface
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
@@ -244,11 +244,11 @@ class SphericalSurface
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return ::get_pos_sid_pair(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return ::get_pos_sid_pair(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/Structure.hpp b/Structure.hpp
index 6e57bb17..e4958668 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -175,6 +175,10 @@ class Structure
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const;
     // *** 2 *** - Producing two new positions
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
@@ -190,7 +194,11 @@ class Structure
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;                                                                          
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const;
     
     // *** 3 *** - Pair reactions => two origin structures
     // The following functions handle the case of two origin structures.
@@ -221,6 +229,10 @@ class Structure
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+    // The template function that defines the actual final dispatch procedure.
+    template<typename Tstruct_>
+    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
     
     // Some further helper functions used by template<typename Tstruct_> get_pos_sid_pair_helper_two_origins_any(...),
     // which is the final dispatch template defined in each of the derived classes and makes use of the two following checker functions:
diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
index 943b00c7..acafbc01 100644
--- a/StructureFunctions.cpp
+++ b/StructureFunctions.cpp
@@ -20,6 +20,7 @@
 
 /******************************************************************************************/
 
+namespace SF {
 /************************/
 /*** ONE NEW POSITION ***/
 /************************/
@@ -29,7 +30,7 @@
 /******************************/
 // CuboidalRegion -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -53,7 +54,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 
 // CuboidalRegion -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -73,7 +74,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 
 // CuboidalRegion -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -102,7 +103,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 
 // CuboidalRegion -> DiskSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -130,7 +131,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 
 // CuboidalRegion -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -161,7 +162,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 /********************************/
 // SphericalSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -181,7 +182,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 
 // SphericalSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -201,7 +202,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 
 // SphericalSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -221,7 +222,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 
 // SphericalSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -241,7 +242,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 
 // SphericalSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -264,7 +265,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 /**********************************/
 // CylindricalSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -285,7 +286,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 
 // CylindricalSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -309,7 +310,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 
 // CylindricalSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -329,7 +330,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 
 // CylindricalSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -357,7 +358,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 
 // CylindricalSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -380,7 +381,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 /***************************/
 // DiskSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -401,7 +402,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 
 // DiskSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -421,7 +422,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 
 // DiskSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -446,7 +447,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 
 // DiskSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -470,7 +471,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 
 // DiskSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -493,7 +494,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 /*****************************/
 // PlanarSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -514,7 +515,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 
 // PlanarSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -534,7 +535,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 
 // PlanarSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -554,7 +555,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 
 // PlanarSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -574,7 +575,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 
 // PlanarSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -609,7 +610,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 /******************************/
 // CuboidalRegion -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -642,7 +643,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 
 // CuboidalRegion -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -665,7 +666,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 
 // CuboidalRegion -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -689,7 +690,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 
 // CuboidalRegion -> DiskSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
@@ -712,7 +713,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 
 // CuboidalRegion -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -738,7 +739,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 /********************************/
 // SphericalSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -761,7 +762,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 
 // SphericalSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -784,7 +785,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 
 // SphericalSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -807,7 +808,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 
 // SphericalSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
@@ -830,7 +831,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 
 // SphericalSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -856,7 +857,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 /**********************************/
 // CylindricalSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -883,7 +884,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 
 // CylindricalSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -916,7 +917,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 
 // CylindricalSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -939,7 +940,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 
 // CylindricalSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
@@ -962,7 +963,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 
 // CylindricalSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -988,7 +989,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 /***************************/
 // DiskSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -1015,7 +1016,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 
 // DiskSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -1038,7 +1039,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 
 // DiskSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -1064,7 +1065,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 
 // DiskSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
@@ -1087,7 +1088,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 
 // DiskSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -1113,7 +1114,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 /*****************************/
 // PlanarSurface -> CuboidalRegion
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -1140,7 +1141,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 
 // PlanarSurface -> SphericalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -1163,7 +1164,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 
 // PlanarSurface -> CylindricalSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -1186,7 +1187,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 
 // PlanarSurface -> DiskSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
@@ -1209,7 +1210,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 
 // PlanarSurface -> PlanarSurface
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -1243,7 +1244,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 };
 
 /******************************************************************************************************/
-
+} // namespace
 
 #endif /* STRUCTUREFUNCTIONS_CPP */
 
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index bf2aa22d..88482fbc 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -40,7 +40,7 @@ class PlanarSurface;
 /*****************************/
 // // These are actually never called but have to be there for type consistency reasons
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 //                   Structure<Ttraits_>                   const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -52,7 +52,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 //                   Structure<Ttraits_>                   const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -64,7 +64,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 //                   Structure<Ttraits_>                   const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -76,7 +76,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 //                   Structure<Ttraits_>                   const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -88,7 +88,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( PlanarSurface<Ttraits_>              const& origin_structure,
 //                   Structure<Ttraits_>                   const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -100,7 +100,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
 //                   CuboidalRegion<Ttraits_>              const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -112,7 +112,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
 //                   SphericalSurface<Ttraits_>            const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -124,7 +124,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
 //                   CylindricalSurface<Ttraits_>          const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -136,7 +136,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
 //                   DiskSurface<Ttraits_>                 const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -148,7 +148,7 @@ class PlanarSurface;
 // }
 // 
 // template <typename Ttraits_>
-// inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 // get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
 //                   PlanarSurface<Ttraits_>               const& target_structure,
 //                   typename Ttraits_::position_type      const& old_pos,
@@ -159,11 +159,12 @@ class PlanarSurface;
 //     throw illegal_propagation_attempt("Calling structure function without type specification!");
 // }
 
+namespace SF {
 /******************************/
 /* Coming from CuboidalRegion */
 /******************************/
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -172,7 +173,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -181,7 +182,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -190,7 +191,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -199,7 +200,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -211,7 +212,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 /* Coming from SphericalSurface */
 /********************************/
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -220,7 +221,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -229,7 +230,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -238,7 +239,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -247,7 +248,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -259,7 +260,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 /* Coming from CylindricalSurface */
 /**********************************/
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -268,7 +269,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -277,7 +278,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -286,7 +287,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -295,7 +296,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
@@ -307,7 +308,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 /* Coming from DiskSurface */
 /***************************/
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -316,7 +317,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -325,7 +326,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -334,7 +335,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -343,7 +344,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -355,7 +356,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 /* Coming from PlanarSurface */
 /*****************************/
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -364,7 +365,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -373,7 +374,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -382,7 +383,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
 
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -391,7 +392,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::rng_type           const& rng              );
                   
 template <typename Ttraits_>
-inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure, 
                   typename Ttraits_::position_type      const& old_pos,
@@ -412,7 +413,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 /******************************/
 // These are actually never called but have to be there for type consistency reasons
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        Structure<Ttraits_>                    const& target_structure,
@@ -426,7 +427,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 }
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        Structure<Ttraits_>                    const& target_structure,
@@ -440,7 +441,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 }
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        Structure<Ttraits_>                    const& target_structure,
@@ -454,7 +455,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 }
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        Structure<Ttraits_>                    const& target_structure,
@@ -468,7 +469,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 }
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        Structure<Ttraits_>                    const& target_structure,
@@ -485,7 +486,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 /* Coming from CuboidalRegion */
 /******************************/
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -496,7 +497,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -507,7 +508,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -518,7 +519,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
@@ -529,7 +530,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -543,7 +544,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 /* Coming from SphericalSurface */
 /********************************/
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -554,7 +555,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -565,7 +566,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -576,7 +577,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
@@ -587,7 +588,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -601,7 +602,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 /* Coming from CylindricalSurface */
 /**********************************/
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
@@ -612,7 +613,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
@@ -623,7 +624,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
@@ -634,7 +635,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
@@ -645,7 +646,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
@@ -659,7 +660,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 /* Coming from DiskSurface */
 /***************************/
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure, 
@@ -670,7 +671,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure, 
@@ -681,7 +682,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure, 
@@ -692,7 +693,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
@@ -703,7 +704,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure, 
@@ -717,7 +718,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 /* Coming from PlanarSurface */
 /*****************************/
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure, 
@@ -728,7 +729,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure, 
@@ -739,7 +740,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure, 
@@ -750,7 +751,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
 
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure, 
@@ -761,7 +762,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        typename Ttraits_::rng_type            const& rng                 );
                   
 template <typename Ttraits_>
-inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure, 
@@ -773,7 +774,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 
                        
 /******************************************************************************************************/
-
+} // namespace
                   
 #endif /* STRUCTUREFUNCTIONS_HPP */
 

From b7b96ddb36e49c83cb5625fafdaa3b33721860af Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Jul 2012 19:19:10 +0200
Subject: [PATCH 1014/1541] More informative output for some exceptions

---
 StructureFunctions.hpp | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index ca59baba..f59bdb26 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -48,7 +48,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (CuboidalRegion, Structure).");
 }
 
 template <typename Ttraits_>
@@ -60,7 +60,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (SphericalSurface, Structure).");
 }
 
 template <typename Ttraits_>
@@ -72,7 +72,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (CylindricalSurface, Structure).");
 }
 
 template <typename Ttraits_>
@@ -84,7 +84,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (DiskSurface, Structure).");
 }
 
 template <typename Ttraits_>
@@ -96,7 +96,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>              const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (PlanarSurface, Structure).");
 }
 
 template <typename Ttraits_>
@@ -108,7 +108,7 @@ get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (Structure, CuboidalRegion).");
 }
 
 template <typename Ttraits_>
@@ -120,7 +120,7 @@ get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (Structure, SphericalSurface).");
 }
 
 template <typename Ttraits_>
@@ -132,7 +132,7 @@ get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (Structure, CylindricalSurface).");
 }
 
 template <typename Ttraits_>
@@ -144,7 +144,7 @@ get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (Structure, DiskSurface).");
 }
 
 template <typename Ttraits_>
@@ -156,7 +156,7 @@ get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           const& rng              )
 {
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
+    throw illegal_propagation_attempt("Calling structure function without type specification! Type signature: (Structure, PlanarSurface).");
 }
 
 /******************************/

From 6581d636fa5213e555bcbf9b10a92bc151d568fc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Jul 2012 10:52:27 +0200
Subject: [PATCH 1015/1541] Include derived classes into newBDPropagator

---
 StructureFunctions.hpp | 140 ++++++++++++++++++++---------------------
 newBDPropagator.hpp    |   7 +++
 2 files changed, 77 insertions(+), 70 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 88482fbc..7549c7df 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -411,76 +411,76 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 /******************************/
 /* Some Defaults declarations */
 /******************************/
-// These are actually never called but have to be there for type consistency reasons
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
-                       Structure<Ttraits_>                    const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
-                       Structure<Ttraits_>                    const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       Structure<Ttraits_>                    const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       Structure<Ttraits_>                    const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
-
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       Structure<Ttraits_>                    const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 )
-{
-    throw illegal_propagation_attempt("Calling structure function without type specification!");
-}
+// // These are actually never called but have to be there for type consistency reasons
+// template <typename Ttraits_>
+// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+// get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
+//                        Structure<Ttraits_>                    const& target_structure,
+//                        typename Ttraits_::position_type       const& old_pos,
+//                        typename Ttraits_::species_type        const& s1,
+//                        typename Ttraits_::species_type        const& s2,
+//                        typename Ttraits_::length_type         const& reaction_length,
+//                        typename Ttraits_::rng_type            const& rng                 )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+// get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
+//                        Structure<Ttraits_>                    const& target_structure,
+//                        typename Ttraits_::position_type       const& old_pos,
+//                        typename Ttraits_::species_type        const& s1,
+//                        typename Ttraits_::species_type        const& s2,
+//                        typename Ttraits_::length_type         const& reaction_length,
+//                        typename Ttraits_::rng_type            const& rng                 )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+// get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
+//                        Structure<Ttraits_>                    const& target_structure,
+//                        typename Ttraits_::position_type       const& old_pos,
+//                        typename Ttraits_::species_type        const& s1,
+//                        typename Ttraits_::species_type        const& s2,
+//                        typename Ttraits_::length_type         const& reaction_length,
+//                        typename Ttraits_::rng_type            const& rng                 )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+// get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
+//                        Structure<Ttraits_>                    const& target_structure,
+//                        typename Ttraits_::position_type       const& old_pos,
+//                        typename Ttraits_::species_type        const& s1,
+//                        typename Ttraits_::species_type        const& s2,
+//                        typename Ttraits_::length_type         const& reaction_length,
+//                        typename Ttraits_::rng_type            const& rng                 )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
+// 
+// template <typename Ttraits_>
+// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
+// get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
+//                        Structure<Ttraits_>                    const& target_structure,
+//                        typename Ttraits_::position_type       const& old_pos,
+//                        typename Ttraits_::species_type        const& s1,
+//                        typename Ttraits_::species_type        const& s2,
+//                        typename Ttraits_::length_type         const& reaction_length,
+//                        typename Ttraits_::rng_type            const& rng                 )
+// {
+//     throw illegal_propagation_attempt("Calling structure function without type specification!");
+// }
 
 /******************************/
 /* Coming from CuboidalRegion */
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 6a848751..e8dc2ce1 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -20,6 +20,13 @@
 #include "utils/get_default_impl.hpp"
 #include "Logger.hpp"
 
+#include "Structure.hpp"
+#include "CuboidalRegion.hpp"
+#include "SphericalSurface.hpp"
+#include "CylindricalSurface.hpp"
+#include "DiskSurface.hpp"
+#include "PlanarSurface.hpp"
+
 #include <iostream>
 
 template<typename Ttraits_>

From e4db5d131ce3267366fc622094eebc603da68361 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Jul 2012 13:24:49 +0200
Subject: [PATCH 1016/1541] Make structure functions inline + major cleanup

---
 CuboidalRegion.hpp     |   50 +-
 CylindricalSurface.hpp |   52 +-
 DiskSurface.hpp        |   50 +-
 Makefile.am            |    1 -
 PlanarSurface.hpp      |   50 +-
 SphericalSurface.hpp   |   50 +-
 Structure.hpp          |   60 +-
 StructureFunctions.hpp | 1319 +++++++++++++++++++++++++++-------------
 8 files changed, 1060 insertions(+), 572 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 05b8f50b..0808d70e 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -158,133 +158,133 @@ class CuboidalRegion
     // This requires a double dynamic dispatch.
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                            length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
+        return ::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return ::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
-                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 87a6bf5f..faf04e65 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -233,133 +233,133 @@ class CylindricalSurface
     // This requires a double dynamic dispatch.
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                            length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
+        return ::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return ::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
-                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
@@ -369,7 +369,7 @@ class CylindricalSurface
 //     // Overloading get_pos_sid_pair again with signature (origin_structure2, target_structure, ...) and introducing
 //     // a triple dynamic dispatch.
 //     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type& rng) const
 //     {
 //         return origin_structure2.get_pos_sid_pair_helper1(*this, target_structure, position, offset, reaction_length, rng);
 //     }
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 21f5923f..b638f21c 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -246,133 +246,133 @@ class DiskSurface
     // This requires a double dynamic dispatch.
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                            length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
+        return ::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return ::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
-                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/Makefile.am b/Makefile.am
index ec557bb3..e057a41e 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -194,7 +194,6 @@ _gfrd_la_SOURCES=\
 	SpeciesType.cpp\
 	SphericalBesselGenerator.cpp\
 	StructureType.cpp\
-	StructureFunctions.cpp\
 	utils.cpp
 
 _greens_functions_la_SOURCES=\
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index badfb780..353a98db 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -224,133 +224,133 @@ class PlanarSurface
     // This requires a double dynamic dispatch.
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                            length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
+        return ::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return ::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
-                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 4649dd7c..f9822dbf 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -122,133 +122,133 @@ class SphericalSurface
     // This requires a double dynamic dispatch.
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_helper(*this, position, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, offset, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                            length_type const& offset, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
+        return ::get_pos_sid_pair<traits_type>(origin_structure, *this, position, offset, rl, rng); 
     };
                                                         
     // *** 2 *** - Two new positions
     // Same principle as above, but different return type
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type const& rng) const
+                                                                   species_type const& s1, species_type const& s2, length_type const& reaction_length, rng_type& rng) const
     {
         return target_structure.get_pos_sid_pair_pair_helper(*this, position, s1, s2, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CuboidalRegion<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<SphericalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<CylindricalSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<DiskSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         return this->get_pos_sid_pair_pair_helper_any<PlanarSurface<traits_type> >(origin_structure, position, s_orig, s_targ, rl, rng);
     }
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const
+                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const
     {
         // redirect to structure function with well-defined typing
-        return SF::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
+        return ::get_pos_sid_pair_pair<traits_type>(origin_structure, *this, position, s_orig, s_targ, rl, rng); 
     };
     
     // *** 3 *** - Pair reactions => two origin structures
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
-                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                         position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
-                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type const& rng) const
+                                                                            position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
         return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
     position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+                                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
-            return SF::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
             
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
-            return SF::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
             
         else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
     }
diff --git a/Structure.hpp b/Structure.hpp
index e4958668..23b28f65 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -162,43 +162,43 @@ class Structure
     // *** 1 *** - Producing one new position
     // First dispatch
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
-                                                         length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+                                                         length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     // Second dispatch
     // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                        length_type const& offset, length_type const& rl, rng_type const& rng) const = 0;
+                                                        length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     // The template function that defines the actual final dispatch procedure.
-    template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                            length_type const& offset, length_type const& rl, rng_type const& rng) const;
+//     template<typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+//                                                             length_type const& offset, length_type const& rl, rng_type& rng) const;
     // *** 2 *** - Producing two new positions
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
-                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+                                                                   species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     // Second dispatch
     // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CylindricalSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(DiskSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
-                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const = 0;                                                                          
+                                                                          species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;                                                                          
     // The template function that defines the actual final dispatch procedure.
-    template<typename Tstruct_>
-    position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-                                                                      species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type const& rng) const;
+//     template<typename Tstruct_>
+//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
+//                                                                       species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const;
     
     // *** 3 *** - Pair reactions => two origin structures
     // The following functions handle the case of two origin structures.
@@ -215,24 +215,24 @@ class Structure
     // First dispatch, overloading method call structure.get_pos_sid_pair
     // This is called as a method of origin_structure1 with origin_structure2 as an argument.
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;    
+                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;    
     // Second dispatch
     // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
     // It is called as a method of origin_structure2 by origin_structure1 with origin_structure1 as an argument
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     // The template function that defines the actual final dispatch procedure.
-    template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                        length_type const& offset, length_type const& reaction_length, rng_type const& rng) const;
+//     template<typename Tstruct_>
+//     position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+//                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const;
     
     // Some further helper functions used by template<typename Tstruct_> get_pos_sid_pair_helper_two_origins_any(...),
     // which is the final dispatch template defined in each of the derived classes and makes use of the two following checker functions:
@@ -258,16 +258,16 @@ class Structure
 //     // This introduces a triple dynamic dispatch, overloading method call structure.get_pos_sid_pair once more.
 //     // NOTE: As yet these methods are unused but might prove useful in the future.
 //     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const = 0;
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
 //     template <typename Tstruct1_>
 //     position_structid_pair_type get_pos_sid_pair_helper1(Tstruct1_ const& origin_structure1, structure_type const& target_structure, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type& rng) const
 //     {
 //         return target_structure.get_pos_sid_pair_helper2(origin_structure1, *this, position, offset, reaction_length, rng);
 //     }
 //     template <typename Tstruct1_, typename Tstruct2_>
 //     position_structid_pair_type get_pos_sid_pair_helper2(Tstruct1_ const& origin_structure1, Tstruct2_ const& origin_structure2, position_type const& position,
-//                                                          length_type const& offset, length_type const& reaction_length, rng_type const& rng) const
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type& rng) const
 //     {
 //         structure_id_type    this_id( this->id );
 //         structure_id_type    os1_id( origin_structure1.id );
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 7549c7df..21487eff 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -1,6 +1,24 @@
 #ifndef STRUCTFUNC_HPP
 #define STRUCTFUNC_HPP
 
+//#include "StructureFunctions.hpp" // TODO Why the hell does this not work, man???
+//#include "CuboidalRegion.hpp"
+//#include "SphericalSurface.hpp"
+//#include "CylindricalSurface.hpp"
+//#include "DiskSurface.hpp"
+//#include "PlanarSurface.hpp"
+#include "linear_algebra.hpp"
+#include "exceptions.hpp"
+
+
+/******************************************************************************************/
+
+// Define the structure functions and the actions performed in each case.
+// There are two types: 1) yielding one new position and structure id
+//                      2) yielding two new positions and structure ids
+//                         (for single reactions with two products)
+
+/******************************************************************************************/
 
 // Forward declaration of structures
 template <typename Ttraits_>
@@ -21,386 +39,584 @@ class DiskSurface;
 template <typename Ttraits_>
 class PlanarSurface;
 
-
-/******************************************************************************************/
-
-// Now declare the structure functions.
-// There are two types: 1) yielding one new position and structure id
-//                      2) yielding two new positions and structure ids
-//                         (for single reactions with two products)
-
-/******************************************************************************************/
-
 /************************/
 /*** ONE NEW POSITION ***/
 /************************/
 
-/*****************************/
-/* Some default declarations */
-/*****************************/
-// // These are actually never called but have to be there for type consistency reasons
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-//                   Structure<Ttraits_>                   const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-//                   Structure<Ttraits_>                   const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-//                   Structure<Ttraits_>                   const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-//                   Structure<Ttraits_>                   const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( PlanarSurface<Ttraits_>              const& origin_structure,
-//                   Structure<Ttraits_>                   const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-//                   CuboidalRegion<Ttraits_>              const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-//                   SphericalSurface<Ttraits_>            const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-//                   CylindricalSurface<Ttraits_>          const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-//                   DiskSurface<Ttraits_>                 const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-// get_pos_sid_pair( Structure<Ttraits_>                   const& origin_structure,
-//                   PlanarSurface<Ttraits_>               const& target_structure,
-//                   typename Ttraits_::position_type      const& old_pos,
-//                   typename Ttraits_::length_type        const& offset,
-//                   typename Ttraits_::length_type        const& reaction_length,
-//                   typename Ttraits_::rng_type           const& rng              )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-
-namespace SF {
 /******************************/
 /* Coming from CuboidalRegion */
 /******************************/
+// CuboidalRegion -> CuboidalRegion
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+    
+    // Currently only species change and decay are supported
+    if(origin_structure.id() == target_structure.id()){
+     
+          return std::make_pair( old_pos, origin_structure.id() );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
+};
 
+// CuboidalRegion -> SphericalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
 
+// CuboidalRegion -> CylindricalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
+    structure_id_type   new_id(    target_structure.id() );
+    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    length_type         proj_dist( target_structure.project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
+    
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+    
+};
+
+// CuboidalRegion -> DiskSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    structure_id_type   new_id(    target_structure.id() );
+    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    length_type         proj_dist( target_structure.project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
+    
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+};
 
+// CuboidalRegion -> PlanarSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    structure_id_type   new_id(    target_structure.id() );
+    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    length_type         proj_dist( target_structure.project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
+    
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+};
 
 /********************************/
 /* Coming from SphericalSurface */
 /********************************/
+// SphericalSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// SphericalSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// SphericalSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// SphericalSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
 
+// SphericalSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
 
 /**********************************/
 /* Coming from CylindricalSurface */
 /**********************************/
+// CylindricalSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+    
+    position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type new_pos( add(old_pos, displacement) );    
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id());
+};
+
+// CylindricalSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure,
+                  CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
+    // Currently only species change and decay are supported
+    if(origin_structure.id() == target_structure.id()){
+     
+          return std::make_pair( old_pos, origin_structure.id() );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
+};
+
+// CylindricalSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure,
+                  SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// CylindricalSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure, 
+                  DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    structure_id_type   new_id(    target_structure.id() );
+    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    length_type         proj_dist( target_structure.project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
+    
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+};
+
+// CylindricalSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
 
 /***************************/
 /* Coming from DiskSurface */
 /***************************/
+// DiskSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure, 
+                  CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type new_pos( add(old_pos, displacement) );
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id());
+};
+
+// DiskSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure, 
+                  SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// DiskSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure, 
+                  CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
+    position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
+    
+    // When a particle is dissociation from a disk to the cylinder, the direction is randomized
+    Real r( rng.uniform(0.,1.));    
+    Real rs( r < 0.5 ? -1.0 : +1.0 ); // TESTING TESTING TESTING this is unused yet, work this into the func. below!
+    //position_type new_pos( add(old_pos, multiply(rs, displacement)) );
+    position_type new_pos( add(old_pos, origin_structure.surface_dissociation_vector(rng, offset, reaction_length) ) );
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id());
+};
+
+// DiskSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure, 
+                  DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    // Currently only species change and decay are supported
+    if(origin_structure.id() == target_structure.id()){
+     
+          return std::make_pair( old_pos, origin_structure.id() );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");    
+};
+
+// DiskSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure, 
+                  PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
 /*****************************/
 /* Coming from PlanarSurface */
 /*****************************/
+// PlanarSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure, 
+                  CuboidalRegion<Ttraits_>              const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type new_pos( add(old_pos, displacement) );
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id());
+};
+
+// PlanarSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure, 
+                  SphericalSurface<Ttraits_>            const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// PlanarSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure, 
+                  CylindricalSurface<Ttraits_>          const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// PlanarSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure, 
+                  DiskSurface<Ttraits_>                 const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
-                  
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(position_type(), structure_id_type());
+};
+
+// PlanarSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
+inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure, 
+                  PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
                   typename Ttraits_::length_type        const& offset,
                   typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              );
+                  typename Ttraits_::rng_type           &rng              )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    // Currently only species change and decay are supported
+    if(origin_structure.id() == target_structure.id()){
+     
+          return std::make_pair( old_pos, origin_structure.id() );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+};
+
 
-                  
 /******************************************************************************************/
 
 
@@ -408,373 +624,646 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 /*** TWO NEW POSITIONS ***/
 /*************************/
 
-/******************************/
-/* Some Defaults declarations */
-/******************************/
-// // These are actually never called but have to be there for type consistency reasons
-// template <typename Ttraits_>
-// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-// get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
-//                        Structure<Ttraits_>                    const& target_structure,
-//                        typename Ttraits_::position_type       const& old_pos,
-//                        typename Ttraits_::species_type        const& s1,
-//                        typename Ttraits_::species_type        const& s2,
-//                        typename Ttraits_::length_type         const& reaction_length,
-//                        typename Ttraits_::rng_type            const& rng                 )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-// get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
-//                        Structure<Ttraits_>                    const& target_structure,
-//                        typename Ttraits_::position_type       const& old_pos,
-//                        typename Ttraits_::species_type        const& s1,
-//                        typename Ttraits_::species_type        const& s2,
-//                        typename Ttraits_::length_type         const& reaction_length,
-//                        typename Ttraits_::rng_type            const& rng                 )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-// get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-//                        Structure<Ttraits_>                    const& target_structure,
-//                        typename Ttraits_::position_type       const& old_pos,
-//                        typename Ttraits_::species_type        const& s1,
-//                        typename Ttraits_::species_type        const& s2,
-//                        typename Ttraits_::length_type         const& reaction_length,
-//                        typename Ttraits_::rng_type            const& rng                 )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-// get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-//                        Structure<Ttraits_>                    const& target_structure,
-//                        typename Ttraits_::position_type       const& old_pos,
-//                        typename Ttraits_::species_type        const& s1,
-//                        typename Ttraits_::species_type        const& s2,
-//                        typename Ttraits_::length_type         const& reaction_length,
-//                        typename Ttraits_::rng_type            const& rng                 )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-// 
-// template <typename Ttraits_>
-// std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-//                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-// get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-//                        Structure<Ttraits_>                    const& target_structure,
-//                        typename Ttraits_::position_type       const& old_pos,
-//                        typename Ttraits_::species_type        const& s1,
-//                        typename Ttraits_::species_type        const& s2,
-//                        typename Ttraits_::length_type         const& reaction_length,
-//                        typename Ttraits_::rng_type            const& rng                 )
-// {
-//     throw illegal_propagation_attempt("Calling structure function without type specification!");
-// }
-
 /******************************/
 /* Coming from CuboidalRegion */
 /******************************/
+// CuboidalRegion -> CuboidalRegion
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
+    // Currently we do not allow for pair forward/backward reactions between two different cubes
+    if(origin_structure.id() == target_structure.id()){
+     
+        structure_id_type new_sid( origin_structure.id() );
+        std::pair<position_type, position_type> new_positions( origin_structure.geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+        // the type of origin_structure and the properties of the two product species
+        // (the displacements from old_pos are weighted by the diffusion constants)
+            
+        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
+                                    std::make_pair(new_positions.second, new_sid)    );          
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+};
+
+// CuboidalRegion -> SphericalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
 
+// CuboidalRegion -> CylindricalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+    
+};
+
+// CuboidalRegion -> DiskSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
 
+// CuboidalRegion -> PlanarSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
 
 /********************************/
 /* Coming from SphericalSurface */
 /********************************/
+// SphericalSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// SphericalSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// SphericalSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// SphericalSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
 
+// SphericalSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
 
 /**********************************/
 /* Coming from CylindricalSurface */
 /**********************************/
+// CylindricalSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+    // the types of origin_structure and target_structure and the properties of the two product species
+    // (the displacements from old_pos are weighted by the diffusion constants);
+    // the first pair entry is the particle staying on the surface, the second entry the particle
+    // that goes into the bulk
+            
+    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id()),
+                                std::make_pair(new_positions.second, target_structure.id())    );  
+};
+
+// CylindricalSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure,
+                       CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    // Currently we do not allow for pair forward/backward reactions between two different cylinders
+    if(origin_structure.id() == target_structure.id()){
+     
+        structure_id_type new_sid( origin_structure.id() );
+        std::pair<position_type, position_type> new_positions( origin_structure.geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+        // the type of origin_structure and the properties of the two product species
+        // (the displacements from old_pos are weighted by the diffusion constants)
+            
+        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
+                                    std::make_pair(new_positions.second, new_sid)    );          
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+};
 
+// CylindricalSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure,
+                       SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CylindricalSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure, 
+                       DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// CylindricalSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
                        PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
 
 /***************************/
 /* Coming from DiskSurface */
 /***************************/
+// DiskSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       CuboidalRegion<Ttraits_>               const& target_structure, 
+                       CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+    // the types of origin_structure and target_structure and the properties of the two product species
+    // (the displacements from old_pos are weighted by the diffusion constants);
+    // the first pair entry is the particle staying on the surface, the second entry the particle
+    // that goes into the bulk
+            
+    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id()),
+                                std::make_pair(new_positions.second, target_structure.id())    );
+};
+
+// DiskSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure, 
+                       SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// DiskSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure, 
+                       CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    // TODO TODO TODO
+    // IMPLEMENT THE UNBINDING FROM THE DISK ACTING AS A SINK!
+    
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
 
+// DiskSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure, 
+                       DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// DiskSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       PlanarSurface<Ttraits_>                const& target_structure, 
+                       PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
 /*****************************/
 /* Coming from PlanarSurface */
 /*****************************/
+// PlanarSurface -> CuboidalRegion
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       CuboidalRegion<Ttraits_>               const& target_structure, 
+                       CuboidalRegion<Ttraits_>               const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+    
+    std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+    // the types of origin_structure and target_structure and the properties of the two product species
+    // (the displacements from old_pos are weighted by the diffusion constants);
+    // the first pair entry is the particle staying on the surface, the second entry the particle
+    // that goes into the bulk
+            
+    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id()),
+                                std::make_pair(new_positions.second, target_structure.id())    );    
+};
+
+// PlanarSurface -> SphericalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure, 
+                       SphericalSurface<Ttraits_>             const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// PlanarSurface -> CylindricalSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure, 
+                       CylindricalSurface<Ttraits_>           const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
 
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// PlanarSurface -> DiskSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure, 
+                       DiskSurface<Ttraits_>                  const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
-                  
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    /*** COMBINATION NOT SUPPORTED ***/
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    
+    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
+                                std::make_pair(position_type(), structure_id_type())    );
+};
+
+// PlanarSurface -> PlanarSurface
 template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
+inline std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
                   std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
 get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       PlanarSurface<Ttraits_>                const& target_structure, 
+                       PlanarSurface<Ttraits_>                const& target_structure,
                        typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s1,
-                       typename Ttraits_::species_type        const& s2,
+                       typename Ttraits_::species_type        const& s_orig,
+                       typename Ttraits_::species_type        const& s_targ,
                        typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                 );
+                       typename Ttraits_::rng_type            &rng                )
+{
+    typedef typename Ttraits_::structure_id_type        structure_id_type;
+    typedef typename Ttraits_::position_type            position_type;
+    typedef typename Ttraits_::length_type              length_type;
+
+    // As a default we produce two new positions on the same plane; in principle the particles can end up
+    // on different planes, but this should be treated afterwards via apply_boundary.
+    // TODO: Move apply_boundary into structure functions?
+    if(origin_structure.id() == target_structure.id()){
+     
+        structure_id_type new_sid( origin_structure.id() );
+        std::pair<position_type, position_type> new_positions( origin_structure.geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+        // the type of origin_structure and the properties of the two product species
+        // (the displacements from old_pos are weighted by the diffusion constants)
+            
+        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
+                                    std::make_pair(new_positions.second, new_sid)    );          
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+};
 
-                       
 /******************************************************************************************************/
-} // namespace
-                  
+
+
 #endif /* STRUCTUREFUNCTIONS_HPP */
 

From 1d75b52d6872f5fe9fbd4f8e93c1acdb62f31d25 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Jul 2012 16:00:57 +0200
Subject: [PATCH 1017/1541] Fix unbinding from disk to cylinder for the sink
 (in BD)

---
 StructureFunctions.hpp | 11 ++++++-----
 newBDPropagator.hpp    |  5 ++++-
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 21487eff..055fe2f9 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -452,13 +452,14 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type u( origin_structure.surface_dissociation_unit_vector(rng) );
     
     // When a particle is dissociation from a disk to the cylinder, the direction is randomized
-    Real r( rng.uniform(0.,1.));    
-    Real rs( r < 0.5 ? -1.0 : +1.0 ); // TESTING TESTING TESTING this is unused yet, work this into the func. below!
-    //position_type new_pos( add(old_pos, multiply(rs, displacement)) );
-    position_type new_pos( add(old_pos, origin_structure.surface_dissociation_vector(rng, offset, reaction_length) ) );
+    Real r(    rng.uniform(0.,1.) );
+    Real r_rl( rng.uniform(0.,reaction_length) );
+    Real r_displace( r < 0.5 ? -1.0*r_rl : +1.0*r_rl );
+    
+    position_type new_pos( add(old_pos, multiply(u, r_displace)) );
     // TODO assert that new_pos is in target_structure
     
     return std::make_pair(new_pos, target_structure.id());
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index e8dc2ce1..bd017e33 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -442,10 +442,11 @@ class newBDPropagator
                             const structure_id_type product_structure_id(reactant_structure->structure_id()); // the parent structure
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
                             // Produce new position and structure id
+                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(product_structure).c_str())); // TESTING
                             const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos,
                                                                                                                       product_species.radius(), reaction_length_, rng_) );                            
                             // Apply boundary conditions
-                            product_pos_struct_id = tx_.apply_boundary( product_pos_struct_id );
+                            product_pos_struct_id = tx_.apply_boundary( new_pos_sid_pair );
                             // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
@@ -550,6 +551,7 @@ class newBDPropagator
                             
                             // Produce two new positions and structure IDs
                             // Note that reactant_structure = prod0_structure here.
+                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(prod1_structure).c_str())); // TESTING
                             pos0pos1_pair = reactant_structure->get_pos_sid_pair_pair(*prod1_structure, reactant_pos, product0_species, product1_species, reaction_length_, rng_ );
                             // Remember the new structure IDs
                             prod0_struct_id = pos0pos1_pair.first.second;
@@ -734,6 +736,7 @@ class newBDPropagator
                         // structures are the same, no projection should occur. This is handled correctly by the structure functions defined for equal
                         // origin_structure types.
                         const length_type offset(0.0);
+                        LOG_DEBUG(("Attempting pair reaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(reactant1_structure).c_str())); // TESTING
                         const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair(*reactant1_structure, product_structure_type_id,
                                                                                                                        reactants_CoM, offset, reaction_length_, rng_ ) );
                         // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above

From f757ee96122f0124eb4e8c7b252ab196ff7272a0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Jul 2012 18:15:19 +0200
Subject: [PATCH 1018/1541] Some further cleanup

---
 StructureFunctions.hpp | 21 ++++++++++-----------
 newBDPropagator.hpp    |  6 ------
 2 files changed, 10 insertions(+), 17 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 055fe2f9..7fd59bf2 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -1,7 +1,6 @@
 #ifndef STRUCTFUNC_HPP
 #define STRUCTFUNC_HPP
 
-//#include "StructureFunctions.hpp" // TODO Why the hell does this not work, man???
 //#include "CuboidalRegion.hpp"
 //#include "SphericalSurface.hpp"
 //#include "CylindricalSurface.hpp"
@@ -10,16 +9,6 @@
 #include "linear_algebra.hpp"
 #include "exceptions.hpp"
 
-
-/******************************************************************************************/
-
-// Define the structure functions and the actions performed in each case.
-// There are two types: 1) yielding one new position and structure id
-//                      2) yielding two new positions and structure ids
-//                         (for single reactions with two products)
-
-/******************************************************************************************/
-
 // Forward declaration of structures
 template <typename Ttraits_>
 class Structure;
@@ -39,6 +28,16 @@ class DiskSurface;
 template <typename Ttraits_>
 class PlanarSurface;
 
+
+/******************************************************************************************/
+
+// Define the structure functions and the actions performed in each case.
+// There are two types: 1) yielding one new position and structure id
+//                      2) yielding two new positions and structure ids
+//                         (for single reactions with two products)
+
+/******************************************************************************************/
+
 /************************/
 /*** ONE NEW POSITION ***/
 /************************/
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index bd017e33..bee35df2 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -20,12 +20,6 @@
 #include "utils/get_default_impl.hpp"
 #include "Logger.hpp"
 
-#include "Structure.hpp"
-#include "CuboidalRegion.hpp"
-#include "SphericalSurface.hpp"
-#include "CylindricalSurface.hpp"
-#include "DiskSurface.hpp"
-#include "PlanarSurface.hpp"
 
 #include <iostream>
 

From 05423b6961a3b7b3ab26046433d073a85d2023db Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Jul 2012 18:16:03 +0200
Subject: [PATCH 1019/1541] Remove StructureFunctions.cpp

---
 StructureFunctions.cpp | 1250 ----------------------------------------
 1 file changed, 1250 deletions(-)
 delete mode 100644 StructureFunctions.cpp

diff --git a/StructureFunctions.cpp b/StructureFunctions.cpp
deleted file mode 100644
index acafbc01..00000000
--- a/StructureFunctions.cpp
+++ /dev/null
@@ -1,1250 +0,0 @@
-#ifndef STRUCTFUNC_CPP
-#define STRUCTFUNC_CPP
-
-//#include "StructureFunctions.hpp" // TODO Why the hell does this not work, man???
-#include "CuboidalRegion.hpp"
-#include "SphericalSurface.hpp"
-#include "CylindricalSurface.hpp"
-#include "DiskSurface.hpp"
-#include "PlanarSurface.hpp"
-#include "linear_algebra.hpp"
-#include "exceptions.hpp"
-
-
-/******************************************************************************************/
-
-// Define the structure functions and the actions performed in each case.
-// There are two types: 1) yielding one new position and structure id
-//                      2) yielding two new positions and structure ids
-//                         (for single reactions with two products)
-
-/******************************************************************************************/
-
-namespace SF {
-/************************/
-/*** ONE NEW POSITION ***/
-/************************/
-
-/******************************/
-/* Coming from CuboidalRegion */
-/******************************/
-// CuboidalRegion -> CuboidalRegion
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-    
-    // Currently only species change and decay are supported
-    if(origin_structure.id == target_structure.id){
-     
-          return std::make_pair( old_pos, origin_structure.id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
-};
-
-// CuboidalRegion -> SphericalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// CuboidalRegion -> CylindricalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    structure_id_type   new_id(    target_structure.id );
-    position_type       new_pos(   target_structure->project_point(old_pos).first );
-    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
-        // the distance of the projection of old_pos on target_structure to target_structure
-    
-    if(proj_dist < 0){ // if projection of old_pos is in structure
-     
-          return std::make_pair( new_pos, new_id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
-    
-};
-
-// CuboidalRegion -> DiskSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    structure_id_type   new_id(    target_structure.id );
-    position_type       new_pos(   target_structure->project_point(old_pos).first );
-    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
-        // the distance of the projection of old_pos on target_structure to target_structure
-    
-    if(proj_dist < 0){ // if projection of old_pos is in structure
-     
-          return std::make_pair( new_pos, new_id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
-};
-
-// CuboidalRegion -> PlanarSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    structure_id_type   new_id(    target_structure.id );
-    position_type       new_pos(   target_structure->project_point(old_pos).first );
-    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
-        // the distance of the projection of old_pos on target_structure to target_structure
-    
-    if(proj_dist < 0){ // if projection of old_pos is in structure
-     
-          return std::make_pair( new_pos, new_id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
-};
-
-/********************************/
-/* Coming from SphericalSurface */
-/********************************/
-// SphericalSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// SphericalSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// SphericalSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// SphericalSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// SphericalSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-/**********************************/
-/* Coming from CylindricalSurface */
-/**********************************/
-// CylindricalSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-    
-    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
-    position_type new_pos( add(old_pos, displacement) );    
-    // TODO assert that new_pos is in target_structure
-    
-    return std::make_pair(new_pos, target_structure.id);
-};
-
-// CylindricalSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // Currently only species change and decay are supported
-    if(origin_structure.id == target_structure.id){
-     
-          return std::make_pair( old_pos, origin_structure.id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
-};
-
-// CylindricalSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// CylindricalSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    structure_id_type   new_id(    target_structure.id );
-    position_type       new_pos(   target_structure->project_point(old_pos).first );
-    length_type         proj_dist( target_structure->project_point(old_pos).second.second );
-        // the distance of the projection of old_pos on target_structure to target_structure
-    
-    if(proj_dist < 0){ // if projection of old_pos is in structure
-     
-          return std::make_pair( new_pos, new_id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
-};
-
-// CylindricalSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-/***************************/
-/* Coming from DiskSurface */
-/***************************/
-// DiskSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
-    position_type new_pos( add(old_pos, displacement) );
-    // TODO assert that new_pos is in target_structure
-    
-    return std::make_pair(new_pos, target_structure.id);
-};
-
-// DiskSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// DiskSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
-    
-    // When a particle is dissociation from a disk to the cylinder, the direction is randomized
-    Real r( rng.uniform(0.,1.));    
-    Real rs( r < 0.5 ? -1.0 : +1.0 );
-    position_type new_pos( add(old_pos, multiply(rs, displacement)) );
-    // TODO assert that new_pos is in target_structure
-    
-    return std::make_pair(new_pos, target_structure.id);
-};
-
-// DiskSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // Currently only species change and decay are supported
-    if(origin_structure.id == target_structure.id){
-     
-          return std::make_pair( old_pos, origin_structure.id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");    
-};
-
-// DiskSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-/*****************************/
-/* Coming from PlanarSurface */
-/*****************************/
-// PlanarSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  CuboidalRegion<Ttraits_>              const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    position_type displacement( origin_structure->surface_dissociation_vector(rng, offset, reaction_length) );
-    position_type new_pos( add(old_pos, displacement) );
-    // TODO assert that new_pos is in target_structure
-    
-    return std::make_pair(new_pos, target_structure.id);
-};
-
-// PlanarSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  SphericalSurface<Ttraits_>            const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// PlanarSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  CylindricalSurface<Ttraits_>          const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// PlanarSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  DiskSurface<Ttraits_>                 const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(position_type(), structure_id_type());
-};
-
-// PlanarSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
-                  PlanarSurface<Ttraits_>               const& target_structure,
-                  typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
-                  typename Ttraits_::length_type        const& reaction_length,
-                  typename Ttraits_::rng_type           const& rng              )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // Currently only species change and decay are supported
-    if(origin_structure.id == target_structure.id){
-     
-          return std::make_pair( old_pos, origin_structure.id );
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
-};
-
-
-/******************************************************************************************/
-
-
-/*************************/
-/*** TWO NEW POSITIONS ***/
-/*************************/
-
-/******************************/
-/* Coming from CuboidalRegion */
-/******************************/
-// CuboidalRegion -> CuboidalRegion
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
-                       CuboidalRegion<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // Currently we do not allow for pair forward/backward reactions between two different cubes
-    if(origin_structure.id == target_structure.id){
-     
-        structure_id_type new_sid( origin_structure.id );
-        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
-        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
-        // the type of origin_structure and the properties of the two product species
-        // (the displacements from old_pos are weighted by the diffusion constants)
-            
-        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
-                                    std::make_pair(new_positions.second, new_sid)    );          
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
-};
-
-// CuboidalRegion -> SphericalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// CuboidalRegion -> CylindricalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-    
-};
-
-// CuboidalRegion -> DiskSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// CuboidalRegion -> PlanarSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_structure,
-                       PlanarSurface<Ttraits_>                const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-/********************************/
-/* Coming from SphericalSurface */
-/********************************/
-// SphericalSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
-                       CuboidalRegion<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// SphericalSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// SphericalSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// SphericalSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// SphericalSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_structure,
-                       PlanarSurface<Ttraits_>                const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-/**********************************/
-/* Coming from CylindricalSurface */
-/**********************************/
-// CylindricalSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       CuboidalRegion<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    std::pair<position_type, position_type> new_positions( origin_structure->special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
-    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
-    // the types of origin_structure and target_structure and the properties of the two product species
-    // (the displacements from old_pos are weighted by the diffusion constants);
-    // the first pair entry is the particle staying on the surface, the second entry the particle
-    // that goes into the bulk
-            
-    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id),
-                                std::make_pair(new_positions.second, target_structure.id)    );  
-};
-
-// CylindricalSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // Currently we do not allow for pair forward/backward reactions between two different cylinders
-    if(origin_structure.id == target_structure.id){
-     
-        structure_id_type new_sid( origin_structure.id );
-        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
-        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
-        // the type of origin_structure and the properties of the two product species
-        // (the displacements from old_pos are weighted by the diffusion constants)
-            
-        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
-                                    std::make_pair(new_positions.second, new_sid)    );          
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
-};
-
-// CylindricalSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// CylindricalSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// CylindricalSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_structure,
-                       PlanarSurface<Ttraits_>                const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-/***************************/
-/* Coming from DiskSurface */
-/***************************/
-// DiskSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       CuboidalRegion<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    std::pair<position_type, position_type> new_positions( origin_structure->special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
-    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
-    // the types of origin_structure and target_structure and the properties of the two product species
-    // (the displacements from old_pos are weighted by the diffusion constants);
-    // the first pair entry is the particle staying on the surface, the second entry the particle
-    // that goes into the bulk
-            
-    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id),
-                                std::make_pair(new_positions.second, target_structure.id)    );
-};
-
-// DiskSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// DiskSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // TODO TODO TODO
-    // IMPLEMENT THE UNBINDING FROM THE DISK ACTING AS A SINK!
-    
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// DiskSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// DiskSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_structure,
-                       PlanarSurface<Ttraits_>                const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-/*****************************/
-/* Coming from PlanarSurface */
-/*****************************/
-// PlanarSurface -> CuboidalRegion
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       CuboidalRegion<Ttraits_>               const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-    
-    std::pair<position_type, position_type> new_positions( origin_structure->special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
-    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
-    // the types of origin_structure and target_structure and the properties of the two product species
-    // (the displacements from old_pos are weighted by the diffusion constants);
-    // the first pair entry is the particle staying on the surface, the second entry the particle
-    // that goes into the bulk
-            
-    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id),
-                                std::make_pair(new_positions.second, target_structure.id)    );    
-};
-
-// PlanarSurface -> SphericalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       SphericalSurface<Ttraits_>             const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// PlanarSurface -> CylindricalSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       CylindricalSurface<Ttraits_>           const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// PlanarSurface -> DiskSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       DiskSurface<Ttraits_>                  const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
-};
-
-// PlanarSurface -> PlanarSurface
-template <typename Ttraits_>
-std::pair< std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>, 
-                  std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> >
-get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_structure,
-                       PlanarSurface<Ttraits_>                const& target_structure,
-                       typename Ttraits_::position_type       const& old_pos,
-                       typename Ttraits_::species_type        const& s_orig,
-                       typename Ttraits_::species_type        const& s_targ,
-                       typename Ttraits_::length_type         const& reaction_length,
-                       typename Ttraits_::rng_type            const& rng                )
-{
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // As a default we produce two new positions on the same plane; in principle the particles can end up
-    // on different planes, but this should be treated afterwards via apply_boundary.
-    // TODO: Move apply_boundary into structure functions?
-    if(origin_structure.id == target_structure.id){
-     
-        structure_id_type new_sid( origin_structure.id );
-        std::pair<position_type, position_type> new_positions( origin_structure->geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
-        // geminate_dissociation_positions will produce two new positions close to old_pos taking into account
-        // the type of origin_structure and the properties of the two product species
-        // (the displacements from old_pos are weighted by the diffusion constants)
-            
-        return std::make_pair(      std::make_pair(new_positions.first,  new_sid),
-                                    std::make_pair(new_positions.second, new_sid)    );          
-    }
-    else // structure transition not allowed
-      
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
-};
-
-/******************************************************************************************************/
-} // namespace
-
-#endif /* STRUCTUREFUNCTIONS_CPP */
-

From b3e10bc3d85c5b5df3d525cea31173e0ed0d4f9d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 27 Jul 2012 12:25:25 +0200
Subject: [PATCH 1020/1541] Some temporary additional testing/debugging output

---
 multi.py            |  3 ++-
 newBDPropagator.hpp | 10 ++++++----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/multi.py b/multi.py
index a2aa0730..dfe35e4e 100644
--- a/multi.py
+++ b/multi.py
@@ -34,7 +34,8 @@ def initialize(self, t):
         self.start_time = t
         main = self.main()
         self.set_dt_and_reaction_length()
-        #print "Multi intit, dt = %s, rl = %s" %(self.dt,self.reaction_length)
+        # DEBUG stuff
+        print "Multi intit, dt = %s, rl = %s" %(self.dt,self.reaction_length) # TESTING
         #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index bee35df2..555e4bf3 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -205,6 +205,7 @@ class newBDPropagator
             // restore old position and structure_id
             new_pos = old_pos;
             new_structure_id = old_struct_id;
+            LOG_DEBUG( ("particle bounced, restoring old position and structure id.") ); // TESTING
             
             // re-get the reaction partners (particles), now on old position.
             boost::scoped_ptr<particle_id_pair_and_distance_list> overlap_particles_after_bounce( 
@@ -217,10 +218,11 @@ class newBDPropagator
             // re-get the reaction partners (structures), now on old position.
             boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_after_bounce( 
                     tx_.check_surface_overlap( particle_shape_type( old_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0) );
-            overlap_structures.swap( overlap_structures_after_bounce );     // FIXME is there no better way?
+            overlap_structures.swap( overlap_structures_after_bounce );   // FIXME is there no better way?
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
-            structures_in_overlap = overlap_structures ? overlap_structures->size(): 0; 
+            structures_in_overlap = overlap_structures ? overlap_structures->size(): 0;
+            LOG_DEBUG( ("structures_in_overlap = %g", structures_in_overlap) ); // TESTING
         }
         
 
@@ -234,7 +236,6 @@ class newBDPropagator
         //// 5.1 INTERACTIONS WITH STRUCTURES
         // First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction.
         // TODO Rework this using the new structure functions?
-        // TODO Also an interaction should be allowed when a particle is on a cylinder. // Is that not yet the case???
         // TODO Don't check only the closest but check all overlapping surfaces.
         j = 0;
         while(j < structures_in_overlap)
@@ -290,7 +291,8 @@ class newBDPropagator
 
             species_type s0(pp_species);
             species_type s1(tx_.get_species(overlap_particle.first.second.sid()));
-                
+
+            // TODO Remove this if everything works fine!
 /*            // If the structure_types of the reactants are not equal, one of the reactants has to come from the bulk,
             // and we let this be s1, the particle from the surface is named s0.
             if(s0.structure_type_id() != s1.structure_type_id())

From c9e0cbb15775368e40babba8021b7686bd236d2a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 27 Jul 2012 12:31:07 +0200
Subject: [PATCH 1021/1541] Readability and comments in Multi.hpp

---
 Multi.hpp | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 82585f6d..702f8029 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -333,28 +333,37 @@ class MultiParticleContainer
         Real k_max(0.);
         int i = 0, j= 0;
         
+        // Rates for surface/structure interactions
         BOOST_FOREACH(particle_id_pair pp, get_particles_range())
         {
+            // s = species of the current particle
             species_type const s( get_species(pp.second.sid()) );
-            const boost::scoped_ptr<const structure_id_pair_and_distance_list> close_struct_id_distance (
+            
+            const boost::scoped_ptr<const structure_id_pair_and_distance_list>   close_struct_id_distance (
                 get_close_structures(pp.second.position(), pp.second.structure_id(), pp.second.structure_id()) );
-            const std::pair<boost::shared_ptr<structure_type>, length_type> strc_and_dist (
+                
+            const std::pair<boost::shared_ptr<structure_type>, length_type>   struct_and_dist (
                 close_struct_id_distance ? std::make_pair(close_struct_id_distance->at(0).first.second, close_struct_id_distance->at(0).second)
                                          : std::make_pair(get_structure(pp.second.structure_id()), std::numeric_limits<length_type>::max()));
-//            structure_id_and_distance_pair const strc_id_and_dist( 
+                                         
+//            structure_id_and_distance_pair const struct_id_and_dist( 
 //                get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
-                
-            if( strc_and_dist.second < 2.0 * s.radius() && s.structure_type_id() == get_def_structure_type_id() )
+            
+            // If structure is within specified range and this particle lives in the default structure
+            // TODO Extend the last requirement to all "allowed" interactions using the new structure functions
+            if( struct_and_dist.second < 2.0 * s.radius() && s.structure_type_id() == get_def_structure_type_id() )
             {
-                structure_type_id_type const strc_sid( strc_and_dist.first->sid() );
-                reaction_rules const& rrules(rules.query_reaction_rule( s.id(), strc_sid ));
+                // Get the reaction rule for this particle-structure interaction
+                structure_type_id_type const struct_sid( struct_and_dist.first->sid() );
+                reaction_rules const& rrules(rules.query_reaction_rule( s.id(), struct_sid ));
                 if (::size(rrules) == 0)
                     continue;
 
+                // If there is rules, determine the largest on-rate for this interaction
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
-                    Real const k( strc_and_dist.first->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
+                    Real const k( struct_and_dist.first->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
 
                     if ( k_max < k )
                         k_max = k;
@@ -366,6 +375,7 @@ class MultiParticleContainer
         //Since surface rates are not devided by 2 to compensate for double reaction attempts.
         k_max *= 2.0;
         
+        // Rates for particle-particle interactions
         BOOST_FOREACH(species_type s0, get_species_in_multi())
         {
             j = 0;

From b47ce171bb0a8b452447e1616713249fcd5275d9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 27 Jul 2012 15:48:56 +0200
Subject: [PATCH 1022/1541] De-randomize unbinding from planes in BD mode

Particles now unbind into the direction of the plane's unit_z
vector.
---
 PlanarSurface.hpp | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 353a98db..88625a93 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -87,13 +87,16 @@ class PlanarSurface
         length_type r01_sq( r01 * r01 );
 
         return M_PI * ( r01l_sq - r01_sq );
+        // TODO Is there a correction factor if binding is allowed from both sides of the planes?
     }
     
     // Reaction volume for binding to the structure
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
-        //factor 2 because surface has two possible reaction sides due to cyclic BCn.
-        return 2*rl; // FIXME because we reject the above constraint at some point
+        // Assuming binding from one side only (the one that unit_z points towards)
+        // If binding occurs from two sides, this has to be changed to 2*rl and 
+        // unbinding (surface_dissociation_vector) has to be randomized, too.
+        return rl;
     }
     
     // Vector of dissociation from the structure to parent structure
@@ -102,7 +105,7 @@ class PlanarSurface
         Real X( rng.uniform(0.,1.) );
         length_type diss_vec_length( X*rl );
 
-        return multiply( base_type::shape().unit_z(), (rng.uniform_int(0, 1) * 2 - 1) * diss_vec_length );
+        return multiply( base_type::shape().unit_z(), diss_vec_length );
     }
     
     // Normed direction of dissociation from the structure to parent structure
@@ -144,21 +147,25 @@ class PlanarSurface
         //Real theta_max( M_PI/2 - asin(s_bulk.radius() / ( r01 )) );
         //theta_max = theta_max < 0 ? 0 : theta_max;
         
+        // Create random angles for later construction of randomly oriented vector
         Real const theta( rng.uniform(0.,1.) * M_PI );        
         Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
         
+        // Construct dissociation length
         Real const X( rng.uniform(0.,1.) );
         length_type const r01l( r01 + rl );
         length_type const r01l_cb( r01l * r01l * r01l );
         length_type const r01_cb( r01 * r01 * r01 );
         
-        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );   
+        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );                  
         
-        position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
-        unit_z = normalize ( unit_z );  // TODO unit_z is already defined, don't have to do a cross product
-        
-        //unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
+        position_type unit_z = base_type::shape().unit_x();
+        // Old version for binding from both plane sides; TODO Remove this once everything is fine
+        // position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
+        // unit_z = normalize ( unit_z );        
+        // unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
         
+        // Construct randomly oriented dissociation vector
         length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
         length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
         length_type const z( diss_vec_length * cos( theta ) );

From b5fda51b9a47ca1ced55454a4946ba244d4fd540 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 27 Jul 2012 17:44:01 +0200
Subject: [PATCH 1023/1541] Invert unit vectors of planes that make up the box

Now they point inwards, ensuring that dissociation in BD mode goes
into this direction.
---
 gfrdbase.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index f659dc73..57ef13d1 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -200,12 +200,12 @@ def create_box(world, structure_type, center, size):
     name = 'box'
     def_struct_id = world.get_def_structure_id()
     
-    front  = model.create_planar_surface(sid, name+'_front', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
-    back   = model.create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
-    right  = model.create_planar_surface(sid, name+'_right', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
-    left   = model.create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
-    top    = model.create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
-    bottom = model.create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
+    front  = model.create_planar_surface(sid, name+'_front', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
+    back   = model.create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
+    right  = model.create_planar_surface(sid, name+'_right', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
+    left   = model.create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
+    top    = model.create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
+    bottom = model.create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
     world.add_structure(front)
     world.add_structure(back)
     world.add_structure(right)

From 1608cf44b1f42367e37129902fc762f42c969750 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 27 Jul 2012 18:06:21 +0200
Subject: [PATCH 1024/1541] Remove template definition from Structure.hpp

---
 Structure.hpp | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/Structure.hpp b/Structure.hpp
index 23b28f65..5eb4e249 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -175,10 +175,6 @@ class Structure
                                                         length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
-    // The template function that defines the actual final dispatch procedure.
-//     template<typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-//                                                             length_type const& offset, length_type const& rl, rng_type& rng) const;
     // *** 2 *** - Producing two new positions
     // First dispatch
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
@@ -195,10 +191,6 @@ class Structure
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(PlanarSurface<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;                                                                          
-    // The template function that defines the actual final dispatch procedure.
-//     template<typename Tstruct_>
-//     position_structid_pair_pair_type get_pos_sid_pair_pair_helper_any(Tstruct_ const& origin_structure, position_type const& position,
-//                                                                       species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const;
     
     // *** 3 *** - Pair reactions => two origin structures
     // The following functions handle the case of two origin structures.
@@ -229,10 +221,6 @@ class Structure
                                                                             length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                             length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
-    // The template function that defines the actual final dispatch procedure.
-//     template<typename Tstruct_>
-//     position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-//                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const;
     
     // Some further helper functions used by template<typename Tstruct_> get_pos_sid_pair_helper_two_origins_any(...),
     // which is the final dispatch template defined in each of the derived classes and makes use of the two following checker functions:

From 501f021f1080ec936699de2071b66da8842a791d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 27 Jul 2012 18:45:15 +0200
Subject: [PATCH 1025/1541] Fix connection of structures at box creation

---
 gfrdbase.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 57ef13d1..ce55fa4f 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -212,18 +212,18 @@ def create_box(world, structure_type, center, size):
     world.add_structure(left)
     world.add_structure(top)
     world.add_structure(bottom)
-    world.connect_structures( front, 0, top, 1)
-    world.connect_structures( front, 1, bottom, 2)
-    world.connect_structures( front, 2, left, 1)
-    world.connect_structures( front, 3, right, 2)
-    world.connect_structures(  back, 0, right, 3)
-    world.connect_structures(  back, 1, left, 0)
-    world.connect_structures(  back, 2, bottom, 3)
-    world.connect_structures(  back, 3, top, 0)
-    world.connect_structures(   top, 2, left, 3)
-    world.connect_structures(   top, 3, right, 0)
-    world.connect_structures(bottom, 0, right, 1)
-    world.connect_structures(bottom, 1, left, 2)
+    world.connect_structures( front, 3, top, 2)
+    world.connect_structures( front, 2, bottom, 1)
+    world.connect_structures( front, 1, left, 2)
+    world.connect_structures( front, 0, right, 1)
+    world.connect_structures(  back, 3, right, 0)
+    world.connect_structures(  back, 2, left, 3)
+    world.connect_structures(  back, 1, bottom, 0)
+    world.connect_structures(  back, 0, top, 3)
+    world.connect_structures(   top, 1, left, 0)
+    world.connect_structures(   top, 0, right, 3)
+    world.connect_structures(bottom, 3, right, 2)
+    world.connect_structures(bottom, 2, left, 1)
 
 
 def create_network_rules_wrapper(model):

From 5493cad2980a5a6e32dc3083491e2b58b3180e1d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 30 Jul 2012 15:50:43 +0200
Subject: [PATCH 1026/1541] Fix a cast to int that prevented correct overlap
 checking in new BD propagator

... and introduce some temporary debug output for testing (to be
removed later).
---
 newBDPropagator.hpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 555e4bf3..4061b834 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -191,7 +191,7 @@ class newBDPropagator
             boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_tmp(
                 tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, new_structure_id, r0, old_struct_id));
             overlap_structures.swap(overlap_structures_tmp);
-            int structures_in_overlap(overlap_structures ? overlap_structures->size(): 0);
+            structures_in_overlap = (int)(overlap_structures ? overlap_structures->size(): 0);
  
             j = 0;
             while(!bounced && j < structures_in_overlap)
@@ -214,6 +214,7 @@ class newBDPropagator
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
             particles_in_overlap = overlap_particles ? overlap_particles->size(): 0; 
+            LOG_DEBUG( ("particles_in_overlap = %g", particles_in_overlap) ); // TESTING
             
             // re-get the reaction partners (structures), now on old position.
             boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_after_bounce( 
@@ -221,7 +222,7 @@ class newBDPropagator
             overlap_structures.swap( overlap_structures_after_bounce );   // FIXME is there no better way?
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
-            structures_in_overlap = overlap_structures ? overlap_structures->size(): 0;
+            structures_in_overlap = (int)(overlap_structures ? overlap_structures->size(): 0);
             LOG_DEBUG( ("structures_in_overlap = %g", structures_in_overlap) ); // TESTING
         }
         
@@ -251,6 +252,7 @@ class newBDPropagator
                 accumulated_prob += k_total( pp.second.sid(), overlap_struct.first.second->sid() ) * dt_ / 
                                     overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ );
         
+                LOG_DEBUG( ("check for surface interaction, acc_prob = %g", accumulated_prob) ); // TESTING
                 if(accumulated_prob >= 1.) // sth. is wrong in this case
                 {
                     LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one; %f.",
@@ -258,7 +260,8 @@ class newBDPropagator
                 }
                 
                 if( accumulated_prob > rnd ) // OK, try to fire the interaction
-                {            
+                {   
+                    LOG_DEBUG( ("attempting surface interaction, acc_prob = %g", accumulated_prob) ); // TESTING
                     try
                     {
                         LOG_DEBUG( ("fire surface interaction with surface %s.",

From a79bc73d7379224772c5a603b025bad426f96432 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 30 Jul 2012 15:51:47 +0200
Subject: [PATCH 1027/1541] Style

---
 Multi.hpp | 2 +-
 multi.py  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 702f8029..0d767e0a 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -372,7 +372,7 @@ class MultiParticleContainer
             
         }
         
-        //Since surface rates are not devided by 2 to compensate for double reaction attempts.
+        // since surface rates are not devided by 2 to compensate for double reaction attempts.
         k_max *= 2.0;
         
         // Rates for particle-particle interactions
diff --git a/multi.py b/multi.py
index dfe35e4e..bcf24ef0 100644
--- a/multi.py
+++ b/multi.py
@@ -35,7 +35,7 @@ def initialize(self, t):
         main = self.main()
         self.set_dt_and_reaction_length()
         # DEBUG stuff
-        print "Multi intit, dt = %s, rl = %s" %(self.dt,self.reaction_length) # TESTING
+        print "Multi init, dt = %s, rl = %s" %(self.dt,self.reaction_length) # TESTING
         #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):

From cc22889d5c9f3c38f1bc6acaf31323b125d2301b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 31 Jul 2012 16:09:29 +0200
Subject: [PATCH 1028/1541] Define a (Python) function that creates a capped
 rod and adds it to the world automatically

---
 gfrdbase.py | 74 +++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 72 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index ce55fa4f..3ae5e48c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -27,6 +27,7 @@
     'NoSpace',
     'create_world',
     'create_box',
+    'create_rod',
     'ParticleSimulatorBase',
     'get_all_surfaces',
     'get_neighbor_surfaces',
@@ -186,8 +187,9 @@ def create_world(m, matrix_size=10):
     return world
 
 def create_box(world, structure_type, center, size):
-    # Creates a box of PlanarSurface sections and adds it to the world.
-    # size is a vector in x, y, z
+    """ Creates a box of PlanarSurface sections and adds it to the world.
+        Argument size is a vector in x, y, z
+    """
 
     # assert that the center and size is ok
     center = numpy.array(center)
@@ -225,6 +227,74 @@ def create_box(world, structure_type, center, size):
     world.connect_structures(bottom, 3, right, 2)
     world.connect_structures(bottom, 2, left, 1)
 
+def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length):
+    """ Creates a cylinder with two disk-caps at its ends and adds it to the world.
+
+        The function ensures that the orientation vectors of the disks point
+        outwards, i.e. away from the cylinder center.
+
+        It returns a structure id which is the structure id of the cylindrical
+        surface. This can be used to create further sub-structures of the rod,
+        i.e. a disk acting as a sink on the rod.
+
+        Arguments:
+            - world
+                the world that the geometry is constructed in
+            - cyl_structure_type
+                the structure type of the cylinder;
+                this is relevant to properly define interactions
+            - cap_structure_type
+                the structure type of the disks representing the caps;
+                this is relevant to properly define interactions
+            - name
+                name of the rod; names of the sub-components will
+                be created from this
+            - position
+                the 3D position vector from which the rod is 
+                constructed; note: this is not the center, but one
+                of the cylinder ends
+            - radius
+                the rod radius; affects both the cylinder and the
+                cap disks
+            - orientation
+                a 3D vector defining the the rod orientation
+            - length
+                the rod length
+    """    
+    # assert that the location and size is ok
+    position = numpy.array(position)
+    orientation = numpy.array(orientation)
+    assert all(0 < position) and all(position < world.world_size)
+    assert (radius < world.world_size/2)
+    assert (length < world.world_size)
+
+    # Some abbreviations
+    cyl_sid       = cyl_structure_type.id
+    cap_sid       = cap_structure_type.id
+    def_struct_id = world.get_def_structure_id()
+    p = position
+    o = orientation
+    l = length
+
+    # Create the cylinder of the rod
+    rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', position, radius, orientation, length, def_struct_id)
+    print rod
+
+    # Create the caps
+    #front_cap_pos = [c[0]+(l/2)*o[0], c[1]+(l/2)*o[1], c[2]+(l/2)*o[2]]
+    front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
+    front_cap = model.create_disk_surface(cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, def_struct_id)
+
+    #back_cap_pos = [c[0]-(l/2)*o[0], c[1]-(l/2)*o[1], c[2]-(l/2)*o[2]]
+    back_cap_pos = p
+    back_cap = model.create_disk_surface(cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], def_struct_id)
+
+    # Add the new structures to the world
+    world.add_structure(rod)
+    world.add_structure(front_cap)
+    world.add_structure(back_cap)
+
+    return rod.id
 
 def create_network_rules_wrapper(model):
     return _gfrd.NetworkRulesWrapper(model.network_rules)

From 07df52366994b3b799fa30cf22fb1d0d07de0db6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 31 Jul 2012 16:11:00 +0200
Subject: [PATCH 1029/1541] Cleanup

---
 gfrdbase.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 3ae5e48c..708a7ba1 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -261,7 +261,7 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
             - length
                 the rod length
     """    
-    # assert that the location and size is ok
+    # Assert that the location and size is ok
     position = numpy.array(position)
     orientation = numpy.array(orientation)
     assert all(0 < position) and all(position < world.world_size)
@@ -281,12 +281,10 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
     print rod
 
     # Create the caps
-    #front_cap_pos = [c[0]+(l/2)*o[0], c[1]+(l/2)*o[1], c[2]+(l/2)*o[2]]
     front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
     front_cap = model.create_disk_surface(cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, def_struct_id)
 
-    #back_cap_pos = [c[0]-(l/2)*o[0], c[1]-(l/2)*o[1], c[2]-(l/2)*o[2]]
-    back_cap_pos = p
+    back_cap_pos = position
     back_cap = model.create_disk_surface(cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], def_struct_id)
 
     # Add the new structures to the world

From 73442792b567da8d5f73628b1408cc0f4cb96175 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 31 Jul 2012 16:25:11 +0200
Subject: [PATCH 1030/1541] docstring for create_box

---
 gfrdbase.py | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 708a7ba1..97c3c02c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -188,10 +188,20 @@ def create_world(m, matrix_size=10):
 
 def create_box(world, structure_type, center, size):
     """ Creates a box of PlanarSurface sections and adds it to the world.
-        Argument size is a vector in x, y, z
+
+        Arguments:
+            - world
+                the world that the geometry is constructed in
+            - structure_type
+                the structure type of the planar surfaces that make up
+                the box
+            - center
+                a 3D vector defining the center of the box
+            - size
+                a 3D vector defining the box extensions
     """
 
-    # assert that the center and size is ok
+    # Assert that the center and size is ok
     center = numpy.array(center)
     size   = numpy.array(size)
     assert all(0 < center) and all(center < world.world_size)
@@ -202,6 +212,7 @@ def create_box(world, structure_type, center, size):
     name = 'box'
     def_struct_id = world.get_def_structure_id()
     
+    # Create the planes and add them to the world
     front  = model.create_planar_surface(sid, name+'_front', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
     back   = model.create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
     right  = model.create_planar_surface(sid, name+'_right', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
@@ -214,6 +225,9 @@ def create_box(world, structure_type, center, size):
     world.add_structure(left)
     world.add_structure(top)
     world.add_structure(bottom)
+
+    # Update the connectivity container
+    # This has to follow the plane side convention strictly!
     world.connect_structures( front, 3, top, 2)
     world.connect_structures( front, 2, bottom, 1)
     world.connect_structures( front, 1, left, 2)

From 8a9fc0b25f9a8b71f7092bc77e05132cab1d97ec Mon Sep 17 00:00:00 2001
From: jintram <jintram@jintram-Aspire-7745G.(none)>
Date: Mon, 13 Aug 2012 12:30:53 +0200
Subject: [PATCH 1031/1541] __init__ method called stuff in wrong order; fixed
 now. wq

---
 shells.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index 1462e313..44ec44b1 100755
--- a/shells.py
+++ b/shells.py
@@ -311,6 +311,12 @@ class testMixedPair2D3D(testPair):
 
     def __init__(self, single2D, single3D):
 
+        # First define 
+        # for clarity:
+        self.structure2D = single2D.structure   # equal to self.structure1
+        self.structure3D = single3D.structure   # equal to self.structure2
+
+        # These methods need above definitions.
         if __debug__: 
                 assert isinstance(single2D.structure, PlanarSurface) 
                 assert isinstance(single3D.structure, CuboidalRegion)
@@ -318,10 +324,6 @@ def __init__(self, single2D, single3D):
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
           #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
 
-        # for clarity:
-        self.structure2D = single2D.structure   # equal to self.structure1
-        self.structure3D = single3D.structure   # equal to self.structure2
-
     def get_sigma(self):
         # rescale sigma to correct for the rescaling of the coordinate system
         # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly

From cc8358cbb1d50caea0427588f9069d1642f1bdc7 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <Jintram@Gmail.com>
Date: Mon, 13 Aug 2012 14:31:35 +0200
Subject: [PATCH 1032/1541] More __init__ definitions that were incorrectly
 placed; fixed.

---
 pair.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index fce04d31..049d05d8 100644
--- a/pair.py
+++ b/pair.py
@@ -797,13 +797,15 @@ class MixedPair2D3D(Pair, hasCylindricalShell):
 
     def __init__(self, domain_id, shell_id, testShell, rrs):
 
+        # Some definitions (which are also needed by __init__ functions below)
+        self.structure2D = self.testShell.structure2D   # the surface on which particle1 lives
+        self.structure3D = self.testShell.structure3D   # structure on which both particles live
+
         assert isinstance(testShell, MixedPair2D3DtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         Pair.__init__(self, domain_id, shell_id, rrs)
 
         assert isinstance(self.testShell, testMixedPair2D3D)
-        self.structure2D = self.testShell.structure2D   # the surface on which particle1 lives
-        self.structure3D = self.testShell.structure3D   # structure on which both particles live
 
         # initialize some useful constants
         self.z_scaling_factor = self.testShell.get_scaling_factor()

From 21cb0eee4c8a248b8548ba0e30834173b3344122 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <Jintram@Gmail.com>
Date: Mon, 13 Aug 2012 14:38:32 +0200
Subject: [PATCH 1033/1541] Changed __init__ issues with definitions in whole
 of pair.py.

---
 pair.py | 59 +++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 38 insertions(+), 21 deletions(-)

diff --git a/pair.py b/pair.py
index 049d05d8..6b6f7d10 100644
--- a/pair.py
+++ b/pair.py
@@ -41,11 +41,8 @@ class Pair(ProtectiveDomain, Others):
     CUTOFF_FACTOR = 5.6
 
     def __init__(self, domain_id, shell_id, rrs):
-        ProtectiveDomain.__init__(self, domain_id, shell_id)
-        # Note: for the Others superclass nothing is to be initialized.
-
-        assert self.testShell       # assume that the testShell exists
-        assert isinstance(self.testShell, testPair)
+        
+        # Definitions
         self.multiplicity = 2
 
         self.single1 = self.testShell.single1
@@ -63,6 +60,12 @@ def __init__(self, domain_id, shell_id, rrs):
         self.iv    = self.testShell.iv
         self.r0    = self.testShell.r0
         self.sigma = self.testShell.sigma
+        
+        assert self.testShell       # assume that the testShell exists
+        assert isinstance(self.testShell, testPair)
+        
+        ProtectiveDomain.__init__(self, domain_id, shell_id)
+        # Note: for the Others superclass nothing is to be initialized.
 
     def __del__(self):
         if __debug__:
@@ -207,14 +210,15 @@ class SimplePair(Pair):
 
     def __init__(self, domain_id, shell_id, rrs):
 
-        Pair.__init__(self, domain_id, shell_id, rrs)
-
+        # Defintions (also needed by __init__ calls below)
         self.structure = self.testShell.structure # structure on which both particles live
 
         shell_size = self.get_shell_size()                  # FIXME
         self.a_R, self.a_r = self.determine_radii(self.r0, shell_size)
         # set the radii of the inner domains as a function of the outer protective domain
 
+        Pair.__init__(self, domain_id, shell_id, rrs)
+
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
@@ -324,9 +328,12 @@ class SphericalPair(SimplePair, hasSphericalShell):
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
 
+        # Definitions
+        self.LD_MAX = numpy.inf
+
         assert isinstance(testShell, SphericalPairtestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
-        self.LD_MAX = numpy.inf
+        
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
 
     def com_greens_function(self):
@@ -423,9 +430,11 @@ class PlanarSurfacePair(SimplePair, hasCylindricalShell):
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
 
-        assert isinstance(testShell, PlanarSurfacePairtestShell)
-        hasCylindricalShell.__init__(self, testShell, domain_id)
+        # Definitions
         self.LD_MAX = 20
+
+        assert isinstance(testShell, PlanarSurfacePairtestShell)
+        hasCylindricalShell.__init__(self, testShell, domain_id)        
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
     def com_greens_function(self):
@@ -520,14 +529,19 @@ class PlanarSurfaceTransitionPair(SimplePair, hasSphericalShell):
     # do_back_transform() method.
     def __init__(self, domain_id, shell_id, testShell, rrs):
 
+
+        # Definitions
+        self.structure1 = self.testShell.structure1
+        self.structure2 = self.testShell.structure2
+        self.structure  = self.testShell.structure1 # just for safety
+        self.LD_MAX = numpy.inf # TODO was 20. Why? Because of convergence issues! Maybe not really an issue here though
+        
         assert isinstance(testShell, PlanarSurfaceTransitionPairtestShell)
+
         hasSphericalShell.__init__(self, testShell, domain_id)
-        self.LD_MAX = numpy.inf # TODO was 20. Why? Because of convergence issues! Maybe not really an issue here though
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
         
-        self.structure1 = self.testShell.structure1
-        self.structure2 = self.testShell.structure2
-        self.structure  = self.testShell.structure1 # just for safety
+
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
@@ -703,9 +717,12 @@ class CylindricalSurfacePair(SimplePair, hasCylindricalShell):
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
 
+        # Definitions
+        self.LD_MAX = numpy.inf
+
         assert isinstance(testShell, CylindricalSurfacePairtestShell)
+
         hasCylindricalShell.__init__(self, testShell, domain_id)
-        self.LD_MAX = numpy.inf
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
 
@@ -1038,18 +1055,18 @@ class MixedPair1DCap(Pair, hasCylindricalShell):
 
     def __init__(self, domain_id, shell_id, testShell, rrs):
 
+        # Some useful definitions (also needed by __init__ calls below):
+        self.particle1D    = self.testShell.particle1D
+        self.structure1D   = self.testShell.structure1D
+        self.cap_particle  = self.testShell.cap_particle
+        self.cap_structure = self.testShell.cap_structure
+
         assert isinstance(testShell, MixedPair1DCaptestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         Pair.__init__(self, domain_id, shell_id, rrs)
 
         assert isinstance(self.testShell, MixedPair1DCaptestShell)
 
-        # Some useful definitions:
-        self.particle1D    = self.testShell.particle1D
-        self.structure1D   = self.testShell.structure1D
-        self.cap_particle  = self.testShell.cap_particle
-        self.cap_structure = self.testShell.cap_structure
-
         # The latter is defined for completeness and used by check_domain() in egfrd.py:
         self.origin_structure = self.structure1D
         self.target_structure = self.cap_structure

From 5e2032173189d5341f63b30bf256318cef84ae4b Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <Jintram@Gmail.com>
Date: Mon, 13 Aug 2012 16:14:12 +0200
Subject: [PATCH 1034/1541] Seem also to be dependencies other way around in
 __init__s.

Seems to be OK now. Other bugs pop up now.
---
 domain.py | 12 ++++++++
 pair.py   | 83 +++++++++++++++++++++++++++++++++++++++++--------------
 2 files changed, 74 insertions(+), 21 deletions(-)

diff --git a/domain.py b/domain.py
index b5946bc3..d0187bf9 100644
--- a/domain.py
+++ b/domain.py
@@ -17,6 +17,11 @@ class Domain(object):
 # with an own domain_id
 
     def __init__(self, domain_id):
+        # Calls required parent inits and sets variables.
+        #    
+        # Sets:     domain_id, event_id, event_type, last_time, dt
+        # Requires nothing to be set.
+        
         self.domain_id = domain_id      # identifier for this domain object
         self.event_id = None            # identifier for the event coupled to this domain
 
@@ -69,8 +74,15 @@ class ProtectiveDomain(Domain):
 # their shell within a timestep, breaking the principle of a Protective Domain
 
     def __init__(self, domain_id, shell_id):
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:     shell_id, num_shells
+        # Requires nothing to be set.            
+    
+        # Inits parent classes
         Domain.__init__(self, domain_id)
 
+        # Definitions
         self.shell_id = shell_id
 #        self.shell = None
         self.num_shells = 1             # all protective domains have only one shell
diff --git a/pair.py b/pair.py
index 6b6f7d10..3879581e 100644
--- a/pair.py
+++ b/pair.py
@@ -41,6 +41,21 @@ class Pair(ProtectiveDomain, Others):
     CUTOFF_FACTOR = 5.6
 
     def __init__(self, domain_id, shell_id, rrs):
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:     multiplicity, single1, single2, pid_particle_pair1, 
+        #           pid_particle_pair2, structure1, structure2, 
+        #           interparticle_rrs, interparticle_ktot, com, iv, r0,
+        #           sigma
+        #
+        # Requires nothing to be set.
+
+        assert self.testShell       # assume that the testShell exists
+        assert isinstance(self.testShell, testPair)  
+
+        # Call init from parent class(es)
+        ProtectiveDomain.__init__(self, domain_id, shell_id)
+            # Note: for the Others superclass nothing is to be initialized.
         
         # Definitions
         self.multiplicity = 2
@@ -59,13 +74,7 @@ def __init__(self, domain_id, shell_id, rrs):
         self.com   = self.testShell.com
         self.iv    = self.testShell.iv
         self.r0    = self.testShell.r0
-        self.sigma = self.testShell.sigma
-        
-        assert self.testShell       # assume that the testShell exists
-        assert isinstance(self.testShell, testPair)
-        
-        ProtectiveDomain.__init__(self, domain_id, shell_id)
-        # Note: for the Others superclass nothing is to be initialized.
+        self.sigma = self.testShell.sigma              
 
     def __del__(self):
         if __debug__:
@@ -209,15 +218,23 @@ def __str__(self):
 class SimplePair(Pair):
 
     def __init__(self, domain_id, shell_id, rrs):
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:     a_R, a_r, strucutre, shell_size
+        # Requires: r0
 
-        # Defintions (also needed by __init__ calls below)
-        self.structure = self.testShell.structure # structure on which both particles live
-
+        # Definitions that are needed by inits
         shell_size = self.get_shell_size()                  # FIXME
+                
+        # Inits from parent classes 
+        Pair.__init__(self, domain_id, shell_id, rrs)        
+        
+        # Definitions 
         self.a_R, self.a_r = self.determine_radii(self.r0, shell_size)
-        # set the radii of the inner domains as a function of the outer protective domain
+            # set the radii of the inner domains as a function of the outer protective domain
+            # (self.r0 is determined in Pair.__init__)
+        self.structure = self.testShell.structure # structure on which both particles live            
 
-        Pair.__init__(self, domain_id, shell_id, rrs)
 
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
@@ -327,13 +344,18 @@ class SphericalPair(SimplePair, hasSphericalShell):
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
-
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:         LD_MAX
+        # Requires:     nothing to be set
+        
         # Definitions
         self.LD_MAX = numpy.inf
 
         assert isinstance(testShell, SphericalPairtestShell)
         hasSphericalShell.__init__(self, testShell, domain_id)
         
+        # Parent classes
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
 
     def com_greens_function(self):
@@ -429,7 +451,11 @@ class PlanarSurfacePair(SimplePair, hasCylindricalShell):
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
-
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:         LD_MAX
+        # Requires:     Nothing to be set.
+        
         # Definitions
         self.LD_MAX = 20
 
@@ -528,7 +554,10 @@ class PlanarSurfaceTransitionPair(SimplePair, hasSphericalShell):
     # hasSphericalShell instead of hasCylindricalShell and a modified 
     # do_back_transform() method.
     def __init__(self, domain_id, shell_id, testShell, rrs):
-
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:         structure1, strucutre2, structure, LD_MAX
+        # Requires:     nothing to be set
 
         # Definitions
         self.structure1 = self.testShell.structure1
@@ -716,7 +745,11 @@ class CylindricalSurfacePair(SimplePair, hasCylindricalShell):
 
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
-
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:         LD_MAX
+        # Requires:     nothing to be set
+        
         # Definitions
         self.LD_MAX = numpy.inf
 
@@ -813,10 +846,14 @@ def __str__(self):
 class MixedPair2D3D(Pair, hasCylindricalShell):
 
     def __init__(self, domain_id, shell_id, testShell, rrs):
-
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:         structure2D, structure3D, z_scaling_factor, a_R, a_r
+        # Requires:     nothing to be set
+        
         # Some definitions (which are also needed by __init__ functions below)
-        self.structure2D = self.testShell.structure2D   # the surface on which particle1 lives
-        self.structure3D = self.testShell.structure3D   # structure on which both particles live
+        self.structure2D = testShell.structure2D   # the surface on which particle1 lives
+        self.structure3D = testShell.structure3D   # structure on which both particles live
 
         assert isinstance(testShell, MixedPair2D3DtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
@@ -1054,8 +1091,12 @@ class MixedPair1DCap(Pair, hasCylindricalShell):
     # TODO: Is the new pos. of the cap particle sampled correctly in case of a decay event?
 
     def __init__(self, domain_id, shell_id, testShell, rrs):
-
-        # Some useful definitions (also needed by __init__ calls below):
+        # Calls required parent inits and sets variables.
+        #
+        # Sets:             particle1D, structure1D, cap_particle, cap_structure
+        # Requires:         nothing to be set
+        
+        # Some useful definitions 
         self.particle1D    = self.testShell.particle1D
         self.structure1D   = self.testShell.structure1D
         self.cap_particle  = self.testShell.cap_particle

From 88b6e8962063fcef4a0bc13f34b34abe7866e4af Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <Jintram@Gmail.com>
Date: Mon, 13 Aug 2012 18:17:31 +0200
Subject: [PATCH 1035/1541] Only testMixedPair2D3D needed fixing, reverted rest
 to original state. Oops.

---
 pair.py | 77 +++++++++++++++++++++++++++------------------------------
 1 file changed, 37 insertions(+), 40 deletions(-)

diff --git a/pair.py b/pair.py
index 3879581e..82c1d97b 100644
--- a/pair.py
+++ b/pair.py
@@ -50,12 +50,12 @@ def __init__(self, domain_id, shell_id, rrs):
         #
         # Requires nothing to be set.
 
-        assert self.testShell       # assume that the testShell exists
-        assert isinstance(self.testShell, testPair)  
-
         # Call init from parent class(es)
         ProtectiveDomain.__init__(self, domain_id, shell_id)
             # Note: for the Others superclass nothing is to be initialized.
+
+        assert self.testShell       # assume that the testShell exists
+        assert isinstance(self.testShell, testPair)  
         
         # Definitions
         self.multiplicity = 2
@@ -221,19 +221,20 @@ def __init__(self, domain_id, shell_id, rrs):
         # Calls required parent inits and sets variables.
         #
         # Sets:     a_R, a_r, strucutre, shell_size
-        # Requires: r0
+        # Requires: r0, LD_MAX
 
-        # Definitions that are needed by inits
-        shell_size = self.get_shell_size()                  # FIXME
-                
         # Inits from parent classes 
-        Pair.__init__(self, domain_id, shell_id, rrs)        
+        Pair.__init__(self, domain_id, shell_id, rrs) 
         
         # Definitions 
+        self.structure = self.testShell.structure # structure on which both particles live                    
+        
+        shell_size = self.get_shell_size()                  # FIXME                      
+                                                            # Needed by pair.init()?? No?
         self.a_R, self.a_r = self.determine_radii(self.r0, shell_size)
             # set the radii of the inner domains as a function of the outer protective domain
             # (self.r0 is determined in Pair.__init__)
-        self.structure = self.testShell.structure # structure on which both particles live            
+            # determine_radii requires LD_MAX to be set
 
 
     @ classmethod
@@ -347,15 +348,14 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # Calls required parent inits and sets variables.
         #
         # Sets:         LD_MAX
-        # Requires:     nothing to be set
-        
-        # Definitions
-        self.LD_MAX = numpy.inf
+        # Requires:     nothing to be set       
 
         assert isinstance(testShell, SphericalPairtestShell)
-        hasSphericalShell.__init__(self, testShell, domain_id)
         
         # Parent classes
+        hasSphericalShell.__init__(self, testShell, domain_id) 
+
+        self.LD_MAX = numpy.inf # required by simplepair, set_radii           
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
 
     def com_greens_function(self):
@@ -454,13 +454,12 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # Calls required parent inits and sets variables.
         #
         # Sets:         LD_MAX
-        # Requires:     Nothing to be set.
-        
-        # Definitions
-        self.LD_MAX = 20
+        # Requires:     Nothing to be set.       
 
         assert isinstance(testShell, PlanarSurfacePairtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)        
+        
+        self.LD_MAX = 20 # Required by SimplePair.__init__
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
     def com_greens_function(self):
@@ -559,18 +558,17 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # Sets:         structure1, strucutre2, structure, LD_MAX
         # Requires:     nothing to be set
 
-        # Definitions
-        self.structure1 = self.testShell.structure1
-        self.structure2 = self.testShell.structure2
-        self.structure  = self.testShell.structure1 # just for safety
-        self.LD_MAX = numpy.inf # TODO was 20. Why? Because of convergence issues! Maybe not really an issue here though
-        
         assert isinstance(testShell, PlanarSurfaceTransitionPairtestShell)
 
         hasSphericalShell.__init__(self, testShell, domain_id)
+        self.LD_MAX = numpy.inf # TODO was 20. Why? Because of convergence issues! Maybe not really an issue here though
+                                # Required by SimplePair.__init__        
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
-        
 
+        # Definitions
+        self.structure1 = self.testShell.structure1
+        self.structure2 = self.testShell.structure2
+        self.structure  = self.testShell.structure1 # just for safety          
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
@@ -748,14 +746,13 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # Calls required parent inits and sets variables.
         #
         # Sets:         LD_MAX
-        # Requires:     nothing to be set
-        
-        # Definitions
-        self.LD_MAX = numpy.inf
+        # Requires:     nothing to be set        
 
         assert isinstance(testShell, CylindricalSurfacePairtestShell)
 
         hasCylindricalShell.__init__(self, testShell, domain_id)
+
+        self.LD_MAX = numpy.inf # Required by SimplePair.__init__
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
 
@@ -850,16 +847,16 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         #
         # Sets:         structure2D, structure3D, z_scaling_factor, a_R, a_r
         # Requires:     nothing to be set
-        
-        # Some definitions (which are also needed by __init__ functions below)
-        self.structure2D = testShell.structure2D   # the surface on which particle1 lives
-        self.structure3D = testShell.structure3D   # structure on which both particles live
 
         assert isinstance(testShell, MixedPair2D3DtestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         Pair.__init__(self, domain_id, shell_id, rrs)
 
         assert isinstance(self.testShell, testMixedPair2D3D)
+        
+        # Some definitions 
+        self.structure2D = self.testShell.structure2D   # the surface on which particle1 lives
+        self.structure3D = self.testShell.structure3D   # structure on which both particles live
 
         # initialize some useful constants
         self.z_scaling_factor = self.testShell.get_scaling_factor()
@@ -1094,13 +1091,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # Calls required parent inits and sets variables.
         #
         # Sets:             particle1D, structure1D, cap_particle, cap_structure
-        # Requires:         nothing to be set
-        
-        # Some useful definitions 
-        self.particle1D    = self.testShell.particle1D
-        self.structure1D   = self.testShell.structure1D
-        self.cap_particle  = self.testShell.cap_particle
-        self.cap_structure = self.testShell.cap_structure
+        # Requires:         nothing to be set       
 
         assert isinstance(testShell, MixedPair1DCaptestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
@@ -1108,6 +1099,12 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         assert isinstance(self.testShell, MixedPair1DCaptestShell)
 
+        # Some useful definitions 
+        self.particle1D    = self.testShell.particle1D
+        self.structure1D   = self.testShell.structure1D
+        self.cap_particle  = self.testShell.cap_particle
+        self.cap_structure = self.testShell.cap_structure
+
         # The latter is defined for completeness and used by check_domain() in egfrd.py:
         self.origin_structure = self.structure1D
         self.target_structure = self.cap_structure

From 5905f4378a9fe0bda71af44c55fc20060b044008 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <Jintram@Gmail.com>
Date: Mon, 13 Aug 2012 18:48:33 +0200
Subject: [PATCH 1036/1541] Fixed also another bug with origin_structure.

---
 egfrd.py  |  6 +++++-
 pair.py   | 19 +++++++++++++++++--
 shells.py |  4 ++++
 single.py |  2 +-
 4 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1e0c0b35..9bbe5480 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2586,7 +2586,11 @@ def print_report(self, out=None):
     def check_domain(self, domain):
         domain.check()
 
-        # construct ignore list for surfaces and the structures that the domain is associated with
+        # Construct ignore list for surfaces and the structures that the domain is associated with
+        # __
+        # This is necessary because structures which are involved in the 
+        # mathematical solution need to be excluded from the overlap 
+        # check.
         if isinstance(domain, Multi):
             # Ignore all surfaces, multi shells can overlap with 
             # surfaces.
diff --git a/pair.py b/pair.py
index 82c1d97b..894cb0b1 100644
--- a/pair.py
+++ b/pair.py
@@ -755,6 +755,12 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.LD_MAX = numpy.inf # Required by SimplePair.__init__
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
+        # The latter is defined for completeness and used by check_domain() in egfrd.py:
+        # (Note that that origin and target end up in same list.)
+        self.origin_structure = self.testShell.origin_structure
+        self.target_structure = self.testShell.target_structure         
+#        self.origin_structure = self.structure2D
+#        self.target_structure = self.structure2D #TODO: redundant..
 
     def get_shell_size(self):
         return self.shell.shape.half_length
@@ -863,6 +869,13 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
 
         # set the radii of the inner domains as a function of the outer protective domain
         self.a_R, self.a_r = self.determine_radii()
+        
+        # The latter is defined for completeness and used by check_domain() in egfrd.py:
+        # (Note that that origin and target end up in same list.)
+        self.origin_structure = self.testShell.origin_structure
+        self.target_structure = self.testShell.target_structure         
+#        self.origin_structure = self.structure3D
+#        self.target_structure = self.structure2D
 
 
     def determine_radii(self):
@@ -1106,8 +1119,10 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.cap_structure = self.testShell.cap_structure
 
         # The latter is defined for completeness and used by check_domain() in egfrd.py:
-        self.origin_structure = self.structure1D
-        self.target_structure = self.cap_structure
+        self.origin_structure = self.testShell.origin_structure
+        self.target_structure = self.testShell.target_structure         
+#        self.origin_structure = self.structure1D
+#        self.target_structure = self.cap_structure
 
         # The cap_particle should be immobile; check to be sure:
         assert self.cap_particle.D == 0
diff --git a/shells.py b/shells.py
index 44ec44b1..e46aed81 100755
--- a/shells.py
+++ b/shells.py
@@ -323,6 +323,10 @@ def __init__(self, single2D, single3D):
         testPair.__init__(self, single2D, single3D)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
           #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
+          
+        # TODO: modification by Martijn Wehrens (jintram@gmail.com) -- not absolutely sure this is correct place
+        self.origin_structure = self.structure3D
+        self.target_structure = self.structure2D        
 
     def get_sigma(self):
         # rescale sigma to correct for the rescaling of the coordinate system
diff --git a/single.py b/single.py
index 2a6f1e68..d3696cd1 100644
--- a/single.py
+++ b/single.py
@@ -688,7 +688,7 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
 
         self.origin_structure = self.testShell.origin_structure
         self.target_structure = self.testShell.target_structure 
-             # The surface with which the particle is trying to interact
+             # The surface with which the particle is trying to interact                         
 
     def get_interaction_rule(self):
         if self.intrule == None:

From 9592500619c335380bece71c6d10d794f5743f40 Mon Sep 17 00:00:00 2001
From: Martijn Wehrens <Jintram@Gmail.com>
Date: Mon, 13 Aug 2012 19:20:04 +0200
Subject: [PATCH 1037/1541] Fixed classmethods which were trying to return
 self.(..)

Which is impossible because class methods are available without
instantiating objects, so self.(..) can sometimes not exist.
---
 pair.py   | 10 ++++++----
 single.py |  4 ++--
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/pair.py b/pair.py
index 894cb0b1..32ef393a 100644
--- a/pair.py
+++ b/pair.py
@@ -931,7 +931,7 @@ def determine_radii(self):
 
         return a_R, a_r
 
-    @ classmethod
+    @ classmethod 
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, structure3D, unit_z):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
@@ -942,7 +942,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
         weight1 = D1 / D_tot
         weight2 = D2 / D_tot
 
-#        min_iv_z_length = radius2
+#       min_iv_z_length = radius2
         # get a sence of scale of the separation between the particle and the membrane
         min_iv_z_length = (radius1 + radius2) * 0.5 * (MINIMAL_SEPARATION_FACTOR - 1.0)
 
@@ -968,7 +968,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
         pos1 = com - weight1 * (iv_x + iv_y)
         pos2 = com + weight2 * (iv_x + iv_y) + iv_z 
 
-        return pos1, pos2, self.structure2D.id, self.structure2D.id
+        # Class method; so don't use self.(..)
+        return pos1, pos2, structure2D.id, structure2D.id        
 
     @ classmethod
     def calc_z_scaling_factor(cls, D2d, D3d):
@@ -1084,7 +1085,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1D, struc
         pos1 = com - weight1 * iv_z
         pos2 = com + weight2 * iv_z + iv_r
 
-        return pos1, pos2, self.structure1D.id, self.structure1D.id
+        # Class method; so don't use self.(..)
+        return pos1, pos2, structure1D.id, structure1D.id
 
     @ classmethod
     def calc_r_scaling_factor(cls, D1, D2):
diff --git a/single.py b/single.py
index d3696cd1..68fb3e20 100644
--- a/single.py
+++ b/single.py
@@ -436,8 +436,8 @@ def check(self):
         assert self.greens_function
         assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
 
-        assert feq(numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,
-                             self.structure.shape.unit_z), 0.0, typical=self.shell.shape.half_length)
+        assert feq(numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,\
+                    self.structure.shape.unit_z), 0.0, typical=self.shell.shape.half_length)
 
         return True
 

From ce521ec02f3a044a1a1e680f134007baf162b2e6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 16 Aug 2012 15:59:13 +0200
Subject: [PATCH 1038/1541] Add a flag to Makefile.am that allows to capture
 linking errors

In particular, it will capture undefined symbols that otherwise
might compile but cause trouble in runtime.
---
 Makefile.am | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile.am b/Makefile.am
index e057a41e..7fe4268f 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -217,7 +217,7 @@ _greens_functions_la_SOURCES=\
 	Logger.cpp\
 	ConsoleAppender.cpp
 
-_gfrd_la_LDFLAGS = -module -export-dynamic -avoid-version $(no_undefined)
+_gfrd_la_LDFLAGS = -module -export-dynamic -avoid-version $(no_undefined) -Wl,--no-undefined
 _gfrd_la_LIBADD = binding/libbinding_utils.la
 _gfrd_la_LIBADD += $(LIBBOOSTPYTHON) $(LIBPYTHON) $(GSL_LIBS)
 

From 11ec0f0190e08f88d1136dd28a5c402dd44d2682 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Aug 2012 12:37:29 +0200
Subject: [PATCH 1039/1541] Reset accumulated prob. to zero before particle
 reaction check in newBDPropagator

This caused particle reactions and removal of reactants when
a particle overlapped with another one and a surface simultaneously
even if there was no reaction defined between the two particle
species involved.
---
 newBDPropagator.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 4061b834..b9495556 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -288,6 +288,9 @@ class newBDPropagator
         //// 6.1 REACTIONS WITH OTHER PARTICLES
         /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
+        accumulated_prob = 0.0; // has to be reset to zero otherwise the particle will react even
+                                // if the reaction rate is zero!
+                                // TODO Is that correct or should everything be in one loop???
         while(j < particles_in_overlap)
         {
             const particle_id_pair_and_distance & overlap_particle( overlap_particles->at(j) );

From 941cb6d5a7256e7ded5a058469aa8742bb5dfce8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Aug 2012 13:59:58 +0200
Subject: [PATCH 1040/1541] Instead of resetting to zero, reduce acc. prob. by
 last increment when a reaction gets rejected

... treating it as "forbidden" in the first place.
---
 newBDPropagator.hpp | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b9495556..69b908d8 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -231,6 +231,7 @@ class newBDPropagator
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
         Real accumulated_prob (0);
+        Real prob_increase (0);
         Real rnd( rng_() );
         
         const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
@@ -249,8 +250,9 @@ class newBDPropagator
                 (overlap_struct.second < r0 + reaction_length_) &&                  // - within the reaction volume
                 (new_pos_projected.second.second < 0) )                             // - 'alongside' of the particle
             {
-                accumulated_prob += k_total( pp.second.sid(), overlap_struct.first.second->sid() ) * dt_ / 
+                prob_increase = k_total( pp.second.sid(), overlap_struct.first.second->sid() ) * dt_ / 
                                     overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ );
+                accumulated_prob += prob_increase;
         
                 LOG_DEBUG( ("check for surface interaction, acc_prob = %g", accumulated_prob) ); // TESTING
                 if(accumulated_prob >= 1.) // sth. is wrong in this case
@@ -273,6 +275,13 @@ class newBDPropagator
                     {
                         log_.info("surface interaction rejected (reason: %s).", reason.what());
                         ++rejected_move_count_;
+                        // Revert the addition of the prob. increment to avoid that the a reaction will
+                        // fire in the (following) particle overlap loop even if the reaction rate and
+                        // prob. increment zero there.
+                        // Conceptually this means that the prob. for the reaction that was just attempted
+                        // and failed was zero in the first place (due to lack of space).
+                        log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
+                        accumulated_prob -= prob_increase;
                     }
                 }
                 else
@@ -288,9 +297,7 @@ class newBDPropagator
         //// 6.1 REACTIONS WITH OTHER PARTICLES
         /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
-        accumulated_prob = 0.0; // has to be reset to zero otherwise the particle will react even
-                                // if the reaction rate is zero!
-                                // TODO Is that correct or should everything be in one loop???
+        prob_increase = 0;
         while(j < particles_in_overlap)
         {
             const particle_id_pair_and_distance & overlap_particle( overlap_particles->at(j) );
@@ -313,8 +320,9 @@ class newBDPropagator
             }
 */            
             const boost::shared_ptr<const structure_type> s1_struct( tx_.get_structure( overlap_particle.first.second.structure_id()) );
-            accumulated_prob += k_total(s0.id(), s1.id()) * dt_ /
+            prob_increase = k_total(s0.id(), s1.id()) * dt_ /
                                 ( 2. * s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ); 
+            accumulated_prob += prob_increase;
             
             if (accumulated_prob >= 1.)
             {
@@ -335,6 +343,9 @@ class newBDPropagator
                 {
                     log_.info("second-order reaction rejected (reason: %s)", reason.what());
                     ++rejected_move_count_;
+                    // Set the increase to zero a posteriori
+                    log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
+                    accumulated_prob -= prob_increase;
                 }
             }
             else                

From f6a13b7423304d957cae16dbaf8c438ea975253c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Aug 2012 14:56:24 +0200
Subject: [PATCH 1041/1541] Some convenient renaming

Among other changes, overloaded get_pos_sid_pair now is a redirect
to a method with a distinct name to facilitate later python binding.
---
 CuboidalRegion.hpp     | 34 +++++++++++++++++++++-------------
 CylindricalSurface.hpp | 34 +++++++++++++++++++++-------------
 DiskSurface.hpp        | 34 +++++++++++++++++++++-------------
 PlanarSurface.hpp      | 34 +++++++++++++++++++++-------------
 SphericalSurface.hpp   | 34 +++++++++++++++++++++-------------
 Structure.hpp          | 34 ++++++++++++++++++----------------
 6 files changed, 123 insertions(+), 81 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 0808d70e..fe7b9bb3 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -241,41 +241,49 @@ class CuboidalRegion
     };
     
     // *** 3 *** - Pair reactions => two origin structures
+    // First dispatch
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+    {   
+        // this just redirects
+        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+    }
+    // The actual implementation of the first dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
-        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+        return origin_structure2.get_pos_sid_pair_2o_helper(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index faf04e65..70eca263 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -316,41 +316,49 @@ class CylindricalSurface
     };
     
     // *** 3 *** - Pair reactions => two origin structures
+    // First dispatch
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+    {   
+        // this just redirects
+        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+    }
+    // The actual implementation of the first dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
-        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+        return origin_structure2.get_pos_sid_pair_2o_helper(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index b638f21c..cd913e3d 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -329,41 +329,49 @@ class DiskSurface
     };
     
     // *** 3 *** - Pair reactions => two origin structures
+    // First dispatch
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+    {   
+        // this just redirects
+        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+    }
+    // The actual implementation of the first dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
-        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+        return origin_structure2.get_pos_sid_pair_2o_helper(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 88625a93..6e8098d7 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -314,41 +314,49 @@ class PlanarSurface
     };
     
     // *** 3 *** - Pair reactions => two origin structures
+    // First dispatch
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+    {   
+        // this just redirects
+        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+    }
+    // The actual implementation of the first dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
-        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+        return origin_structure2.get_pos_sid_pair_2o_helper(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index f9822dbf..0ada333d 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -205,41 +205,49 @@ class SphericalSurface
     };
     
     // *** 3 *** - Pair reactions => two origin structures
+    // First dispatch
     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
+   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+    {   
+        // this just redirects
+        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+    }
+    // The actual implementation of the first dispatch
+    virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
-        return origin_structure2.get_pos_sid_pair_helper_two_origins(*this, target_sid, CoM, offset, reaction_length, rng);
+        return origin_structure2.get_pos_sid_pair_2o_helper(*this, target_sid, CoM, offset, reaction_length, rng);
     }
     // Second dispatch
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CuboidalRegion<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<SphericalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<CylindricalSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<DiskSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid,
                                                                             position_type const& CoM, length_type const& offset, length_type const& rl, rng_type& rng) const
     {                          
-        return this->get_pos_sid_pair_helper_two_origins_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
+        return this->get_pos_sid_pair_2o_helper_any<PlanarSurface<traits_type> >(origin_structure1, target_sid, CoM, offset, rl, rng);
     }    
     // The template function that defines the actual final dispatch procedure.
     template<typename Tstruct_>
-    position_structid_pair_type get_pos_sid_pair_helper_two_origins_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+    position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
diff --git a/Structure.hpp b/Structure.hpp
index 5eb4e249..771574b3 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -164,7 +164,7 @@ class Structure
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& target_structure, position_type const& position,
                                                          length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     // Second dispatch
-    // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
+    // The helper functions are the dispatch acceptors and have to be declared for each derived structure class because C++ does not support virtual templates.
     virtual position_structid_pair_type get_pos_sid_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                         length_type const& offset, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_type get_pos_sid_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
@@ -180,7 +180,7 @@ class Structure
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair(structure_type const& target_structure, position_type const& position,
                                                                    species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     // Second dispatch
-    // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
+    // The helper functions are dispatch acceptors and have to be declared for each derived structure class because C++ does not support virtual templates.
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(CuboidalRegion<traits_type> const& origin_structure, position_type const& position,
                                                                           species_type const& s_orig, species_type const& s_targ, length_type const& rl, rng_type& rng) const = 0;
     virtual position_structid_pair_pair_type get_pos_sid_pair_pair_helper(SphericalSurface<traits_type> const& origin_structure, position_type const& position,
@@ -204,23 +204,25 @@ class Structure
     //   - in case of equal structure type id's it can end up on either origin structure
     //     and apply_boundary will handle the right placement afterwards.
        
-    // First dispatch, overloading method call structure.get_pos_sid_pair
+    // First dispatch
     // This is called as a method of origin_structure1 with origin_structure2 as an argument.
+    virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
+    // Some convenient method overloading; this is just a redirect to the above                                       
     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;    
+                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     // Second dispatch
-    // This helper function has to be declared for each derived structure class because C++ does not support virtual templates (yet).
-    // It is called as a method of origin_structure2 by origin_structure1 with origin_structure1 as an argument
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
-    virtual position_structid_pair_type get_pos_sid_pair_helper_two_origins(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                                            length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
+    // The helper functions are the dispatch acceptors and have to be declared for each derived structure class because C++ does not support virtual templates.
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(SphericalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CylindricalSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(DiskSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
+    virtual position_structid_pair_type get_pos_sid_pair_2o_helper(PlanarSurface<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
+                                                                   length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     
     // Some further helper functions used by template<typename Tstruct_> get_pos_sid_pair_helper_two_origins_any(...),
     // which is the final dispatch template defined in each of the derived classes and makes use of the two following checker functions:

From 92dab5094272a6393533e22663595136e43cf081 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Aug 2012 15:34:01 +0200
Subject: [PATCH 1042/1541] Disable overloading get_pos_sid_pair to facilitate
 Python binding and introduce basic binding of structure functions

---
 CuboidalRegion.hpp     | 16 ++++++++--------
 CylindricalSurface.hpp | 16 ++++++++--------
 DiskSurface.hpp        | 16 ++++++++--------
 PlanarSurface.hpp      | 16 ++++++++--------
 SphericalSurface.hpp   | 16 ++++++++--------
 Structure.hpp          |  6 +++---
 binding/Structure.hpp  |  3 +++
 newBDPropagator.hpp    |  6 +++---
 8 files changed, 49 insertions(+), 46 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index fe7b9bb3..66fbbb0c 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -242,14 +242,14 @@ class CuboidalRegion
     
     // *** 3 *** - Pair reactions => two origin structures
     // First dispatch
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
-    {   
-        // this just redirects
-        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
-    }
-    // The actual implementation of the first dispatch
+//     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
+//    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+//     {   
+//         // this just redirects
+//         return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+//     }
+//     // The actual implementation of the first dispatch
     virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 70eca263..6faa2987 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -317,14 +317,14 @@ class CylindricalSurface
     
     // *** 3 *** - Pair reactions => two origin structures
     // First dispatch
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
-    {   
-        // this just redirects
-        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
-    }
-    // The actual implementation of the first dispatch
+//     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
+//    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+//     {   
+//         // this just redirects
+//         return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+//     }
+//     // The actual implementation of the first dispatch
     virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index cd913e3d..44c12bde 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -330,14 +330,14 @@ class DiskSurface
     
     // *** 3 *** - Pair reactions => two origin structures
     // First dispatch
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
-    {   
-        // this just redirects
-        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
-    }
-    // The actual implementation of the first dispatch
+//     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
+//    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+//     {   
+//         // this just redirects
+//         return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+//     }
+//     // The actual implementation of the first dispatch
     virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 6e8098d7..129909a0 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -315,14 +315,14 @@ class PlanarSurface
     
     // *** 3 *** - Pair reactions => two origin structures
     // First dispatch
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
-    {   
-        // this just redirects
-        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
-    }
-    // The actual implementation of the first dispatch
+//     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
+//    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+//     {   
+//         // this just redirects
+//         return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+//     }
+//     // The actual implementation of the first dispatch
     virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 0ada333d..eaaa6c2e 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -206,14 +206,14 @@ class SphericalSurface
     
     // *** 3 *** - Pair reactions => two origin structures
     // First dispatch
-    // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
-   virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                        length_type const& offset, length_type const& reaction_length, rng_type& rng) const
-    {   
-        // this just redirects
-        return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
-    }
-    // The actual implementation of the first dispatch
+//     // Overloading get_pos_sid_pair with signature (origin_structure2, target_structure_type_id, ...)
+//    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+//                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
+//     {   
+//         // this just redirects
+//         return this->get_pos_sid_pair_2o(origin_structure2, target_sid, CoM, offset, reaction_length, rng);                            
+//     }
+//     // The actual implementation of the first dispatch
     virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid,
                                                          position_type const& CoM, length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
diff --git a/Structure.hpp b/Structure.hpp
index 771574b3..5ecaf799 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -208,9 +208,9 @@ class Structure
     // This is called as a method of origin_structure1 with origin_structure2 as an argument.
     virtual position_structid_pair_type get_pos_sid_pair_2o(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
                                                             length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
-    // Some convenient method overloading; this is just a redirect to the above                                       
-    virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
-                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
+//     // Some convenient method overloading; this is just a redirect to the above                                       
+//     virtual position_structid_pair_type get_pos_sid_pair(structure_type const& origin_structure2, structure_type_id_type const& target_sid, position_type const& CoM,
+//                                                          length_type const& offset, length_type const& reaction_length, rng_type& rng) const = 0;
     // Second dispatch
     // The helper functions are the dispatch acceptors and have to be declared for each derived structure class because C++ does not support virtual templates.
     virtual position_structid_pair_type get_pos_sid_pair_2o_helper(CuboidalRegion<traits_type> const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
diff --git a/binding/Structure.hpp b/binding/Structure.hpp
index 469b167c..05c31e96 100644
--- a/binding/Structure.hpp
+++ b/binding/Structure.hpp
@@ -49,6 +49,9 @@ inline boost::python::objects::class_base register_structure_class(char const *n
         .def("project_point", &impl_type::project_point)
         .def("deflect", &impl_type::deflect)
 //        .def("deflect_back", &impl_type::deflect_back)
+        .def("get_pos_sid_pair", &impl_type::get_pos_sid_pair)
+        .def("get_pos_sid_pair_pair", &impl_type::get_pos_sid_pair_pair)
+        .def("get_pos_sid_pair_2o", &impl_type::get_pos_sid_pair_2o)
         ;
 }
 
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 69b908d8..71a3a3e4 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -564,7 +564,7 @@ class newBDPropagator
                             
                             // Produce two new positions and structure IDs
                             // Note that reactant_structure = prod0_structure here.
-                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(prod1_structure).c_str())); // TESTING
+                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair_pair with %s", boost::lexical_cast<std::string>(prod1_structure).c_str())); // TESTING
                             pos0pos1_pair = reactant_structure->get_pos_sid_pair_pair(*prod1_structure, reactant_pos, product0_species, product1_species, reaction_length_, rng_ );
                             // Remember the new structure IDs
                             prod0_struct_id = pos0pos1_pair.first.second;
@@ -750,8 +750,8 @@ class newBDPropagator
                         // origin_structure types.
                         const length_type offset(0.0);
                         LOG_DEBUG(("Attempting pair reaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(reactant1_structure).c_str())); // TESTING
-                        const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair(*reactant1_structure, product_structure_type_id,
-                                                                                                                       reactants_CoM, offset, reaction_length_, rng_ ) );
+                        const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair_2o(*reactant1_structure, product_structure_type_id,
+                                                                                                                          reactants_CoM, offset, reaction_length_, rng_ ) );
                         // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above
                         // in some cases might end up out of the target_structure (e.g. in case the two reactants are coming from adjacent planes
                         tx_.apply_boundary(product_pos_struct_id);

From cc27beb64c9db75ae709b022223d93c202606a71 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Aug 2012 16:24:11 +0200
Subject: [PATCH 1043/1541] Fix unbinding direction for DiskSurfaceSingles in
 egfrd mode

---
 egfrd.py  | 17 +++++++++++++----
 shells.py |  9 +++++----
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1e0c0b35..b41836e3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -223,7 +223,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         self.DEFAULT_DT_FACTOR = 1e-5           # Diffusion time prefactor in oldBD algortithm to determine time step.
         
-        self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # The maximum step size in the newBD algorithm is determined as DSSF * sigma_min.
+        self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # The maximum step size in the newBD algorithm is determined as DSSF * sigma_min.  # TESTING was 0.05
                                                 # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
                                                 # reaction volume sticks out of the multi. 
 
@@ -979,9 +979,18 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         product_pos_list.append(vector)
 
                 elif isinstance(reactant_structure, DiskSurface):
-                    vector_length = 1.0*product_radius * MINIMAL_SEPARATION_FACTOR
-                    vector        = reactant_pos + vector_length * reactant_structure.shape.unit_z
-                    product_pos_list.append(vector)
+                    # unbinding in direction of disk unit vector
+                    #vector_length = 1.0*product_radius * MINIMAL_SEPARATION_FACTOR
+                    #vector        = reactant_pos + vector_length * reactant_structure.shape.unit_z
+                    #product_pos_list.append(vector)
+                    # unbinding perpendicularly to disk unit vector (i.e. like on cylinder)
+                    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
+                    for _ in range(self.dissociation_retry_moves):
+                        unit_vector3D = random_unit_vector()
+                        unit_vector2D = normalize(unit_vector3D - 
+                                        (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
+                        vector = reactant_pos + vector_length * unit_vector2D
+                        product_pos_list.append(vector)
 
                 else:
                     # cannot decay from 3D to other structure
diff --git a/shells.py b/shells.py
index 1462e313..00c72777 100755
--- a/shells.py
+++ b/shells.py
@@ -1701,6 +1701,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         # - dz_left stays constant and is equal to the cap-bound particle radius
         # - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal particle radius involved
+        #   plus the rod radius (particle unbinds perpendicularly to disk normal vector)
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
         self.r0_right   = self.pid_particle_pair[1].radius
@@ -1713,11 +1714,11 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
-        self.dr       = self.pid_particle_pair[1].radius        
+        self.dr       = self.pid_particle_pair[1].radius + self.structure.shape.radius
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z
-        # just copy from disk structure; note that this defines the direction of dissociation!        
+        # just copy from disk structure
 
     def get_searchpoint(self):
         return self.pid_particle_pair[1].position
@@ -1727,14 +1728,14 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
-        dr       = self.pid_particle_pair[1].radius
+        dr       = self.dr
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) #  TODO Use SINGLE_SHELL_FACTOR instead?
         dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         # Radius is not scaled here so we do not to check for distance to shape edge
-        dr       = self.pid_particle_pair[1].radius
+        dr       = self.dr
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
         dz_left  = dz_right
         return dr, dz_right, dz_left

From f8dea1cabeacaf4c72eba8a2c354536f1ce66bd2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Aug 2012 18:04:11 +0200
Subject: [PATCH 1044/1541] Small fix to prevent rootfinder failure when
 checking for cyl.-disk overlaps

---
 shells.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 00c72777..0a92a6c7 100755
--- a/shells.py
+++ b/shells.py
@@ -980,7 +980,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
                 h1_min = r1_min/math.tan(scale_angle)
 
-#        print "situation= ", situation
+        print "situation= ", situation
         #################
         if situation == 1:
             # shell hits the scaling cylinder with its flat surface on the radial side
@@ -992,8 +992,9 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # TODO we have a solution but it can only be found with a root finder -> slow
             tan_scale_angle = math.tan(scale_angle)
 
-            if scale_angle <= Pi/4.0:
+            if scale_angle < Pi/4.0:
                 def h1(x):
+                    print "value = %s" % str((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)) # TODO DEBUG output, remove when done
                     return x - scale_center_to_shell_z + \
                            math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2 )
 

From e510b6bb2e6009d9650994b02717e9144059251b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 17 Aug 2012 19:34:56 +0200
Subject: [PATCH 1045/1541] Use structure functions to handle interactions in
 BD mode

... in order to be able to specify when an interaction is legal
for each structure individually.
---
 newBDPropagator.hpp | 43 +++++++++++++++++++++++++++++++------------
 1 file changed, 31 insertions(+), 12 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 71a3a3e4..427ce72b 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -283,6 +283,14 @@ class newBDPropagator
                         log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
                         accumulated_prob -= prob_increase;
                     }
+                    catch (illegal_propagation_attempt const& reason)
+                    {
+                        log_.info("surface interaction: illegal propagation attempt (reason: %s)", reason.what());
+                        ++rejected_move_count_;
+                        log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
+                        accumulated_prob -= prob_increase;
+                        // TODO return true here?
+                    }
                 }
                 else
                 {
@@ -818,17 +826,17 @@ class newBDPropagator
     /********************/
     /*** INTERACTIONS ***/
     /********************/
-    const bool attempt_interaction(particle_id_pair const& pp, position_type const& pos_in_struct, boost::shared_ptr<structure_type> const& structure)
+    const bool attempt_interaction(particle_id_pair const& pp, position_type const& pos_in_struct, boost::shared_ptr<structure_type> const& product_structure)
     // This handles the 'reaction' (interaction) between a particle and a structure.
     // Returns True if the interaction was succesfull
     {
         // Get the reaction rules for the interaction with this structure.
-        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), structure->sid() ));
+        reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid(), product_structure->sid() ));
         if (::size(rules) == 0)
             throw propagation_error("trying to fire an interaction with a structure without a reaction rule.");
         
                 
-        const Real k_tot( k_total(pp.second.sid(), structure->sid()) );
+        const Real k_tot( k_total(pp.second.sid(), product_structure->sid()) );
         const Real rnd( k_tot * rng_() );
         Real k_cumm = 0;  
 
@@ -856,11 +864,24 @@ class newBDPropagator
                     /*** ONE PRODUCT ***/
                     case 1:
                     {
-                        const species_type product_species(tx_.get_species(products[0]));
+                      
+                        const position_type                             reactant_pos( pp.second.position() );
+                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure(pp.second.structure_id()) );
+                        const structure_id_type                         reactant_structure_id( pp.second.structure_id() );
+                        const species_type                              product_species( tx_.get_species(products[0]) );
 
-                        //// 1 - GET NEW POSITION ON THE TARGET STRUCTURE
-                        // TODO Rework this using structure functions?
-                        const position_type product_pos( tx_.apply_boundary(pos_in_struct) );
+                        //// 1 - GET NEW POSITION ON THE TARGET STRUCTURE                        
+                        LOG_DEBUG(("Attempting interaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(product_structure).c_str())); // TESTING
+                        const position_structid_pair_type new_pos_sid_pair_tmp( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos,
+                                                                                product_species.radius(), reaction_length_, rng_) );
+                        // Apply boundary conditions
+                        // NOTE make_move is not called here because interactions are the result of a move before
+                        const position_structid_pair_type new_pos_sid_pair = tx_.apply_boundary( new_pos_sid_pair_tmp );
+                        const position_type product_pos( new_pos_sid_pair.first );
+                        const structure_id_type product_structure_id( new_pos_sid_pair.second);
+                        
+                        // OLD VERSION
+                        //const position_type product_pos( tx_.apply_boundary(pos_in_struct) );
 
 
                         //// 2 - CHECK FOR OVERLAPS
@@ -873,11 +894,9 @@ class newBDPropagator
                             throw propagation_error("no space");
                         }
                         // check overlap with structures.
-                        // first get the structure_id of the old structure...
-                        const structure_id_type old_struct_id(pp.second.structure_id());
-                        // ...and ignore the latter when checking for overlaps
+                        // ignore reactant_structures when checking for overlaps
                         const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
-                                tx_.check_surface_overlap(new_shape, product_pos, structure->id(), product_species.radius(), old_struct_id));
+                                tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius(), reactant_structure_id));
                         if (overlap_structures && overlap_structures->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");
@@ -894,7 +913,7 @@ class newBDPropagator
                         //// 3 - PROCESS CHANGES
                         remove_particle(pp.first);
                         // Make new particle in interaction structure 
-                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), structure->id(), product_pos) );
+                        const particle_id_pair product_particle( tx_.new_particle(product_species.id(), product_structure_id, product_pos) );
                         // Record changes
                         if (rrec_)
                         {

From df60abf31e9d67bf89ddf60446471adc1ebe707b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 13:04:32 +0200
Subject: [PATCH 1046/1541] Use disk unit_z instead of reference_vector as
 orientation vector of cylindrical shell for
 CylindricalSurfaceCapInteractiontestShell

Because reference_vector is not defined when particle position is
coincident with disk position.
---
 shells.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/shells.py b/shells.py
index 0a92a6c7..cb1df391 100755
--- a/shells.py
+++ b/shells.py
@@ -809,6 +809,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         z2 = z_right
 
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
+
     if feq(relative_orientation, 1.0):
     ### If the cylinders are oriented parallelly
 
@@ -980,7 +981,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
                 h1_min = r1_min/math.tan(scale_angle)
 
-        print "situation= ", situation
+        #print "situation= ", situation
         #################
         if situation == 1:
             # shell hits the scaling cylinder with its flat surface on the radial side
@@ -1950,11 +1951,9 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
                                  (str(e)))
 
     def get_orientation_vector(self):
-        # The orientation vector is collinear with the parent cylinder axis and
-        # pointing "inwards", i.e. towards the center point of the parent cylinder
-        # TODO Check that this works properly!
-        return self.reference_vector     # from testInteractionSingle; reference vector always points from the
-                                         # particle position projected onto the target surface towards particle pos.
+        # Here we assume implicitly that the cap and the
+        # rod are collinear
+        return self.target_structure.shape.unit_z
 
     def get_searchpoint(self):
         return self.pid_particle_pair[1].position

From 2db495daf2fa55b215f816e15fc89ddfcda921a6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 13:11:38 +0200
Subject: [PATCH 1047/1541] Treat case reference_vector = 0

... with raising a shellmaking error exception for now.
---
 shells.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index cb1df391..740b2989 100755
--- a/shells.py
+++ b/shells.py
@@ -188,7 +188,11 @@ def __init__(self, single, origin_structure, target_structure):
         self.particle_surface_distance = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
 
         # The reference_vector is the normalized vector from the reference_point to the particle
-        self.reference_vector = normalize(pos_transposed - self.reference_point)
+        if pos_transposed != self.reference_point :
+            self.reference_vector = normalize(pos_transposed - self.reference_point)
+        else:
+            self.reference_vector = 0
+            raise testShellError('(testInteractionSingle). reference vector = 0.')
 
 class testTransitionSingle(testSingle, Others):
 

From 4ff11e2673dae921c0b058bd4e2addd97caad831 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 13:20:10 +0200
Subject: [PATCH 1048/1541] Small fix to vector equality check

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 740b2989..0d53dd13 100755
--- a/shells.py
+++ b/shells.py
@@ -188,7 +188,7 @@ def __init__(self, single, origin_structure, target_structure):
         self.particle_surface_distance = self.world.distance(self.target_structure.shape, self.pid_particle_pair[1].position)
 
         # The reference_vector is the normalized vector from the reference_point to the particle
-        if pos_transposed != self.reference_point :
+        if any(pos_transposed != self.reference_point) :
             self.reference_vector = normalize(pos_transposed - self.reference_point)
         else:
             self.reference_vector = 0

From f283a068659b9b17567c092d27ef8a66f891bff2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 17:33:18 +0200
Subject: [PATCH 1049/1541] Introduce a flag that determines whether plane
 particles unbind on both or only one sides of the plane

---
 Plane.hpp                    | 28 ++++++++++++++++++++++------
 StructureUtils.hpp           | 36 ++++++++++++++++++++++++++++++++++--
 binding/Plane.hpp            | 17 ++++++++++++++++-
 binding/module_functions.cpp |  2 ++
 4 files changed, 74 insertions(+), 9 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index 3620bcbd..d751e5f9 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -18,6 +18,7 @@ class Plane
     typedef T_ value_type;
     typedef Vector3<T_> position_type;
     typedef T_ length_type;
+    typedef bool flag_type;
     typedef enum side_enum_type {TOP=0, BOTTOM=1, LEFT=2, RIGHT=3} side_enum_type;  // The typedef is a little bit C style but doesn't matter for C++
 
 public:
@@ -27,7 +28,8 @@ class Plane
             create_vector<position_type>(1., 0., 0.),
             create_vector<position_type>(0., 1., 0.),
             create_vector<position_type>(0., 0., 1.))),
-          half_extent_(array_gen<length_type>(0.5, 0.5)) {}
+          half_extent_(array_gen<length_type>(0.5, 0.5)),
+          is_one_sided_(true) {}
 
     template<typename Tarray_>
     Plane(position_type const& position, Tarray_ const& half_extent)
@@ -35,7 +37,8 @@ class Plane
           units_(array_gen(
             create_vector<position_type>(1., 0., 0.),
             create_vector<position_type>(0., 1., 0.),
-            create_vector<position_type>(0., 0., 1.)))
+            create_vector<position_type>(0., 0., 1.))),
+          is_one_sided_(true)
     {
         std::copy(boost::begin(half_extent), boost::end(half_extent),
                   boost::begin(half_extent_));
@@ -44,7 +47,7 @@ class Plane
     template<typename Tarray1, typename Tarray2>
     Plane(position_type const& position,
         Tarray1 const& units, Tarray2 const& half_extent)
-        : position_(position)
+        : position_(position), is_one_sided_(true)
     {
         std::copy(boost::begin(units), boost::end(units),
                   boost::begin(units_));
@@ -57,7 +60,8 @@ class Plane
         position_type const& vx,
         position_type const& vy,
         Tarray_ const& half_extent = array_gen<length_type>(0.5, 0.5))
-        : position_(position), units_(array_gen(vx, vy, cross_product(vx, vy)))
+        : position_(position), units_(array_gen(vx, vy, cross_product(vx, vy))),
+          is_one_sided_(true)
     {
         std::copy(boost::begin(half_extent), boost::end(half_extent),
                   boost::begin(half_extent_));
@@ -67,9 +71,10 @@ class Plane
         position_type const& vx,
         position_type const& vy,
         length_type const& half_lx,
-        length_type const& half_ly)
+        length_type const& half_ly,
+        flag_type const& is_one_sided)
         : position_(position), units_(array_gen(vx, vy, cross_product(vx, vy))),
-          half_extent_(array_gen<length_type>(half_lx, half_ly)) {}
+          half_extent_(array_gen<length_type>(half_lx, half_ly)), is_one_sided_(is_one_sided) {}
 
     position_type const& position() const
     {
@@ -150,6 +155,16 @@ class Plane
     {
         return half_extent_;
     }
+    
+    flag_type const& is_one_sided() const
+    {
+        return is_one_sided_;
+    }
+    
+    flag_type& is_one_sided()
+    {
+        return is_one_sided_;
+    }
 
     bool operator==(const Plane& rhs) const
     {
@@ -174,6 +189,7 @@ class Plane
     position_type position_;
     boost::array<position_type, 3> units_;
     boost::array<length_type, 2> half_extent_;
+    flag_type is_one_sided_;
 };
 
 template<typename T_>
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index 48490a0d..ab36b714 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -36,6 +36,8 @@ struct StructureUtils
     typedef typename simulator_type::planar_surface_type        planar_surface_type;
     typedef typename simulator_type::cuboidal_region_type       cuboidal_region_type;
     typedef typename simulator_type::world_type::traits_type::rng_type rng_type;
+    
+    typedef bool flag_type;
  
     static planar_surface_type* create_planar_surface(
             structure_type_id_type const& sid,          // This refers to the structure type of the planar surface
@@ -44,7 +46,7 @@ struct StructureUtils
             position_type const& unit_x,
             position_type const& unit_y,
             length_type const& lx,
-            length_type const& ly,
+            length_type const& ly,            
             structure_id_type const& parent_struct_id)
     {
         BOOST_ASSERT(is_cartesian_versor(unit_x));
@@ -59,10 +61,40 @@ struct StructureUtils
 
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
                                                 multiply(unit_y, half_ly)));
+        const flag_type is_one_sided(true);
+
+        return new planar_surface_type(name, sid, parent_struct_id,
+                                       plane_type(pos, unit_x, unit_y,
+                                                  half_lx, half_ly, is_one_sided));
+    }
+    
+    static planar_surface_type* create_double_sided_planar_surface(
+            structure_type_id_type const& sid,          // This refers to the structure type of the planar surface
+            structure_name_type   const& name,
+            position_type const& corner,
+            position_type const& unit_x,
+            position_type const& unit_y,
+            length_type const& lx,
+            length_type const& ly,            
+            structure_id_type const& parent_struct_id)
+    {
+        BOOST_ASSERT(is_cartesian_versor(unit_x));
+        BOOST_ASSERT(is_cartesian_versor(unit_y));
+        BOOST_ASSERT(is_cartesian_versor(cross_product(unit_x, unit_y)));
+
+        // Note that when calling the function the origin is in the corner and the length
+        // is the whole length of the plane, whereas for 'plane_type' the origin is in the
+        // center of the plane (pos) and that the length is only half lengths 'half_lx' and 'half_ly'.
+        const length_type half_lx(lx / 2);
+        const length_type half_ly(ly / 2);
+
+        const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
+                                                multiply(unit_y, half_ly)));
+        const flag_type is_one_sided(false);
 
         return new planar_surface_type(name, sid, parent_struct_id,
                                        plane_type(pos, unit_x, unit_y,
-                                                  half_lx, half_ly));
+                                                  half_lx, half_ly, is_one_sided));
     }
 
     static spherical_surface_type* create_spherical_surface(
diff --git a/binding/Plane.hpp b/binding/Plane.hpp
index ba6cd338..7c6085a2 100644
--- a/binding/Plane.hpp
+++ b/binding/Plane.hpp
@@ -29,7 +29,8 @@ inline boost::python::objects::class_base register_plane_class(char const* name)
                   typename impl_type::position_type, 
                   typename impl_type::position_type, 
                   typename impl_type::length_type,
-                  typename impl_type::length_type>())
+                  typename impl_type::length_type,
+                  bool>())
         .def(init<typename impl_type::position_type, 
                   boost::array<typename impl_type::length_type, 2> >())
         .add_property("position",
@@ -102,6 +103,20 @@ inline boost::python::objects::class_base register_plane_class(char const* name)
                     typename impl_type::position_type,
                     &impl_type::unit_z,
                     &impl_type::unit_z>::set))
+        .add_property("is_one_sided",
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::flag_type,
+                    &impl_type::is_one_sided,
+                    &impl_type::is_one_sided>::get,
+                return_value_policy<return_by_value>()),
+            make_function(
+                &peer::util::reference_accessor_wrapper<
+                    impl_type,
+                    typename impl_type::flag_type,
+                    &impl_type::is_one_sided,
+                    &impl_type::is_one_sided>::set))
         ;
                         
 }
diff --git a/binding/module_functions.cpp b/binding/module_functions.cpp
index 38049e49..918830cd 100644
--- a/binding/module_functions.cpp
+++ b/binding/module_functions.cpp
@@ -47,6 +47,8 @@ void register_module_functions()
     def( "cyclic_transpose", &cyclic_transpose<Position, element_type_of<Position>::type> );
     def("create_planar_surface", &StructureUtils::create_planar_surface,
             return_value_policy<manage_new_object>());
+    def("create_double_sided_planar_surface", &StructureUtils::create_double_sided_planar_surface,
+            return_value_policy<manage_new_object>());
     def("create_spherical_surface", &StructureUtils::create_spherical_surface,
             return_value_policy<manage_new_object>());
     def("create_cylindrical_surface", &StructureUtils::create_cylindrical_surface,

From 9f9002d7cd41d2b864d9721e8beb21a952bddeba Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 17:36:29 +0200
Subject: [PATCH 1050/1541] De-randomize plane unbinding in egfrd.py if
 is_one_sided flag is set

---
 egfrd.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b41836e3..cb8c5120 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -962,8 +962,13 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                 # TODO make these generators for efficiency
                 product_pos_list = []
                 if isinstance(reactant_structure, PlanarSurface):
-                    a = myrandom.choice(-1, 1)
-                    directions = [-a,a]
+                    if not reactant_structure.shape.is_one_sided:
+                        # randomize unbinding direction
+                        a = myrandom.choice(-1, 1)
+                        directions = [-a,a]
+                    else:
+                        # unbinding always in direction of unit_z
+                        directions = [1]
                     # place the center of mass of the particle 'at contact' with the membrane
                     vector_length = (product_radius + 0.0) * (MINIMAL_SEPARATION_FACTOR - 1.0)  # the thickness of the membrane is 0.0
                     product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \

From a1f9e1fcf8e4cfaa938c8a0179bdfa0c64e7a527 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 17:58:01 +0200
Subject: [PATCH 1051/1541] Also correctly check the one_sided flag in case of
 two products

---
 egfrd.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index cb8c5120..82bd82a1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -962,13 +962,13 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                 # TODO make these generators for efficiency
                 product_pos_list = []
                 if isinstance(reactant_structure, PlanarSurface):
-                    if not reactant_structure.shape.is_one_sided:
+                    if reactant_structure.shape.is_one_sided:
+                        # unbinding always in direction of unit_z
+                        directions = [1]
+                    else:
                         # randomize unbinding direction
                         a = myrandom.choice(-1, 1)
                         directions = [-a,a]
-                    else:
-                        # unbinding always in direction of unit_z
-                        directions = [1]
                     # place the center of mass of the particle 'at contact' with the membrane
                     vector_length = (product_radius + 0.0) * (MINIMAL_SEPARATION_FACTOR - 1.0)  # the thickness of the membrane is 0.0
                     product_pos_list = [reactant_pos + vector_length * reactant_structure.shape.unit_z * direction \
@@ -1098,7 +1098,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
                 if isinstance(reactant_structure, PlanarSurface):
                     # draw a number of new positions for the two product particles
-                    # TODO make this into a generator
+                    # TODO make this a generator
 
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
@@ -1111,7 +1111,12 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         iv *= MINIMAL_SEPARATION_FACTOR
 
                         # determine the side of the membrane the dissociation takes place
-                        unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+                        if(reactant_structure.shape.is_one_sided):
+                            unit_z = reactant_structure.shape.unit_z
+                        else:
+                            unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
+
+                        # calculate the new positions and structure IDs
                         newposA, newposB, sidA, sidB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                                        productA_radius, productB_radius,
                                                                                        reactant_structure, reactant_structure,

From 2c761e986e1dc8d6c215fe3887089e872ff27645 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 17:59:38 +0200
Subject: [PATCH 1052/1541] Query one_sided flag in
 PlanarSurface->surface_dissociation_vector to correctly determine unbinding
 direction in BD mode

---
 PlanarSurface.hpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 129909a0..09b3deb0 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -104,8 +104,18 @@ class PlanarSurface
     {
         Real X( rng.uniform(0.,1.) );
         length_type diss_vec_length( X*rl );
-
-        return multiply( base_type::shape().unit_z(), diss_vec_length );
+        
+        if( base_type::shape().is_one_sided() )
+        {
+            return multiply( base_type::shape().unit_z(), diss_vec_length );
+        }
+        else
+        {
+            int sign( rng.uniform(0,1)<=0.5 ? -1 : +1);
+            diss_vec_length *= (Real)sign;
+            
+            return multiply( base_type::shape().unit_z(), diss_vec_length );
+        }
     }
     
     // Normed direction of dissociation from the structure to parent structure

From 564c8cfd470377190e671de2bc49198ea2118347 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 18:53:47 +0200
Subject: [PATCH 1053/1541] Also fix choice between single-/double-sided
 unbinding for forward reaction and special geminate dissociation in
 PlanarSurface

---
 PlanarSurface.hpp   | 26 ++++++++++++++------------
 newBDPropagator.hpp |  3 +--
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 09b3deb0..52b16fe1 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -93,10 +93,10 @@ class PlanarSurface
     // Reaction volume for binding to the structure
     virtual Real surface_reaction_volume( length_type const& r0, length_type const& rl ) const
     {
-        // Assuming binding from one side only (the one that unit_z points towards)
-        // If binding occurs from two sides, this has to be changed to 2*rl and 
-        // unbinding (surface_dissociation_vector) has to be randomized, too.
-        return rl;
+        if( base_type::shape().is_one_sided() )
+            return rl;
+        else
+            return 2.0*rl;
     }
     
     // Vector of dissociation from the structure to parent structure
@@ -111,8 +111,8 @@ class PlanarSurface
         }
         else
         {
-            int sign( rng.uniform(0,1)<=0.5 ? -1 : +1);
-            diss_vec_length *= (Real)sign;
+            Real sign( rng.uniform_int(0, 1) * 2 - 1 );
+            diss_vec_length *= sign;
             
             return multiply( base_type::shape().unit_z(), diss_vec_length );
         }
@@ -167,13 +167,15 @@ class PlanarSurface
         length_type const r01l_cb( r01l * r01l * r01l );
         length_type const r01_cb( r01 * r01 * r01 );
         
-        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );                  
+        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb ) + r01_cb ) );        
+        
         
-        position_type unit_z = base_type::shape().unit_x();
-        // Old version for binding from both plane sides; TODO Remove this once everything is fine
-        // position_type unit_z( cross_product( base_type::shape().unit_x(), base_type::shape().unit_y() ) );
-        // unit_z = normalize ( unit_z );        
-        // unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
+        // Determine direction of dissociation for the particle that ends up in the bulk
+        // As a standard it is the plane's unit_z vector
+        position_type unit_z( base_type::shape().unit_z() );
+        // If the plane however is two-sided: randomize!
+        if( not(base_type::shape().is_one_sided()) )
+            unit_z = multiply(unit_z, rng.uniform_int(0, 1) * 2 - 1);
         
         // Construct randomly oriented dissociation vector
         length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 427ce72b..0b9414cd 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -289,7 +289,6 @@ class newBDPropagator
                         ++rejected_move_count_;
                         log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
                         accumulated_prob -= prob_increase;
-                        // TODO return true here?
                     }
                 }
                 else
@@ -313,7 +312,7 @@ class newBDPropagator
             species_type s0(pp_species);
             species_type s1(tx_.get_species(overlap_particle.first.second.sid()));
 
-            // TODO Remove this if everything works fine!
+            // TODO Remove this when everything works fine!
 /*            // If the structure_types of the reactants are not equal, one of the reactants has to come from the bulk,
             // and we let this be s1, the particle from the surface is named s0.
             if(s0.structure_type_id() != s1.structure_type_id())

From 87de00ffe527d263394ab690d97e35c6ac017417 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 21 Aug 2012 19:27:14 +0200
Subject: [PATCH 1054/1541] Introduce an optional parameter into create_box for
 boxes with double-sided unbinding and docstring for create_double_sided_plane

---
 gfrdbase.py | 19 ++++++++++++-------
 model.py    | 42 ++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 52 insertions(+), 9 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 97c3c02c..f894a8c7 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -186,7 +186,7 @@ def create_world(m, matrix_size=10):
     world.model = m
     return world
 
-def create_box(world, structure_type, center, size):
+def create_box(world, structure_type, center, size, one_sided=True):
     """ Creates a box of PlanarSurface sections and adds it to the world.
 
         Arguments:
@@ -212,13 +212,18 @@ def create_box(world, structure_type, center, size):
     name = 'box'
     def_struct_id = world.get_def_structure_id()
     
+    if one_sided:
+        create_planar_surface = model.create_planar_surface
+    else:
+        create_planar_surface = model.create_double_sided_planar_surface
+
     # Create the planes and add them to the world
-    front  = model.create_planar_surface(sid, name+'_front', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
-    back   = model.create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
-    right  = model.create_planar_surface(sid, name+'_right', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
-    left   = model.create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
-    top    = model.create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
-    bottom = model.create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
+    front  = create_planar_surface(sid, name+'_front', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
+    back   = create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
+    right  = create_planar_surface(sid, name+'_right', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
+    left   = create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
+    top    = create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
+    bottom = create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
     world.add_structure(front)
     world.add_structure(back)
     world.add_structure(right)
diff --git a/model.py b/model.py
index 8bd19e6f..a3a67acf 100644
--- a/model.py
+++ b/model.py
@@ -1,6 +1,6 @@
 import _gfrd
 from _gfrd import create_cuboidal_region, create_cylindrical_surface, \
-        create_disk_surface, create_planar_surface
+        create_disk_surface, create_planar_surface, create_double_sided_planar_surface
 import numpy
 
 __all__ = [
@@ -20,6 +20,7 @@
     'create_cylindrical_surface',
     'create_disk_surface',
     'create_planar_surface',
+    'create_double_sided_planar_surface',
     ]
 
 
@@ -100,7 +101,44 @@
 _gfrd.create_planar_surface.__doc__ = \
 """create_planar_surface(sid, id, corner, unit_x, unit_y, length_x, length_y)
 
-Create and return a new planar Surface.
+Create and return a new planar surface with one-sided particle unbinding,
+i.e. particles on this surface will unbind in the direction of the normal
+vector unit_z (cross product of unit_x and unit_y).
+
+Arguments:
+    - sid
+        the structure type of the planar surface.
+    - id
+        the name of the structure
+    - corner
+        the point [x, y, z] on the plane closest to [0, 0, 0]. Units: 
+        [meters, meters, meters]
+    - unit_x
+        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the 
+        plane.
+    - unit_y
+        a unit vector [1, 0, 0], [0, 1, 0] or [0, 0, 1] along the plane 
+        and perpendicular to unit_x.
+    - length_x
+        the length of the plane along the unit vector unit_x. Should be 
+        equal to the world_size. Units: meters.
+    - length_y
+        the length of the plane along the unit vector unit_y. Should be 
+        equal to the world_size. Units: meters.
+
+Surfaces are not allowed to overlap.
+
+Todo: allow the user to specify the position of a planar surface 
+relative to a region.
+
+"""
+
+_gfrd.create_double_sided_planar_surface.__doc__ = \
+"""create_double_sided_planar_surface(sid, id, corner, unit_x, unit_y, length_x, length_y)
+
+Create and return a new planar surface with double-sided particle unbinding,
+i.e. particles on this surface will unbind randomly in either unit_z or -unit_z
+direction (unit_z = cross product of unit_x and unit_y).
 
 Arguments:
     - sid

From 49063743c1daf3a7e1305aac114c6abb657d3754 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 22 Aug 2012 14:36:40 +0200
Subject: [PATCH 1055/1541] Remove origin_structure and target_structure from
 CylindricalSurfacePair because it is not needed there

---
 pair.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/pair.py b/pair.py
index 32ef393a..73c626a5 100644
--- a/pair.py
+++ b/pair.py
@@ -755,13 +755,6 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.LD_MAX = numpy.inf # Required by SimplePair.__init__
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
-        # The latter is defined for completeness and used by check_domain() in egfrd.py:
-        # (Note that that origin and target end up in same list.)
-        self.origin_structure = self.testShell.origin_structure
-        self.target_structure = self.testShell.target_structure         
-#        self.origin_structure = self.structure2D
-#        self.target_structure = self.structure2D #TODO: redundant..
-
     def get_shell_size(self):
         return self.shell.shape.half_length
 

From f6fca5442a973ebfb6e627a6ea9434c60c27571e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 22 Aug 2012 15:03:31 +0200
Subject: [PATCH 1056/1541] Fixed a bug which returned wrong structure ID for
 the 3D particle at MixedPair2D3D dissociation and caused an assert to fail

---
 pair.py   | 2 +-
 single.py | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 73c626a5..3eea7757 100644
--- a/pair.py
+++ b/pair.py
@@ -962,7 +962,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
         pos2 = com + weight2 * (iv_x + iv_y) + iv_z 
 
         # Class method; so don't use self.(..)
-        return pos1, pos2, structure2D.id, structure2D.id        
+        return pos1, pos2, structure2D.id, structure3D.id
 
     @ classmethod
     def calc_z_scaling_factor(cls, D2d, D3d):
diff --git a/single.py b/single.py
index 68fb3e20..5171ed8a 100644
--- a/single.py
+++ b/single.py
@@ -436,6 +436,7 @@ def check(self):
         assert self.greens_function
         assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
 
+        # Assert that new position is in the structure
         assert feq(numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,\
                     self.structure.shape.unit_z), 0.0, typical=self.shell.shape.half_length)
 

From 68f7e8f671c6323a7f51fcc3368e6cf276888458 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 22 Aug 2012 15:25:54 +0200
Subject: [PATCH 1057/1541] Define origin_structure and target_structure
 properly for MixedPair1DCap

---
 pair.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/pair.py b/pair.py
index 3eea7757..89f4824c 100644
--- a/pair.py
+++ b/pair.py
@@ -1114,10 +1114,8 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.cap_structure = self.testShell.cap_structure
 
         # The latter is defined for completeness and used by check_domain() in egfrd.py:
-        self.origin_structure = self.testShell.origin_structure
-        self.target_structure = self.testShell.target_structure         
-#        self.origin_structure = self.structure1D
-#        self.target_structure = self.cap_structure
+        self.origin_structure = self.structure1D
+        self.target_structure = self.cap_structure
 
         # The cap_particle should be immobile; check to be sure:
         assert self.cap_particle.D == 0

From 77a6700fb28cc0d181f1adb4458706aecd6d8507 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 22 Aug 2012 18:33:27 +0200
Subject: [PATCH 1058/1541] Revise cylinder scaling for cap interaction domains
 and DiskSurfaceSingle

...because this caused problems with overlapping domains
due to ill-defined orientation vector.
---
 shells.py | 81 +++++++++++++++++++++++++++++--------------------------
 1 file changed, 43 insertions(+), 38 deletions(-)

diff --git a/shells.py b/shells.py
index b73f42a6..2a1cbe2b 100755
--- a/shells.py
+++ b/shells.py
@@ -1708,25 +1708,26 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
 
         # Initialize scaling parameters
         # - the reference point is at the cap disk position
-        # - the right scaling point is for the scaling "inwards", i.e. onto the rod
-        # - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
-        # - dz_left stays constant and is equal to the cap-bound particle radius
-        # - dz_right can be scaled, minimum is set accordingly
-        # - dr stays constant and is determined by the maximal particle radius involved
-        #   plus the rod radius (particle unbinds perpendicularly to disk normal vector)
+        # - the orientation vector points from the cap towards the rod center, i.e.:
+        #       - the right scaling point is for the scaling "inwards", i.e. onto the rod
+        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
+        #       - dz_left stays constant and is equal to the cap-bound particle radius
+        #       - dz_right can be scaled, minimum is set accordingly
+        # - dr stays constant and is determined by the maximal radius involved
+        self.shell_radius = max(self.pid_particle_pair[1].radius, self.structure.shape.radius)
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = self.pid_particle_pair[1].radius
+        self.r0_right   = self.shell_radius
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = self.pid_particle_pair[1].radius
+        self.r0_left    = self.shell_radius
         self.z0_left    = 0.0
 
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
-        self.dr       = self.pid_particle_pair[1].radius + self.structure.shape.radius
+        self.dr       = self.shell_radius
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z
@@ -1740,14 +1741,14 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
-        dr       = self.dr
+        dr       = self.shell_radius
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) #  TODO Use SINGLE_SHELL_FACTOR instead?
         dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         # Radius is not scaled here so we do not to check for distance to shape edge
-        dr       = self.dr
+        dr       = self.shell_radius
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
         dz_left  = dz_right
         return dr, dz_right, dz_left
@@ -1936,18 +1937,20 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
 
         # Initialize scaling parameters
         # - the reference point is at the cap disk position
-        # - the right scaling point is for the scaling "inwards", i.e. onto the rod
-        # - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
-        # - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
-        # - dz_right can be scaled, minimum is set accordingly
-        # - dr stays constant and is determined by the maximal particle radius involved
+        # - the orientation vector points from the cap towards the rod particle, i.e.:
+        #       - the right scaling point is for the scaling "inwards", i.e. onto the rod
+        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
+        #       - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
+        #       - dz_right can be scaled, minimum is set accordingly
+        # - dr stays constant and is determined by the maximal radius involved
+        self.shell_radius = max([self.pid_particle_pair[1].radius, self.origin_structure.shape.radius, self.target_structure.shape.radius])
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = self.pid_particle_pair[1].radius
+        self.r0_right   = self.shell_radius
         self.z0_right   = 0.0
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
-        self.r0_left    = self.pid_particle_pair[1].radius      # TODO put to zero?
+        self.r0_left    = self.shell_radius # better put to zero?
         self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
 
         # This will determine if the shell is possible.
@@ -1961,9 +1964,9 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
                                  (str(e)))
 
     def get_orientation_vector(self):
-        # Here we assume implicitly that the cap and the
-        # rod are collinear
-        return self.target_structure.shape.unit_z
+        # The orientation vector is the (normalized) vector that points from the cap
+        # towards the particle on the rod
+        return normalize(self.pid_particle_pair[1].position - self.target_structure.shape.position)
 
     def get_searchpoint(self):
         return self.pid_particle_pair[1].position
@@ -1972,13 +1975,13 @@ def get_referencepoint(self):
         return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = self.pid_particle_pair[1].radius
+        dr       = self.shell_radius
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         dz_right = self.particle_surface_distance + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        dr       = self.pid_particle_pair[1].radius
+        dr       = self.shell_radius
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
         # TODO include max distance to other side of rod?
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
@@ -2234,18 +2237,21 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
 
         # Initialize scaling parameters
         # - the reference point is at the cap disk position
-        # - the right scaling point is for the scaling "inwards", i.e. onto the rod
-        # - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
-        # - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
-        # - dz_right can be scaled, minimum is set accordingly
-        # - dr stays constant and is determined by the maximal particle radius involved
+        # - the orientation vector points from the cap towards the rod particle, i.e.:
+        #       - the right scaling point is for the scaling "inwards", i.e. onto the rod
+        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
+        #       - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
+        #       - dz_right can be scaled, minimum is set accordingly
+        # - dr stays constant and is determined by the maximal radius involved
+        self.shell_radius = max([self.cap_particle.radius, self.particle1D.radius,\
+                                 self.cap_structure.shape.radius, self.structure1D.shape.radius])
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = max(self.cap_particle.radius, self.particle1D.radius)
+        self.r0_right   = self.shell_radius
         self.z0_right   = 0.0
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
-        self.r0_left    = max(self.cap_particle.radius, self.particle1D.radius)      # TODO put to zero?
+        self.r0_left    = self.shell_radius
         self.z0_left    = self.cap_particle.radius * SINGLE_SHELL_FACTOR
 
         # This will determine if the shell is possible.
@@ -2258,11 +2264,10 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
             raise testShellError('(MixedPair1DCap). %s' %
                                  (str(e)))
 
-    def get_orientation_vector(self):
-        # The orientation vector is collinear with the parent cylinder axis and
-        # pointing "inwards", i.e. towards the center point of the parent cylinder
-        direction = cmp(numpy.dot(self.structure1D.shape.unit_z, self.structure1D.shape.position - self.cap_structure.shape.position), 0)
-        return  direction * self.structure1D.shape.unit_z
+    def get_orientation_vector(self):        
+        # The orientation vector is the (normalized) vector that points from the cap
+        # towards the particle on the rod
+        return normalize(self.particle1D.position - self.cap_structure.shape.position)
 
     def get_searchpoint(self):
         return self.particle1D.position
@@ -2271,13 +2276,13 @@ def get_referencepoint(self):
         return self.cap_structure.shape.position
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = max(self.particle1D.radius, self.cap_particle.radius)
+        dr       = self.shell_radius
         dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR
         dz_right = self.get_min_pair_size() # TODO make sure this does the right thing!
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        dr       = max(self.particle1D.radius, self.cap_particle.radius)
+        dr       = self.shell_radius
         dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         return dr, dz_right, dz_left
@@ -2297,7 +2302,7 @@ def get_min_pair_size(self):
         radius1 = self.particle1D.radius
         radius2 = self.cap_particle.radius
 
-        dist_from_com1 = self.r0 * D_1 / self.D_tot      # particle distance from CoM
+        dist_from_com1 = self.r0 * D_1 / self.D_tot     # particle distance from CoM
         dist_from_com2 = self.r0 * D_2 / self.D_tot
         iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
         iv_shell_size2 = dist_from_com2 + radius2

From b4e65baac9694f772d40ea5e6c46f8e5ccd59e1b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 22 Aug 2012 19:00:08 +0200
Subject: [PATCH 1059/1541] Make caps daughter structures of the cylinders
 again (for now) because otherwise the simulator will not form DiskSingles

---
 egfrd.py    |  1 +
 gfrdbase.py | 13 +++++--------
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 5c401530..a70c8298 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1643,6 +1643,7 @@ def make_new_domain(self, single):
                 else:
                     # with a cylindrical surface it is the surface of the particle
                     surface_horizon = single_radius * MULTI_SHELL_FACTOR
+
                 multi_partners.append((surface, distance - surface_horizon))
 
 
diff --git a/gfrdbase.py b/gfrdbase.py
index f894a8c7..d1cc4353 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -297,19 +297,16 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
 
     # Create the cylinder of the rod
     rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', position, radius, orientation, length, def_struct_id)
-    print rod
+    world.add_structure(rod) # This must happen directly here otherwise rod.id will be undefined
 
     # Create the caps
     front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
-    front_cap = model.create_disk_surface(cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, def_struct_id)
+    front_cap = model.create_disk_surface(cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, rod.id)
+    world.add_structure(front_cap)
 
     back_cap_pos = position
-    back_cap = model.create_disk_surface(cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], def_struct_id)
-
-    # Add the new structures to the world
-    world.add_structure(rod)
-    world.add_structure(front_cap)
-    world.add_structure(back_cap)
+    back_cap = model.create_disk_surface(cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], rod.id)
+    world.add_structure(back_cap)    
 
     return rod.id
 

From 817db68326264e3a5b842514dc29d759c30b54db Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 22 Aug 2012 19:26:02 +0200
Subject: [PATCH 1060/1541] Allow for creation of "half_rods", i.e. rods capped
 on one (or no) side only

---
 gfrdbase.py | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index d1cc4353..722ae447 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -246,7 +246,7 @@ def create_box(world, structure_type, center, size, one_sided=True):
     world.connect_structures(bottom, 3, right, 2)
     world.connect_structures(bottom, 2, left, 1)
 
-def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length):
+def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length, front_cap=True, back_cap=True):
     """ Creates a cylinder with two disk-caps at its ends and adds it to the world.
 
         The function ensures that the orientation vectors of the disks point
@@ -279,6 +279,13 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
                 a 3D vector defining the the rod orientation
             - length
                 the rod length
+
+        Optional arguments:
+            - front_cap = [True/False]
+                if set to false, the front cap will not be placed;
+                True by default
+            - back_cap = [True/False]
+                same as above
     """    
     # Assert that the location and size is ok
     position = numpy.array(position)
@@ -300,13 +307,15 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
     world.add_structure(rod) # This must happen directly here otherwise rod.id will be undefined
 
     # Create the caps
-    front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
-    front_cap = model.create_disk_surface(cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, rod.id)
-    world.add_structure(front_cap)
-
-    back_cap_pos = position
-    back_cap = model.create_disk_surface(cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], rod.id)
-    world.add_structure(back_cap)    
+    if front_cap:
+        front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
+        front_cap = model.create_disk_surface(cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, rod.id)
+        world.add_structure(front_cap)
+
+    if back_cap:
+        back_cap_pos = position
+        back_cap = model.create_disk_surface(cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], rod.id)
+        world.add_structure(back_cap)    
 
     return rod.id
 

From 80a2ccb37019e6eca79ecd5bbb4b673d3b0bb7bd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 22 Aug 2012 20:13:41 +0200
Subject: [PATCH 1061/1541] Allow specification of cap type instead of not
 placing them for half rods.

---
 gfrdbase.py | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 722ae447..04f9ee1d 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -246,7 +246,7 @@ def create_box(world, structure_type, center, size, one_sided=True):
     world.connect_structures(bottom, 3, right, 2)
     world.connect_structures(bottom, 2, left, 1)
 
-def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length, front_cap=True, back_cap=True):
+def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length, front_cap_structure_type=None, back_cap_structure_type=None):
     """ Creates a cylinder with two disk-caps at its ends and adds it to the world.
 
         The function ensures that the orientation vectors of the disks point
@@ -302,20 +302,26 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
     o = orientation
     l = length
 
+    front_cap_sid = cap_sid
+    back_cap_sid  = cap_sid
+
+    if front_cap_structure_type:
+        front_cap_sid = front_cap_structure_type.id
+    if back_cap_structure_type:
+        back_cap_sid  = back_cap_structure_type.id
+         
     # Create the cylinder of the rod
     rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', position, radius, orientation, length, def_struct_id)
     world.add_structure(rod) # This must happen directly here otherwise rod.id will be undefined
 
     # Create the caps
-    if front_cap:
-        front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
-        front_cap = model.create_disk_surface(cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, rod.id)
-        world.add_structure(front_cap)
-
-    if back_cap:
-        back_cap_pos = position
-        back_cap = model.create_disk_surface(cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], rod.id)
-        world.add_structure(back_cap)    
+    front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
+    front_cap = model.create_disk_surface(front_cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, rod.id)
+    world.add_structure(front_cap)
+
+    back_cap_pos = position
+    back_cap = model.create_disk_surface(back_cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], rod.id)
+    world.add_structure(back_cap)    
 
     return rod.id
 

From c303e39f0450fbe50df115ab9578263c060b7c0b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 23 Aug 2012 12:58:30 +0200
Subject: [PATCH 1062/1541] Test changes to make cylinder domain formation
 finite again

---
 shells.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 2a1cbe2b..1ddad725 100755
--- a/shells.py
+++ b/shells.py
@@ -1690,9 +1690,12 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr = self.pid_particle_pair[1].radius
-#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink this
+        #dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink this
+        ##_, (_, pp_dist) = self.structure.project_point(self.get_referencepoint())
+        ##assert(pp_dist <= 0.0)
+        ##dz_right_edge = abs(pp_dist)
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-#        dz_right      = min(dz_right_sr, dz_right_edge)
+        #dz_right      = min(dz_right_sr, dz_right_edge)
         dz_right      = dz_right_sr
         dz_left       = dz_right
         return dr, dz_right, dz_left

From 0d168eb146e7713dd64fa8e5e66cf646d95b1945 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 23 Aug 2012 13:00:49 +0200
Subject: [PATCH 1063/1541] Temporarily switch off formation of MixedPair2D3D
 for testing

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a70c8298..c9fb1849 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -142,10 +142,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return CylindricalSurfacePairtestShell  (single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
         return PlanarSurfaceTransitionPairtestShell (single1, single2, geometrycontainer, domains) 
-    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
-    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+    #elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+        #return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
+    #elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+        #return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
         return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):

From ea4a68b25de4154981c6bfd402a90d64f02717d6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 23 Aug 2012 14:00:58 +0200
Subject: [PATCH 1064/1541] Revert last change

...and better have a separate branch for it.
---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c9fb1849..a70c8298 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -142,10 +142,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return CylindricalSurfacePairtestShell  (single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
         return PlanarSurfaceTransitionPairtestShell (single1, single2, geometrycontainer, domains) 
-    #elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        #return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
-    #elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        #return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
+    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
         return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):

From 5830ae96593b5adcfc63b6921bbc237581a644c9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 23 Aug 2012 16:11:43 +0200
Subject: [PATCH 1065/1541] Some better commenting and readability for cylinder
 scaling code

---
 shells.py | 113 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 65 insertions(+), 48 deletions(-)

diff --git a/shells.py b/shells.py
index 1ddad725..64d8979d 100755
--- a/shells.py
+++ b/shells.py
@@ -769,40 +769,41 @@ def get_radius_to_SphericalShape(shape, testShell, r):
 # functions to size up a testShell to a Cylindrical shape object
 def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_left):
     # This function returns the dr, dz_right, dz_left parameters for the cylindrical 'testShell'
-    # using the cylindrical 'shell' as its closest neighbor. Note that it returns the minimum the newly calculated
-    # dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell' can therefore only become
-    # smaller.
+    # using a cylindrical 'shell' as its closest neighbor. Note that it returns the minimum of 
+    # the newly calculated dr, dz_right, dz_left and the old r, z_right, z_left. The 'testShell'
+    # therefore can only become smaller.
 
-    # Note that the 'shell' is querried from this domain earlier by the testShell.
+    # Note that the neighboring 'shell' is querried from this domain earlier by the testShell.
     # -> the shell MUST be a Cylinder.
-    assert (type(shape) is Cylinder)
+    assert(type(shape) is Cylinder)
 
     # Laurens' algorithm (part2)
     shell_position = shape.position
     shell_radius = shape.radius 
     shell_half_length = shape.half_length 
 
-
-    # get the reference point and orientation of the domain to scale
+    # Get the reference point and orientation of the domain to scale
     reference_point = testShell.get_referencepoint()
     orientation_vector = testShell.get_orientation_vector()
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
 #    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
 
-    # determine on what side the midpoint of the shell is relative to the reference_point
+    # Determine on what side the midpoint of the shell is relative to the reference_point
     shell_position_t = testShell.world.cyclic_transpose (shell_position, reference_point)
     ref_to_shell_vec = shell_position_t - reference_point
     ref_to_shell_z = numpy.dot(ref_to_shell_vec, orientation_vector)
+    # The length ref_to_shell_z is positive when the shell is on the right side of the
+    # cylinder and negative when it is on the left side
 
-    # if the shell is on the side of orientation_vector -> use z_right
-    # also use this one if the shell is in plane with the reference_point
+    # If the shell is on the side of orientation_vector -> use z_right
+    # Also use this one if the shell is in plane with the reference_point
     if ref_to_shell_z >= 0:
         direction = 1           # improve direction specification such that following calculations still work
-                                    # Otherwise problems when direction = 0
+                                # Otherwise problems when direction = 0
         scale_angle = testShell.right_scalingangle
         scale_center_r, scale_center_z = testShell.right_scalingcenter 
-        r1_function =  testShell.r_right
+        r1_function = testShell.r_right
         z1_function = testShell.z_right
         z2_function = testShell.z_left
         z1 = z_right
@@ -812,16 +813,17 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         direction = -1
         scale_angle = testShell.left_scalingangle
         scale_center_r, scale_center_z = testShell.left_scalingcenter 
-        r1_function =  testShell.r_left
+        r1_function = testShell.r_left
         z1_function = testShell.z_left
         z2_function = testShell.z_right
         z1 = z_left
         z2 = z_right
 
+    # Check how the cylinders are oriented with respect to each other
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
 
     if feq(relative_orientation, 1.0):
-    ### If the cylinders are oriented parallelly
+    #### If the cylinders are oriented parallelly ####
 
         # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
         ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
@@ -852,14 +854,15 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             z1_new = min(z1, z1_function(r_new))
 
     elif feq(relative_orientation, 0):
-    ### If the cylinders are oriented perpendicularly
-
-        # The local x-axis is defined as the vector parallel to the axis of the shell in the direction from the
-        # reference_point of the scaling cylinder to the cylindrical shell
-        # The local y-axis is defined as the vector parallel to the flat side of the shell, perpendicular to the
-        # axis of the scaling cylinder. It also point from the reference_point of the scaling cylinder to the shell.
-        # The local z-axis is defined as the vector parallel to the axis of the scaling cylinder in the direction
-        # from the reference point to the shell.
+    #### If the cylinders are oriented perpendicularly ####
+
+        # First construct a local coordinate system:
+        #   - The local x-axis is defined as the vector parallel to the axis of the neighboring shell pointing
+        #   from the reference_point of the scaling cylinder towards the neighboring shell.
+        #   - The local y-axis is defined as the vector parallel to the flat side of the shell, perpendicular to the
+        #   axis of the scaling cylinder. It also points from the reference_point of the scaling cylinder to the shell.
+        #   - The local z-axis is defined as the vector parallel to the axis of the scaling cylinder pointing
+        #   from the reference point towards the neighboring shell.
         if numpy.dot(ref_to_shell_vec, shape.unit_z) >= 0:
             local_x = shape.unit_z
         else:
@@ -867,26 +870,39 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         local_z = orientation_vector * direction
         cross = numpy.cross(local_x, local_z)
         if numpy.dot(ref_to_shell_vec, cross) >= 0:
+            # cross already points towards the shell, we are fine
             local_y = cross
         else:
+            # it points away from the shell, thus negate it
             local_y = -cross
 
+        # Transform the vector pointing from the ref. point towards the shell
+        # into the local coordinate system
         ref_to_shell_x = numpy.dot(ref_to_shell_vec, local_x)
         ref_to_shell_y = numpy.dot(ref_to_shell_vec, local_y)
         ref_to_shell_z = numpy.dot(ref_to_shell_vec, local_z)
-        assert (ref_to_shell_x >= 0.0) and (ref_to_shell_y >= 0.0) and (ref_to_shell_z >= 0.0)  # By the definition of the local coordinate system
-
+        assert (ref_to_shell_x >= 0.0) and (ref_to_shell_y >= 0.0) and (ref_to_shell_z >= 0.0)  # by the definition of the local coordinate system
+        # Also calculate the coordinates of the scale center
         scale_center_to_shell_x = ref_to_shell_x
         scale_center_to_shell_y = ref_to_shell_y
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
-        
+        # And the coordinates of the closest corner of a box surrounding the shape
         ref_to_shell_x2 = ref_to_shell_x - shell_half_length
         ref_to_shell_y2 = ref_to_shell_y - shell_radius
+        ref_to_shell_z2 = ref_to_shell_z - shell_radius # not really needed, but defined here for completeness
+
+        # Define situation (collision) specifiers
+        # Depending on the geometric constellation the scaling will eventually lead to different collision behaviour
+        # which has to be treated in different ways; the following collision specifiers are from the point of view
+        # of the scaled cylinder:
+        BARREL_HITS_FLAT, EDGE_HITS_EDGE, BARREL_HITS_EDGE, FLAT_HITS_BARREL, EDGE_HITS_BARREL, BARREL_HITS_BARREL = range(6)
+
+        # Now first determine which type of collision happens:
 
         if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
             # quadrant 1
 #            print "quadrant 1"
-            situation = 4
+            situation = FLAT_HITS_BARREL
 
         elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
             # quadrant 2
@@ -913,13 +929,13 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
 
             if scale_angle <= scale_center_to_shell_crit_angle_y:
-                situation = 1
+                situation = BARREL_HITS_FLAT
             elif scale_center_to_shell_low_angle_y <= scale_angle:
-                situation = 4
+                situation = FLAT_HITS_BARREL
             else:
                 assert scale_center_to_shell_crit_angle_y < scale_angle and \
                        scale_angle < scale_center_to_shell_low_angle_y
-                situation = 2
+                situation = EDGE_HITS_EDGE
                 r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
                 h1_min = r1_min/math.tan(scale_angle)
 
@@ -947,13 +963,13 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
 
             if scale_angle <= scale_center_to_shell_crit_angle_x:
-                situation = 6
+                situation = BARREL_HITS_BARREL
             elif scale_center_to_shell_low_angle_x <= scale_angle:
-                situation = 4
+                situation = FLAT_HITS_BARREL
             else:
                 assert scale_center_to_shell_crit_angle_x < scale_angle and \
                        scale_angle < scale_center_to_shell_low_angle_x
-                situation = 5
+                situation = EDGE_HITS_BARREL
 
         else:
             # quadrant 4
@@ -981,29 +997,30 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
 
             if scale_angle <= scale_center_to_shell_crit_angle_xy:
-                situation = 3
+                situation = BARREL_HITS_EDGE
             elif scale_center_to_shell_low_angle_xy <= scale_angle:
-                situation = 4
+                situation = FLAT_HITS_BARREL
             else:
                 assert scale_center_to_shell_crit_angle_xy < scale_angle and \
                        scale_angle < scale_center_to_shell_low_angle_xy
-                situation = 2
+                situation = EDGE_HITS_EDGE
                 r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
                 h1_min = r1_min/math.tan(scale_angle)
 
         #print "situation= ", situation
         #################
-        if situation == 1:
-            # shell hits the scaling cylinder with its flat surface on the radial side
+        if situation == BARREL_HITS_FLAT:
+            # the scaling cylinder hits the flat side of 'shell' with its barrel side
             r_new = min(r, (ref_to_shell_x - shell_half_length))
             z1_new = min(z1, z1_function(r_new))
 
-        elif situation == 2:
-            # shell hits the scaling cylinder with its edge on the edge
+        elif situation == EDGE_HITS_EDGE:             
+            # the scaling cylinder hits the edge of 'shell' with its edge
             # TODO we have a solution but it can only be found with a root finder -> slow
+            # FIXME THIS CAUSES SERIOUS ERRORS IN SOME SITUATIONS!!!
             tan_scale_angle = math.tan(scale_angle)
 
-            if scale_angle < Pi/4.0:
+            if scale_angle <= Pi/4.0:
                 def h1(x):
                     print "value = %s" % str((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)) # TODO DEBUG output, remove when done
                     return x - scale_center_to_shell_z + \
@@ -1022,18 +1039,18 @@ def r1(x):
                 r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))
 
-        elif situation == 3:
-            # shell hits the scaling cylinder with its edge on the radial side
+        elif situation == BARREL_HITS_EDGE:
+            # the scaling cylinder hits the edge of 'shell' with its barrel side
             r_new = min(r, math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2))
             z1_new = min(z1, z1_function(r_new))
 
-        elif situation == 4:
-            # shell hits the scaling cylinder with its round side on the top flat side
+        elif situation == FLAT_HITS_BARREL:
+            # the scaling cylinder hits the barrel of 'shell' with its top flat side
             z1_new = min(z1, (ref_to_shell_z - shell_radius))
             r_new  = min(r,  r1_function(z1_new))
 
-        elif situation == 5:
-            # shell hist the scaling cylinder with its round side on the edge of the scaling cylinder.
+        elif situation == EDGE_HITS_BARREL:
+            # the scaling cylinder hits the barrel of 'shell' with its edge
             shell_radius_sq = shell_radius*shell_radius
 
             ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_y**2)
@@ -1056,8 +1073,8 @@ def r1(x):
                 r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist))
                 z1_new = min(z1, z1_function(r_new))
 
-        elif situation == 6:
-            # shell hits the scaling cylinder with its round side on the radial side
+        elif situation == BARREL_HITS_BARREL:
+            # The scaling cylinder hits the barrel of 'shell' with its barrel
             r_new = min(r, (ref_to_shell_y - shell_radius))
             z1_new = min(z1, z1_function(r_new))
 

From cc06fec9eba210a7f22df8f26893219f5efa4cf5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 23 Aug 2012 18:49:38 +0200
Subject: [PATCH 1066/1541] A crude fix for the edge-hits-edge cylinder scaling
 rootfinder problem

---
 shells.py | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/shells.py b/shells.py
index 64d8979d..dd1ca530 100755
--- a/shells.py
+++ b/shells.py
@@ -897,7 +897,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         # of the scaled cylinder:
         BARREL_HITS_FLAT, EDGE_HITS_EDGE, BARREL_HITS_EDGE, FLAT_HITS_BARREL, EDGE_HITS_BARREL, BARREL_HITS_BARREL = range(6)
 
-        # Now first determine which type of collision happens:
+        #### (1) Now first determine which type of collision happens:
 
         if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
             # quadrant 1
@@ -1007,8 +1007,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
                 h1_min = r1_min/math.tan(scale_angle)
 
+        ##### (2) Treat the situation accordingly
         #print "situation= ", situation
-        #################
         if situation == BARREL_HITS_FLAT:
             # the scaling cylinder hits the flat side of 'shell' with its barrel side
             r_new = min(r, (ref_to_shell_x - shell_half_length))
@@ -1017,25 +1017,28 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         elif situation == EDGE_HITS_EDGE:             
             # the scaling cylinder hits the edge of 'shell' with its edge
             # TODO we have a solution but it can only be found with a root finder -> slow
-            # FIXME THIS CAUSES SERIOUS ERRORS IN SOME SITUATIONS!!!
+            # FIXME THIS CAUSES SERIOUS ERRORS IN SOME SITUATIONS! FIND A SOLUTION WHICH DOES NOT EMPLOY THE ROOTFINDER!
             tan_scale_angle = math.tan(scale_angle)
 
             if scale_angle <= Pi/4.0:
-                def h1(x):
-                    print "value = %s" % str((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)) # TODO DEBUG output, remove when done
-                    return x - scale_center_to_shell_z + \
-                           math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2 )
+                #def h1(x):
+                    #print "value = %s" % str((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)) # TODO DEBUG output, remove when done
+                    #return x - scale_center_to_shell_z + \
+                           #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2 )
 
-                h_touch = scale_center_z + findroot(h1, h1_min, scale_center_to_shell_z*(1.0-TOLERANCE))
+                #h_touch = scale_center_z + findroot(h1, h1_min, scale_center_to_shell_z*(1.0-TOLERANCE))
+                h_touch = ref_to_shell_z - shell_radius # TODO This is a crude fix to override the original version above and may be improved
                 z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
             else:
-                def r1(x):
-                    shell_radius_sq = shell_radius**2
-                    return x/tan_scale_angle - scale_center_to_shell_z + \
-                           math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2))**2)
-
-                r_touch = findroot(r1, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
+                #def r1(x):
+                    #shell_radius_sq = shell_radius**2
+                    #return x/tan_scale_angle - scale_center_to_shell_z + \
+                           #math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2))**2)
+
+                #r_touch = findroot(r1, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
+                r_touch = math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2)
+                          # TODO This is a crude fix to override the original version above and may be improved
                 r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))
 

From b2f2363984a866e2dbfab219910a44431ee4e5be Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 10:45:45 +0200
Subject: [PATCH 1067/1541] More informative BD warnings

---
 newBDPropagator.hpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 0b9414cd..853cf5da 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -257,8 +257,8 @@ class newBDPropagator
                 LOG_DEBUG( ("check for surface interaction, acc_prob = %g", accumulated_prob) ); // TESTING
                 if(accumulated_prob >= 1.) // sth. is wrong in this case
                 {
-                    LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one; %f.",
-                                 accumulated_prob));
+                    LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one in particle-surface interaction: p_acc = %f, reaction_length = %f, dt = %f.",
+                                 accumulated_prob, reaction_length_, dt_));
                 }
                 
                 if( accumulated_prob > rnd ) // OK, try to fire the interaction
@@ -334,8 +334,8 @@ class newBDPropagator
             if (accumulated_prob >= 1.)
             {
                 LOG_WARNING((
-                    "the accumulated acceptance probability inside a reaction volume exeededs one; %f.",
-                    accumulated_prob));
+                    "the accumulated acceptance probability inside a reaction volume exeededs one in particle-particle reaction: p_acc = %f, reaction_length = %f, dt = %f.",
+                     accumulated_prob, reaction_length_, dt_));
             } 
             
             if(accumulated_prob > rnd)

From 61dcdc5f51188e62d955bc6a362f76f473eb8f11 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 10:51:21 +0200
Subject: [PATCH 1068/1541] One more warning for particle-surface interactions
 in BD

---
 newBDPropagator.hpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 853cf5da..b045269d 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -255,6 +255,13 @@ class newBDPropagator
                 accumulated_prob += prob_increase;
         
                 LOG_DEBUG( ("check for surface interaction, acc_prob = %g", accumulated_prob) ); // TESTING
+                
+                if(prob_increase >= 1.) // sth. is wrong in this case
+                {
+                    LOG_WARNING(("probability increase exceeded one in particle-surface interaction: prob_increase = %f, k_total = %f, surface_reaction_volume = %f.",
+                                 prob_increase, k_total( pp.second.sid(), overlap_struct.first.second->sid() ),
+                                 overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ )           ));
+                }
                 if(accumulated_prob >= 1.) // sth. is wrong in this case
                 {
                     LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one in particle-surface interaction: p_acc = %f, reaction_length = %f, dt = %f.",

From d68161b0b99f638f8cdf2bfd583c626d45228cad Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 12:33:16 +0200
Subject: [PATCH 1069/1541] Add logger and improve readability of
 GreensFunction2DRadAbs

---
 GreensFunction2DRadAbs.cpp | 1237 +++++++++++++++++++-----------------
 GreensFunction2DRadAbs.hpp |    3 +
 2 files changed, 649 insertions(+), 591 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index b692447f..2deefe30 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -43,28 +43,29 @@ const unsigned int GreensFunction2DRadAbs::MAX_ALPHA_SEQ;
 // This is the constructor
 GreensFunction2DRadAbs::
 GreensFunction2DRadAbs( const Real D, 
-				    const Real kf,
-				    const Real r0, 
-				    const Real Sigma,
-                    const Real a )
+                        const Real kf,
+                        const Real r0, 
+                        const Real Sigma,
+                        const Real a )
     :
     PairGreensFunction(D, kf, r0, Sigma),   
     h( kf / (D * 2.0 * M_PI * Sigma) ),       
     a( a ),                                    
     estimated_alpha_root_distance_(M_PI/(a-Sigma)) // observed convergence of
-                                                   // distance roots f_alpha().                                                                                     
+                                                   // distance roots f_alpha().
     // ^: Here parent "constructors" are specified that are executed, 
     // also a constructor initialization list can be (and is) specified. 
     // These variables will be set before the contents of the constructor are 
     // called.
 {
+  
     const Real sigma(this->getSigma());
 
     // Check wether input makes sense, outer boundary a should be > inner 
     // boundary sigma.    
     if (a < sigma)
     {
-        throw std::invalid_argument((boost::format("a >= sigma : a=%.16g, sigma=%.16g") % a % sigma).str());
+        throw std::invalid_argument((boost::format("GreensFunction2DRadAbs: a >= sigma : a=%.16g, sigma=%.16g") % a % sigma).str());
     }
     
     // Clear AlphaTables
@@ -78,66 +79,66 @@ GreensFunction2DRadAbs::~GreensFunction2DRadAbs()
     ; // do nothing
 }
 
+
 //
 // Alpha-related methods
 //
-
 // Resets the alpha-tables
 void GreensFunction2DRadAbs::clearAlphaTable() const
 {
+  
     const Real estimated_alpha_root_distance(getestimated_alpha_root_distance_());
 
     // Clears all vectors in the alphaTable
     std::for_each( this->alphaTable.begin(), this->alphaTable.end(),
-		   boost::mem_fn( &RealVector::clear ) );
-		   
-	// Sets all values of the alpha_x_scan_table_ to zero.
+                  boost::mem_fn( &RealVector::clear ) );
+                  
+    // Sets all values of the alpha_x_scan_table_ to zero.
     std::fill( this->alpha_x_scan_table_.begin(), 
-               this->alpha_x_scan_table_.end(),
-	           SCAN_START*estimated_alpha_root_distance); // DEBUG TODO; actual number here might
-                     	            // be important for functioning of Bessel
-                     	            // functions.
-	           
-	// Sets all values of the alpha_correctly_estimated_ table to zero.
+              this->alpha_x_scan_table_.end(),
+                  SCAN_START*estimated_alpha_root_distance);
+                  // DEBUG TODO; actual number here might
+                  // be important for functioning of Bessel functions.
+                  
+    // Sets all values of the alpha_correctly_estimated_ table to zero.
     std::fill( this->alpha_correctly_estimated_.begin(), 
-               this->alpha_correctly_estimated_.end(),
-	           0 );	           
-	           
+              this->alpha_correctly_estimated_.end(),
+                  0 );                 
 }
 
+
 // The method evaluates the equation for finding the alphas for given alpha. This
 // is needed to find the alpha's at which the expression is zero -> alpha is the root.
 const Real 
 GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 {
 
-	const Real a( this->geta() );
-	const Real sigma( getSigma() );
-	const Real h( this->geth() );
-	const Real s_An( sigma * alpha );
-	const Real a_An( a * alpha );
-	// Needed? TODO
-//	const Real h_s( h * sigma);
+    const Real a( this->geta() );
+    const Real sigma( getSigma() );
+    const Real h( this->geth() );
+    const Real s_An( sigma * alpha );
+    const Real a_An( a * alpha );
+    // Needed? TODO
+//  const Real h_s( h * sigma);
 
-	const double J0_s_An (gsl_sf_bessel_J0(s_An));
-	const double J1_s_An (gsl_sf_bessel_J1(s_An));
-	const double J0_a_An (gsl_sf_bessel_J0(a_An));
+    const double J0_s_An (gsl_sf_bessel_J0(s_An));
+    const double J1_s_An (gsl_sf_bessel_J1(s_An));
+    const double J0_a_An (gsl_sf_bessel_J0(a_An));
 
-	const double Y0_s_An (gsl_sf_bessel_Y0(s_An));
-	const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
-	const double Y0_a_An (gsl_sf_bessel_Y0(a_An));	
+    const double Y0_s_An (gsl_sf_bessel_Y0(s_An));
+    const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
+    const double Y0_a_An (gsl_sf_bessel_Y0(a_An));	
 
 //  const double rho1 ( ( (h_s * J0_s_An) + (s_An * J1_s_An) ) * Y0_a_An );
-//	const double rho2 ( ( (h_s * Y0_s_An) + (s_An * Y1_s_An) ) * J0_a_An );
-//	return (rho1 - rho2); 
-
-//  Sigma can be divided out, roots will remain same:
-//  (Note: actually double checked this).
-	const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
-	const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
+//  const double rho2 ( ( (h_s * Y0_s_An) + (s_An * Y1_s_An) ) * J0_a_An );
+//  return (rho1 - rho2); 
 
-	return rho1 - rho2;
+    // Sigma can be divided out, roots will remain same:
+    // (Note: actually double checked this).
+    const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
+    const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
 
+    return rho1 - rho2;
 }
 
 
@@ -148,7 +149,7 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 // wrapper of f_alpha.  
 const Real 
 GreensFunction2DRadAbs::f_alpha0_aux_F( const Real alpha,
-						const f_alpha0_aux_params* const params )
+                                                const f_alpha0_aux_params* const params )
 {
     // create pointer to Green's Function object
     const GreensFunction2DRadAbs* const gf( params->gf ); 	
@@ -160,39 +161,41 @@ GreensFunction2DRadAbs::f_alpha0_aux_F( const Real alpha,
 // f_alpha() Calculates the value of the mathematical function f_alpha(). The
 // roots (y=0) of this function are constants in the Green's Functions.
 const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
-						    const Integer n ) const
+                                                    const Integer n ) const
 {
-	const Real a( this->geta() );
-	const Real sigma( getSigma() );
-	const Real h( this->geth() );
-	const Real s_An( sigma * alpha );
-	const Real a_An( a * alpha );	
+  
+    const Real a( this->geta() );
+    const Real sigma( getSigma() );
+    const Real h( this->geth() );
+    const Real s_An( sigma * alpha );
+    const Real a_An( a * alpha );	
     const Real realn( static_cast<Real>( n ) );
     const Real h_sigma( h * sigma);
 
-	const double Jn_s_An (gsl_sf_bessel_Jn(n,s_An));
-	const double Jn1_s_An (gsl_sf_bessel_Jn(n+1,s_An));
-	const double Jn_a_An (gsl_sf_bessel_Jn(n,a_An));
+    const double Jn_s_An (gsl_sf_bessel_Jn(n,s_An));
+    const double Jn1_s_An (gsl_sf_bessel_Jn(n+1,s_An));
+    const double Jn_a_An (gsl_sf_bessel_Jn(n,a_An));
 
-	const double Yn_s_An (gsl_sf_bessel_Yn(n,s_An));
-	const double Yn1_s_An (gsl_sf_bessel_Yn(n+1,s_An));
-	const double Yn_a_An (gsl_sf_bessel_Yn(n,a_An));
+    const double Yn_s_An (gsl_sf_bessel_Yn(n,s_An));
+    const double Yn1_s_An (gsl_sf_bessel_Yn(n+1,s_An));
+    const double Yn_a_An (gsl_sf_bessel_Yn(n,a_An));
 
     const double rho1 ( ( (h_sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
-	const double rho2 ( ( (h_sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
-	return (rho1 - rho2); 
+    const double rho2 ( ( (h_sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
+    return (rho1 - rho2); 
 
-//  Or..? -:	
+//  Or..?
 //  const double rho1 ( ( ((h*sigma-realn) * Jn_s_An) + (s_An * Jn1_s_An) ) * Yn_a_An );
-//	const double rho2 ( ( ((h*sigma-realn) * Yn_s_An) + (s_An * Yn1_s_An) ) * Jn_a_An );
-//	return (rho1 - rho2); 		
-       
+//  const double rho2 ( ( ((h*sigma-realn) * Yn_s_An) + (s_An * Yn1_s_An) ) * Jn_a_An );
+//  return (rho1 - rho2);
+      
 } 
 
+
 // Simply a wrapper for f_alpha().
 const Real 
 GreensFunction2DRadAbs::f_alpha_aux_F( const Real alpha,
-	       					const f_alpha_aux_params* const params )     					
+                                                const f_alpha_aux_params* const params )
 {
     // Params contains pointer to gf object (params.gf), which has f_alpha() as 
     // a member.
@@ -207,39 +210,42 @@ GreensFunction2DRadAbs::f_alpha_aux_F( const Real alpha,
 const Real 
 GreensFunction2DRadAbs::p_survival_i( const Real alpha) const
 {
-	const Real a( geta() );		// get the needed parameters
-	const Real sigma( getSigma() );
+  
+    const Real a( geta() );         // get the needed parameters
+    const Real sigma( getSigma() );
 
-	const Real s_An (sigma*alpha);
-	const Real a_An (a*alpha);
+    const Real s_An (sigma*alpha);
+    const Real a_An (a*alpha);
     const Real alpha_sq (alpha*alpha);
 
-	// calculate all the required Bessel functions
+    // calculate all the required Bessel functions
     const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
     const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
     const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
+    const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
 
-	// calculate C0,n
-        const Real C_i_0 (calc_A_i_0(alpha)); 
+    // calculate C0,n
+    const Real C_i_0 (calc_A_i_0(alpha)); 
 
-	// calculate the integral over Bn,0
-	const Real dB_n_0dr (J1_sAn*Y0_aAn - Y1_sAn*J0_aAn);	// this is only the 
-	                                   // part without alpha of dB0,n(sigma)/dr
-	const Real B_n_0_int (Real(2.0)/(M_PI*alpha_sq) - (sigma/alpha)*dB_n_0dr);
+    // calculate the integral over Bn,0
+    const Real dB_n_0dr (J1_sAn*Y0_aAn - Y1_sAn*J0_aAn);
+    // this is only the part without alpha of dB0,n(sigma)/dr
+    const Real B_n_0_int (Real(2.0)/(M_PI*alpha_sq) - (sigma/alpha)*dB_n_0dr);
 
-	// return the total result
-	const Real result (C_i_0 * B_n_0_int);
-	return result;
+    // return the total result
+    const Real result (C_i_0 * B_n_0_int);
+    
+    return result;
 }
 
+
 // Calculates the factor An,0 for (for example) determination of the flux 
 // through the outer interface
 const Real 
 GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
 {
     // Get the required parameters
-    const Real a( geta() );    		        
+    const Real a( geta() );
     const Real sigma( getSigma() );
     const Real h (this->geth());
 
@@ -248,7 +254,7 @@ GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
     const Real r0An (r0*alpha);
 
     // Calculate all the required Bessel functions
-	const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    
+    const Real J0_sAn  (gsl_sf_bessel_J0(s_An));    
     const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
     const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
 
@@ -266,14 +272,16 @@ GreensFunction2DRadAbs::calc_A_i_0( const Real alpha) const
 
     const Real A_i_0 ((alpha_sq * rho_sq * B_n_0)/( rho_sq - (J0_aAn*J0_aAn)*(h*h + alpha_sq)));
 
-	return A_i_0;
+    return A_i_0;
 }
 
+
 // Calculates the n-th term of the summation for calculating the flux through 
 // the inner interface (reaction)
 const Real 
 GreensFunction2DRadAbs::leaves_i( const Real alpha) const
 {
+  
     const Real a( geta() );         // get the needed parameters
     const Real sigma( getSigma() );
 
@@ -284,18 +292,18 @@ GreensFunction2DRadAbs::leaves_i( const Real alpha) const
     const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
     const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
     const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
-    const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-        
+    const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));        
 
     // calculate An,0
-    const Real A_i_0 (calc_A_i_0(alpha));		// calculate the coefficient A0,n
+    const Real A_i_0 (calc_A_i_0(alpha)); // calculate the coefficient A0,n
 
-	// calculate dBn,0(sigma)/dr
-	const Real dB_n_0dr (-alpha*(J1_sAn*Y0_aAn - Y1_sAn*J0_aAn));
+    // calculate dBn,0(sigma)/dr
+    const Real dB_n_0dr (-alpha*(J1_sAn*Y0_aAn - Y1_sAn*J0_aAn));
 
-	// calculate the total result
-	const Real result (A_i_0 * dB_n_0dr);
-        return result;
+    // calculate the total result
+    const Real result (A_i_0 * dB_n_0dr);
+    
+    return result;
 }
 
 
@@ -303,80 +311,84 @@ GreensFunction2DRadAbs::leaves_i( const Real alpha) const
 void 
 GreensFunction2DRadAbs::createPsurvTable( RealVector& table) const
 {
+  
     const RealVector& alphaTable_0( this->getAlphaTable( 0 ) );	// get the roots for the survival probability
 
-    table.clear();				// empty the table
-    table.reserve( alphaTable_0.size() );	// and get the nescessary memory
+    table.clear();                              // empty the table
+    table.reserve( alphaTable_0.size() );       // and get the nescessary memory
 
     std::transform( alphaTable_0.begin(), alphaTable_0.end(),
-		    std::back_inserter( table ),
-		    boost::bind( &GreensFunction2DRadAbs::p_survival_i,
-				 this, _1) );	// This gets all the roots from 'begin' to 'end'
-						// passes them as an argument to p_survival_i and
-						// the result is passed to back_inserter
+                    std::back_inserter( table ),
+                    boost::bind( &GreensFunction2DRadAbs::p_survival_i,
+                                this, _1) );    // This gets all the roots from 'begin' to 'end'
+                                                // passes them as an argument to p_survival_i and
+                                                // the result is passed to back_inserter
 }
 
+
 // Creates the tables with various Bessel functions used in drawR, the table is used to speed things up
 void
 GreensFunction2DRadAbs::createY0J0Tables( RealVector& Y0_Table,
-							RealVector& J0_Table,
-							RealVector& Y0J1J0Y1_Table,
-							const Real t ) const
+                                                        RealVector& J0_Table,
+                                                        RealVector& Y0J1J0Y1_Table,
+                                                        const Real t ) const
 {
-	const RealVector& alphaTable_0( this->getAlphaTable( 0 ) );
-							// get the roots for the survival probability
-	Y0_Table.clear();				// empty the table
-	J0_Table.clear();
-	Y0J1J0Y1_Table.clear();
-
-	Y0_Table.reserve( alphaTable_0.size() );	// and get the nescessary memory
-	J0_Table.reserve( alphaTable_0.size() );
-	Y0J1J0Y1_Table.reserve( alphaTable_0.size() );
-
-	boost::tuple<Real,Real,Real> result;
-	
-	for (unsigned int count = 0; count < alphaTable_0.size(); count++)
-	{	result = Y0J0J1_constants(alphaTable_0[count], t);
-
-		Y0_Table.push_back (result.get<0>());
-		J0_Table.push_back (result.get<1>());
-		Y0J1J0Y1_Table.push_back (result.get<2>());
-	}
+  
+    const RealVector& alphaTable_0( this->getAlphaTable( 0 ) );
+                                                // get the roots for the survival probability
+    Y0_Table.clear();                           // empty the table
+    J0_Table.clear();
+    Y0J1J0Y1_Table.clear();
+
+    Y0_Table.reserve( alphaTable_0.size() );    // and get the nescessary memory
+    J0_Table.reserve( alphaTable_0.size() );
+    Y0J1J0Y1_Table.reserve( alphaTable_0.size() );
 
+    boost::tuple<Real,Real,Real> result;
+
+    for (unsigned int count = 0; count < alphaTable_0.size(); count++)
+    {       result = Y0J0J1_constants(alphaTable_0[count], t);
+
+            Y0_Table.push_back (result.get<0>());
+            J0_Table.push_back (result.get<1>());
+            Y0J1J0Y1_Table.push_back (result.get<2>());
+    }
 }
 
 
 // Creates the values for in the tables Y0, J0 and Y0J1J0Y1
 const boost::tuple<Real,Real,Real>
 GreensFunction2DRadAbs::Y0J0J1_constants ( const Real alpha,
-							const Real t) const
-{	const Real D(this->getD());
-	const Real sigma(this->getSigma());
-	const Real a(this->geta());
-
-	const Real s_An (sigma*alpha);
-	const Real a_An (a*alpha);
-	const Real alpha_sq (alpha*alpha);
-
-	// calculate all the required Bessel functions	
-	const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
-	const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
-	const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
-	const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
-	
+                                                        const Real t) const
+{
+  
+    const Real D(this->getD());
+    const Real sigma(this->getSigma());
+    const Real a(this->geta());
+
+    const Real s_An (sigma*alpha);
+    const Real a_An (a*alpha);
+    const Real alpha_sq (alpha*alpha);
+
+    // calculate all the required Bessel functions	
+    const Real J0_aAn  (gsl_sf_bessel_J0(a_An));
+    const Real Y0_aAn  (gsl_sf_bessel_Y0(a_An));
+    const Real J1_sAn  (gsl_sf_bessel_J1(s_An));
+    const Real Y1_sAn  (gsl_sf_bessel_Y1(s_An));
+
 
     // calculate An,0
-	const Real A_i_0 (calc_A_i_0(alpha)); //_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
+    const Real A_i_0 (calc_A_i_0(alpha)); //_sq * rho_sq * B_n_0)/( rho_sq - J0_bAn*J0_bAn*(h*h + alpha_sq)));
 
-	// calculate the exponent with the time
-	const Real expT( std::exp(-D*alpha_sq*t));
-	// and the product
-	const Real Ai0_expT (A_i_0 * expT / alpha);
+    // calculate the exponent with the time
+    const Real expT( std::exp(-D*alpha_sq*t));
+    // and the product
+    const Real Ai0_expT (A_i_0 * expT / alpha);
 
-	// calculate the large constant term in the intergral of Bn,0
-	const Real Y0J1_J0Y1 (Y0_aAn*sigma*J1_sAn - J0_aAn*sigma*Y1_sAn);
+    // calculate the large constant term in the intergral of Bn,0
+    const Real Y0J1_J0Y1 (Y0_aAn*sigma*J1_sAn - J0_aAn*sigma*Y1_sAn);
 
-	return boost::make_tuple (Ai0_expT*Y0_aAn, Ai0_expT*J0_aAn, Ai0_expT*Y0J1_J0Y1);
+    return boost::make_tuple (Ai0_expT*Y0_aAn, Ai0_expT*J0_aAn, Ai0_expT*Y0J1_J0Y1);
 }
 
 
@@ -411,20 +423,21 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
     //      (This can be done because the offsets only get bigger, the roots 
     // shift to the right with the order of the Bessel functions n.)   
     if (alpha_x_scan_table_[n] == 0) { // which implies i == 0   
-	    if (n > 0)
-	    {	
-	        alpha_x_scan_table_[n] = ( this->alphaTable[n-1][0] ); 
-	    }
-	}	    						
+            if (n > 0)
+            {
+                alpha_x_scan_table_[n] = ( this->alphaTable[n-1][0] ); 
+            }
+    }
 
     // Define new interval as between x1=offset ("low") and x2=(offset+interval)
     // ("high"). Make sure "low" is > 0.
-    low = alpha_x_scan_table_[n];		
+    low = alpha_x_scan_table_[n];
     high = alpha_x_scan_table_[n] + interval;	
-	if (low <= 0)			        // TODO this check should be redundant
-	{	std::cerr << "Left alpha search interval boundary < 0.";//low = EPSILON/L_TYPICAL;
-    	throw std::exception();
-	}
+    if (low <= 0) // TODO this check should be redundant
+    {
+        log_.error("Left alpha search interval boundary < 0.");//low = EPSILON/L_TYPICAL;
+        throw std::exception();
+    }
 
     // # Look for the sign change:
     
@@ -443,9 +456,9 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
 
     // Continue shifting the search interval until a sign change is detected.
     while( f_low * f_high > 0 )		
-    {	      				  
-        low =  high;			
-        f_low = f_high;			
+    {
+        low =  high;
+        f_low = f_high;
 
         high += interval;
         f_high = f_alpha( high, n );
@@ -460,6 +473,7 @@ const void GreensFunction2DRadAbs::GiveRootInterval(
     return;
 }
 
+
 // Simply returns an interval based upon previous root, estimated interval 
 // inbetween roots and INTERVAL_MARGIN (see .hpp).
 const void GreensFunction2DRadAbs::GiveRootIntervalSimple(
@@ -474,7 +488,7 @@ const void GreensFunction2DRadAbs::GiveRootIntervalSimple(
 
     // get estimated interval
     const Real estimated_alpha_root_distance_( this->getestimated_alpha_root_distance_() );
- 
+
     // Calculates interval [low, high] where root is expected based on the 
     // assumption where in a converging regime, where the deviation from this
     // estimate is not more than INTERVAL_MARGIN.     
@@ -486,12 +500,13 @@ const void GreensFunction2DRadAbs::GiveRootIntervalSimple(
     return;
 }
 
+
 // This function calls the GSL root finder, for roots for which n = 0. (This is
 // a special case for which the function simplifies.)
 const Real 
 GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
-                                      const Real high   // .. and high 
-                                    ) const
+                                       const Real high  // .. and high 
+                                     ) const
 {                                    
     // Reinterpret_cast converts any pointer type to any other pointer type, 
     // even of unrelated classes. Hence below code converts pointer to 
@@ -506,7 +521,7 @@ GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
         reinterpret_cast<typeof(F.function)>
         ( &GreensFunction2DRadAbs::f_alpha0_aux_F ),
         &params 
-    };				
+    };
 
     // Define solvertype.
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  
@@ -515,28 +530,28 @@ GreensFunction2DRadAbs::getAlphaRoot0( const Real low,  // root lies between low
 
     // Call rootfinder, find root called "alpha" and return it.
     const Real alpha ( findRoot( F, solver, low, high,
-		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRoot0" ) );
+                EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRoot0" ) );
     gsl_root_fsolver_free( solver );
     
-//    const Real sigma(getSigma());
+//  const Real sigma(getSigma());
     return alpha; 
 }    
 
+
 // This function calls the GSL root finder, for roots for which n > 0. (n = 0 is
 // a special case for which the function simplifies.)
 const Real 
 GreensFunction2DRadAbs::getAlphaRootN( const Real low,  // root lies between low
-                                      const Real high,  // .. and high 
-                                      const Integer n   // nth order Bessel
-                                    ) const
+                                       const Real high, // .. and high 
+                                       const Integer n  // nth order Bessel
+                                     ) const
 {                                    
-
     // f_alpha_aux_params is a struct: {gf, n, value}
     // n is the summation index (the order of the Bessel functions used
     f_alpha_aux_params params = { this, n, 0 };	// TODO: purpose of this zero is unclear!!!
     
     gsl_function F = 
-    {	    
+    {
         reinterpret_cast<typeof(F.function)>
         ( &GreensFunction2DRadAbs::f_alpha_aux_F ),
         &params
@@ -549,12 +564,13 @@ GreensFunction2DRadAbs::getAlphaRootN( const Real low,  // root lies between low
 
     // Call rootfinder, find root called "alpha" and return it.
     const Real alpha ( findRoot( F, solver, low, high,
-		 EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRootN" ) );
+                EPSILON/L_TYPICAL, EPSILON, "GreensFunction2DRadAbs::getAlphaRootN" ) );
     gsl_root_fsolver_free( solver );
     
     return alpha;
 }
 
+
 // Simply calls the correct function to call the rootfinder (either 
 // getAlphaRoot0 or getAlphaRootN).
 const Real 
@@ -563,6 +579,7 @@ GreensFunction2DRadAbs::getAlphaRoot( const Real low,   // root lies between low
                                       const Integer n   // nth order Bessel
                                     ) const
 {
+  
     Real alpha;
 
     if (n == 0) {
@@ -574,6 +591,7 @@ GreensFunction2DRadAbs::getAlphaRoot( const Real low,   // root lies between low
     return alpha;
 }
 
+
 // Subfunction of getAlpha
 // 
 // The function just counts the number of times the root lies in the interval 
@@ -583,10 +601,9 @@ GreensFunction2DRadAbs::getAlphaRoot( const Real low,   // root lies between low
 // equal the interval +/- margin.
 // TODO: This could be more sophisticated.
 const void GreensFunction2DRadAbs::decideOnMethod2(size_t n, 
-                                                   RealVector::size_type i
+                                                  RealVector::size_type i
                                                   ) const
 {    
-
     // Since the function can only decide with two alpha's already calculated, 
     // it can't do anything if i = 0.
     if (i > 0) { 
@@ -613,20 +630,21 @@ const void GreensFunction2DRadAbs::decideOnMethod2(size_t n,
     return;
 }
 
+
 // This function searches for roots (y=0) of the so-called alpha-function 
 // (::f_alpha()). It either moves a small search interval along the x-axis to
 // check for sign-change (which would indicate a root), and calls the GSL
 // root finder, or directly calls the root finder if the spacing between 
 // roots is found to be converged. 
 const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
-                                             RealVector::size_type i // ith root
-                                           ) const 
+                                            RealVector::size_type i // ith root
+                                          ) const 
 {
-//    const Real sigma(this->getSigma());
+  
+//  const Real sigma(this->getSigma());
     Real current_root_, low, high;   
     
     // # "Administration"
-
     // Equals reading/writing to/from alphaTable to reading/writing from/to to 
     // this->alphaTable[n]; n being the order of the Bessel function. 
     // (Funky pointer operations.)
@@ -648,8 +666,8 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
         {
             if (alphaTable[j] != 0)		
             {
-                std::cerr << "Error: tried accessing root that's not 0. Didn't search.. \n";
-                std::cerr << "       i = " << i << ", oldSize = " << oldSize << ", j = " << j << " \n";                
+                log_.error("tried accessing root that's not 0. Didn't search..");
+                log_.error("    i = %g, oldSize = %g, j = %g", i, oldSize, j);
             }  else   
             {
                 // Method 1. SCANNING. If the roots are not expected to lie close enough 
@@ -658,7 +676,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                 //      If it is established that we can use method 2, 
                 // alpha_x_scan_table_[n] will contain a value < 0.
                 if (alpha_x_scan_table_[n] >= 0)
-                {		                        
+                {
                     // ### Gets estimate of interval by sign-change-searching
                     //      high and low are the return-values of GiveRootInterval.
                     GiveRootInterval(low, high, n);	        
@@ -667,10 +685,10 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                     current_root_ = getAlphaRoot(low, high, n);
                     
                     // ### Puts the found root in the table.
-	                alphaTable[j]= current_root_;
-	                		    
-	                // Check if we can use method 2 for next roots
-	                decideOnMethod2(n, j);		    
+                        alphaTable[j]= current_root_;
+                                            
+                        // Check if we can use method 2 for next roots
+                        decideOnMethod2(n, j);		    
                 }
                 // Method 2. ASSUMING ROOTS AT ~FIXED INTERVAL. If next root is expected 
                 // to lie at distance close enough to estimated distance the root finder 
@@ -684,7 +702,7 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
                     current_root_ = getAlphaRoot(low, high, n);
 
                     // ### Puts the found root in the table.
-	                alphaTable[j] = current_root_;		    
+                        alphaTable[j] = current_root_;		    
                 }
             }
         }
@@ -699,31 +717,37 @@ const Real GreensFunction2DRadAbs::getAlpha( size_t n,               // order
 // End modification
 // =============================================================================
 
+
 // calculates the ith term with exponent and time for the survival probability
 const Real 
 GreensFunction2DRadAbs::p_survival_i_exp_table( const unsigned int i,
-							const Real t,
-							const RealVector& table ) const
+                                                const Real t,
+                                                const RealVector& table ) const
 {
+  
     const Real alpha( this->getAlpha( 0, i ) );
     return std::exp( - getD() * t * alpha * alpha ) * table[i];
 }
 
+
 // adds the exponential with the time to the sum. Needed for the calculation of the flux throught the outer
 // interface
 const Real 
 GreensFunction2DRadAbs::leavea_i_exp( const unsigned int i,
-					      const Real t) const
+                                              const Real t) const
 {
+  
     const Real alpha( this->getAlpha( 0,i ) );
     return std::exp( - getD() * t * alpha * alpha ) * calc_A_i_0( alpha );
 }
 
+
 // adds the exponential with the time to the sum. Needed for the inner interface (reaction)
 const Real 
 GreensFunction2DRadAbs::leaves_i_exp( const unsigned int i,
-					      const Real t) const
+                                              const Real t) const
 {
+  
     const Real alpha( this->getAlpha( 0, i ) );
 
     return std::exp( - getD() * t * alpha * alpha ) * leaves_i( alpha );
@@ -733,28 +757,29 @@ GreensFunction2DRadAbs::leaves_i_exp( const unsigned int i,
 // calculates the Bossen function for a given r
 const Real
 GreensFunction2DRadAbs::p_int_r_i_exp_table( const unsigned int i,
-				                     const Real r,
-                				     const RealVector& Y0_aAnTable,
-               					     const RealVector& J0_aAnTable,
-							const RealVector& Y0J1J0Y1Table ) const
+                                             const Real r,
+                                             const RealVector& Y0_aAnTable,
+                                             const RealVector& J0_aAnTable,
+                                             const RealVector& Y0J1J0Y1Table ) const
 {
-	const Real alpha( this->getAlpha( 0, i ) );	// get the root An
-	const Real r_An( r*alpha);
-   
-	const Real J1_rAn (gsl_sf_bessel_J1(r_An));
-	const Real Y1_rAn (gsl_sf_bessel_Y1(r_An));
-
-	const Real result (Y0_aAnTable[i]*r*J1_rAn - J0_aAnTable[i]*r*Y1_rAn - Y0J1J0Y1Table[i]);
-	return result;
+  
+        const Real alpha( this->getAlpha( 0, i ) );	// get the root An
+        const Real r_An( r*alpha);
+  
+        const Real J1_rAn (gsl_sf_bessel_J1(r_An));
+        const Real Y1_rAn (gsl_sf_bessel_Y1(r_An));
+
+        const Real result (Y0_aAnTable[i]*r*J1_rAn - J0_aAnTable[i]*r*Y1_rAn - Y0J1J0Y1Table[i]);
+        return result;
 }
 
 
 // This tries to guess the maximum number of n iterations it needs for calculating the survival probability
 // Not really sure yet how this works
-
 const unsigned int
 GreensFunction2DRadAbs::guess_maxi( const Real t ) const
 {
+  
     const unsigned int safety( 2 );
 
     if( t >= INFINITY )
@@ -789,6 +814,7 @@ GreensFunction2DRadAbs::guess_maxi( const Real t ) const
 const Real 
 GreensFunction2DRadAbs::p_survival( const Real t) const
 {
+  
     RealVector psurvTable;
 
     const Real p( p_survival_table( t, psurvTable ) );
@@ -796,66 +822,71 @@ GreensFunction2DRadAbs::p_survival( const Real t) const
     return p;
 }
 
+
 // This actually calculates the Survival probability at time t given the particle was at r0 at time 0
 // It uses the pSurvTable for efficiency (so you don't have to calculate all the constant factors all
 // the time)
 const Real 
-GreensFunction2DRadAbs::p_survival_table( const Real t,
-		  				  RealVector& psurvTable ) const
+GreensFunction2DRadAbs::p_survival_table( const        Real t,
+                                          RealVector&  psurvTable ) const
 {
-	Real p;
-	const unsigned int maxi( guess_maxi( t ) );	// guess the maximum number of iterations required
-//	const unsigned int maxi( 500 );	// THIS LEADS TO BIZARRE RESULTS
+  
+    Real p;
+    const unsigned int maxi( guess_maxi( t ) ); // guess the maximum number of iterations required
+//  const unsigned int maxi( 500 );             // THIS LEADS TO BIZARRE RESULTS
             
     // If the estimated # terms needed for convergence is bigger than number
     // of terms summed over (MAX_ALPHA_SEQ), give error.
     if( maxi == this->MAX_ALPHA_SEQ )
-        std::cerr << " p_survival_table (used by drawTime) couldn't converge; max terms reached: " << maxi << std::endl;
-           
-    if( psurvTable.size() < maxi + 1 )		// if the dimensions are good then this means
-    {						// that the table is filled
-    	IGNORE_RETURN getAlpha( 0, maxi );	// this updates the table of roots
-            this->createPsurvTable( psurvTable);	// then the table is filled with data
+        log_.warn("p_survival_table (used by drawTime) couldn't converge; max terms reached: %u", maxi);
+          
+    if( psurvTable.size() < maxi + 1 )           // if the dimensions are good then this means
+    {                                            // that the table is filled
+        IGNORE_RETURN getAlpha( 0, maxi );       // this updates the table of roots
+            this->createPsurvTable( psurvTable); // then the table is filled with data
     }
     // A sum over terms is performed, where convergence is assumed. It is not 
     // clear if this is a just assumption.
     // TODO!
     p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
-                                      this,
-                                      _1, t, psurvTable ),
-                     maxi );	// calculate the sum at time t
-
+                                  this,
+                                  _1, t, psurvTable ),
+                                  maxi ); // calculate the sum at time t
     return p*M_PI*M_PI_2;
 }
 
+
 // calculates the flux leaving through the inner interface at a given moment
 // FIXME: This is inaccurate for small t's!!
 const Real 
 GreensFunction2DRadAbs::leaves( const Real t) const
 {
+  
     const Real sigma(this->getSigma());
     const Real D(this->getD() );
 
     const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::leaves_i_exp,
                                         this,
                                         _1, t),
-                           this->MAX_ALPHA_SEQ ) );
+                                        this->MAX_ALPHA_SEQ ) );
 
-    return M_PI_2*M_PI*D*sigma*p;	// The minus is not there because the flux is in the negative r
-					// direction, and the direction is already accounted for in the derivative of B0,n(r)
-					// See also leaves_i
+    return M_PI_2*M_PI*D*sigma*p; // The minus is not there because the flux is in the negative r
+                                  // direction, and the direction is already accounted for in the derivative of B0,n(r)
+                                  // See also leaves_i
 }
 
+
 // calculates the flux leaving through the outer interface at a given moment
 const Real 
 GreensFunction2DRadAbs::leavea( const Real t) const
 {
+  
     const Real D(this->getD() );
 
     const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::leavea_i_exp,
                                         this,
                                         _1, t),
-                           this->MAX_ALPHA_SEQ ) );
+                                        this->MAX_ALPHA_SEQ ) );
     return M_PI*D*p;
 }
 
@@ -863,25 +894,28 @@ GreensFunction2DRadAbs::leavea( const Real t) const
 // calculates the sum of the sequence for drawR based upon the values in the tables and r
 const Real
 GreensFunction2DRadAbs::p_int_r_table( const Real r,
-               					const RealVector& Y0_aAnTable,
-               					const RealVector& J0_aAnTable,
-               					const RealVector& Y0J1J0Y1Table ) const
+                                       const RealVector& Y0_aAnTable,
+                                       const RealVector& J0_aAnTable,
+                                       const RealVector& Y0J1J0Y1Table ) const
 {
+  
     const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::p_int_r_i_exp_table,
                                         this,
                                         _1, r, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table ),
-                           Y0_aAnTable.size() ) );
+                                        Y0_aAnTable.size() ) );
     return p*M_PI*M_PI_2;
 }
 
+
 // Used by drawTime
 // Wrapper for p_survival_table for the interator to find the root for drawTime
 const Real
 GreensFunction2DRadAbs::p_survival_table_F( const Real t,
-                    					const p_survival_table_params* params )
+                                            const p_survival_table_params* params )
 {
+  
     const GreensFunction2DRadAbs* const gf( params->gf ); // the current gf (not sure why this is here)
-    RealVector& table( params->table );		// table is empty but will be filled in p_survival_table
+    RealVector& table( params->table ); // table is empty but will be filled in p_survival_table
     const Real rnd( params->rnd );
 
     return rnd - gf->p_survival_table( t, table );
@@ -891,8 +925,9 @@ GreensFunction2DRadAbs::p_survival_table_F( const Real t,
 // a wrapper to make p_int_r_table available to the iterator calculating the root
 const Real
 GreensFunction2DRadAbs::p_int_r_F( const Real r,
-					   const p_int_r_params* params )
+                                   const p_int_r_params* params )
 {
+  
     const GreensFunction2DRadAbs* const gf( params->gf ); 
     const RealVector& Y0_aAnTable( params->Y0_aAnTable );
     const RealVector& J0_aAnTable( params->J0_aAnTable );
@@ -907,6 +942,7 @@ GreensFunction2DRadAbs::p_int_r_F( const Real r,
 // the inner boundary)
 Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 {
+  
     const Real D( this->getD() );
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
@@ -918,97 +954,97 @@ Real GreensFunction2DRadAbs::drawTime( const Real rnd) const
 
     Real t_guess;
 
-    if( r0 == a || a == sigma )		// when the particle is at the border or if the PD has no real size
+    if( r0 == a || a == sigma ) // when the particle is at the border or if the PD has no real size
     {
-	return 0.0;
+        return 0.0;
     }
 
     // get some initial guess for the time, dr=sqrt(2dDt) with d
     // the dimensionality (2 in this case)
     const Real t_Abs( gsl_pow_2( a - r0 ) / ( 4.0 * D ) );
-    if ( kf == 0.0 )			// if there was only one absorbing boundary
+    if ( kf == 0.0 ) // if there was only one absorbing boundary
     {	
         t_guess = t_Abs;
     }
     else
-    {	
+    {
         const Real t_Rad( D / gsl_pow_2( kf/(2*M_PI*a) ) + gsl_pow_2( r0 - sigma ) / D );
-        t_guess = std::min( t_Abs, t_Rad );	// take the shortest time to a boundary
+        t_guess = std::min( t_Abs, t_Rad ); // take the shortest time to a boundary
     }
     
     t_guess *= .1;
     
-	const Real minT( std::min( sigma * sigma / D * this->MIN_T_FACTOR,
-                               t_guess * 1e-7 ) );	// something with determining the lowest possible t
-
-
-	RealVector psurvTable;		// this is still empty as of now->not used
-	p_survival_table_params params = { this, psurvTable, rnd };
-	gsl_function F = 
-	{
-	    reinterpret_cast<typeof(F.function)>( &p_survival_table_F ),
-	    &params 
-	};
-
-	// put in a upper and lower limit (the picked time cannot be infinite!)
-	Real low( t_guess );	
-	Real high( t_guess );
-
-	// adjust high and low to make sure that f( low ) and f( high ) straddle.
-	Real value( GSL_FN_EVAL( &F, t_guess ) );
-
-	if( value < 0.0 )			// if the function is below zero at the guess the upper
-	{					// boundary should be moved (passed the zero point)
-		do
-		{
-			high *= 10;
-			value = GSL_FN_EVAL( &F, high );
-            
-			if( fabs( high ) >= 1e10 )	// if high time is way too high forget about it
-			{
-				std::cerr << "Couldn't adjust high. F(" << high <<
-					") = " << GSL_FN_EVAL( &F, high ) << "; r0 = " << r0 << 
-					", " << dump() << std::endl;
-				throw std::exception();
-			}
-		}
-		while ( value < 0.0 );
-	}
-	else				// if the function is over zero (or at zero!) then the lower
-	{					// boundary should be moved
-                Real value_prev( value );
-                do
-                {       low *= .1;      // keep decreasing the lower boundary until the function straddles
-                        value = GSL_FN_EVAL( &F, low );     // get the accompanying value
-
-                        if( fabs( low ) <= minT || fabs( value - value_prev ) < EPSILON*this->T_TYPICAL )
-                        {
-                                std::cerr << "Couldn't adjust low. F(" << low <<
-                                        ") = " << value << std::endl;
-                                return low;
-                        }
-                        value_prev = value;
-                }
-                while ( value >= 0.0 );
+    const Real minT( std::min( sigma * sigma / D * this->MIN_T_FACTOR,
+                          t_guess * 1e-7 ) ); // something with determining the lowest possible t
+
+
+    RealVector psurvTable; // this is still empty as of now->not used
+    p_survival_table_params params = { this, psurvTable, rnd };
+    gsl_function F = 
+    {
+        reinterpret_cast<typeof(F.function)>( &p_survival_table_F ),
+        &params 
+    };
+
+    // put in a upper and lower limit (the picked time cannot be infinite!)
+    Real low( t_guess );	
+    Real high( t_guess );
+
+    // adjust high and low to make sure that f( low ) and f( high ) straddle.
+    Real value( GSL_FN_EVAL( &F, t_guess ) );
+
+    if( value < 0.0 )                   // if the function is below zero at the guess the upper
+    {                                   // boundary should be moved (passed the zero point)
+            do
+            {
+                    high *= 10;
+                    value = GSL_FN_EVAL( &F, high );
+        
+                    if( fabs( high ) >= 1e10 )	// if high time is way too high forget about it
+                    {
+                            log_.warn("Couldn't adjust high. F(%.16g) = %.16g; r0 = %.16g,", high, GSL_FN_EVAL( &F, high ), r0);
+                            std::cerr << dump() << std::endl;
+                            throw std::exception();
+                    }
+            }
+            while ( value < 0.0 );
+    }
+    else                                // if the function is over zero (or at zero!) then the lower
+    {                                   // boundary should be moved
+            Real value_prev( value );
+            do
+            {       low *= .1;      // keep decreasing the lower boundary until the function straddles
+                    value = GSL_FN_EVAL( &F, low );     // get the accompanying value
+
+                    if( fabs( low ) <= minT || fabs( value - value_prev ) < EPSILON*this->T_TYPICAL )
+                    {
+                            log_.warn("Couldn't adjust low. F(%.16g) = %.16g", low, value);
+                            return low;
+                    }
+                    value_prev = value;
+            }
+            while ( value >= 0.0 );
     }
 
     // find the intersection of the cummulative survival probability and the randomly generated number
-    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );	// initialize the solver
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent ); // initialize the solver
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
 
-    const Real t( findRoot( F, solver, low, high,		// find the intersection between the random
-		EPSILON*T_TYPICAL, EPSILON, "GreensFunction2DRadAbs::drawTime" ) );
-								// number and the cumm probability
+    const Real t( findRoot( F, solver, low, high,               // find the intersection between the random
+                EPSILON*T_TYPICAL, EPSILON, "GreensFunction2DRadAbs::drawTime" ) );
+                                                                // number and the cumm probability
     gsl_root_fsolver_free( solver );
 
     return t;
 }
 
+
 // This determines based on the flux at a certain time, if the 'escape' was a reaction or a proper escape
 GreensFunction2DRadAbs::EventKind
 GreensFunction2DRadAbs::drawEventType( const Real rnd, 
-					       const Real t ) const
+                                       const Real t     ) const
 {
+  
     const Real D( this->getD() );
     const Real sigma( this->getSigma() );
     const Real kf( this->getkf() );
@@ -1019,7 +1055,7 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
     THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 < a );
     THROW_UNLESS( std::invalid_argument, t > 0.0 );
 
-    if( kf == 0.0 )	// if there cannot be any flow through the radiating boundary it is always an escape
+    if( kf == 0.0 ) // if there cannot be any flow through the radiating boundary it is always an escape
     {
         return IV_ESCAPE;
     }
@@ -1057,18 +1093,20 @@ GreensFunction2DRadAbs::drawEventType( const Real rnd,
 
     if( rnd <= value )  
     {
-	return IV_REACTION;   // leaves -> return 0
+        return IV_REACTION;   // leaves -> return 0
     }
     else 
     {
-	return IV_ESCAPE;     // leavea -> return 1
+        return IV_ESCAPE;     // leavea -> return 1
     }
 }
 
+
 // This draws a radius R at a given time, provided that the particle was at r0 at t=0
 Real GreensFunction2DRadAbs::drawR( const Real rnd, 
-						  const Real t ) const
-{     
+                                    const Real t        ) const
+{
+
     // Diffusion constant, inner boundary, outer boundary, starting r.
     const Real D( this->getD() );
     const Real sigma( getSigma() );
@@ -1078,16 +1116,16 @@ Real GreensFunction2DRadAbs::drawR( const Real rnd,
     THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
     THROW_UNLESS( std::invalid_argument, r0 >= sigma && r0 < a );
 
-    if( t == 0.0 )		// if no time has passed
+    if( t == 0.0 ) // if no time has passed
     {
-	return r0;
+        return r0;
     }
 
-    const Real psurv( p_survival( t ) );	// calculate the survival probability at this time
-						// this is used as the normalization factor
-						// BEWARE!!! This also produces the roots An and therefore
-						// SETS THE HIGHEST INDEX -> side effect
-						// VERY BAD PROGRAMMING PRACTICE!!
+    const Real psurv( p_survival( t ) ); // calculate the survival probability at this time
+                                         // this is used as the normalization factor
+                                         // BEWARE!!! This also produces the roots An and therefore
+                                         // SETS THE HIGHEST INDEX -> side effect
+                                         // VERY BAD PROGRAMMING PRACTICE!!
 
     RealVector Y0_aAnTable;
     RealVector J0_aAnTable;
@@ -1097,15 +1135,15 @@ Real GreensFunction2DRadAbs::drawR( const Real rnd,
     p_int_r_params params = { this, t, Y0_aAnTable, J0_aAnTable, Y0J1J0Y1Table, rnd * psurv };
 
     gsl_function F = 
-	{
-	    reinterpret_cast<typeof(F.function)>( &p_int_r_F ),
-	    &params 
-	};
+        {
+            reinterpret_cast<typeof(F.function)>( &p_int_r_F ),
+            &params 
+        };
 
     // adjust low and high starting from r0.
     // this is necessary to avoid root finding in the long tails where
     // numerics can be unstable.
-    Real low( r0 );				// start with the initial position as the first guess
+    Real low( r0 );             // start with the initial position as the first guess
     Real high( r0 );
     Real value (0);
     unsigned int H( 3 );
@@ -1113,14 +1151,14 @@ Real GreensFunction2DRadAbs::drawR( const Real rnd,
     const Real msd( sqrt( 4.0 * D * t ) );
     if( GSL_FN_EVAL( &F, r0 ) < 0.0 )
     {
-	do
+        do
         {
             high = r0 + H * msd;
             if( high > a )
             {
-                if( GSL_FN_EVAL( &F, a ) < 0.0 )	// something is very wrong, this should never happen
+                if( GSL_FN_EVAL( &F, a ) < 0.0 )        // something is very wrong, this should never happen
                 {
-                    printf( "drawR: p_int_r_table( a ) < 0.0. returning a.\n" );
+                    log_.warn("drawR: p_int_r_table( a ) < 0.0. Returning a.");
                     return a;
                 }
                 high = a;
@@ -1129,20 +1167,19 @@ Real GreensFunction2DRadAbs::drawR( const Real rnd,
             value = GSL_FN_EVAL( &F, high );
             ++H;
         }
-	while (value < 0.0);
+        while (value < 0.0);
 
     }
     else
     {
-	do
+        do
         {
             low = r0 - H * msd;
             if( low < sigma )
             {
                 if( GSL_FN_EVAL( &F, sigma ) > 0.0 )
                 {
-                    printf( "drawR: p_int_r_table( sigma ) > 0.0. "
-                            "returning sigma.\n" );
+                    log_.warn("drawR: p_int_r_table( sigma ) > 0.0. Returning sigma.");
                     return sigma;
                 }
 
@@ -1153,261 +1190,265 @@ Real GreensFunction2DRadAbs::drawR( const Real rnd,
             value = GSL_FN_EVAL( &F, low );
             ++H;
         }
-	while ( value > 0.0 );
+        while ( value > 0.0 );
     }
 
 
     // root finding by iteration.
     const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
     gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-    const Real r( findRoot( F, solver, low, high,		// find the intersection between the random
-		 L_TYPICAL*EPSILON, EPSILON, "GreensFunction2DRadAbs::drawR" ) );
-								// number and the cumm probability
+    const Real r( findRoot( F, solver, low, high,               // find the intersection between the random
+                L_TYPICAL*EPSILON, EPSILON, "GreensFunction2DRadAbs::drawR" ) );
+                                                                // number and the cumm probability
     gsl_root_fsolver_free( solver );
 
     return r;
 }
 
 
-
 // The calculates constant factor m,n for the drawing of theta. These factors are summed later.
 const Real GreensFunction2DRadAbs::p_m_alpha( const unsigned int n,
-						      const unsigned int m,
-						      const Real r,
-						      const Real t ) const
+                                              const unsigned int m,
+                                              const Real r,
+                                              const Real t          ) const
 {
-	const Real sigma( this->getSigma() );
-	const Real h( this->geth() );
-	const Real a( this->geta() );
-	const Real D( this->getD() );
-	const Real alpha( this->getAlpha( m, n ) ); // Gets the n-th root using the 
-	                                            // besselfunctions of order m.
-	const Real r0( this->getr0() );
-
-	const Real alpha_sq( alpha * alpha );
-	const Real realm( static_cast<Real>( m ) );
-	const Real msq( realm * realm);
-	const Real ssq( sigma * sigma);
-
-	const Real s_Anm (sigma * alpha);
-	const Real a_Anm (a * alpha);
-	const Real r0Anm (r0 * alpha);
-	const Real r_Anm (r * alpha);
-
-//	const CylindricalBesselGenerator& s(CylindricalBesselGenerator::instance());
-
-	// calculate the needed bessel functions
-	const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
-	const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));	// prime
-//	const Real Jm_sAnm   (s.J(m, s_Anm));
-//	const Real Jmp1_sAnm (s.J(m+1, s_Anm));	// prime
-
-	const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
-	const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
-//	const Real Jm_aAnm   (s.J(m, a_Anm));
-//	const Real Ym_aAnm   (s.Y(m, a_Anm));
-
-	const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
-	const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
-//	const Real Jm_r0Anm  (s.J(m, r0Anm));
-//	const Real Ym_r0Anm  (s.Y(m, r0Anm));
-
-	const Real Jm_rAnm   (gsl_sf_bessel_Jn(m, r_Anm));
-	const Real Ym_rAnm   (gsl_sf_bessel_Yn(m, r_Anm));
-//	const Real Jm_rAnm   (s.J(m, r_Anm));
-//	const Real Ym_rAnm   (s.Y(m, r_Anm));
-
-	// calculating An,m
-	const Real h_ma (h - realm/sigma);
-	const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
-	const Real rho_sq (rho*rho);
-	// calculating Bn,m(r')
-	const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
-
-	const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
+  
+    const Real sigma( this->getSigma() );
+    const Real h( this->geth() );
+    const Real a( this->geta() );
+    const Real D( this->getD() );
+    const Real alpha( this->getAlpha( m, n ) ); // Gets the n-th root using the 
+                                                // besselfunctions of order m.
+    const Real r0( this->getr0() );
 
+    const Real alpha_sq( alpha * alpha );
+    const Real realm( static_cast<Real>( m ) );
+    const Real msq( realm * realm);
+    const Real ssq( sigma * sigma);
+
+    const Real s_Anm (sigma * alpha);
+    const Real a_Anm (a * alpha);
+    const Real r0Anm (r0 * alpha);
+    const Real r_Anm (r * alpha);
+
+//  const CylindricalBesselGenerator& s(CylindricalBesselGenerator::instance());
+
+    // calculate the needed bessel functions
+    const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
+    const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));	// prime
+//  const Real Jm_sAnm   (s.J(m, s_Anm));
+//  const Real Jmp1_sAnm (s.J(m+1, s_Anm));	// prime
+
+    const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
+    const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm));
+//  const Real Jm_aAnm   (s.J(m, a_Anm));
+//  const Real Ym_aAnm   (s.Y(m, a_Anm));
+
+    const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
+    const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm));
+//  const Real Jm_r0Anm  (s.J(m, r0Anm));
+//  const Real Ym_r0Anm  (s.Y(m, r0Anm));
+
+    const Real Jm_rAnm   (gsl_sf_bessel_Jn(m, r_Anm));
+    const Real Ym_rAnm   (gsl_sf_bessel_Yn(m, r_Anm));
+//  const Real Jm_rAnm   (s.J(m, r_Anm));
+//  const Real Ym_rAnm   (s.Y(m, r_Anm));
+
+    // calculating An,m
+    const Real h_ma (h - realm/sigma);
+    const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
+    const Real rho_sq (rho*rho);
+    // calculating Bn,m(r')
+    const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
 
-	// calculating Bn,m(r*)
-	const Real B_n_m_r (Jm_rAnm * Ym_aAnm  -  Ym_rAnm * Jm_aAnm);
+    const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
 
+    // calculating Bn,m(r*)
+    const Real B_n_m_r (Jm_rAnm * Ym_aAnm  -  Ym_rAnm * Jm_aAnm);
 
-	// calculating the result
-	const Real result( A_n_m * B_n_m_r * exp(-D*alpha_sq*t) );
+    // calculating the result
+    const Real result( A_n_m * B_n_m_r * exp(-D*alpha_sq*t) );
 
-	return result;
+    return result;
 }
 
 
 // This calculates the m-th constant factor for the drawTheta method. 
 const Real 
 GreensFunction2DRadAbs::p_m( const Integer m,
-				     const Real r,
-				     const Real t ) const
+                             const Real r,
+                             const Real t     ) const
 {
+  
     const Real p( funcSum( boost::bind( &GreensFunction2DRadAbs::p_m_alpha,
-					this,
-					_1, m, r, t ),	// The m-th factor is a summation over n
-			   MAX_ALPHA_SEQ, EPSILON ) );
+                                        this,
+                                        _1, m, r, t ), // The m-th factor is a summation over n
+                          MAX_ALPHA_SEQ, EPSILON ) );
     return p;
 }
 
+
 // this should make the table of constants used in the iteration for finding the root for drawTheta
 // The index of the array is consistent with the index of the summation
 void
 GreensFunction2DRadAbs::makep_mTable( RealVector& p_mTable,
-					      const Real r, 
-					      const Real t ) const
+                                      const Real r, 
+                                      const Real t          ) const
 {
-	p_mTable.clear();
-
-	const Real p_0 ( this->p_m( 0, r, t ) );	// This is the p_m where m is 0, for the denominator
-	p_mTable.push_back( p_0 );			// put it in the table
-
-	const Real p_1 ( this->p_m( 1, r, t ) / p_0 );
-	p_mTable.push_back( p_1 );			// put the first result in the table
-
-	if( p_1 == 0 )
-	{
-		return;					// apparantly all the terms are zero? We are finished
-		                        // TODO: is this assumption correct??
-	}
-
-	const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error, is this correct?
-
-	Real p_m_abs (fabs (p_1));
-	Real p_m_prev_abs;	
-	unsigned int m( 1 );
-	do
-	{
-		m++;
-		if( m >= this->MAX_ORDER )		// If the number of terms is too large
-		{
-			std::cerr << "p_m didn't converge (m=" << m << "), t = " << t << " r0, r = " << getr0() << ", " << r << 
-			    " t_est = " << gsl_pow_2( r - getr0() ) / getD() << ", continuing..." << std::endl;
-    		std::cerr << dump() <<std::endl;	    
-			break;
-		}
-
-		p_m_prev_abs = p_m_abs;					// store the previous term
-		const Real p_m( this->p_m( m, r, t ) / p_0 );	// get the next term
-
-		if( ! std::isfinite( p_m ) )		// if the calculated value is not valid->exit
-		{
-			std::cerr << "makep_mTable: invalid value; " <<
-				p_m << "( m= " << m << ")." << std::endl;
-			break;
-		}
-
-		p_mTable.push_back( p_m );				// put the result in the table
-		p_m_abs = fabs( p_m );					// take the absolute value
-        }
-	while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
+  
+    p_mTable.clear();
+
+    const Real p_0 ( this->p_m( 0, r, t ) ); // This is the p_m where m is 0, for the denominator
+    p_mTable.push_back( p_0 );               // put it in the table
+
+    const Real p_1 ( this->p_m( 1, r, t ) / p_0 );
+    p_mTable.push_back( p_1 );               // put the first result in the table
+
+    if( p_1 == 0 )
+    {
+            return; // apparantly all the terms are zero? We are finished
+                    // TODO: is this assumption correct??
+    }
+
+    const Real threshold( fabs( EPSILON * p_1  ) ); // get a measure for the allowed error, is this correct?
+
+    Real p_m_abs (fabs (p_1));
+    Real p_m_prev_abs;	
+    unsigned int m( 1 );
+    do
+    {
+            m++;
+            if( m >= this->MAX_ORDER ) // If the number of terms is too large
+            {
+                    log_.warn("p_m didn't converge (m=%u, t=%.16g, r0=%.16g, r=%.16g, t_est=%.16g, continuing...", 
+                               m, t, getr0(), r, gsl_pow_2( r - getr0() ) / getD() 
+                             );
+                    std::cerr << dump() << std::endl;
+                    break;
+            }
+
+            p_m_prev_abs = p_m_abs;                             // store the previous term
+            const Real p_m( this->p_m( m, r, t ) / p_0 );       // get the next term
 
-	// truncate when converged enough.
-	// if the current term is smaller than threshold
-	// AND the previous term is also smaller than threshold
-	// AND the current term is smaller than the previous
-		
+            if( ! std::isfinite( p_m ) )                        // if the calculated value is not valid->exit
+            {
+                    log_.warn("makep_mTable: invalid value (p_m = %.16g, m=%u)", p_m, m);
+                    break;
+            }
+
+            p_mTable.push_back( p_m );  // put the result in the table
+            p_m_abs = fabs( p_m );      // take the absolute value
+    }
+    while (p_m_abs >= threshold || p_m_prev_abs >= threshold || p_m_abs >= p_m_prev_abs );
+
+    // truncate when converged enough.
+    // if the current term is smaller than threshold
+    // AND the previous term is also smaller than threshold
+    // AND the current term is smaller than the previous                
 }
 
+
 // This method calculates the constants for the drawTheta method when the particle is at the boundary
 const Real 
 GreensFunction2DRadAbs::dp_m_alpha_at_a( const unsigned int n,
-						 const unsigned int m,
-						 const Real t ) const
+                                         const unsigned int m,
+                                         const Real t           ) const
 {
-        const Real sigma( this->getSigma() );
-        const Real h( this->geth() );
-        const Real a( this->geta() );
-        const Real D( this->getD() );
-        const Real r0( this->getr0() );
+  
+    const Real sigma( this->getSigma() );
+    const Real h( this->geth() );
+    const Real a( this->geta() );
+    const Real D( this->getD() );
+    const Real r0( this->getr0() );
 
-        const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
-       
-        const Real alpha_sq( alpha * alpha );
-        const Real realm( static_cast<Real>( m ) );
-        const Real msq( realm * realm);
-        const Real ssq( sigma * sigma);
+    const Real alpha( this->getAlpha( m, n ) ); // get the n-th root using the besselfunctions of order m
+  
+    const Real alpha_sq( alpha * alpha );
+    const Real realm( static_cast<Real>( m ) );
+    const Real msq( realm * realm);
+    const Real ssq( sigma * sigma);
 
-        const Real s_Anm (sigma*alpha);
-        const Real a_Anm (a*alpha);
-        const Real r0Anm (r0*alpha);
+    const Real s_Anm (sigma*alpha);
+    const Real a_Anm (a*alpha);
+    const Real r0Anm (r0*alpha);
 
-        const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
-        const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    
-        const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
-        const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm)); 
+    const Real Jm_sAnm   (gsl_sf_bessel_Jn(m, s_Anm));
+    const Real Jmp1_sAnm (gsl_sf_bessel_Jn(m+1, s_Anm));    
+    const Real Jm_aAnm   (gsl_sf_bessel_Jn(m, a_Anm));
+    const Real Ym_aAnm   (gsl_sf_bessel_Yn(m, a_Anm)); 
 
-        const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
-        const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm)); 
+    const Real Jm_r0Anm  (gsl_sf_bessel_Jn(m, r0Anm));
+    const Real Ym_r0Anm  (gsl_sf_bessel_Yn(m, r0Anm)); 
 
-        // calculating An,m
-        const Real h_ma (h - realm/sigma);
-        const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
-        const Real rho_sq (rho*rho);
+    // calculating An,m
+    const Real h_ma (h - realm/sigma);
+    const Real rho (h_ma*Jm_sAnm + alpha*Jmp1_sAnm);
+    const Real rho_sq (rho*rho);
 
-        // calculating Bn,m(r')
-        const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
+    // calculating Bn,m(r')
+    const Real B_n_m_r0 (Jm_r0Anm * Ym_aAnm  -  Ym_r0Anm * Jm_aAnm);
 
-        const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
+    const Real A_n_m ((alpha_sq * rho_sq * B_n_m_r0)/( rho_sq - (Jm_aAnm*Jm_aAnm)*(h*h + alpha_sq - msq/ssq)));
 
-        // calculating the result
-        const Real result( A_n_m * exp(-D*alpha_sq*t) );
+    // calculating the result
+    const Real result( A_n_m * exp(-D*alpha_sq*t) );
 
-	return result;
+    return result;
 }
 
+
 // Makes the sum over n for order m for the constants for the drawtheta Method
 const Real 
 GreensFunction2DRadAbs::dp_m_at_a( const Integer m,
-					   const Real t ) const
+                                   const Real t     ) const
 {
-
     const Real p( funcSum( 
                         boost::bind( 
                             &GreensFunction2DRadAbs::dp_m_alpha_at_a,
-			                    this,
-			                    _1, 
-                                m,
-                                t 
+                            this,
+                            _1, 
+                            m,
+                            t 
                         ),
-		                MAX_ALPHA_SEQ, 
+                        MAX_ALPHA_SEQ, 
                         EPSILON 
-                  ) 
+                  )
                 );
 
-               // boost::bind 
-               // explanation by example:
-               // "bind(f, _1, 5)(x)"  is equivalent to "f(x, 5)"
-               // this means funcsum receives f(x, m=.., t=..) as
-               // input, with m and t already determined.
-    
-                // Arguments of dp_m_alpha_at_a:
-                // n, m, t
+    // boost::bind 
+    // explanation by example:
+    // "bind(f, _1, 5)(x)"  is equivalent to "f(x, 5)"
+    // this means funcsum receives f(x, m=.., t=..) as
+    // input, with m and t already determined.
+
+    // Arguments of dp_m_alpha_at_a:
+    // n, m, t
 
     return p;
 }
 
+
 // creates a tables of constants for drawTheta when the particle is at the edge of the domain
 void
 GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
-						    const Real t ) const
+                                            const Real  t          ) const
 {
+  
     p_mTable.clear();
 
-    const Real p_0 ( this->dp_m_at_a( 0, t ) );	// This is the p_m where m is 0, for the denominator
-    p_mTable.push_back( p_0 );                      // put it in the table
+    const Real p_0 ( this->dp_m_at_a( 0, t ) ); // This is the p_m where m is 0, for the denominator
+    p_mTable.push_back( p_0 );                  // put it in the table
 
     const Real p_1 ( this->dp_m_at_a( 1, t ) / p_0 );
-    p_mTable.push_back( p_1 );                      // put the first result in the table
+    p_mTable.push_back( p_1 );                  // put the first result in the table
 
 
     if( p_1 == 0 )
     {
-            return;                 // apparantly all the terms are zero? We are finished
+            return; // apparantly all the terms are zero? We are finished
     }
 
-    const Real threshold( fabs( EPSILON * p_1  ) );	// get a measure for the allowed error
+    const Real threshold( fabs( EPSILON * p_1  ) ); // get a measure for the allowed error
 
     Real p_m_abs (fabs (p_1));
     Real p_m_prev_abs;      
@@ -1415,15 +1456,15 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
     do
     {
             m++;
-            if( m >= this->MAX_ORDER )				// If the number of terms is too large
+            if( m >= this->MAX_ORDER ) // If the number of terms is too large
             {
-                    std::cerr << "dp_m didn't converge (m=" << m << "), continuing..." << std::endl;
+                    log_.warn("dp_m didn't converge (m=%u), continuing...", m);
                     break;
             }
 
 
-            p_m_prev_abs = p_m_abs;					// store the previous term
-            const Real p_m( this->dp_m_at_a( m, t ) / p_0 );	// get the next term
+            p_m_prev_abs = p_m_abs;                             // store the previous term
+            const Real p_m( this->dp_m_at_a( m, t ) / p_0 );    // get the next term
 
             // DEBUG (something to check in the future?)
             // if (p_m_abs == 0) {
@@ -1432,10 +1473,9 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
             // }
             // END DEBUG
 
-            if( ! std::isfinite( p_m ) )			// if the calculated value is not valid->exit
+            if( ! std::isfinite( p_m ) ) // if the calculated value is not valid->exit
             {
-                    std::cerr << "makedp_m_at_aTable: invalid value; " <<
-                            p_m << "( m= " << m << ")." << "( t= " << t << ")."<< "( p_0= " << p_0 << ")." << std::endl;
+                    log_.warn("makedp_m_at_aTable: invalid value (p_m=%.16g, m=%u, t=%.16g, p_0=%.16g)", p_m, m, t, p_0);
                     break;
             }
 
@@ -1449,14 +1489,16 @@ GreensFunction2DRadAbs::makedp_m_at_aTable( RealVector& p_mTable,
     // AND the current term is smaller than the previous
 }
 
+
 // This calculates the m-th term of the summation for the drawTheta calculation
 // Note that m here starts at 0 and in the equations the sum starts at 1!
 const Real 
 GreensFunction2DRadAbs::ip_theta_n( const unsigned int m,
-						const Real theta,
-						const RealVector& p_nTable) const
+                                    const Real theta,
+                                    const RealVector& p_nTable ) const
 {
-	const unsigned int m_p1 (m+1);		// artificial increase of m to make sure m starts at 1
+  
+        const unsigned int m_p1 (m+1); // artificial increase of m to make sure m starts at 1
         return p_nTable[m_p1] * sin (m_p1*theta)/m_p1;
 }
 
@@ -1466,26 +1508,29 @@ GreensFunction2DRadAbs::ip_theta_n( const unsigned int m,
 // It uses the p_nTable for it to speed things up
 const Real 
 GreensFunction2DRadAbs::ip_theta_table( const Real theta,
-						const RealVector& p_nTable ) const
+                                        const RealVector& p_nTable ) const
 {
-    const unsigned int maxm( p_nTable.size()-1 );	// get the length of the sum
-							// it is shifted one because the first entry should
-							// be used (m=0)
+  
+    const unsigned int maxm( p_nTable.size()-1 ); // get the length of the sum
+                                                  // it is shifted one because the first entry should
+                                                  // be used (m=0)
 
     const Real p( funcSum_all( boost::bind( &GreensFunction2DRadAbs::ip_theta_n,
-                                             this,
-                                             _1, theta, p_nTable ),
+                                            this,
+                                            _1, theta, p_nTable ),
                                 maxm ) );
     return p;
 }
 
+
 // function to iterate when drawing the theta
 const Real
 GreensFunction2DRadAbs::ip_theta_F( const Real theta,
-					    const ip_theta_params* params )
+                                    const ip_theta_params* params )
 {
+  
     const GreensFunction2DRadAbs* const gf( params->gf ); 
-    const RealVector& p_nTable( params->p_nTable );	// table with useful constants
+    const RealVector& p_nTable( params->p_nTable ); // table with useful constants
     const Real value( params->value );
 
     return theta/(M_PI*2) + (gf->ip_theta_table( theta, p_nTable )/M_PI) - value;
@@ -1495,140 +1540,144 @@ GreensFunction2DRadAbs::ip_theta_F( const Real theta,
 // This method draws a theta given a certain r and time (and intial condition of course)
 Real 
 GreensFunction2DRadAbs::drawTheta( const Real rnd,
-					   const Real r, 
-					   const Real t ) const
+                                   const Real r, 
+                                   const Real t   ) const
 {
+    
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
     const Real D( this->getD() );
     const Real r0( this->getr0() );
 
-	// input parameter range checks.
-	THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
-	THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
-	THROW_UNLESS( std::invalid_argument, sigma <= r && r <= a);
-	THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-
-	// t == 0 means no move.
-	if( t <= T_TYPICAL*EPSILON || D == 0 || fabs(r0 - a) <= EPSILON*L_TYPICAL || rnd <= EPSILON)
-	{
-		return 0.0;
-	}
-	else if (r == sigma)	// a reaction has occured, the angle is irrelevant
-	{
-		return 0.0;
-	}
-
-	// making the tables with constants
-
-	RealVector p_mTable;			// a table with constants to make calculationdraws much faster
-	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
-	{
-		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
-	}
-	else
-	{
-		makep_mTable( p_mTable, r, t );	// making the table of constants for the regular case
-	}
-
-	// preparing the function
-	
-	// ip_theta_params is a struct.
-	ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 };	// r, r0, t are not required	    
-	                                                        // 0.5 is not even used
+    // input parameter range checks.
+    THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
+    THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
+    THROW_UNLESS( std::invalid_argument, sigma <= r && r <= a);
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
+    // t == 0 means no move.
+    if( t <= T_TYPICAL*EPSILON || D == 0 || fabs(r0 - a) <= EPSILON*L_TYPICAL || rnd <= EPSILON)
+    {
+            return 0.0;
+    }
+    else if (r == sigma) // a reaction has occured, the angle is irrelevant
+    {
+            return 0.0;
+    }
+
+    // making the tables with constants
+
+    RealVector p_mTable;                        // a table with constants to make calculationdraws much faster
+    if( fabs(r - a) <= EPSILON*L_TYPICAL )      // If the r is at the outer boundary
+    {
+            makedp_m_at_aTable( p_mTable, t );  // making the table if particle on the outer boundary
+    }
+    else
+    {
+            makep_mTable( p_mTable, r, t );     // making the table of constants for the regular case
+    }
+
+    // preparing the function
+    
+    // ip_theta_params is a struct.
+    ip_theta_params params = { this, r, t, p_mTable, rnd*0.5 }; // r, r0, t are not required	    
+                                                                // 0.5 is not even used
     // F is a struct of type "gsl_function" that contains a function pointer
-	// and the required parameters.
-	gsl_function F = 
-	{
-	    reinterpret_cast<typeof(F.function)>( &ip_theta_F ), // ip_theta_F is 
-	                                                    // theta pdf function.
-	    &params 
-        // reinterpret_cast converts any pointer type to any other pointer type.
-        // reinterpret_cast<new_type> variable
-	}; 
-	    
-	// finding the root
-	const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
-	gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
-	const Real theta( findRoot( F, solver, 0, M_PI, EPSILON, EPSILON,
-                "GreensFunction2DRadAbs::drawTheta" ) );
-	gsl_root_fsolver_free( solver );
-
-	return theta;
+    // and the required parameters.
+    gsl_function F = 
+    {
+        reinterpret_cast<typeof(F.function)>( &ip_theta_F ), // ip_theta_F is 
+                                                             // theta pdf function.
+        &params 
+    // reinterpret_cast converts any pointer type to any other pointer type.
+    // reinterpret_cast<new_type> variable
+    }; 
+        
+    // finding the root
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
+    const Real theta( findRoot( F, solver, 0, M_PI, EPSILON, EPSILON,
+            "GreensFunction2DRadAbs::drawTheta" ) );
+    gsl_root_fsolver_free( solver );
+
+    return theta;
 }
 
 
 //
-// debug
+// DEBUG
 //
-
 // Debug functionality
 std::string GreensFunction2DRadAbs::dump() const
 {
+    
     std::ostringstream ss;
-    ss << "D = " << this->getD() << ", sigma = " << this->getSigma() <<
-	", a = " << this->geta() <<
-	", kf = " << this->getkf() <<
-	", r0 = " << this->getr0() <<
-	", h = " << this->geth() << std::endl;
+    ss << "D = " << this->getD()   << ", sigma = " << this->getSigma() <<
+        ", a = " << this->geta()   <<
+        ", kf = " << this->getkf() <<
+        ", r0 = " << this->getr0() <<
+        ", h = " << this->geth()   << std::endl;
     return ss.str();
 }    
 
+
 // Debug functionality
 // Directly outputs probability distribution function value of leaving angle
 // for given theta, r and t.
-Real 
+Real
 GreensFunction2DRadAbs::givePDFTheta( const Real theta,
-					   const Real r, 
-					   const Real t ) const
+                                      const Real r, 
+                                      const Real t      ) const
 {
+  
     const Real sigma( this->getSigma() );
     const Real a( this->geta() );
-//    const Real D( this->getD() );
+//  const Real D( this->getD() );
     const Real r0( this->getr0() );
 
-	// input parameter range checks.
-	THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
-	THROW_UNLESS( std::invalid_argument, sigma <= r && r <= a);
-	THROW_UNLESS( std::invalid_argument, t >= 0.0 );
-
-	// making the tables with constants
-	RealVector p_mTable;			// a table with constants to make calculations much faster
-	if( fabs(r - a) <= EPSILON*L_TYPICAL )	// If the r is at the outer boundary
-	{
-		makedp_m_at_aTable( p_mTable, t );	// making the table if particle on the outer boundary
-	}
-	else
-	{
-		makep_mTable( p_mTable, r, t );	// making the table of constants for the regular case
-	}
+    // input parameter range checks.
+    THROW_UNLESS( std::invalid_argument, sigma <= r0 && r0 <= a );
+    THROW_UNLESS( std::invalid_argument, sigma <= r && r <= a);
+    THROW_UNLESS( std::invalid_argument, t >= 0.0 );
+
+    // making the tables with constants
+    RealVector p_mTable;                        // a table with constants to make calculations much faster
+    if( fabs(r - a) <= EPSILON*L_TYPICAL )      // If the r is at the outer boundary
+    {
+            makedp_m_at_aTable( p_mTable, t );  // making the table if particle on the outer boundary
+    }
+    else
+    {
+            makep_mTable( p_mTable, r, t );     // making the table of constants for the regular case
+    }
 
     // Return the pdf
-  	ip_theta_params params = { this, r, t, p_mTable, 0.0 };	// r, r0, t are not required	    
+    ip_theta_params params = { this, r, t, p_mTable, 0.0 }; // r, r0, t are not required
     Real PDF (ip_theta_F( theta, &params ));
     return PDF;
-	
+        
 }
 
+
 // Output the PDF of r, given time t has passed.
 Real GreensFunction2DRadAbs::givePDFR( const Real r, const Real t ) const
 {
+  
 //    const Real D( this->getD() );
 //    const Real sigma( this->getSigma() );
 //    const Real a( this->geta() );
     const Real r0( this->getr0() );
 
-    if( t == 0.0 )		// if no time has passed
+    if( t == 0.0 ) // if no time has passed
     {
-	    return r0;
+            return r0;
     }
 
-    const Real psurv( p_survival( t ) );	// calculate the survival probability at this time
-						// this is used as the normalization factor
-						// BEWARE!!! This also produces the roots An and therefore
-						// SETS THE HIGHEST INDEX -> side effect
-						// VERY BAD PROGRAMMING PRACTICE!!
-
+    const Real psurv( p_survival( t ) ); // calculate the survival probability at this time
+                                         // this is used as the normalization factor
+                                         // BEWARE!!! This also produces the roots An and therefore
+                                         // SETS THE HIGHEST INDEX -> side effect
+                                         // VERY BAD PROGRAMMING PRACTICE!!
     RealVector Y0_aAnTable;
     RealVector J0_aAnTable;
     RealVector Y0J1J0Y1Table;
@@ -1643,9 +1692,11 @@ Real GreensFunction2DRadAbs::givePDFR( const Real r, const Real t ) const
     return PDF;
 }
 
+
 void GreensFunction2DRadAbs::dumpRoots( int n )
 {
-//        return this->alphaTable[n];
+  
+//    return this->alphaTable[n];
       std::cout << "Roots are: {";
       
       const int size( alphaTable.size() );
@@ -1666,13 +1717,17 @@ GreensFunction2DRadAbs::debug_ip_theta_table( const Real theta) const
     const RealVector& p_nTable( params->p_nTable );	// table with useful constants
     
     const unsigned int maxm( p_nTable.size()-1 );	// get the length of the sum
-							// it is shifted one because the first entry should
-							// be used (m=0)
+                                                        // it is shifted one because the first entry should
+                                                        // be used (m=0)
 
     const Real p( funcSum_all( boost::bind( &GreensFunction2DRadAbs::ip_theta_n,
-                                             this,
-                                             _1, theta, p_nTable ),
+                                            this,
+                                            _1, theta, p_nTable ),
                                 maxm ) );
     return p;
 }
 */
+
+Logger& GreensFunction2DRadAbs::log_(
+        Logger::get_logger("GreensFunction2DRadAbs"));
+        
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 2a98cce5..d1f049e5 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -16,6 +16,7 @@
 #include <boost/array.hpp>
 
 #include <gsl/gsl_roots.h>
+#include "Logger.hpp"
 
 #include "PairGreensFunction.hpp"
 
@@ -344,6 +345,8 @@ class GreensFunction2DRadAbs
     // we're within margin of the distance to which they're expected to 
     // converge.
     mutable boost::array<int,MAX_ORDER+1> alpha_correctly_estimated_;
+    
+    static Logger& log_;
 
 };
 

From 9a6c966e2cdccea33101670d3cda9126a9d06ac1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 12:34:09 +0200
Subject: [PATCH 1070/1541] Add Green's function name to error and warnings
 where appropriate

---
 GreensFunction3D.cpp       | 18 ++++-----
 GreensFunction3DAbs.cpp    | 58 ++++++++++++++---------------
 GreensFunction3DAbsSym.cpp | 10 ++---
 GreensFunction3DRadAbs.cpp | 76 +++++++++++++++++++-------------------
 GreensFunction3DRadInf.cpp | 26 ++++++-------
 GreensFunction3DSym.cpp    |  6 +--
 6 files changed, 97 insertions(+), 97 deletions(-)

diff --git a/GreensFunction3D.cpp b/GreensFunction3D.cpp
index b44b3c57..91c36ff2 100644
--- a/GreensFunction3D.cpp
+++ b/GreensFunction3D.cpp
@@ -86,17 +86,17 @@ Real GreensFunction3D::drawR(Real rnd, Real t) const
     // input parameter range checks.
     if ( !(rnd <= 1.0 && rnd >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g" ) % rnd ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3D: rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g" ) % rnd ).str() );
     }
 
     if ( !(r0 >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "r0 >= 0.0 : r0=%.16g" ) % r0 ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3D: r0 >= 0.0 : r0=%.16g" ) % r0 ).str() );
     }
 
     if ( !(t >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "t >= 0.0 : t=%.16g" ) % t ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3D: t >= 0.0 : t=%.16g" ) % t ).str() );
     }
 
 
@@ -150,7 +150,7 @@ Real GreensFunction3D::drawR(Real rnd, Real t) const
             if( i >= maxIter )
             {
                 gsl_root_fsolver_free( solver );
-                throw std::runtime_error("drawR: failed to converge");
+                throw std::runtime_error("GreensFunction3D: drawR: failed to converge");
             }
         }
         else
@@ -185,22 +185,22 @@ Real GreensFunction3D::drawTheta(Real rnd, Real r, Real t) const
     // input parameter range checks.
     if ( !(rnd <= 1.0 && rnd >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g" ) % rnd ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3D: rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g" ) % rnd ).str() );
     }
 
     if ( !(r >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "r >= 0.0 : r=%.16g" ) % r ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3D: r >= 0.0 : r=%.16g" ) % r ).str() );
     }
 
     if ( !(r0 >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "r0 >= 0.0 : r0=%.16g" ) % r0 ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3D: r0 >= 0.0 : r0=%.16g" ) % r0 ).str() );
     }
 
     if ( !(t >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "t >= 0.0 : t=%.16g" ) % t ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3D: t >= 0.0 : t=%.16g" ) % t ).str() );
     }
 
 
@@ -241,7 +241,7 @@ Real GreensFunction3D::drawTheta(Real rnd, Real r, Real t) const
             if( i >= maxIter )
             {
                 gsl_root_fsolver_free( solver );
-                throw std::runtime_error("drawTheta: failed to converge");
+                throw std::runtime_error("GreensFunction3D: drawTheta: failed to converge");
             }
         }
         else
diff --git a/GreensFunction3DAbs.cpp b/GreensFunction3DAbs.cpp
index 6d141701..feef57e7 100644
--- a/GreensFunction3DAbs.cpp
+++ b/GreensFunction3DAbs.cpp
@@ -31,7 +31,7 @@ GF3DA::GreensFunction3DAbs(Real D, Real r0, Real a)
 {
     if (a < 0.0)
     {
-        throw std::invalid_argument((boost::format("a >= 0.0 : a=%.16g") % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbs: a >= 0.0 : a=%.16g") % a).str());
     }
 }
 
@@ -271,22 +271,22 @@ Real GF3DA::p_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
         if (!(r >= 0 && r < a))
         {
-            throw std::invalid_argument((boost::format("r >= 0 && r < a : r=%.16g, a=%.16g") % r % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r >= 0 && r < a : r=%.16g, a=%.16g") % r % a).str());
         }
 
         if (!(r0 >= 0 && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= 0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r0 >= 0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -315,23 +315,23 @@ Real GF3DA::ip_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
         // r \in (sigma, a)
         if (!(r >= 0.0 && r < a))
         {
-            throw std::invalid_argument((boost::format("r >= 0.0 && r < a : r=%.16g, a=%.16g") % r % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r >= 0.0 && r < a : r=%.16g, a=%.16g") % r % a).str());
         }
 
         if (!(r0 >= 0.0 && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -504,7 +504,7 @@ GF3DA::dp_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
 
@@ -512,17 +512,17 @@ GF3DA::dp_theta(Real theta, Real r, Real t) const
         // defined at r == sigma and r == a.
         if (!(r >= 0.0 && r <= a))
         {
-            throw std::invalid_argument((boost::format("r >= 0.0 && r <= a : r=%.16g, a=%.16g") % r % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r >= 0.0 && r <= a : r=%.16g, a=%.16g") % r % a).str());
         }
 
         if (!(r0 >= 0.0 && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -549,23 +549,23 @@ GF3DA::idp_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
         // r \in [ sigma, a ]
         if (!(r >= 0.0 && r <= a))
         {
-            throw std::invalid_argument((boost::format("r >= 0.0 && r <= a : r=%.16g, a=%.16g") % r % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r >= 0.0 && r <= a : r=%.16g, a=%.16g") % r % a).str());
         }
 
         if (!(r0 >= 0.0 && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -591,12 +591,12 @@ GF3DA::drawTime(Real rnd) const
 
    if (!(rnd <= 1.0 && rnd >= 0.0))
    {
-       throw std::invalid_argument((boost::format("rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+       throw std::invalid_argument((boost::format("GreensFunction3DAbs: rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
    }
 
    if (!(r0 >= 0.0 && r0 <= a))
    {
-       throw std::invalid_argument((boost::format("r0 >= 0.0 && r0 <= a : r0=%.16g, a=%.16g") % r0 % a).str());
+       throw std::invalid_argument((boost::format("GreensFunction3DAbs: r0 >= 0.0 && r0 <= a : r0=%.16g, a=%.16g") % r0 % a).str());
    }
 
 
@@ -623,7 +623,7 @@ GF3DA::drawTime(Real rnd) const
         if (fabs(high) >= 1e10)
         {
             throw std::runtime_error(
-                (boost::format("couldn't adjust high. F(%.16g) = %.16g; r0=%.16g, %s") %
+                (boost::format("GreensFunction3DAbs: couldn't adjust high. F(%.16g) = %.16g; r0=%.16g, %s") %
                     high % GSL_FN_EVAL(&F, high) % r0 % dump()).str());
         }
     }
@@ -670,7 +670,7 @@ GF3DA::drawTime(Real rnd) const
             if (i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawTime: failed to converge");
+                throw std::runtime_error("GreensFunction3DAbs: drawTime: failed to converge");
             }
         }
         else
@@ -694,12 +694,12 @@ GF3DA::drawR(Real rnd, Real t) const
 
     if (!(rnd <= 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbs: rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= 0.0 && r0 < a))
     {
-        throw std::invalid_argument((boost::format("r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbs: r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
     }
 
 
@@ -753,7 +753,7 @@ GF3DA::drawR(Real rnd, Real t) const
             if (i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawR: failed to converge");
+                throw std::runtime_error("GreensFunction3DAbs: drawR: failed to converge");
             }
         }
         else
@@ -780,22 +780,22 @@ GF3DA::drawTheta(Real rnd, Real r, Real t) const
     // input parameter range checks.
     if (!(rnd <= 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbs: rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= 0.0 && r0 < a))
     {
-        throw std::invalid_argument((boost::format("r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbs: r0 >= 0.0 && r0 < a : r0=%.16g, a=%.16g") % r0 % a).str());
     }
 
     if (!(r >= 0.0 && r <= a))
     {
-        throw std::invalid_argument((boost::format("r >= 0.0 && r <= a : r=%.16g, a=%.16g") % r % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbs: r >= 0.0 && r <= a : r=%.16g, a=%.16g") % r % a).str());
     }
 
     if (!(t >= 0.0))
     {
-        throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbs: t >= 0.0 : t=%.16g") % t).str());
     }
 
 
@@ -847,7 +847,7 @@ GF3DA::drawTheta(Real rnd, Real r, Real t) const
             if (i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawTheta: failed to converge");
+                throw std::runtime_error("GreensFunction3DAbs: drawTheta: failed to converge");
             }
         }
         else
diff --git a/GreensFunction3DAbsSym.cpp b/GreensFunction3DAbsSym.cpp
index d1496c54..7af011dc 100644
--- a/GreensFunction3DAbsSym.cpp
+++ b/GreensFunction3DAbsSym.cpp
@@ -31,7 +31,7 @@ Real GreensFunction3DAbsSym::ellipticTheta4Zero(Real q)
 {
     if (fabs(q) > 1.0)
     {
-        throw std::invalid_argument((boost::format("fabs(%.16g) <= 1.0") % q).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbsSym: fabs(%.16g) <= 1.0") % q).str());
     }
 
     // et4z(1 - 1e4) ~= 7.2e-23
@@ -215,7 +215,7 @@ Real GreensFunction3DAbsSym::drawTime(Real rnd) const
 
     if (rnd >= 1.0 || rnd < 0.0)
     {
-        throw std::invalid_argument((boost::format("0.0 <= %.16g < 1.0") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbsSym: 0.0 <= %.16g < 1.0") % rnd).str());
     }
 
     const Real a(geta());
@@ -261,7 +261,7 @@ Real GreensFunction3DAbsSym::drawTime(Real rnd) const
             if (fabs(high) >= t_guess * 1e6)
             {
                 throw std::runtime_error(
-                    (boost::format("couldn't adjust high. F(%.16g) = %.16g; %s") %
+                    (boost::format("GreensFunction3DAbsSym: couldn't adjust high. F(%.16g) = %.16g; %s") %
                        high % GSL_FN_EVAL(&F, high) %
                        boost::lexical_cast<std::string>(*this)).str());
             }
@@ -330,12 +330,12 @@ Real GreensFunction3DAbsSym::drawR(Real rnd, Real t) const
 {
     if (rnd >= 1.0 || rnd < 0.0)
     {
-        throw std::invalid_argument((boost::format("0.0 <= %.16g < 1.0") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbsSym: 0.0 <= %.16g < 1.0") % rnd).str());
     }
 
     if (t < 0.0)
     {
-        throw std::invalid_argument((boost::format("%.16g < 0.0") % t).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DAbsSym: %.16g < 0.0") % t).str());
     }
 
     const Real a(geta());
diff --git a/GreensFunction3DRadAbs.cpp b/GreensFunction3DRadAbs.cpp
index c1e57acf..8269c6be 100644
--- a/GreensFunction3DRadAbs.cpp
+++ b/GreensFunction3DRadAbs.cpp
@@ -40,7 +40,7 @@ GreensFunction3DRadAbs::GreensFunction3DRadAbs(
 
     if (a < sigma)
     {
-        throw std::invalid_argument((boost::format("a >= sigma : a=%.16g, sigma=%.16g") % a % sigma).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: a >= sigma : a=%.16g, sigma=%.16g") % a % sigma).str());
     }
     clearAlphaTable();
 }
@@ -118,7 +118,7 @@ Real GreensFunction3DRadAbs::alpha0_i(Integer i) const
 {
     if (!(i >= 0))
     {
-        throw std::out_of_range((boost::format("i >= 0 : i=%.16g") % i).str());
+        throw std::out_of_range((boost::format("GreensFunction3DRadAbs: i >= 0 : i=%.16g") % i).str());
     }
 
 
@@ -161,7 +161,7 @@ Real GreensFunction3DRadAbs::alpha0_i(Integer i) const
             if (j >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("alpha0_i: failed to converge");
+                throw std::runtime_error("GreensFunction3DRadAbs: alpha0_i: failed to converge");
             }
         }
         else
@@ -476,7 +476,7 @@ GreensFunction3DRadAbs::alpha_i(Integer i, Integer n,
             if (k >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("alpha_i: failed to converge");
+                throw std::runtime_error("GreensFunction3DRadAbs: alpha_i: failed to converge");
             }
         }
         else
@@ -557,7 +557,7 @@ GreensFunction3DRadAbs::updateAlphaTable(const unsigned int n,
 {
     if (!(n >= 0 && n <= this->MAX_ORDER))
     {
-        throw std::range_error((boost::format("n >= 0 && n <= this->MAX_ORDER : n=%.16g, this->MAX_ORDER=%.16g") % n % this->MAX_ORDER).str());
+        throw std::range_error((boost::format("GreensFunction3DRadAbs: n >= 0 && n <= this->MAX_ORDER : n=%.16g, this->MAX_ORDER=%.16g") % n % this->MAX_ORDER).str());
     }
 
 
@@ -1333,12 +1333,12 @@ Real GreensFunction3DRadAbs::drawTime(Real rnd) const
 
     if (!(rnd < 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= sigma && r0 <= a))
     {
-        throw std::invalid_argument((boost::format("r0 >= sigma && r0 <= a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 <= a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
     }
 
 
@@ -1396,7 +1396,7 @@ Real GreensFunction3DRadAbs::drawTime(Real rnd) const
             {
                 throw std::runtime_error(
                     (boost::format(
-                        "couldn't adjust high. F(%.16g) = %.16g; r0 = %.16g, %s") %
+                        "GreensFunction3DRadAbs: couldn't adjust high. F(%.16g) = %.16g; r0 = %.16g, %s") %
                         high % GSL_FN_EVAL(&F, high) % r0 % dump()).str());
             }
 
@@ -1422,7 +1422,7 @@ Real GreensFunction3DRadAbs::drawTime(Real rnd) const
             if (fabs(low) <= minT ||
                 fabs(low_value - low_value_prev) < TOLERANCE) 
             {
-                log_.info("couldn't adjust low. F(%.16g) = %.16g; r0 = %.16g, %s",
+                log_.info("GreensFunction3DRadAbs: couldn't adjust low. F(%.16g) = %.16g; r0 = %.16g, %s",
                           low, GSL_FN_EVAL(&F, low), r0,
                           dump().c_str());
                 log_.info("returning %.16g", low);
@@ -1455,17 +1455,17 @@ GreensFunction3DRadAbs::drawEventType(Real rnd, Real t) const
 
     if (!(rnd < 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= sigma && r0 < a))
     {
-        throw std::invalid_argument((boost::format("r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
     }
 
     if (!(t > 0.0))
     {
-        throw std::invalid_argument((boost::format("t > 0.0 : t=%.16g") % t).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: t > 0.0 : t=%.16g") % t).str());
     }
 
 
@@ -1545,7 +1545,7 @@ GreensFunction3DRadAbs::drawPleavea(gsl_function const& F,
             {
                 throw std::runtime_error(
                     (boost::format(
-                        "couldn't adjust high. Fa(%.16g) = %.16g; r0 = %.16g, %s") %
+                        "GreensFunction3DRadAbs: couldn't adjust high. Fa(%.16g) = %.16g; r0 = %.16g, %s") %
                         high % GSL_FN_EVAL(&F, high) % r0 % dump()).str());
             }
 
@@ -1625,7 +1625,7 @@ GreensFunction3DRadAbs::drawPleaves(gsl_function const& F,
             {
                 throw std::runtime_error(
                     (boost::format(
-                        "couldn't adjust high. Fs(%.16g) = %.16g; r0 = %.16g, %s") %
+                        "GreensFunction3DRadAbs: couldn't adjust high. Fs(%.16g) = %.16g; r0 = %.16g, %s") %
                         high % GSL_FN_EVAL(&F, high) % r0 % dump()).str());
             }
 
@@ -1685,12 +1685,12 @@ Real GreensFunction3DRadAbs::drawR(Real rnd, Real t) const
 
     if (!(rnd < 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= sigma && r0 < a))
     {
-        throw std::invalid_argument((boost::format("r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
     }
 
 
@@ -1804,7 +1804,7 @@ Real GreensFunction3DRadAbs::drawR(Real rnd, Real t) const
             if (i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawR: failed to converge");
+                throw std::runtime_error("GreensFunction3DRadAbs: drawR: failed to converge");
             }
         }
         else
@@ -2126,23 +2126,23 @@ GreensFunction3DRadAbs::p_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
         // r \in (sigma, a);  not defined at r == sigma and r == a.
         if (!(r >= sigma && r < a))
         {
-            throw std::invalid_argument((boost::format("r >= sigma && r < a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r >= sigma && r < a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
         }
 
         if (!(r0 >= sigma && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -2169,7 +2169,7 @@ Real GreensFunction3DRadAbs::dp_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
 
@@ -2177,17 +2177,17 @@ Real GreensFunction3DRadAbs::dp_theta(Real theta, Real r, Real t) const
         // defined at r == sigma and r == a.
         if (!(r >= sigma && r <= a))
         {
-            throw std::invalid_argument((boost::format("r >= sigma && r <= a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r >= sigma && r <= a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
         }
 
         if (!(r0 >= sigma && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -2285,23 +2285,23 @@ GreensFunction3DRadAbs::ip_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
         // r \in (sigma, a)
         if (!(r >= sigma && r < a))
         {
-            throw std::invalid_argument((boost::format("r >= sigma && r < a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r >= sigma && r < a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
         }
 
         if (!(r0 >= sigma && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -2330,23 +2330,23 @@ GreensFunction3DRadAbs::idp_theta(Real theta, Real r, Real t) const
         
         if (!(theta >= 0.0 && theta <= M_PI))
         {
-            throw std::invalid_argument((boost::format("theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: theta >= 0.0 && theta <= M_PI : theta=%.16g, M_PI=%.16g") % theta % M_PI).str());
         }
 
         // r \in [ sigma, a ]
         if (!(r >= sigma && r <= a))
         {
-            throw std::invalid_argument((boost::format("r >= sigma && r <= a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r >= sigma && r <= a : r=%.16g, sigma=%.16g, a=%.16g") % r % sigma % a).str());
         }
 
         if (!(r0 >= sigma && r0 < a))
         {
-            throw std::invalid_argument((boost::format("r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
         }
 
         if (!(t >= 0.0))
         {
-            throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+            throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: t >= 0.0 : t=%.16g") % t).str());
         }
 
     }
@@ -2431,22 +2431,22 @@ GreensFunction3DRadAbs::drawTheta(Real rnd, Real r, Real t) const
     // input parameter range checks.
     if (!(rnd < 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= sigma && r0 < a))
     {
-        throw std::invalid_argument((boost::format("r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r0 >= sigma && r0 < a : r0=%.16g, sigma=%.16g, a=%.16g") % r0 % sigma % a).str());
     }
 
     if (!(r >= sigma))
     {
-        throw std::invalid_argument((boost::format("r >= sigma : r=%.16g, sigma=%.16g") % r % sigma).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: r >= sigma : r=%.16g, sigma=%.16g") % r % sigma).str());
     }
 
     if (!(t >= 0.0))
     {
-        throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadAbs: t >= 0.0 : t=%.16g") % t).str());
     }
 
 
@@ -2497,7 +2497,7 @@ GreensFunction3DRadAbs::drawTheta(Real rnd, Real r, Real t) const
             if (i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawTheta: failed to converge");
+                throw std::runtime_error("GreensFunction3DRadAbs: drawTheta: failed to converge");
             }
         }
         else
diff --git a/GreensFunction3DRadInf.cpp b/GreensFunction3DRadInf.cpp
index 10faa458..90a505b2 100644
--- a/GreensFunction3DRadInf.cpp
+++ b/GreensFunction3DRadInf.cpp
@@ -234,12 +234,12 @@ Real GreensFunction3DRadInf::drawTime(Real rnd) const
 
     if (!(rnd < 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= sigma))
     {
-        throw std::invalid_argument((boost::format("r0 >= sigma : r0=%.16g, sigma=%.16g") % r0 % sigma).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: r0 >= sigma : r0=%.16g, sigma=%.16g") % r0 % sigma).str());
     }
 
 
@@ -283,7 +283,7 @@ Real GreensFunction3DRadInf::drawTime(Real rnd) const
             if(i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawTime: failed to converge");
+                throw std::runtime_error("GreensFunction3DRadInf: drawTime: failed to converge");
             }
         }
         else
@@ -310,17 +310,17 @@ Real GreensFunction3DRadInf::drawR(Real rnd, Real t) const
 
     if (!(rnd < 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r0 >= sigma))
     {
-        throw std::invalid_argument((boost::format("r0 >= sigma : r0=%.16g, sigma=%.16g") % r0 % sigma).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: r0 >= sigma : r0=%.16g, sigma=%.16g") % r0 % sigma).str());
     }
 
     if (!(t >= 0.0))
     {
-        throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: t >= 0.0 : t=%.16g") % t).str());
     }
 
 
@@ -367,7 +367,7 @@ Real GreensFunction3DRadInf::drawR(Real rnd, Real t) const
 
             if(H > 20)
             {
-                throw std::runtime_error("drawR: H > 20 while adjusting upper bound of r");
+                throw std::runtime_error("GreensFunction3DRadInf: drawR: H > 20 while adjusting upper bound of r");
             }
         }
 
@@ -426,7 +426,7 @@ Real GreensFunction3DRadInf::drawR(Real rnd, Real t) const
             if(i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawR: failed to converge");
+                throw std::runtime_error("GreensFunction3DRadInf: drawR: failed to converge");
             }
         }
         else
@@ -694,22 +694,22 @@ Real GreensFunction3DRadInf::drawTheta(Real rnd, Real r, Real t) const
     // input parameter range checks.
     if (!(rnd < 1.0 && rnd >= 0.0))
     {
-        throw std::invalid_argument((boost::format("rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: rnd < 1.0 && rnd >= 0.0 : rnd=%.16g") % rnd).str());
     }
 
     if (!(r >= sigma))
     {
-        throw std::invalid_argument((boost::format("r >= sigma : r=%.16g, sigma=%.16g") % r % sigma).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: r >= sigma : r=%.16g, sigma=%.16g") % r % sigma).str());
     }
 
     if (!(r0 >= sigma))
     {
-        throw std::invalid_argument((boost::format("r0 >= sigma : r0=%.16g, sigma=%.16g") % r0 % sigma).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: r0 >= sigma : r0=%.16g, sigma=%.16g") % r0 % sigma).str());
     }
 
     if (!(t >= 0.0))
     {
-        throw std::invalid_argument((boost::format("t >= 0.0 : t=%.16g") % t).str());
+        throw std::invalid_argument((boost::format("GreensFunction3DRadInf: t >= 0.0 : t=%.16g") % t).str());
     }
 
 
@@ -755,7 +755,7 @@ Real GreensFunction3DRadInf::drawTheta(Real rnd, Real r, Real t) const
             if(i >= maxIter)
             {
                 gsl_root_fsolver_free(solver);
-                throw std::runtime_error("drawTheta: failed to converge");
+                throw std::runtime_error("GreensFunction3DRadInf: drawTheta: failed to converge");
             }
         }
         else
diff --git a/GreensFunction3DSym.cpp b/GreensFunction3DSym.cpp
index 530bb712..9f6c5ab1 100644
--- a/GreensFunction3DSym.cpp
+++ b/GreensFunction3DSym.cpp
@@ -65,12 +65,12 @@ Real GreensFunction3DSym::drawR(Real rnd, Real t) const
     // input parameter range checks.
     if ( !(rnd <= 1.0 && rnd >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g" ) % rnd ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3DSym: rnd <= 1.0 && rnd >= 0.0 : rnd=%.16g" ) % rnd ).str() );
     }
 
     if ( !(t >= 0.0 ) )
     {
-        throw std::invalid_argument( ( boost::format( "t >= 0.0 : t=%.16g" ) % t ).str() );
+        throw std::invalid_argument( ( boost::format( "GreensFunction3DSym: t >= 0.0 : t=%.16g" ) % t ).str() );
     }
 
 
@@ -115,7 +115,7 @@ Real GreensFunction3DSym::drawR(Real rnd, Real t) const
             if( i >= maxIter )
             {
                 gsl_root_fsolver_free( solver );
-                throw std::runtime_error("drawR: failed to converge");
+                throw std::runtime_error("GreensFunction3DSym: drawR: failed to converge");
             }
         }
         else

From 902734c3ded3cae5e7dbf9bddb10d5bda7278298 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 14:57:17 +0200
Subject: [PATCH 1071/1541] Also clean up GreensFunction2DAbsSym for
 completeness

---
 GreensFunction2DAbsSym.cpp | 202 +++++++++++++++++++------------------
 GreensFunction2DAbsSym.hpp |   5 +-
 2 files changed, 109 insertions(+), 98 deletions(-)

diff --git a/GreensFunction2DAbsSym.cpp b/GreensFunction2DAbsSym.cpp
index 1bbca5bd..3b8726a1 100644
--- a/GreensFunction2DAbsSym.cpp
+++ b/GreensFunction2DAbsSym.cpp
@@ -24,6 +24,7 @@
 const Real 
 GreensFunction2DAbsSym::p_survival( const Real t ) const
 {
+  
     const Real D( getD() );
     const Real a( geta() );
     const Real Dt( -D * t );
@@ -37,24 +38,24 @@ GreensFunction2DAbsSym::p_survival( const Real t ) const
 
     const Real threshold( CUTOFF );	// 
 
-//std::cout << "p_survival_2D ";
-//std::cout << "time: " << t << std::endl;
+    //std::cout << "p_survival_2D ";
+    //std::cout << "time: " << t << std::endl;
     for( Integer n( 1 ); n <= N; ++n )
     {
-	aAn = gsl_sf_bessel_zero_J0(n);		// gsl roots of J0(aAn)
-	An = aAn/a;
-	J1_aAn = gsl_sf_bessel_J1(aAn);
-	term = (exp(An*An*Dt))/(An*J1_aAn);
-	sum += term;
+        aAn = gsl_sf_bessel_zero_J0(n);		// gsl roots of J0(aAn)
+        An = aAn/a;
+        J1_aAn = gsl_sf_bessel_J1(aAn);
+        term = (exp(An*An*Dt))/(An*J1_aAn);
+        sum += term;
 
-//std::cout << n << " " << aAn << " " << J1_aAn << " " << term << " " << value << std::endl;
+        //std::cout << n << " " << aAn << " " << J1_aAn << " " << term << " " << value << std::endl;
 
         if( fabs( term/sum ) < threshold )
-	{
-	    // normal exit.
-//std::cout << n << std::endl;
-	    break;
-	}
+        {
+            // normal exit.
+            //std::cout << n << std::endl;
+            break;
+        }
     }
     return (2.0/a) * sum;
 } 
@@ -63,6 +64,7 @@ GreensFunction2DAbsSym::p_survival( const Real t ) const
 const Real 
 GreensFunction2DAbsSym::p_int_r_free( const Real r, const Real t ) const
 {
+  
     const Real D( getD() );
     const Real Dt( D * t );
     const Real sqrtDt( sqrt( Dt ) );
@@ -72,10 +74,12 @@ GreensFunction2DAbsSym::p_int_r_free( const Real r, const Real t ) const
         - r * exp( - r * r / ( 4.0 * Dt ) ) / ( sqrtPI * sqrtDt );
 }
 
+
 const Real 
 GreensFunction2DAbsSym::p_int_r( const Real r, 
-                                     const Real t ) const
+                                    const Real t ) const
 {
+  
     const Real a( geta() );
     const Real D( getD() );
     const Real Dt( -D * t );
@@ -93,16 +97,16 @@ GreensFunction2DAbsSym::p_int_r( const Real r,
 
     do
     {
-	aAn = gsl_sf_bessel_zero_J0(n);         // gsl roots of J0(aAn)
+        aAn = gsl_sf_bessel_zero_J0(n);         // gsl roots of J0(aAn)
         An  = aAn/a;
-	rAn = r*An;
+        rAn = r*An;
         J1_aAn = gsl_sf_bessel_J1(aAn);
-	J1_rAn = gsl_sf_bessel_J1(rAn);
+        J1_rAn = gsl_sf_bessel_J1(rAn);
         term = (exp(An*An*Dt) * r * J1_rAn) / (An*J1_aAn*J1_aAn);
         sum += term;
-	n++;
+        n++;
 
-//std::cout << n << " " << aAn << " " << J1_aAn << " " << term << " " << value << std::endl;
+        //std::cout << n << " " << aAn << " " << J1_aAn << " " << term << " " << value << std::endl;
     }
     while (fabs( term/sum ) > threshold && n <= N_MAX);
 
@@ -112,8 +116,9 @@ GreensFunction2DAbsSym::p_int_r( const Real r,
 
 const Real
 GreensFunction2DAbsSym::p_survival_F( const Real t,
-					  const p_survival_params* params )
+                                          const p_survival_params* params )
 {
+  
     const GreensFunction2DAbsSym* const gf( params->gf ); 
     const Real rnd( params->rnd );
 
@@ -121,88 +126,88 @@ GreensFunction2DAbsSym::p_survival_F( const Real t,
 }
 
 
-
 const Real 
 GreensFunction2DAbsSym::drawTime( const Real rnd ) const
 {
-	THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
-
-	const Real a( geta() );
-
-	if( getD() == 0.0 || a == INFINITY )
-	{
-		return INFINITY;
-	}
-	if( a == 0.0 )
-	{
-		return 0.0;
-	}
-
-	p_survival_params params = { this, rnd };
-
-	gsl_function F = 
-	{
-		reinterpret_cast<typeof(F.function)>( &p_survival_F ), &params 
-	};
-
-//for (Real t=0.0001; t<=1; t+=0.0001)
-//{	std::cout << t << " " << GSL_FN_EVAL( &F, t) << std::endl;
-//}
-
-	// Find a good interval to determine the first passage time in
-        const Real t_guess( a * a / ( 4. * D ) );   // construct a guess: msd = sqrt (2*d*D*t)
-        Real value( GSL_FN_EVAL( &F, t_guess ) );
-        Real low( t_guess );
-        Real high( t_guess );
-
-        // scale the interval around the guess such that the function straddles
-        if( value < 0.0 )               // if the guess was too low
-        {
-                do
-                {       high *= 10;     // keep increasing the upper boundary until the function straddles
-                        value = GSL_FN_EVAL( &F, high );
-
-                        if( fabs( high ) >= t_guess * 1e6 )
-                        {
-                                std::cerr << "Couldn't adjust high. F(" << high <<
-                                    ") = " << value << std::endl;
-                                throw std::exception();
-                        }
-                }
-                while ( value <= 0.0 );
-        }
-        else                            // if the guess was too high
-        {
-                Real value_prev( value );
-                do
-                {       low *= .1;      // keep decreasing the lower boundary until the function straddles
-                        value = GSL_FN_EVAL( &F, low );     // get the accompanying value
-
-                        if( fabs( low ) <= t_guess * 1e-6 || fabs( value - value_prev ) < CUTOFF )
-                        {
-                                std::cerr << "Couldn't adjust low. F(" << low <<
-                                        ") = " << value << std::endl;
-                                return low;
-                        }
-                        value_prev = value;
-                }
-                while ( value >= 0.0 );
-        }
+  
+    THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
+
+    const Real a( geta() );
+
+    if( getD() == 0.0 || a == INFINITY )
+    {
+            return INFINITY;
+    }
+    if( a == 0.0 )
+    {
+            return 0.0;
+    }
+
+    p_survival_params params = { this, rnd };
+
+    gsl_function F = 
+    {
+            reinterpret_cast<typeof(F.function)>( &p_survival_F ), &params 
+    };
+
+    //for (Real t=0.0001; t<=1; t+=0.0001)
+    //{	std::cout << t << " " << GSL_FN_EVAL( &F, t) << std::endl;
+    //}
+
+    // Find a good interval to determine the first passage time in
+    const Real t_guess( a * a / ( 4. * D ) );   // construct a guess: msd = sqrt (2*d*D*t)
+    Real value( GSL_FN_EVAL( &F, t_guess ) );
+    Real low( t_guess );
+    Real high( t_guess );
+
+    // scale the interval around the guess such that the function straddles
+    if( value < 0.0 )               // if the guess was too low
+    {
+            do
+            {       high *= 10;     // keep increasing the upper boundary until the function straddles
+                    value = GSL_FN_EVAL( &F, high );
+
+                    if( fabs( high ) >= t_guess * 1e6 )
+                    {
+                            log_.warn("Couldn't adjust high. F(%.16g) = %.16g", high, value);
+                            throw std::exception();
+                    }
+            }
+            while ( value <= 0.0 );
+    }
+    else                            // if the guess was too high
+    {
+            Real value_prev( value );
+            do
+            {       low *= .1;      // keep decreasing the lower boundary until the function straddles
+                    value = GSL_FN_EVAL( &F, low );     // get the accompanying value
+
+                    if( fabs( low ) <= t_guess * 1e-6 || fabs( value - value_prev ) < CUTOFF )
+                    {
+                            log_.warn("Couldn't adjust high. F(%.16g) = %.16g", low, value);
+                            return low;
+                    }
+                    value_prev = value;
+            }
+            while ( value >= 0.0 );
+    }
 
-	// find the root
-	const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );	// a new solver type brent
-	gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );	// make a new solver instance
-	const Real t( findRoot( F, solver, low, high, 1e-18, 1e-12,
-                            "GreensFunction2DAbsSym::drawTime" ) );
-	gsl_root_fsolver_free( solver );
+    // find the root
+    const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );  // a new solver type brent
+    gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );   // make a new solver instance
+    const Real t( findRoot( F, solver, low, high, 1e-18, 1e-12,
+                        "GreensFunction2DAbsSym::drawTime" ) );
+    gsl_root_fsolver_free( solver );
 
-	return t;
+    return t;
 }
 
+
 const Real
 GreensFunction2DAbsSym::p_r_free_F( const Real r,
                                         const p_r_params* params )
 {
+  
     const GreensFunction2DAbsSym* const gf( params->gf ); 
     const Real t( params->t );
     const Real target( params->target );
@@ -213,8 +218,9 @@ GreensFunction2DAbsSym::p_r_free_F( const Real r,
 
 const Real
 GreensFunction2DAbsSym::p_r_F( const Real r,
-				   const p_r_params* params )
+                                  const p_r_params* params )
 {
+  
     const GreensFunction2DAbsSym* const gf( params->gf ); 
     const Real t( params->t );
     const Real target( params->target );
@@ -223,10 +229,10 @@ GreensFunction2DAbsSym::p_r_F( const Real r,
 }
 
 
-
 const Real 
 GreensFunction2DAbsSym::drawR( const Real rnd, const Real t ) const 
 {
+  
     THROW_UNLESS( std::invalid_argument, rnd <= 1.0 && rnd >= 0.0 );
     THROW_UNLESS( std::invalid_argument, t >= 0.0 );
 
@@ -243,8 +249,8 @@ GreensFunction2DAbsSym::drawR( const Real rnd, const Real t ) const
     gsl_function F;
     Real psurv;
 
-//    if( a <= thresholdDistance )	// if the domain is not so big, the boundaries are felt
-//    {
+//  if( a <= thresholdDistance )	// if the domain is not so big, the boundaries are felt
+//  {
         psurv = p_survival( t );
         //psurv = p_int_r( a, t );
         //printf("dr %g %g\n",psurv, p_survival( t ));
@@ -253,7 +259,7 @@ GreensFunction2DAbsSym::drawR( const Real rnd, const Real t ) const
         assert( psurv > 0.0 );
 
         F.function = reinterpret_cast<typeof(F.function)>( &p_r_F );
-/*    }
+/*  }
     else				// if the domain is very big, just use the free solution
     {
         // p_int_r < p_int_r_free
@@ -290,10 +296,12 @@ GreensFunction2DAbsSym::drawR( const Real rnd, const Real t ) const
 }
 
 
-
 const std::string GreensFunction2DAbsSym::dump() const
 {
     std::ostringstream ss;
     ss << "D = " << this->getD() << ", a = " << this->geta() << std::endl;
     return ss.str();
 }    
+
+Logger& GreensFunction2DAbsSym::log_(
+        Logger::get_logger("GreensFunction2DAbsSym"));
diff --git a/GreensFunction2DAbsSym.hpp b/GreensFunction2DAbsSym.hpp
index 07010966..ed799e7c 100644
--- a/GreensFunction2DAbsSym.hpp
+++ b/GreensFunction2DAbsSym.hpp
@@ -5,7 +5,7 @@
 #include <boost/multi_array.hpp>
 
 #include "Defs.hpp"
-
+#include "Logger.hpp"
 
 class GreensFunction2DAbsSym
 {
@@ -88,6 +88,9 @@ class GreensFunction2DAbsSym
     const Real D;
 
     const Real a;
+    
+    static Logger& log_;
+    
 };
 
 

From 3c81dade228d298e280a68b0739a5c09d4e6d301 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 14:58:11 +0200
Subject: [PATCH 1072/1541] Better output format for BD warnings

---
 newBDPropagator.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b045269d..5a06ca98 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -258,13 +258,13 @@ class newBDPropagator
                 
                 if(prob_increase >= 1.) // sth. is wrong in this case
                 {
-                    LOG_WARNING(("probability increase exceeded one in particle-surface interaction: prob_increase = %f, k_total = %f, surface_reaction_volume = %f.",
+                    LOG_WARNING(("probability increase exceeded one in particle-surface interaction: prob_increase = %f, k_total = %e, surface_reaction_volume = %e.",
                                  prob_increase, k_total( pp.second.sid(), overlap_struct.first.second->sid() ),
                                  overlap_struct.first.second->surface_reaction_volume( r0, reaction_length_ )           ));
                 }
                 if(accumulated_prob >= 1.) // sth. is wrong in this case
                 {
-                    LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one in particle-surface interaction: p_acc = %f, reaction_length = %f, dt = %f.",
+                    LOG_WARNING(("the acceptance probability of an interaction/reaction exceeded one in particle-surface interaction: p_acc = %f, reaction_length = %e, dt = %e.",
                                  accumulated_prob, reaction_length_, dt_));
                 }
                 
@@ -341,7 +341,7 @@ class newBDPropagator
             if (accumulated_prob >= 1.)
             {
                 LOG_WARNING((
-                    "the accumulated acceptance probability inside a reaction volume exeededs one in particle-particle reaction: p_acc = %f, reaction_length = %f, dt = %f.",
+                    "the accumulated acceptance probability inside a reaction volume exeededs one in particle-particle reaction: p_acc = %f, reaction_length = %e, dt = %e.",
                      accumulated_prob, reaction_length_, dt_));
             } 
             

From 80128fcd1742dc1059d4db184c634d3d38e83bd5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 14:58:29 +0200
Subject: [PATCH 1073/1541] Output percentage of steps spent in different sim.
 modes at the end

---
 egfrd.py | 28 +++++++++++++++++++---------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c9fb1849..d38860b4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2563,32 +2563,42 @@ def print_report(self, out=None):
             - None
 
         """
+        total_steps = self.step_counter
+        single_steps = numpy.array(self.single_steps.values()).sum()
+        interaction_steps = numpy.array(self.interaction_steps.values()).sum()
+        pair_steps = numpy.array(self.pair_steps.values()).sum()
+        multi_steps = self.multi_steps[3] # total multi steps
+
         report = '''
 t = %g
 steps = %d 
-\tSingle:\t%d\t(escape: %d, reaction: %d, bursted: %d)
-\tInteraction: %d\t(escape: %d, interaction: %d, bursted: %d)
-\tPair:\t%d\t(escape r: %d, R: %d, reaction pair: %d, single: %d, bursted: %d)
-\tMulti:\t%d\t(escape: %d, reaction pair: %d, single: %d, bursted: %d)
+\tSingle:\t%d\t(%.2f %%)\t(escape: %d, reaction: %d, bursted: %d)
+\tInteraction: %d\t(%.2f %%)\t(escape: %d, interaction: %d, bursted: %d)
+\tPair:\t%d\t(%.2f %%)\t(escape r: %d, R: %d, reaction pair: %d, single: %d, bursted: %d)
+\tMulti:\t%d\t(%.2f %%)\t(escape: %d, reaction pair: %d, single: %d, bursted: %d)
 total reactions = %d
 rejected moves = %d
 ''' \
-            % (self.t, self.step_counter,
-               numpy.array(self.single_steps.values()).sum(),
+            % (self.t, total_steps,
+               single_steps,
+               (100.0*single_steps) / total_steps,
                self.single_steps[EventType.SINGLE_ESCAPE],
                self.single_steps[EventType.SINGLE_REACTION],
                self.single_steps[EventType.BURST],
-               numpy.array(self.interaction_steps.values()).sum(),
+               interaction_steps,
+               (100.0*interaction_steps) / total_steps,
                self.interaction_steps[EventType.IV_ESCAPE],
                self.interaction_steps[EventType.IV_INTERACTION],
                self.interaction_steps[EventType.BURST],
-               numpy.array(self.pair_steps.values()).sum(),
+               pair_steps,
+               (100.0*pair_steps) / total_steps,
                self.pair_steps[EventType.IV_ESCAPE],
                self.pair_steps[EventType.COM_ESCAPE],
                self.pair_steps[EventType.IV_REACTION],
                self.pair_steps[EventType.SINGLE_REACTION],
                self.pair_steps[EventType.BURST],
-               self.multi_steps[3], # total multi steps
+               multi_steps,
+               (100.0*multi_steps) / total_steps,
                self.multi_steps[EventType.MULTI_ESCAPE],
                self.multi_steps[EventType.MULTI_BIMOLECULAR_REACTION],
                self.multi_steps[EventType.MULTI_UNIMOLECULAR_REACTION],

From 6ef9a8ae74f5b274879823abf89fe1e9e366ee81 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 18:35:36 +0200
Subject: [PATCH 1074/1541] A better workaround for the EDGE_HITS_EDGE cylinder
 scaling problem

---
 shells.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index dd1ca530..4061e17c 100755
--- a/shells.py
+++ b/shells.py
@@ -1030,15 +1030,21 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 h_touch = ref_to_shell_z - shell_radius # TODO This is a crude fix to override the original version above and may be improved
                 z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
-            else:
+            else:                
                 #def r1(x):
                     #shell_radius_sq = shell_radius**2
                     #return x/tan_scale_angle - scale_center_to_shell_z + \
                            #math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2))**2)
 
                 #r_touch = findroot(r1, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
-                r_touch = math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2)
-                          # TODO This is a crude fix to override the original version above and may be improved
+
+                # Very crude alternative that does not involve a rootfinder; treat the static shell as a box:
+                #r_touch = math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2)
+
+                # Improved fix, but still suboptimal: basically the edge-hits-barrel solution
+                cot_scale_angle = math.tan(scale_angle - Pi/2.0)
+                r_touch = ref_to_shell_y - shell_radius * ( math.sqrt(2.0*cot_scale_angle)+ cot_scale_angle ) / (1.0 + cot_scale_angle**2.0)
+                          
                 r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))
 

From 8aa0176d98fd762abfa693bac92311f131d70a2e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 18:54:36 +0200
Subject: [PATCH 1075/1541] Allow for creation of (static) spherical surfaces

---
 model.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/model.py b/model.py
index a3a67acf..fd31b402 100644
--- a/model.py
+++ b/model.py
@@ -1,5 +1,5 @@
 import _gfrd
-from _gfrd import create_cuboidal_region, create_cylindrical_surface, \
+from _gfrd import create_cuboidal_region, create_spherical_surface, create_cylindrical_surface, \
         create_disk_surface, create_planar_surface, create_double_sided_planar_surface
 import numpy
 
@@ -17,6 +17,7 @@
 
     # From _gfrd. Should be part of the world class.
     'create_cuboidal_region',
+    'create_spherical_surface',
     'create_cylindrical_surface',
     'create_disk_surface',
     'create_planar_surface',

From 1c5f1b5e9176a59e973eeba686f62b190f99022b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 19:13:53 +0200
Subject: [PATCH 1076/1541] Test-log static spherical surfaces

---
 visualization/vtklogger.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 07bfcd8e..938a2742 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -271,6 +271,8 @@ def stop(self):
                            self.get_cylindrical_surface_data())
         self.make_snapshot('planar_surfaces',
                            self.get_planar_surface_data())
+        self.make_snapshot('spherical_surfaces',
+                           self.get_spherical_surface_data())
         if self.draw_simulation_box:
             self.make_snapshot('cuboidal_regions', 
                                self.get_cuboidal_region_data())
@@ -365,6 +367,12 @@ def get_cylindrical_surface_data(self):
                              or isinstance(surface.shape, Disk)]
         return self.process_cylinders(cylinders)
 
+    def get_spherical_surface_data(self):
+        spheres = [surface for surface
+                           in self.sim.world.structures
+                           if isinstance(surface.shape, Sphere)]
+        return self.process_spheres(spheres)
+
     def process_spheres(self, spheres=[], color_list=[]):
         # Return 4 lists:
         #   - positions

From 1e017da68ca0ee25ed90c2e4af113b8ef5a1831a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 24 Aug 2012 19:15:10 +0200
Subject: [PATCH 1077/1541] Changes to pipeline - not yet working well

---
 visualization/pipeline.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/visualization/pipeline.py b/visualization/pipeline.py
index f4425ec3..adb5141c 100644
--- a/visualization/pipeline.py
+++ b/visualization/pipeline.py
@@ -440,6 +440,16 @@ def rebuild(self):
             else:
                 rep6.AmbientColor = color
 
+            # Spherical surfaces.
+            spherical_surface_data = self.add_extract_block(static, [8], 'b7')
+            spherical_surfaces = self.add_tensor_glyph(spherical_surface_data, 'Box', 
+                                                    name='Spherical Surfaces')
+
+            rep7 = self.show(spherical_surfaces)
+            rep7.Representation = 'Surface'
+            rep7.Opacity = 0.5
+            rep7.Opacity = 0.5
+
 
         # Set camera.
         cam = rv.GetActiveCamera()

From 2a23b8f531ee2d6f0f55da48e7644f3fec4eed80 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 27 Aug 2012 11:43:26 +0200
Subject: [PATCH 1078/1541] Make static spheres visible for cylinder scaling
 and multi formation

---
 egfrd.py  | 6 ++++--
 shells.py | 5 ++++-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d38860b4..d8cc6114 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -16,6 +16,7 @@
     DomainID,
     ParticleContainer,
     CuboidalRegion,
+    SphericalSurface,
     CylindricalSurface,
     DiskSurface,
     PlanarSurface,
@@ -1650,7 +1651,7 @@ def make_new_domain(self, single):
             # get the closest object (if there)
             if multi_partners:
                 multi_partners = sorted(multi_partners, key=lambda domain_overlap: domain_overlap[1])
-#                log.debug('multi_partners: %s' % str(multi_partners))
+                #log.debug('multi_partners: %s' % str(multi_partners))
                 closest_overlap = multi_partners[0][1]
             else:
                 # In case there is really nothing
@@ -2363,7 +2364,8 @@ def form_multi(self, single, multi_partners):
                     isinstance(partner, Multi) or \
                     isinstance(partner, PlanarSurface) or \
                     isinstance(partner, DiskSurface) or \
-                    isinstance(partner, CylindricalSurface)), \
+                    isinstance(partner, CylindricalSurface)) or \
+                    isinstance(partner, SphericalSurface), \
                     'multi_partner %s was not of proper type' % (partner)
 
 
diff --git a/shells.py b/shells.py
index 4061e17c..0288b2dd 100755
--- a/shells.py
+++ b/shells.py
@@ -5,6 +5,7 @@
 from _gfrd import (
     Sphere,
     SphericalShell,
+    SphericalSurface,
     Cylinder,
     CylindricalShell,    
     CylindricalSurface,
@@ -1433,7 +1434,9 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # or planar surfaces and parallel to the testCylinder axis
         for surface, distance in neighbor_surfaces:
             # TODO
-            if isinstance(surface, CylindricalSurface):
+            if isinstance(surface, SphericalSurface):
+                dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(surface.shape, self, dr, dz_right, dz_left)
+            elif isinstance(surface, CylindricalSurface):
                 dr, dz_right, dz_left = get_dr_dzright_dzleft_to_CylindricalShape(surface.shape, self, dr, dz_right, dz_left)            
             elif isinstance(surface, PlanarSurface):
                 dr, dz_right, dz_left = get_dr_dzright_dzleft_to_PlanarShape(surface.shape, self, dr, dz_right, dz_left)

From fe78fd48ff1f307a492cb9c96942da3ff3a52233 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 27 Aug 2012 11:43:59 +0200
Subject: [PATCH 1079/1541] Correct pipeline construction for VTKlogging of
 static spheres

---
 visualization/pipeline.py  | 8 ++++----
 visualization/vtklogger.py | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/visualization/pipeline.py b/visualization/pipeline.py
index adb5141c..55cd6799 100644
--- a/visualization/pipeline.py
+++ b/visualization/pipeline.py
@@ -416,7 +416,6 @@ def rebuild(self):
             rep5 = self.show(planar_surfaces)
             rep5.Representation = 'Surface'
             rep5.Opacity = 0.5
-            rep5.Opacity = 0.5
 
 
             # Cuboidal surfaces.
@@ -442,13 +441,14 @@ def rebuild(self):
 
             # Spherical surfaces.
             spherical_surface_data = self.add_extract_block(static, [8], 'b7')
-            spherical_surfaces = self.add_tensor_glyph(spherical_surface_data, 'Box', 
-                                                    name='Spherical Surfaces')
+            spherical_surfaces = self.add_sphere_glyph(spherical_surface_data, self.resolution, 
+                                                       name='Spherical Surfaces')
+            spherical_surfaces.SetScaleFactor = self.sphere_radius_scale_factor
 
             rep7 = self.show(spherical_surfaces)
+            #self.set_color(spherical_surfaces, rep7, color_map=MakeNiceLT)
             rep7.Representation = 'Surface'
             rep7.Opacity = 0.5
-            rep7.Opacity = 0.5
 
 
         # Set camera.
diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 938a2742..8fc30371 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -271,11 +271,11 @@ def stop(self):
                            self.get_cylindrical_surface_data())
         self.make_snapshot('planar_surfaces',
                            self.get_planar_surface_data())
-        self.make_snapshot('spherical_surfaces',
-                           self.get_spherical_surface_data())
         if self.draw_simulation_box:
             self.make_snapshot('cuboidal_regions', 
                                self.get_cuboidal_region_data())
+        self.make_snapshot('spherical_surfaces',
+                           self.get_spherical_surface_data())
 
         # Finally, write PVD files.
         self.vtk_writer.write_pvd(self.dir + '/' + 'files.pvd', 

From 11d180a7178bc38ddae9bd0479ae7fab899e653d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 27 Aug 2012 11:52:01 +0200
Subject: [PATCH 1080/1541] Revise order of surfaces in VTK logging and
 pipeline construction

---
 visualization/pipeline.py  | 62 ++++++++++++++++++++------------------
 visualization/vtklogger.py |  4 +--
 2 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/visualization/pipeline.py b/visualization/pipeline.py
index 55cd6799..dd167fd7 100644
--- a/visualization/pipeline.py
+++ b/visualization/pipeline.py
@@ -341,8 +341,21 @@ def rebuild(self):
 
 
         if SURFACES:
-            # Cylindrical surfaces.
-            cylindrical_surface_data = self.add_extract_block(static, [2], 'b4')
+
+            istart=2
+
+            #### Spherical surfaces.
+            spherical_surface_data = self.add_extract_block(static, [istart], 'b4')
+            spherical_surfaces = self.add_sphere_glyph(spherical_surface_data, self.resolution, 
+                                                       name='Spherical Surfaces')
+            spherical_surfaces.SetScaleFactor = self.sphere_radius_scale_factor
+
+            rep4 = self.show(spherical_surfaces)
+            rep4.Representation = 'Surface'
+            rep4.Opacity = 0.5
+
+            #### Cylindrical surfaces.
+            cylindrical_surface_data = self.add_extract_block(static, [istart+2], 'b5')
 
 
             if not HELIX:
@@ -351,9 +364,9 @@ def rebuild(self):
                                           name='Cylindrical Surfaces',
                                           scale=self.helix_radius_scale_factor)
 
-                rep4 = self.show(cylindrical_surfaces)
-                rep4.Representation = 'Wireframe'
-                rep4.Opacity = 0.5
+                rep5 = self.show(cylindrical_surfaces)
+                rep5.Representation = 'Wireframe'
+                rep5.Opacity = 0.5
             else:
                 helix_path = scripts_dir + '/helix.py'
                 assert os.path.isfile(helix_path), \
@@ -403,31 +416,31 @@ def rebuild(self):
                 # Make double_helix a bit thinner than helix.
                 double_helix.Radius = helix_radius / 20
 
-                rep4 = self.show(double_helix)
-                self.set_color(double_helix, rep4, color_map=MakeCoolToWarmLT,
+                rep5 = self.show(double_helix)
+                self.set_color(double_helix, rep5, color_map=MakeCoolToWarmLT,
                                color_array_name='TubeNormals')
 
 
-            # Planar surfaces.
-            planar_surface_data = self.add_extract_block(static, [4], 'b5')
+            #### Planar surfaces.
+            planar_surface_data = self.add_extract_block(static, [istart+4], 'b6')
             planar_surfaces = self.add_tensor_glyph(planar_surface_data, 'Box', 
                                                     name='Planar Surfaces')
 
-            rep5 = self.show(planar_surfaces)
-            rep5.Representation = 'Surface'
-            rep5.Opacity = 0.5
+            rep6 = self.show(planar_surfaces)
+            rep6.Representation = 'Surface'
+            rep6.Opacity = 0.5
 
 
             # Cuboidal surfaces.
-            cuboidal_region_data = self.add_extract_block(static, [6], 'b6')
+            cuboidal_region_data = self.add_extract_block(static, [istart+6], 'b7')
             cuboidal_regions = self.add_tensor_glyph(cuboidal_region_data,
                                                      'Box',
                                                      name='Cuboidal Regions')
 
-            rep6 = self.show(cuboidal_regions)
-            rep6.Representation = 'Wireframe'
-            rep6.Opacity = 1.0
-            rep6.LineWidth = 2 #1
+            rep7 = self.show(cuboidal_regions)
+            rep7.Representation = 'Wireframe'
+            rep7.Opacity = 1.0
+            rep7.LineWidth = 2 #1
 
             if DARK_BACKGROUND:
                 color = [1, 1, 1] # White.
@@ -435,20 +448,9 @@ def rebuild(self):
                 color = [0, 0, 0] # Black.
 
             if version == 4:
-                rep6.Color = color
+                rep7.Color = color
             else:
-                rep6.AmbientColor = color
-
-            # Spherical surfaces.
-            spherical_surface_data = self.add_extract_block(static, [8], 'b7')
-            spherical_surfaces = self.add_sphere_glyph(spherical_surface_data, self.resolution, 
-                                                       name='Spherical Surfaces')
-            spherical_surfaces.SetScaleFactor = self.sphere_radius_scale_factor
-
-            rep7 = self.show(spherical_surfaces)
-            #self.set_color(spherical_surfaces, rep7, color_map=MakeNiceLT)
-            rep7.Representation = 'Surface'
-            rep7.Opacity = 0.5
+                rep7.AmbientColor = color
 
 
         # Set camera.
diff --git a/visualization/vtklogger.py b/visualization/vtklogger.py
index 8fc30371..f57ed57f 100644
--- a/visualization/vtklogger.py
+++ b/visualization/vtklogger.py
@@ -267,6 +267,8 @@ def stop(self):
             self.writelog(entry[0], index, entry[2:])
 
         # Write data for regions and surfaces only once.
+        self.make_snapshot('spherical_surfaces',
+                           self.get_spherical_surface_data())
         self.make_snapshot('cylindrical_surfaces', 
                            self.get_cylindrical_surface_data())
         self.make_snapshot('planar_surfaces',
@@ -274,8 +276,6 @@ def stop(self):
         if self.draw_simulation_box:
             self.make_snapshot('cuboidal_regions', 
                                self.get_cuboidal_region_data())
-        self.make_snapshot('spherical_surfaces',
-                           self.get_spherical_surface_data())
 
         # Finally, write PVD files.
         self.vtk_writer.write_pvd(self.dir + '/' + 'files.pvd', 

From d87e7e1b5ea94538ea364c91811ce07508b73ac7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 27 Aug 2012 16:19:19 +0200
Subject: [PATCH 1081/1541] More informative debug output in newBDpropagator

---
 newBDPropagator.hpp | 53 +++++++++++++++++++++++++++++++++++++++------
 1 file changed, 46 insertions(+), 7 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 5a06ca98..ad4021b4 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -468,12 +468,24 @@ class newBDPropagator
                             // For a disk bound particle it can be both the bulk and the cylinder
                             const structure_id_type product_structure_id(reactant_structure->structure_id()); // the parent structure
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
-                            // Produce new position and structure id
-                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(product_structure).c_str())); // TESTING
+                            
+                            assert( product_species.structure_type_id() == product_structure->sid() );
+                            
+                            // Some debug info // TESTING
+                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair with:" ));
+                            LOG_DEBUG(("reactant_structure = %s, sid = %s",
+                                          boost::lexical_cast<std::string>(*reactant_structure).c_str(),
+                                          boost::lexical_cast<std::string>( reactant_structure->sid()).c_str() ));
+                            LOG_DEBUG(("product_structure = %s, sid = %s",
+                                          boost::lexical_cast<std::string>(*product_structure).c_str(),
+                                          boost::lexical_cast<std::string>( product_structure->sid()).c_str() ));
+                                          
+                            // Produce new position and structure id                            
                             const position_structid_pair_type new_pos_sid_pair( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos,
-                                                                                                                      product_species.radius(), reaction_length_, rng_) );                            
+                                                                                                                      product_species.radius(), reaction_length_, rng_) );                                                                                                                      
                             // Apply boundary conditions
-                            product_pos_struct_id = tx_.apply_boundary( new_pos_sid_pair );
+                            product_pos_struct_id = tx_.apply_boundary( new_pos_sid_pair );                            
+                            
                             // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
@@ -575,10 +587,19 @@ class newBDPropagator
                             // This is all taken care of by the structure functions get_pos_sid_pair_pair; the latter has to be called
                             // with the right order of parameters, i.e. passing first the species of the particle staying on the reactant_structure,
                             // then the species of the particle staying on the parent_structure.
+                                                        
+                            // Some debug info // TESTING
+                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair_pair with:" ));
+                            LOG_DEBUG(("reactant_structure = %s, sid = %s",
+                                          boost::lexical_cast<std::string>(*reactant_structure).c_str(),
+                                          boost::lexical_cast<std::string>( reactant_structure->sid()).c_str() ));
+                            LOG_DEBUG(("prod1_structure = %s, sid = %s",
+                                          boost::lexical_cast<std::string>(*prod1_structure).c_str(),
+                                          boost::lexical_cast<std::string>( prod1_structure->sid()).c_str() ));
+                            LOG_DEBUG(("Note: prod0_structure = reactant_structure"));
                             
                             // Produce two new positions and structure IDs
                             // Note that reactant_structure = prod0_structure here.
-                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair_pair with %s", boost::lexical_cast<std::string>(prod1_structure).c_str())); // TESTING
                             pos0pos1_pair = reactant_structure->get_pos_sid_pair_pair(*prod1_structure, reactant_pos, product0_species, product1_species, reaction_length_, rng_ );
                             // Remember the new structure IDs
                             prod0_struct_id = pos0pos1_pair.first.second;
@@ -763,7 +784,17 @@ class newBDPropagator
                         // structures are the same, no projection should occur. This is handled correctly by the structure functions defined for equal
                         // origin_structure types.
                         const length_type offset(0.0);
-                        LOG_DEBUG(("Attempting pair reaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(reactant1_structure).c_str())); // TESTING
+                        
+                        // Some debug info // TESTING
+                        LOG_DEBUG(("Attempting pair reaction: calling get_pos_sid_pair with:" ));
+                        LOG_DEBUG(("reactant0_structure = %s, sid = %s",
+                                      boost::lexical_cast<std::string>(*reactant0_structure).c_str(),
+                                      boost::lexical_cast<std::string>( reactant0_structure->sid()).c_str() ));
+                        LOG_DEBUG(("reactant1_structure = %s, sid = %s",
+                                      boost::lexical_cast<std::string>(*reactant1_structure).c_str(),
+                                      boost::lexical_cast<std::string>( reactant1_structure->sid()).c_str() ));
+                        LOG_DEBUG(("Note: product_structure_type_id = %s", boost::lexical_cast<std::string>( product_structure_type_id).c_str() ));
+                        
                         const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair_2o(*reactant1_structure, product_structure_type_id,
                                                                                                                           reactants_CoM, offset, reaction_length_, rng_ ) );
                         // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above
@@ -877,7 +908,15 @@ class newBDPropagator
                         const species_type                              product_species( tx_.get_species(products[0]) );
 
                         //// 1 - GET NEW POSITION ON THE TARGET STRUCTURE                        
-                        LOG_DEBUG(("Attempting interaction: calling get_pos_sid_pair with %s", boost::lexical_cast<std::string>(product_structure).c_str())); // TESTING
+                        // Some debug info // TESTING
+                        LOG_DEBUG(("Attempting interaction: calling get_pos_sid_pair with:" ));
+                        LOG_DEBUG(("reactant_structure = %s, sid = %s",
+                                      boost::lexical_cast<std::string>(*reactant_structure).c_str(),
+                                      boost::lexical_cast<std::string>( reactant_structure->sid()).c_str() ));
+                        LOG_DEBUG(("product_structure = %s, sid = %s",
+                                      boost::lexical_cast<std::string>(*product_structure).c_str(),
+                                      boost::lexical_cast<std::string>( product_structure->sid()).c_str() ));
+                        
                         const position_structid_pair_type new_pos_sid_pair_tmp( reactant_structure->get_pos_sid_pair(*product_structure, reactant_pos,
                                                                                 product_species.radius(), reaction_length_, rng_) );
                         // Apply boundary conditions

From cebd0d9190134fd666055e23452f1eeb39de21c2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 27 Aug 2012 18:11:28 +0200
Subject: [PATCH 1082/1541] Determine product structure for BD single reactions
 in a better way + more informative debug output

---
 newBDPropagator.hpp | 151 ++++++++++++++++++++++++++++++--------------
 1 file changed, 103 insertions(+), 48 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index ad4021b4..55665bda 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -451,8 +451,10 @@ class newBDPropagator
                     case 1:
                     {
                         const position_type                             reactant_pos( pp.second.position() );
-                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure(pp.second.structure_id()) );
                         const structure_id_type                         reactant_structure_id( pp.second.structure_id() );
+                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure(reactant_structure_id) );
+                        const structure_id_type                         parent_structure_id( reactant_structure->structure_id() );
+                        const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure( parent_structure_id ) );
                         const species_type                              product_species( tx_.get_species(products[0]) );
                         
                         // Set default values for the position and structure of the product
@@ -462,21 +464,39 @@ class newBDPropagator
                         
                         //// 1 - CREATE NEW POSITION AND STRUCTURE ID                                                
                         if( product_species.structure_type_id() != reactant_structure->sid() )
-                        {
-                            // Get target structure; if not staying on the origin structure, the particle is
-                            // assumed to go to its parent structure, which in most cases is the bulk;
-                            // For a disk bound particle it can be both the bulk and the cylinder
-                            const structure_id_type product_structure_id(reactant_structure->structure_id()); // the parent structure
-                            const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
+                        {                            
+                            LOG_DEBUG(("Attempting single reaction with one product." ));
                             
-                            assert( product_species.structure_type_id() == product_structure->sid() );
+                            // Now determine the target structure id; if not staying on the origin structure,
+                            // the particle is assumed to go to either the default structure or its parent structure,
+                            // if different from the bulk.
+                            // For a disk-bound particle it can be both the bulk and the cylinder
+                            
+                            // Initialize: by default the particle goes to the bulk
+                            structure_id_type product_structure_id( tx_.get_def_structure_id() );
+                            
+                            if( product_species.structure_type_id() == tx_.get_def_structure_type_id() )
+                                ; // the product lives in the bulk; do nothing, set correctly already above
                             
+                            else if( product_species.structure_type_id() == parent_structure->sid() )
+                                // the product lives on the parent structure 
+                                product_structure_id =  parent_structure_id;
+                            
+                            else
+                              
+                                throw not_implemented("Invalid product structure in single reaction: Must be either parent or default structure!");
+                            
+                            // Get the structure behind the product_structure_id
+                            const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
+                            // Just one more check for safety
+                            assert( product_species.structure_type_id() == product_structure->sid() );
+
                             // Some debug info // TESTING
-                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair with:" ));
-                            LOG_DEBUG(("reactant_structure = %s, sid = %s",
+                            LOG_DEBUG(("Calling get_pos_sid_pair with:" ));
+                            LOG_DEBUG(("  reactant_structure = %s, sid = %s",
                                           boost::lexical_cast<std::string>(*reactant_structure).c_str(),
                                           boost::lexical_cast<std::string>( reactant_structure->sid()).c_str() ));
-                            LOG_DEBUG(("product_structure = %s, sid = %s",
+                            LOG_DEBUG(("  product_structure = %s, sid = %s",
                                           boost::lexical_cast<std::string>(*product_structure).c_str(),
                                           boost::lexical_cast<std::string>( product_structure->sid()).c_str() ));
                                           
@@ -534,38 +554,73 @@ class newBDPropagator
                     case 2:
                     {                        
                         //// 0 - SOME NECESSARY DEFINITONS
-                        const position_type                             reactant_pos(pp.second.position());
+                        const position_type                             reactant_pos(pp.second.position());                        
                         const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
-                        const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure( reactant_structure->structure_id() ) );
+                        const structure_type_id_type                    reactant_structure_type_id( reactant_structure->sid() );
+                        const structure_id_type                         parent_structure_id( reactant_structure->structure_id() );
+                        const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure(parent_structure_id) );
+                        const structure_type_id_type                    parent_structure_type_id( parent_structure->sid() );
+                        const structure_id_type                         default_structure_id( tx_.get_def_structure_id() );
+                        const boost::shared_ptr<const structure_type>   default_structure( tx_.get_structure(default_structure_id) );
+                        const structure_type_id_type                    default_structure_type_id( tx_.get_def_structure_type_id() );
                         
                         // The following will store the new positions and structure IDs
-                        structure_id_type                               prod0_struct_id;
-                        structure_id_type                               prod1_struct_id;
+                        structure_id_type                               product0_struct_id;
+                        structure_id_type                               product1_struct_id;
                         posstructid_posstructid_pair_type               pos0pos1_pair;
                         
                         // Determine the structures on which the products will end up.
                         // By default we set both product structure to reactant_structure.
-                        const boost::shared_ptr<const structure_type> prod0_structure(reactant_structure);
-                        const boost::shared_ptr<const structure_type> prod1_structure(reactant_structure);
+                        const boost::shared_ptr<const structure_type> product0_structure(reactant_structure);
+                        const boost::shared_ptr<const structure_type> product1_structure(reactant_structure);
                         // Now check whether one of the products actually leaves reactant_structure according to the reaction rules.
                         species_type product0_species(tx_.get_species(products[0]));
-                        species_type product1_species(tx_.get_species(products[1]));
-                        // If the products live on different structures, one must be the parent of the other.
-                        // In the latter case we have to bring them into the right order.
-                        // We set: species 0 lives on the current structure; species 1 lives in the parent structure (if applicable).
-                        // Compare the structure type IDs of the product species to determine where products will end up:
+                        species_type product1_species(tx_.get_species(products[1]));                        
+
+                        LOG_DEBUG(("Attempting single reaction with two products." ));
+                        
+                        // If the products live on different structures, one must be the parent of the other or the default structure.
+                        // In this case we have to bring the products into the right order.
+                        // We set: species 0 lives on the current structure; species 1 lives in the product structure (if applicable).
+                        // Compare the structure type IDs of the product species to determine where products will end up:                                                                                                                                                                    
+
+                        // Initialize: by default the dissociating particle goes into the bulk
+                        structure_id_type product1_structure_id( tx_.get_def_structure_id() );
+                        
                         if( product0_species.structure_type_id() != product1_species.structure_type_id() )
-                        {
-                            if( !(product0_species.structure_type_id() == parent_structure->sid() || 
-                                  product1_species.structure_type_id() == parent_structure->sid())  )
-                                throw not_implemented("One of the product species should live on parent structure.");
-                                             
-                            if ( !(product0_species.structure_type_id() == reactant_structure->sid()) )
+                        {                          
+                            // First check whether the reaction rule defines a legal dissociation reaction
+                            if( !( product0_species.structure_type_id() == reactant_structure_type_id ||
+                                   product1_species.structure_type_id() == reactant_structure_type_id    )
+                              )
+                                throw not_implemented("Invalid product structure for first product in single reaction: One particle must stay behind on structure of origin!");
+                                
+                            if( !( product0_species.structure_type_id() == parent_structure_type_id  ||
+                                   product0_species.structure_type_id() == default_structure_type_id || 
+                                   product1_species.structure_type_id() == parent_structure_type_id  ||                                  
+                                   product1_species.structure_type_id() == default_structure_type_id    )
+                              )
+                                throw not_implemented("Invalid product structure for second product in single reaction: Must be either parent or default structure!");
+                            
+                            // OK, reaction rule is legal; set the product species according to the above convention
+                            if ( !(product0_species.structure_type_id() == reactant_structure_type_id) )
                                 std::swap(product0_species, product1_species);
                             
-                            // If the exception was not thrown, everything should be OK now.
+                            // Determine where the dissociating particle (product1) goes
+                            if( product1_species.structure_type_id() == default_structure_type_id )
+                                ; // the dissociating product lives in the bulk; do nothing, set correctly already above
+                            
+                            else if( product1_species.structure_type_id() == parent_structure_type_id )
+                                // the product lives on the parent structure 
+                                product1_structure_id =  parent_structure_id;
+                            
+                            else
+                              
+                              throw not_implemented("Invalid product structure: Must be either parent structure or default structure!");
+                                                        
+                            // If no exception was thrown, everything should be OK now.
                             // Change the default setting for product1
-                            const boost::shared_ptr<const structure_type> prod1_structure(parent_structure);
+                            const boost::shared_ptr<const structure_type> product1_structure( tx_.get_structure(product1_structure_id) );
                         }
                         // TODO Can we not outsource this part to the structure functions, too?
 
@@ -582,28 +637,28 @@ class newBDPropagator
                             }
                         
                             //// 1a - GENERATE POSITIONS AND STRUCTURE IDs FOR PRODUCT PARTICLES AFTER REACTION
-                            // If the product particles do NOT live on the same structure => structure -> structure + parent_structure dissociation.
+                            // If the product particles do NOT live on the same structure => structure -> structure + (parent or default structure) dissociation.
                             // Else, the products live on the same structure AND on the same structure as the reactant.
                             // This is all taken care of by the structure functions get_pos_sid_pair_pair; the latter has to be called
                             // with the right order of parameters, i.e. passing first the species of the particle staying on the reactant_structure,
-                            // then the species of the particle staying on the parent_structure.
-                                                        
+                            // then the species of the particle that leaves reactant_structure
+                            
                             // Some debug info // TESTING
-                            LOG_DEBUG(("Attempting single reaction: calling get_pos_sid_pair_pair with:" ));
-                            LOG_DEBUG(("reactant_structure = %s, sid = %s",
+                            LOG_DEBUG(("Calling get_pos_sid_pair_pair with:" ));
+                            LOG_DEBUG(("  reactant_structure = %s, sid = %s",
                                           boost::lexical_cast<std::string>(*reactant_structure).c_str(),
                                           boost::lexical_cast<std::string>( reactant_structure->sid()).c_str() ));
-                            LOG_DEBUG(("prod1_structure = %s, sid = %s",
-                                          boost::lexical_cast<std::string>(*prod1_structure).c_str(),
-                                          boost::lexical_cast<std::string>( prod1_structure->sid()).c_str() ));
-                            LOG_DEBUG(("Note: prod0_structure = reactant_structure"));
-                            
+                            LOG_DEBUG(("  product1_structure = %s, sid = %s",
+                                          boost::lexical_cast<std::string>(*product1_structure).c_str(),
+                                          boost::lexical_cast<std::string>( product1_structure->sid()).c_str() ));
+                            LOG_DEBUG(("Note: product0_structure = reactant_structure"));
+                        
                             // Produce two new positions and structure IDs
-                            // Note that reactant_structure = prod0_structure here.
-                            pos0pos1_pair = reactant_structure->get_pos_sid_pair_pair(*prod1_structure, reactant_pos, product0_species, product1_species, reaction_length_, rng_ );
+                            // Note that reactant_structure = product0_structure here.                            
+                            pos0pos1_pair = reactant_structure->get_pos_sid_pair_pair(*product1_structure, reactant_pos, product0_species, product1_species, reaction_length_, rng_ );
                             // Remember the new structure IDs
-                            prod0_struct_id = pos0pos1_pair.first.second;
-                            prod1_struct_id = pos0pos1_pair.second.second;
+                            product0_struct_id = pos0pos1_pair.first.second;
+                            product1_struct_id = pos0pos1_pair.second.second;
                             // Apply the boundary conditions
                             const position_structid_pair_type pos_structid0 (tx_.apply_boundary( pos0pos1_pair.first  ));
                             const position_structid_pair_type pos_structid1 (tx_.apply_boundary( pos0pos1_pair.second ));
@@ -787,10 +842,10 @@ class newBDPropagator
                         
                         // Some debug info // TESTING
                         LOG_DEBUG(("Attempting pair reaction: calling get_pos_sid_pair with:" ));
-                        LOG_DEBUG(("reactant0_structure = %s, sid = %s",
+                        LOG_DEBUG(("  reactant0_structure = %s, sid = %s",
                                       boost::lexical_cast<std::string>(*reactant0_structure).c_str(),
                                       boost::lexical_cast<std::string>( reactant0_structure->sid()).c_str() ));
-                        LOG_DEBUG(("reactant1_structure = %s, sid = %s",
+                        LOG_DEBUG(("  reactant1_structure = %s, sid = %s",
                                       boost::lexical_cast<std::string>(*reactant1_structure).c_str(),
                                       boost::lexical_cast<std::string>( reactant1_structure->sid()).c_str() ));
                         LOG_DEBUG(("Note: product_structure_type_id = %s", boost::lexical_cast<std::string>( product_structure_type_id).c_str() ));
@@ -910,10 +965,10 @@ class newBDPropagator
                         //// 1 - GET NEW POSITION ON THE TARGET STRUCTURE                        
                         // Some debug info // TESTING
                         LOG_DEBUG(("Attempting interaction: calling get_pos_sid_pair with:" ));
-                        LOG_DEBUG(("reactant_structure = %s, sid = %s",
+                        LOG_DEBUG(("  reactant_structure = %s, sid = %s",
                                       boost::lexical_cast<std::string>(*reactant_structure).c_str(),
                                       boost::lexical_cast<std::string>( reactant_structure->sid()).c_str() ));
-                        LOG_DEBUG(("product_structure = %s, sid = %s",
+                        LOG_DEBUG(("  product_structure = %s, sid = %s",
                                       boost::lexical_cast<std::string>(*product_structure).c_str(),
                                       boost::lexical_cast<std::string>( product_structure->sid()).c_str() ));
                         

From 2a0667ec047ed411752a285a9d31c2fe9bab7e48 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 28 Aug 2012 14:27:06 +0200
Subject: [PATCH 1083/1541] Turn off MixedPair2D3D formation again after
 merging confusion...

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 873f1590..d8cc6114 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -143,10 +143,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return CylindricalSurfacePairtestShell  (single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
         return PlanarSurfaceTransitionPairtestShell (single1, single2, geometrycontainer, domains) 
-    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
-    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+    #elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+        #return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
+    #elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+        #return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
         return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):

From 7124f1d792e053e81f4a80d311d552b6ed1a863f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 28 Aug 2012 15:17:09 +0200
Subject: [PATCH 1084/1541] More informative exception texts for
 StructureFunctions

---
 StructureFunctions.hpp | 86 +++++++++++++++++++++---------------------
 1 file changed, 43 insertions(+), 43 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 7fd59bf2..5630d4df 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -66,7 +66,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (CuboidalRegion->CuboidalRegion).");
 };
 
 // CuboidalRegion -> SphericalSurface
@@ -84,7 +84,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->Sphere).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -114,7 +114,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (CuboidalRegion->Cylinder).");
     
 };
 
@@ -143,7 +143,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (CuboidalRegion->Disk).");
 };
 
 // CuboidalRegion -> PlanarSurface
@@ -171,7 +171,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (CuboidalRegion->Plane).");
 };
 
 /********************************/
@@ -192,7 +192,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->CuboidalRegion).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -212,7 +212,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -232,7 +232,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Cylinder).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -252,7 +252,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Disk).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -272,7 +272,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Plane).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -322,7 +322,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (Cylinder->Cylinder).");
 };
 
 // CylindricalSurface -> SphericalSurface
@@ -340,7 +340,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Sphere).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -370,7 +370,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition.");
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (Cylinder->Disk).");
 };
 
 // CylindricalSurface -> PlanarSurface
@@ -388,7 +388,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Plane).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -432,7 +432,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Sphere).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -485,7 +485,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");    
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (Disk->Disk).");    
 };
 
 // DiskSurface -> PlanarSurface
@@ -503,7 +503,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Plane).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -547,7 +547,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Sphere).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -567,7 +567,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Cylinder).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -587,7 +587,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Disk).");
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -613,7 +613,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (Plane->Plane).");        
 };
 
 
@@ -657,7 +657,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (CuboidalRegion->CuboidalRegion/CuboidalRegion).");        
 };
 
 // CuboidalRegion -> SphericalSurface
@@ -677,7 +677,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Sphere).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -700,7 +700,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Cylinder).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -724,7 +724,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Disk).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -747,7 +747,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Plane).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -773,7 +773,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/CuboidalRegion).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -796,7 +796,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Sphere).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -819,7 +819,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Cylinder).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -842,7 +842,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Disk).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -865,7 +865,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Plane).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -931,7 +931,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (Cylinder->Cylinder/Cylinder).");        
 };
 
 // CylindricalSurface -> SphericalSurface
@@ -951,7 +951,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Cylinder/Sphere).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -974,7 +974,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Cylinder/Disk).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -997,7 +997,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Cylinder/Plane).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1050,7 +1050,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Disk/Sphere).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1076,7 +1076,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
     // IMPLEMENT THE UNBINDING FROM THE DISK ACTING AS A SINK!
     
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Disk/Cylinder).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1099,7 +1099,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Disk/Disk).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1122,7 +1122,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Disk/Plane).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1175,7 +1175,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Plane/Sphere).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1198,7 +1198,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Plane/Cylinder).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1221,7 +1221,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
     typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported.");
+    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Plane/Disk).");
     
     return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
                                 std::make_pair(position_type(), structure_id_type())    );
@@ -1259,7 +1259,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition.");        
+      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (Plane->Plane/Plane).");        
 };
 
 /******************************************************************************************************/

From cb8b6ad9695863f00a1f8f0e49b9ba81a9c1916b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 28 Aug 2012 19:11:17 +0200
Subject: [PATCH 1085/1541] Comment more on project_point method of Structures

---
 Cylinder.hpp | 6 ++++++
 Plane.hpp    | 4 +++-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/Cylinder.hpp b/Cylinder.hpp
index 81f3a0dd..9266de36 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -121,6 +121,12 @@ to_internal(Cylinder<T_> const& obj, typename Cylinder<T_>::position_type const&
     return std::make_pair(r, z);
 }
 
+// The following projects 'pos' on the cylinder
+// It returns a pair of which the first component is the projected position.
+// The second is again a pair of which the first entry is the distance of 'pos'
+// from the cylinder axis, the second a length l which indicates whether the
+// projected position is in the cylinder (true if l negative; l is the negative
+// distance of the projected position to the cylinder edge).
 template<typename T_>
 inline std::pair<typename Cylinder<T_>::position_type,
                  std::pair<typename Cylinder<T_>::length_type,
diff --git a/Plane.hpp b/Plane.hpp
index d751e5f9..dee53f2f 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -212,7 +212,9 @@ inline std::pair<typename Plane<T_>::position_type,
                            typename Plane<T_>::length_type> >
 project_point(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
 // Calculates the projection of 'pos' onto the plane 'obj' and also returns the coefficient
-// for the normal component (z) of 'pos' in the basis of the plane
+// for the normal component (z) of 'pos' in the basis of the plane (pair entry .second.first)
+// and the negative distance to the closest edge (pair entry .second.second). Note that the
+// latter also indicates whether the projected point is in the plane.
 {
     typedef typename Plane<T_>::length_type length_type;
 

From 270d03186687f580c64cac7585ab5367d289bfc6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 28 Aug 2012 19:11:40 +0200
Subject: [PATCH 1086/1541] Include BD pair reactions with reactants on
 different planes

---
 StructureFunctions.hpp | 49 +++++++++++++++++++++++++++++++++++-------
 1 file changed, 41 insertions(+), 8 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 5630d4df..9e184cd3 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -364,6 +364,10 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     length_type         proj_dist( target_structure.project_point(old_pos).second.second );
         // the distance of the projection of old_pos on target_structure to target_structure
     
+    // Note that this function also correctly handles the pair reaction between a particle on a disk
+    // and a particle on a cylinder. Since we assume that the product will end up on the disk, new_pos
+    // (which is the projection of the center of mass of both particles on the disk) will be the
+    // correct product position.
     if(proj_dist < 0){ // if projection of old_pos is in structure
      
           return std::make_pair( new_pos, new_id );
@@ -602,18 +606,47 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
-
-    // Currently only species change and decay are supported
-    if(origin_structure.id() == target_structure.id()){
-     
+    typedef typename Ttraits_::structure_id_type          structure_id_type;
+    typedef typename Ttraits_::position_type              position_type;
+    typedef typename Ttraits_::length_type                length_type;
+    typedef std::pair<length_type, length_type>           length_pair_type;
+    typedef std::pair<position_type, length_pair_type>    projected_type;
+    
+    // Species change and decay: no structure change
+    if( origin_structure.id() == target_structure.id() )
+    {     
           return std::make_pair( old_pos, origin_structure.id() );
     }
+    // Function is called with two different structure of the same type: Pair reaction "over the edge"
+    else if( origin_structure.sid() == target_structure.sid() )
+    {        
+          // In this case old_pos = CoM of the two reactants, 
+          // origin_structure = the origin structure of the first reactant,
+          // target_structure = the origin structure of the second reactant.
+          // Return the projection of the CoM towards the plane that
+          // it is closest to.
+          
+          // First make sure that the projection of the CoM is in both planes (should never fail)
+          projected_type      proj_1( origin_structure.project_point(old_pos) );
+          projected_type      proj_2( target_structure.project_point(old_pos) );
+          
+          if( !(proj_1.second.second<=0.0 && proj_2.second.second<=0.0) ) // second length pair entry is negative if pos. is in plane
+              throw illegal_propagation_attempt("Center of mass does not project on both origin planes in pair reaction involving two planes.");
+          
+          // Decide which projection of the CoM to take for the product position
+          position_type       proj_pos_1( proj_1.first );
+          position_type       proj_pos_2( proj_2.first );
+          length_type         proj_normal_1( proj_1.second.first );
+          length_type         proj_normal_2( proj_2.second.first );
+    
+          if(proj_normal_1 < proj_normal_2)
+              return std::make_pair( proj_pos_1, origin_structure.id() );
+          else
+              return std::make_pair( proj_pos_2, target_structure.id() );
+    }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Origin structure must be equal to target structure for this type of structure transition (Plane->Plane).");        
+      throw illegal_propagation_attempt("Origin structure type must be equal to target structure type for this type of structure transition (Plane->Plane).");        
 };
 
 

From 61750cedd726677c6ffe400522c85e5659633f95 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 29 Aug 2012 15:08:02 +0200
Subject: [PATCH 1087/1541] Another fix to BD pair reaction "around the edge"

The introduced check for the CoM being in plane with one of the
structures was to rigid and got replaced with a more appropriate one.
---
 StructureFunctions.hpp | 43 ++++++++++++++++++++++++------------------
 newBDPropagator.hpp    | 14 ++++++++++----
 2 files changed, 35 insertions(+), 22 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 9e184cd3..eb6176b6 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -8,6 +8,7 @@
 //#include "PlanarSurface.hpp"
 #include "linear_algebra.hpp"
 #include "exceptions.hpp"
+#include "Logger.hpp"
 
 // Forward declaration of structures
 template <typename Ttraits_>
@@ -602,7 +603,7 @@ inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_
 get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   PlanarSurface<Ttraits_>               const& target_structure,
                   typename Ttraits_::position_type      const& old_pos,
-                  typename Ttraits_::length_type        const& offset,
+                  typename Ttraits_::length_type        const& typical_length,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
@@ -610,7 +611,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::position_type              position_type;
     typedef typename Ttraits_::length_type                length_type;
     typedef std::pair<length_type, length_type>           length_pair_type;
-    typedef std::pair<position_type, length_pair_type>    projected_type;
+    typedef std::pair<position_type, length_pair_type>    projected_type;    
     
     // Species change and decay: no structure change
     if( origin_structure.id() == target_structure.id() )
@@ -623,26 +624,32 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
           // In this case old_pos = CoM of the two reactants, 
           // origin_structure = the origin structure of the first reactant,
           // target_structure = the origin structure of the second reactant.
-          // Return the projection of the CoM towards the plane that
-          // it is closest to.
+          // We assume here that the problem has been correctly transformed
+          // into the structure passed as target_structure to this function
+          // before; however, to be sure, we check again and return the 
+          // ID of the structure that the CoM (old_pos) lies in.
+          // As a standard, this should be target_structure.
           
-          // First make sure that the projection of the CoM is in both planes (should never fail)
-          projected_type      proj_1( origin_structure.project_point(old_pos) );
-          projected_type      proj_2( target_structure.project_point(old_pos) );
+          // Calculate the projections of the CoM (old_pos) into both involved planes
+          // This will also give the normal components of old_pos in the CS of the planes
+          projected_type proj_o( origin_structure.project_point(old_pos) );
+          projected_type proj_t( target_structure.project_point(old_pos) );
           
-          if( !(proj_1.second.second<=0.0 && proj_2.second.second<=0.0) ) // second length pair entry is negative if pos. is in plane
-              throw illegal_propagation_attempt("Center of mass does not project on both origin planes in pair reaction involving two planes.");
+          // Check in which plane old_pos lies by comparing the normal components of the projection
+          // Note: pair entries proj_X.second.first are the normal components
+          // Then return the right position-structure_id pair; for safety we return the projected CoM
+          // Note: apply_boundary will modify the product position accordingly if it lies outside of the (bounded) plane
+          assert(typical_length > 0.0); // typical_length should contain the particle radius if this function was called correctly
+          if( feq(proj_t.second.first, 0.0, typical_length) )
+              // CoM is in target_structure
+              return std::make_pair( proj_t.first, target_structure.id() );
           
-          // Decide which projection of the CoM to take for the product position
-          position_type       proj_pos_1( proj_1.first );
-          position_type       proj_pos_2( proj_2.first );
-          length_type         proj_normal_1( proj_1.second.first );
-          length_type         proj_normal_2( proj_2.second.first );
-    
-          if(proj_normal_1 < proj_normal_2)
-              return std::make_pair( proj_pos_1, origin_structure.id() );
+          else if( feq(proj_o.second.first, 0.0, typical_length) )
+              // CoM is in origin_structure
+              return std::make_pair( proj_o.first, origin_structure.id() );
           else
-              return std::make_pair( proj_pos_2, target_structure.id() );
+              // CoM is in neither plane; something is terribly wrong...
+              throw illegal_propagation_attempt("Center of mass is not in plane of either origin_structure or target_structure in pair reaction involving two PlanarSurfaces.");                    
     }
     else // structure transition not allowed
       
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 55665bda..061522a7 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -651,7 +651,7 @@ class newBDPropagator
                             LOG_DEBUG(("  product1_structure = %s, sid = %s",
                                           boost::lexical_cast<std::string>(*product1_structure).c_str(),
                                           boost::lexical_cast<std::string>( product1_structure->sid()).c_str() ));
-                            LOG_DEBUG(("Note: product0_structure = reactant_structure"));
+                            LOG_DEBUG(("  Note: product0_structure = reactant_structure"));
                         
                             // Produce two new positions and structure IDs
                             // Note that reactant_structure = product0_structure here.                            
@@ -816,9 +816,11 @@ class newBDPropagator
                         if ((s0.structure_type_id() == s1.structure_type_id()) &&
                             (reactant0_structure_id != reactant1_structure_id))
                         {
+                            LOG_DEBUG(("Transforming postion of reactant1 into structure of reactant0")); // TESTING
                             const position_structid_pair_type pos_cyclic1 (tx_.cyclic_transpose(std::make_pair(reactant1_pos, reactant1_structure_id),
                                                                                                 (*reactant0_structure) ));
                             reactant1_pos = pos_cyclic1.first;
+                            LOG_DEBUG(("  reactant1_pos=%s", boost::lexical_cast<std::string>(reactant1_pos).c_str() )); // TESTING
                         }
 
                         // calculate the product position (CoM of the two particles)
@@ -838,7 +840,10 @@ class newBDPropagator
                         // get_pos_sid_pair should result in projecting the CoM onto the lower level origin structure in this case. If both reactant
                         // structures are the same, no projection should occur. This is handled correctly by the structure functions defined for equal
                         // origin_structure types.
-                        const length_type offset(0.0);
+                        
+                        // This has to be passed to get_pos_sid_pair_2o because in some cases it will use feq() to compare whether a normal component
+                        // is zero; for that a typical length scale is needed
+                        const length_type typical_length( s0.radius() );
                         
                         // Some debug info // TESTING
                         LOG_DEBUG(("Attempting pair reaction: calling get_pos_sid_pair with:" ));
@@ -848,10 +853,11 @@ class newBDPropagator
                         LOG_DEBUG(("  reactant1_structure = %s, sid = %s",
                                       boost::lexical_cast<std::string>(*reactant1_structure).c_str(),
                                       boost::lexical_cast<std::string>( reactant1_structure->sid()).c_str() ));
-                        LOG_DEBUG(("Note: product_structure_type_id = %s", boost::lexical_cast<std::string>( product_structure_type_id).c_str() ));
+                        LOG_DEBUG(("  Note: product_structure_type_id = %s", boost::lexical_cast<std::string>( product_structure_type_id).c_str() ));                        
+                        LOG_DEBUG(("  Note: reactants_CoM=%s", boost::lexical_cast<std::string>(reactants_CoM).c_str() ));
                         
                         const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair_2o(*reactant1_structure, product_structure_type_id,
-                                                                                                                          reactants_CoM, offset, reaction_length_, rng_ ) );
+                                                                                                                          reactants_CoM, typical_length, reaction_length_, rng_ ) );
                         // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above
                         // in some cases might end up out of the target_structure (e.g. in case the two reactants are coming from adjacent planes
                         tx_.apply_boundary(product_pos_struct_id);

From 37085daf13500abd411bf8c2d7fc9ddbe26ecf38 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 29 Aug 2012 16:12:52 +0200
Subject: [PATCH 1088/1541] Allow user to define a bounding box for
 throw_in_particles

---
 gfrdbase.py | 50 +++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 43 insertions(+), 7 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 04f9ee1d..d163f33d 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -328,7 +328,7 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
 def create_network_rules_wrapper(model):
     return _gfrd.NetworkRulesWrapper(model.network_rules)
 
-def throw_in_particles(world, sid, n):
+def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
     """Add n particles of a certain Species to the specified world.
 
     Arguments:
@@ -338,6 +338,17 @@ def throw_in_particles(world, sid, n):
         - n
             the number of particles to add.
 
+    Optional arguments:
+        - bound_1
+            a 3D vector specifying corner 1 of a bounding box
+            that defines a rectangular region to which the placement
+            of the particles is restricted.
+            All vector components must be >=0 and <=world_size.
+        - bound_2
+            a 3D vector specifying corner 2 of the bounding box.
+            All vector components must be bigger than the components
+            of bound_1 and <=world_size.
+
     Make sure to first add the Species to the model with the method
     model.ParticleModel.add_species_type.
 
@@ -346,12 +357,33 @@ def throw_in_particles(world, sid, n):
     structure_type = world.get_structure_type(species.structure_type_id)
     structure_list = list(world.get_structure_ids(structure_type))
 
+    ws = world.world_size
+    # For comparison purposes:
+    bound_1 = numpy.array(bound_1)
+    bound_2 = numpy.array(bound_2)
+
+    if all(bound_1 == bound_2):
+      
+        # Don't allow a zero bounding box
+        bound_1 = numpy.array([0,0,0])
+        bound_2 = numpy.array([ws,ws,ws])
+
+        log.info('\n\tZero bounding box; setting bound_1 = %s and bound_2 = %s' % (bound_1, bound_2) )
+
+    correct_bounding_box = ( all(bound_1 >= 0) and all(bound_1 - bound_2 < 0) and all(bound_2 - [ws,ws,ws] <= 0) )
+
     if __debug__:
-        name = world.model.get_species_type_by_id(sid)["name"]
-        if name[0] != '(':
-            name = '(' + name + ')'
-        log.info('\n\tthrowing in %s particles of type %s to %s' %
-                 (n, name, structure_type.id))
+
+        if not correct_bounding_box:
+            log.error('\n\tIncorrect bounding box!')
+        else:
+            name = world.model.get_species_type_by_id(sid)["name"]
+            if name[0] != '(':
+                name = '(' + name + ')'
+            log.info('\n\tthrowing in %s particles of type %s to %s' % (n, name, structure_type.id))
+            log.info('\n\tbounding box = (%s, %s)' % (bound_1, bound_2))        
+
+    assert(correct_bounding_box)
 
     i = 0
     while i < int(n):
@@ -366,7 +398,9 @@ def throw_in_particles(world, sid, n):
         surface_overlaps  = world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
                                                         position, structure_id, species.radius)
 
-        if (not particle_overlaps) and (not surface_overlaps):
+        out_of_bounds = ( any(position < bound_1) or any(position > bound_2) )
+
+        if (not particle_overlaps) and (not surface_overlaps) and (not out_of_bounds):
             # All checks passed. Create particle.
             p = world.new_particle(sid, structure_id, position)
             i += 1
@@ -377,6 +411,8 @@ def throw_in_particles(world, sid, n):
                 log.info('\t%d-th particle rejected. Too close to particle. I will keep trying.' % i)
             if surface_overlaps:
                 log.info('\t%d-th particle rejected. Too close to surface. I will keep trying.' % i)
+            if out_of_bounds:
+                log.info('\t%d-th particle rejected. Out of bounding box. I will keep trying.' % i)
 
 def place_particle(world, sid, position):
     """Place a particle of a certain Species at a specific position in 

From 2c0cdb085dd3f4b5ede2169a10c93b7640704e2c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 29 Aug 2012 16:28:50 +0200
Subject: [PATCH 1089/1541] Introduce a hard bound for the BD timestep for
 testing purposes

---
 Multi.hpp | 14 +++++++++-----
 egfrd.py  |  9 +++++++--
 multi.py  |  5 +++--
 3 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 0d767e0a..e8bad579 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -333,15 +333,17 @@ class MultiParticleContainer
         Real k_max(0.);
         int i = 0, j= 0;
         
-        // Rates for surface/structure interactions
+        // Rates for particle-surface interactions
         BOOST_FOREACH(particle_id_pair pp, get_particles_range())
         {
             // s = species of the current particle
             species_type const s( get_species(pp.second.sid()) );
             
+            // Get list of close structures with ids and distances from current particle's position           
             const boost::scoped_ptr<const structure_id_pair_and_distance_list>   close_struct_id_distance (
                 get_close_structures(pp.second.position(), pp.second.structure_id(), pp.second.structure_id()) );
-                
+
+            // Take the closest one and pass it as an id-and-distance pair
             const std::pair<boost::shared_ptr<structure_type>, length_type>   struct_and_dist (
                 close_struct_id_distance ? std::make_pair(close_struct_id_distance->at(0).first.second, close_struct_id_distance->at(0).second)
                                          : std::make_pair(get_structure(pp.second.structure_id()), std::numeric_limits<length_type>::max()));
@@ -350,7 +352,7 @@ class MultiParticleContainer
 //                get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
             
             // If structure is within specified range and this particle lives in the default structure
-            // TODO Extend the last requirement to all "allowed" interactions using the new structure functions
+            //    TODO Extend the last requirement to all "allowed" interactions using the new structure functions
             if( struct_and_dist.second < 2.0 * s.radius() && s.structure_type_id() == get_def_structure_type_id() )
             {
                 // Get the reaction rule for this particle-structure interaction
@@ -429,13 +431,13 @@ class MultiParticleContainer
        
        PROBLEM: for certain parameters (large k) dt can be very small and the simulation will slow down.
     */    
-    real_pair determine_dt_and_reaction_length(network_rules_type const& rules, Real const& step_size_factor) const
+    real_pair determine_dt_and_reaction_length(network_rules_type const& rules, Real const& step_size_factor, Real const& dt_hardcore_min = -1.0) const
     {               
         const real_pair maxD_minr( maxD_minsigma() );
         const Real k_max( get_max_rate(rules) );
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
-        const Real Pacc_max( 0.01 ); //Maximum allowed value of the acceptance probability.
+        const Real Pacc_max( 0.1 ); //Maximum allowed value of the acceptance probability. // TESTING was 0.01
         Real dt;
         const Real tau_D( 2. * gsl_pow_2(step_size_factor * r_min) / D_max );
         
@@ -446,6 +448,8 @@ class MultiParticleContainer
         }
         else
             dt = tau_D;
+        
+        if( dt < dt_hardcore_min )      dt = dt_hardcore_min;
 
         return real_pair(dt, step_size_factor * r_min);
     }
diff --git a/egfrd.py b/egfrd.py
index d8cc6114..7b3cc5fa 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -229,7 +229,12 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
                                                 # reaction volume sticks out of the multi. 
 
         self.BD_ONLY_FLAG = False               # Will force the algorithm into Multi-creation, i.e. always to use BD
-                                                # This is for testing only! Keep this 'False' for normal sims!
+                                                # Take care: This is for testing only! Keep this 'False' for normal sims!
+
+        self.BD_DT_HARDCORE_MIN = 1e-7          # This is to define a hardcore lower bound for the timestep that will be
+                                                # dynamically determined by the new BD scheme. It will prevent the algorithm
+                                                # to calculate ridiculously small timesteps, but will break detail balance.
+                                                # Take care: This is for testing only! Keep this at a negative value for normal sims!
 
         # used datastructrures
         self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
@@ -621,7 +626,7 @@ def create_multi(self):
         domain_id = self.domain_id_generator()
 
         # 2. Create and register domain object
-        multi = Multi(domain_id, self, self.DEFAULT_STEP_SIZE_FACTOR)
+        multi = Multi(domain_id, self, self.DEFAULT_STEP_SIZE_FACTOR, self.BD_DT_HARDCORE_MIN)
         self.domains[domain_id] = multi
 
         # 3. no shells are yet made, since these are added later
diff --git a/multi.py b/multi.py
index bcf24ef0..b4dad6d5 100644
--- a/multi.py
+++ b/multi.py
@@ -13,7 +13,7 @@
 import os
 
 class Multi(Domain, hasSphericalShell, Others):
-    def __init__(self, domain_id, main, step_size_factor):
+    def __init__(self, domain_id, main, step_size_factor, dt_hardcore_min = -1):
         Domain.__init__(self, domain_id)
         # note: hasSphericalShell.__init__ is not called and that the Multi has no self.testShell
         #       Only the methods of the hasSphericalShell class are used
@@ -26,6 +26,7 @@ def __init__(self, domain_id, main, step_size_factor):
         self.particle_container = _gfrd.MultiParticleContainer(main.world)
         self.escaped = False
         self.step_size_factor = step_size_factor
+        self.dt_hardcore_min = dt_hardcore_min
         self.last_reaction = None
         self.reaction_length = 0
 
@@ -74,7 +75,7 @@ def add_particle(self, pid_particle_pair):
     def set_dt_and_reaction_length(self):
         main = self.main()
         self.dt, self.reaction_length = \
-            self.particle_container.determine_dt_and_reaction_length(main.network_rules, self.step_size_factor)
+            self.particle_container.determine_dt_and_reaction_length(main.network_rules, self.step_size_factor, self.dt_hardcore_min)
 
     def step(self):
         self.escaped = False

From a38265df6ca5ccaa22cce8fb20f95d3bb4afd47b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 30 Aug 2012 19:55:24 +0200
Subject: [PATCH 1090/1541] Test-commit an improved version of the
 EDGE_HITS_EDGE cylinder scaling routine based on corrected math. domains for
 the rootfinder

---
 shells.py | 59 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 46 insertions(+), 13 deletions(-)

diff --git a/shells.py b/shells.py
index 0288b2dd..3557e033 100755
--- a/shells.py
+++ b/shells.py
@@ -1022,29 +1022,62 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             tan_scale_angle = math.tan(scale_angle)
 
             if scale_angle <= Pi/4.0:
-                #def h1(x):
-                    #print "value = %s" % str((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)) # TODO DEBUG output, remove when done
-                    #return x - scale_center_to_shell_z + \
-                           #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt((x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2 )
+                def h1_eq(x):
+                    
+                    print "testShell = "+str(testShell)
+                    print "scale_angle = %s" % scale_angle
+                    print "tan_scale_angle = %s" % tan_scale_angle
+                    print "r2 = %s" % (shell_radius)
+                    print "h2 = %s" % (shell_half_length)
+                    print "Dy = %s" % (scale_center_to_shell_y)
+                    print "Dx = %s" % (scale_center_to_shell_x)
+                    print "Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                    print "Dx-h2 = %s" % (scale_center_to_shell_x - shell_half_length)
+                    print "lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                    print "Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                    print "(Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
+
+                    print "h = %s, val = %s" % (x, (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) # TESTING
+                    print "outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
+
+                    print "r1 = %s" % (r1_function(x+scale_center_z))
+                                        
+                    return x - (scale_center_to_shell_z - \
+                           math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
+
+                if scale_center_to_shell_y > shell_radius :
+                    h1_interval_start = (1.0+TOLERANCE)*(z1_function( math.sqrt( (scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2 ) ) - scale_center_z) # h1_min
+                else:
+                    h1_interval_start = (1.0+TOLERANCE)*(scale_center_to_shell_x - shell_half_length)
+                
+                assert(h1_interval_start >= 0)
+                h1_interval_end   = scale_center_to_shell_z*(1.0-TOLERANCE)                
+
+                print "h1_interval_start = %s" % h1_interval_start
+                print "h1_interval_end = %s"   % h1_interval_end
 
-                #h_touch = scale_center_z + findroot(h1, h1_min, scale_center_to_shell_z*(1.0-TOLERANCE))
-                h_touch = ref_to_shell_z - shell_radius # TODO This is a crude fix to override the original version above and may be improved
+                h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
+                #h_touch = ref_to_shell_z - shell_radius # TODO This is a crude fix to override the original version above and may be improved
                 z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
             else:                
-                #def r1(x):
-                    #shell_radius_sq = shell_radius**2
-                    #return x/tan_scale_angle - scale_center_to_shell_z + \
-                           #math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2))**2)
+                def r1_eq(x):
+                    shell_radius_sq = shell_radius**2
+                    return x - tan_scale_angle * (scale_center_to_shell_z - \
+                           math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2) )
 
-                #r_touch = findroot(r1, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
+                r_touch = findroot(r1_eq, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
 
                 # Very crude alternative that does not involve a rootfinder; treat the static shell as a box:
                 #r_touch = math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2)
 
                 # Improved fix, but still suboptimal: basically the edge-hits-barrel solution
-                cot_scale_angle = math.tan(scale_angle - Pi/2.0)
-                r_touch = ref_to_shell_y - shell_radius * ( math.sqrt(2.0*cot_scale_angle)+ cot_scale_angle ) / (1.0 + cot_scale_angle**2.0)
+                #cot_scale_angle = math.tan(scale_angle - Pi/2.0)
+                #r_touch = ref_to_shell_y - shell_radius * ( math.sqrt(2.0*cot_scale_angle)+ cot_scale_angle ) / (1.0 + cot_scale_angle**2.0)
+
+                #if feq(scale_angle, Pi/2.0):
+                    #r_touch_x = ref_to_shell_x - shell_half_length
+                    #r_touch = max(r_touch, r_touch_x)
                           
                 r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))

From 75678035a05646ea7c3454a6ec12f33058fbe364 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 31 Aug 2012 17:15:40 +0200
Subject: [PATCH 1091/1541] Test-commit improved EDGE_HITS_EDGE rootfinding
 routine

- reformulated the equation to solve to get rid of the outer
square root
- introduced proper bounds for the rootfinder variable to
prevent math. domain errors and to make sure there is only one
solution in the given interval
---
 shells.py | 57 ++++++++++++++++++++++++++++---------------------------
 1 file changed, 29 insertions(+), 28 deletions(-)

diff --git a/shells.py b/shells.py
index 3557e033..8ecf7441 100755
--- a/shells.py
+++ b/shells.py
@@ -1023,38 +1023,39 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
             if scale_angle <= Pi/4.0:
                 def h1_eq(x):
-                    
-                    print "testShell = "+str(testShell)
-                    print "scale_angle = %s" % scale_angle
-                    print "tan_scale_angle = %s" % tan_scale_angle
-                    print "r2 = %s" % (shell_radius)
-                    print "h2 = %s" % (shell_half_length)
-                    print "Dy = %s" % (scale_center_to_shell_y)
-                    print "Dx = %s" % (scale_center_to_shell_x)
-                    print "Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                    print "Dx-h2 = %s" % (scale_center_to_shell_x - shell_half_length)
-                    print "lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                    print "Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                    print "(Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
-
-                    print "h = %s, val = %s" % (x, (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) # TESTING
-                    print "outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
-
-                    print "r1 = %s" % (r1_function(x+scale_center_z))
+
+                    #rhs = (scale_center_to_shell_z - \
+                           #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
+
+                    rhs2 = (scale_center_to_shell_z - x)**2 - shell_radius**2 +\
+                           (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2
+
+                    print "***** ROOTFINDER CALL with: *****"
+                    print "  h1 = %s, rhs2 = %s" % (x, rhs2 )
+                    print "  r1 = %s" % (r1_function(x+scale_center_z))
+                    print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                    print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                    print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
+                    print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
                                         
-                    return x - (scale_center_to_shell_z - \
-                           math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
+                    return rhs2
 
-                if scale_center_to_shell_y > shell_radius :
-                    h1_interval_start = (1.0+TOLERANCE)*(z1_function( math.sqrt( (scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2 ) ) - scale_center_z) # h1_min
-                else:
-                    h1_interval_start = (1.0+TOLERANCE)*(scale_center_to_shell_x - shell_half_length)
-                
+                h1_interval_start = (1.0001)*(z1_function(scale_center_to_shell_x - shell_half_length) - scale_center_z)                
+                h1_interval_end   = (0.9999)*(z1_function( math.sqrt( scale_center_to_shell_y**2 + (scale_center_to_shell_x-shell_half_length)**2 ) ) - scale_center_z)
                 assert(h1_interval_start >= 0)
-                h1_interval_end   = scale_center_to_shell_z*(1.0-TOLERANCE)                
 
-                print "h1_interval_start = %s" % h1_interval_start
-                print "h1_interval_end = %s"   % h1_interval_end
+                print "***** NEW ROOTFINDER ITERATION *****"
+                print "  testShell = "+str(testShell)
+                print "  scale_angle = %s" % scale_angle
+                print "  tan_scale_angle = %s" % tan_scale_angle
+                print "  r2 = %s" % (shell_radius)
+                print "  h2 = %s" % (shell_half_length)
+                print "  Dy = %s" % (scale_center_to_shell_y)
+                print "  Dx = %s" % (scale_center_to_shell_x)
+                print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                print "  Dx-h2 = %s" % (scale_center_to_shell_x - shell_half_length)
+                print "  h1_interval_start = %s" % h1_interval_start
+                print "  h1_interval_end = %s"   % h1_interval_end
 
                 h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                 #h_touch = ref_to_shell_z - shell_radius # TODO This is a crude fix to override the original version above and may be improved

From 8bee69d6b5c2e52fa41e84e1e3c04ffdb55f8f37 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 31 Aug 2012 17:20:53 +0200
Subject: [PATCH 1092/1541] Some cleanup

---
 shells.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index 8ecf7441..8ba14498 100755
--- a/shells.py
+++ b/shells.py
@@ -1027,22 +1027,23 @@ def h1_eq(x):
                     #rhs = (scale_center_to_shell_z - \
                            #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
 
-                    rhs2 = (scale_center_to_shell_z - x)**2 - shell_radius**2 +\
-                           (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2
+                    eq_value = (scale_center_to_shell_z - x)**2 - shell_radius**2 +\
+                               (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2
 
                     print "***** ROOTFINDER CALL with: *****"
-                    print "  h1 = %s, rhs2 = %s" % (x, rhs2 )
+                    print "  h1 = %s, value = %s" % (x, eq_value )
                     print "  r1 = %s" % (r1_function(x+scale_center_z))
                     print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
                     print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
                     print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
                     print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
                                         
-                    return rhs2
+                    return eq_value
 
-                h1_interval_start = (1.0001)*(z1_function(scale_center_to_shell_x - shell_half_length) - scale_center_z)                
-                h1_interval_end   = (0.9999)*(z1_function( math.sqrt( scale_center_to_shell_y**2 + (scale_center_to_shell_x-shell_half_length)**2 ) ) - scale_center_z)
+                h1_interval_start = (1+TOLERANCE)*(z1_function(scale_center_to_shell_x - shell_half_length) - scale_center_z)                
+                h1_interval_end   = (1-TOLERANCE)*(z1_function( math.sqrt( scale_center_to_shell_y**2 + (scale_center_to_shell_x-shell_half_length)**2 ) ) - scale_center_z)
                 assert(h1_interval_start >= 0)
+                assert(h1_interval_end   >= h1_interval_end)
 
                 print "***** NEW ROOTFINDER ITERATION *****"
                 print "  testShell = "+str(testShell)
@@ -1058,9 +1059,9 @@ def h1_eq(x):
                 print "  h1_interval_end = %s"   % h1_interval_end
 
                 h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
-                #h_touch = ref_to_shell_z - shell_radius # TODO This is a crude fix to override the original version above and may be improved
                 z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
+
             else:                
                 def r1_eq(x):
                     shell_radius_sq = shell_radius**2

From e52e861fe611c0e2530a61a949ae5866cc3d6daf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 31 Aug 2012 18:25:52 +0200
Subject: [PATCH 1093/1541] Also adapt the rootfinder routine for scale_angle >
 pi/4 (scaling the radius instead of the height)

---
 shells.py | 55 +++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 41 insertions(+), 14 deletions(-)

diff --git a/shells.py b/shells.py
index 8ba14498..8a1795d4 100755
--- a/shells.py
+++ b/shells.py
@@ -1020,6 +1020,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # TODO we have a solution but it can only be found with a root finder -> slow
             # FIXME THIS CAUSES SERIOUS ERRORS IN SOME SITUATIONS! FIND A SOLUTION WHICH DOES NOT EMPLOY THE ROOTFINDER!
             tan_scale_angle = math.tan(scale_angle)
+            shell_radius_sq = shell_radius**2
+            scale_center_to_shell_edge_x = scale_center_to_shell_x - shell_half_length
 
             if scale_angle <= Pi/4.0:
                 def h1_eq(x):
@@ -1027,21 +1029,21 @@ def h1_eq(x):
                     #rhs = (scale_center_to_shell_z - \
                            #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
 
-                    eq_value = (scale_center_to_shell_z - x)**2 - shell_radius**2 +\
-                               (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2
+                    eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
+                               (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2 ) )**2
 
                     print "***** ROOTFINDER CALL with: *****"
                     print "  h1 = %s, value = %s" % (x, eq_value )
                     print "  r1 = %s" % (r1_function(x+scale_center_z))
-                    print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                    print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                    print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
-                    print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
+                    #print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                    #print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                    #print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
+                    #print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
                                         
                     return eq_value
 
-                h1_interval_start = (1+TOLERANCE)*(z1_function(scale_center_to_shell_x - shell_half_length) - scale_center_z)                
-                h1_interval_end   = (1-TOLERANCE)*(z1_function( math.sqrt( scale_center_to_shell_y**2 + (scale_center_to_shell_x-shell_half_length)**2 ) ) - scale_center_z)
+                h1_interval_start = (1+TOLERANCE)*(z1_function(scale_center_to_shell_edge_x) - scale_center_z)
+                h1_interval_end   = (1-TOLERANCE)*(z1_function( math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 ) ) - scale_center_z)
                 assert(h1_interval_start >= 0)
                 assert(h1_interval_end   >= h1_interval_end)
 
@@ -1054,7 +1056,7 @@ def h1_eq(x):
                 print "  Dy = %s" % (scale_center_to_shell_y)
                 print "  Dx = %s" % (scale_center_to_shell_x)
                 print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                print "  Dx-h2 = %s" % (scale_center_to_shell_x - shell_half_length)
+                print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
                 print "  h1_interval_start = %s" % h1_interval_start
                 print "  h1_interval_end = %s"   % h1_interval_end
 
@@ -1062,13 +1064,38 @@ def h1_eq(x):
                 z1_new = min(z1, h_touch)
                 r_new  = min(r,  r1_function(z1_new))
 
-            else:                
+            else:
+                # This uses the same rootfinding equation and interval as above with r1=h1/tan_scale_angle
+                # instead of h1; notice that scale_angle > 0 here, so we can divide by it
                 def r1_eq(x):
-                    shell_radius_sq = shell_radius**2
-                    return x - tan_scale_angle * (scale_center_to_shell_z - \
-                           math.sqrt(shell_radius_sq - (scale_center_to_shell_y - math.sqrt(x**2 - (scale_center_to_shell_x - shell_half_length)**2) )**2) )
+                    eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
+                               (scale_center_to_shell_y - math.sqrt( x**2 - scale_center_to_shell_edge_x**2 ) )**2
+
+                    print "***** ROOTFINDER CALL with: *****"
+                    print "  r1 = %s, value = %s" % (x, eq_value )
+                    print "  h1 = %s" % (z1_function(x))
+
+                    return eq_value
+
+                r1_interval_start = (1+TOLERANCE)*scale_center_to_shell_edge_x
+                r1_interval_end   = (1-TOLERANCE)*math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
+                assert(r1_interval_start >= 0)
+                assert(r1_interval_end   >= r1_interval_start)
+
+                print "***** NEW ROOTFINDER ITERATION *****"
+                print "  testShell = "+str(testShell)
+                print "  scale_angle = %s" % scale_angle
+                print "  tan_scale_angle = %s" % tan_scale_angle
+                print "  r2 = %s" % (shell_radius)
+                print "  h2 = %s" % (shell_half_length)
+                print "  Dy = %s" % (scale_center_to_shell_y)
+                print "  Dx = %s" % (scale_center_to_shell_x)
+                print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
+                print "  r1_interval_start = %s" % r1_interval_start
+                print "  r1_interval_end = %s"   % r1_interval_end
 
-                r_touch = findroot(r1_eq, r1_min, math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y)**2)*(1.0-TOLERANCE))
+                r_touch = findroot(r1_eq, r1_interval_start, r1_interval_end)
 
                 # Very crude alternative that does not involve a rootfinder; treat the static shell as a box:
                 #r_touch = math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2)

From 06af4d5c3bbc86f19c5594f3b3440cf09a1801f0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 3 Sep 2012 14:07:34 +0200
Subject: [PATCH 1094/1541] Remove tolerance application for the
 radius-rootfinder case

Because it causes more problems than it solves.
---
 shells.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index 8a1795d4..3beb7f20 100755
--- a/shells.py
+++ b/shells.py
@@ -1032,7 +1032,7 @@ def h1_eq(x):
                     eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
                                (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2 ) )**2
 
-                    print "***** ROOTFINDER CALL with: *****"
+                    print "***** ROOTFINDER CALL: Calling h1_eq() with: *****"
                     print "  h1 = %s, value = %s" % (x, eq_value )
                     print "  r1 = %s" % (r1_function(x+scale_center_z))
                     #print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
@@ -1059,6 +1059,8 @@ def h1_eq(x):
                 print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
                 print "  h1_interval_start = %s" % h1_interval_start
                 print "  h1_interval_end = %s"   % h1_interval_end
+                print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
+                print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
 
                 h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                 z1_new = min(z1, h_touch)
@@ -1071,14 +1073,14 @@ def r1_eq(x):
                     eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
                                (scale_center_to_shell_y - math.sqrt( x**2 - scale_center_to_shell_edge_x**2 ) )**2
 
-                    print "***** ROOTFINDER CALL with: *****"
+                    print "***** ROOTFINDER CALL: Calling r1_eq() with: *****"
                     print "  r1 = %s, value = %s" % (x, eq_value )
                     print "  h1 = %s" % (z1_function(x))
 
                     return eq_value
 
-                r1_interval_start = (1+TOLERANCE)*scale_center_to_shell_edge_x
-                r1_interval_end   = (1-TOLERANCE)*math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
+                r1_interval_start = scale_center_to_shell_edge_x
+                r1_interval_end   = math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
                 assert(r1_interval_start >= 0)
                 assert(r1_interval_end   >= r1_interval_start)
 
@@ -1094,6 +1096,8 @@ def r1_eq(x):
                 print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
                 print "  r1_interval_start = %s" % r1_interval_start
                 print "  r1_interval_end = %s"   % r1_interval_end
+                print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
+                print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
 
                 r_touch = findroot(r1_eq, r1_interval_start, r1_interval_end)
 

From 4b2ff689ac8acaa060c7cf945a2d8737f0384f43 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 5 Sep 2012 14:15:34 +0200
Subject: [PATCH 1095/1541] Some useful comments in Multi.hpp

---
 Multi.hpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Multi.hpp b/Multi.hpp
index e8bad579..c2e379e4 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -437,12 +437,17 @@ class MultiParticleContainer
         const Real k_max( get_max_rate(rules) );
         const Real D_max( maxD_minr.first );
         const Real r_min( maxD_minr.second );
-        const Real Pacc_max( 0.1 ); //Maximum allowed value of the acceptance probability. // TESTING was 0.01
+        const Real Pacc_max( 0.1 ); // Maximum allowed value of the acceptance probability. // TESTING was 0.01
+                                    // This should be kept very low (max. 0.01), otherwise the approximation of
+                                    // treating the reaction as two sequential attempts fails
         Real dt;
         const Real tau_D( 2. * gsl_pow_2(step_size_factor * r_min) / D_max );
         
         if( k_max > 0)
         {
+            // step_size_factor * r_min is the reaction length
+            // Here it is assumed that the RL is linear in any dimension,
+            // which requires it to be very small!
             Real dt_temp( 2. * Pacc_max * step_size_factor * r_min / k_max );
             dt = std::min( dt_temp, tau_D ); // tau_D is upper limit of dt.
         }

From 8cfc63f3f04c760616e06ac6b980bf43d848b9a9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 5 Sep 2012 14:16:01 +0200
Subject: [PATCH 1096/1541] Better detection of cylinder collision in the
 "Quadrant 1" situation

---
 shells.py | 81 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 64 insertions(+), 17 deletions(-)

diff --git a/shells.py b/shells.py
index 3beb7f20..6b10a47f 100755
--- a/shells.py
+++ b/shells.py
@@ -849,6 +849,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # shell hits the scaling cylinder on top
             z1_new = min(z1, (ref_to_shell_z - shell_half_length))
             r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
+            print "PARALLEL CYLINDERS: Called r1_function with r=%s, z1=%s, z1_new=%s, to_edge_angle=%s, scale_angle=%s, ref_to_shell_z=%s, shell_half_length=%s" %\
+                                                              (r, z1, z1_new, to_edge_angle, scale_angle, ref_to_shell_z, shell_half_length) # TESTING
         else:
             # shell hits the scaling cylinder on the radial side
             r_new = min(r, (ref_to_shell_r - shell_radius))
@@ -884,6 +886,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         ref_to_shell_z = numpy.dot(ref_to_shell_vec, local_z)
         assert (ref_to_shell_x >= 0.0) and (ref_to_shell_y >= 0.0) and (ref_to_shell_z >= 0.0)  # by the definition of the local coordinate system
         # Also calculate the coordinates of the scale center
+        # FIXME Attention: The scale center is not always on the z-axis!
         scale_center_to_shell_x = ref_to_shell_x
         scale_center_to_shell_y = ref_to_shell_y
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
@@ -898,20 +901,42 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         # of the scaled cylinder:
         BARREL_HITS_FLAT, EDGE_HITS_EDGE, BARREL_HITS_EDGE, FLAT_HITS_BARREL, EDGE_HITS_BARREL, BARREL_HITS_BARREL = range(6)
 
+        # Define some constants
+        tan_scale_angle = math.tan(scale_angle)
+
         #### (1) Now first determine which type of collision happens:
 
         if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
-            # quadrant 1
-#            print "quadrant 1"
-            situation = FLAT_HITS_BARREL
+            # Quadrant 1
+            print "Quadrant 1"
+            # Scale cylinder one until its height is equal to the z-distance minus the radius of the cyl. shell 2;
+            # Then check whether any point of the axis of cyl. 2 projected on the top side of cyl. 1 is inside the radius of (scaled) cyl. 1.
+            # If this is the case, we have the flat side of cyl. 1 hitting the barrel of cyl. 2. Else we have the edge hitting the barrel.
+            r1_touch = (scale_center_to_shell_z - shell_radius)*tan_scale_angle
+
+            # TODO Probably not needed any more, remove!
+            dist_to_projected_edge_1 = math.sqrt(scale_center_to_shell_y**2 + (shell_half_length + scale_center_to_shell_y)**2)
+            dist_to_projected_edge_2 = math.sqrt(scale_center_to_shell_y**2 + (shell_half_length - scale_center_to_shell_y)**2)
+
+            print "r1_touch=%s, scale_angle=%s, shell_radius=%s, shell_half_length=%s" % (r1_touch, scale_angle, shell_radius, shell_half_length)
+            print "s_x=%s, s_y=%s, d_1=%s, d_2=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, dist_to_projected_edge_1, dist_to_projected_edge_2)
+
+            if r1_touch >= scale_center_to_shell_y:
+                # At least a part of the projected axis is within r_touch => flat side of scaled cyl. hits the barrel of cyl. 2
+                # Note that we know that at least a part of the shell is above the top side of the scaled cylinder (quadrant 1 condition)
+                print "-> FLAT_HITS_BARREL"
+                situation = FLAT_HITS_BARREL
+            else:
+                print "-> EDGE_HITS_BARREL"
+                situation = EDGE_HITS_BARREL
 
         elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
-            # quadrant 2
-#            print "quadrant 2"
-            scale_center_to_shell_x -= scale_center_r
-            scale_center_to_flatend_x = scale_center_to_shell_x - shell_half_length
+            # Quadrant 2
+            print "Quadrant 2"
+            scale_center_to_shell_x    -= scale_center_r
+            scale_center_to_flatend_x   = scale_center_to_shell_x - shell_half_length
             scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
-            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+            scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
 
             # angle1
             if scale_center_to_critpoint_z == 0:
@@ -941,8 +966,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 h1_min = r1_min/math.tan(scale_angle)
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
-            # quadrant 3
-#            print "quadrant 3"
+            # Quadrant 3
+            print "Quadrant 3"
             scale_center_to_shell_y -= scale_center_r
             scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
             scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
@@ -973,8 +998,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 situation = EDGE_HITS_BARREL
 
         else:
-            # quadrant 4
-#            print "quadrant 4"
+            # Quadrant 4
+            print "Quadrant 4"
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
 
             scale_center_to_critpoint_r = math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r
@@ -1019,7 +1044,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # the scaling cylinder hits the edge of 'shell' with its edge
             # TODO we have a solution but it can only be found with a root finder -> slow
             # FIXME THIS CAUSES SERIOUS ERRORS IN SOME SITUATIONS! FIND A SOLUTION WHICH DOES NOT EMPLOY THE ROOTFINDER!
-            tan_scale_angle = math.tan(scale_angle)
             shell_radius_sq = shell_radius**2
             scale_center_to_shell_edge_x = scale_center_to_shell_x - shell_half_length
 
@@ -1124,6 +1148,10 @@ def r1_eq(x):
             # the scaling cylinder hits the barrel of 'shell' with its top flat side
             z1_new = min(z1, (ref_to_shell_z - shell_radius))
             r_new  = min(r,  r1_function(z1_new))
+            print "SITUATION FLAT_HITS_BARREL: Called r1_function with r=%s, z1=%s, z1_new=%s, scale_angle=%s, ref_to_shell_z=%s, shell_radius=%s" %\
+                                                                      (r, z1, z1_new, scale_angle, ref_to_shell_z, shell_radius) # TESTING
+            print "SITUATION FLAT_HITS_BARREL: ref_to_shell_x=%s, ref_to_shell_y=%s, shell_half_length=%s" %\
+                                                                      (ref_to_shell_x, ref_to_shell_y, shell_half_length) # TESTING
 
         elif situation == EDGE_HITS_BARREL:
             # the scaling cylinder hits the barrel of 'shell' with its edge
@@ -1132,18 +1160,29 @@ def r1_eq(x):
             ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_y**2)
             scale_center_to_shell = math.sqrt(ss_sq)
 
-            shell_angle_x = math.atan(scale_center_to_shell_y/scale_center_to_shell_z)
-            angle_diff = shell_angle_x - scale_angle
+            print "ss = %s, s_z=%s, s_y=%s, shell_radius=%s" % (scale_center_to_shell, scale_center_to_shell_z, scale_center_to_shell_y, shell_radius)  # TESTING
+
+            shell_angle_yz = math.atan(scale_center_to_shell_y/scale_center_to_shell_z)
+            angle_diff = abs(shell_angle_yz - scale_angle)
+            print "angle_diff = %s, shell_angle_yz=%s" % (angle_diff, shell_angle_yz)  # TESTING
             sin_angle_diff = math.sin(angle_diff)
             cos_angle_diff = math.cos(angle_diff)
 
-            scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
-                                       math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
+            # TODO TESTING Laurens' version
+            #scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
+                                       #math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
+            assert scale_center_to_shell >= shell_radius
+            print "asin-value=%s" % str(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
+            ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
+            scale_center_shell_dist = shell_radius * math.cos(angle_diff+ss_angle) / math.sin(angle_diff)
+            assert scale_center_shell_dist>0 # TESTING
 
             if scale_angle <= Pi/4.0:
                 cos_scale_angle = math.cos(scale_angle)
                 z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist))
                 r_new  = min(r, r1_function(z1_new))
+                print "SITUATION EDGE_HITS_BARREL: Called r1_function with r=%s, z1=%s, z1_new=%s, scale_angle=%s, scale_center_z=%s, scale_center_shell_dist=%s" %\
+                                                                          (r, z1, z1_new, scale_angle, scale_center_z, scale_center_shell_dist) # TESTING
             else:
                 sin_scale_angle = math.sin(scale_angle)
                 r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist))
@@ -1171,6 +1210,8 @@ def r1_eq(x):
         z_right = z2_new
         z_left  = z1_new
 
+    assert r > 0 and z_left > 0 and z_right > 0
+
     return r, z_right, z_left
 
 def get_radius_to_CylindricalShape(shape, testShell, r):
@@ -1494,6 +1535,12 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # initialize the parameters to start the scaling of the cylinder
         min_dr, min_dz_right, min_dz_left = self.apply_safety(min_dr, min_dz_right, min_dz_left)
         dr, dz_right, dz_left             = max_dr, max_dz_right, max_dz_left
+
+        ## TESTING
+        #assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
+               #'CylindricaltestShell dimensions smaller than the minimum, \
+                #dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
+               #(dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left)
  
         # first check the maximum dr, dz_right, dz_left against the surfaces
         # NOTE: we assume that all relevant surfaces are cylindrical and parallel to the testCylinder

From 0effd00e622583e43438bc6e7482b4f460c7be7d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 5 Sep 2012 19:22:54 +0200
Subject: [PATCH 1097/1541] Fix an erroneous angle calculation

---
 shells.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 6b10a47f..170c515a 100755
--- a/shells.py
+++ b/shells.py
@@ -1128,7 +1128,7 @@ def r1_eq(x):
                 # Very crude alternative that does not involve a rootfinder; treat the static shell as a box:
                 #r_touch = math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2)
 
-                # Improved fix, but still suboptimal: basically the edge-hits-barrel solution
+                # Improved fix, but still suboptimal: basically the edge-coshits-barrel solution
                 #cot_scale_angle = math.tan(scale_angle - Pi/2.0)
                 #r_touch = ref_to_shell_y - shell_radius * ( math.sqrt(2.0*cot_scale_angle)+ cot_scale_angle ) / (1.0 + cot_scale_angle**2.0)
 
@@ -1174,7 +1174,7 @@ def r1_eq(x):
             assert scale_center_to_shell >= shell_radius
             print "asin-value=%s" % str(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
             ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
-            scale_center_shell_dist = shell_radius * math.cos(angle_diff+ss_angle) / math.sin(angle_diff)
+            scale_center_shell_dist = shell_radius * math.sin(math.pi-(angle_diff+ss_angle)) / math.sin(angle_diff)
             assert scale_center_shell_dist>0 # TESTING
 
             if scale_angle <= Pi/4.0:

From 67f7bf2980b564ee7d97991d4ec427d401908b48 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Sep 2012 16:46:06 +0200
Subject: [PATCH 1098/1541] Output BD diffusion steps in final statistics

---
 egfrd.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7b3cc5fa..c28b2e13 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -231,7 +231,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.BD_ONLY_FLAG = False               # Will force the algorithm into Multi-creation, i.e. always to use BD
                                                 # Take care: This is for testing only! Keep this 'False' for normal sims!
 
-        self.BD_DT_HARDCORE_MIN = 1e-7          # This is to define a hardcore lower bound for the timestep that will be
+        self.BD_DT_HARDCORE_MIN = -1e-9         # This is to define a hardcore lower bound for the timestep that will be
                                                 # dynamically determined by the new BD scheme. It will prevent the algorithm
                                                 # to calculate ridiculously small timesteps, but will break detail balance.
                                                 # Take care: This is for testing only! Keep this at a negative value for normal sims!
@@ -2581,8 +2581,8 @@ def print_report(self, out=None):
 steps = %d 
 \tSingle:\t%d\t(%.2f %%)\t(escape: %d, reaction: %d, bursted: %d)
 \tInteraction: %d\t(%.2f %%)\t(escape: %d, interaction: %d, bursted: %d)
-\tPair:\t%d\t(%.2f %%)\t(escape r: %d, R: %d, reaction pair: %d, single: %d, bursted: %d)
-\tMulti:\t%d\t(%.2f %%)\t(escape: %d, reaction pair: %d, single: %d, bursted: %d)
+\tPair:\t%d\t(%.2f %%)\t(r-escape: %d, R-escape: %d, reaction pair: %d, single: %d, bursted: %d)
+\tMulti:\t%d\t(%.2f %%)\t(diffusion: %d, escape: %d, reaction pair: %d, single: %d, bursted: %d)
 total reactions = %d
 rejected moves = %d
 ''' \
@@ -2606,6 +2606,7 @@ def print_report(self, out=None):
                self.pair_steps[EventType.BURST],
                multi_steps,
                (100.0*multi_steps) / total_steps,
+               self.multi_steps[EventType.MULTI_DIFFUSION],
                self.multi_steps[EventType.MULTI_ESCAPE],
                self.multi_steps[EventType.MULTI_BIMOLECULAR_REACTION],
                self.multi_steps[EventType.MULTI_UNIMOLECULAR_REACTION],

From 82becbae559431468f0bdbd689df895938fb5f1d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Sep 2012 16:46:42 +0200
Subject: [PATCH 1099/1541] Treat the special case of scale_angle=0 in
 EDGE_HITS_EDGE cylinder collision

... and add some useful namestrings to the "situations".
---
 shells.py | 187 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 108 insertions(+), 79 deletions(-)

diff --git a/shells.py b/shells.py
index 170c515a..d7e5755d 100755
--- a/shells.py
+++ b/shells.py
@@ -849,8 +849,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # shell hits the scaling cylinder on top
             z1_new = min(z1, (ref_to_shell_z - shell_half_length))
             r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
-            print "PARALLEL CYLINDERS: Called r1_function with r=%s, z1=%s, z1_new=%s, to_edge_angle=%s, scale_angle=%s, ref_to_shell_z=%s, shell_half_length=%s" %\
-                                                              (r, z1, z1_new, to_edge_angle, scale_angle, ref_to_shell_z, shell_half_length) # TESTING
         else:
             # shell hits the scaling cylinder on the radial side
             r_new = min(r, (ref_to_shell_r - shell_radius))
@@ -900,6 +898,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         # which has to be treated in different ways; the following collision specifiers are from the point of view
         # of the scaled cylinder:
         BARREL_HITS_FLAT, EDGE_HITS_EDGE, BARREL_HITS_EDGE, FLAT_HITS_BARREL, EDGE_HITS_BARREL, BARREL_HITS_BARREL = range(6)
+        situation_string = ["BARREL_HITS_FLAT", "EDGE_HITS_EDGE", "BARREL_HITS_EDGE", "FLAT_HITS_BARREL", "EDGE_HITS_BARREL", "BARREL_HITS_BARREL"]
 
         # Define some constants
         tan_scale_angle = math.tan(scale_angle)
@@ -918,16 +917,11 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             dist_to_projected_edge_1 = math.sqrt(scale_center_to_shell_y**2 + (shell_half_length + scale_center_to_shell_y)**2)
             dist_to_projected_edge_2 = math.sqrt(scale_center_to_shell_y**2 + (shell_half_length - scale_center_to_shell_y)**2)
 
-            print "r1_touch=%s, scale_angle=%s, shell_radius=%s, shell_half_length=%s" % (r1_touch, scale_angle, shell_radius, shell_half_length)
-            print "s_x=%s, s_y=%s, d_1=%s, d_2=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, dist_to_projected_edge_1, dist_to_projected_edge_2)
-
             if r1_touch >= scale_center_to_shell_y:
                 # At least a part of the projected axis is within r_touch => flat side of scaled cyl. hits the barrel of cyl. 2
                 # Note that we know that at least a part of the shell is above the top side of the scaled cylinder (quadrant 1 condition)
-                print "-> FLAT_HITS_BARREL"
                 situation = FLAT_HITS_BARREL
             else:
-                print "-> EDGE_HITS_BARREL"
                 situation = EDGE_HITS_BARREL
 
         elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
@@ -1000,20 +994,30 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         else:
             # Quadrant 4
             print "Quadrant 4"
+            print "shell_radius=%s, shell_half_length=%s, r=%s, scale_center_r=%s" % (shell_radius, shell_half_length, r, scale_center_r)
+            print "scale_angle=%s, scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_angle, scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
+
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
 
-            scale_center_to_critpoint_r = math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r
-            scale_center_to_lowpoint_r = math.sqrt(scale_center_to_shell_y**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r
-            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+            # Two points on the edge of the static cylinder are of interest here:
+            # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy plane
+            # - the "critpoint" (critical point), which is the point on the edge with the minimal y-distance to
+            #   the scale center in the zy-plane
+            scale_center_to_critpoint_r = math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r    # a_r
+            scale_center_to_lowpoint_r = math.sqrt(scale_center_to_shell_y**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r                      # b_r
+            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius                                                                                         # b_z
 
-            # angle1
+            # Calculate the angle between the z-axis of the scaled cylinder and the line that
+            # connects this axis with the "critpoint" on the static cylinder's edge
             if scale_center_to_shell_z == 0.0:
                 scale_center_to_shell_crit_angle_xy = Pi/2.0
             else:
                 scale_center_to_shell_crit_angle_xy = math.atan(scale_center_to_critpoint_r / scale_center_to_shell_z)
                 if scale_center_to_shell_z < 0.0:
                     scale_center_to_shell_crit_angle_xy += Pi
-            # angle2
+
+            # Calculate the angle between the z-axis of the scaled cylinder and the line that
+            # connects this axis with the "lowpoint" on the static cylinder's edge
             if scale_center_to_lowpoint_z == 0.0:
                 scale_center_to_shell_low_angle_xy = Pi/2.0
             else:
@@ -1021,20 +1025,33 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 if scale_center_to_lowpoint_z < 0.0:
                     scale_center_to_shell_low_angle_xy += Pi
 
+            print "scale_center_to_shell_crit_angle_xy=%s, scale_center_to_shell_low_angle_xy=%s, scale_center_to_critpoint_r=%s, scale_center_to_lowpoint_r=%s, scale_center_to_lowpoint_z=%s" \
+                 % (scale_center_to_shell_crit_angle_xy, scale_center_to_shell_low_angle_xy, scale_center_to_critpoint_r, scale_center_to_lowpoint_r, scale_center_to_lowpoint_z)
 
-            if scale_angle <= scale_center_to_shell_crit_angle_xy:
-                situation = BARREL_HITS_EDGE
-            elif scale_center_to_shell_low_angle_xy <= scale_angle:
-                situation = FLAT_HITS_BARREL
-            else:
-                assert scale_center_to_shell_crit_angle_xy < scale_angle and \
-                       scale_angle < scale_center_to_shell_low_angle_xy
+            # First treat the special case: when the scale center is further away from the z-axis than the "critpoint" (in the xy-plane)
+            if scale_center_to_critpoint_r <= 0.0:
                 situation = EDGE_HITS_EDGE
-                r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
-                h1_min = r1_min/math.tan(scale_angle)
+
+                if scale_center_to_lowpoint_r <= 0.0:
+                    situation = FLAT_HITS_BARREL
+
+            # Now the standard case:
+            else:
+
+                if scale_angle <= scale_center_to_shell_crit_angle_xy:
+                    situation = BARREL_HITS_EDGE
+
+                elif scale_center_to_shell_low_angle_xy <= scale_angle:
+                    situation = FLAT_HITS_BARREL
+
+                else:
+                    assert scale_center_to_shell_crit_angle_xy < scale_angle and scale_angle < scale_center_to_shell_low_angle_xy and scale_angle > 0.0
+                    situation = EDGE_HITS_EDGE
+                    r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
+                    h1_min = r1_min/math.tan(scale_angle)
 
         ##### (2) Treat the situation accordingly
-        #print "situation= ", situation
+        print "Situation= ", situation_string[situation]
         if situation == BARREL_HITS_FLAT:
             # the scaling cylinder hits the flat side of 'shell' with its barrel side
             r_new = min(r, (ref_to_shell_x - shell_half_length))
@@ -1043,11 +1060,36 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         elif situation == EDGE_HITS_EDGE:             
             # the scaling cylinder hits the edge of 'shell' with its edge
             # TODO we have a solution but it can only be found with a root finder -> slow
-            # FIXME THIS CAUSES SERIOUS ERRORS IN SOME SITUATIONS! FIND A SOLUTION WHICH DOES NOT EMPLOY THE ROOTFINDER!
             shell_radius_sq = shell_radius**2
             scale_center_to_shell_edge_x = scale_center_to_shell_x - shell_half_length
+            scale_center_to_shell_edge_y = scale_center_to_shell_y - shell_radius
+            scale_center_to_shell_edge_z = scale_center_to_shell_z - shell_radius
+            print "scale_center_to_shell_edge_x=%s" % str(scale_center_to_shell_edge_x)
+
+            if scale_angle == 0.0:
+
+                # scale_angle = 0 means that the radius r will stay constant at scaling
+                # Therefore, if the projected edge of the static shell lies outside of the 
+                # circle defined by r there will be no collision:
+                if r < math.sqrt(scale_center_to_shell_edge_x**2 + scale_center_to_shell_edge_y**2) :
+
+                    # The height and radius of the scaled cylinder remain unaltered
+                    z1_new = z1
+                    r1_new = r
+
+                else:
+                # There is a collision possible when z1 is scaled
+                    
+                    y1_collide = math.sqrt(r**2 - scale_center_to_shell_edge_x**2)
+                    y2_collide = scale_center_to_shell_y - y1_collide
+                    h_collide = math.sqrt(shell_radius**2 - y2_collide**2)
+
+                    h_touch = scale_center_to_shell_z - h_collide
+                    z1_new = min(z1, h_touch)
+                    r_new  = min(r,  r1_function(z1_new))
+
+            elif scale_angle <= Pi/4.0:
 
-            if scale_angle <= Pi/4.0:
                 def h1_eq(x):
 
                     #rhs = (scale_center_to_shell_z - \
@@ -1056,9 +1098,10 @@ def h1_eq(x):
                     eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
                                (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2 ) )**2
 
-                    print "***** ROOTFINDER CALL: Calling h1_eq() with: *****"
-                    print "  h1 = %s, value = %s" % (x, eq_value )
-                    print "  r1 = %s" % (r1_function(x+scale_center_z))
+                    # TODO TESTING REMOVE THIS WHEN DONE
+                    #print "***** ROOTFINDER CALL: Calling h1_eq() with: *****"
+                    #print "  h1 = %s, value = %s" % (x, eq_value )
+                    #print "  r1 = %s" % (r1_function(x+scale_center_z))
                     #print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
                     #print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
                     #print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
@@ -1068,23 +1111,25 @@ def h1_eq(x):
 
                 h1_interval_start = (1+TOLERANCE)*(z1_function(scale_center_to_shell_edge_x) - scale_center_z)
                 h1_interval_end   = (1-TOLERANCE)*(z1_function( math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 ) ) - scale_center_z)
+
                 assert(h1_interval_start >= 0)
                 assert(h1_interval_end   >= h1_interval_end)
 
-                print "***** NEW ROOTFINDER ITERATION *****"
-                print "  testShell = "+str(testShell)
-                print "  scale_angle = %s" % scale_angle
-                print "  tan_scale_angle = %s" % tan_scale_angle
-                print "  r2 = %s" % (shell_radius)
-                print "  h2 = %s" % (shell_half_length)
-                print "  Dy = %s" % (scale_center_to_shell_y)
-                print "  Dx = %s" % (scale_center_to_shell_x)
-                print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                print "  h1_interval_start = %s" % h1_interval_start
-                print "  h1_interval_end = %s"   % h1_interval_end
-                print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
-                print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
+                # TODO TESTING REMOVE THIS WHEN DONE
+                #print "***** NEW ROOTFINDER ITERATION *****"
+                #print "  testShell = "+str(testShell)
+                #print "  scale_angle = %s" % scale_angle
+                #print "  tan_scale_angle = %s" % tan_scale_angle
+                #print "  r2 = %s" % (shell_radius)
+                #print "  h2 = %s" % (shell_half_length)
+                #print "  Dy = %s" % (scale_center_to_shell_y)
+                #print "  Dx = %s" % (scale_center_to_shell_x)
+                #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
+                #print "  h1_interval_start = %s" % h1_interval_start
+                #print "  h1_interval_end = %s"   % h1_interval_end
+                #print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
+                #print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
 
                 h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                 z1_new = min(z1, h_touch)
@@ -1097,9 +1142,10 @@ def r1_eq(x):
                     eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
                                (scale_center_to_shell_y - math.sqrt( x**2 - scale_center_to_shell_edge_x**2 ) )**2
 
-                    print "***** ROOTFINDER CALL: Calling r1_eq() with: *****"
-                    print "  r1 = %s, value = %s" % (x, eq_value )
-                    print "  h1 = %s" % (z1_function(x))
+                    # TODO TESTING REMOVE THIS WHEN DONE
+                    #print "***** ROOTFINDER CALL: Calling r1_eq() with: *****"
+                    #print "  r1 = %s, value = %s" % (x, eq_value )
+                    #print "  h1 = %s" % (z1_function(x))
 
                     return eq_value
 
@@ -1108,33 +1154,23 @@ def r1_eq(x):
                 assert(r1_interval_start >= 0)
                 assert(r1_interval_end   >= r1_interval_start)
 
-                print "***** NEW ROOTFINDER ITERATION *****"
-                print "  testShell = "+str(testShell)
-                print "  scale_angle = %s" % scale_angle
-                print "  tan_scale_angle = %s" % tan_scale_angle
-                print "  r2 = %s" % (shell_radius)
-                print "  h2 = %s" % (shell_half_length)
-                print "  Dy = %s" % (scale_center_to_shell_y)
-                print "  Dx = %s" % (scale_center_to_shell_x)
-                print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                print "  r1_interval_start = %s" % r1_interval_start
-                print "  r1_interval_end = %s"   % r1_interval_end
-                print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
-                print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
+                # TODO TESTING REMOVE THIS WHEN DONE
+                #print "***** NEW ROOTFINDER ITERATION *****"
+                #print "  testShell = "+str(testShell)
+                #print "  scale_angle = %s" % scale_angle
+                #print "  tan_scale_angle = %s" % tan_scale_angle
+                #print "  r2 = %s" % (shell_radius)
+                #print "  h2 = %s" % (shell_half_length)
+                #print "  Dy = %s" % (scale_center_to_shell_y)
+                #print "  Dx = %s" % (scale_center_to_shell_x)
+                #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
+                #print "  r1_interval_start = %s" % r1_interval_start
+                #print "  r1_interval_end = %s"   % r1_interval_end
+                #print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
+                #print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
 
                 r_touch = findroot(r1_eq, r1_interval_start, r1_interval_end)
-
-                # Very crude alternative that does not involve a rootfinder; treat the static shell as a box:
-                #r_touch = math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2)
-
-                # Improved fix, but still suboptimal: basically the edge-coshits-barrel solution
-                #cot_scale_angle = math.tan(scale_angle - Pi/2.0)
-                #r_touch = ref_to_shell_y - shell_radius * ( math.sqrt(2.0*cot_scale_angle)+ cot_scale_angle ) / (1.0 + cot_scale_angle**2.0)
-
-                #if feq(scale_angle, Pi/2.0):
-                    #r_touch_x = ref_to_shell_x - shell_half_length
-                    #r_touch = max(r_touch, r_touch_x)
                           
                 r_new  = min(r, r_touch)
                 z1_new = min(z1, z1_function(r_new))
@@ -1148,10 +1184,6 @@ def r1_eq(x):
             # the scaling cylinder hits the barrel of 'shell' with its top flat side
             z1_new = min(z1, (ref_to_shell_z - shell_radius))
             r_new  = min(r,  r1_function(z1_new))
-            print "SITUATION FLAT_HITS_BARREL: Called r1_function with r=%s, z1=%s, z1_new=%s, scale_angle=%s, ref_to_shell_z=%s, shell_radius=%s" %\
-                                                                      (r, z1, z1_new, scale_angle, ref_to_shell_z, shell_radius) # TESTING
-            print "SITUATION FLAT_HITS_BARREL: ref_to_shell_x=%s, ref_to_shell_y=%s, shell_half_length=%s" %\
-                                                                      (ref_to_shell_x, ref_to_shell_y, shell_half_length) # TESTING
 
         elif situation == EDGE_HITS_BARREL:
             # the scaling cylinder hits the barrel of 'shell' with its edge
@@ -1160,11 +1192,8 @@ def r1_eq(x):
             ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_y**2)
             scale_center_to_shell = math.sqrt(ss_sq)
 
-            print "ss = %s, s_z=%s, s_y=%s, shell_radius=%s" % (scale_center_to_shell, scale_center_to_shell_z, scale_center_to_shell_y, shell_radius)  # TESTING
-
             shell_angle_yz = math.atan(scale_center_to_shell_y/scale_center_to_shell_z)
             angle_diff = abs(shell_angle_yz - scale_angle)
-            print "angle_diff = %s, shell_angle_yz=%s" % (angle_diff, shell_angle_yz)  # TESTING
             sin_angle_diff = math.sin(angle_diff)
             cos_angle_diff = math.cos(angle_diff)
 
@@ -1181,8 +1210,6 @@ def r1_eq(x):
                 cos_scale_angle = math.cos(scale_angle)
                 z1_new = min(z1, (scale_center_z + cos_scale_angle * scale_center_shell_dist))
                 r_new  = min(r, r1_function(z1_new))
-                print "SITUATION EDGE_HITS_BARREL: Called r1_function with r=%s, z1=%s, z1_new=%s, scale_angle=%s, scale_center_z=%s, scale_center_shell_dist=%s" %\
-                                                                          (r, z1, z1_new, scale_angle, scale_center_z, scale_center_shell_dist) # TESTING
             else:
                 sin_scale_angle = math.sin(scale_angle)
                 r_new  = min(r,  (scale_center_r + sin_scale_angle * scale_center_shell_dist))
@@ -1210,7 +1237,9 @@ def r1_eq(x):
         z_right = z2_new
         z_left  = z1_new
 
-    assert r > 0 and z_left > 0 and z_right > 0
+    # TODO MAKE THIS WORK!!!!
+    #print "r=%s, z_left=%s, z_right=%s" % (r, z_left, z_right)
+    #assert r > 0 and z_left > 0 and z_right > 0
 
     return r, z_right, z_left
 

From 43ed1245fd9ac72d112abb560e31f12f766c1376 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Sep 2012 16:48:17 +0200
Subject: [PATCH 1100/1541] Some cleanup

---
 shells.py | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/shells.py b/shells.py
index d7e5755d..c63c70e8 100755
--- a/shells.py
+++ b/shells.py
@@ -908,6 +908,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
             # Quadrant 1
             print "Quadrant 1"
+
             # Scale cylinder one until its height is equal to the z-distance minus the radius of the cyl. shell 2;
             # Then check whether any point of the axis of cyl. 2 projected on the top side of cyl. 1 is inside the radius of (scaled) cyl. 1.
             # If this is the case, we have the flat side of cyl. 1 hitting the barrel of cyl. 2. Else we have the edge hitting the barrel.
@@ -927,6 +928,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
             # Quadrant 2
             print "Quadrant 2"
+
             scale_center_to_shell_x    -= scale_center_r
             scale_center_to_flatend_x   = scale_center_to_shell_x - shell_half_length
             scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
@@ -962,6 +964,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
             # Quadrant 3
             print "Quadrant 3"
+
             scale_center_to_shell_y -= scale_center_r
             scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
             scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
@@ -994,8 +997,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         else:
             # Quadrant 4
             print "Quadrant 4"
-            print "shell_radius=%s, shell_half_length=%s, r=%s, scale_center_r=%s" % (shell_radius, shell_half_length, r, scale_center_r)
-            print "scale_angle=%s, scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_angle, scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
 
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
 
@@ -1025,9 +1026,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 if scale_center_to_lowpoint_z < 0.0:
                     scale_center_to_shell_low_angle_xy += Pi
 
-            print "scale_center_to_shell_crit_angle_xy=%s, scale_center_to_shell_low_angle_xy=%s, scale_center_to_critpoint_r=%s, scale_center_to_lowpoint_r=%s, scale_center_to_lowpoint_z=%s" \
-                 % (scale_center_to_shell_crit_angle_xy, scale_center_to_shell_low_angle_xy, scale_center_to_critpoint_r, scale_center_to_lowpoint_r, scale_center_to_lowpoint_z)
-
             # First treat the special case: when the scale center is further away from the z-axis than the "critpoint" (in the xy-plane)
             if scale_center_to_critpoint_r <= 0.0:
                 situation = EDGE_HITS_EDGE
@@ -1064,7 +1062,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             scale_center_to_shell_edge_x = scale_center_to_shell_x - shell_half_length
             scale_center_to_shell_edge_y = scale_center_to_shell_y - shell_radius
             scale_center_to_shell_edge_z = scale_center_to_shell_z - shell_radius
-            print "scale_center_to_shell_edge_x=%s" % str(scale_center_to_shell_edge_x)
 
             if scale_angle == 0.0:
 

From 89d12780f2770f2eaa918f29d0dc613af363e4f5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Sep 2012 18:23:25 +0200
Subject: [PATCH 1101/1541] Correct some of the scaling parameters for cyl.
 shells with constant radii

Some of the derivatives dzdr_left were ill-defined and caused scaling problems.
---
 shells.py | 29 +++++++++++------------------
 1 file changed, 11 insertions(+), 18 deletions(-)

diff --git a/shells.py b/shells.py
index c63c70e8..38b4acbe 100755
--- a/shells.py
+++ b/shells.py
@@ -1048,6 +1048,13 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
                     h1_min = r1_min/math.tan(scale_angle)
 
+        # TESTING Debug info
+        print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
+        print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
+        print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
+        print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
+        print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
+
         ##### (2) Treat the situation accordingly
         print "Situation= ", situation_string[situation]
         if situation == BARREL_HITS_FLAT:
@@ -1114,13 +1121,6 @@ def h1_eq(x):
 
                 # TODO TESTING REMOVE THIS WHEN DONE
                 #print "***** NEW ROOTFINDER ITERATION *****"
-                #print "  testShell = "+str(testShell)
-                #print "  scale_angle = %s" % scale_angle
-                #print "  tan_scale_angle = %s" % tan_scale_angle
-                #print "  r2 = %s" % (shell_radius)
-                #print "  h2 = %s" % (shell_half_length)
-                #print "  Dy = %s" % (scale_center_to_shell_y)
-                #print "  Dx = %s" % (scale_center_to_shell_x)
                 #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
                 #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
                 #print "  h1_interval_start = %s" % h1_interval_start
@@ -1153,13 +1153,6 @@ def r1_eq(x):
 
                 # TODO TESTING REMOVE THIS WHEN DONE
                 #print "***** NEW ROOTFINDER ITERATION *****"
-                #print "  testShell = "+str(testShell)
-                #print "  scale_angle = %s" % scale_angle
-                #print "  tan_scale_angle = %s" % tan_scale_angle
-                #print "  r2 = %s" % (shell_radius)
-                #print "  h2 = %s" % (shell_half_length)
-                #print "  Dy = %s" % (scale_center_to_shell_y)
-                #print "  Dx = %s" % (scale_center_to_shell_x)
                 #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
                 #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
                 #print "  r1_interval_start = %s" % r1_interval_start
@@ -2119,8 +2112,8 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.drdz_right = 0.0
         self.r0_right   = self.shell_radius
         self.z0_right   = 0.0
-        self.dzdr_left  = 0.0
-        self.drdz_left  = numpy.inf
+        self.dzdr_left  = numpy.inf
+        self.drdz_left  = 0.0
         self.r0_left    = self.shell_radius # better put to zero?
         self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
 
@@ -2420,8 +2413,8 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         self.drdz_right = 0.0
         self.r0_right   = self.shell_radius
         self.z0_right   = 0.0
-        self.dzdr_left  = 0.0
-        self.drdz_left  = numpy.inf
+        self.dzdr_left  = numpy.inf
+        self.drdz_left  = 0.0
         self.r0_left    = self.shell_radius
         self.z0_left    = self.cap_particle.radius * SINGLE_SHELL_FACTOR
 

From 946d1c41260fb56d11ce6acca6edbcc141dc74ae Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Sep 2012 19:13:17 +0200
Subject: [PATCH 1102/1541] Replace assertion of positive shell dimensions by
 exception

---
 shells.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index 38b4acbe..e23ef618 100755
--- a/shells.py
+++ b/shells.py
@@ -1227,9 +1227,8 @@ def r1_eq(x):
         z_right = z2_new
         z_left  = z1_new
 
-    # TODO MAKE THIS WORK!!!!
-    #print "r=%s, z_left=%s, z_right=%s" % (r, z_left, z_right)
-    #assert r > 0 and z_left > 0 and z_right > 0
+    if( r < 0 or z_left < 0 or z_right < 0 ):
+        raise testShellError('get_dr_dzright_dzleft_to_CylindricalShape: Negative length in shell scaling: r=%s, z_left=%s, z_right=%s' % (r, z_left, z_right) )
 
     return r, z_right, z_left
 

From 0dff6e5fc629b4260f8de71c5ede554f0aeea23a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Sep 2012 19:38:06 +0200
Subject: [PATCH 1103/1541] Some cleanup

---
 shells.py | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index e23ef618..1b117b12 100755
--- a/shells.py
+++ b/shells.py
@@ -1048,12 +1048,12 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
                     h1_min = r1_min/math.tan(scale_angle)
 
-        # TESTING Debug info
-        print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
-        print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
-        print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
-        print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
-        print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
+        # TODO TESTING Debug info
+        #print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
+        #print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
+        #print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
+        #print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
+        #print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
 
         ##### (2) Treat the situation accordingly
         print "Situation= ", situation_string[situation]
@@ -1191,7 +1191,6 @@ def r1_eq(x):
             #scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
                                        #math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
             assert scale_center_to_shell >= shell_radius
-            print "asin-value=%s" % str(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
             ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
             scale_center_shell_dist = shell_radius * math.sin(math.pi-(angle_diff+ss_angle)) / math.sin(angle_diff)
             assert scale_center_shell_dist>0 # TESTING

From 52e898ceca1a014e4fd11b4bea9d9d905670c180 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Sep 2012 15:09:57 +0200
Subject: [PATCH 1104/1541] Test-commit an improved self-adaptive rootfinder
 interval scaling in the EDGE_HITS_EDGE cylinder collision detection

---
 shells.py | 209 ++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 140 insertions(+), 69 deletions(-)

diff --git a/shells.py b/shells.py
index 1b117b12..fd8634c1 100755
--- a/shells.py
+++ b/shells.py
@@ -819,6 +819,9 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         z2_function = testShell.z_right
         z1 = z_left
         z2 = z_right
+    
+    # This must always be the case:
+    assert scale_angle >= 0.0
 
     # Check how the cylinders are oriented with respect to each other
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
@@ -1049,11 +1052,11 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     h1_min = r1_min/math.tan(scale_angle)
 
         # TODO TESTING Debug info
-        #print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
-        #print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
-        #print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
-        #print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
-        #print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
+        print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
+        print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
+        print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
+        print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
+        print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
 
         ##### (2) Treat the situation accordingly
         print "Situation= ", situation_string[situation]
@@ -1092,78 +1095,146 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     z1_new = min(z1, h_touch)
                     r_new  = min(r,  r1_function(z1_new))
 
-            elif scale_angle <= Pi/4.0:
+            else:
+
+                # Check whether to run the rootfinder.
+                # We only want to run it if the radius increase at intersection of the cylinder edges is "significant".
+                # This is sub-optimal but it avoids rootfinder errors caused by the fact that the radius search interval
+                # becomes to small, which is equivalent to the potential r-increase becoming small.
+                #
+                # We define the increase as "significant" by comparing the potential radius increase with the radial (xy-) distance
+                # from the scale center to the static shell; if increase / distance >= 10% the gain is "significant".
+                #radial_distance = math.sqrt( scale_center_to_shell_x**2 + scale_center_to_shell_y**2 )
+                #potential_r_increase = math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 ) - scale_center_to_shell_edge_x  
+                #assert radial_distance >= potential_r_increase and potential_r_increase >= 0
+
+                #if( potential_r_increase / radial_distance >= 0.10 ):
+
+                    #run_rootfinder = True
+
+                #else:
+
+                    #run_rootfinder = False
+        
+                    #if scale_center_to_shell_x >= scale_center_to_shell_y:
+                        #r_touch = scale_center_to_shell_edge_x
+                    #else:
+                        #r_touch = scale_center_to_shell_edge_y
+                    
+                    #r_new  = min(r, r_touch)
+                    #z1_new = min(z1, z1_function(r_new))
+
+
+            #if run_rootfinder:
+
+                if scale_angle <= Pi/4.0:
+
+                    def h1_eq(x):
 
-                def h1_eq(x):
+                        #rhs = (scale_center_to_shell_z - \
+                              #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
 
-                    #rhs = (scale_center_to_shell_z - \
-                           #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
+                        eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
+                                  (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2 ) )**2
 
-                    eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
-                               (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2 ) )**2
+                        # TODO TESTING REMOVE THIS WHEN DONE
+                        #print "***** ROOTFINDER CALL: Calling h1_eq() with: *****"
+                        #print "  h1 = %s, value = %s" % (x, eq_value )
+                        #print "  r1 = %s" % (r1_function(x+scale_center_z))
+                        #print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                        #print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
+                        #print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
+                        #print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
+                                            
+                        return eq_value
+
+                    # Self-adaptive initial value guessing for the rootfinder procedure:
+                    # Start with prefactors (1+TOLERANCE), (1-TOLERANCE) and check whether the h1_eq values for these
+                    # interval boundaries have different signs; if not, slightly enlarge the interval.
+                    n=1
+                    nmax=100
+                    h1_eq_product = 1
+                    assert(TOLERANCE<1.0) # TODO Remove this?
+                    while h1_eq_product > 0.0:
+
+                        h1_interval_start = (1.0+TOLERANCE**n) * (z1_function(scale_center_to_shell_edge_x) - scale_center_z)
+                        h1_interval_end   = (1.0-TOLERANCE**n) * (z1_function( math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 ) ) - scale_center_z)
+                        h1_eq_product     = h1_eq(h1_interval_start) * h1_eq(h1_interval_end)
+
+                        n = n+1
+
+                        if n>nmax:
+                            raise testShellError('get_dr_dzright_dzleft_to_CylindricalShape: Could not find suitable rootfinder boundaries in EDGE_HITS_EDGE cylinder scaling. nmax=%s' % str(nmax) )
+
+                    # h1-based VERSION; does not work well...
+                    #h1_interval_start = (1+TOLERANCE)*max(scale_center_to_shell_z - shell_radius, 0.0)
+                    #h1_interval_end   = (1-TOLERANCE)*scale_center_to_shell_z
+
+                    assert(h1_interval_start >= 0)
+                    assert(h1_interval_end   >= h1_interval_end)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    #print "***** ROOTFINDER CALL: Calling h1_eq() with: *****"
-                    #print "  h1 = %s, value = %s" % (x, eq_value )
-                    #print "  r1 = %s" % (r1_function(x+scale_center_z))
-                    #print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                    #print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                    #print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
-                    #print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
-                                        
-                    return eq_value
-
-                h1_interval_start = (1+TOLERANCE)*(z1_function(scale_center_to_shell_edge_x) - scale_center_z)
-                h1_interval_end   = (1-TOLERANCE)*(z1_function( math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 ) ) - scale_center_z)
-
-                assert(h1_interval_start >= 0)
-                assert(h1_interval_end   >= h1_interval_end)
-
-                # TODO TESTING REMOVE THIS WHEN DONE
-                #print "***** NEW ROOTFINDER ITERATION *****"
-                #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                #print "  h1_interval_start = %s" % h1_interval_start
-                #print "  h1_interval_end = %s"   % h1_interval_end
-                #print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
-                #print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
-
-                h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
-                z1_new = min(z1, h_touch)
-                r_new  = min(r,  r1_function(z1_new))
+                    print "***** NEW ROOTFINDER ITERATION *****"
+                    print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                    print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
+                    print "  h1_interval_start = %s" % h1_interval_start
+                    print "  h1_interval_end = %s"   % h1_interval_end
+                    print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
+                    print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
+
+                    h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
+                    z1_new = min(z1, h_touch)
+                    r_new  = min(r,  r1_function(z1_new))
 
-            else:
-                # This uses the same rootfinding equation and interval as above with r1=h1/tan_scale_angle
-                # instead of h1; notice that scale_angle > 0 here, so we can divide by it
-                def r1_eq(x):
-                    eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
-                               (scale_center_to_shell_y - math.sqrt( x**2 - scale_center_to_shell_edge_x**2 ) )**2
+                else:
+                    # This uses the same rootfinding equation and interval as above with r1=h1/tan_scale_angle
+                    # instead of h1; notice that scale_angle > 0 here, so we can divide by it
+                    def r1_eq(x):
+                        eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
+                                  (scale_center_to_shell_y - math.sqrt( x**2 - scale_center_to_shell_edge_x**2 ) )**2
+
+                        # TODO TESTING REMOVE THIS WHEN DONE
+                        #print "***** ROOTFINDER CALL: Calling r1_eq() with: *****"
+                        #print "  r1 = %s, value = %s" % (x, eq_value )
+                        #print "  h1 = %s" % (z1_function(x))
+
+                        return eq_value
+
+                    n=1
+                    nmax=100
+                    r1_eq_product = 1
+                    assert(TOLERANCE<1.0) # TODO TESTING Remove this?
+                    while r1_eq_product > 0.0:
+
+                        r1_interval_start = (1.0+TOLERANCE**n) * scale_center_to_shell_edge_x
+                        r1_interval_end   = (1.0-TOLERANCE**n) * math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
+                        r1_eq_product     = r1_eq(r1_interval_start) * r1_eq(r1_interval_end)
+                        
+                        n = n+1
+
+                        if n>nmax:
+                            raise testShellError('get_dr_dzright_dzleft_to_CylindricalShape: Could not find suitable rootfinder boundaries in EDGE_HITS_EDGE cylinder scaling. nmax=%s' % str(nmax) )
+
+                    # Non-adaptive version
+                    #r1_interval_start = scale_center_to_shell_edge_x
+                    #r1_interval_end   = math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
+                    assert(r1_interval_start >= 0)
+                    assert(r1_interval_end   >= r1_interval_start)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    #print "***** ROOTFINDER CALL: Calling r1_eq() with: *****"
-                    #print "  r1 = %s, value = %s" % (x, eq_value )
-                    #print "  h1 = %s" % (z1_function(x))
-
-                    return eq_value
-
-                r1_interval_start = scale_center_to_shell_edge_x
-                r1_interval_end   = math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
-                assert(r1_interval_start >= 0)
-                assert(r1_interval_end   >= r1_interval_start)
-
-                # TODO TESTING REMOVE THIS WHEN DONE
-                #print "***** NEW ROOTFINDER ITERATION *****"
-                #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                #print "  r1_interval_start = %s" % r1_interval_start
-                #print "  r1_interval_end = %s"   % r1_interval_end
-                #print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
-                #print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
-
-                r_touch = findroot(r1_eq, r1_interval_start, r1_interval_end)
-                          
-                r_new  = min(r, r_touch)
-                z1_new = min(z1, z1_function(r_new))
+                    print "***** NEW ROOTFINDER ITERATION *****"
+                    print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                    print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
+                    print "  r1_interval_start = %s" % r1_interval_start
+                    print "  r1_interval_end = %s"   % r1_interval_end
+                    print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
+                    print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
+
+                    r_touch = findroot(r1_eq, r1_interval_start, r1_interval_end)
+                              
+                    r_new  = min(r, r_touch)
+                    z1_new = min(z1, z1_function(r_new))
+
 
         elif situation == BARREL_HITS_EDGE:
             # the scaling cylinder hits the edge of 'shell' with its barrel side

From 142b88a000957194b523070e084ca7f74d28a3e9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Sep 2012 16:38:30 +0200
Subject: [PATCH 1105/1541] Extra collision detection for scale_angle=0 in
 situation 2

---
 shells.py | 68 +++++++++++++++++++++++++++++++++----------------------
 1 file changed, 41 insertions(+), 27 deletions(-)

diff --git a/shells.py b/shells.py
index fd8634c1..3e5989a7 100755
--- a/shells.py
+++ b/shells.py
@@ -932,37 +932,51 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # Quadrant 2
             print "Quadrant 2"
 
-            scale_center_to_shell_x    -= scale_center_r
-            scale_center_to_flatend_x   = scale_center_to_shell_x - shell_half_length
-            scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
-            scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
+            if scale_angle == 0:
 
-            # angle1
-            if scale_center_to_critpoint_z == 0:
-                scale_center_to_shell_crit_angle_y = Pi/2
-            else:
-                scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
-                if scale_center_to_critpoint_z < 0.0:
-                    scale_center_to_shell_crit_angle_y += Pi
-            # angle2
-            if scale_center_to_lowpoint_z == 0:
-                scale_center_to_shell_low_angle_y = Pi/2
+                  if math.sqrt( (scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) < r :
+                  # The lowest point of the static cylinder is within the radius/flat side circle of the scaling cylinder.
+                  # Therefore, when the height is scaled, the flat side must hit the barrel of the static cylinder at the lowpoint.
+                      situation = FLAT_HITS_BARREL
+
+                  else:
+                      situation = EDGE_HITS_EDGE
+                      # This will also properly treat the case in which there is no collision because the projection of
+                      # the static cylinder does not overlap with the flat side circle of the scaled cylinder
             else:
-                scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_flatend_x/ scale_center_to_lowpoint_z )
-                if scale_center_to_lowpoint_z < 0.0:
-                    scale_center_to_shell_low_angle_y += Pi
 
+                # Lauren's version
+                scale_center_to_shell_x    -= scale_center_r
+                scale_center_to_flatend_x   = scale_center_to_shell_x - shell_half_length
+                scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
+                scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
 
-            if scale_angle <= scale_center_to_shell_crit_angle_y:
-                situation = BARREL_HITS_FLAT
-            elif scale_center_to_shell_low_angle_y <= scale_angle:
-                situation = FLAT_HITS_BARREL
-            else:
-                assert scale_center_to_shell_crit_angle_y < scale_angle and \
-                       scale_angle < scale_center_to_shell_low_angle_y
-                situation = EDGE_HITS_EDGE
-                r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
-                h1_min = r1_min/math.tan(scale_angle)
+                # angle1
+                if scale_center_to_critpoint_z == 0:
+                    scale_center_to_shell_crit_angle_y = Pi/2
+                else:
+                    scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
+                    if scale_center_to_critpoint_z < 0.0:
+                        scale_center_to_shell_crit_angle_y += Pi
+                # angle2
+                if scale_center_to_lowpoint_z == 0:
+                    scale_center_to_shell_low_angle_y = Pi/2
+                else:
+                    scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_flatend_x/ scale_center_to_lowpoint_z )
+                    if scale_center_to_lowpoint_z < 0.0:
+                        scale_center_to_shell_low_angle_y += Pi
+
+
+                if scale_angle <= scale_center_to_shell_crit_angle_y:
+                    situation = BARREL_HITS_FLAT
+                elif scale_center_to_shell_low_angle_y <= scale_angle:
+                    situation = FLAT_HITS_BARREL
+                else:
+                    assert scale_center_to_shell_crit_angle_y < scale_angle and \
+                          scale_angle < scale_center_to_shell_low_angle_y
+                    situation = EDGE_HITS_EDGE
+                    r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
+                    h1_min = r1_min/math.tan(scale_angle)
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
             # Quadrant 3

From 505b88507551c7cdb34c130f6a2a37073c54d2ca Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Sep 2012 16:43:42 +0200
Subject: [PATCH 1106/1541] Fix a wrong variable assignment

---
 shells.py | 62 +++++++++++++++++++++++++++----------------------------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/shells.py b/shells.py
index 3e5989a7..4f8e971f 100755
--- a/shells.py
+++ b/shells.py
@@ -945,38 +945,38 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                       # the static cylinder does not overlap with the flat side circle of the scaled cylinder
             else:
 
-                # Lauren's version
-                scale_center_to_shell_x    -= scale_center_r
-                scale_center_to_flatend_x   = scale_center_to_shell_x - shell_half_length
-                scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
-                scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
-
-                # angle1
-                if scale_center_to_critpoint_z == 0:
-                    scale_center_to_shell_crit_angle_y = Pi/2
-                else:
-                    scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
-                    if scale_center_to_critpoint_z < 0.0:
-                        scale_center_to_shell_crit_angle_y += Pi
-                # angle2
-                if scale_center_to_lowpoint_z == 0:
-                    scale_center_to_shell_low_angle_y = Pi/2
-                else:
-                    scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_flatend_x/ scale_center_to_lowpoint_z )
-                    if scale_center_to_lowpoint_z < 0.0:
-                        scale_center_to_shell_low_angle_y += Pi
+                  # Lauren's version
+                  scale_center_to_shell_x    -= scale_center_r
+                  scale_center_to_flatend_x   = scale_center_to_shell_x - shell_half_length
+                  scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
+                  scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
+
+                  # angle1
+                  if scale_center_to_critpoint_z == 0:
+                      scale_center_to_shell_crit_angle_y = Pi/2
+                  else:
+                      scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
+                      if scale_center_to_critpoint_z < 0.0:
+                          scale_center_to_shell_crit_angle_y += Pi
+                  # angle2
+                  if scale_center_to_lowpoint_z == 0:
+                      scale_center_to_shell_low_angle_y = Pi/2
+                  else:
+                      scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_flatend_x/ scale_center_to_lowpoint_z )
+                      if scale_center_to_lowpoint_z < 0.0:
+                          scale_center_to_shell_low_angle_y += Pi
 
 
-                if scale_angle <= scale_center_to_shell_crit_angle_y:
-                    situation = BARREL_HITS_FLAT
-                elif scale_center_to_shell_low_angle_y <= scale_angle:
-                    situation = FLAT_HITS_BARREL
-                else:
-                    assert scale_center_to_shell_crit_angle_y < scale_angle and \
-                          scale_angle < scale_center_to_shell_low_angle_y
-                    situation = EDGE_HITS_EDGE
-                    r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
-                    h1_min = r1_min/math.tan(scale_angle)
+                  if scale_angle <= scale_center_to_shell_crit_angle_y:
+                      situation = BARREL_HITS_FLAT
+                  elif scale_center_to_shell_low_angle_y <= scale_angle:
+                      situation = FLAT_HITS_BARREL
+                  else:
+                      assert scale_center_to_shell_crit_angle_y < scale_angle and \
+                            scale_angle < scale_center_to_shell_low_angle_y
+                      situation = EDGE_HITS_EDGE
+                      r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
+                      h1_min = r1_min/math.tan(scale_angle)
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
             # Quadrant 3
@@ -1096,7 +1096,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
                     # The height and radius of the scaled cylinder remain unaltered
                     z1_new = z1
-                    r1_new = r
+                    r_new = r
 
                 else:
                 # There is a collision possible when z1 is scaled

From f42e35cb63dc3cea7367d515440d0ebf4626c4ae Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Sep 2012 16:50:26 +0200
Subject: [PATCH 1107/1541] Useful comments

---
 shells.py | 39 +++++++++++++++++++++++++++------------
 1 file changed, 27 insertions(+), 12 deletions(-)

diff --git a/shells.py b/shells.py
index 4f8e971f..a1af71bd 100755
--- a/shells.py
+++ b/shells.py
@@ -932,6 +932,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # Quadrant 2
             print "Quadrant 2"
 
+            # The case scale_angle=0, i.e. radius remaining constant at scaling, has to be treated separately
+            # because in this case the mathematics in the standard case misdetect the collision situation
             if scale_angle == 0:
 
                   if math.sqrt( (scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) < r :
@@ -944,21 +946,33 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                       # This will also properly treat the case in which there is no collision because the projection of
                       # the static cylinder does not overlap with the flat side circle of the scaled cylinder
             else:
-
-                  # Lauren's version
-                  scale_center_to_shell_x    -= scale_center_r
-                  scale_center_to_flatend_x   = scale_center_to_shell_x - shell_half_length
+                  # case scale_angle >0
+
+                  # Two points on the edge of the static cylinder are of interest here:
+                  # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy-plane
+                  # - the "critpoint" (critical point), which is the point on the edge with the shortest distance to the scale center                  
+                  scale_center_to_flatend_x   = (scale_center_to_shell_x - shell_half_length) - scale_center_r
+                  scale_center_to_lowpoint_x  = math.sqrt(( scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) - scale_center_r
+                      # TODO Is there no better way to include scale_center_r here?
                   scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
                   scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
 
-                  # angle1
+                  # Strategy:
+                  # - When the scale angle is smaller than the angle between the scaled cylinder's axis and the line
+                  #   that links the critpoint then we have a BARREL_HITS_FLAT situation.
+                  # - When the scale angle is bigger than the angle between the scaled cylinder's axis and the line
+                  #   that links the lowpoint then we are in a FLAT_HITS_BARREL situation.                  
+                  # - Everything else results in EDGE_HITS_EDGE
+
+                  # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and lowpoint
                   if scale_center_to_critpoint_z == 0:
                       scale_center_to_shell_crit_angle_y = Pi/2
                   else:
                       scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
                       if scale_center_to_critpoint_z < 0.0:
                           scale_center_to_shell_crit_angle_y += Pi
-                  # angle2
+
+                  # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and critpoint
                   if scale_center_to_lowpoint_z == 0:
                       scale_center_to_shell_low_angle_y = Pi/2
                   else:
@@ -966,10 +980,10 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                       if scale_center_to_lowpoint_z < 0.0:
                           scale_center_to_shell_low_angle_y += Pi
 
-
+                  # Compare the angles to determine the situation
                   if scale_angle <= scale_center_to_shell_crit_angle_y:
                       situation = BARREL_HITS_FLAT
-                  elif scale_center_to_shell_low_angle_y <= scale_angle:
+                  elif scale_angle >= scale_center_to_shell_low_angle_y:
                       situation = FLAT_HITS_BARREL
                   else:
                       assert scale_center_to_shell_crit_angle_y < scale_angle and \
@@ -982,7 +996,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # Quadrant 3
             print "Quadrant 3"
 
-            scale_center_to_shell_y -= scale_center_r
+            scale_center_to_shell_y -= scale_center_r  # TODO Is there no better way to include scale_center_r here?
             scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
             scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
 
@@ -1018,7 +1032,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
 
             # Two points on the edge of the static cylinder are of interest here:
-            # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy plane
+            # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy-plane
             # - the "critpoint" (critical point), which is the point on the edge with the minimal y-distance to
             #   the scale center in the zy-plane
             scale_center_to_critpoint_r = math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r    # a_r
@@ -1044,6 +1058,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     scale_center_to_shell_low_angle_xy += Pi
 
             # First treat the special case: when the scale center is further away from the z-axis than the "critpoint" (in the xy-plane)
+            # This also treats the case in which scale_angle = 0 and the scaled cylinder is directly below the static shell
             if scale_center_to_critpoint_r <= 0.0:
                 situation = EDGE_HITS_EDGE
 
@@ -1095,9 +1110,9 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 if r < math.sqrt(scale_center_to_shell_edge_x**2 + scale_center_to_shell_edge_y**2) :
 
                     # The height and radius of the scaled cylinder remain unaltered
-                    z1_new = z1
                     r_new = r
-
+                    z1_new = z1         # Note that z1_function would give infinity,
+                                        # but we would take the min(z1_function(r_new), z1)
                 else:
                 # There is a collision possible when z1 is scaled
                     

From 7b3b3e36d4a788a2575e28f521fd6bde681b1dcd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Sep 2012 17:49:16 +0200
Subject: [PATCH 1108/1541] Small fix in calculation of lowpoint-angle

---
 shells.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/shells.py b/shells.py
index a1af71bd..7c2127b8 100755
--- a/shells.py
+++ b/shells.py
@@ -962,7 +962,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                   #   that links the critpoint then we have a BARREL_HITS_FLAT situation.
                   # - When the scale angle is bigger than the angle between the scaled cylinder's axis and the line
                   #   that links the lowpoint then we are in a FLAT_HITS_BARREL situation.                  
-                  # - Everything else results in EDGE_HITS_EDGE
+                  # - Everything else results in EDGE_HITS_EDGE.
 
                   # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and lowpoint
                   if scale_center_to_critpoint_z == 0:
@@ -976,7 +976,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                   if scale_center_to_lowpoint_z == 0:
                       scale_center_to_shell_low_angle_y = Pi/2
                   else:
-                      scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_flatend_x/ scale_center_to_lowpoint_z )
+                      scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_lowpoint_x/ scale_center_to_lowpoint_z )
                       if scale_center_to_lowpoint_z < 0.0:
                           scale_center_to_shell_low_angle_y += Pi
 
@@ -987,7 +987,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                       situation = FLAT_HITS_BARREL
                   else:
                       assert scale_center_to_shell_crit_angle_y < scale_angle and \
-                            scale_angle < scale_center_to_shell_low_angle_y
+                             scale_angle < scale_center_to_shell_low_angle_y
                       situation = EDGE_HITS_EDGE
                       r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
                       h1_min = r1_min/math.tan(scale_angle)
@@ -1057,8 +1057,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 if scale_center_to_lowpoint_z < 0.0:
                     scale_center_to_shell_low_angle_xy += Pi
 
-            # First treat the special case: when the scale center is further away from the z-axis than the "critpoint" (in the xy-plane)
-            # This also treats the case in which scale_angle = 0 and the scaled cylinder is directly below the static shell
+            # First treat the special case: when the scale center is further away from the z-axis than the "critpoint" (in the xy-plane).
+            # This also treats the case in which scale_angle = 0 and the scaled cylinder is directly below the static shell.
             if scale_center_to_critpoint_r <= 0.0:
                 situation = EDGE_HITS_EDGE
 

From fd713919b6c8f8f1b32bb3c436639c3d7c2055cf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Sep 2012 20:21:47 +0200
Subject: [PATCH 1109/1541] Treat the scale_angle=0 case in quadrant 3 and
 extend the commenting

---
 shells.py | 192 +++++++++++++++++++++++++++++++-----------------------
 1 file changed, 112 insertions(+), 80 deletions(-)

diff --git a/shells.py b/shells.py
index 7c2127b8..24a6f5b4 100755
--- a/shells.py
+++ b/shells.py
@@ -935,95 +935,121 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # The case scale_angle=0, i.e. radius remaining constant at scaling, has to be treated separately
             # because in this case the mathematics in the standard case misdetect the collision situation
             if scale_angle == 0:
+                
+                if math.sqrt( (scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) < r :
+                # The lowest point of the static cylinder is within the radius/flat side circle of the scaling cylinder.
+                # Therefore, when the height is scaled, the flat side must hit the barrel of the static cylinder at the lowpoint.
+                    situation = FLAT_HITS_BARREL
 
-                  if math.sqrt( (scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) < r :
-                  # The lowest point of the static cylinder is within the radius/flat side circle of the scaling cylinder.
-                  # Therefore, when the height is scaled, the flat side must hit the barrel of the static cylinder at the lowpoint.
-                      situation = FLAT_HITS_BARREL
-
-                  else:
-                      situation = EDGE_HITS_EDGE
-                      # This will also properly treat the case in which there is no collision because the projection of
-                      # the static cylinder does not overlap with the flat side circle of the scaled cylinder
+                else:
+                    situation = EDGE_HITS_EDGE
+                    # This will also properly treat the case in which there is no collision because the projection of
+                    # the static cylinder does not overlap with the flat side circle of the scaled cylinder
             else:
-                  # case scale_angle >0
-
-                  # Two points on the edge of the static cylinder are of interest here:
-                  # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy-plane
-                  # - the "critpoint" (critical point), which is the point on the edge with the shortest distance to the scale center                  
-                  scale_center_to_flatend_x   = (scale_center_to_shell_x - shell_half_length) - scale_center_r
-                  scale_center_to_lowpoint_x  = math.sqrt(( scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) - scale_center_r
-                      # TODO Is there no better way to include scale_center_r here?
-                  scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
-                  scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
-
-                  # Strategy:
-                  # - When the scale angle is smaller than the angle between the scaled cylinder's axis and the line
-                  #   that links the critpoint then we have a BARREL_HITS_FLAT situation.
-                  # - When the scale angle is bigger than the angle between the scaled cylinder's axis and the line
-                  #   that links the lowpoint then we are in a FLAT_HITS_BARREL situation.                  
-                  # - Everything else results in EDGE_HITS_EDGE.
-
-                  # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and lowpoint
-                  if scale_center_to_critpoint_z == 0:
-                      scale_center_to_shell_crit_angle_y = Pi/2
-                  else:
-                      scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
-                      if scale_center_to_critpoint_z < 0.0:
-                          scale_center_to_shell_crit_angle_y += Pi
-
-                  # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and critpoint
-                  if scale_center_to_lowpoint_z == 0:
-                      scale_center_to_shell_low_angle_y = Pi/2
-                  else:
-                      scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_lowpoint_x/ scale_center_to_lowpoint_z )
-                      if scale_center_to_lowpoint_z < 0.0:
-                          scale_center_to_shell_low_angle_y += Pi
-
-                  # Compare the angles to determine the situation
-                  if scale_angle <= scale_center_to_shell_crit_angle_y:
-                      situation = BARREL_HITS_FLAT
-                  elif scale_angle >= scale_center_to_shell_low_angle_y:
-                      situation = FLAT_HITS_BARREL
-                  else:
-                      assert scale_center_to_shell_crit_angle_y < scale_angle and \
-                             scale_angle < scale_center_to_shell_low_angle_y
-                      situation = EDGE_HITS_EDGE
-                      r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
-                      h1_min = r1_min/math.tan(scale_angle)
+                # case scale_angle >0
+
+                # Two points on the edge of the static cylinder are of interest here:
+                # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy-plane
+                # - the "critpoint" (critical point), which is the point on the edge with the shortest distance to the scale center                  
+                scale_center_to_flatend_x   = (scale_center_to_shell_x - shell_half_length) - scale_center_r
+                scale_center_to_lowpoint_x  = math.sqrt(( scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) - scale_center_r
+                    # TODO Is there no better way to include scale_center_r here?
+                scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
+                scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
+
+                # Strategy:
+                # - When the scale angle is smaller than the angle between the scaled cylinder's axis and the line
+                #   that links the critpoint then we have a BARREL_HITS_FLAT situation.
+                # - When the scale angle is bigger than the angle between the scaled cylinder's axis and the line
+                #   that links the lowpoint then we are in a FLAT_HITS_BARREL situation.                  
+                # - Everything else results in EDGE_HITS_EDGE.
+
+                # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and lowpoint
+                if scale_center_to_critpoint_z == 0:
+                    scale_center_to_shell_crit_angle_y = Pi/2
+                else:
+                    scale_center_to_shell_crit_angle_y = math.atan(scale_center_to_flatend_x/ scale_center_to_critpoint_z)
+                    if scale_center_to_critpoint_z < 0.0:
+                        scale_center_to_shell_crit_angle_y += Pi
+
+                # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and critpoint
+                if scale_center_to_lowpoint_z == 0:
+                    scale_center_to_shell_low_angle_y = Pi/2
+                else:
+                    scale_center_to_shell_low_angle_y  = math.atan(scale_center_to_lowpoint_x/ scale_center_to_lowpoint_z )
+                    if scale_center_to_lowpoint_z < 0.0:
+                        scale_center_to_shell_low_angle_y += Pi
+
+                # Compare the angles to determine the situation
+                if scale_angle <= scale_center_to_shell_crit_angle_y:
+                    situation = BARREL_HITS_FLAT
+                elif scale_angle >= scale_center_to_shell_low_angle_y:
+                    situation = FLAT_HITS_BARREL
+                else:
+                    assert scale_center_to_shell_crit_angle_y < scale_angle and \
+                            scale_angle < scale_center_to_shell_low_angle_y
+                    situation = EDGE_HITS_EDGE
+                    r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
+                    h1_min = r1_min/math.tan(scale_angle)
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
             # Quadrant 3
             print "Quadrant 3"
 
-            scale_center_to_shell_y -= scale_center_r  # TODO Is there no better way to include scale_center_r here?
-            scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
-            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+            # The case scale_angle=0, i.e. radius remaining constant at scaling, has to be treated separately
+            # because in this case the mathematics in the standard case misdetect the collision situation
+            if scale_angle == 0:
 
-            # angle1
-            if scale_center_to_shell_z == 0.0:
-                scale_center_to_shell_crit_angle_x = Pi/2.0
-            else:
-                scale_center_to_shell_crit_angle_x = math.atan(scale_center_to_critpoint_y / scale_center_to_shell_z)
-                if scale_center_to_shell_z < 0.0:
-                    scale_center_to_shell_crit_angle_x += Pi
-            # angle2
-            if scale_center_to_lowpoint_z == 0.0:
-                scale_center_to_shell_low_angle_x = Pi/2.0
-            else:
-                scale_center_to_shell_low_angle_x  = math.atan(scale_center_to_shell_y/scale_center_to_lowpoint_z)
-                if scale_center_to_lowpoint_z < 0.0:
-                    scale_center_to_shell_low_angle_x += Pi
+                if scale_center_to_shell_y < r :
+                # The lowest point of the static cylinder is within the radius/flat side circle of the scaling cylinder.
+                # Therefore, when the height is scaled, the flat side must hit the barrel of the static cylinder at the lowpoint.
+                    situation = FLAT_HITS_BARREL
 
+                elif scale_center_to_shell_y - shell_radius <= r:
+                    situation = EDGE_HITS_BARREL
+
+                else:
+                    # In this case the cylinders do not hit; this is treated properly by the BARREL_HITS_BARREL routine
+                    situation = BARREL_HITS_BARREL
 
-            if scale_angle <= scale_center_to_shell_crit_angle_x:
-                situation = BARREL_HITS_BARREL
-            elif scale_center_to_shell_low_angle_x <= scale_angle:
-                situation = FLAT_HITS_BARREL
             else:
-                assert scale_center_to_shell_crit_angle_x < scale_angle and \
-                       scale_angle < scale_center_to_shell_low_angle_x
-                situation = EDGE_HITS_BARREL
+
+                # Two points on the edge of the static cylinder are of interest here:
+                # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy-plane
+                # - the "critpoint" (critical point), which is the point on the edge with the shortest distance to the scale center   
+                scale_center_to_shell_y -= scale_center_r  # TODO Is there no better way to include scale_center_r here?
+                scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
+                scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+
+                # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and critpoint
+                if scale_center_to_shell_z == 0.0:
+                    scale_center_to_shell_crit_angle_x = Pi/2.0
+                else:
+                    scale_center_to_shell_crit_angle_x = math.atan(scale_center_to_critpoint_y / scale_center_to_shell_z)
+                    if scale_center_to_shell_z < 0.0:
+                        scale_center_to_shell_crit_angle_x += Pi
+                # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and lowpoint
+                if scale_center_to_lowpoint_z == 0.0:
+                    scale_center_to_shell_low_angle_x = Pi/2.0
+                else:
+                    scale_center_to_shell_low_angle_x  = math.atan(scale_center_to_shell_y/scale_center_to_lowpoint_z)
+                    if scale_center_to_lowpoint_z < 0.0:
+                        scale_center_to_shell_low_angle_x += Pi
+
+                # Determine which collision will happen:
+                # If the scale angle is bigger than the angle between the scaled cylinder's axis and the lowpoint
+                # then we hit the barrel of the static cylinder when scaling.
+                # If the scale angle is smaller than the angle between the scaled cylinder's axis and the critpoint
+                # the barrel of the scaled cylinder will hit the barrel of the static cylinder.
+                # Otherwise we have the edge of the scaled cylinder hitting the barrel of the static cylinder.
+                if scale_angle <= scale_center_to_shell_crit_angle_x:
+                    situation = BARREL_HITS_BARREL
+                elif scale_center_to_shell_low_angle_x <= scale_angle:
+                    situation = FLAT_HITS_BARREL
+                else:
+                    assert scale_center_to_shell_crit_angle_x < scale_angle and \
+                          scale_angle < scale_center_to_shell_low_angle_x
+                    situation = EDGE_HITS_BARREL
 
         else:
             # Quadrant 4
@@ -1306,8 +1332,14 @@ def r1_eq(x):
 
         elif situation == BARREL_HITS_BARREL:
             # The scaling cylinder hits the barrel of 'shell' with its barrel
-            r_new = min(r, (ref_to_shell_y - shell_radius))
-            z1_new = min(z1, z1_function(r_new))
+            if scale_angle == 0.0:
+                # In this case the cylinders can never hit; just leave the lenghts as they are
+                r_new = r
+                z1_new = z1
+            else:
+                # case scale_angle > 0
+                r_new = min(r, (ref_to_shell_y - shell_radius))
+                z1_new = min(z1, z1_function(r_new))
 
         else:
             raise RuntimeError('get_dr_dzright_dzleft_to_CylindricalShape: Bad situation for making cylinders against cylinders.')

From 42f5c7a306a23e2ee0e0ef10c31dd7084d2c8798 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 17 Sep 2012 14:17:30 +0200
Subject: [PATCH 1110/1541] A small fix to the single dissociation into two
 products at the edge

---
 egfrd.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c28b2e13..a45f0e1b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1211,14 +1211,14 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             out_pos = newpos2
                             in_pos  = newpos1
 
-                        assert(newpos1_is_out * newpos2_is_out == 0)
-                            # at most one particle should be out if the CoM did not move out of the plane!
+                        if newpos1_is_out * newpos2_is_out == 0:
+                            log.warning('single reaction: both product positions lie out of plane (reactant_pos=%s, newpos1=%s, newpos2=%s)' % (reactant_pos, newpos1, newpos2) )
 
                         if(newpos1_is_out or newpos2_is_out):
 
                             # Get the closest plane
                             neighbors = []
-                            neighbors = self.geometrycontainer.get_neighbor_surfaces(out_pos, reactant_structure.id, ignores=[])
+                            neighbors = get_neighbor_surfaces(self.world, out_pos, reactant_structure.id, ignores=[])
 
                             neighbor_planes = []
                             for structure, structure_distance in neighbors:

From f5a10066d66dbab66717890a422f30a7fb2f0596 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 17 Sep 2012 15:15:38 +0200
Subject: [PATCH 1111/1541] Test-commit using apply_boundary in
 do_back_transform for single reaction around the edge

---
 egfrd.py |  8 ++++++--
 pair.py  | 33 ++++++++++++++++++++-------------
 2 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a45f0e1b..c180ce35 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1211,8 +1211,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             out_pos = newpos2
                             in_pos  = newpos1
 
-                        if newpos1_is_out * newpos2_is_out == 0:
-                            log.warning('single reaction: both product positions lie out of plane (reactant_pos=%s, newpos1=%s, newpos2=%s)' % (reactant_pos, newpos1, newpos2) )
+                        if newpos1_is_out * newpos2_is_out > 0:  # TESTING
+                            log.warning('single reaction: both product positions lie out of plane (reactant_pos=%s, iv=%s, newpos1=%s, newpos2=%s)' % (reactant_pos, iv, newpos1, newpos2) )
+                            assert newpos1_is_out * newpos2_is_out == 0
 
                         if(newpos1_is_out or newpos2_is_out):
 
@@ -1235,6 +1236,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                                                                                          reactant_structure, target_structure,
                                                                                                          unit_z)
 
+                            newpos1, sid1 = self.world.apply_boundary((newpos1, sid1))
+                            newpos2, sid2 = self.world.apply_boundary((newpos2, sid2))
+
                         # If none of the new pos. is out the call to SimplePair.do_back_transform() should have
                         # produced the correct positions.
 
diff --git a/pair.py b/pair.py
index 89f4824c..6378a29f 100644
--- a/pair.py
+++ b/pair.py
@@ -688,21 +688,28 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # if not, they have to be deflected on structure2.
         # The structure.deflect() method requires a starting point and a displacement; we can construct
         # bogus parameters for these by subtracting the center position of structure1 from pos1 and pos2.
-        s1_ctr = structure1.shape.position
+        #s1_ctr = structure1.shape.position
 
-        new_pos1, changeflag1 = structure2.deflect(s1_ctr, pos1 - s1_ctr)   #TODO replace by world.apply_boundary
-        new_pos2, changeflag2 = structure2.deflect(s1_ctr, pos2 - s1_ctr)
+        #new_pos1, changeflag1 = structure2.deflect(s1_ctr, pos1 - s1_ctr)   #TODO replace by world.apply_boundary
+        #new_pos2, changeflag2 = structure2.deflect(s1_ctr, pos2 - s1_ctr)      
         
-        # adjust the structure_ids of the particles
-        if changeflag1 == 0 :
-            new_sid1 = structure1.id
-        else :
-            new_sid1 = structure2.id
-
-        if changeflag2 == 0 :
-            new_sid2 = structure1.id
-        else :
-            new_sid2 = structure2.id
+        ## adjust the structure_ids of the particles
+        #if changeflag1 == 0 :
+            #new_sid1 = structure1.id
+        #else :
+            #new_sid1 = structure2.id
+
+        #if changeflag2 == 0 :
+            #new_sid2 = structure1.id
+        #else :
+            #new_sid2 = structure2.id
+
+        # TESTING Using world.apply_boundary here not work because a classmethod does not know anything outside...
+        # Therefore we return the raw positions still in structure1 here; make sure apply_boundary is invoked later
+        new_pos1 = pos1
+        new_pos2 = pos2
+        new_sid1 = structure1.id
+        new_sid2 = structure1.id
 
         # TODO: Check that the new positions are in their new planes and 
         # maybe also that pos1 and pos2 are in structure1 in the first place?

From 0bb93a4229016fc278ce8430d5862ffcbbec8514 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 17 Sep 2012 15:32:46 +0200
Subject: [PATCH 1112/1541] Pass self.world to do_back_transform method in
 order to use apply_boundary

---
 egfrd.py | 13 ++++++++-----
 pair.py  | 51 +++++++++++----------------------------------------
 2 files changed, 19 insertions(+), 45 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c180ce35..79f456a1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1126,7 +1126,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         newposA, newposB, sidA, sidB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                                        productA_radius, productB_radius,
                                                                                        reactant_structure, reactant_structure,
-                                                                                       unit_z)
+                                                                                       unit_z, self.world)
                         # the second reactant_structure parameter passed is ignored here
 
                         if default:
@@ -1142,11 +1142,14 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         iv = random_vector(particle_radius12 * MixedPair1D3D.calc_r_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
 
+                        unit_z = reactant_structure.shape.unit_z
+
                         newposA, newposB, sidA, sidB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                                        productA_radius, productB_radius,
-                                                                                       reactant_structure, reactant_structure)
+                                                                                       reactant_structure, reactant_structure,
+                                                                                       unit_z, self.world)
                         # the second reactant_structure parameter passed is ignored here
-                        # TODO: Why is there no unit_z passed here?
+                        # unit_z is passed here for completeness but not used in the method
 
                         newposB = self.world.apply_boundary(newposB)
                         if __debug__:
@@ -1179,7 +1182,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     newpos1, newpos2, sid1, sid2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
                                                                                 product1_radius, product2_radius,
                                                                                 reactant_structure, reactant_structure,
-                                                                                unit_z)
+                                                                                unit_z, self.world)
                     # for the SimplePair do_back_transform() requires that the two structures passed are the same
                     # because it will check for this!
 
@@ -1234,7 +1237,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                                                                                          D1, D2,
                                                                                                          product1_radius, product2_radius,
                                                                                                          reactant_structure, target_structure,
-                                                                                                         unit_z)
+                                                                                                         unit_z, self.world)
 
                             newpos1, sid1 = self.world.apply_boundary((newpos1, sid1))
                             newpos2, sid2 = self.world.apply_boundary((newpos2, sid2))
diff --git a/pair.py b/pair.py
index 6378a29f..979b4b38 100644
--- a/pair.py
+++ b/pair.py
@@ -161,7 +161,7 @@ def draw_new_positions(self, dt, r0, old_iv, event_type):
                                                   self.pid_particle_pair2[1].radius,
                                                   self.structure1,
                                                   self.structure2,
-                                                  unit_z)
+                                                  unit_z, self.world)
         # sid = structure_id
 
         return newpos1, newpos2, sid1, sid2
@@ -238,7 +238,7 @@ def __init__(self, domain_id, shell_id, rrs):
 
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z, world):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
 
@@ -647,7 +647,7 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
         return new_iv_x + new_iv_y
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z, world):
 
         # structure should be = structure1, but for safety we use the structures
         # inherited from the test shell
@@ -667,11 +667,10 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         _, (pos2_orth, _) = structure2.project_point(pos2)
 
         if( pos1_orth * pos2_orth < 0.0 ) :
-            # The particles will end up on different planes, i.e.
+            # The particles will end up on different planes, that means
             # that one of the points will be deflected.
             # The interparticle vector therefore must be enlarged to
             # ensure that there is no overlap after deflection.
-            particles_on_same_structure = 0
             # Calculate the safety (= IPV enlargement) factor
             l_iv = length(iv)
             assert(2.0*abs(pos1_orth*pos2_orth) < (l_iv*l_iv))  # That should never fail!
@@ -680,41 +679,12 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
             iv_rescaled = iv_safety * iv
             pos1 = com - iv_rescaled * (D1 / D_tot)
             pos2 = com + iv_rescaled * (D2 / D_tot)
-
-        else :
-            particles_on_same_structure = 1
-
-        # Now we have to check (for both[!] new positions) whether they are still in plane1;
-        # if not, they have to be deflected on structure2.
-        # The structure.deflect() method requires a starting point and a displacement; we can construct
-        # bogus parameters for these by subtracting the center position of structure1 from pos1 and pos2.
-        #s1_ctr = structure1.shape.position
-
-        #new_pos1, changeflag1 = structure2.deflect(s1_ctr, pos1 - s1_ctr)   #TODO replace by world.apply_boundary
-        #new_pos2, changeflag2 = structure2.deflect(s1_ctr, pos2 - s1_ctr)      
-        
-        ## adjust the structure_ids of the particles
-        #if changeflag1 == 0 :
-            #new_sid1 = structure1.id
-        #else :
-            #new_sid1 = structure2.id
-
-        #if changeflag2 == 0 :
-            #new_sid2 = structure1.id
-        #else :
-            #new_sid2 = structure2.id
-
-        # TESTING Using world.apply_boundary here not work because a classmethod does not know anything outside...
-        # Therefore we return the raw positions still in structure1 here; make sure apply_boundary is invoked later
-        new_pos1 = pos1
-        new_pos2 = pos2
-        new_sid1 = structure1.id
-        new_sid2 = structure1.id
+                
 
         # TODO: Check that the new positions are in their new planes and 
         # maybe also that pos1 and pos2 are in structure1 in the first place?
 
-        return new_pos1, new_pos2, new_sid1, new_sid2
+        return pos1, pos2, structure1.id, structure1.id
 
     def draw_new_com(self, dt, event_type):
         # Draws a new coordinate for the CoM in world coordinates.
@@ -932,7 +902,7 @@ def determine_radii(self):
         return a_R, a_r
 
     @ classmethod 
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, structure3D, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, structure3D, unit_z, world):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
     #
@@ -1050,10 +1020,11 @@ def __str__(self):
 class MixedPair1D3D(Pair):
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1D, structure3D, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1D, structure3D, unit_z, world):
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
-    # unit_z is a putatively different unit_z than that available in the surface object
+    # unit_z is a putatively different unit_z than that available in the surface object and should not be
+    # of use here (however the method is defined with the same parameter signature as elsewhere)
     #
     # note that structure1D is not a 1D object but the surface that the 1D particle is bound to
     #
@@ -1172,7 +1143,7 @@ def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
 
     @ classmethod
-    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z):
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z, world):
     # here we assume that structure1 = structure1D and structure2 = cap_structure
     # and that com has been correctly initialized with the initial (and constant) position
     # of the cap particle.

From 1ab42e1b1622446cc05a260deb8c2d5b33b2a0b9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 17 Sep 2012 15:41:31 +0200
Subject: [PATCH 1113/1541] Move apply_boundary into do_back_transform for
 PlanarSurfaceTransitionPair

---
 egfrd.py |  3 ---
 pair.py  | 13 ++++++++-----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 79f456a1..aa18cfd3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1239,9 +1239,6 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                                                                                          reactant_structure, target_structure,
                                                                                                          unit_z, self.world)
 
-                            newpos1, sid1 = self.world.apply_boundary((newpos1, sid1))
-                            newpos2, sid2 = self.world.apply_boundary((newpos2, sid2))
-
                         # If none of the new pos. is out the call to SimplePair.do_back_transform() should have
                         # produced the correct positions.
 
diff --git a/pair.py b/pair.py
index 979b4b38..74fa1591 100644
--- a/pair.py
+++ b/pair.py
@@ -652,21 +652,21 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # structure should be = structure1, but for safety we use the structures
         # inherited from the test shell
 
-        # Calculate the new positions still in structure1
+        # Calculate the new positions (still in structure1)
         D_tot = D1 + D2
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
 
         # Check whether the new positions will end up on the same structure
         # by comparing their orthogonal components in the coordinate system of
-        # structure2 (which is orthogonal to structure1).
+        # structure2 (which is assumed to be orthogonal to structure1).
         # These components also are used to calculate the safety factor for
         # interparticle vector enlargement in case that the two particles
         # indeed are on two different planes.
         _, (pos1_orth, _) = structure2.project_point(pos1)
         _, (pos2_orth, _) = structure2.project_point(pos2)
 
-        if( pos1_orth * pos2_orth < 0.0 ) :
+        if pos1_orth < 0.0 or pos2_orth < 0.0 :
             # The particles will end up on different planes, that means
             # that one of the points will be deflected.
             # The interparticle vector therefore must be enlarged to
@@ -679,12 +679,15 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
             iv_rescaled = iv_safety * iv
             pos1 = com - iv_rescaled * (D1 / D_tot)
             pos2 = com + iv_rescaled * (D2 / D_tot)
-                
+
+        # Apply boundary; this will also correctly set the new structure IDs
+        new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
+        new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))                
 
         # TODO: Check that the new positions are in their new planes and 
         # maybe also that pos1 and pos2 are in structure1 in the first place?
 
-        return pos1, pos2, structure1.id, structure1.id
+        return new_pos1, new_pos2, new_sid1, new_sid2
 
     def draw_new_com(self, dt, event_type):
         # Draws a new coordinate for the CoM in world coordinates.

From 236c89738941a21dcab7f873b6383300f7eba32e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 17 Sep 2012 16:15:43 +0200
Subject: [PATCH 1114/1541] A better treatment of the safety factor application
 in case of two dissociation products overlapping when ending up on adjacent
 planes

---
 pair.py | 69 ++++++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 51 insertions(+), 18 deletions(-)

diff --git a/pair.py b/pair.py
index 74fa1591..807035ce 100644
--- a/pair.py
+++ b/pair.py
@@ -657,21 +657,26 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
 
-        # Check whether the new positions will end up on the same structure
-        # by comparing their orthogonal components in the coordinate system of
-        # structure2 (which is assumed to be orthogonal to structure1).
-        # These components also are used to calculate the safety factor for
-        # interparticle vector enlargement in case that the two particles
-        # indeed are on two different planes.
-        _, (pos1_orth, _) = structure2.project_point(pos1)
-        _, (pos2_orth, _) = structure2.project_point(pos2)
-
-        if pos1_orth < 0.0 or pos2_orth < 0.0 :
-            # The particles will end up on different planes, that means
-            # that one of the points will be deflected.
-            # The interparticle vector therefore must be enlarged to
-            # ensure that there is no overlap after deflection.
-            # Calculate the safety (= IPV enlargement) factor
+        # Tentatively apply boundaries; this will also set the new structure IDs.
+        # In some cases the new positions may end up on adjacent planar surfaces.
+        # This may lead to an overlap which has to be checked for and removed if present
+        # in the next step.
+        new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
+        new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
+
+        # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
+        if world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR :
+
+            new_structure1 = world.get_structure(new_sid1)
+            new_structure2 = world.get_structure(new_sid2)
+
+            # Calculate the distances from the two new positions to the edge between the planes
+            # in which the particles temporarily ended up
+            # This is easily done by projecting new_pos1 into new_structure2 + vice versa and
+            # computing the orthogonal components of the projections:
+            _, (pos1_orth, _) = new_structure2.project_point(new_pos1)
+            _, (pos2_orth, _) = new_structure1.project_point(new_pos2)
+
             l_iv = length(iv)
             assert(2.0*abs(pos1_orth*pos2_orth) < (l_iv*l_iv))  # That should never fail!
             iv_safety = 1.0/( 1.0 - 2.0*abs(pos1_orth*pos2_orth)/(l_iv*l_iv) )
@@ -680,9 +685,37 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
             pos1 = com - iv_rescaled * (D1 / D_tot)
             pos2 = com + iv_rescaled * (D2 / D_tot)
 
-        # Apply boundary; this will also correctly set the new structure IDs
-        new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
-        new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))                
+            # Re-apply boundaries
+            new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
+            new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
+
+        
+        ## Check whether the new positions will end up on the same structure
+        ## by comparing their orthogonal components in the coordinate system of
+        ## structure2 (which is assumed to be orthogonal to structure1).
+        ## These components also are used to calculate the safety factor for
+        ## interparticle vector enlargement in case that the two particles
+        ## indeed are on two different planes.
+        #_, (pos1_orth, _) = structure2.project_point(pos1)
+        #_, (pos2_orth, _) = structure2.project_point(pos2)
+
+        #if pos1_orth < 0.0 or pos2_orth < 0.0 :
+            ## The particles will end up on different planes, that means
+            ## that one of the points will be deflected.
+            ## The interparticle vector therefore must be enlarged to
+            ## ensure that there is no overlap after deflection.
+            ## Calculate the safety (= IPV enlargement) factor
+            #l_iv = length(iv)
+            #assert(2.0*abs(pos1_orth*pos2_orth) < (l_iv*l_iv))  # That should never fail!
+            #iv_safety = 1.0/( 1.0 - 2.0*abs(pos1_orth*pos2_orth)/(l_iv*l_iv) )
+            ## Recalculate the interparticle vector and new positions
+            #iv_rescaled = iv_safety * iv
+            #pos1 = com - iv_rescaled * (D1 / D_tot)
+            #pos2 = com + iv_rescaled * (D2 / D_tot)
+
+        ## Apply boundary; this will also correctly set the new structure IDs
+        #new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
+        #new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))          
 
         # TODO: Check that the new positions are in their new planes and 
         # maybe also that pos1 and pos2 are in structure1 in the first place?

From 3efd009f7893f3ac426c939f1976cab1e1891075 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 17 Sep 2012 16:33:28 +0200
Subject: [PATCH 1115/1541] Revise single_reaction treatment on PlanarSurfaces

---
 egfrd.py | 93 ++++++++++++++++++++------------------------------------
 1 file changed, 33 insertions(+), 60 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index aa18cfd3..d0f352b1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1169,7 +1169,8 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             #     If the two particles stay on the same structure type as the reactant
             #     (but not necessarily on the same structure!)
             else:
-                # generate new positions in the structure
+                # Case product1_structure_type_id == product2_structure_type_id
+                # Generate new positions in the structure
                 # TODO Make this into a generator
                 product_pos_list = []
                 for _ in range(self.dissociation_retry_moves):
@@ -1178,72 +1179,44 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     iv = _random_vector(reactant_structure, particle_radius12, self.rng)
                     iv *= MINIMAL_SEPARATION_FACTOR
 
-                    unit_z = reactant_structure.shape.unit_z    # not used
-                    newpos1, newpos2, sid1, sid2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
-                                                                                product1_radius, product2_radius,
-                                                                                reactant_structure, reactant_structure,
-                                                                                unit_z, self.world)
-                    # for the SimplePair do_back_transform() requires that the two structures passed are the same
-                    # because it will check for this!
+                    unit_z = reactant_structure.shape.unit_z    # not used but passed for completeness
 
                     # If reactant_structure is a finite PlanarSurface the new position potentially can
                     # lie outside of the plane. The two product particles then will end up on different
-                    # planes of the same structure_type.
-                    #
-                    # In this case we have to:
-                    #
-                    # (1) Check whether one of the new positions are out of plane reactant_structure
-                    #     (note that this can be the case for at most one of the particles).
-                    # (2) If yes, find the plane that they should be deflected to, which is
-                    #     the closest one with respect to the new position.
-                    # (3) Calculate the new postions again using the correct back transform function.
+                    # planes of the same structure_type. Therefore this case is treated separately.
+                    # We use a specific do_back_transform method here which automatically takes care
+                    # of the potential structure change and potentially resulting overlaps.
                     if isinstance(reactant_structure, PlanarSurface):
 
-                        dist1 = self.world.distance(reactant_structure.shape, newpos1)
-                        dist2 = self.world.distance(reactant_structure.shape, newpos2)
+                        ## Get the closest plane
+                        #neighbors = []
+                        #neighbors = get_neighbor_surfaces(self.world, out_pos, reactant_structure.id, ignores=[])
 
-                        newpos1_is_out = 0
-                        newpos2_is_out = 0
-                        if(dist1 > 0.0):
-                            newpos1_is_out = 1
-                            out_pos = newpos1
-                            in_pos  = newpos2
-
-                        if(dist2 > 0.0):
-                            newpos2_is_out = 1
-                            out_pos = newpos2
-                            in_pos  = newpos1
-
-                        if newpos1_is_out * newpos2_is_out > 0:  # TESTING
-                            log.warning('single reaction: both product positions lie out of plane (reactant_pos=%s, iv=%s, newpos1=%s, newpos2=%s)' % (reactant_pos, iv, newpos1, newpos2) )
-                            assert newpos1_is_out * newpos2_is_out == 0
-
-                        if(newpos1_is_out or newpos2_is_out):
-
-                            # Get the closest plane
-                            neighbors = []
-                            neighbors = get_neighbor_surfaces(self.world, out_pos, reactant_structure.id, ignores=[])
-
-                            neighbor_planes = []
-                            for structure, structure_distance in neighbors:
-                                if isinstance(structure, PlanarSurface):
-                                    neighbor_planes.append((structure, structure_distance))
+                        #neighbor_planes = []
+                        #for structure, structure_distance in neighbors:
+                            #if isinstance(structure, PlanarSurface):
+                                #neighbor_planes.append((structure, structure_distance))
+                    
+                        #neighbor_planes = sorted(neighbor_planes, key=lambda plane_and_dist: plane_and_dist[1])
+                        #target_structure, _  = neighbor_planes[0]
+
+                        # Recalculate the back transform taking into account the deflection
+                        newpos1, newpos2, sid1, sid2 = PlanarSurfaceTransitionPair.do_back_transform(reactant_pos, iv,
+                                                                                                      D1, D2,
+                                                                                                      product1_radius, product2_radius,
+                                                                                                      reactant_structure, reactant_structure,
+                                                                                                      unit_z, self.world)
+                    else:
                         
-                            neighbor_planes = sorted(neighbor_planes, key=lambda plane_and_dist: plane_and_dist[1])
-                            target_structure, _  = neighbor_planes[0]
-
-                            # Recalculate the back transform taking into account the deflection
-                            newpos1, newpos2, sid1, sid2 = PlanarSurfaceTransitionPair.do_back_transform(reactant_pos, iv,
-                                                                                                         D1, D2,
-                                                                                                         product1_radius, product2_radius,
-                                                                                                         reactant_structure, target_structure,
-                                                                                                         unit_z, self.world)
-
-                        # If none of the new pos. is out the call to SimplePair.do_back_transform() should have
-                        # produced the correct positions.
-
-                # End of special treatment for PlanarSurface particles
-                                        
+                        # Calculate the standard back transform
+                        newpos1, newpos2, sid1, sid2 = SimplePair.do_back_transform(reactant_pos, iv, D1, D2,
+                                                                                    product1_radius, product2_radius,
+                                                                                    reactant_structure, reactant_structure,
+                                                                                    unit_z, self.world)
+                        # for the SimplePair do_back_transform() requires that the two structures passed are the same
+                        # because it will check for this!
+
+                # Pass on the newly generated information
                 product_pos_list.append((newpos1, newpos2))
                 product1_structure_id = sid1
                 product2_structure_id = sid2

From 3ee9dfd90c1552b078742fae418353271364dc5d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 17 Sep 2012 16:36:52 +0200
Subject: [PATCH 1116/1541] Clean up do_back_transform and usage of it

---
 egfrd.py | 12 ------------
 pair.py  | 30 +-----------------------------
 2 files changed, 1 insertion(+), 41 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d0f352b1..83ed9c1f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1188,18 +1188,6 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     # of the potential structure change and potentially resulting overlaps.
                     if isinstance(reactant_structure, PlanarSurface):
 
-                        ## Get the closest plane
-                        #neighbors = []
-                        #neighbors = get_neighbor_surfaces(self.world, out_pos, reactant_structure.id, ignores=[])
-
-                        #neighbor_planes = []
-                        #for structure, structure_distance in neighbors:
-                            #if isinstance(structure, PlanarSurface):
-                                #neighbor_planes.append((structure, structure_distance))
-                    
-                        #neighbor_planes = sorted(neighbor_planes, key=lambda plane_and_dist: plane_and_dist[1])
-                        #target_structure, _  = neighbor_planes[0]
-
                         # Recalculate the back transform taking into account the deflection
                         newpos1, newpos2, sid1, sid2 = PlanarSurfaceTransitionPair.do_back_transform(reactant_pos, iv,
                                                                                                       D1, D2,
diff --git a/pair.py b/pair.py
index 807035ce..81464874 100644
--- a/pair.py
+++ b/pair.py
@@ -687,35 +687,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
 
             # Re-apply boundaries
             new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
-            new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
-
-        
-        ## Check whether the new positions will end up on the same structure
-        ## by comparing their orthogonal components in the coordinate system of
-        ## structure2 (which is assumed to be orthogonal to structure1).
-        ## These components also are used to calculate the safety factor for
-        ## interparticle vector enlargement in case that the two particles
-        ## indeed are on two different planes.
-        #_, (pos1_orth, _) = structure2.project_point(pos1)
-        #_, (pos2_orth, _) = structure2.project_point(pos2)
-
-        #if pos1_orth < 0.0 or pos2_orth < 0.0 :
-            ## The particles will end up on different planes, that means
-            ## that one of the points will be deflected.
-            ## The interparticle vector therefore must be enlarged to
-            ## ensure that there is no overlap after deflection.
-            ## Calculate the safety (= IPV enlargement) factor
-            #l_iv = length(iv)
-            #assert(2.0*abs(pos1_orth*pos2_orth) < (l_iv*l_iv))  # That should never fail!
-            #iv_safety = 1.0/( 1.0 - 2.0*abs(pos1_orth*pos2_orth)/(l_iv*l_iv) )
-            ## Recalculate the interparticle vector and new positions
-            #iv_rescaled = iv_safety * iv
-            #pos1 = com - iv_rescaled * (D1 / D_tot)
-            #pos2 = com + iv_rescaled * (D2 / D_tot)
-
-        ## Apply boundary; this will also correctly set the new structure IDs
-        #new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
-        #new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))          
+            new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))               
 
         # TODO: Check that the new positions are in their new planes and 
         # maybe also that pos1 and pos2 are in structure1 in the first place?

From 669ba1be42ea7d731143d284b5fc62d4e4069d04 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 12:06:38 +0200
Subject: [PATCH 1117/1541] Some cleanup in process_single_event() and utils.py

---
 egfrd.py | 53 ++++++++++++++++++++++++++++++-----------------------
 utils.py | 15 ++++++++-------
 2 files changed, 38 insertions(+), 30 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 83ed9c1f..cf380471 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -224,7 +224,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         self.DEFAULT_DT_FACTOR = 1e-5           # Diffusion time prefactor in oldBD algortithm to determine time step.
         
-        self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # The maximum step size in the newBD algorithm is determined as DSSF * sigma_min.  # TESTING was 0.05
+        self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # The maximum step size in the newBD algorithm is determined as DSSF * sigma_min.
                                                 # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
                                                 # reaction volume sticks out of the multi. 
 
@@ -466,9 +466,9 @@ def step(self):
                 # TODO What is best solution here? Usually no prob, -> just let 
                 # user know?
                 if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
-                    #raise RuntimeError('too many dt=zero steps. '
-                    #                   'Simulator halted?'
-                    #                'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
+                    raise RuntimeError('too many dt=zero steps. '
+                                       'Simulator halted?'
+                                    'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
                     log.warning('dt=zero step, working in s.t >> dt~0 Python limit.')
             else:
                 self.zero_steps = 0
@@ -1728,13 +1728,16 @@ def process_single_event(self, single, ignore):
     # produced by a single. The single can be a NonInteractionSingle or an InteractionSingle.
     # Note that this method is also called when a single is bursted, in that case the event
     # is a BURST event.
-    # Note that 'ignore' should already contain the id of 'pair'.
-    # Returns:
-    # - the 'domains' that were the results of the processing. This can be a newly made domain
-    #   (since make_new_domain is also called from here) or zero_singles that are the result of
-    #   the process. Note that these could be many since the event can induce recursive bursting.
-    # - the updated ignore list. This contains the id of the 'single' domain, ids of domains
-    #   bursted in the process and the ids of zero-dt singles.
+    #
+    # Note that 'ignore' should already contain the id of 'single'.
+    #
+    # This method returns:
+    #
+    # - the 'domains' that were created as a result of the processing. This can be a newly made domains
+    #   (since make_new_domain is also called from here) or zero_singles
+    #   Note that these could be many since the event can induce recursive bursting. 
+    # - the updated ignore list. This contains the id of the 'single' domain, IDs of domains
+    #   bursted in the process and the IDs of zero-dt singles.
 
         if __debug__:
 #            # TODO assert that there is no event associated with this domain in the scheduler
@@ -1762,7 +1765,6 @@ def process_single_event(self, single, ignore):
 
 
 
-
         ### NORMAL:
         # Process 'normal' event produced by the single
         else:
@@ -1814,39 +1816,44 @@ def process_single_event(self, single, ignore):
                     log.info('reactant = %s' % single)
 
                 if single.event_type == EventType.SINGLE_REACTION:
-                    self.single_steps[single.event_type] += 1       # TODO counters should also be updated for escape events
+                    self.single_steps[single.event_type] += 1
                     particles, zero_singles_b, ignore = self.fire_single_reaction(single, newpos, struct_id, ignore)
                     # The 'zero_singles_b' list now contains the resulting singles of a putative burst
                     # that occured in fire_single_reaction
 
                 else:
-                    self.interaction_steps[single.event_type] += 1  # TODO similarly here
+                    self.interaction_steps[single.event_type] += 1
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, struct_id, ignore)
 
             else:
                 particles = self.fire_move(single, newpos, struct_id)
-                zero_singles_b = []     # no bursting takes place
-                # ignore is unchanged
+                zero_singles_b = []   # no bursting takes place, ignore list remains unchanged
+                # Update statistics
+                if single.event_type == EventType.SINGLE_ESCAPE:
+                    self.single_steps[single.event_type] += 1
+                    # TODO count burst events ?
+
             domains = zero_singles_b
 
-            ### 5. Make a (new) domain (reuse) domain for each particle(s)
+            ### 5. Make a new domain (or reuse the old one) for each particle(s)
             #      (Re)schedule the (new) domain
             zero_singles = []
             for pid_particle_pair in particles:
-#               single.pid_particle_pair = pid_particle_pair    # reuse single
+#               single.pid_particle_pair = pid_particle_pair         # TODO reuse single
                 zero_single = self.create_single(pid_particle_pair)  # TODO re-use NonInteractionSingle domain if possible
                 self.add_domain_event(zero_single)                   # TODO re-use event if possible
                 zero_singles.append(zero_single)       # Add the newly made zero-dt singles to the list
-                ignore.append(zero_single.domain_id)   # Ignore these newly made singles (cannot be bursted)
+                ignore.append(zero_single.domain_id)   # Ignore these newly made singles (they should not be bursted)
             domains.extend(zero_singles)
 
             ### 6. Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
+            #      For each zero_single the burst radius equals the particle radius * SINGLE_SHELL_FACTOR
             #      Add the resulting zero_singles to the already existing list.
             for zero_single in zero_singles:
-                zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
-                                                              zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                              ignore)
-                domains.extend(zero_singles2)
+                more_zero_singles, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
+                                                                  zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                                  ignore)
+                domains.extend(more_zero_singles)
 
             if __debug__:
                 # check that at least all the zero_singles are on the ignore list
diff --git a/utils.py b/utils.py
index 62c04aaa..44c4ab84 100644
--- a/utils.py
+++ b/utils.py
@@ -29,13 +29,14 @@
 MINIMAL_SEPARATION_FACTOR = 1.0 + TOLERANCE
 
 
-MULTI_SHELL_FACTOR = math.sqrt(3) # MULTI_SHELL_FACTOR should be AT LEAST sqrt(2)
-                                    # This stems from the fact that there vacant space in the cylinder
-                                    # NonInteractionSingles to a Multi and also defines the Multi
-                                    # shell size.
-SINGLE_SHELL_FACTOR = 2.0           # This is the threshold for when the algorithm switches from
-                                    # NonInteractionSingles to a Pair or Interaction. It also defines
-                                    # the radius in which the NonInteractionSingle will burst.
+MULTI_SHELL_FACTOR = math.sqrt(3)   # This factor multiplied with the particle radius decides when to add
+                                    # NonInteractionSingles to a Multi and also defines the Multi shell size.
+                                    # IMPORTANT NOTE: MULTI_SHELL_FACTOR: this should be AT LEAST sqrt(2) !
+                                    # This stems from the fact that there is vacant space in the cylinder
+
+SINGLE_SHELL_FACTOR = 2.0           # This is the threshold for when the algorithm switches from forming
+                                    # NonInteractionSingles to forming a Pair or Interaction. It also defines
+                                    # the radius in which the NonInteractionSingle will burst intruding domains.
 
 if __debug__:
     PRECISION = 7

From 8257c18732bf0a182262652eac5ca2927f648ba2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 12:15:10 +0200
Subject: [PATCH 1118/1541] Also count single burst events in statistics

---
 egfrd.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index cf380471..dde5c9bc 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1831,7 +1831,11 @@ def process_single_event(self, single, ignore):
                 # Update statistics
                 if single.event_type == EventType.SINGLE_ESCAPE:
                     self.single_steps[single.event_type] += 1
-                    # TODO count burst events ?
+                elif single.event_type == EventType.BURST:
+                    self.single_steps[single.event_type] += 1
+                else if __debug__:
+                    log.warning('Omitting to count a single event with unforeseen event type (%s).' % single.event_type)
+                    
 
             domains = zero_singles_b
 

From 20c83090539ddccd397c64b81d2c31fe9f16828f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 13:27:50 +0200
Subject: [PATCH 1119/1541] Re-balance length scales in
 PlanarSurfaceTransitionSingle creation

---
 egfrd.py  | 4 ++--
 shells.py | 2 +-
 utils.py  | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index dde5c9bc..4bd610e7 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1550,7 +1550,7 @@ def make_new_domain(self, single):
         for surface, surface_distance in surface_distances:
             if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):
                 # a transition going from one plane to the next can be initiated from a distance    TODO still not sure this is the right place
-                surface_horizon = single_radius * SINGLE_SHELL_FACTOR * 2        # HACK  to be balanced
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
             elif isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
                 # with a planar or disk surface it is the center of mass that 'looks around'
                 surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
@@ -1833,7 +1833,7 @@ def process_single_event(self, single, ignore):
                     self.single_steps[single.event_type] += 1
                 elif single.event_type == EventType.BURST:
                     self.single_steps[single.event_type] += 1
-                else if __debug__:
+                elif __debug__:
                     log.warning('Omitting to count a single event with unforeseen event type (%s).' % single.event_type)
                     
 
diff --git a/shells.py b/shells.py
index 24a6f5b4..341768df 100755
--- a/shells.py
+++ b/shells.py
@@ -1627,7 +1627,7 @@ def get_min_radius(self):
         # the target surface. Make sure that min_offset > 0.0, because only then it is
         # guaranteed that there is always a certain probability to cross the edge even
         # if the shell with minimal radius is constructed
-        return self.distance_to_target_structure + self.pid_particle_pair[1].radius
+        return self.distance_to_target_structure + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
 
 #####
 class PlanarSurfaceTransitionPairtestShell(SphericaltestShell, testPlanarSurfaceTransitionPair):
diff --git a/utils.py b/utils.py
index 44c4ab84..48769fc5 100644
--- a/utils.py
+++ b/utils.py
@@ -31,12 +31,13 @@
 
 MULTI_SHELL_FACTOR = math.sqrt(3)   # This factor multiplied with the particle radius decides when to add
                                     # NonInteractionSingles to a Multi and also defines the Multi shell size.
-                                    # IMPORTANT NOTE: MULTI_SHELL_FACTOR: this should be AT LEAST sqrt(2) !
+                                    # IMPORTANT NOTE: MULTI_SHELL_FACTOR should be AT LEAST sqrt(2) !
                                     # This stems from the fact that there is vacant space in the cylinder
 
 SINGLE_SHELL_FACTOR = 2.0           # This is the threshold for when the algorithm switches from forming
                                     # NonInteractionSingles to forming a Pair or Interaction. It also defines
                                     # the radius in which the NonInteractionSingle will burst intruding domains.
+                                    # IMPORTANT NOTE: SINGLE_SHELL_FACTOR should be AT_LEAST 2 !
 
 if __debug__:
     PRECISION = 7

From b321ac2467438a289dc5df514c50f1e45a863baa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 14:12:09 +0200
Subject: [PATCH 1120/1541] Basic cleanup in egfrd.py

---
 egfrd.py | 446 ++++++++++++++++++++++++++++++-------------------------
 1 file changed, 247 insertions(+), 199 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4bd610e7..c2964290 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -194,6 +194,7 @@ class EGFRDSimulator(ParticleSimulatorBase):
     object containing particles and structures, and can be attached and detached from
     this 'world'.
     """
+
     def __init__(self, world, rng=myrandom.rng, network_rules=None):
         """Create a new EGFRDSimulator.
 
@@ -261,9 +262,9 @@ def get_next_time(self):
         else:
             return self.scheduler.top[1].time
 
-    ###
-    # The next methods control the general functioning of the simulator
-    ###
+    #####################################################
+    #### METHODS FOR GENERAL SIMULATOR FUNCTIONALITY ####
+    #####################################################
     def reset(self):
         """
         This function resets the "records" of the simulator. This means
@@ -300,6 +301,7 @@ def reset(self):
 
         self.is_dirty = True            # simulator needs to be re-initialized
 
+
     def initialize(self):
         """Initialize the eGFRD simulator
 
@@ -337,6 +339,7 @@ def initialize(self):
         # 3. The simulator is now consistent with 'world'
         self.is_dirty = False
 
+
     def stop(self, t):
         """Bring the simulation to a full stop, which synchronizes all
         particles at time t. The state is similar to the state after
@@ -373,36 +376,38 @@ def stop(self, t):
 
         self.t = t
 
-#        non_single_list = []
+        #non_single_list = []
 
         # Burst all the domains that we know of.
         self.burst_all_domains()
-        # first burst all Singles, and put Pairs and Multis in a list.
-#        for id, event in self.scheduler:
-#        ignore = []
-#        for domain_id, domain in self.domains.items():
-#            if domain_id not in ignore:
-##                domain = self.domains[event.data]
-#                if isinstance(domain, Pair) or isinstance(domain, Multi):
-#                    non_single_list.append(domain)
-#                elif isinstance(domain, Single):
-#                    if __debug__:
-#                        log.debug('burst %s, last_time= %s' % 
-#                                  (domain, FORMAT_DOUBLE % domain.last_time))
-#                    ignore.append(domain.domain_id)
-#                    ignore = self.burst_single(domain, ignore)
-#                else:
-#                    assert False, 'domain from domains{} was no Single, Pair or Multi'
-#
-#
-#        # then burst all Pairs and Multis.
-#        if __debug__:
-#            log.debug('burst %s' % non_single_list)
-#        non_single_ids = [non_single.domain_id for non_single in non_single_list]
-#        self.burst_domains(non_single_ids, ignore)
+
+        ##first burst all Singles, and put Pairs and Multis in a list.
+        #for id, event in self.scheduler:
+        #ignore = []
+        #for domain_id, domain in self.domains.items():
+            #if domain_id not in ignore:
+                  ##domain = self.domains[event.data]
+                #if isinstance(domain, Pair) or isinstance(domain, Multi):
+                    #non_single_list.append(domain)
+                #elif isinstance(domain, Single):
+                    #if __debug__:
+                        #log.debug('burst %s, last_time= %s' % 
+                                  #(domain, FORMAT_DOUBLE % domain.last_time))
+                    #ignore.append(domain.domain_id)
+                    #ignore = self.burst_single(domain, ignore)
+                #else:
+                    #assert False, 'domain from domains{} was no Single, Pair or Multi'
+
+
+        ## then burst all Pairs and Multis.
+        #if __debug__:
+            #log.debug('burst %s' % non_single_list)
+        #non_single_ids = [non_single.domain_id for non_single in non_single_list]
+        #self.burst_domains(non_single_ids, ignore)
 
         self.dt = 0.0
 
+
     def step(self):
         """Execute one eGFRD step.
 
@@ -474,7 +479,9 @@ def step(self):
                 self.zero_steps = 0
 
 
-
+    #####################################
+    #### METHODS FOR DOMAIN CREATION ####
+    #####################################
     def create_single(self, pid_particle_pair):
     # Create a new single domain from a particle.
     # The interaction can be any NonInteractionSingle (SphericalSingle, PlanarSurface or CylindricalSurface
@@ -507,20 +514,20 @@ def create_single(self, pid_particle_pair):
         # 3. update the proper shell container
         self.geometrycontainer.move_shell(single.shell_id_shell_pair)
 
-#        if __debug__:
-#            # Used in __str__.
+        #if __debug__:
+            ## Used in __str__.
         single.world = self.world
 
         return single
 
+
     def create_interaction(self, testShell):
     # Create a new interaction domain from a testShell.
     # The interaction can be any interaction (PlanarSurface or CylindricalSurface). The creation of the testShell was
     # succesful, so here we can just make the domain.
 
-#       assert that the particle is not already associated with another domain
-
         assert isinstance(testShell, testInteractionSingle)
+        # TODO? Assert that the particle is not already associated with another domain
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
         # the scheduler
@@ -549,8 +556,8 @@ def create_interaction(self, testShell):
         # 3. update the shell containers 
         self.geometrycontainer.move_shell(interaction.shell_id_shell_pair)
 
-#        if __debug__:
-#            # Used in __str__.
+        #if __debug__:
+            ## Used in __str__.
         interaction.world = self.world
 
         return interaction
@@ -615,12 +622,13 @@ def create_pair(self, testShell):
         # 3. update the shell containers with the new shell
         self.geometrycontainer.move_shell(pair.shell_id_shell_pair)
 
-#        if __debug__:
-#            # Used in __str__.
+        #if __debug__:
+            ## Used in __str__.
         pair.world = self.world
 
         return pair
 
+
     def create_multi(self):
         # 1. generate necessary id's
         domain_id = self.domain_id_generator()
@@ -634,19 +642,23 @@ def create_multi(self):
         return multi
 
 
-#    def move_single(self, single, position, radius=None):
-#        single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
-#        self.update_single_shell(single, position, radius)
-#
-#    def update_single_shell(self, single, shell):#position, radius=None):
-#        # Reuse shell_id.
-#        shell_id = single.shell_id
-#
-#        # Replace shell.
-#        shell_id_shell_pair = (shell_id, shell) 
-#
-#        single.shell_id_shell_pair = shell_id_shell_pair
-#        self.geometrycontainer.move_shell(shell_id_shell_pair)
+    ##############################################
+    #### METHODS FOR PARTICLE / DOMAIN UPDATE ####
+    ##############################################
+   #def move_single(self, single, position, radius=None):
+       #single.pid_particle_pair = self.move_particle(single.pid_particle_pair, position)
+       #self.update_single_shell(single, position, radius)
+
+   #def update_single_shell(self, single, shell):#position, radius=None):
+       ## Reuse shell_id.
+       #shell_id = single.shell_id
+
+       ## Replace shell.
+       #shell_id_shell_pair = (shell_id, shell) 
+
+       #single.shell_id_shell_pair = shell_id_shell_pair
+       #self.geometrycontainer.move_shell(shell_id_shell_pair)
+
 
     def move_particle(self, pid_particle_pair, position, structure_id):
         # Moves a particle in World and performs the required change of structure_id
@@ -664,6 +676,7 @@ def move_particle(self, pid_particle_pair, position, structure_id):
 
         return new_pid_particle_pair
 
+
     def remove_domain(self, obj):
         # Removes all the ties to a domain (single, pair, multi) from the system.
         # Note that the particles that it represented still exist
@@ -675,7 +688,11 @@ def remove_domain(self, obj):
         for shell_id_shell_pair in obj.shell_list:
             self.geometrycontainer.remove_shell(shell_id_shell_pair)
 
-### TODO These methods can be made methods to the scheduler class
+
+    #######################################
+    #### METHODS FOR EVENT BOOKKEEPING ####
+    #######################################
+    # TODO This method can be made a method to the scheduler class
     def add_domain_event(self, domain):
     # This method makes an event for domain 'domain' in the scheduler.
     # The event will have the domain_id pointing to the appropriate domain in 'domains{}'.
@@ -689,11 +706,15 @@ def add_domain_event(self, domain):
                       FORMAT_DOUBLE % (event_time)))
         domain.event_id = event_id                      # FIXME side effect programming -> unclear!!
 
+
+    # TODO This method can be made a method to the scheduler class
     def remove_event(self, event):
         if __debug__:
             log.info('remove_event: event=#%d' % event.event_id)
         del self.scheduler[event.event_id]
 
+
+    # TODO This method can be made a method to the scheduler class
     def update_domain_event(self, t, domain):
         if __debug__:
             log.info('update_event: %s, event=#%d, t=%s' %
@@ -701,8 +722,9 @@ def update_domain_event(self, t, domain):
         self.scheduler.update((domain.event_id, DomainEvent(t, domain)))
 
 
-
-
+    #####################################
+    #### METHODS FOR DOMAIN BURSTING ####
+    #####################################
     def burst_domain(self, domain, ignore):
     # Reduces 'domain' (Single, Pair or Multi) to 'zero_singles', singles
     # with the zero shell, and dt=0.
@@ -734,6 +756,7 @@ def burst_domain(self, domain, ignore):
 
         return zero_singles, ignore
 
+
     def burst_single(self, single, ignore):
         # Bursts the 'single' domain and updates the 'ignore' list.
         # Returns:
@@ -758,6 +781,7 @@ def burst_single(self, single, ignore):
 
         return self.process_single_event(single, ignore)
 
+
     def burst_pair(self, pair, ignore):
         # Bursts the 'pair' domain and updates the 'ignore' list.
         # Returns:
@@ -782,6 +806,7 @@ def burst_pair(self, pair, ignore):
 
         return self.process_pair_event(pair, ignore)
 
+
     def burst_multi(self, multi, ignore):
         # Bursts the 'multi' domain and updates the 'ignore' list.
         # Returns:
@@ -804,6 +829,7 @@ def burst_multi(self, multi, ignore):
 
         return self.break_up_multi(multi, ignore)
 
+
     def burst_volume(self, pos, radius, ignore=[]):
         """ Burst domains within a certain volume and give their ids.
 
@@ -814,16 +840,18 @@ def burst_volume(self, pos, radius, ignore=[]):
             - pos: position of area to be "bursted"
             - radius: radius of spherical area to be "bursted"
             - ignore: ids of domains that should be ignored, none by default.
-        """ # ~ MW
+        """
         # TODO burst_volume now always assumes a spherical volume to burst.
         # It is inefficient to burst on the 'other' side of the membrane or to
         # burst in a circle, when you want to make a new shell in the membrane.
         # Then we may want to burst in a cylindrical volume, not a sphere.
+        # Same for the 1D particles on rods.
 
         neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius, ignore)
 
         return self.burst_domains(neighbor_ids, ignore)
 
+
     def burst_all_domains(self):
         # Bursts all the domains in the simulator
 
@@ -836,6 +864,7 @@ def burst_all_domains(self):
             assert len(zero_singles) == self.world.num_particles
             assert len(ignore) == (len(all_domains) + self.world.num_particles)
 
+
     def burst_domains(self, domain_ids, ignore=[]):
         # bursts all the domains that are in the list 'domain_ids'
         # ignores all the domain ids on 'ignore'
@@ -857,6 +886,7 @@ def burst_domains(self, domain_ids, ignore=[]):
 
         return zero_singles, ignore
 
+
     def burst_non_multis(self, pos, radius, ignore):
         # Recursively bursts the domains within 'radius' centered around 'pos'
         # Similarly to burst_volume but now doesn't burst all domains.
@@ -905,8 +935,9 @@ def burst_non_multis(self, pos, radius, ignore):
         return zero_singles, ignore
 
 
-
-
+    ####################################
+    #### METHODS FOR EVENT HANDLING ####
+    ####################################
     def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, ignore):
         # This takes care of the identity change when a single particle decays into
         # one or a number of other particles
@@ -1266,6 +1297,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
         return products, zero_singles, ignore
 
+
     def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
         # This takes care of the identity change when a particle associates with a surface.
         # It performs the reactions:
@@ -1313,9 +1345,9 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
             product_structure    = single.target_structure
 
             # TODO make sure that the product species lives on the same type of the interaction surface
-#            product_structure_type = self.world.get_structure(product_species.structure_id)
-#            assert (single.target_structure.sid == self.world.get_structure(product_species.structure_id)), \
-#                   'Product particle should live on the surface of interaction after the reaction.'
+           #product_structure_type = self.world.get_structure(product_species.structure_id)
+           #assert (single.target_structure.sid == self.world.get_structure(product_species.structure_id)), \
+                  #'Product particle should live on the surface of interaction after the reaction.'
 
             # 1.5 get new position and structure_id of particle
             transposed_pos       = self.world.cyclic_transpose(reactant_pos, product_structure.shape.position)
@@ -1425,7 +1457,8 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, reactant1_struc
 
             # 2.  make space for products
             # 2.1 if the product particle sticks out of the shell
-#            if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_radius):
+
+            #if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_radius): # TODO What is that?
             zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
 
             # 3. check that there is space for the products ignoring the reactants
@@ -1498,7 +1531,9 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
         return [moved_reactant]
 
 
-
+    #########################################
+    #### METHODS FOR NEW DOMAIN CREATION ####
+    #########################################
     def make_new_domain(self, single):
         ### Make a new domain out of a NonInteractionSingle that was
         ### just fired
@@ -1510,11 +1545,11 @@ def make_new_domain(self, single):
         # Special case: When D=0, nothing needs to change and only new event
         # time is drawn
         # TODO find nicer construction than just this if statement
-#        if single.getD() == 0:
-#            single.dt, single.event_type = single.determine_next_event() 
-#            single.last_time = self.t
-#            self.add_domain_event(single)
-#            return single
+       #if single.getD() == 0:
+           #single.dt, single.event_type = single.determine_next_event() 
+           #single.last_time = self.t
+           #self.add_domain_event(single)
+           #return single
 
 
         # 0. Get generic info
@@ -1641,27 +1676,28 @@ def make_new_domain(self, single):
 
         return domain
 
-##### Redundant but maybe useful for parts
+
+    #### Redundant but maybe useful for parts
     def calculate_simplepair_shell_size(self, single1, single2):
         # 3. Calculate the maximum based on some other criterium (convergence?)
         radius1 = single1.pid_particle_pair[1].radius
         radius2 = single2.pid_particle_pair[1].radius
         sigma = radius1 + radius2
         distance_from_sigma = r0 - sigma        # the distance between the surfaces of the particles
-#        convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin                # FIXME
-#       max_shell_size = min(max_shell_size, convergence_max)
-
-        # 5. Calculate the 'ideal' shell size, it matches the expected first-passage time of the closest particle
-        # with the expected time of the particles in the pair.
-#        D1 = single1.pid_particle_pair[1].D
-#        D2 = single2.pid_particle_pair[1].D
-#        D12 = D1 + D2
-#
-#        D_closest = closest.pid_particle_pair[1].D
-#        D_tot = D_closest + D12
-#        ideal_shell_size = min((D12 / D_tot) *
-#                            (closest_particle_distance - min_shell_size - closest_min_radius) +
-#                            min_shell_size,
+       #convergence_max = distance_from_sigma * 100 + sigma + shell_size_margin                # FIXME
+      #max_shell_size = min(max_shell_size, convergence_max)
+
+        #5. Calculate the 'ideal' shell size, it matches the expected first-passage time of the closest particle
+        #with the expected time of the particles in the pair.
+       #D1 = single1.pid_particle_pair[1].D
+       #D2 = single2.pid_particle_pair[1].D
+       #D12 = D1 + D2
+
+       #D_closest = closest.pid_particle_pair[1].D
+       #D_tot = D_closest + D12
+       #ideal_shell_size = min((D12 / D_tot) *
+                           #(closest_particle_distance - min_shell_size - closest_min_radius) +
+                           #min_shell_size,
         ideal_shell_size = numpy.inf
         shell_size = min(max_shell_size, ideal_shell_size)
 
@@ -1684,6 +1720,9 @@ def calculate_simplepair_shell_size(self, single1, single2):
             return None, None, None
 
 
+    #################################################
+    #### METHODS FOR EVENT CONSEQUENCES HANDLING ####
+    #################################################
     def update_single(self, single): 
     # updates a NonInteractionSingle given that the single already holds its new position
 
@@ -1740,12 +1779,12 @@ def process_single_event(self, single, ignore):
     #   bursted in the process and the IDs of zero-dt singles.
 
         if __debug__:
-#            # TODO assert that there is no event associated with this domain in the scheduler
-#            assert self.check_domain(single)
+           ## TODO assert that there is no event associated with this domain in the scheduler
+           #assert self.check_domain(single)
             assert (single.domain_id in ignore), \
                    'Domain_id should already be on ignore list before processing event.'
 
-        ### SPECIAL CASE:
+        ### SPECIAL CASE 1:
         # If just need to make new domain.
         if single.is_reset():
             if __debug__:
@@ -1754,7 +1793,7 @@ def process_single_event(self, single, ignore):
             domains = [self.make_new_domain(single)]
             # domain is already scheduled in make_new_domain
 
-        ### SPECIAL CASE:
+        ### SPECIAL CASE 2:
         # In case nothing is scheduled to happen: do nothing and just reschedule
         elif single.dt == numpy.inf:
             if __debug__:
@@ -1763,8 +1802,6 @@ def process_single_event(self, single, ignore):
             self.add_domain_event(single)
             domains = [single]
 
-
-
         ### NORMAL:
         # Process 'normal' event produced by the single
         else:
@@ -1865,20 +1902,18 @@ def process_single_event(self, single, ignore):
 
             ### 7. Log change?
                 
-# NOTE Code snippets to re-use the domain/event
-#
-#        if isinstance(single, InteractionSingle):
-#            # When bursting an InteractionSingle, the domain changes from Interaction
-#           # NonInteraction domain. This needs to be reflected in the event 
-#            self.remove_event(single)
-#            self.add_domain_event(newsingle)
-#        else:
-#            assert single == newsingle
-#            self.update_domain_event(self.t, single)
-#
-#        particle_radius = single.pid_particle_pair[1].radius
-#        assert newsingle.shell.shape.radius == particle_radius
-
+       #NOTE Code snippets to re-use the domain/event
+       #if isinstance(single, InteractionSingle):
+           ## When bursting an InteractionSingle, the domain changes from Interaction
+          ## NonInteraction domain. This needs to be reflected in the event 
+           #self.remove_event(single)
+           #self.add_domain_event(newsingle)
+       #else:
+           #assert single == newsingle
+           #self.update_domain_event(self.t, single)
+
+       #particle_radius = single.pid_particle_pair[1].radius
+       #assert newsingle.shell.shape.radius == particle_radius
 
         return domains, ignore
 
@@ -1931,6 +1966,8 @@ def process_pair_event(self, pair, ignore):
 
 
         ### 3. Process the event produced by the pair
+
+        # Count the event in the event statistics
         self.pair_steps[pair.event_type] += 1
 
         ### 3.1 Get new position and current structures of particles
@@ -1952,8 +1989,8 @@ def process_pair_event(self, pair, ignore):
             struct2_id = pid_particle_pair2[1].structure_id
         # TODO? Check if the new positions are within domain
         # TODO? some more consistency checking of the positions
-##            assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
-##                                       pair.get_shell_size())
+        #     assert self.check_pair_pos(pair, newpos1, newpos2, old_com,
+        #                                pair.get_shell_size())
 
 
         # newpos1/2 now hold the new positions of the particles (not yet committed to the world)
@@ -1972,13 +2009,13 @@ def process_pair_event(self, pair, ignore):
                 # first move the non-reacting particle
                 particles = self.fire_move(single2, newpos2, struct2_id, pid_particle_pair1)
                 # don't ignore the (moved) non-reacting particle
-                particles2, zero_singles_b, ignore = self.fire_single_reaction(single1, newpos1, struct1_id, ignore)
-                particles.extend(particles2)
+                more_particles, zero_singles_b, ignore = self.fire_single_reaction(single1, newpos1, struct1_id, ignore)
+                particles.extend(more_particles)
             else:
                 theothersingle = single1
                 particles = self.fire_move(single1, newpos1, struct1_id, pid_particle_pair2)
-                particles2, zero_singles_b, ignore = self.fire_single_reaction(single2, newpos2, struct2_id, ignore)
-                particles.extend(particles2)
+                more_particles, zero_singles_b, ignore = self.fire_single_reaction(single2, newpos2, struct2_id, ignore)
+                particles.extend(more_particles)
 
             if __debug__:
                 log.info('reactant = %s' % reactingsingle)
@@ -2008,7 +2045,7 @@ def process_pair_event(self, pair, ignore):
 
         # Just moving the particles
         #       3a. IV escape
-        #       3b. com escape
+        #       3b. CoM escape
         elif(pair.event_type == EventType.IV_ESCAPE or
              pair.event_type == EventType.COM_ESCAPE or
              pair.event_type == EventType.BURST):
@@ -2029,51 +2066,51 @@ def process_pair_event(self, pair, ignore):
         else:
             raise SystemError('process_pair_event: invalid event_type.')
 
-# NOTE code snippit to reuse domains that were cached in pair domain
-#        # re-use single domains for particles
-#        # normally we would take the particles + new positions from the old pair
-#        # and use them to make new singles. Now we re-use the singles stored in the
-#        # pair
-#        single1 = pair.single1
-#        single2 = pair.single2
-#        assert single1.domain_id not in self.domains
-#        assert single2.domain_id not in self.domains
-#        single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
-#        single2.pid_particle_pair = pid_particle_pair2
-#
-#        # 'make' the singles
-#        single1.initialize(self.t)
-#        single2.initialize(self.t)
-#        
-#        self.update_single_shell(single1, newpos1, pid_particle_pair1[1].radius)
-#        self.update_single_shell(single2, newpos2, pid_particle_pair2[1].radius)
-#
-#
-#        self.domains[single1.domain_id] = single1
-#        self.domains[single2.domain_id] = single2
-#
-#        # Check the dimensions of the shells of the singles with the shell in the container
-#        if __debug__:
-#            container1 = self.geometrycontainer.get_container(single1.shell)
-#            assert container1[single1.shell_id].shape.radius == \
-#                   single1.shell.shape.radius
-#            if type(single1.shell) is CylindricalShell:
-#                assert container1[single1.shell_id].shape.half_length == \
-#                       single1.shell.shape.half_length
-#
-#            container2 = self.geometrycontainer.get_container(single2.shell)
-#            assert container2[single2.shell_id].shape.radius == \
-#                   single2.shell.shape.radius
-#            if type(single2.shell) is CylindricalShell:
-#                assert container2[single2.shell_id].shape.half_length == \
-#                       single2.shell.shape.half_length
-#
-#        assert single1.shell.shape.radius == pid_particle_pair1[1].radius
-#        assert single2.shell.shape.radius == pid_particle_pair2[1].radius
-#        # even more checking
-#        assert self.check_domain(single1)
-#        assert self.check_domain(single2)
-#        # Now finally we are convinced that the singles were actually made correctly
+       ##NOTE code snippit to reuse domains that were cached in pair domain
+       ## re-use single domains for particles
+       ## normally we would take the particles + new positions from the old pair
+       ## and use them to make new singles. Now we re-use the singles stored in the
+       ## pair
+       #single1 = pair.single1
+       #single2 = pair.single2
+       #assert single1.domain_id not in self.domains
+       #assert single2.domain_id not in self.domains
+       #single1.pid_particle_pair = pid_particle_pair1  # this is probably redundant
+       #single2.pid_particle_pair = pid_particle_pair2
+
+       ## 'make' the singles
+       #single1.initialize(self.t)
+       #single2.initialize(self.t)
+       
+       #self.update_single_shell(single1, newpos1, pid_particle_pair1[1].radius)
+       #self.update_single_shell(single2, newpos2, pid_particle_pair2[1].radius)
+
+
+       #self.domains[single1.domain_id] = single1
+       #self.domains[single2.domain_id] = single2
+
+       ## Check the dimensions of the shells of the singles with the shell in the container
+       #if __debug__:
+           #container1 = self.geometrycontainer.get_container(single1.shell)
+           #assert container1[single1.shell_id].shape.radius == \
+                  #single1.shell.shape.radius
+           #if type(single1.shell) is CylindricalShell:
+               #assert container1[single1.shell_id].shape.half_length == \
+                      #single1.shell.shape.half_length
+
+           #container2 = self.geometrycontainer.get_container(single2.shell)
+           #assert container2[single2.shell_id].shape.radius == \
+                  #single2.shell.shape.radius
+           #if type(single2.shell) is CylindricalShell:
+               #assert container2[single2.shell_id].shape.half_length == \
+                      #single2.shell.shape.half_length
+
+       #assert single1.shell.shape.radius == pid_particle_pair1[1].radius
+       #assert single2.shell.shape.radius == pid_particle_pair2[1].radius
+       ## even more checking
+       #assert self.check_domain(single1)
+       #assert self.check_domain(single2)
+       ## Now finally we are convinced that the singles were actually made correctly
 
 
         # Put the zero singles resulting from putative bursting in fire_... in the final list.
@@ -2085,14 +2122,14 @@ def process_pair_event(self, pair, ignore):
 
         ### 6. Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
         for zero_single in zero_singles:
-            zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
-                                                          zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                          ignore)
+            more_zero_singles, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
+                                                              zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                              ignore)
             # Also add the zero-dt singles from this bursting to the final list
-            zero_singles_fin.extend(zero_singles2)
-
+            zero_singles_fin.extend(more_zero_singles)
 
-        # check that at least all the zero_singles are on the ignore list
+        # Some usefull checks in debugging mode
+        # Check that at least all the zero_singles are on the ignore list
         if __debug__:
             assert all(zero_single.domain_id in ignore for zero_single in zero_singles_fin)
 
@@ -2142,7 +2179,7 @@ def process_multi_event(self, multi, ignore):
 
         if multi.last_event is not EventType.MULTI_DIFFUSION:                # if an event took place
             zero_singles, ignore = self.break_up_multi(multi, ignore)
-#            self.multi_steps[multi.last_event] += 1
+            #self.multi_steps[multi.last_event] += 1
         else:
             multi.last_time = self.t
             self.add_domain_event(multi)
@@ -2151,6 +2188,7 @@ def process_multi_event(self, multi, ignore):
 
         return zero_singles, ignore
 
+
     def break_up_multi(self, multi, ignore):
         # Dissolves 'multi' into zero_singles, single with a zero shell (dt=0)
         # - 'ignore' contains domain ids that should be ignored
@@ -2183,6 +2221,9 @@ def break_up_multi(self, multi, ignore):
         return zero_singles_fin, ignore
 
 
+    ###################################################
+    #### METHODS FOR NEW SHELL CONSTRUCTION TRIALS ####
+    ###################################################
     def try_interaction(self, single, target_structure):
     # Try to form an interaction between the 'single' particle and the 'target_structure'. The interaction can be a:
     # -CylindricalSurfaceInteraction
@@ -2335,6 +2376,9 @@ def try_pair(self, single1, single2):
             return None
     
 
+    ##############################################
+    #### METHODS FOR MULTI SHELL CONSTRUCTION ####
+    ##############################################
     def form_multi(self, single, multi_partners):
         # form a Multi with the 'single'
 
@@ -2497,6 +2541,7 @@ def add_to_multi(self, single, multi):
 
         # TODO maybe also cache the singles in the Multi for reuse?
 
+
     def merge_multis(self, multi1, multi2):
         # merge multi1 into multi2. multi1 will be removed.
         if __debug__:
@@ -2523,6 +2568,9 @@ def merge_multis(self, multi1, multi2):
         self.remove_event(multi1)
 
 
+    ##############################
+    #### SOME HELPER METHODS  ####
+    ##############################
     def domain_distance(self, pos, domain):
         # calculates the shortest distance from 'pos' to A shell (a Multi
         # can have multiple) of 'domain'.
@@ -2530,15 +2578,15 @@ def domain_distance(self, pos, domain):
         return min(self.world.distance(shell.shape, pos)
                    for i, (_, shell) in enumerate(domain.shell_list))
 
+
     def obj_distance_array(self, pos, domains):
         dists = numpy.array([self.domain_distance(pos, domain) for domain in domains])
         return dists
             
 
-    #
-    # statistics reporter
-    #
-
+    ###########################
+    #### STATISTICS REPORT ####
+    ###########################
     def print_report(self, out=None):
         """Print various statistics about the simulation.
         
@@ -2593,10 +2641,10 @@ def print_report(self, out=None):
 
         print >> out, report
 
-    #
-    # consistency checkers
-    #
 
+    ##########################################
+    #### METHODS FOR CONSISTENCY CHECKING ####
+    ##########################################
     def check_domain(self, domain):
         domain.check()
 
@@ -2635,8 +2683,6 @@ def check_domain(self, domain):
             ignores = []
             associated = [domain.structure.id]
 
-
-
         ###### check shell consistency
         # check that shells of the domain don't overlap with surfaces that are not associated with the domain.
         # check that shells of the domain DO overlap with the structures that it is associated with.
@@ -2698,6 +2744,7 @@ def check_domain(self, domain):
 
         return True
 
+
     def check_shape_overlap(self, shape1, shape2):
     # Return the distance between two shapes (positive number means no overlap, negative means overlap)
 
@@ -2811,6 +2858,7 @@ def check_domain_for_all(self):
         for domain in self.domains.itervalues():
             self.check_domain(domain)
 
+
     def check_event_stoichiometry(self):
         ### check scheduler
         # -check that every event on scheduler is associated with domain or is a non domain related event
@@ -2861,27 +2909,27 @@ def check_particle_consistency(self):
             raise RuntimeError('population %d != domain_population %d' %
                                (world_population, domain_population))
 
-#        # Next, check that every particle in the domains is once and only once in the world.
-#        already_in_domain = set()
-#        world_particles = list(self.world)
-#        for domain in self.domains.itervalues():
-#            for domain_particle in domain.particles:
-#                for world_particle in world_particles:
-#                    if domain_particle == world_particle:
-#                        break
-#                else:
-#                    raise RuntimeError('particle %s not in world' % str(domain_particle))
-#
-#                assert domain_particle not in already_in_domain, 'particle %s twice in domains' % str(domain_particle)
-#                already_in_domain.add(domain_particle)
-#
-#        # This now means that all the particles in domains are represented in the world and that
-#        # all the particles in the domains are unique (no particle is represented in two domains)
-#
-#        assert already_in_domain == len(world_particles)
-        # Since the number of particles in the domains is equal to the number of particles in the
-        # world this now also means that all the particles in the world are represented in the
-        # domains.
+       ## Next, check that every particle in the domains is once and only once in the world.
+       #already_in_domain = set()
+       #world_particles = list(self.world)
+       #for domain in self.domains.itervalues():
+           #for domain_particle in domain.particles:
+               #for world_particle in world_particles:
+                   #if domain_particle == world_particle:
+                       #break
+               #else:
+                   #raise RuntimeError('particle %s not in world' % str(domain_particle))
+
+               #assert domain_particle not in already_in_domain, 'particle %s twice in domains' % str(domain_particle)
+               #already_in_domain.add(domain_particle)
+
+       ## This now means that all the particles in domains are represented in the world and that
+       ## all the particles in the domains are unique (no particle is represented in two domains)
+
+       #assert already_in_domain == len(world_particles)
+       ## Since the number of particles in the domains is equal to the number of particles in the
+       ## world this now also means that all the particles in the world are represented in the
+       ## domains.
 
     def check_shell_matrix(self):
         ### checks the consistency between the shells in the geometry container and the domains
@@ -2927,7 +2975,10 @@ def check_shell_matrix(self):
         # This now also means that the shells of all the cached singles in Pairs are not in the containers.
 
 
-# check that all the cached singles in Pairs are not in domains{}.
+#####################################################
+#### TODO: METHODS PROTOTYPES FOR FURTHER CHECKS ####
+#####################################################
+### check that all the cached singles in Pairs are not in domains{}.
 
 ### check world
 # check that particles do not overlap with cylinderical surfaces unless the domain is associated with the surface
@@ -2965,9 +3016,6 @@ def check_shell_matrix(self):
 ### check Interaction
 # check shell.unit_z = +- surface.unit_z
 
-
-
-
 ### check consistency of the model
 # check that the product species of an interaction lives on the interaction surface.
 # check that the product species of a bimolecular reaction lives on either structure of reactant species
@@ -3026,9 +3074,9 @@ def check_pair_pos(self, pair, pos1, pos2, com, radius):
 
         return True
 
-
-
-
+    ##########################
+    #### CHECKLIST METHOD ####
+    ##########################
     def check(self):
         ParticleSimulatorBase.check(self)
 
@@ -3044,10 +3092,10 @@ def check(self):
         
         self.check_domain_for_all()
 
-    #
-    # methods for debugging.
-    #
 
+    ###############################
+    #### METHODS FOR DEBUGGING ####
+    ###############################
     def dump_scheduler(self):
         """Dump scheduler information.
 

From 874dd8944f65311bcfe61d153a33b25855a43b97 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 14:38:10 +0200
Subject: [PATCH 1121/1541] Small changes, mostly readability and comments

---
 StructureContainer.hpp | 24 +++++++++++-------------
 shells.py              | 11 ++++++-----
 2 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index c84f2d95..0f50dc11 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -42,15 +42,13 @@ cyclic_transpose (std::pair<typename Ttraits_::position_type, typename Ttraits_:
 
 
 
-
-
 template <typename Tobj_, typename Tid_, typename Ttraits_>
 class StructureContainer
 {
 public:
-    typedef Tobj_               structure_type;
-    typedef Tid_                structure_id_type;
-    typedef Ttraits_            traits_type;
+    typedef Tobj_                                                                   structure_type;
+    typedef Tid_                                                                    structure_id_type;
+    typedef Ttraits_                                                                traits_type;
     typedef std::set<structure_id_type>                                             structure_id_set;
     typedef std::pair<const structure_id_type, boost::shared_ptr<structure_type> >  structure_id_pair;
     typedef std::map<structure_id_type, boost::shared_ptr<structure_type> >         structure_map;
@@ -61,11 +59,11 @@ class StructureContainer
             typename structure_map::const_iterator>                                 structure_iterator;
     typedef typename std::map<structure_id_type, structure_id_set>                  per_structure_substructure_id_set;
 
-    typedef typename structure_type::length_type                        length_type;
-    typedef typename structure_type::position_type                      position_type;
-    typedef typename structure_type::position_type                      vector_type;
+    typedef typename structure_type::length_type                                    length_type;
+    typedef typename structure_type::position_type                                  position_type;
+    typedef typename structure_type::position_type                                  vector_type;
 
-    typedef std::pair<structure_id_type, vector_type>                   neighbor_id_vector_type;    // FIXME this is actually a datatype of the ConnectivityContainer.
+    typedef std::pair<structure_id_type, vector_type>                               neighbor_id_vector_type; // FIXME this is actually a datatype of the ConnectivityContainer.
 
 public:
     typedef SphericalSurface<traits_type>                                               spherical_surface_type;
@@ -292,7 +290,7 @@ class StructureContainer
         structure_substructures_map_[default_structid] = structure_id_set();
     }
 
-    // The constructor
+//    // The constructor
 //    StructureContainer() {}
 //    StructureContainer(structure_id_type default_structid) : default_structure_id_(default_structid)
 //    {
@@ -369,7 +367,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
 // query the boundary conditions and connectivity.
 {
     // useful typedefs
-    typedef Ttraits_        traits_type;
+    typedef Ttraits_                                        traits_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
 
     typedef typename PlanarSurface<Ttraits_>::shape_type    plane_type;
@@ -472,7 +470,7 @@ cyclic_transpose (std::pair<typename Ttraits_::position_type, typename Ttraits_:
                   StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
 {
     // useful typedefs
-    typedef Ttraits_        traits_type;
+    typedef Ttraits_                                        traits_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
 
     typedef typename PlanarSurface<Ttraits_>::shape_type    plane_type;
@@ -569,7 +567,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
 // to query the boundary conditions and connectivity.
 {
     // useful typedefs
-    typedef Ttraits_        traits_type;
+    typedef Ttraits_                                            traits_type;
     typedef typename traits_type::structure_id_type             structure_id_type;
 
     typedef typename CylindricalSurface<Ttraits_>::shape_type   cylinder_type;
diff --git a/shells.py b/shells.py
index 341768df..03c6c486 100755
--- a/shells.py
+++ b/shells.py
@@ -474,8 +474,8 @@ def do_transform(self):
 
         com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
         com = self.world.apply_boundary(com)
-        # make sure that the com is in the structure of the particle (assume that this is done correctly in
-        # calculate_pair_CoM)
+        # TODO make sure that the com is in the structure of the particle
+        # (assume that this is done correctly in calculate_pair_CoM)
 
         pos2t = self.world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
@@ -488,15 +488,16 @@ def get_min_pair_size(self):
         # SphericalPair          -> size = radius
         # PlanarSurfacePair      -> size = radius
         # CylindricalSurfacePair -> size = half_length
-        # TODO: Make sure this also works correctly when IP-vectors are enlarged to remove overlaps
-        # at deflection.
+
+        # TODO: Make sure this also works correctly when IP-vectors are enlarged to remove
+        # overlaps at deflection.
 
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
 
-        dist_from_com1 = self.r0 * D_1 / self.D_tot      # particle distance from CoM
+        dist_from_com1 = self.r0 * D_1 / self.D_tot     # particle distance from CoM
         dist_from_com2 = self.r0 * D_2 / self.D_tot
         iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
         iv_shell_size2 = dist_from_com2 + radius2

From bc11e3317a34a0d76ae7b763bf5da277c4ab194c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 14:51:24 +0200
Subject: [PATCH 1122/1541] Use AbsAbs Green's Function when k=inf in cap
 interactions / reactions

---
 pair.py   | 5 ++++-
 single.py | 5 ++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 81464874..161aeded 100644
--- a/pair.py
+++ b/pair.py
@@ -1144,7 +1144,10 @@ def com_greens_function(self):
         return GreensFunction1DAbsAbs(self.D_R, self.v_R, 0.0, -self.a_R, self.a_R)
 
     def iv_greens_function(self, r0):
-        return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
+        if( numpy.isinf(self.interparticle_ktot) ):
+            return GreensFunction1DAbsAbs(self.D_r, self.v_r, r0, self.sigma, self.a_r)
+        else:
+            return GreensFunction1DRadAbs(self.D_r, self.v_r, self.interparticle_ktot, r0, self.sigma, self.a_r)
 
     def choose_pair_greens_function(self, r0, t):
         # Todo
diff --git a/single.py b/single.py
index 5171ed8a..8c040bf1 100644
--- a/single.py
+++ b/single.py
@@ -1098,7 +1098,10 @@ def iv_greens_function(self):
         dz_cap = -self.get_inner_dz_left()
         dz_abs = self.get_inner_dz_right()
 
-        return GreensFunction1DRadAbs(self.D, self.v, self.interaction_ktot, 0.0, dz_cap, dz_abs)
+        if( numpy.isinf(self.interaction_ktot) ):
+            return GreensFunction1DAbsAbs(self.D, self.v, 0.0, dz_cap, dz_abs)
+        else:
+            return GreensFunction1DRadAbs(self.D, self.v, self.interaction_ktot, 0.0, dz_cap, dz_abs)
 
     def draw_new_position(self, dt, event_type):
 

From 199cc6d96dcc2504d0d609a00f436715d6fbffac Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 14:54:06 +0200
Subject: [PATCH 1123/1541] Test-disable an unused statement

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 03c6c486..a7a9873a 100755
--- a/shells.py
+++ b/shells.py
@@ -453,7 +453,7 @@ def __init__(self, single1, single2):
                 assert isinstance(single2.structure, PlanarSurface) 
 
         testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
-        self.structure  = self.structure1         # some pair methods might need this to be defined TODO Remove and test
+        #self.structure  = self.structure1         # some pair methods might need this to be defined TODO Remove and test
 
     def get_sigma(self):
         # Nothing changed as compared to the simple pair here

From ded09461a1abd305d770d49fb47d872144f28db6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 15:10:43 +0200
Subject: [PATCH 1124/1541] Small fix in event type statistics acquisition

---
 egfrd.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c2964290..4f7dd84f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1866,10 +1866,9 @@ def process_single_event(self, single, ignore):
                 particles = self.fire_move(single, newpos, struct_id)
                 zero_singles_b = []   # no bursting takes place, ignore list remains unchanged
                 # Update statistics
-                if single.event_type == EventType.SINGLE_ESCAPE:
-                    self.single_steps[single.event_type] += 1
-                elif single.event_type == EventType.BURST:
-                    self.single_steps[single.event_type] += 1
+                if single.event_type == EventType.SINGLE_ESCAPE or\
+                   single.event_type == EventType.BURST:
+                    self.single_steps[single.event_type] += 1                
                 elif __debug__:
                     log.warning('Omitting to count a single event with unforeseen event type (%s).' % single.event_type)
                     

From dd25b21d40c3c4db79249bf6e2aca464b8a2ab90 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 17:29:14 +0200
Subject: [PATCH 1125/1541] Compactify reaction horizon setting

---
 egfrd.py | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4f7dd84f..66e49584 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1582,13 +1582,10 @@ def make_new_domain(self, single):
                 pair_horizon  = (single_radius + domain.pid_particle_pair[1].radius) * SINGLE_SHELL_FACTOR
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
-        for surface, surface_distance in surface_distances:
-            if isinstance(surface, PlanarSurface) and isinstance(single.structure, PlanarSurface):
-                # a transition going from one plane to the next can be initiated from a distance    TODO still not sure this is the right place
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
-            elif isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
-                # with a planar or disk surface it is the center of mass that 'looks around'
-                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)
+        for surface, surface_distance in surface_distances:            
+            if isinstance(surface, PlanarSurface):# or isinstance(surface, DiskSurface):
+                # with a planar surface it is the center of mass that 'looks around'
+                surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)            
             else:
                 # with a cylindrical surface it is the surface of the particle
                 surface_horizon = single_radius * SINGLE_SHELL_FACTOR

From 642e37218418452dccb41e44a5f11b2c43397d10 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 17:29:33 +0200
Subject: [PATCH 1126/1541] Comment out cylinder scaling debug output

---
 shells.py | 55 ++++++++++++++++++++++++++-----------------------------
 1 file changed, 26 insertions(+), 29 deletions(-)

diff --git a/shells.py b/shells.py
index a7a9873a..e6af6c85 100755
--- a/shells.py
+++ b/shells.py
@@ -911,7 +911,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
         if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
             # Quadrant 1
-            print "Quadrant 1"
+            quadrant = 1
 
             # Scale cylinder one until its height is equal to the z-distance minus the radius of the cyl. shell 2;
             # Then check whether any point of the axis of cyl. 2 projected on the top side of cyl. 1 is inside the radius of (scaled) cyl. 1.
@@ -931,7 +931,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
         elif (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 < 0):
             # Quadrant 2
-            print "Quadrant 2"
+            quadrant = 2
 
             # The case scale_angle=0, i.e. radius remaining constant at scaling, has to be treated separately
             # because in this case the mathematics in the standard case misdetect the collision situation
@@ -995,7 +995,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
             # Quadrant 3
-            print "Quadrant 3"
+            quadrant = 3
 
             # The case scale_angle=0, i.e. radius remaining constant at scaling, has to be treated separately
             # because in this case the mathematics in the standard case misdetect the collision situation
@@ -1054,7 +1054,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
         else:
             # Quadrant 4
-            print "Quadrant 4"
+            quadrant = 4
 
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
 
@@ -1108,14 +1108,15 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     h1_min = r1_min/math.tan(scale_angle)
 
         # TODO TESTING Debug info
+        print "  *** QUADRANT = %s ***" % str(quadrant)
+        print "  *** Situation = ", situation_string[situation]
         print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
         print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
         print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
         print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
         print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
 
-        ##### (2) Treat the situation accordingly
-        print "Situation= ", situation_string[situation]
+        ##### (2) Treat the situation accordingly        
         if situation == BARREL_HITS_FLAT:
             # the scaling cylinder hits the flat side of 'shell' with its barrel side
             r_new = min(r, (ref_to_shell_x - shell_half_length))
@@ -1153,7 +1154,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
             else:
 
-                # Check whether to run the rootfinder.
+                # TESTING Code snippet to check whether rootfinder run is necessary
                 # We only want to run it if the radius increase at intersection of the cylinder edges is "significant".
                 # This is sub-optimal but it avoids rootfinder errors caused by the fact that the radius search interval
                 # becomes to small, which is equivalent to the potential r-increase becoming small.
@@ -1210,7 +1211,7 @@ def h1_eq(x):
                     n=1
                     nmax=100
                     h1_eq_product = 1
-                    assert(TOLERANCE<1.0) # TODO Remove this?
+                    assert TOLERANCE>0.0 and TOLERANCE<1.0
                     while h1_eq_product > 0.0:
 
                         h1_interval_start = (1.0+TOLERANCE**n) * (z1_function(scale_center_to_shell_edge_x) - scale_center_z)
@@ -1222,21 +1223,17 @@ def h1_eq(x):
                         if n>nmax:
                             raise testShellError('get_dr_dzright_dzleft_to_CylindricalShape: Could not find suitable rootfinder boundaries in EDGE_HITS_EDGE cylinder scaling. nmax=%s' % str(nmax) )
 
-                    # h1-based VERSION; does not work well...
-                    #h1_interval_start = (1+TOLERANCE)*max(scale_center_to_shell_z - shell_radius, 0.0)
-                    #h1_interval_end   = (1-TOLERANCE)*scale_center_to_shell_z
-
                     assert(h1_interval_start >= 0)
                     assert(h1_interval_end   >= h1_interval_end)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    print "***** NEW ROOTFINDER ITERATION *****"
-                    print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                    print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                    print "  h1_interval_start = %s" % h1_interval_start
-                    print "  h1_interval_end = %s"   % h1_interval_end
-                    print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
-                    print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
+                    #print "***** NEW ROOTFINDER ITERATION *****"
+                    #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                    #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
+                    #print "  h1_interval_start = %s" % h1_interval_start
+                    #print "  h1_interval_end = %s"   % h1_interval_end
+                    #print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
+                    #print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
 
                     h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                     z1_new = min(z1, h_touch)
@@ -1259,7 +1256,7 @@ def r1_eq(x):
                     n=1
                     nmax=100
                     r1_eq_product = 1
-                    assert(TOLERANCE<1.0) # TODO TESTING Remove this?
+                    assert TOLERANCE>0.0 and TOLERANCE<1.0
                     while r1_eq_product > 0.0:
 
                         r1_interval_start = (1.0+TOLERANCE**n) * scale_center_to_shell_edge_x
@@ -1271,20 +1268,20 @@ def r1_eq(x):
                         if n>nmax:
                             raise testShellError('get_dr_dzright_dzleft_to_CylindricalShape: Could not find suitable rootfinder boundaries in EDGE_HITS_EDGE cylinder scaling. nmax=%s' % str(nmax) )
 
-                    # Non-adaptive version
+                    # Non-adaptive version; TODO Remove this after TESTING
                     #r1_interval_start = scale_center_to_shell_edge_x
                     #r1_interval_end   = math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
                     assert(r1_interval_start >= 0)
                     assert(r1_interval_end   >= r1_interval_start)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    print "***** NEW ROOTFINDER ITERATION *****"
-                    print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                    print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                    print "  r1_interval_start = %s" % r1_interval_start
-                    print "  r1_interval_end = %s"   % r1_interval_end
-                    print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
-                    print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
+                    #print "***** NEW ROOTFINDER ITERATION *****"
+                    #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
+                    #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
+                    #print "  r1_interval_start = %s" % r1_interval_start
+                    #print "  r1_interval_end = %s"   % r1_interval_end
+                    #print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
+                    #print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
 
                     r_touch = findroot(r1_eq, r1_interval_start, r1_interval_end)
                               
@@ -2272,7 +2269,7 @@ def get_referencepoint(self):
     def get_min_dr_dzright_dzleft(self):
         dr       = self.shell_radius
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-        dz_right = self.particle_surface_distance + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        dz_right = self.particle_surface_distance + 2*self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):

From 4e1ad8752714e4de93590017c6f456cc634cb5a7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 18:23:03 +0200
Subject: [PATCH 1127/1541] Introduce an important assert

---
 single.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/single.py b/single.py
index 8c040bf1..c1e4c237 100644
--- a/single.py
+++ b/single.py
@@ -1080,9 +1080,12 @@ def get_inner_dz_right(self):
         # towards the absorbing cylinder boundary opposite of the cap.
         # Note that the reference point of the shell is the cap position,
         # therefore we have to subtract particle_surface_distance here.
-        return self.testShell.dz_right - self.testShell.particle_surface_distance \
-                                       - self.pid_particle_pair[1].radius
-        # TODO is shell.dz_right always positive?
+        to_abs_bnd_distance = self.testShell.dz_right \
+                              - self.testShell.particle_surface_distance \
+                              - self.pid_particle_pair[1].radius
+        assert to_abs_bnd_distance >= 0.0
+
+        return to_abs_bnd_distance
 
     def determine_next_event(self):
         """Return an (event_time, event_type)-tuple.

From da2f4cb338976a5f94981c7e8ee9d0e3ef113e0b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 18:23:16 +0200
Subject: [PATCH 1128/1541] Minor cleanup in Multi.hpp

---
 Multi.hpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index c2e379e4..53fa5b59 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -348,8 +348,8 @@ class MultiParticleContainer
                 close_struct_id_distance ? std::make_pair(close_struct_id_distance->at(0).first.second, close_struct_id_distance->at(0).second)
                                          : std::make_pair(get_structure(pp.second.structure_id()), std::numeric_limits<length_type>::max()));
                                          
-//            structure_id_and_distance_pair const struct_id_and_dist( 
-//                get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
+            //structure_id_and_distance_pair const struct_id_and_dist( 
+            //    get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
             
             // If structure is within specified range and this particle lives in the default structure
             //    TODO Extend the last requirement to all "allowed" interactions using the new structure functions
@@ -399,13 +399,13 @@ class MultiParticleContainer
                     if(s0.structure_type_id() != s1.structure_type_id())
                     {
                         if(s0.structure_type_id() == get_def_structure_type_id())
-                            k = 0.001;  // TODO k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+                            k = 0.001;  // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                         else
-                            k = 0.001;  // TODO k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+                            k = 0.001;  // HACK k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                     }
                     else
                     {
-                        k = 0.001;      // TODO k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
+                        k = 0.001;      // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
                     }
                 
                     if ( k_max < k )
@@ -427,7 +427,8 @@ class MultiParticleContainer
        (3) particles escape the multi with a maximum step size in the order of the 
            reaction length. (Dmax * dt ~ (ssf * r_min)**2 ).
        
-       TODO:This function should be a method of the Multi Class, but I put it in the mpc (multi particle container) such that we can use it in python.
+       TODO: This function should be a method of the Multi Class,
+             but I put it in the mpc (multi particle container) such that we can use it in python.
        
        PROBLEM: for certain parameters (large k) dt can be very small and the simulation will slow down.
     */    

From 9dd7ab130f9356ebc5b566081478080aba29a988 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Sep 2012 18:25:10 +0200
Subject: [PATCH 1129/1541] Comment out more debug statements

---
 shells.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index e6af6c85..014dca74 100755
--- a/shells.py
+++ b/shells.py
@@ -1108,13 +1108,13 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     h1_min = r1_min/math.tan(scale_angle)
 
         # TODO TESTING Debug info
-        print "  *** QUADRANT = %s ***" % str(quadrant)
-        print "  *** Situation = ", situation_string[situation]
-        print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
-        print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
-        print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
-        print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
-        print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
+        #print "  *** QUADRANT = %s ***" % str(quadrant)
+        #print "  *** Situation = ", situation_string[situation]
+        #print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
+        #print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
+        #print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
+        #print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
+        #print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
 
         ##### (2) Treat the situation accordingly        
         if situation == BARREL_HITS_FLAT:

From f0231b14fb288534cf70cf647266324eaf532556 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 24 Sep 2012 10:10:58 +0200
Subject: [PATCH 1130/1541] Include a missing attribute into
 PlanarSurfaceTransitiontestShell

---
 pair.py   | 5 +++--
 shells.py | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/pair.py b/pair.py
index 161aeded..c63b1bfe 100644
--- a/pair.py
+++ b/pair.py
@@ -565,10 +565,11 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
                                 # Required by SimplePair.__init__        
         SimplePair.__init__(self, domain_id, shell_id, rrs)     # Always initialize AFTER hasSphericalShell
 
-        # Definitions
+        # extra definitions for the TransitionPair
         self.structure1 = self.testShell.structure1
         self.structure2 = self.testShell.structure2
-        self.structure  = self.testShell.structure1 # just for safety          
+        # self.structure is equal to self.structure1 and inherited from the testShell
+        # and SimplePair
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
diff --git a/shells.py b/shells.py
index 014dca74..d3f7ed5f 100755
--- a/shells.py
+++ b/shells.py
@@ -453,7 +453,7 @@ def __init__(self, single1, single2):
                 assert isinstance(single2.structure, PlanarSurface) 
 
         testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
-        #self.structure  = self.structure1         # some pair methods might need this to be defined TODO Remove and test
+        self.structure  = self.structure1         # some pair methods need this to be defined
 
     def get_sigma(self):
         # Nothing changed as compared to the simple pair here

From 3a40fe142495ac28c9d5910006b7a3883cacdd6d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 26 Sep 2012 15:39:39 +0200
Subject: [PATCH 1131/1541] Comments

---
 egfrd.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 66e49584..b113d045 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1193,6 +1193,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         product_pos_list.append((newpos1, newpos2))
 
                 else:
+                    # TODO TODO TODO Include dissociation from cap with two products TODO TODO TODO
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
@@ -2654,7 +2655,7 @@ def check_domain(self, domain):
             # surfaces.
             ignores = [s.id for s in self.world.structures]
             associated = []
-        elif isinstance(domain, SphericalSingle) or isinstance(domain, SphericalPair) or isinstance(domain, PlanarSurfaceSingle):
+        elif isinstance(domain, SphericalSingle) or isinstance(domain, SphericalPair) or isinstance(domain, PlanarSurfaceSingle): # TODO Why not PlanarSurfacePair ?
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []

From 3e3ef148052d875a76db50267c720f5fa46700c4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 26 Sep 2012 15:40:19 +0200
Subject: [PATCH 1132/1541] Increase SAFETY to overcome some shell collision
 problems

---
 utils.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index 48769fc5..2767b913 100644
--- a/utils.py
+++ b/utils.py
@@ -17,7 +17,8 @@
 ZEROPOS = numpy.array([0., 0., 0.])
 NOWHERE = numpy.array((INF, INF, INF))
 
-SAFETY = 1.0 + 1e-3
+SAFETY = 1.0 + 1e-2     # Lengths of shell in construction are divided by this safety factor 
+                        # to make sure that they do not overlap due to numerical rounding errors
 
 # Tolerance used for float comparison functions. Oversimplifying: two floats a 
 # and b are considered to be equal if abs(a - b) < TOLERANCE * abs(a).

From 2e117cb289edc25319f06b974e609338a7ac65a3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 26 Sep 2012 16:02:07 +0200
Subject: [PATCH 1133/1541] Additional SAFETY application in shellmaking

---
 shells.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index d3f7ed5f..f8a080f8 100755
--- a/shells.py
+++ b/shells.py
@@ -2163,7 +2163,7 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
-        return self.r_right(z_right/SAFETY), z_right/SAFETY, z_left
+        return self.r_right(z_right/SAFETY)/SAFETY, z_right/SAFETY, z_left
 
 #####
 class CylindricalSurfaceInteractiontestShell(CylindricaltestShell, testInteractionSingle):
@@ -2219,7 +2219,7 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
-        return r/SAFETY, self.z_right(r/SAFETY), self.z_left(r/SAFETY)
+        return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, self.z_left(r/SAFETY)/SAFETY
 
 class CylindricalSurfaceCapInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
@@ -2514,8 +2514,8 @@ def r_right(self, z_right):
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
-        SAFETY = 1.1
-        return r/SAFETY, self.z_right(r/SAFETY), z_left
+        SAFETY = 1.1 # FIXME What is that? Why is that not the standard?
+        return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, z_left
 
 class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):
 

From af3081f3ad15bc45d9d7f2373662cf4f00fa930f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 26 Sep 2012 19:11:02 +0200
Subject: [PATCH 1134/1541] Implement unbinding from the disk with two products
 in eGFRD mode

---
 egfrd.py | 38 ++++++++++++++++++++++++++++++--------
 1 file changed, 30 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b113d045..34e4d3bf 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1104,19 +1104,21 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
 
             # 1.5 Get new positions and structure_ids of particles
+            # FIXME     This should be made more elegant, using as much as possible the
+            #           structure functions from the BD mode.
             #     If one of the particle is not on the surface of the reactant.
             if product1_structure_type_id != product2_structure_type_id:
-                # make sure that the reactant was on a 2D or 1D surface
+                # Make sure that the reactant was on a 2D or 1D surface
                 assert reactant_structure_type_id != self.world.get_def_structure_type_id()
-                # make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
+                # Make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
                 assert ((product1_structure_type_id == self.world.get_def_structure_type_id()) ^ \
                         (product2_structure_type_id == self.world.get_def_structure_type_id()))
 
-                # figure out which product stays in the surface and which one goes to 3D
+                # Figure out which product stays in the surface and which one goes to 3D
                 # Note that A is a particle in the surface and B is in the 3D
                 if (product2_structure_type_id == self.world.get_def_structure_type_id()):
                     # product2 goes to 3D and is now particleB (product1 is particleA and is on the surface)
-                    product1_structure_id = reactant_structure_id               # TODO after the displacement the structure can change!
+                    product1_structure_id = reactant_structure_id # TODO after the displacement the structure can change!
                     product2_structure_id = self.world.get_def_structure_id()
                     productA_radius = product1_radius
                     productB_radius = product2_radius
@@ -1192,8 +1194,29 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             newpos1, newpos2 = newposB, newposA
                         product_pos_list.append((newpos1, newpos2))
 
+                elif isinstance(reactant_structure, DiskSurface):
+
+                    product_pos_list = []
+
+                    # productA always must stay on the disk, in the position of the reactant
+                    newposA = reactant_pos
+
+                    # Create the position of the particle that goes into the bulk (productB)
+                    # This is the same as for the single reaction of a disk-bound particle (see above)
+                    vector_length = (productB_radius + max(productA_radius, reactant_structure.shape.radius)) * MINIMAL_SEPARATION_FACTOR
+                    for _ in range(self.dissociation_retry_moves):
+                        unit_vector3D = random_unit_vector()
+                        unit_vector2D = normalize(unit_vector3D - 
+                                        (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
+                        newposB = reactant_pos + vector_length * unit_vector2D                    
+
+                        if default:
+                            newpos1, newpos2 = newposA, newposB
+                        else:
+                            newpos1, newpos2 = newposB, newposA
+                        product_pos_list.append((newpos1, newpos2))
+
                 else:
-                    # TODO TODO TODO Include dissociation from cap with two products TODO TODO TODO
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
@@ -1261,9 +1284,8 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
                 # check that there is space for the products 
                 # Note that we do not check overlap with surfaces -> TODO
-                if (not self.world.check_overlap((newpos1, product1_radius), reactant[0])
-                   and
-                   not self.world.check_overlap((newpos2, product2_radius), reactant[0])):
+                if (not self.world.check_overlap((newpos1, product1_radius), reactant[0]) and \
+                    not self.world.check_overlap((newpos2, product2_radius), reactant[0])):
                     
                     # 4. process the changes (remove particle, make new ones)
                     self.world.remove_particle(reactant[0])

From 12dd578ba7a43af1ed1e7668d6202558e5ff861e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 27 Sep 2012 17:19:04 +0200
Subject: [PATCH 1135/1541] Multiply burst radius by SAFETY because sometimes
 not all domains within the burst radius were detected properly

---
 egfrd.py  | 9 +++++++--
 shells.py | 2 +-
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 34e4d3bf..31aee6d5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1,4 +1,5 @@
 #!/usr/env python
+# -*- coding: utf-8 -*-
 
 from weakref import ref
 import math
@@ -893,9 +894,8 @@ def burst_non_multis(self, pos, radius, ignore):
         # Returns:
         # - the updated list domains that are already bursted -> ignore list
         # - zero_singles that were the result of the burst
-
         # get the neighbors in the burstradius that are not already bursted.
-        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius, ignore)
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, SAFETY*radius, ignore)        
 
         zero_singles = []
         for domain_id in neighbor_ids:
@@ -1915,6 +1915,11 @@ def process_single_event(self, single, ignore):
                                                                   ignore)
                 domains.extend(more_zero_singles)
 
+            # TESTING
+            print "burst_radius = %s, ignore = %s" % (zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR, ignore)
+            print "zero_singles = %s " % zero_singles
+            print "more_zero_singles = %s " % more_zero_singles
+
             if __debug__:
                 # check that at least all the zero_singles are on the ignore list
                 assert all(zero_single.domain_id in ignore for zero_single in domains)
diff --git a/shells.py b/shells.py
index f8a080f8..e5b7d55e 100755
--- a/shells.py
+++ b/shells.py
@@ -1363,7 +1363,7 @@ def r1_eq(x):
 
 def get_radius_to_CylindricalShape(shape, testShell, r):
     # This function returns the radius for the spherical 'testShell' using the cylindrical 'shell' as its closest
-    # neighbor. Note that it returns the minimum the newly calculated radius and the old radius. The 'testShell' can
+    # neighbor. Note that it returns the minimum of the newly calculated radius and the old radius. The 'testShell' can
     # therefore only become smaller.
 
     # Note that the 'shell' is querried from this domain earlier by the testShell.

From a86c34001c836ba00eba7c1450ae7e4128f3e94b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 27 Sep 2012 17:22:03 +0200
Subject: [PATCH 1136/1541] Some cleanup and renaming

---
 egfrd.py | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 31aee6d5..f537acfb 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -881,9 +881,9 @@ def burst_domains(self, domain_ids, ignore=[]):
                 # add the domain_id to the list of domains that is already bursted (ignore list),
                 # and burst the domain.
                 ignore.append(domain_id)
-                zero_singles2, ignore = self.burst_domain(domain, ignore)
+                more_zero_singles, ignore = self.burst_domain(domain, ignore)
                 # add the resulting zero_singles from the burst to the total list of zero_singles.
-                zero_singles.extend(zero_singles2)
+                zero_singles.extend(more_zero_singles)
 
         return zero_singles, ignore
 
@@ -918,9 +918,9 @@ def burst_non_multis(self, pos, radius, ignore):
                     # add the domain_id to the list of domains that is already bursted (ignore list),
                     # and burst the domain.
                     ignore.append(domain_id)
-                    zero_singles2, ignore = self.burst_domain(domain, ignore)
+                    more_zero_singles, ignore = self.burst_domain(domain, ignore)
                     # add the resulting zero_singles from the burst to the total list of zero_singles.
-                    zero_singles.extend(zero_singles2)
+                    zero_singles.extend(more_zero_singles)
 
                 #else:
                     # Don't burst domain if (OR):
@@ -1915,11 +1915,6 @@ def process_single_event(self, single, ignore):
                                                                   ignore)
                 domains.extend(more_zero_singles)
 
-            # TESTING
-            print "burst_radius = %s, ignore = %s" % (zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR, ignore)
-            print "zero_singles = %s " % zero_singles
-            print "more_zero_singles = %s " % more_zero_singles
-
             if __debug__:
                 # check that at least all the zero_singles are on the ignore list
                 assert all(zero_single.domain_id in ignore for zero_single in domains)
@@ -2233,10 +2228,10 @@ def break_up_multi(self, multi, ignore):
 
         ### Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
         for zero_single in zero_singles:
-            zero_singles2, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
-                                                          zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
-                                                          ignore)
-            zero_singles_fin.extend(zero_singles2)
+            more_zero_singles, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
+                                                              zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
+                                                              ignore)
+            zero_singles_fin.extend(more_zero_singles)
 
         # check that at least all the zero_singles are on the ignore list
         if __debug__:

From 2bc299fae37c163bf863425b2f16d2294d15f8f9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 28 Sep 2012 12:17:59 +0200
Subject: [PATCH 1137/1541] Add a very basic spatial histogram of created
 domain types

---
 egfrd.py | 107 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index f537acfb..ba186212 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -245,6 +245,9 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
                                                 # in the simulation system. The id of the domain (domain_id) is the key.
                                                 # The domains can be a single, pair or multi of any type.
 
+        # spatial histograms of domain type creation
+        self.DomainCreationHists = DomainsHistogramCollection(world, nbins=100)
+
         # other stuff
         self.is_dirty = True                    # The simulator is dirty if the state if the simulator is not
                                                 # consistent with the content of the world that it represents
@@ -1694,6 +1697,9 @@ def make_new_domain(self, single):
                 # Form a multi with everything that is in the multi_horizon
                 domain = self.form_multi(single, multi_partners)
 
+            # Update statistics on domain creation
+            self.DomainCreationHists.bin_domain(domain)
+
         return domain
 
 
@@ -3154,3 +3160,104 @@ def count_domains(self):
         ]
 
 
+
+class Histogram3D(object):
+
+    def __init__(self, nbins, dimensions):
+
+        self.nbins      = nbins
+        self.dimensions = dimensions
+        self.histogram  = numpy.zeros(nbins)
+        self.total_cnt  = 0
+
+        self.binsizes   = self.calculate_binsizes()
+
+        self.normalized = False
+
+
+    def calculate_binsizes(self):
+
+        binsizes = numpy.zeros(3)
+
+        for d in [0,1,2]:
+
+            binsizes[d] = 1.0 * self.dimensions[d] / self.nbins[d]
+
+        return binsizes
+
+
+    def bin(self, data):
+
+        index = [-1, -1, -1]
+
+        for d in [0, 1, 2]:
+
+            for b in range(0, self.nbins[d]-1):
+                
+                lb = b * self.binsizes[d]
+                rb = (b+1) * self.binsizes[d]
+
+                if data[d] > lb and data[d] <= rb:
+
+                    index[d] = b
+
+        ilist = [index[0], index[1], index[2]]
+
+        if all([i>=0 and i<=self.nbins for i in ilist]):
+            
+            [ix, iy, iz] = ilist
+            self.histogram[ix][iy][iz] = self.histogram[ix][iy][iz] + 1
+
+            self.total_cnt = self.total_cnt + 1
+
+
+    def normalize(self):
+        # TODO
+        pass   
+    
+
+class DomainsHistogramCollection(object):
+
+    def __init__(self, world, nbins):
+
+        self.world = world
+        self.ws = world.world_size
+
+        self.nbins = nbins
+
+        self.SinglesHistogram   = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+        self.PairsHistogram     = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+        self.MultisHistogram    = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+        self.NonMultisHistogram = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+
+
+    def bin_domain(self, domain):
+
+        if isinstance(domain, Single):
+
+            pos = domain.pid_particle_pair[1].position
+
+            self.SinglesHistogram.bin(pos)
+            self.NonMultisHistogram.bin(pos)
+
+        elif isinstance(domain, Pair):
+
+            pos1 = domain.pid_particle_pair1[1].position
+            pos2 = domain.pid_particle_pair2[1].position
+
+            for pos in [pos1, pos2]:
+                self.PairsHistogram.bin(pos)
+                self.NonMultisHistogram.bin(pos)
+
+        elif isinstance(domain, Multi):
+
+            for pid_particle_pair in domain.particle_container:
+
+                pos = pid_particle_pair[1].position            
+                self.MultisHistogram.bin(pos)
+
+
+    def normalize(self):
+        # TODO
+        pass
+

From 2c41191e1309530bd38a86d1da7cdcf604c31fbe Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 28 Sep 2012 17:27:19 +0200
Subject: [PATCH 1138/1541] Allow user to control histogram binning by debug
 flags

---
 egfrd.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ba186212..fcb0af1a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -246,7 +246,13 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
                                                 # The domains can be a single, pair or multi of any type.
 
         # spatial histograms of domain type creation
-        self.DomainCreationHists = DomainsHistogramCollection(world, nbins=100)
+        self.CREATION_HISTOGRAMS = True
+        self.UPDATES_HISTOGRAMS = False         # Attention, this slows down simulation significantly!
+
+        if self.CREATION_HISTOGRAMS:
+            self.DomainCreationHists = DomainsHistogramCollection(world, nbins=100)
+        if self.UPDATES_HISTOGRAMS:
+            self.DomainUpdatesHists  = DomainsHistogramCollection(world, nbins=100)
 
         # other stuff
         self.is_dirty = True                    # The simulator is dirty if the state if the simulator is not
@@ -448,7 +454,10 @@ def step(self):
                      'Singles: %d, Pairs: %d, Multis: %d\n' % domain_counts + 
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
-       
+
+        if self.UPDATES_HISTOGRAMS:
+            self.DomainUpdatesHists.bin_domain(domain)
+
         # 2. Use the correct method to process (fire) the shell that produced the event
         #
         # Dispatch is a dictionary (hash) of what function to use to fire
@@ -1698,7 +1707,8 @@ def make_new_domain(self, single):
                 domain = self.form_multi(single, multi_partners)
 
             # Update statistics on domain creation
-            self.DomainCreationHists.bin_domain(domain)
+            if self.CREATION_HISTOGRAMS:
+                self.DomainCreationHists.bin_domain(domain)
 
         return domain
 
@@ -3179,7 +3189,7 @@ def calculate_binsizes(self):
 
         binsizes = numpy.zeros(3)
 
-        for d in [0,1,2]:
+        for d in [0, 1, 2]:
 
             binsizes[d] = 1.0 * self.dimensions[d] / self.nbins[d]
 

From 597b8c529a7632afb987c13be5b504f16cd2de6f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 28 Sep 2012 17:31:34 +0200
Subject: [PATCH 1139/1541] Outsource histogram objects into own module

---
 egfrd.py      | 103 +---------------------------------------------
 histograms.py | 112 ++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 114 insertions(+), 101 deletions(-)
 create mode 100644 histograms.py

diff --git a/egfrd.py b/egfrd.py
index fcb0af1a..6475f2e6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3,7 +3,6 @@
 
 from weakref import ref
 import math
-
 import numpy
 
 from _gfrd import (
@@ -63,6 +62,8 @@
 import logging
 import os
 
+from histograms import *
+
 log = logging.getLogger('ecell')
 
 ### Singles
@@ -3171,103 +3172,3 @@ def count_domains(self):
 
 
 
-class Histogram3D(object):
-
-    def __init__(self, nbins, dimensions):
-
-        self.nbins      = nbins
-        self.dimensions = dimensions
-        self.histogram  = numpy.zeros(nbins)
-        self.total_cnt  = 0
-
-        self.binsizes   = self.calculate_binsizes()
-
-        self.normalized = False
-
-
-    def calculate_binsizes(self):
-
-        binsizes = numpy.zeros(3)
-
-        for d in [0, 1, 2]:
-
-            binsizes[d] = 1.0 * self.dimensions[d] / self.nbins[d]
-
-        return binsizes
-
-
-    def bin(self, data):
-
-        index = [-1, -1, -1]
-
-        for d in [0, 1, 2]:
-
-            for b in range(0, self.nbins[d]-1):
-                
-                lb = b * self.binsizes[d]
-                rb = (b+1) * self.binsizes[d]
-
-                if data[d] > lb and data[d] <= rb:
-
-                    index[d] = b
-
-        ilist = [index[0], index[1], index[2]]
-
-        if all([i>=0 and i<=self.nbins for i in ilist]):
-            
-            [ix, iy, iz] = ilist
-            self.histogram[ix][iy][iz] = self.histogram[ix][iy][iz] + 1
-
-            self.total_cnt = self.total_cnt + 1
-
-
-    def normalize(self):
-        # TODO
-        pass   
-    
-
-class DomainsHistogramCollection(object):
-
-    def __init__(self, world, nbins):
-
-        self.world = world
-        self.ws = world.world_size
-
-        self.nbins = nbins
-
-        self.SinglesHistogram   = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
-        self.PairsHistogram     = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
-        self.MultisHistogram    = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
-        self.NonMultisHistogram = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
-
-
-    def bin_domain(self, domain):
-
-        if isinstance(domain, Single):
-
-            pos = domain.pid_particle_pair[1].position
-
-            self.SinglesHistogram.bin(pos)
-            self.NonMultisHistogram.bin(pos)
-
-        elif isinstance(domain, Pair):
-
-            pos1 = domain.pid_particle_pair1[1].position
-            pos2 = domain.pid_particle_pair2[1].position
-
-            for pos in [pos1, pos2]:
-                self.PairsHistogram.bin(pos)
-                self.NonMultisHistogram.bin(pos)
-
-        elif isinstance(domain, Multi):
-
-            for pid_particle_pair in domain.particle_container:
-
-                pos = pid_particle_pair[1].position            
-                self.MultisHistogram.bin(pos)
-
-
-    def normalize(self):
-        # TODO
-        pass
-
diff --git a/histograms.py b/histograms.py
new file mode 100644
index 00000000..65a3cdf3
--- /dev/null
+++ b/histograms.py
@@ -0,0 +1,112 @@
+#!/usr/env python
+
+import math
+import numpy
+
+from single import *
+from pair import *
+from multi import *
+
+__all__ = [ 'Histogram3D', 'DomainsHistogramCollection' ]
+
+
+class Histogram3D(object):
+
+    def __init__(self, nbins, dimensions):
+
+        self.nbins      = nbins
+        self.dimensions = dimensions
+        self.histogram  = numpy.zeros(nbins)
+        self.total_cnt  = 0
+
+        self.binsizes   = self.calculate_binsizes()
+
+        self.normalized = False
+
+
+    def calculate_binsizes(self):
+
+        binsizes = numpy.zeros(3)
+
+        for d in [0, 1, 2]:
+
+            binsizes[d] = 1.0 * self.dimensions[d] / self.nbins[d]
+
+        return binsizes
+
+
+    def bin(self, data):
+
+        index = [-1, -1, -1]
+
+        for d in [0, 1, 2]:
+
+            for b in range(0, self.nbins[d]-1):
+                
+                lb = b * self.binsizes[d]
+                rb = (b+1) * self.binsizes[d]
+
+                if data[d] > lb and data[d] <= rb:
+
+                    index[d] = b
+
+        ilist = [index[0], index[1], index[2]]
+
+        if all([i>=0 and i<=self.nbins for i in ilist]):
+            
+            [ix, iy, iz] = ilist
+            self.histogram[ix][iy][iz] = self.histogram[ix][iy][iz] + 1
+
+            self.total_cnt = self.total_cnt + 1
+
+
+    def normalize(self):
+        # TODO
+        pass   
+    
+
+class DomainsHistogramCollection(object):
+
+    def __init__(self, world, nbins):
+
+        self.world = world
+        self.ws = world.world_size
+
+        self.nbins = nbins
+
+        self.SinglesHistogram   = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+        self.PairsHistogram     = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+        self.MultisHistogram    = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+        self.NonMultisHistogram = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+
+
+    def bin_domain(self, domain):
+
+        if isinstance(domain, Single):
+
+            pos = domain.pid_particle_pair[1].position
+
+            self.SinglesHistogram.bin(pos)
+            self.NonMultisHistogram.bin(pos)
+
+        elif isinstance(domain, Pair):
+
+            pos1 = domain.pid_particle_pair1[1].position
+            pos2 = domain.pid_particle_pair2[1].position
+
+            for pos in [pos1, pos2]:
+                self.PairsHistogram.bin(pos)
+                self.NonMultisHistogram.bin(pos)
+
+        elif isinstance(domain, Multi):
+
+            for pid_particle_pair in domain.particle_container:
+
+                pos = pid_particle_pair[1].position            
+                self.MultisHistogram.bin(pos)
+
+
+    def normalize(self):
+        # TODO
+        pass
+

From a5bcd78361eedaf814eeb3c207c9078b9c486a4f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 28 Sep 2012 17:35:14 +0200
Subject: [PATCH 1140/1541] Replace loop by division in binning to save runtime

---
 histograms.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/histograms.py b/histograms.py
index 65a3cdf3..27077a3f 100644
--- a/histograms.py
+++ b/histograms.py
@@ -41,12 +41,9 @@ def bin(self, data):
 
         for d in [0, 1, 2]:
 
-            for b in range(0, self.nbins[d]-1):
-                
-                lb = b * self.binsizes[d]
-                rb = (b+1) * self.binsizes[d]
+            b = int(data[d] / self.binsizes[d])
 
-                if data[d] > lb and data[d] <= rb:
+            if b > 0 and b < self.nbins[d]-1:
 
                     index[d] = b
 

From 1f2c23b05d45a1857fcf7d6ccd1ac46868381c4b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 28 Sep 2012 18:28:06 +0200
Subject: [PATCH 1141/1541] One more assert

---
 histograms.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/histograms.py b/histograms.py
index 27077a3f..3f40ef8f 100644
--- a/histograms.py
+++ b/histograms.py
@@ -32,6 +32,8 @@ def calculate_binsizes(self):
 
             binsizes[d] = 1.0 * self.dimensions[d] / self.nbins[d]
 
+        assert all([bs>0 for bs in binsizes]), "Cannot work with nonzero binsizes!"
+
         return binsizes
 
 

From c8488813b95712dfe62e74ac5f0f9bfd8414e447 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Oct 2012 14:37:46 +0200
Subject: [PATCH 1142/1541] Add histogram normalization

---
 histograms.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/histograms.py b/histograms.py
index 3f40ef8f..5e828f67 100644
--- a/histograms.py
+++ b/histograms.py
@@ -60,8 +60,16 @@ def bin(self, data):
 
 
     def normalize(self):
-        # TODO
-        pass   
+        
+        binvolume  = self.binsizes[0] * self.binsizes[1] * self.binsizes[3]
+        normfactor = self.total_cnt * binvolume
+
+        for i0 in range(0, self.dimensions[0]):
+          for i1 in range(0, self.dimensions[1]):
+            for i2 in range(0, self.dimensions[2]):
+
+                self.histogram[i0][i1][i2] = self.histogram[i0][i1][i2] / normfactor
+
     
 
 class DomainsHistogramCollection(object):
@@ -106,6 +114,8 @@ def bin_domain(self, domain):
 
 
     def normalize(self):
-        # TODO
-        pass
+        
+        for h in [self.SinglesHistogram, self.PairsHistogram, self.MultisHistogram, self.NonMultisHistogram]:
+
+            h.normalize()
 

From 599f750ec1907c03aea4911257fce712b4b2a9aa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Oct 2012 14:40:39 +0200
Subject: [PATCH 1143/1541] Add two asserts to prevent division by zero and to
 catch cases when domains are not recognized during binning

---
 histograms.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/histograms.py b/histograms.py
index 5e828f67..0a40a73d 100644
--- a/histograms.py
+++ b/histograms.py
@@ -60,6 +60,9 @@ def bin(self, data):
 
 
     def normalize(self):
+
+        assert all([bs>0 for bs in self.binsizes]), "Cannot work with nonzero binsizes!"
+        assert self.total_cnt > 0, "Cannot normalize histogram that does not contain any counts."
         
         binvolume  = self.binsizes[0] * self.binsizes[1] * self.binsizes[3]
         normfactor = self.total_cnt * binvolume
@@ -112,6 +115,9 @@ def bin_domain(self, domain):
                 pos = pid_particle_pair[1].position            
                 self.MultisHistogram.bin(pos)
 
+        else: 
+            raise RuntimeError( "Cannot classify domain type for binning, domain = %s" % str(domain) )
+
 
     def normalize(self):
         

From 64a29549e7b3ca78ed688a9e9066cb329221ae79 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Oct 2012 17:23:08 +0200
Subject: [PATCH 1144/1541] Small index fix

---
 histograms.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/histograms.py b/histograms.py
index 0a40a73d..9c305995 100644
--- a/histograms.py
+++ b/histograms.py
@@ -64,12 +64,12 @@ def normalize(self):
         assert all([bs>0 for bs in self.binsizes]), "Cannot work with nonzero binsizes!"
         assert self.total_cnt > 0, "Cannot normalize histogram that does not contain any counts."
         
-        binvolume  = self.binsizes[0] * self.binsizes[1] * self.binsizes[3]
+        binvolume  = self.binsizes[0] * self.binsizes[1] * self.binsizes[2]
         normfactor = self.total_cnt * binvolume
 
-        for i0 in range(0, self.dimensions[0]):
-          for i1 in range(0, self.dimensions[1]):
-            for i2 in range(0, self.dimensions[2]):
+        for i0 in range(0, self.nbins[0]):
+          for i1 in range(0, self.nbins[1]):
+            for i2 in range(0, self.nbins[2]):
 
                 self.histogram[i0][i1][i2] = self.histogram[i0][i1][i2] / normfactor
 

From 76273d6cfdbeb2e9d862c77c0a16a12e94c7c1f4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Oct 2012 17:35:40 +0200
Subject: [PATCH 1145/1541] Small fix to histogram binning boundaries

---
 histograms.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/histograms.py b/histograms.py
index 9c305995..de34d1a5 100644
--- a/histograms.py
+++ b/histograms.py
@@ -45,7 +45,7 @@ def bin(self, data):
 
             b = int(data[d] / self.binsizes[d])
 
-            if b > 0 and b < self.nbins[d]-1:
+            if b >= 0 and b < self.nbins[d]:
 
                     index[d] = b
 

From 58e2efb8e56264793ea3ec99085e16404ded61c9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Oct 2012 19:14:46 +0200
Subject: [PATCH 1146/1541] More safety checks and exception handling for
 histograms

---
 egfrd.py      | 13 +++++----
 histograms.py | 80 ++++++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 76 insertions(+), 17 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6475f2e6..215dc774 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -248,12 +248,12 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
 
         # spatial histograms of domain type creation
         self.CREATION_HISTOGRAMS = True
-        self.UPDATES_HISTOGRAMS = False         # Attention, this slows down simulation significantly!
+        self.UPDATES_HISTOGRAMS = True          # Attention, this may slow down simulation significantly!
 
         if self.CREATION_HISTOGRAMS:
-            self.DomainCreationHists = DomainsHistogramCollection(world, nbins=100)
+            self.DomainCreationHists = DomainsHistogramCollection(world, nbins=100, name='Creation Histograms Collection')
         if self.UPDATES_HISTOGRAMS:
-            self.DomainUpdatesHists  = DomainsHistogramCollection(world, nbins=100)
+            self.DomainUpdatesHists  = DomainsHistogramCollection(world, nbins=100, name='Updates Histograms Collection')
 
         # other stuff
         self.is_dirty = True                    # The simulator is dirty if the state if the simulator is not
@@ -456,9 +456,6 @@ def step(self):
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
 
-        if self.UPDATES_HISTOGRAMS:
-            self.DomainUpdatesHists.bin_domain(domain)
-
         # 2. Use the correct method to process (fire) the shell that produced the event
         #
         # Dispatch is a dictionary (hash) of what function to use to fire
@@ -466,9 +463,13 @@ def step(self):
         # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
         # e.g. "if class is Single, then process_single_event" ~ MW
         for klass, f in self.dispatch:
+
             if isinstance(domain, klass):
                 f(self, domain, [domain.domain_id])         # fire the correct method for the class (e.g. process_single_event(self, Single))
 
+                if self.UPDATES_HISTOGRAMS:
+                    self.DomainUpdatesHists.bin_domain(domain)
+
         if __debug__:
             if self.scheduler.size == 0:
                 raise RuntimeError('Zero events left.')
diff --git a/histograms.py b/histograms.py
index de34d1a5..9ebbd878 100644
--- a/histograms.py
+++ b/histograms.py
@@ -12,7 +12,9 @@
 
 class Histogram3D(object):
 
-    def __init__(self, nbins, dimensions):
+    def __init__(self, nbins, dimensions, name='noname'):
+
+        self.name       = str(name)
 
         self.nbins      = nbins
         self.dimensions = dimensions
@@ -32,7 +34,8 @@ def calculate_binsizes(self):
 
             binsizes[d] = 1.0 * self.dimensions[d] / self.nbins[d]
 
-        assert all([bs>0 for bs in binsizes]), "Cannot work with nonzero binsizes!"
+        if not all([bs>0 for bs in binsizes]):
+            raise HistogramError('At least one bin size was zero in histogram %s.' % self.__str__() )
 
         return binsizes
 
@@ -61,8 +64,11 @@ def bin(self, data):
 
     def normalize(self):
 
-        assert all([bs>0 for bs in self.binsizes]), "Cannot work with nonzero binsizes!"
-        assert self.total_cnt > 0, "Cannot normalize histogram that does not contain any counts."
+        if not all([bs>0 for bs in self.binsizes]):
+            raise HistogramError('At least one bin size was zero in histogram %s.' % self.__str__() )
+
+        if not self.total_cnt > 0:
+            raise HistogramError('No counts in histogram %s, cannot normalize!' % self.__str__() )
         
         binvolume  = self.binsizes[0] * self.binsizes[1] * self.binsizes[2]
         normfactor = self.total_cnt * binvolume
@@ -73,21 +79,56 @@ def normalize(self):
 
                 self.histogram[i0][i1][i2] = self.histogram[i0][i1][i2] / normfactor
 
+
+    def integrate(self):
+        
+        binvolume  = self.binsizes[0] * self.binsizes[1] * self.binsizes[2]
+
+        I = 0.0
+        for i0 in range(0, self.nbins[0]):
+          for i1 in range(0, self.nbins[1]):
+            for i2 in range(0, self.nbins[2]):
+
+                I = I + self.histogram[i0][i1][i2] * binvolume
+
+        return I
+
+
+    def check(self):
+
+        I = self.integrate()
+
+        if not feq(I, 1.0):
+
+            raise HistogramError( 'Integrated density does not equal 1 in histogram %s; integral = %s.' % (self.__str__(), I) )
+
+
+    def __str__(self):
+
+        if self.name != '':
+
+            return self.name
+
+        else:
+            return 'Histogram3D'
+
     
 
 class DomainsHistogramCollection(object):
 
-    def __init__(self, world, nbins):
+    def __init__(self, world, nbins, name='noname'):
+
+        self.name = name
 
         self.world = world
         self.ws = world.world_size
 
         self.nbins = nbins
 
-        self.SinglesHistogram   = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
-        self.PairsHistogram     = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
-        self.MultisHistogram    = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
-        self.NonMultisHistogram = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws])
+        self.SinglesHistogram   = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws], name='SinglesHistogram')
+        self.PairsHistogram     = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws], name='PairsHistogram')
+        self.MultisHistogram    = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws], name='MultisHistogram')
+        self.NonMultisHistogram = Histogram3D([self.nbins, self.nbins, self.nbins], [self.ws, self.ws, self.ws], name='NonMultisHistogram')
 
 
     def bin_domain(self, domain):
@@ -116,12 +157,29 @@ def bin_domain(self, domain):
                 self.MultisHistogram.bin(pos)
 
         else: 
-            raise RuntimeError( "Cannot classify domain type for binning, domain = %s" % str(domain) )
+            raise HistogramError( 'Cannot classify domain type for binning, domain = %s' % str(domain) )
 
 
     def normalize(self):
         
         for h in [self.SinglesHistogram, self.PairsHistogram, self.MultisHistogram, self.NonMultisHistogram]:
 
-            h.normalize()
+            try:
+
+                h.normalize()
+                h.check()
+
+            except HistogramError as e:
+
+                print "Warning: in %s: %s" % (self.__str__(), str(e))
+
+
+    def __str__(self):
+
+        return 'DomainsHistogramCollection \'' + str(self.name) + '\''
+
+
+
+class HistogramError(Exception):
+    pass
 

From d665c32d5f90f651023b133951c0096391bff26c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Oct 2012 19:49:48 +0200
Subject: [PATCH 1147/1541] Counting of domain updates was not totally correct
 => fix

---
 egfrd.py | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 215dc774..fadbc9a4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1703,14 +1703,22 @@ def make_new_domain(self, single):
             if closest_overlap > 0.0 and not self.BD_ONLY_FLAG : 
                 # just make a normal NonInteractionSingle
                 self.update_single(single)
+                bin_domain = single
+
             else:
                 # An object was closer than the Multi horizon
                 # Form a multi with everything that is in the multi_horizon
                 domain = self.form_multi(single, multi_partners)
+                bin_domain = domain
+
+        else:
 
-            # Update statistics on domain creation
-            if self.CREATION_HISTOGRAMS:
-                self.DomainCreationHists.bin_domain(domain)
+            # A non-Single / non-Multi has been successfully created
+            bin_domain = domain
+
+        # Update statistics on domain creation
+        if self.CREATION_HISTOGRAMS:
+            self.DomainCreationHists.bin_domain(bin_domain)
 
         return domain
 

From 40a491632b8de7956466b3ec741e8004fe354004 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 9 Oct 2012 11:18:54 +0200
Subject: [PATCH 1148/1541] Count cumulative update times for multis and
 nonmultis

---
 egfrd.py | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index fadbc9a4..6985b487 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -305,6 +305,10 @@ def reset(self):
                             EventType.BURST:0,
                             3:0}
         self.zero_steps = 0
+
+        self.multi_time = 0.0
+        self.nonmulti_time = 0.0
+
         self.rejected_moves = 0
         self.reaction_events = 0
         self.last_event = None
@@ -1867,6 +1871,8 @@ def process_single_event(self, single, ignore):
                        'Timeline incorrect. single.last_time = %s, single.dt = %s, self.t = %s' % \
                         (FORMAT_DOUBLE % single.last_time, FORMAT_DOUBLE % single.dt, FORMAT_DOUBLE % self.t)
 
+            self.nonmulti_time += single.dt
+
 
             ### 2. get some necessary information
             pid_particle_pair = single.pid_particle_pair
@@ -1996,6 +2002,8 @@ def process_pair_event(self, pair, ignore):
                     'Timeline incorrect. pair.last_time = %s, pair.dt = %s, self.t = %s' % \
                     (FORMAT_DOUBLE % pair.last_time, FORMAT_DOUBLE % pair.dt, FORMAT_DOUBLE % self.t)
 
+        self.nonmulti_time += pair.dt
+
         ### 2. get some necessary information
         single1 = pair.single1
         single2 = pair.single2
@@ -2215,6 +2223,7 @@ def process_multi_event(self, multi, ignore):
 
         self.multi_steps[multi.last_event] += 1
         self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
+        self.multi_time += multi.dt
         multi.step()
 
         if(multi.last_event == EventType.MULTI_UNIMOLECULAR_REACTION or
@@ -2647,6 +2656,7 @@ def print_report(self, out=None):
 
         report = '''
 t = %g
+\tNonmulti: %g\tMulti: %g
 steps = %d 
 \tSingle:\t%d\t(%.2f %%)\t(escape: %d, reaction: %d, bursted: %d)
 \tInteraction: %d\t(%.2f %%)\t(escape: %d, interaction: %d, bursted: %d)
@@ -2655,7 +2665,7 @@ def print_report(self, out=None):
 total reactions = %d
 rejected moves = %d
 ''' \
-            % (self.t, total_steps,
+            % (self.t, self.nonmulti_time, self.multi_time, total_steps,
                single_steps,
                (100.0*single_steps) / total_steps,
                self.single_steps[EventType.SINGLE_ESCAPE],

From 74ffe9878ad30531a206d331c7ad4c1b87e938a6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 9 Oct 2012 18:42:26 +0200
Subject: [PATCH 1149/1541] Somewhat more tolerant overlap checking

---
 egfrd.py | 45 +++++++++++++++++++++++++++++++--------------
 1 file changed, 31 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6985b487..0154b0e7 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2806,10 +2806,10 @@ def check_shape_overlap(self, shape1, shape2):
         # overlap criterium when one of the shapes is a sphere
         if (type(shape1) is Sphere):
             distance = self.world.distance(shape2, shape1.position)
-            return distance - shape1.radius
+            return (1.0+TOLERANCE)*distance - shape1.radius
         elif (type(shape2) is Sphere):
             distance = self.world.distance(shape1, shape2.position)
-            return distance - shape2.radius
+            return (1.0+TOLERANCE)*distance - shape2.radius
 
         # overlap criterium when one of the shapes is a cylinder and the other is a plane
         elif ((type(shape1) is Cylinder) and (type(shape2) is Plane)) or \
@@ -2824,6 +2824,7 @@ def check_shape_overlap(self, shape1, shape2):
             if math.sqrt(shape1.half_length**2 + shape1.radius**2) < self.world.distance(shape2, shape1.position):
                 # if the plane is outside the sphere surrounding the cylinder.
                 return 1
+
             else: 
                 shape1_pos = shape1.position
                 shape2_pos = shape2.position
@@ -2866,33 +2867,49 @@ def check_shape_overlap(self, shape1, shape2):
             if type(shape2) is Cylinder:                
                 shape2_hl = shape2.half_length
 
+            # Check whether the cylinders are inside the sphere of which the radius is the shortest distance
+            # to the other cylinder; in that case, there cannot be any overlap and we are fine.
             if math.sqrt(shape1_hl**2 + shape1.radius**2) < self.world.distance(shape2, shape1.position) or \
                math.sqrt(shape2_hl**2 + shape2.radius**2) < self.world.distance(shape1, shape2.position):
-                # if cylinder2 is outside the sphere surrounding the cylinder.
+                
                 return 1
-            else: 
+
+            else:
+
+                # Calculate the inter-object vector (inter_pos)
+                # Don't forget the periodic boundary conditions
                 shape1_pos = shape1.position
                 shape2_pos = shape2.position
                 shape1_post = self.world.cyclic_transpose(shape1_pos, shape2_pos)
                 inter_pos = shape1_post - shape2_pos
 
                 relative_orientation = numpy.dot(shape1.unit_z, shape2.unit_z)
-                # if the unit_z of cylinder1 (disk1) is perpendicular to the axis of cylinder2 (disk2).
+
+                # If the unit_z of cylinder1 (disk1) is perpendicular to the axis of cylinder2 (disk2).
                 if feq(relative_orientation, 0.0):
                     return 1                                      # TODO Why does this always return 1 ?
 
-
+                # If the two objects (cylinder or disk) are parallel
                 elif feq(abs(relative_orientation), 1.0):
+
+                    # Calculate the components of the inter-object vector in the COS
+                    # defined by shape2
                     inter_pos_z = shape2.unit_z * numpy.dot(inter_pos, shape2.unit_z)
                     inter_pos_r = inter_pos - inter_pos_z
-                    overlap_r = length(inter_pos_r) - (shape1.radius + shape2.radius)
-                    overlap_z = length(inter_pos_z) - (shape1_hl + shape2_hl)
-                    if (overlap_r <= 0.0) and (overlap_z <= 0.0):
-                        if (overlap_r == 0.0) or (overlap_z == 0.0):
-                            # Special treatment of "direct overlap", i.e. e.g. two overlapping disks
-                            return -1
-                        else:
-                            return -(overlap_r * overlap_z)        # TODO: find better number for overlap measure
+                    overlap_r = (1.0+TOLERANCE)*length(inter_pos_r) - (shape1.radius + shape2.radius)
+                    overlap_z = (1.0+TOLERANCE)*length(inter_pos_z) - (shape1_hl + shape2_hl)
+
+                    if (overlap_r < 0.0) and (overlap_z < 0.0):
+
+                       if length(inter_pos_r) == 0.0: 
+                          total_overlap = overlap_z
+                       elif length(inter_pos_z) == 0.0:
+                          total_overlap = overlap_r
+                       else:
+                          total_overlap = -1.0 * sqrt(overlap_r*overlap_r + overlap_z*overlap_z)
+                        
+                       return total_overlap
+
                     else:
                         return 1
                 else:

From e58a32d0ff34afe3c0a1b0f4f6b285b59bbdd90c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 9 Oct 2012 20:18:26 +0200
Subject: [PATCH 1150/1541] Small fixes to cylindrical single test shells

---
 shells.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/shells.py b/shells.py
index e5b7d55e..89a4272f 100755
--- a/shells.py
+++ b/shells.py
@@ -1944,7 +1944,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
-        # initialize the scaling parameters
+        # Initialize the scaling parameters
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
         self.r0_right   = self.pid_particle_pair[1].radius
@@ -1954,7 +1954,9 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.r0_left    = self.pid_particle_pair[1].radius
         self.z0_left    = 0.0
 
-        # sizing up the shell to a zero shell
+        # Sizing up the shell to a zero shell
+        # Important: leave this as it is, because we always want to construct
+        # a zero-single by default!
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
         self.dr       = self.pid_particle_pair[1].radius
@@ -2016,7 +2018,9 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.r0_left    = self.shell_radius
         self.z0_left    = 0.0
 
-        # sizing up the shell to a zero shell
+        # Sizing up the shell to a zero shell
+        # Important: leave this as it is, because we always want to construct
+        # a zero-single by default!
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
         self.dr       = self.shell_radius
@@ -2034,7 +2038,7 @@ def get_referencepoint(self):
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
         dr       = self.shell_radius
-        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) #  TODO Use SINGLE_SHELL_FACTOR instead?
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         dz_left  = dz_right
         return dr, dz_right, dz_left
         
@@ -2046,7 +2050,7 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
-        return r, z_right/SAFETY, z_left/SAFETY     # TODO this should just be r, z_right, z_left
+        return r, z_right/SAFETY, z_left/SAFETY
 
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, testSimplePair):

From 5388f56f395fc8a10c24e4bb1d504da6118f3c52 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 9 Oct 2012 20:18:50 +0200
Subject: [PATCH 1151/1541] Just a comment in Multi.hpp

---
 Multi.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Multi.hpp b/Multi.hpp
index 53fa5b59..e863cd53 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -400,6 +400,8 @@ class MultiParticleContainer
                     {
                         if(s0.structure_type_id() == get_def_structure_type_id())
                             k = 0.001;  // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+                                        // TODO This is because we do not know the structure here, only structure type
+                                        // Use structure functions here?
                         else
                             k = 0.001;  // HACK k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
                     }

From 6a360fd0b43fba7b49f8fdbf515d4f87487eabe5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 10 Oct 2012 14:51:11 +0200
Subject: [PATCH 1152/1541] Introduce a hard-tunable global factor
 CYLINDER_R_FACTOR to regulate the (constant) radius of rod-based cylindrical
 domains globally

---
 shells.py | 84 +++++++++++++++++++++++++++++++------------------------
 utils.py  |  3 ++
 2 files changed, 51 insertions(+), 36 deletions(-)

diff --git a/shells.py b/shells.py
index 89a4272f..5ab18ce6 100755
--- a/shells.py
+++ b/shells.py
@@ -550,8 +550,8 @@ class hasCylindricalShell(hasShell):
     # This class is inherited by domains that have a Cylindrical shell such as the PlanarSurfaceNonInteractionSingle
     # and a MixedPair2D3D.
     # The class makes the appropriate shell for the domain and allows a testShell to ask what the maximum dimensions
-    # of the testShell can be. This means, how far can the testShell be scaled according to its scaling rules before
-    # it hits THIS Cylindrical shell.
+    # of the testShell can be. This means, how far can (the other) testShell be scaled according to its scaling rules
+    # before it hits THIS Cylindrical shell.
 
     def __init__(self, cylindricaltestShell, domain_id):
         # Note: the hasShell.__init__ is not called because nothing happens there
@@ -585,6 +585,7 @@ def r_zright_zleft_to_r_center_hl(cls, referencepoint, orientation_vector, dr, d
         return center, radius, half_length
 
     def create_new_shell(self, position, radius, half_length, domain_id):
+
         orientation = self.testShell.get_orientation_vector()
         return CylindricalShell(domain_id, Cylinder(position, radius, orientation, half_length))
 
@@ -1945,13 +1946,15 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
         # Initialize the scaling parameters
+        self.dr_const   = self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR
+
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = self.pid_particle_pair[1].radius
+        self.r0_right   = self.dr_const
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = self.pid_particle_pair[1].radius
+        self.r0_left    = self.dr_const
         self.z0_left    = 0.0
 
         # Sizing up the shell to a zero shell
@@ -1974,13 +1977,13 @@ def get_min_dr_dzright_dzleft(self):
         # we need to make sure that the minimal cylinder for the Single fits inside the putative
         # spherical Multi shell.
         # NOTE the MULTI_SHELL_FACTOR should therefore be at least sqrt(2)!!
-        dr       = self.pid_particle_pair[1].radius
+        dr       = self.dr_const
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         dz_left  = dz_right
         return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
-        dr = self.pid_particle_pair[1].radius
+        dr = self.dr_const
         #dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink this
         ##_, (_, pp_dist) = self.structure.project_point(self.get_referencepoint())
         ##assert(pp_dist <= 0.0)
@@ -2008,14 +2011,15 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         #       - dz_left stays constant and is equal to the cap-bound particle radius
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
-        self.shell_radius = max(self.pid_particle_pair[1].radius, self.structure.shape.radius)
+        self.dr_const   = max(self.pid_particle_pair[1].radius*CYLINDER_R_FACTOR, self.structure.shape.radius)
+
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = self.shell_radius
+        self.r0_right   = self.dr_const
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = self.shell_radius
+        self.r0_left    = self.dr_const
         self.z0_left    = 0.0
 
         # Sizing up the shell to a zero shell
@@ -2023,7 +2027,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         # a zero-single by default!
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
-        self.dr       = self.shell_radius
+        self.dr       = self.pid_particle_pair[1].radius
 
     def get_orientation_vector(self):
         return self.structure.shape.unit_z
@@ -2037,14 +2041,14 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
-        dr       = self.shell_radius
+        dr       = self.dr_const
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         # Radius is not scaled here so we do not to check for distance to shape edge
-        dr       = self.shell_radius
+        dr       = self.dr_const
         dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
         dz_left  = dz_right
         return dr, dz_right, dz_left
@@ -2060,13 +2064,15 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         testSimplePair.__init__(self, single1, single2)
 
         # initialize scaling parameters
+        self.dr_const   = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius) * CYLINDER_R_FACTOR
+
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        self.r0_right   = self.dr_const
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        self.r0_left    = self.dr_const
         self.z0_left    = 0.0
 
         # This will determine if the shell is possible.
@@ -2094,18 +2100,18 @@ def get_referencepoint(self):
         return self.com
 
     def get_min_dr_dzright_dzleft(self):
-        dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        dr       = self.dr_const
         dz_right = self.get_min_pair_size()
-        dz_left = dz_right
+        dz_left  = dz_right
         return dr, dz_right, dz_left
 
     def get_max_dr_dzright_dzleft(self):
-        dr = max(self.pid_particle_pair1[1].radius, self.pid_particle_pair2[1].radius)
+        dr          = self.dr_const
 #        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink
-        dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
-#        dz_right      = min(dz_right_sr, dz_right_edge)
-        dz_right      = dz_right_sr
-        dz_left       = dz_right
+        dz_right_sr = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+#        dz_right    = min(dz_right_sr, dz_right_edge)
+        dz_right    = dz_right_sr
+        dz_left     = dz_right
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):
@@ -2239,14 +2245,16 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         #       - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
-        self.shell_radius = max([self.pid_particle_pair[1].radius, self.origin_structure.shape.radius, self.target_structure.shape.radius])
+        self.dr_const   = max([self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR, \
+                               self.origin_structure.shape.radius, self.target_structure.shape.radius])
+
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = self.shell_radius
+        self.r0_right   = self.dr_const
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = self.shell_radius # better put to zero?
+        self.r0_left    = self.dr_const
         self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
 
         # This will determine if the shell is possible.
@@ -2271,13 +2279,13 @@ def get_referencepoint(self):
         return self.reference_point         # calculated in the __init__ of testInteractionSingle
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = self.shell_radius
+        dr       = self.dr_const
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         dz_right = self.particle_surface_distance + 2*self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        dr       = self.shell_radius
+        dr       = self.dr_const
         dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
         # TODO include max distance to other side of rod?
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
@@ -2293,13 +2301,15 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
         # initialize scaling parameters
+        self.dr_const   = self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR
+
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = self.pid_particle_pair[1].radius
+        self.r0_right   = self.dr_const
         self.z0_right   = 0.0
         self.dzdr_left  = self.dzdr_right
         self.drdz_left  = self.drdz_right
-        self.r0_left    = self.r0_right
+        self.r0_left    = self.dr_const
         self.z0_left    = self.z0_right
 
         # This will determine if the shell is possible.
@@ -2334,13 +2344,13 @@ def get_referencepoint(self):
         return self.pid_particle_pair[1].position
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = self.pid_particle_pair[1].radius
+        dr       = self.dr_const
         dz_left  = self.particle_surface_distance + self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
         dz_right = dz_left              # we make the domain to be symmetrical around the particle
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        dr       = self.pid_particle_pair[1].radius
+        dr       = self.dr_const
 #        dz_right_edge = self.origin_structure.min_dist_proj_to_edge(self.get_referencepoint()) # TODO rethink
         dz_right_sr   = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
 #        dz_right      = min(dz_right_sr, dz_right_edge)
@@ -2539,15 +2549,17 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         #       - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
-        self.shell_radius = max([self.cap_particle.radius, self.particle1D.radius,\
-                                 self.cap_structure.shape.radius, self.structure1D.shape.radius])
+        CRF             = CYLINDER_R_FACTOR
+        self.dr_const   = max([CRF * self.cap_particle.radius, CRF * self.particle1D.radius,\
+                               self.cap_structure.shape.radius, self.structure1D.shape.radius])
+
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
-        self.r0_right   = self.shell_radius
+        self.r0_right   = self.dr_const
         self.z0_right   = 0.0
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
-        self.r0_left    = self.shell_radius
+        self.r0_left    = self.dr_const
         self.z0_left    = self.cap_particle.radius * SINGLE_SHELL_FACTOR
 
         # This will determine if the shell is possible.
@@ -2572,13 +2584,13 @@ def get_referencepoint(self):
         return self.cap_structure.shape.position
 
     def get_min_dr_dzright_dzleft(self):
-        dr       = self.shell_radius
+        dr       = self.dr_const
         dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR
         dz_right = self.get_min_pair_size() # TODO make sure this does the right thing!
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
-        dr       = self.shell_radius
+        dr       = self.dr_const
         dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         return dr, dz_right, dz_left
diff --git a/utils.py b/utils.py
index 2767b913..83391703 100644
--- a/utils.py
+++ b/utils.py
@@ -40,6 +40,9 @@
                                     # the radius in which the NonInteractionSingle will burst intruding domains.
                                     # IMPORTANT NOTE: SINGLE_SHELL_FACTOR should be AT_LEAST 2 !
 
+CYLINDER_R_FACTOR = 1.0             # This factor rescales all cylindrical domains constructed on cylindrical
+                                    # surfaces. It should be ALWAYS at least 1.0
+
 if __debug__:
     PRECISION = 7
     FORMAT_DOUBLE = '%.' + str(PRECISION) + 'g'

From f5841a7819203da6c9e87b778194cc70db4f8620 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 10 Oct 2012 15:43:43 +0200
Subject: [PATCH 1153/1541] Increase SINGLE_SHELL_FACTOR to
 2*MULTI_SHELL_FACTOR to avoid the nasty cases in which neither multis nor
 singles can be constructed

---
 utils.py | 30 ++++++++++++++++++------------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/utils.py b/utils.py
index 83391703..ed99a345 100644
--- a/utils.py
+++ b/utils.py
@@ -30,18 +30,24 @@
 MINIMAL_SEPARATION_FACTOR = 1.0 + TOLERANCE
 
 
-MULTI_SHELL_FACTOR = math.sqrt(3)   # This factor multiplied with the particle radius decides when to add
-                                    # NonInteractionSingles to a Multi and also defines the Multi shell size.
-                                    # IMPORTANT NOTE: MULTI_SHELL_FACTOR should be AT LEAST sqrt(2) !
-                                    # This stems from the fact that there is vacant space in the cylinder
-
-SINGLE_SHELL_FACTOR = 2.0           # This is the threshold for when the algorithm switches from forming
-                                    # NonInteractionSingles to forming a Pair or Interaction. It also defines
-                                    # the radius in which the NonInteractionSingle will burst intruding domains.
-                                    # IMPORTANT NOTE: SINGLE_SHELL_FACTOR should be AT_LEAST 2 !
-
-CYLINDER_R_FACTOR = 1.0             # This factor rescales all cylindrical domains constructed on cylindrical
-                                    # surfaces. It should be ALWAYS at least 1.0
+MULTI_SHELL_FACTOR = math.sqrt(3)
+                     # This factor multiplied with the particle radius decides when to add
+                     # NonInteractionSingles to a Multi and also defines the Multi shell size.
+                     # IMPORTANT NOTE: MULTI_SHELL_FACTOR should be AT LEAST sqrt(2) !
+                     # This stems from the fact that there is vacant space in the cylinder
+
+SINGLE_SHELL_FACTOR = 2.0*MULTI_SHELL_FACTOR
+                      # This is the threshold for when the algorithm switches from forming
+                      # NonInteractionSingles to forming a Pair or Interaction. It also defines
+                      # the radius in which the NonInteractionSingle will burst intruding domains.
+                      # IMPORTANT NOTE: SINGLE_SHELL_FACTOR should be AT_LEAST 2 * MULTI_SHELL_FACTOR !
+                      # Otherwise we risk the construction of situations in which two neighbouring
+                      # particles neither can burst nor form a multi nor form a minimal single!
+
+CYLINDER_R_FACTOR = 1.0
+                    # This factor rescales all cylindrical domains constructed on cylindrical
+                    # surfaces. It should be ALWAYS at least 1.0. Keep it at 1.0 if you do not
+                    # know what it does.
 
 if __debug__:
     PRECISION = 7

From cdb5fdc9faf17928820d50ebe0a38644e7d4739f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 10 Oct 2012 15:45:41 +0200
Subject: [PATCH 1154/1541] Add SAFETY to multi horizon calculation and exclude
 burst pairs from check_domain routine

---
 egfrd.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0154b0e7..06ff428e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1599,7 +1599,7 @@ def make_new_domain(self, single):
         reaction_threshold = single_radius * SINGLE_SHELL_FACTOR
 
         # 1.0 Get neighboring domains and surfaces
-        neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])
+        neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])        
         # Get also surfaces but only if the particle is in 3D
         surface_distances = get_neighbor_surfaces(self.world, single_pos, single.structure.id, ignores=[])
 
@@ -1667,8 +1667,9 @@ def make_new_domain(self, single):
             # TODO: combine with first selection such that we have to do this loop only once
             multi_partners = []
             for domain, dist_to_shell in neighbor_distances:
+
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
-                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * MULTI_SHELL_FACTOR
+                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * MULTI_SHELL_FACTOR * SAFETY
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
                     multi_partners.append((domain, distance - multi_horizon))
 
@@ -1676,17 +1677,17 @@ def make_new_domain(self, single):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
                     # So only the horizon and distance of the current single needs to be taken into account
                     # Note: this is built on the assumption that the shell of a Multi has the size of the horizon.
-                    multi_horizon = (single_radius * MULTI_SHELL_FACTOR)
+                    multi_horizon = (single_radius * MULTI_SHELL_FACTOR) * SAFETY
                     multi_partners.append((domain, dist_to_shell - multi_horizon))
 
             # Also add surfaces
             for surface, distance in surface_distances:
                 if isinstance(surface, PlanarSurface):
                     # with a planar surface it is the center of mass that 'looks around'
-                    surface_horizon = single_radius * (MULTI_SHELL_FACTOR - 1.0)
+                    surface_horizon = single_radius * (MULTI_SHELL_FACTOR - 1.0) * SAFETY
                 else:
                     # with a cylindrical surface it is the surface of the particle
-                    surface_horizon = single_radius * MULTI_SHELL_FACTOR
+                    surface_horizon = single_radius * MULTI_SHELL_FACTOR * SAFETY
 
                 multi_partners.append((surface, distance - surface_horizon))
 
@@ -1991,7 +1992,9 @@ def process_pair_event(self, pair, ignore):
         if __debug__:
             assert (pair.domain_id in ignore), \
                    'Domain_id should already be on ignore list before processing event.'
-            assert self.check_domain(pair)
+            if pair.event_type != EventType.BURST:
+                assert self.check_domain(pair)
+                # check only non-bursted domains, because the burst may have been caused by an overlap
             assert pair.single1.domain_id not in self.domains
             assert pair.single2.domain_id not in self.domains
             # TODO assert that there is no event associated with this domain in the scheduler

From 395e915684dd61dd637b1203f0260a907259fd03 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 10 Oct 2012 16:29:26 +0200
Subject: [PATCH 1155/1541] Methods to (de)activate shell creation / updates
 histograms

---
 egfrd.py | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 61 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 06ff428e..4b69a464 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -245,15 +245,20 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
         self.domains = {}                       # a dictionary containing references to the domains that are defined
                                                 # in the simulation system. The id of the domain (domain_id) is the key.
                                                 # The domains can be a single, pair or multi of any type.
+        self.world = world
 
         # spatial histograms of domain type creation
-        self.CREATION_HISTOGRAMS = True
-        self.UPDATES_HISTOGRAMS = True          # Attention, this may slow down simulation significantly!
+        self.CREATION_HISTOGRAMS = False
+        self.UPDATES_HISTOGRAMS  = False        # Attention, this may slow down simulation significantly!
+                                                # Use method self.(de)activate_histograms() to switch this on from an external script       
+        self.DomainCreationHists = None
+        self.DomainUpdatesHists  = None
 
         if self.CREATION_HISTOGRAMS:
-            self.DomainCreationHists = DomainsHistogramCollection(world, nbins=100, name='Creation Histograms Collection')
+            self.activate_histograms('creation')
+
         if self.UPDATES_HISTOGRAMS:
-            self.DomainUpdatesHists  = DomainsHistogramCollection(world, nbins=100, name='Updates Histograms Collection')
+            self.activate_histograms('updates')
 
         # other stuff
         self.is_dirty = True                    # The simulator is dirty if the state if the simulator is not
@@ -2641,9 +2646,9 @@ def obj_distance_array(self, pos, domains):
         return dists
             
 
-    ###########################
-    #### STATISTICS REPORT ####
-    ###########################
+    ####################
+    #### STATISTICS ####
+    ####################
     def print_report(self, out=None):
         """Print various statistics about the simulation.
         
@@ -2700,6 +2705,55 @@ def print_report(self, out=None):
         print >> out, report
 
 
+    def activate_histograms(self, modes=['creation', 'updates']):
+        """ Activate and initialize the shell creation and / or updates histograms.
+
+            The argument is a list containing keywords of the histograms to activate,
+            i.e. 'creation' and/or 'updates'.
+
+            The default is ['creation', 'updates'], i.e. both histograms will be
+            activated.
+
+        """
+        for m in modes:
+
+            log.info('Activating %s histograms ...', str(m))
+
+            if str(m) == 'creation':
+                self.CREATION_HISTOGRAMS = True
+
+            if str(m) == 'updates':
+                self.UPDATES_HISTOGRAMS = True
+
+
+        if self.CREATION_HISTOGRAMS:
+            self.DomainCreationHists = DomainsHistogramCollection(self.world, nbins=100, name='Creation Histograms Collection')
+
+        if self.UPDATES_HISTOGRAMS:
+            self.DomainUpdatesHists = DomainsHistogramCollection(self.world, nbins=100, name='Updates Histograms Collection')
+
+
+    def deactivate_histograms(self, modes=['creation', 'updates']):
+        """ Deactivate the shell creation and / or updates histograms.
+
+            The argument is a list containing keywords of the histograms to activate,
+            i.e. 'creation' and/or 'updates'.
+
+            The default is ['creation', 'updates'], i.e. both histograms will be
+            deactivated.
+
+        """
+        for m in modes:
+
+            log.info('Deactivating %s histograms ...', str(m))
+
+            if str(m) == 'creation':
+                self.CREATION_HISTOGRAMS = False
+
+            if str(m) == 'updates':
+                self.UPDATES_HISTOGRAMS = False
+
+
     ##########################################
     #### METHODS FOR CONSISTENCY CHECKING ####
     ##########################################

From 4353a6e7471132ad5f67b7308e08a6f35c05157b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 10 Oct 2012 16:45:14 +0200
Subject: [PATCH 1156/1541] Revert SAFETY multiplication for multi_horizon for
 now because it will produce non-contingent multis

We have to take care that multi shell radii are also scaled up
in the same way first.

For now we can add safety to the definition of MULTI_SHELL_FACTOR
if we want to.
---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4b69a464..54e4d8d9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1674,7 +1674,7 @@ def make_new_domain(self, single):
             for domain, dist_to_shell in neighbor_distances:
 
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
-                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * MULTI_SHELL_FACTOR * SAFETY
+                    multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * MULTI_SHELL_FACTOR
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
                     multi_partners.append((domain, distance - multi_horizon))
 
@@ -1682,17 +1682,17 @@ def make_new_domain(self, single):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
                     # So only the horizon and distance of the current single needs to be taken into account
                     # Note: this is built on the assumption that the shell of a Multi has the size of the horizon.
-                    multi_horizon = (single_radius * MULTI_SHELL_FACTOR) * SAFETY
+                    multi_horizon = (single_radius * MULTI_SHELL_FACTOR)
                     multi_partners.append((domain, dist_to_shell - multi_horizon))
 
             # Also add surfaces
             for surface, distance in surface_distances:
                 if isinstance(surface, PlanarSurface):
                     # with a planar surface it is the center of mass that 'looks around'
-                    surface_horizon = single_radius * (MULTI_SHELL_FACTOR - 1.0) * SAFETY
+                    surface_horizon = single_radius * (MULTI_SHELL_FACTOR - 1.0)
                 else:
                     # with a cylindrical surface it is the surface of the particle
-                    surface_horizon = single_radius * MULTI_SHELL_FACTOR * SAFETY
+                    surface_horizon = single_radius * MULTI_SHELL_FACTOR
 
                 multi_partners.append((surface, distance - surface_horizon))
 

From 60f4ea8b4218cbd8e7044e7b5e20970ddf5fe800 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 10 Oct 2012 19:29:44 +0200
Subject: [PATCH 1157/1541] Adapt scaling of cap interaction domain to disk
 single domain

---
 shells.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index 5ab18ce6..0eba2bef 100755
--- a/shells.py
+++ b/shells.py
@@ -2255,7 +2255,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
         self.r0_left    = self.dr_const
-        self.z0_left    = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        self.z0_left    = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
@@ -2280,13 +2280,13 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         dr       = self.dr_const
-        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
-        dz_right = self.particle_surface_distance + 2*self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR
+        dz_left  = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        dz_right = self.particle_surface_distance + self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.dr_const
-        dz_left  = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dz_left  = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
         # TODO include max distance to other side of rod?
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
         return dr, dz_right, dz_left

From 146eca210b140d161c2c00a7ca3cbfb3466b5d25 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 11 Oct 2012 19:04:55 +0200
Subject: [PATCH 1158/1541] Basic implementation of a rudimentary load/save
 system

... not yet finished. Output routine almost done.
---
 loadsave.py | 221 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 221 insertions(+)
 create mode 100644 loadsave.py

diff --git a/loadsave.py b/loadsave.py
new file mode 100644
index 00000000..b0bda780
--- /dev/null
+++ b/loadsave.py
@@ -0,0 +1,221 @@
+#!/usr/env python
+
+import math
+import numpy
+
+import ConfigParser as CP
+
+from _gfrd import (
+    Event,
+    EventScheduler,
+    Particle,
+    SphericalShell,
+    CylindricalShell,
+    DomainIDGenerator,
+    ShellIDGenerator,
+    DomainID,
+    ParticleContainer,
+    CuboidalRegion,
+    SphericalSurface,
+    CylindricalSurface,
+    DiskSurface,
+    PlanarSurface,
+    Surface,
+    _random_vector,
+    Cylinder,
+    Disk,
+    Sphere,
+    Plane,
+    NetworkRulesWrapper,
+    )
+
+from gfrdbase import *
+
+__all__ = [ 'save_state', 'load_state' ]
+
+
+
+def save_state(simulator, filename):
+    
+
+    #### DEFINE THE CONFIG PARSER OBJECT ####
+    cp = CP.ConfigParser()
+    cp.optionxform = str # for upper case option names
+
+    # Now add the relevant info in separate sections
+    #### MODEL and WORLD ####
+    cp.add_section('MODEL')
+    cp.set('MODEL', 'world_size', simulator.world.world_size)
+
+    cp.add_section('WORLD')
+    cp.set('WORLD', 'world_size', simulator.world.world_size)
+    cp.set('WORLD', 'matrix_size', simulator.world.matrix_size)
+
+    #### SPECIES ####
+    for species in simulator.get_species():
+
+        id_int = id_to_int(species.id)
+        sectionname = 'SPECIES_' + str(id_int)
+        cp.add_section(sectionname)
+
+        cp.set(sectionname, 'id', id_int)
+        cp.set(sectionname, 'radius', species.radius)
+        cp.set(sectionname, 'D', species.D)
+        cp.set(sectionname, 'v', species.v)
+        cp.set(sectionname, 'structure_type_id', id_to_int(species.structure_type_id))
+
+    #### STRUCTURE TYPES ####
+    structure_type_names = [] # will store the names in a lookup list
+    for structure_type in simulator.get_structure_types():
+
+        id_int = id_to_int(structure_type.id)
+
+        if structure_type['name'] != '' :
+            name = structure_type['name']
+
+        elif id_int == 1 : # the std. structure type
+            name = 'default'
+
+        sectionname = 'STRUCTURETYPE_' + str(id_int)
+        cp.add_section(sectionname)        
+
+        cp.set(sectionname, 'id', id_int)
+        cp.set(sectionname, 'name', name)
+
+        # Remember name for later
+        structure_type_names.append( (id_int, name) )
+
+    #### RULES ####
+    # TODO ...
+    for species in simulator.get_species():
+
+        rules = simulator.network_rules.query_reaction_rule(species)
+        
+
+    #### STRUCTURES ####
+    for structure in simulator.get_structures():
+
+        id_int  = id_to_int(structure.id)
+        sid_int = id_to_int(structure.sid)
+        parent_id_int = id_to_int(structure.structure_id)
+            # the structure_id property of structures is the parent structure id
+
+        # Find the name of the structure type
+        for i, name in structure_type_names:
+            if i == sid_int:
+                st_name = name
+
+        # Find the keyword for the geometric type of this structure
+        for instance, key in structure_keywords:
+            if isinstance(structure, instance):
+                geometry_key = key
+
+        sectionname = 'STRUCTURE_' + geometry_key + '_' + str(id_int)
+        cp.add_section(sectionname)
+
+        cp.set(sectionname, 'id', id_int)
+        cp.set(sectionname, 'parent_id', parent_id_int)
+        cp.set(sectionname, 'structure_type_id', sid_int)
+        cp.set(sectionname, 'structure_type_name', st_name)
+        cp.set(sectionname, 'name', structure.name)
+
+        cp.set(sectionname, 'position', list(structure.shape.position))            
+
+        if isinstance(structure, CuboidalRegion):
+            
+            cp.set(sectionname, 'unit_x', list(structure.shape.unit_x))
+            cp.set(sectionname, 'unit_y', list(structure.shape.unit_y))
+            cp.set(sectionname, 'unit_z', list(structure.shape.unit_z))
+            cp.set(sectionname, 'half_extent', list(structure.shape.half_extent))
+
+        elif isinstance(structure, SphericalSurface):
+
+            cp.set(sectionname, 'radius', structure.shape.radius)
+
+        elif isinstance(structure, CylindricalSurface):
+
+            cp.set(sectionname, 'unit_z', list(structure.shape.unit_z))
+            cp.set(sectionname, 'radius', structure.shape.radius)
+            cp.set(sectionname, 'half_length', structure.shape.half_length)
+
+        elif isinstance(structure, DiskSurface):
+
+            cp.set(sectionname, 'unit_z', list(structure.shape.unit_z))
+            cp.set(sectionname, 'radius', structure.shape.radius)
+
+        elif isinstance(structure, PlanarSurface):
+
+            cp.set(sectionname, 'unit_x', list(structure.shape.unit_x))
+            cp.set(sectionname, 'unit_y', list(structure.shape.unit_y))
+            cp.set(sectionname, 'unit_z', list(structure.shape.unit_z))
+            cp.set(sectionname, 'half_extent', list(structure.shape.half_extent))
+
+
+    #### STRUCTURE LINKS ####
+    # TODO
+
+    #### PARTICLES ####
+    pid_particle_pairs = list(simulator.world)
+    pid_particle_pairs.sort()
+
+    for pp in pid_particle_pairs:
+
+        pid = pp[0]
+        particle = pp[1]
+
+        species_id_int   = id_to_int(particle.sid)
+        structure_id_int = id_to_int(pp[1].structure_id)
+
+        pid_int = id_to_int(pid)
+
+        sectionname = 'PARTICLE_' + str(pid_int)
+        cp.add_section(sectionname)
+
+        cp.set(sectionname, 'id', pid_int)
+        cp.set(sectionname, 'species_id', species_id_int)
+        cp.set(sectionname, 'radius', particle.radius)
+        cp.set(sectionname, 'D', particle.D)
+        cp.set(sectionname, 'v', particle.v)
+        cp.set(sectionname, 'position', list(particle.position))
+        cp.set(sectionname, 'structure_id', structure_id_int)
+
+
+    #### WRITE FILE ####
+    with open(filename, 'wb') as outfile:
+        cp.write(outfile)
+
+
+
+def load_state(simulator, filename):
+
+    pass
+
+
+def id_to_int(ID):
+    """ Strips an eGFRD-type ID-specifier off everything
+        but the integer ID numbers.
+
+        I.e., PID(0:2) for example will be converted to 2.
+
+        TODO Is the first number entry not important, too?
+    """
+
+    p = str(ID).partition(':')
+
+    if p[2] != '':
+        q = p[2].partition(')')
+
+    if q[0] != '':
+        return int(q[0])
+
+    else:
+        raise RuntimeError('Could not extract number, probably the argument is not a valid ID.')
+
+
+structure_keywords = [
+        (CuboidalRegion,     'CUBE'),
+        (SphericalSurface,   'SPHERE'),
+        (CylindricalSurface, 'CYLINDER'),
+        (DiskSurface,        'DISK'),
+        (PlanarSurface,      'PLANE')
+        ]
\ No newline at end of file

From c4ed5538c54671c0a831daa166d151e0d01b0b05 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 11 Oct 2012 19:06:06 +0200
Subject: [PATCH 1159/1541] Wrappers for load_state and save_state in egfrd.py

... in order to make these methods of the EGFRDSimulator.

Here we can later impose pre-output bursting of all domains,
for example.
---
 egfrd.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index 54e4d8d9..fdd69cf1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -62,6 +62,7 @@
 import logging
 import os
 
+import loadsave
 from histograms import *
 
 log = logging.getLogger('ecell')
@@ -3222,6 +3223,22 @@ def check(self):
         self.check_domain_for_all()
 
 
+    ########################################
+    #### METHODS FOR LOADING AND SAVING ####
+    ########################################
+    # These are just wrappers around the methods
+    # in loadsave.py :
+
+    def save_state(self, filename):
+
+        loadsave.save_state(self, filename)
+
+
+    def load_state(self, filename):
+
+        loadsave.load_state(self, filename)
+
+
     ###############################
     #### METHODS FOR DEBUGGING ####
     ###############################

From 941d74f1ac3fc6e375a2da157b37fafd040cf97f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 11 Oct 2012 19:07:02 +0200
Subject: [PATCH 1160/1541] Some newly needed getters in gfrdbase.py

---
 gfrdbase.py | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/gfrdbase.py b/gfrdbase.py
index d163f33d..3b2dc540 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -542,6 +542,31 @@ def get_species(self):
         """ #TODO: Added by wehrens@amolf.nl; please revise
         return self.world.species
 
+    def get_structure_types(self):
+        """
+        Return an iterator over the StructureTypes in the simulator.
+
+        Structure types basically have only an id and a name, the
+        latter of which is accessible via a dictionary lookup:
+
+        e.g. structure_type['name'] = 'membrane'
+        
+        Arguments: 
+            - sim an EGFRDSimulator. 
+        
+        """
+        return self.world.structure_types
+
+    def get_structures(self):
+        """
+        Return an iterator over the Structures in the simulator.        
+        
+        Arguments: 
+            - sim an EGFRDSimulator. 
+        
+        """
+        return self.world.structures
+
     def get_first_pid(self, sid):
         """
         Returns the first particle ID of a certain species.

From 871d71aaa60a1e756bb7735e01ef6bd5c2ac19a9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 11 Oct 2012 20:10:13 +0200
Subject: [PATCH 1161/1541] Make get_neighbor_info method of connectivity
 container accessible in Python

---
 World.hpp         | 23 +++++++++++++++++------
 binding/World.hpp |  4 +++-
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/World.hpp b/World.hpp
index 4e815214..fbcd6261 100644
--- a/World.hpp
+++ b/World.hpp
@@ -223,13 +223,13 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename traits_type::structure_type_id_type    structure_type_id_type;
 
     //
-    typedef typename base_type::particle_id_pair                            particle_id_pair;      // defines the pid_particle_pair tuple
-    typedef typename base_type::structure_id_pair                           structure_id_pair;
-    typedef std::pair<position_type, length_type>                           projected_type;
+    typedef typename base_type::particle_id_pair                    particle_id_pair;      // defines the pid_particle_pair tuple
+    typedef typename base_type::structure_id_pair                   structure_id_pair;
+    typedef std::pair<position_type, length_type>                   projected_type;
 
-    typedef typename base_type::particle_id_set                             particle_id_set;
-    typedef typename base_type::structure_id_set                            structure_id_set;
-    typedef typename base_type::structure_types_range                       structure_types_range;
+    typedef typename base_type::particle_id_set                     particle_id_set;
+    typedef typename base_type::structure_id_set                    structure_id_set;
+    typedef typename base_type::structure_types_range               structure_types_range;
 
     typedef typename base_type::cuboidal_region_type                cuboidal_region_type;
     typedef typename base_type::planar_surface_type                 planar_surface_type;
@@ -238,6 +238,9 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     typedef typename base_type::spherical_surface_type              spherical_surface_type;
     typedef typename planar_surface_type::side_enum_type            planar_surface_side_type;
     typedef typename cylindrical_surface_type::side_enum_type       cylindrical_surface_side_type;
+    
+    typedef typename structure_type::position_type                  vector_type;
+    typedef std::pair<structure_id_type, vector_type>               neighbor_id_vector_type;
 
 protected:
     typedef std::map<species_id_type, species_type>                         species_map;
@@ -418,12 +421,20 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         //  -only remove if no particles
         return base_type::remove_structure(id);
     }
+    
+    // Connectivity related stuff
     template <typename Tstructure_, typename Tside_enum_>
     bool connect_structures(Tstructure_ const& structure1, Tside_enum_ const& side1,
                             Tstructure_ const& structure2, Tside_enum_ const& side2)
     {
         return base_type::structures_.connect_structures(structure1, side1, structure2, side2);
     }
+    
+    template <typename Tstructure_, typename Tside_enum_>
+    neighbor_id_vector_type get_neighbor_info(Tstructure_ const& structure, Tside_enum_ side)
+    {
+        return base_type::structures_.get_neighbor_info(structure, side);
+    }
 
     // Get all the structure ids by structure_type id
     structure_id_set get_structure_ids(structure_type_id_type const& sid) const
diff --git a/binding/World.hpp b/binding/World.hpp
index 6325ba1a..da78145b 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -414,7 +414,9 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("add_structure", &impl_type::template add_structure<typename impl_type::spherical_surface_type>)
         .def("connect_structures", &impl_type::template connect_structures<typename impl_type::planar_surface_type,      int>)
         .def("connect_structures", &impl_type::template connect_structures<typename impl_type::cylindrical_surface_type, int>)
-        .def("set_def_structure", &impl_type::set_def_structure)
+        .def("get_neighbor_info",  &impl_type::template get_neighbor_info<typename impl_type::planar_surface_type,      int>)
+        .def("get_neighbor_info",  &impl_type::template get_neighbor_info<typename impl_type::cylindrical_surface_type, int>)
+        .def("set_def_structure",  &impl_type::set_def_structure)
         // StructureType stuff
         .def("add_structure_type", &impl_type::add_structure_type)
         .def("set_def_structure_type_id", &impl_type::set_def_structure_type_id)

From 005da8e679859354f2ac8603c485fb5719c4c0d1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 11 Oct 2012 20:27:51 +0200
Subject: [PATCH 1162/1541] Bind a version with simpler return type

... until we have an appropriate type converter.
---
 World.hpp         | 6 ++++++
 binding/World.hpp | 3 +++
 2 files changed, 9 insertions(+)

diff --git a/World.hpp b/World.hpp
index fbcd6261..63b6ffa1 100644
--- a/World.hpp
+++ b/World.hpp
@@ -435,6 +435,12 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     {
         return base_type::structures_.get_neighbor_info(structure, side);
     }
+    
+    template <typename Tstructure_, typename Tside_enum_>
+    structure_id_type get_neighbor_id(Tstructure_ const& structure, Tside_enum_ side)
+    {
+        return base_type::structures_.get_neighbor_info(structure, side).first;
+    }
 
     // Get all the structure ids by structure_type id
     structure_id_set get_structure_ids(structure_type_id_type const& sid) const
diff --git a/binding/World.hpp b/binding/World.hpp
index da78145b..f806a6d3 100644
--- a/binding/World.hpp
+++ b/binding/World.hpp
@@ -416,6 +416,9 @@ inline boost::python::objects::class_base register_world_class(char const* name)
         .def("connect_structures", &impl_type::template connect_structures<typename impl_type::cylindrical_surface_type, int>)
         .def("get_neighbor_info",  &impl_type::template get_neighbor_info<typename impl_type::planar_surface_type,      int>)
         .def("get_neighbor_info",  &impl_type::template get_neighbor_info<typename impl_type::cylindrical_surface_type, int>)
+              // TODO get_neighbor_info still needs a type converter to work properly!
+        .def("get_neighbor_id",    &impl_type::template get_neighbor_id<typename impl_type::planar_surface_type,      int>)
+        .def("get_neighbor_id",    &impl_type::template get_neighbor_id<typename impl_type::cylindrical_surface_type, int>)
         .def("set_def_structure",  &impl_type::set_def_structure)
         // StructureType stuff
         .def("add_structure_type", &impl_type::add_structure_type)

From f8bb8d6c7927dffa7538f154745fc74a2628bcbb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 11 Oct 2012 20:37:45 +0200
Subject: [PATCH 1163/1541] Save plane connectivity information

---
 loadsave.py | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index b0bda780..116b24f4 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -151,8 +151,22 @@ def save_state(simulator, filename):
             cp.set(sectionname, 'half_extent', list(structure.shape.half_extent))
 
 
-    #### STRUCTURE LINKS ####
-    # TODO
+    #### STRUCTURE CONNECTIVITY ####
+    for structure in simulator.get_structures():
+
+        if isinstance(structure, PlanarSurface):
+
+            id_int  = id_to_int(structure.id)
+
+            sectionname = 'STRUCTURECONNECTION_' + str(id_int)
+            cp.add_section(sectionname)
+
+            for n in range(0, 4):
+
+                nid = simulator.world.get_neighbor_id(structure, n)
+                nid_int  = id_to_int(nid)
+
+                cp.set(sectionname, 'neighbor'+str(n), nid_int)
 
     #### PARTICLES ####
     pid_particle_pairs = list(simulator.world)

From e9cd9c7d4e40bf867b797d68395be9539db385ea Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 15:13:13 +0200
Subject: [PATCH 1164/1541] Output reaction network when saving state

---
 loadsave.py | 116 ++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 108 insertions(+), 8 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 116b24f4..7264ae28 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -86,11 +86,105 @@ def save_state(simulator, filename):
         structure_type_names.append( (id_int, name) )
 
     #### RULES ####
-    # TODO ...
-    for species in simulator.get_species():
+    extracted_rules = []  # to avoid double-extraction
+    for species0 in simulator.get_species():
 
-        rules = simulator.network_rules.query_reaction_rule(species)
+        # Reactions with one reactant (unimolecular or unbinding)
+        rules = simulator.network_rules.query_reaction_rule(species0)
         
+        for rr in rules:
+
+              if not rr.id in extracted_rules:
+
+                  rate = rr.k
+
+                  r0 = rr.reactants[0]
+                  reactant_ids = ( id_to_int(r0), )
+
+                  if len(rr.products) == 1:
+
+                      rtype = 'unimolecular'
+                      p0 = rr.products[0]
+                      product_ids  = ( id_to_int(p0), )
+
+                  elif len(rr.products) == 2:
+
+                      rtype = 'unbinding'
+                      p0 = rr.products[0]
+                      p1 = rr.products[1]
+                      product_ids  = ( id_to_int(p0), id_to_int(p1) )
+
+                  else:
+                      raise LoadSaveError('Unimolecular or unbinding reaction rule has more than two products. Something is utterly wrong.')
+
+                  sectionname = 'REACTIONRULE_' + str(rr.id)
+                  cp.add_section(sectionname)
+
+                  cp.set(sectionname, 'type', rtype)
+                  cp.set(sectionname, 'reactant_ids', reactant_ids)
+                  cp.set(sectionname, 'product_ids', product_ids)
+                  cp.set(sectionname, 'rate', rate)
+
+                  extracted_rules.append(rr.id)
+
+        # Reactions with two reactants (particle species)
+        for species1 in list(simulator.get_species()) + list(simulator.get_structure_types()):
+              
+            rules = simulator.network_rules.query_reaction_rule(species0, species1)
+
+            for rr in rules:
+
+                if not rr.id in extracted_rules and not len(rr.products)==0:
+
+                    rate = rr.k
+
+                    # Check whether we have a surface binding reaction.
+                    # Since only species1 loops over StructureTypes we only have to check
+                    # whether species1 is a SstructureType or not.
+                    if species1.id in [st.id for st in list(simulator.get_structure_types())]:
+                        # We must construct an id list from the iterator because otherwise
+                        # the comparison does not work
+                        rtype = 'binding_surface'
+
+                    else:
+                        rtype = 'binding_particle'
+
+                    # Make sure that the first reactant stores species1, which is the surface
+                    # in case we have a surface reaction.
+                    if rr.reactants[0] == species1.id:
+                        r0 = rr.reactants[0]
+                        r1 = rr.reactants[1]
+                    else:
+                        # reverse order
+                        r0 = rr.reactants[1]
+                        r1 = rr.reactants[0]
+
+                    reactant_ids = ( id_to_int(r0), id_to_int(r1) )
+
+                    # Check whether there is a legal number of products
+                    if len(rr.products) == 0:
+
+                        product_ids  = None
+                        rtype = 'annihilation'
+
+                    elif len(rr.products) == 1:
+
+                        p0 = rr.products[0]
+                        product_ids  = ( id_to_int(p0), )
+
+                    else:
+                        raise LoadSaveError('Binding reaction rule has %s product(s). Something is utterly wrong.' % str(len(rr.products)) )           
+
+                    # Construct the section info
+                    sectionname = 'REACTIONRULE_' + str(rr.id)
+                    cp.add_section(sectionname)
+
+                    cp.set(sectionname, 'type', rtype)
+                    cp.set(sectionname, 'reactant_ids', reactant_ids)
+                    cp.set(sectionname, 'product_ids', product_ids)
+                    cp.set(sectionname, 'rate', rate)
+
+                    extracted_rules.append(rr.id)
 
     #### STRUCTURES ####
     for structure in simulator.get_structures():
@@ -161,12 +255,13 @@ def save_state(simulator, filename):
             sectionname = 'STRUCTURECONNECTION_' + str(id_int)
             cp.add_section(sectionname)
 
+            # Retrieve the neighbor structure IDs for this structure
             for n in range(0, 4):
 
                 nid = simulator.world.get_neighbor_id(structure, n)
                 nid_int  = id_to_int(nid)
 
-                cp.set(sectionname, 'neighbor'+str(n), nid_int)
+                cp.set(sectionname, 'neighbor_id_'+str(n), nid_int)
 
     #### PARTICLES ####
     pid_particle_pairs = list(simulator.world)
@@ -219,11 +314,11 @@ def id_to_int(ID):
     if p[2] != '':
         q = p[2].partition(')')
 
-    if q[0] != '':
-        return int(q[0])
+        if q[0] != '':
+            return int(q[0])
 
     else:
-        raise RuntimeError('Could not extract number, probably the argument is not a valid ID.')
+        raise LoadSaveError('Could not extract number, probably the argument is not a valid ID.')
 
 
 structure_keywords = [
@@ -232,4 +327,9 @@ def id_to_int(ID):
         (CylindricalSurface, 'CYLINDER'),
         (DiskSurface,        'DISK'),
         (PlanarSurface,      'PLANE')
-        ]
\ No newline at end of file
+        ]
+
+
+class LoadSaveError(Exception):
+    pass
+

From f00eb132e7666b8b674ebe069520f9c412b0f842 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 18:01:06 +0200
Subject: [PATCH 1165/1541] Move DomainEvent class from egfrd.py into
 gfrdbase.py

because we also need it in loadsave.py
---
 egfrd.py    | 8 +-------
 gfrdbase.py | 6 ++++++
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fdd69cf1..32f27489 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -30,6 +30,7 @@
     )
 
 from gfrdbase import *
+from gfrdbase import DomainEvent
 from single import *
 from pair import *
 from multi import *
@@ -174,13 +175,6 @@ def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
     elif isinstance(testShell, MixedPair1DCaptestShell):
         return MixedPair1DCap              (domain_id, shell_id, testShell, reaction_rules)
 
-class DomainEvent(Event):
-    __slot__ = ['data']
-    def __init__(self, time, domain):
-        Event.__init__(self, time)
-        self.data = domain.domain_id            # Store the domain_id key refering to the domain
-                                                # in domains{} in the scheduler
-
 class Delegate(object):
     def __init__(self, obj, method, arg):
         self.ref = ref(obj)
diff --git a/gfrdbase.py b/gfrdbase.py
index 3b2dc540..a2297a1a 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -481,6 +481,12 @@ def place_particle(world, sid, position):
     return particle
 
 
+class DomainEvent(_gfrd.Event):
+    __slot__ = ['data']
+    def __init__(self, time, domain):
+        _gfrd.Event.__init__(self, time)
+        self.data = domain.domain_id            # Store the domain_id key refering to the domain
+                                                # in domains{} in the scheduler
 
 class ParticleSimulatorBase(object):
     def __init__(self, world, rng, network_rules):

From 9def75c75a2f0709a9358b20da3edc46a4aaa00e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 18:02:31 +0200
Subject: [PATCH 1166/1541] Output order of particles in event scheduler into
 savefile

---
 loadsave.py | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/loadsave.py b/loadsave.py
index 7264ae28..674afd97 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -1,5 +1,6 @@
 #!/usr/env python
 
+import copy
 import math
 import numpy
 
@@ -30,6 +31,7 @@
     )
 
 from gfrdbase import *
+from gfrdbase import DomainEvent
 
 __all__ = [ 'save_state', 'load_state' ]
 
@@ -288,6 +290,39 @@ def save_state(simulator, filename):
         cp.set(sectionname, 'position', list(particle.position))
         cp.set(sectionname, 'structure_id', structure_id_int)
 
+    #### PARTICLE ORDER IN SCHEDULER ####
+    # Pop the events from the scheduler and remember
+    # them to push them back again afterwards.
+    # Event IDs will change but this should not matter
+    # for the simulated trajectory as such.    
+    eventlist = []
+    scheduler_order = []
+    while not simulator.scheduler.size == 0 :
+
+        id, event = simulator.scheduler.pop()
+        domain = simulator.domains[event.data]
+
+        # Store the events in a list
+        # inserting from the beginning; thus it
+        # will already have the right order for
+        # reinsertion
+        eventlist.insert(0, (event, domain))
+
+        pid, particle = domain.pid_particle_pair        
+        pid_int = id_to_int(pid)
+
+        scheduler_order.append(pid_int)
+    
+    # Just to be sure...
+    assert simulator.scheduler.size == 0
+    # Put the events back into the scheduler in reverse order
+    for (event, domain) in list(eventlist):
+        event_id = simulator.scheduler.add(DomainEvent(event.time, domain))
+
+    # Create a new section in the save file
+    sectionname = 'SCHEDULER_' + str(pid_int)
+    cp.add_section(sectionname)
+    cp.set(sectionname, 'order', list(scheduler_order))    
 
     #### WRITE FILE ####
     with open(filename, 'wb') as outfile:

From 968d74b432217bb6d7854835238d111729141afa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 18:05:40 +0200
Subject: [PATCH 1167/1541] Burst all domains before saving

This is essential because otherwise we mess up the scheduler.
---
 loadsave.py | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/loadsave.py b/loadsave.py
index 674afd97..31aee16f 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -40,6 +40,15 @@
 def save_state(simulator, filename):
     
 
+    #### BURST ALL DOMAINS ####
+    # This is an important precondition for this
+    # save routine to work properly.
+    # In particular running this without bursting
+    # all the domains will mess up the EventScheduler
+    # because it will reconstruct it with different
+    # event IDs
+    simulator.burst_all_domains()
+
     #### DEFINE THE CONFIG PARSER OBJECT ####
     cp = CP.ConfigParser()
     cp.optionxform = str # for upper case option names

From 1a61af807c5c912a1396095274ea667c8f9ddd2f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 18:07:59 +0200
Subject: [PATCH 1168/1541] Cleanup

---
 loadsave.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 31aee16f..d651a74b 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -329,9 +329,9 @@ def save_state(simulator, filename):
         event_id = simulator.scheduler.add(DomainEvent(event.time, domain))
 
     # Create a new section in the save file
-    sectionname = 'SCHEDULER_' + str(pid_int)
+    sectionname = 'SCHEDULER'
     cp.add_section(sectionname)
-    cp.set(sectionname, 'order', list(scheduler_order))    
+    cp.set(sectionname, 'particle_order', list(scheduler_order))    
 
     #### WRITE FILE ####
     with open(filename, 'wb') as outfile:

From 92df5a61d374ddd7aa3bec4dd524920028431111 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 18:45:17 +0200
Subject: [PATCH 1169/1541] Introduce a method to reset the RNG seed

---
 gfrdbase.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/gfrdbase.py b/gfrdbase.py
index a2297a1a..45729cae 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -518,6 +518,10 @@ def __init__(self, world, rng, network_rules):
     def initialize(self):
         pass
 
+    def reset_seed(self, s):
+
+        self.rng.seed(s)
+
     def get_species(self):
         """
         Return an iterator over the Species in the simulator. 

From 4a05f5e35e44ab21a1bee2f66072acf526cd2ebe Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 18:54:43 +0200
Subject: [PATCH 1170/1541] Re-seed when saving and output the new seed into
 savefile

---
 loadsave.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index d651a74b..db3813d5 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -1,6 +1,6 @@
 #!/usr/env python
 
-import copy
+import sys
 import math
 import numpy
 
@@ -49,12 +49,21 @@ def save_state(simulator, filename):
     # event IDs
     simulator.burst_all_domains()
 
+    # Re-seed the random number generator
+    # (with a randomly drawn seed)
+    # This seed has to be saved and used to
+    # (re)seed the newly setup simulator when
+    # loading to ensure that we will reproduce
+    # the same trajectory.
+    new_seed = simulator.rng.uniform_int(0, 1000000)
+    simulator.reset_seed(new_seed)
+
     #### DEFINE THE CONFIG PARSER OBJECT ####
     cp = CP.ConfigParser()
     cp.optionxform = str # for upper case option names
 
     # Now add the relevant info in separate sections
-    #### MODEL and WORLD ####
+    #### MODEL, WORLD and SEED ####
     cp.add_section('MODEL')
     cp.set('MODEL', 'world_size', simulator.world.world_size)
 
@@ -62,6 +71,9 @@ def save_state(simulator, filename):
     cp.set('WORLD', 'world_size', simulator.world.world_size)
     cp.set('WORLD', 'matrix_size', simulator.world.matrix_size)
 
+    cp.add_section('SEED')
+    cp.set('SEED', 'seed', new_seed)
+
     #### SPECIES ####
     for species in simulator.get_species():
 

From ab9f42d2aa98e4fe2c6ce9d719d16399ba5d4f6b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 12 Oct 2012 19:28:52 +0200
Subject: [PATCH 1171/1541] Start load_state() routine

---
 egfrd.py    |  2 +-
 loadsave.py | 86 +++++++++++++++++++++++++++++++++++++++++++----------
 2 files changed, 72 insertions(+), 16 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 32f27489..84079129 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3230,7 +3230,7 @@ def save_state(self, filename):
 
     def load_state(self, filename):
 
-        loadsave.load_state(self, filename)
+        loadsave.load_state(filename)
 
 
     ###############################
diff --git a/loadsave.py b/loadsave.py
index db3813d5..53273595 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -32,6 +32,7 @@
 
 from gfrdbase import *
 from gfrdbase import DomainEvent
+import model
 
 __all__ = [ 'save_state', 'load_state' ]
 
@@ -74,19 +75,6 @@ def save_state(simulator, filename):
     cp.add_section('SEED')
     cp.set('SEED', 'seed', new_seed)
 
-    #### SPECIES ####
-    for species in simulator.get_species():
-
-        id_int = id_to_int(species.id)
-        sectionname = 'SPECIES_' + str(id_int)
-        cp.add_section(sectionname)
-
-        cp.set(sectionname, 'id', id_int)
-        cp.set(sectionname, 'radius', species.radius)
-        cp.set(sectionname, 'D', species.D)
-        cp.set(sectionname, 'v', species.v)
-        cp.set(sectionname, 'structure_type_id', id_to_int(species.structure_type_id))
-
     #### STRUCTURE TYPES ####
     structure_type_names = [] # will store the names in a lookup list
     for structure_type in simulator.get_structure_types():
@@ -108,6 +96,19 @@ def save_state(simulator, filename):
         # Remember name for later
         structure_type_names.append( (id_int, name) )
 
+    #### SPECIES ####
+    for species in simulator.get_species():
+
+        id_int = id_to_int(species.id)
+        sectionname = 'SPECIES_' + str(id_int)
+        cp.add_section(sectionname)
+
+        cp.set(sectionname, 'id', id_int)
+        cp.set(sectionname, 'radius', species.radius)
+        cp.set(sectionname, 'D', species.D)
+        cp.set(sectionname, 'v', species.v)
+        cp.set(sectionname, 'structure_type_id', id_to_int(species.structure_type_id))
+
     #### RULES ####
     extracted_rules = []  # to avoid double-extraction
     for species0 in simulator.get_species():
@@ -351,9 +352,46 @@ def save_state(simulator, filename):
 
 
 
-def load_state(simulator, filename):
+def load_state(filename):
+    """ Loads a file previously generated with save_state() and
+        constructs a model, world and info needed to construct the 
+        EGFRDSimulator.       
+    """
 
-    pass
+    #### DEFINE THE CONFIG PARSER OBJECT ####
+    cp = CP.ConfigParser()
+    cp.optionxform = str # for upper case option names
+
+    # Load the saved file
+    # TODO Check for right format
+    cp.read(filename)
+
+    #### FIRST GET GLOBAL INFO ####
+    world_size  = cp.getfloat('WORLD', 'world_size')
+    matrix_size = cp.getfloat('WORLD', 'matrix_size')
+    seed        = cp.getint('SEED', 'seed')    
+
+    #### CREATE THE MODEL ####
+    m = model.ParticleModel(world_size)
+
+    #### STRUCTURE_TYPES ####
+    species_sections = filter_sections(cp.sections(), 'STRUCTURETYPE')
+    for sectionname in species_sections:
+    
+        
+        id      = cp.getint(sectionname, 'id')
+        name    = cp.get(sectionname, 'name')
+
+    #### SPECIES ####
+    species_sections = filter_sections(cp.sections(), 'SPECIES')    
+    for sectionname in species_sections:
+    
+        
+        id      = cp.getint(sectionname, 'id')
+        radius  = cp.getfloat(sectionname, 'radius')
+        D       = cp.getfloat(sectionname, 'D')
+        v       = cp.getfloat(sectionname, 'v')
+        structure_type_id = cp.getint(sectionname, 'structure_type_id')
 
 
 def id_to_int(ID):
@@ -377,6 +415,24 @@ def id_to_int(ID):
         raise LoadSaveError('Could not extract number, probably the argument is not a valid ID.')
 
 
+def separate(sectionname):
+
+    separator = '_'
+    part = sectionname.partition(separator)
+
+    return (part[0], part[2])
+
+    # TODO Check for right tag format
+    # raise LoadSaveError('Section name in input file did not have the required format.')
+
+
+def filter_sections(sectionlist, tagstring):
+
+    assert isinstance(tagstring, str)
+
+    return [section for section in sectionlist if separate(section)[0] == tagstring]
+
+
 structure_keywords = [
         (CuboidalRegion,     'CUBE'),
         (SphericalSurface,   'SPHERE'),

From b7a77b033b86fd668369b53a6ee4449ea063cfde Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 15 Oct 2012 18:14:17 +0200
Subject: [PATCH 1172/1541] Further implementation of load function

- Input structure types and species.
- Define lookup dictionaries to map old IDs to newly defined
  species / structure types and ensure they are added to the
  model in the right order.
- Define counters for total number of species / structure types.
  May come in handy at some point.
---
 loadsave.py | 104 +++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 94 insertions(+), 10 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 53273595..f75977bf 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -4,6 +4,8 @@
 import math
 import numpy
 
+from array import *
+
 import ConfigParser as CP
 
 from _gfrd import (
@@ -33,6 +35,7 @@
 from gfrdbase import *
 from gfrdbase import DomainEvent
 import model
+import _gfrd
 
 __all__ = [ 'save_state', 'load_state' ]
 
@@ -59,6 +62,11 @@ def save_state(simulator, filename):
     new_seed = simulator.rng.uniform_int(0, 1000000)
     simulator.reset_seed(new_seed)
 
+    # Reset counters
+    N_structure_types = 0
+    N_species         = 0
+    N_rules           = 0
+
     #### DEFINE THE CONFIG PARSER OBJECT ####
     cp = CP.ConfigParser()
     cp.optionxform = str # for upper case option names
@@ -96,6 +104,9 @@ def save_state(simulator, filename):
         # Remember name for later
         structure_type_names.append( (id_int, name) )
 
+        # Update counter
+        N_structure_types += 1
+
     #### SPECIES ####
     for species in simulator.get_species():
 
@@ -104,11 +115,15 @@ def save_state(simulator, filename):
         cp.add_section(sectionname)
 
         cp.set(sectionname, 'id', id_int)
+        #cp.set(sectionname, 'name', species.name]) # TODO SpeciesInfo does not have this property for some reason...
         cp.set(sectionname, 'radius', species.radius)
         cp.set(sectionname, 'D', species.D)
         cp.set(sectionname, 'v', species.v)
         cp.set(sectionname, 'structure_type_id', id_to_int(species.structure_type_id))
 
+        # Update counter
+        N_species += 1
+
     #### RULES ####
     extracted_rules = []  # to avoid double-extraction
     for species0 in simulator.get_species():
@@ -346,6 +361,10 @@ def save_state(simulator, filename):
     cp.add_section(sectionname)
     cp.set(sectionname, 'particle_order', list(scheduler_order))    
 
+    #### ADD COUNTERS TO MODEL SECTION ####
+    cp.set('MODEL', 'N_structure_types', N_structure_types)
+    cp.set('MODEL', 'N_species', N_species)
+
     #### WRITE FILE ####
     with open(filename, 'wb') as outfile:
         cp.write(outfile)
@@ -369,31 +388,84 @@ def load_state(filename):
     #### FIRST GET GLOBAL INFO ####
     world_size  = cp.getfloat('WORLD', 'world_size')
     matrix_size = cp.getfloat('WORLD', 'matrix_size')
-    seed        = cp.getint('SEED', 'seed')    
+    N_structure_types = cp.getint('MODEL', 'N_structure_types')
+    N_species   = cp.getint('MODEL', 'N_species')
+    seed        = cp.getint('SEED', 'seed')
 
-    #### CREATE THE MODEL ####
+    #### CREATE THE WORLD AND THE MODEL ####
     m = model.ParticleModel(world_size)
 
     #### STRUCTURE_TYPES ####
-    species_sections = filter_sections(cp.sections(), 'STRUCTURETYPE')
-    for sectionname in species_sections:
-    
+    structure_types_dict = {}  # will map the old (read-in) ID to the StructureType
+    structure_types_sections = filter_sections(cp.sections(), 'STRUCTURETYPE')
+    # Now read in the the structure types and add them to the new model
+    # in the right order.
+    # Note that add_structure_type() will create IDs automatically,
+    # so it is important that we sort the sectionnames list by the ids.
+    for sectionname in sorted(structure_types_sections, key = lambda name : name_to_int(name)):
         
         id      = cp.getint(sectionname, 'id')
-        name    = cp.get(sectionname, 'name')
+        name    = cp.get(sectionname, 'name')        
+
+        # Assert that the read id corresponds to the one in the sectionname
+        assert int(sectionname.split('_')[-1]) == id
+
+        # Create a new StructureType object and add it to the model
+        structure_type = _gfrd.StructureType()
+        structure_type['name'] = name
+
+        if id > 1:  # Skip adding the default structure_type a second time
+            m.add_structure_type(structure_type)
+            assert id_to_int(structure_type.id) == id
+            structure_types_dict[id] = structure_type
+            print 'Added ' + str(structure_type) ### TESTING
+
+    print 'structure_types_dict = ' + str(structure_types_dict) ### TESTING
 
     #### SPECIES ####
-    species_sections = filter_sections(cp.sections(), 'SPECIES')    
-    for sectionname in species_sections:
-    
+    # Now the same for the species
+    # Again we have to make sure we add the species in the right order => sort sections list
+    species_dict = {}  # will map the old (read-in) ID to the Species
+    species_sections = filter_sections(cp.sections(), 'SPECIES')
+    for sectionname in sorted(species_sections, key = lambda name : int(name.split('_')[-1])):    
         
         id      = cp.getint(sectionname, 'id')
+        #name    = cp.getfloat(sectionname, 'name') # TODO
         radius  = cp.getfloat(sectionname, 'radius')
         D       = cp.getfloat(sectionname, 'D')
         v       = cp.getfloat(sectionname, 'v')
         structure_type_id = cp.getint(sectionname, 'structure_type_id')
 
+        # Assert that the read id corresponds to the one in the sectionname
+        assert int(sectionname.split('_')[-1]) == id
+
+        # TODO name cannot be output yet, so we have to make up one here
+        name = 'Species_'+str(id)
+
+        if structure_type_id > 1:
+            structure_type = structure_types_dict[structure_type_id]
+            assert id_to_int(structure_type.id) == structure_type_id
 
+        # Create a new Species object and add it to the model
+        if structure_type_id == 1:
+            species = model.Species(name, D, radius)
+        elif v == 0:
+            species = model.Species(name, D, radius, structure_type)
+        else:
+            species = model.Species(name, D, radius, structure_type, v)
+
+        m.add_species_type(species)
+        assert id_to_int(species.id) == id
+        species_dict[id] = species
+        print 'Added ' + str(species) ### TESTING
+
+    print 'species_dict = ' + str(species_dict) ### TESTING
+
+
+
+##########################
+#### HELPER FUNCTIONS ####
+##########################
 def id_to_int(ID):
     """ Strips an eGFRD-type ID-specifier off everything
         but the integer ID numbers.
@@ -415,9 +487,14 @@ def id_to_int(ID):
         raise LoadSaveError('Could not extract number, probably the argument is not a valid ID.')
 
 
+def get_default_separator():
+
+    return '_'
+
+
 def separate(sectionname):
 
-    separator = '_'
+    separator = get_default_separator()
     part = sectionname.partition(separator)
 
     return (part[0], part[2])
@@ -433,6 +510,13 @@ def filter_sections(sectionlist, tagstring):
     return [section for section in sectionlist if separate(section)[0] == tagstring]
 
 
+def name_to_int(sectionname):
+
+    separator = get_default_separator()
+
+    return int(sectionname.split(separator)[-1])
+
+
 structure_keywords = [
         (CuboidalRegion,     'CUBE'),
         (SphericalSurface,   'SPHERE'),

From de1b79adddae3e4c9a9358713c166191f7f57957 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 15 Oct 2012 18:52:04 +0200
Subject: [PATCH 1173/1541] Parse reaction rules in load routine

---
 loadsave.py | 95 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 90 insertions(+), 5 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index f75977bf..cb849ab6 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -395,8 +395,10 @@ def load_state(filename):
     #### CREATE THE WORLD AND THE MODEL ####
     m = model.ParticleModel(world_size)
 
+
     #### STRUCTURE_TYPES ####
     structure_types_dict = {}  # will map the old (read-in) ID to the StructureType
+
     structure_types_sections = filter_sections(cp.sections(), 'STRUCTURETYPE')
     # Now read in the the structure types and add them to the new model
     # in the right order.
@@ -408,7 +410,7 @@ def load_state(filename):
         name    = cp.get(sectionname, 'name')        
 
         # Assert that the read id corresponds to the one in the sectionname
-        assert int(sectionname.split('_')[-1]) == id
+        assert name_to_int(sectionname) == id
 
         # Create a new StructureType object and add it to the model
         structure_type = _gfrd.StructureType()
@@ -422,26 +424,29 @@ def load_state(filename):
 
     print 'structure_types_dict = ' + str(structure_types_dict) ### TESTING
 
+
     #### SPECIES ####
     # Now the same for the species
     # Again we have to make sure we add the species in the right order => sort sections list
     species_dict = {}  # will map the old (read-in) ID to the Species
+
     species_sections = filter_sections(cp.sections(), 'SPECIES')
-    for sectionname in sorted(species_sections, key = lambda name : int(name.split('_')[-1])):    
+    for sectionname in sorted(species_sections, key = lambda name : name_to_int(name)):
         
         id      = cp.getint(sectionname, 'id')
-        #name    = cp.getfloat(sectionname, 'name') # TODO
+        #name    = cp.getfloat(sectionname, 'name') # FIXME
         radius  = cp.getfloat(sectionname, 'radius')
         D       = cp.getfloat(sectionname, 'D')
         v       = cp.getfloat(sectionname, 'v')
         structure_type_id = cp.getint(sectionname, 'structure_type_id')
 
         # Assert that the read id corresponds to the one in the sectionname
-        assert int(sectionname.split('_')[-1]) == id
+        assert name_to_int(sectionname) == id
 
-        # TODO name cannot be output yet, so we have to make up one here
+        # FIXME name cannot be output yet, so we have to make up one here
         name = 'Species_'+str(id)
 
+        # Get the structure type for this species from the structure_type_id
         if structure_type_id > 1:
             structure_type = structure_types_dict[structure_type_id]
             assert id_to_int(structure_type.id) == structure_type_id
@@ -462,6 +467,86 @@ def load_state(filename):
     print 'species_dict = ' + str(species_dict) ### TESTING
 
 
+    #### RULES ####
+    rules_dict = {}  # will map the old (read-in) ID to the reaction rule
+
+    rules_sections = filter_sections(cp.sections(), 'REACTIONRULE')
+    for sectionname in sorted(rules_sections, key = lambda name : name_to_int(name)):
+
+        rtype        = cp.get(sectionname, 'type')
+        rate         = cp.getfloat(sectionname, 'rate')
+        reactant_ids = eval(cp.get(sectionname, 'reactant_ids')) # eval makes sure we get a list
+        product_ids  = eval(cp.get(sectionname, 'product_ids'))
+
+        rule = None
+        if rtype == 'unimolecular':
+
+            assert len(reactant_ids) == 1 and reactant_ids[0] != None and \
+                   len(product_ids)  == 1 and product_ids[0]  != None, \
+                     'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
+
+            # Get the involved species
+            reactant = species_dict[int(reactant_ids[0])]
+            product  = species_dict[int(product_ids[0])]
+
+            # Create the rule
+            rule = model.create_unimolecular_reaction_rule(reactant, product, rate)
+
+        elif rtype == 'unbinding':
+
+            assert len(reactant_ids) == 1 and reactant_ids[0] != None and \
+                   product_ids[0] != None and product_ids[1]  != None, \
+                     'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
+
+            # Get the involved species
+            reactant = species_dict[int(reactant_ids[0])]
+            product0 = species_dict[int(product_ids[0])]
+            product1 = species_dict[int(product_ids[1])]
+
+            # Create the rule
+            rule = model.create_unbinding_reaction_rule(reactant, product0, product1, rate)
+
+        elif rtype == 'binding_particle':
+            
+            assert reactant_ids[0] != None and reactant_ids[1] != None and \
+                   len(product_ids) == 1   and product_ids[0]  != None, \
+                     'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
+
+            # Get the involved species
+            reactant0 = species_dict[int(reactant_ids[0])]
+            reactant1 = species_dict[int(reactant_ids[1])]
+            product   = species_dict[int(product_ids[0])]
+
+            # Create the rule
+            rule = model.create_binding_reaction_rule(reactant0, reactant1, product, rate)
+
+        elif rtype == 'binding_surface':
+            
+            assert reactant_ids[0] != None and reactant_ids[1] != None and \
+                   len(product_ids) == 1   and product_ids[0]  != None, \
+                     'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
+
+            # Get the involved species
+            structure_type = structure_types_dict[int(reactant_ids[0])]
+            reactant       = species_dict[int(reactant_ids[1])]
+            product        = species_dict[int(product_ids[0])]
+
+            # Create the rule
+            rule = model.create_binding_reaction_rule(reactant, structure_type, product, rate)
+
+        else:
+
+            raise LoadSaveError('Cannot create reaction rule when loading state: unknown reaction rule type.')
+
+        # If we have successfully constructed a reaction rule, add it to the model
+        # and to the internal rules dictionary
+        if rule:
+            
+            m.add_reaction_rule(rule)
+            rules_dict[name_to_int(sectionname)] = rule
+            print 'Added ' + str(rule) + ', type = %s' % str(rtype) ### TESTING
+
+    print 'rules_dict = ' + str(rules_dict) ### TESTING
 
 ##########################
 #### HELPER FUNCTIONS ####

From 573514558bda9dabf0a1e4b119d62f7951dd978e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 15 Oct 2012 20:03:35 +0200
Subject: [PATCH 1174/1541] Read-in structures from saved file - WIP

---
 loadsave.py | 102 +++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 98 insertions(+), 4 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index cb849ab6..ad15d7e9 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -234,13 +234,13 @@ def save_state(simulator, filename):
             # the structure_id property of structures is the parent structure id
 
         # Find the name of the structure type
-        for i, name in structure_type_names:
+        for i, name in structure_type_names: ## FIXME replace by dictionary?
             if i == sid_int:
                 st_name = name
 
         # Find the keyword for the geometric type of this structure
-        for instance, key in structure_keywords:
-            if isinstance(structure, instance):
+        for object_type, key in structure_keywords:
+            if isinstance(structure, object_type):
                 geometry_key = key
 
         sectionname = 'STRUCTURE_' + geometry_key + '_' + str(id_int)
@@ -385,9 +385,11 @@ def load_state(filename):
     # TODO Check for right format
     cp.read(filename)
 
+    print 'Sections in file : ' + str(cp.sections()) ### TESTING
+
     #### FIRST GET GLOBAL INFO ####
     world_size  = cp.getfloat('WORLD', 'world_size')
-    matrix_size = cp.getfloat('WORLD', 'matrix_size')
+    matrix_size = cp.getint('WORLD', 'matrix_size')
     N_structure_types = cp.getint('MODEL', 'N_structure_types')
     N_species   = cp.getint('MODEL', 'N_species')
     seed        = cp.getint('SEED', 'seed')
@@ -548,6 +550,98 @@ def load_state(filename):
 
     print 'rules_dict = ' + str(rules_dict) ### TESTING
 
+    #### CREATE THE WORLD ####
+    w = create_world(m, matrix_size)
+    # This will come in handy later
+    def_structure_id = w.get_def_structure_id()
+
+    #### STRUCTURES ####
+    structures_dict = {}  # will map the old (read-in) ID to the structure
+
+    structures_sections = filter_sections(cp.sections(), 'STRUCTURE')
+    for sectionname in sorted(structures_sections, key = lambda name : name_to_int(name)):
+
+        # Get the geometry key
+        # TODO This assumes that the section name has the right signature
+        #      => Implement a check
+        geometry_key = sectionname.split(get_default_separator())[-2]
+
+        # Find the geometric type of this structure according to its key
+        for object_type, key in structure_keywords:
+            if geometry_key == key:
+                structure_object_type = object_type
+
+        # Read in the information common to all object types
+        id        = cp.getint(sectionname, 'id')        
+        name      = cp.get(sectionname, 'name')
+        parent_id = cp.getint(sectionname, 'parent_id')
+        st_id     = cp.getint(sectionname, 'structure_type_id')        
+        st_name   = cp.get(sectionname, 'structure_type_name')
+        position  = eval(cp.get(sectionname, 'position'))
+                    # eval makes sure we import a list
+
+        # Assert that the read id corresponds to the one in the sectionname
+        # This is particularly important in this part of the loading routine
+        # because structures may be defined as substructures of previously
+        # defined structures. Thus we want to define them in the order in
+        # which they were defined before they have been saved to the file.
+        assert name_to_int(sectionname) == id
+
+        parent_structure = w.get_structure(def_structure_id) # TESTING
+
+        structure = None
+        if structure_object_type == CuboidalRegion:
+        
+            unit_x      = eval(cp.get(sectionname, 'unit_x'))
+            unit_y      = eval(cp.get(sectionname, 'unit_y'))
+            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
+            half_extent = eval(cp.get(sectionname, 'half_extent'))
+
+            assert id == id_to_int(def_structure_id)
+            # TODO Add more than default cuboidal regions
+            # Right now we assume that there is only one which
+            # is created automatically via create_world()            
+
+        elif structure_object_type == SphericalSurface:
+            
+            radius = cp.getfloat(sectionname, 'radius')
+
+            # Create the structure
+            structure = model.create_spherical_surface(structure_type.id, name, position, radius, parent_structure.id)
+
+        elif structure_object_type == CylindricalSurface:
+            
+            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
+            half_length = cp.getfloat(sectionname, 'half_length')
+            radius      = cp.getfloat(sectionname, 'radius')
+
+        elif structure_object_type == DiskSurface:
+            
+            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
+            radius      = cp.getfloat(sectionname, 'radius')
+
+            structure_type = structure_types_dict[st_id]            
+
+            # Create the structure
+            structure = model.create_disk_surface(structure_type.id, name, position, radius, unit_z, parent_structure.id)
+
+        elif structure_object_type == PlanarSurface:
+
+            unit_x      = eval(cp.get(sectionname, 'unit_x'))
+            unit_y      = eval(cp.get(sectionname, 'unit_y'))
+            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
+            half_extent = eval(cp.get(sectionname, 'half_extent'))
+
+        # Add it to the world
+        if structure:
+            w.add_structure(structure)
+            #assert id_to_int(structure.id) == id # TODO
+            structures_dict[id] = structure
+            print 'Added ' + str(structure) + ', type = %s, parent = %s' % (structure_type, parent_id) ### TESTING
+
+    print 'structures_dict = ' + str(structures_dict) ### TESTING
+
+
 ##########################
 #### HELPER FUNCTIONS ####
 ##########################

From caf334782f6e810af63e1db5fe55c7b03a458650 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 17 Oct 2012 18:07:54 +0200
Subject: [PATCH 1175/1541] Continue reading in structures

Also added a function vectorize() which makes a proper numpy.array
out of the list spit out by the parser.
---
 loadsave.py | 56 +++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 42 insertions(+), 14 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index ad15d7e9..35457156 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -558,6 +558,9 @@ def load_state(filename):
     #### STRUCTURES ####
     structures_dict = {}  # will map the old (read-in) ID to the structure
 
+    def_structure = w.get_structure(def_structure_id)
+    structures_dict[id_to_int(def_structure_id)] = def_structure
+
     structures_sections = filter_sections(cp.sections(), 'STRUCTURE')
     for sectionname in sorted(structures_sections, key = lambda name : name_to_int(name)):
 
@@ -577,7 +580,7 @@ def load_state(filename):
         parent_id = cp.getint(sectionname, 'parent_id')
         st_id     = cp.getint(sectionname, 'structure_type_id')        
         st_name   = cp.get(sectionname, 'structure_type_name')
-        position  = eval(cp.get(sectionname, 'position'))
+        position  = vectorize(cp.get(sectionname, 'position'))
                     # eval makes sure we import a list
 
         # Assert that the read id corresponds to the one in the sectionname
@@ -587,15 +590,19 @@ def load_state(filename):
         # which they were defined before they have been saved to the file.
         assert name_to_int(sectionname) == id
 
-        parent_structure = w.get_structure(def_structure_id) # TESTING
+        # Get the parent structure from the structures dictionary
+        # For this to work it is of critical importance that the order
+        # in which the structures are defined is the same as the order
+        # in which they were defined in before the output
+        parent_structure = structures_dict[parent_id]
 
         structure = None
         if structure_object_type == CuboidalRegion:
         
-            unit_x      = eval(cp.get(sectionname, 'unit_x'))
-            unit_y      = eval(cp.get(sectionname, 'unit_y'))
-            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
-            half_extent = eval(cp.get(sectionname, 'half_extent'))
+            unit_x      = vectorize(cp.get(sectionname, 'unit_x'))
+            unit_y      = vectorize(cp.get(sectionname, 'unit_y'))
+            unit_z      = vectorize(cp.get(sectionname, 'unit_z'))            
+            half_extent = vectorize(cp.get(sectionname, 'half_extent'))
 
             assert id == id_to_int(def_structure_id)
             # TODO Add more than default cuboidal regions
@@ -611,13 +618,21 @@ def load_state(filename):
 
         elif structure_object_type == CylindricalSurface:
             
-            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
+            unit_z      = vectorize(cp.get(sectionname, 'unit_z'))            
             half_length = cp.getfloat(sectionname, 'half_length')
             radius      = cp.getfloat(sectionname, 'radius')
 
+            # The cylinder creation function does not take the midpoint of
+            # the cylinder (which is stored in position) and its half length
+            # but the edge point and the total length. Thus we need:
+            edge_pos = position - half_length * unit_z
+
+            # Create the structure
+            structure = model.create_cylindrical_surface(structure_type.id, name, edge_pos, radius, unit_z, 2.0*half_length, parent_structure.id)
+
         elif structure_object_type == DiskSurface:
             
-            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
+            unit_z      = vectorize(cp.get(sectionname, 'unit_z'))            
             radius      = cp.getfloat(sectionname, 'radius')
 
             structure_type = structure_types_dict[st_id]            
@@ -627,17 +642,25 @@ def load_state(filename):
 
         elif structure_object_type == PlanarSurface:
 
-            unit_x      = eval(cp.get(sectionname, 'unit_x'))
-            unit_y      = eval(cp.get(sectionname, 'unit_y'))
-            unit_z      = eval(cp.get(sectionname, 'unit_z'))            
-            half_extent = eval(cp.get(sectionname, 'half_extent'))
+            unit_x      = vectorize(cp.get(sectionname, 'unit_x'))
+            unit_y      = vectorize(cp.get(sectionname, 'unit_y'))
+            unit_z      = vectorize(cp.get(sectionname, 'unit_z'))            
+            half_extent = vectorize(cp.get(sectionname, 'half_extent'))
+
+            # The plane creation function does not take the midpoint of
+            # the plane (which is stored in position) and its half extents
+            # but the corner point and the total extensions. Thus we need:
+            corner_pos = position - half_extent[0] * unit_x - half_extent[1] * unit_y
+
+            # Create the structure
+            structure = model.create_planar_surface(structure_type.id, name, corner_pos, unit_x, unit_y, 2.0*half_extent[0], 2.0*half_extent[1], parent_structure.id)
 
         # Add it to the world
         if structure:
             w.add_structure(structure)
-            #assert id_to_int(structure.id) == id # TODO
+            assert id_to_int(structure.id) == id # TODO
             structures_dict[id] = structure
-            print 'Added ' + str(structure) + ', type = %s, parent = %s' % (structure_type, parent_id) ### TESTING
+            print 'Added ' + str(structure) + ', type = %s, id = %s, parent = %s' % (structure_type, structure.id, structure.structure_id) ### TESTING
 
     print 'structures_dict = ' + str(structures_dict) ### TESTING
 
@@ -696,6 +719,11 @@ def name_to_int(sectionname):
     return int(sectionname.split(separator)[-1])
 
 
+def vectorize(input_list):
+
+    return numpy.array(eval(input_list))
+
+
 structure_keywords = [
         (CuboidalRegion,     'CUBE'),
         (SphericalSurface,   'SPHERE'),

From d808227c0c227046839c91164b1228ff609b37c0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 17 Oct 2012 19:17:41 +0200
Subject: [PATCH 1176/1541] Parse structure connections

---
 loadsave.py | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/loadsave.py b/loadsave.py
index 35457156..c2edebfc 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -558,6 +558,12 @@ def load_state(filename):
     #### STRUCTURES ####
     structures_dict = {}  # will map the old (read-in) ID to the structure
 
+    # The default structure should be always ID 1 and has to be added
+    # from the beginning because it is created automatically at the init
+    # of world.
+    # To be sure we check that the default ID is indeed 1.
+    # FIXME There must be a more elegant solution...
+    assert id_to_int(def_structure_id) == 1
     def_structure = w.get_structure(def_structure_id)
     structures_dict[id_to_int(def_structure_id)] = def_structure
 
@@ -664,6 +670,23 @@ def load_state(filename):
 
     print 'structures_dict = ' + str(structures_dict) ### TESTING
 
+    #### STRUCTURE CONNECTIONS ####
+    connections_dict = {}  # will map the old (read-in) ID to the structure connection
+
+    sc_sections = filter_sections(cp.sections(), 'STRUCTURECONNECTION')
+    for sectionname in sorted(sc_sections, key = lambda name : name_to_int(name)):
+
+        to_connect_id = name_to_int(sectionname)
+
+        neighbor_id_0 = cp.getint(sectionname, 'neighbor_id_0')
+        neighbor_id_1 = cp.getint(sectionname, 'neighbor_id_1')
+        neighbor_id_2 = cp.getint(sectionname, 'neighbor_id_2')
+        neighbor_id_3 = cp.getint(sectionname, 'neighbor_id_3')
+
+        # TODO Continue... we need to find the side number to which
+        # to_connect_id structure is connected at each of its sides
+        # This may require implementing a C++ to Python converter
+        # for get_neighbor_info()
 
 ##########################
 #### HELPER FUNCTIONS ####

From a35ed91ba847317b1ce4bdd74976d254d38cb480 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 18 Oct 2012 12:51:46 +0200
Subject: [PATCH 1177/1541] Create structure connections at read-in

---
 loadsave.py | 44 +++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 39 insertions(+), 5 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index c2edebfc..d4923be4 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -666,13 +666,16 @@ def load_state(filename):
             w.add_structure(structure)
             assert id_to_int(structure.id) == id # TODO
             structures_dict[id] = structure
-            print 'Added ' + str(structure) + ', type = %s, id = %s, parent = %s' % (structure_type, structure.id, structure.structure_id) ### TESTING
+            print 'Added ' + str(structure) + ', type = %s, id = %s, parent = %s' \
+                        % (structure_type, structure.id, structure.structure_id) ### TESTING
 
     print 'structures_dict = ' + str(structures_dict) ### TESTING
 
     #### STRUCTURE CONNECTIONS ####
     connections_dict = {}  # will map the old (read-in) ID to the structure connection
 
+    # Here we first read in all the connections and then figure out which sides are
+    # connected in order to actually connect them.
     sc_sections = filter_sections(cp.sections(), 'STRUCTURECONNECTION')
     for sectionname in sorted(sc_sections, key = lambda name : name_to_int(name)):
 
@@ -683,10 +686,41 @@ def load_state(filename):
         neighbor_id_2 = cp.getint(sectionname, 'neighbor_id_2')
         neighbor_id_3 = cp.getint(sectionname, 'neighbor_id_3')
 
-        # TODO Continue... we need to find the side number to which
-        # to_connect_id structure is connected at each of its sides
-        # This may require implementing a C++ to Python converter
-        # for get_neighbor_info()
+        connections_dict[to_connect_id] = [neighbor_id_0, neighbor_id_1, \
+                                           neighbor_id_2, neighbor_id_3] 
+
+    # Figure out which sides are connected
+    connections = []
+    for to_connect_id, neighbor_list in connections_dict.iteritems():
+
+        # For each neighbor_id find the side with which the neighbor is
+        # connected to the structure with con_id
+        for side in range(0,3):
+
+            n_id = neighbor_list[side]
+            nn_list = connections_dict[n_id]
+
+            for n_side in range(0,3):
+            
+                nn_id = nn_list[n_side]
+                if nn_id == to_connect_id:
+                # We have found the neighbor_id that links to con_id
+                    connections.append( (to_connect_id, side, n_id, n_side) )
+                    break
+
+    print 'connections = ' + str(connections) ### TESTING
+
+    # Establish the connections
+    for struct_id0, side0, struct_id1, side1 in connections:
+
+        struct0 = structures_dict[struct_id0]
+        struct1 = structures_dict[struct_id1]
+
+        w.connect_structures(struct0, side0, struct1, side1)
+        print 'Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
+                    % (side0, struct0, struct0.id, side1, struct1, struct1.id) ### TESTING
+        
+        
 
 ##########################
 #### HELPER FUNCTIONS ####

From 4f7a2403ab361a2f0981e6a7064e8fce9aad7ba1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 18 Oct 2012 15:23:02 +0200
Subject: [PATCH 1178/1541] Read in and create particles in the right order +
 small fix to structure_type parsing and internal storage

---
 loadsave.py | 96 ++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 80 insertions(+), 16 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index d4923be4..3c82efd5 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -330,6 +330,9 @@ def save_state(simulator, filename):
     #### PARTICLE ORDER IN SCHEDULER ####
     # Pop the events from the scheduler and remember
     # them to push them back again afterwards.
+    # This seems awkward but it is convenient because
+    # we will do the same procedure when rebuilding the
+    # system at loading / read-in.
     # Event IDs will change but this should not matter
     # for the simulated trajectory as such.    
     eventlist = []
@@ -359,7 +362,7 @@ def save_state(simulator, filename):
     # Create a new section in the save file
     sectionname = 'SCHEDULER'
     cp.add_section(sectionname)
-    cp.set(sectionname, 'particle_order', list(scheduler_order))    
+    cp.set(sectionname, 'particle_order', list(scheduler_order))
 
     #### ADD COUNTERS TO MODEL SECTION ####
     cp.set('MODEL', 'N_structure_types', N_structure_types)
@@ -389,10 +392,10 @@ def load_state(filename):
 
     #### FIRST GET GLOBAL INFO ####
     world_size  = cp.getfloat('WORLD', 'world_size')
-    matrix_size = cp.getint('WORLD', 'matrix_size')
+    matrix_size = cp.getint('WORLD',   'matrix_size')
     N_structure_types = cp.getint('MODEL', 'N_structure_types')
     N_species   = cp.getint('MODEL', 'N_species')
-    seed        = cp.getint('SEED', 'seed')
+    seed        = cp.getint('SEED',  'seed')
 
     #### CREATE THE WORLD AND THE MODEL ####
     m = model.ParticleModel(world_size)
@@ -401,6 +404,13 @@ def load_state(filename):
     #### STRUCTURE_TYPES ####
     structure_types_dict = {}  # will map the old (read-in) ID to the StructureType
 
+    # First get the default structure type already defined at model creation
+    # and add it to the internal dictionary
+    def_structure_type_id = id_to_int(m.get_def_structure_type_id())
+    def_structure_type    = m.get_structure_type_by_id(m.get_def_structure_type_id())
+    structure_types_dict[def_structure_type_id] = def_structure_type
+    print 'Added ' + str(def_structure_type) ### TESTING
+
     structure_types_sections = filter_sections(cp.sections(), 'STRUCTURETYPE')
     # Now read in the the structure types and add them to the new model
     # in the right order.
@@ -418,9 +428,9 @@ def load_state(filename):
         structure_type = _gfrd.StructureType()
         structure_type['name'] = name
 
-        if id > 1:  # Skip adding the default structure_type a second time
+        if id != def_structure_type_id:  # Skip adding the default structure_type a second time
             m.add_structure_type(structure_type)
-            assert id_to_int(structure_type.id) == id
+            assert id_to_int(structure_type.id) == id            
             structure_types_dict[id] = structure_type
             print 'Added ' + str(structure_type) ### TESTING
 
@@ -449,12 +459,12 @@ def load_state(filename):
         name = 'Species_'+str(id)
 
         # Get the structure type for this species from the structure_type_id
-        if structure_type_id > 1:
-            structure_type = structure_types_dict[structure_type_id]
-            assert id_to_int(structure_type.id) == structure_type_id
+        structure_type = structure_types_dict[structure_type_id]
+        assert id_to_int(structure_type.id) == structure_type_id
 
         # Create a new Species object and add it to the model
-        if structure_type_id == 1:
+        # Make sure to choose the right argument signature for each case
+        if structure_type_id == def_structure_type_id:
             species = model.Species(name, D, radius)
         elif v == 0:
             species = model.Species(name, D, radius, structure_type)
@@ -475,7 +485,7 @@ def load_state(filename):
     rules_sections = filter_sections(cp.sections(), 'REACTIONRULE')
     for sectionname in sorted(rules_sections, key = lambda name : name_to_int(name)):
 
-        rtype        = cp.get(sectionname, 'type')
+        rtype        = cp.get(sectionname,      'type')
         rate         = cp.getfloat(sectionname, 'rate')
         reactant_ids = eval(cp.get(sectionname, 'reactant_ids')) # eval makes sure we get a list
         product_ids  = eval(cp.get(sectionname, 'product_ids'))
@@ -582,10 +592,10 @@ def load_state(filename):
 
         # Read in the information common to all object types
         id        = cp.getint(sectionname, 'id')        
-        name      = cp.get(sectionname, 'name')
+        name      = cp.get(sectionname,    'name')
         parent_id = cp.getint(sectionname, 'parent_id')
         st_id     = cp.getint(sectionname, 'structure_type_id')        
-        st_name   = cp.get(sectionname, 'structure_type_name')
+        st_name   = cp.get(sectionname,    'structure_type_name')
         position  = vectorize(cp.get(sectionname, 'position'))
                     # eval makes sure we import a list
 
@@ -596,6 +606,11 @@ def load_state(filename):
         # which they were defined before they have been saved to the file.
         assert name_to_int(sectionname) == id
 
+        # Get the structure_type of this structure
+        structure_type = structure_types_dict[st_id]
+        if st_id != def_structure_type_id:
+            assert structure_type['name'] == st_name
+
         # Get the parent structure from the structures dictionary
         # For this to work it is of critical importance that the order
         # in which the structures are defined is the same as the order
@@ -620,7 +635,8 @@ def load_state(filename):
             radius = cp.getfloat(sectionname, 'radius')
 
             # Create the structure
-            structure = model.create_spherical_surface(structure_type.id, name, position, radius, parent_structure.id)
+            structure = model.create_spherical_surface(structure_type.id, name, \
+                                                       position, radius, parent_structure.id)
 
         elif structure_object_type == CylindricalSurface:
             
@@ -634,7 +650,8 @@ def load_state(filename):
             edge_pos = position - half_length * unit_z
 
             # Create the structure
-            structure = model.create_cylindrical_surface(structure_type.id, name, edge_pos, radius, unit_z, 2.0*half_length, parent_structure.id)
+            structure = model.create_cylindrical_surface(structure_type.id, name, edge_pos, radius, \
+                                                         unit_z, 2.0*half_length, parent_structure.id)
 
         elif structure_object_type == DiskSurface:
             
@@ -644,7 +661,8 @@ def load_state(filename):
             structure_type = structure_types_dict[st_id]            
 
             # Create the structure
-            structure = model.create_disk_surface(structure_type.id, name, position, radius, unit_z, parent_structure.id)
+            structure = model.create_disk_surface(structure_type.id, name, position, radius, \
+                                                  unit_z, parent_structure.id)
 
         elif structure_object_type == PlanarSurface:
 
@@ -719,8 +737,54 @@ def load_state(filename):
         w.connect_structures(struct0, side0, struct1, side1)
         print 'Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
                     % (side0, struct0, struct0.id, side1, struct1, struct1.id) ### TESTING
+
+    #### PARTICLES ####
+    # Here we first read in the scheduler order, i.e. the
+    # order with which particles were sitting in the scheduler
+    # before the output, and the particles as such.
+    # Then we create the particles in the right order.
+
+    # Get the particle order
+    assert cp.has_section('SCHEDULER')
+    particle_order = eval(cp.get('SCHEDULER', 'particle_order'))
+
+    print 'particle_order = ' + str(particle_order) ### TESTING
+    
+    # Read in the particle information
+    particles_dict = {}  # will map the old (read-in) ID to the particle info
+
+    particle_sections = filter_sections(cp.sections(), 'PARTICLE')
+    for sectionname in particle_sections:
+    
+        pid = cp.getint(sectionname, 'id')
+        sid = cp.getint(sectionname, 'species_id')        
+        radius   = cp.getfloat(sectionname, 'radius')
+        D        = cp.getfloat(sectionname, 'D')
+        v        = cp.getfloat(sectionname, 'v')
+        position = vectorize(cp.get(sectionname, 'position'))
+        str_id   = cp.getint(sectionname, 'structure_id')
+
+        # Store the info in an internal particle dictionary
+        # and add it to the collection (particles_dict)
+        particle = { 'id'  : pid,
+                     'species_id' : sid,
+                     'radius'     : radius,
+                     'D'   : D,
+                     'v'   : v,
+                     'position'   : position,
+                     'structure_id' : str_id
+                   }
+        particles_dict[pid] = particle
+
+    for pid in particle_order:
+
+        particle = particles_dict[pid]
+        particle_species = species_dict[particle['species_id']]
         
-        
+        place_particle(w, particle_species, particle['position'])
+        print 'Placed particle of species %s at %s.' % (particle_species, particle['position']) ### TESTING
+
+
 
 ##########################
 #### HELPER FUNCTIONS ####

From 2f9633b241433fef994c08ed92a278cd57f173d4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 18 Oct 2012 16:52:00 +0200
Subject: [PATCH 1179/1541] Return world and seed to simulator and
 re-initialize in load_state()

---
 egfrd.py    | 15 ++++++++++++++-
 loadsave.py | 14 +++++++++-----
 2 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 84079129..1ee8c075 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3230,7 +3230,20 @@ def save_state(self, filename):
 
     def load_state(self, filename):
 
-        loadsave.load_state(filename)
+        #assert self.is_dirty == True   # TODO
+
+        # Run the load function which will return a
+        # new world containing the read-in model and
+        # objects in the right positions and the seed
+        # that was used to reset the RNG at output
+        world, seed = loadsave.load_state(filename)
+        myrandom.seed(seed)
+
+        if __debug__:
+            log.info('Loaded state from file %s \nRe-initializing the simulator...' % filename)
+
+        # Re-initialize the simulator
+        self.__init__(world, myrandom.rng)
 
 
     ###############################
diff --git a/loadsave.py b/loadsave.py
index 3c82efd5..1c1bb1d4 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -333,7 +333,7 @@ def save_state(simulator, filename):
     # This seems awkward but it is convenient because
     # we will do the same procedure when rebuilding the
     # system at loading / read-in.
-    # Event IDs will change but this should not matter
+    # Event IDs will change but this does not matter
     # for the simulated trajectory as such.    
     eventlist = []
     scheduler_order = []
@@ -355,7 +355,8 @@ def save_state(simulator, filename):
     
     # Just to be sure...
     assert simulator.scheduler.size == 0
-    # Put the events back into the scheduler in reverse order
+    # Put the events back into the scheduler (in reverse order)
+    # Note that the eventlist already has been correctly inverted at this point
     for (event, domain) in list(eventlist):
         event_id = simulator.scheduler.add(DomainEvent(event.time, domain))
 
@@ -779,10 +780,13 @@ def load_state(filename):
     for pid in particle_order:
 
         particle = particles_dict[pid]
-        particle_species = species_dict[particle['species_id']]
+        particle_species = species_dict[ particle['species_id'] ]
         
-        place_particle(w, particle_species, particle['position'])
-        print 'Placed particle of species %s at %s.' % (particle_species, particle['position']) ### TESTING
+        placed = place_particle(w, particle_species, particle['position'])
+        print 'Placed particle %s.' % str(placed) ### TESTING
+
+
+    return w, seed
 
 
 

From 0b2981f5a6e647710fa3f56e9eae6eb87e8eb3dd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 18 Oct 2012 18:27:03 +0200
Subject: [PATCH 1180/1541] Finish particle creation, return world and seed to
 simulator when loading and fix the order of particle_order list at output

---
 loadsave.py | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 1c1bb1d4..ea66fc7a 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -351,15 +351,22 @@ def save_state(simulator, filename):
         pid, particle = domain.pid_particle_pair        
         pid_int = id_to_int(pid)
 
-        scheduler_order.append(pid_int)
-    
+        # Also output the scheduler order in reverse
+        # fashion already, so we don't have to bother later
+        scheduler_order.insert(0, pid_int)
+
+    print scheduler_order
+
     # Just to be sure...
     assert simulator.scheduler.size == 0
     # Put the events back into the scheduler (in reverse order)
     # Note that the eventlist already has been correctly inverted at this point
     for (event, domain) in list(eventlist):
+        print "Re-instering domain %s, pid = %s into scheduler" % (domain, domain.pid_particle_pair[0])
         event_id = simulator.scheduler.add(DomainEvent(event.time, domain))
 
+    print simulator.scheduler
+
     # Create a new section in the save file
     sectionname = 'SCHEDULER'
     cp.add_section(sectionname)
@@ -743,7 +750,11 @@ def load_state(filename):
     # Here we first read in the scheduler order, i.e. the
     # order with which particles were sitting in the scheduler
     # before the output, and the particles as such.
-    # Then we create the particles in the right order.
+    # Then we create the particles in the right order (FILO principle).
+    # Note that the particle_order list of the SCHEDULER section
+    # already contains the particles in reverse order as compared
+    # to their order in the scheduler before saving, i.e. they
+    # will be added to the system in the right order here.
 
     # Get the particle order
     assert cp.has_section('SCHEDULER')
@@ -786,6 +797,8 @@ def load_state(filename):
         print 'Placed particle %s.' % str(placed) ### TESTING
 
 
+    # Return the world and the seed that was used 
+    # to re-seed the simulator at output
     return w, seed
 
 

From 9445f5fe1fe38edd23af4ec0cc72b2c7a61dc04a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 18 Oct 2012 18:51:11 +0200
Subject: [PATCH 1181/1541] Update domain.event_id after reconstruction of
 scheduler in save_state()

---
 loadsave.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index ea66fc7a..666c2549 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -354,18 +354,19 @@ def save_state(simulator, filename):
         # Also output the scheduler order in reverse
         # fashion already, so we don't have to bother later
         scheduler_order.insert(0, pid_int)
-
-    print scheduler_order
-
-    # Just to be sure...
-    assert simulator.scheduler.size == 0
+    
     # Put the events back into the scheduler (in reverse order)
     # Note that the eventlist already has been correctly inverted at this point
+    assert simulator.scheduler.size == 0   # just to be sure
     for (event, domain) in list(eventlist):
         print "Re-instering domain %s, pid = %s into scheduler" % (domain, domain.pid_particle_pair[0])
         event_id = simulator.scheduler.add(DomainEvent(event.time, domain))
+        # The event_id is changed in this process, so don't forget to update the domain
+        domain.event_id = event_id
 
-    print simulator.scheduler
+    # To be sure, check that event IDs in reconstructed scheduler
+    # correspond to event IDs of the domains
+    simulator.check_domains()
 
     # Create a new section in the save file
     sectionname = 'SCHEDULER'

From 60439cff359f0035ed99c85814626747b78f8e90 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 18 Oct 2012 18:52:27 +0200
Subject: [PATCH 1182/1541] Increase SINGLE_SHELL_FACTOR to 2.5

---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index ed99a345..dd9b20f7 100644
--- a/utils.py
+++ b/utils.py
@@ -36,7 +36,7 @@
                      # IMPORTANT NOTE: MULTI_SHELL_FACTOR should be AT LEAST sqrt(2) !
                      # This stems from the fact that there is vacant space in the cylinder
 
-SINGLE_SHELL_FACTOR = 2.0*MULTI_SHELL_FACTOR
+SINGLE_SHELL_FACTOR = 2.5 #2.0*MULTI_SHELL_FACTOR
                       # This is the threshold for when the algorithm switches from forming
                       # NonInteractionSingles to forming a Pair or Interaction. It also defines
                       # the radius in which the NonInteractionSingle will burst intruding domains.

From 28d64e3055a6acbde4088962a8315adad2669bef Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 19 Oct 2012 19:45:55 +0200
Subject: [PATCH 1183/1541] Use myseed correctly to reseed at loading

---
 egfrd.py    | 7 ++++---
 myrandom.py | 8 +++++++-
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1ee8c075..9588d8ba 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3236,13 +3236,14 @@ def load_state(self, filename):
         # new world containing the read-in model and
         # objects in the right positions and the seed
         # that was used to reset the RNG at output
-        world, seed = loadsave.load_state(filename)
-        myrandom.seed(seed)
+        world, seed = loadsave.load_state(filename)        
 
         if __debug__:
             log.info('Loaded state from file %s \nRe-initializing the simulator...' % filename)
 
-        # Re-initialize the simulator
+        # Re-initialize the simulator using the seed
+        # from the input file
+        self.reset_seed(seed)
         self.__init__(world, myrandom.rng)
 
 
diff --git a/myrandom.py b/myrandom.py
index 64e93dd1..2d2e06a5 100644
--- a/myrandom.py
+++ b/myrandom.py
@@ -23,7 +23,13 @@ def uniform(min=0.0, max=1.0, size=None):
 get_raw = rng.get_raw
 random = rng
 normal = rng.normal
-seed = rng.seed
+
+def seed(myseed):
+
+    rng.seed(myseed)
+
+    # for the case we would like to remember the seed used
+    return myseed
 
 # By default seed is 0.
 myseed = 0

From b7f66a5387bf26ac94d4664d1fe3b3eedf6cb293 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 22 Oct 2012 19:31:50 +0200
Subject: [PATCH 1184/1541] Higher output precision for next event times in
 infolog

---
 egfrd.py | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9588d8ba..f0d1d363 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -450,12 +450,12 @@ def step(self):
             self.t, self.last_event = self.MAX_TIME_STEP, event
         else:
             self.t, self.last_event = event.time, event
-
+        
         if __debug__:
             domain_counts = self.count_domains()
-            log.info('\n\n%d: t=%s dt=%s\t' %
-                     (self.step_counter, FORMAT_DOUBLE % self.t,
-                      FORMAT_DOUBLE % self.dt) + 
+            log.info('\n\n%d: t=%s dt=%s (next_time=%s)\t' %
+                     (self.step_counter, self.t,
+                      self.dt, self.scheduler.top[1].time) + 
                      'Singles: %d, Pairs: %d, Multis: %d\n' % domain_counts + 
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
@@ -481,6 +481,7 @@ def step(self):
         # 3. Adjust the simulation time
         #
         next_time = self.scheduler.top[1].time
+        log.info('next_time=%s' % next_time)
         self.dt = next_time - self.t
 
         # assert if not too many successive dt=0 steps occur.
@@ -721,8 +722,8 @@ def add_domain_event(self, domain):
             DomainEvent(event_time, domain))
         if __debug__:
             log.info('add_event: %s, event=#%d, t=%s' %
-                     (domain.domain_id, event_id,
-                      FORMAT_DOUBLE % (event_time)))
+                     (domain.domain_id, event_id, event_time )
+                    )
         domain.event_id = event_id                      # FIXME side effect programming -> unclear!!
 
 
@@ -737,7 +738,7 @@ def remove_event(self, event):
     def update_domain_event(self, t, domain):
         if __debug__:
             log.info('update_event: %s, event=#%d, t=%s' %
-                     (domain.domain_id, domain.event_id, FORMAT_DOUBLE % t))
+                     (domain.domain_id, domain.event_id, t))
         self.scheduler.update((domain.event_id, DomainEvent(t, domain)))
 
 
@@ -2212,7 +2213,7 @@ def process_multi_event(self, multi, ignore):
     #   particles.
 
         if __debug__:
-            log.info('FIRE MULTI: %s' % multi.last_event)
+            log.info('FIRE MULTI: %s (dt=%s)' % (multi.last_event, multi.dt))
 
         if __debug__:
             assert (multi.domain_id in ignore), \

From 2bb4f4565ff598b5eebfdda0151956d22173d66f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 23 Oct 2012 10:55:01 +0200
Subject: [PATCH 1185/1541] Out- and input time information at saving/loading

---
 loadsave.py | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 666c2549..e08ccd2d 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -372,6 +372,9 @@ def save_state(simulator, filename):
     sectionname = 'SCHEDULER'
     cp.add_section(sectionname)
     cp.set(sectionname, 'particle_order', list(scheduler_order))
+    cp.set(sectionname, 't', simulator.t)
+    cp.set(sectionname, 'dt', simulator.dt)
+    cp.set(sectionname, 'step_counter', simulator.step_counter)
 
     #### ADD COUNTERS TO MODEL SECTION ####
     cp.set('MODEL', 'N_structure_types', N_structure_types)
@@ -386,7 +389,13 @@ def save_state(simulator, filename):
 def load_state(filename):
     """ Loads a file previously generated with save_state() and
         constructs a model, world and info needed to construct the 
-        EGFRDSimulator.       
+        EGFRDSimulator.
+
+        Returns: world, seed, time_info
+
+        time_info is a tuple containing (t, dt, step_counter)
+        where t, dt and step_counter are the values of these
+        quantities at the moment of output / saving.
     """
 
     #### DEFINE THE CONFIG PARSER OBJECT ####
@@ -757,9 +766,14 @@ def load_state(filename):
     # to their order in the scheduler before saving, i.e. they
     # will be added to the system in the right order here.
 
-    # Get the particle order
+    # Get the particle order and time counter values at output
     assert cp.has_section('SCHEDULER')
     particle_order = eval(cp.get('SCHEDULER', 'particle_order'))
+    t  = cp.getfloat('SCHEDULER', 't')
+    dt = cp.getfloat('SCHEDULER', 'dt')
+    step_counter = cp.getfloat('SCHEDULER', 'step_counter')
+
+    time_info = (t, dt, step_counter)
 
     print 'particle_order = ' + str(particle_order) ### TESTING
     
@@ -800,7 +814,7 @@ def load_state(filename):
 
     # Return the world and the seed that was used 
     # to re-seed the simulator at output
-    return w, seed
+    return w, seed, time_info
 
 
 

From d64519b91665e8b9a45da22a861c934372812c2e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 23 Oct 2012 16:40:14 +0200
Subject: [PATCH 1186/1541] Set simulator time to time from savefile when
 loading

---
 egfrd.py | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f0d1d363..ddc2fb06 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -284,8 +284,8 @@ def reset(self):
         Can be for example usefull when users want to first do an equilibration
         run before starting the "real experiment".
         """ #~ MW
-        self.t = 0.0
-        self.dt = 0.0
+        self.t = 0.0        
+        self.dt = 0.0        
         self.step_counter = 0
         self.single_steps = {EventType.SINGLE_ESCAPE:0,
                              EventType.SINGLE_REACTION:0,
@@ -3237,7 +3237,7 @@ def load_state(self, filename):
         # new world containing the read-in model and
         # objects in the right positions and the seed
         # that was used to reset the RNG at output
-        world, seed = loadsave.load_state(filename)        
+        world, seed, time_info = loadsave.load_state(filename)
 
         if __debug__:
             log.info('Loaded state from file %s \nRe-initializing the simulator...' % filename)
@@ -3247,6 +3247,12 @@ def load_state(self, filename):
         self.reset_seed(seed)
         self.__init__(world, myrandom.rng)
 
+        # Set the simulator time to the time it had at output
+        # This is to avoid divergence between the original and the
+        # restarted simulation because of the limited floating point 
+        # precision of Python
+        self.t = time_info[0]
+
 
     ###############################
     #### METHODS FOR DEBUGGING ####

From 19dbbce243155055f0d9215cc379fbf58c24d567 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 23 Oct 2012 19:03:27 +0200
Subject: [PATCH 1187/1541] Allow user to set a scheduler precision and to
 reload the saved state when saving

This is in order to overcome the nasty effect of slowly divergent simulations
after reloading because of limited Python float precision.
---
 egfrd.py | 12 +++++++++---
 utils.py |  2 ++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ddc2fb06..c9a7c975 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -717,6 +717,11 @@ def add_domain_event(self, domain):
     # This method makes an event for domain 'domain' in the scheduler.
     # The event will have the domain_id pointing to the appropriate domain in 'domains{}'.
     # The domain will have the event_id pointing to the appropriate event in the scheduler.
+
+        # Adapt the sampled dt to the preset scheduler precision
+        dt_rounded = round(domain.dt, SCHEDULER_DIGITS)
+        domain.dt = dt_rounded
+
         event_time = self.t + domain.dt
         event_id = self.scheduler.add(
             DomainEvent(event_time, domain))
@@ -3224,14 +3229,15 @@ def check(self):
     # These are just wrappers around the methods
     # in loadsave.py :
 
-    def save_state(self, filename):
+    def save_state(self, filename, reload=False):
 
         loadsave.save_state(self, filename)
 
+        if(reload):
+            self.load_state(filename)
 
-    def load_state(self, filename):
 
-        #assert self.is_dirty == True   # TODO
+    def load_state(self, filename):
 
         # Run the load function which will return a
         # new world containing the read-in model and
diff --git a/utils.py b/utils.py
index dd9b20f7..a8545ca9 100644
--- a/utils.py
+++ b/utils.py
@@ -25,6 +25,8 @@
 TOLERANCE = 1e-7
 TIME_TOLERANCE = 1e-10
 
+SCHEDULER_DIGITS = int(-1.0*numpy.log10(TIME_TOLERANCE))
+
 # Multiplication factor used for seperating 2 particles or a particle and a 
 # surface after unbinding.
 MINIMAL_SEPARATION_FACTOR = 1.0 + TOLERANCE

From 1b2bc5012979dbf1968408af6db556d3b6f75719 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 23 Oct 2012 19:06:59 +0200
Subject: [PATCH 1188/1541] Comment new variable SCHEDULER_PRECISION

---
 utils.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/utils.py b/utils.py
index a8545ca9..d36ee3c3 100644
--- a/utils.py
+++ b/utils.py
@@ -25,6 +25,11 @@
 TOLERANCE = 1e-7
 TIME_TOLERANCE = 1e-10
 
+# Scheduler digits: the simulator will round the next-event time steps to this
+# precision before putting them into the scheduler. This was originally introduced
+# to overcome nasty divergence effects in reloaded simulations caused by limited
+# Python float precision. Put this at a high value if you want to sample accurately
+# very small time steps by purpose. 
 SCHEDULER_DIGITS = int(-1.0*numpy.log10(TIME_TOLERANCE))
 
 # Multiplication factor used for seperating 2 particles or a particle and a 

From 01ad09656b9672f11135e8149a677a6f4154bd8d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 23 Oct 2012 19:12:12 +0200
Subject: [PATCH 1189/1541] Docstrings for load and save functions

---
 egfrd.py | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index c9a7c975..fdd3ddd6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3230,7 +3230,23 @@ def check(self):
     # in loadsave.py :
 
     def save_state(self, filename, reload=False):
+    """ Save the state of the simulator after bursting
+        all domains. The latter facilitates reconstruction
+        of precisely the state saved.
 
+        Arguments:
+            - filename : a string specifying the name of
+                         the file that the state will be
+                         saved in.
+            - [reload] : (optional) if this this set
+                         to 'True' the simulator will
+                         be re-initialized with the state
+                         from the save-file ('filename').
+                         Use this if you experience divergence
+                         between the original and saved
+                         simulations caused by limited
+                         Python float precision.
+        """
         loadsave.save_state(self, filename)
 
         if(reload):
@@ -3238,6 +3254,13 @@ def save_state(self, filename, reload=False):
 
 
     def load_state(self, filename):
+    """ Load a state previously saved via save_state()
+        and re-initialize the simulator with the loaded
+        data.
+
+        Takes the name of the save-file as an argument
+        of string-type.
+    """
 
         # Run the load function which will return a
         # new world containing the read-in model and

From 26455cc2f022cd345eaa96df8faa6433b93352fb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 23 Oct 2012 19:13:24 +0200
Subject: [PATCH 1190/1541] One more comment

---
 egfrd.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index fdd3ddd6..01b3555d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3246,6 +3246,8 @@ def save_state(self, filename, reload=False):
                          between the original and saved
                          simulations caused by limited
                          Python float precision.
+
+                         reload = False by default.
         """
         loadsave.save_state(self, filename)
 

From 43fe23bf9af340ff89cabb145d23fae408777f21 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 23 Oct 2012 19:16:21 +0200
Subject: [PATCH 1191/1541] Forgot some indents...

---
 egfrd.py | 25 ++++++++++++-------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 01b3555d..746644f3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3230,11 +3230,11 @@ def check(self):
     # in loadsave.py :
 
     def save_state(self, filename, reload=False):
-    """ Save the state of the simulator after bursting
-        all domains. The latter facilitates reconstruction
-        of precisely the state saved.
-
-        Arguments:
+        """ Save the state of the simulator after bursting
+            all domains. The latter facilitates reconstruction
+            of precisely the state saved.
+            
+            Arguments:
             - filename : a string specifying the name of
                          the file that the state will be
                          saved in.
@@ -3256,14 +3256,13 @@ def save_state(self, filename, reload=False):
 
 
     def load_state(self, filename):
-    """ Load a state previously saved via save_state()
-        and re-initialize the simulator with the loaded
-        data.
-
-        Takes the name of the save-file as an argument
-        of string-type.
-    """
-
+        """ Load a state previously saved via save_state()
+            and re-initialize the simulator with the loaded
+            data.
+            
+            Takes the name of the save-file as an argument
+            of string-type.
+        """
         # Run the load function which will return a
         # new world containing the read-in model and
         # objects in the right positions and the seed

From e1e71b1e6782930f0849bf7cf8d3b539b6c30c86 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 24 Oct 2012 13:56:47 +0200
Subject: [PATCH 1192/1541] Make place_particle work for the disk surfaces

---
 gfrdbase.py | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 45729cae..67f23cac 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -438,13 +438,33 @@ def place_particle(world, sid, position):
     if world.check_overlap((position, radius)):
         raise NoSpace, 'Placing particle failed: overlaps with other particle.'
 
+    # Get the IDs of all structures of the structure type that this particle species lives on
+    structure_ids = world.get_structure_ids(world.get_structure_type(species.structure_type_id))
+
+    # Get all neighboring surfaces ordered by their distance to the particle
     surfaces = get_all_surfaces(world, position, [])
     if surfaces:
-        surface, distance = surfaces[0]
+        # Get the closest surface of the structure type 
+        # for this particle species: we cannot simply take
+        # the closest structure because for a disk-bound
+        # particle this can be either the disk or cylinder
+        # => choose the one with the right structure type
+        for s in range(0, len(surfaces)):
+            surface, distance = surfaces[s]
+
+            if surface.id in structure_ids:
+                # we have found the closest surface with
+                # the required structure type
+                break;
+            else:
+                # there is no such structure, placement
+                # will be impossible
+                surface, distance = None, numpy.inf
     else:
+        # no structure around, we can't place the particle
         surface, distance = None, numpy.inf
 
-    # Check if not too close to a neighbouring structures for particles 
+    # Check if not too close to neighbouring structures for particles 
     # added to the world, or added to a self-defined box.
     if species.structure_type_id == world.get_def_structure_type_id():
         structure_id = world.get_def_structure_id()
@@ -455,8 +475,7 @@ def place_particle(world, sid, position):
                                (sid, position, distance))
     else:
         # If the particle lives on a surface then the position should be in the closest surface.
-        # The closest surface should also be of the structure_type associated with the species.
-        structure_ids = world.get_structure_ids(world.get_structure_type(species.structure_type_id))
+        # The closest surface should also be of the structure_type associated with the species.        
         if not (surface and 
                 distance < TOLERANCE*radius and 
                 surface.id in structure_ids):

From 9ac54b6263986bf6ef1ef3fc7e7c65066e36ac53 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 24 Oct 2012 13:57:18 +0200
Subject: [PATCH 1193/1541] Small fix in domain checker

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 746644f3..f4915410 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2964,7 +2964,7 @@ def check_shape_overlap(self, shape1, shape2):
                        elif length(inter_pos_z) == 0.0:
                           total_overlap = overlap_r
                        else:
-                          total_overlap = -1.0 * sqrt(overlap_r*overlap_r + overlap_z*overlap_z)
+                          total_overlap = -1.0 * math.sqrt(overlap_r*overlap_r + overlap_z*overlap_z)
                         
                        return total_overlap
 

From bd647648718a9331cea465738499419c5aa67b81 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 24 Oct 2012 17:52:48 +0200
Subject: [PATCH 1194/1541] Logging messages for load_state function in
 loadsave module

---
 loadsave.py | 44 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index e08ccd2d..fc20273e 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -37,9 +37,14 @@
 import model
 import _gfrd
 
+import logging
+
+
 __all__ = [ 'save_state', 'load_state' ]
 
 
+log = logging.getLogger('ecell')
+
 
 def save_state(simulator, filename):
     
@@ -51,6 +56,10 @@ def save_state(simulator, filename):
     # all the domains will mess up the EventScheduler
     # because it will reconstruct it with different
     # event IDs
+    
+    if __debug__:
+        log.info('Attempting to save the state of the simulator: running burst_all_domains()')
+
     simulator.burst_all_domains()
 
     # Re-seed the random number generator
@@ -84,6 +93,9 @@ def save_state(simulator, filename):
     cp.set('SEED', 'seed', new_seed)
 
     #### STRUCTURE TYPES ####
+    if __debug__:
+        log.info('Saving structure types...')
+
     structure_type_names = [] # will store the names in a lookup list
     for structure_type in simulator.get_structure_types():
 
@@ -108,6 +120,9 @@ def save_state(simulator, filename):
         N_structure_types += 1
 
     #### SPECIES ####
+    if __debug__:
+        log.info('Saving particle species...')
+
     for species in simulator.get_species():
 
         id_int = id_to_int(species.id)
@@ -125,6 +140,9 @@ def save_state(simulator, filename):
         N_species += 1
 
     #### RULES ####
+    if __debug__:
+        log.info('Saving rules network...')
+
     extracted_rules = []  # to avoid double-extraction
     for species0 in simulator.get_species():
 
@@ -226,6 +244,9 @@ def save_state(simulator, filename):
                     extracted_rules.append(rr.id)
 
     #### STRUCTURES ####
+    if __debug__:
+        log.info('Saving structures...')
+
     for structure in simulator.get_structures():
 
         id_int  = id_to_int(structure.id)
@@ -285,6 +306,9 @@ def save_state(simulator, filename):
 
 
     #### STRUCTURE CONNECTIVITY ####
+    if __debug__:
+        log.info('Saving structure connectivity information...')
+
     for structure in simulator.get_structures():
 
         if isinstance(structure, PlanarSurface):
@@ -303,6 +327,9 @@ def save_state(simulator, filename):
                 cp.set(sectionname, 'neighbor_id_'+str(n), nid_int)
 
     #### PARTICLES ####
+    if __debug__:
+        log.info('Saving particles...')
+
     pid_particle_pairs = list(simulator.world)
     pid_particle_pairs.sort()
 
@@ -335,13 +362,19 @@ def save_state(simulator, filename):
     # system at loading / read-in.
     # Event IDs will change but this does not matter
     # for the simulated trajectory as such.    
+    if __debug__:
+        log.info('Saving particle order in scheduler...')
+
     eventlist = []
     scheduler_order = []
     while not simulator.scheduler.size == 0 :
-
+        
         id, event = simulator.scheduler.pop()
         domain = simulator.domains[event.data]
 
+        if __debug__:
+            log.info('Removed domain %s, particle id = %s from scheduler.' % (domain, domain.pid_particle_pair[0]) )
+
         # Store the events in a list
         # inserting from the beginning; thus it
         # will already have the right order for
@@ -359,7 +392,8 @@ def save_state(simulator, filename):
     # Note that the eventlist already has been correctly inverted at this point
     assert simulator.scheduler.size == 0   # just to be sure
     for (event, domain) in list(eventlist):
-        print "Re-instering domain %s, pid = %s into scheduler" % (domain, domain.pid_particle_pair[0])
+        if __debug__:
+            log.info('Re-instering domain %s, particle id = %s into scheduler.' % (domain, domain.pid_particle_pair[0]) )
         event_id = simulator.scheduler.add(DomainEvent(event.time, domain))
         # The event_id is changed in this process, so don't forget to update the domain
         domain.event_id = event_id
@@ -377,10 +411,16 @@ def save_state(simulator, filename):
     cp.set(sectionname, 'step_counter', simulator.step_counter)
 
     #### ADD COUNTERS TO MODEL SECTION ####
+    if __debug__:
+        log.info('Saving object counters...')
+
     cp.set('MODEL', 'N_structure_types', N_structure_types)
     cp.set('MODEL', 'N_species', N_species)
 
     #### WRITE FILE ####
+    if __debug__:
+        log.info('Writing file...')
+
     with open(filename, 'wb') as outfile:
         cp.write(outfile)
 

From dfc5db28ea8a9dbaaacfb784d8d2af91c5cda1d4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 24 Oct 2012 18:12:11 +0200
Subject: [PATCH 1195/1541] Replace debug messages by logging messages in
 save_state in module loadsave

---
 loadsave.py | 91 +++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 71 insertions(+), 20 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index fc20273e..a8c39f85 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -373,7 +373,7 @@ def save_state(simulator, filename):
         domain = simulator.domains[event.data]
 
         if __debug__:
-            log.info('Removed domain %s, particle id = %s from scheduler.' % (domain, domain.pid_particle_pair[0]) )
+            log.info('  Removed domain %s, particle id = %s from scheduler.' % (domain, domain.pid_particle_pair[0]) )
 
         # Store the events in a list
         # inserting from the beginning; thus it
@@ -393,7 +393,7 @@ def save_state(simulator, filename):
     assert simulator.scheduler.size == 0   # just to be sure
     for (event, domain) in list(eventlist):
         if __debug__:
-            log.info('Re-instering domain %s, particle id = %s into scheduler.' % (domain, domain.pid_particle_pair[0]) )
+            log.info('  Re-instering domain %s, particle id = %s into scheduler.' % (domain, domain.pid_particle_pair[0]) )
         event_id = simulator.scheduler.add(DomainEvent(event.time, domain))
         # The event_id is changed in this process, so don't forget to update the domain
         domain.event_id = event_id
@@ -438,6 +438,9 @@ def load_state(filename):
         quantities at the moment of output / saving.
     """
 
+    if __debug__:
+        log.info('Attempting to load simulator state from file %s.' % str(filename))
+
     #### DEFINE THE CONFIG PARSER OBJECT ####
     cp = CP.ConfigParser()
     cp.optionxform = str # for upper case option names
@@ -445,10 +448,14 @@ def load_state(filename):
     # Load the saved file
     # TODO Check for right format
     cp.read(filename)
-
-    print 'Sections in file : ' + str(cp.sections()) ### TESTING
+  
+    if __debug__:
+        log.info('Sections in file: ' + str(cp.sections()) )
 
     #### FIRST GET GLOBAL INFO ####
+    if __debug__:
+        log.info('Reading global info...')
+
     world_size  = cp.getfloat('WORLD', 'world_size')
     matrix_size = cp.getint('WORLD',   'matrix_size')
     N_structure_types = cp.getint('MODEL', 'N_structure_types')
@@ -456,10 +463,16 @@ def load_state(filename):
     seed        = cp.getint('SEED',  'seed')
 
     #### CREATE THE WORLD AND THE MODEL ####
+    if __debug__:
+        log.info('Creating the model...')
+
     m = model.ParticleModel(world_size)
 
 
     #### STRUCTURE_TYPES ####
+    if __debug__:
+        log.info('Reconstructing structure types...')
+
     structure_types_dict = {}  # will map the old (read-in) ID to the StructureType
 
     # First get the default structure type already defined at model creation
@@ -467,7 +480,8 @@ def load_state(filename):
     def_structure_type_id = id_to_int(m.get_def_structure_type_id())
     def_structure_type    = m.get_structure_type_by_id(m.get_def_structure_type_id())
     structure_types_dict[def_structure_type_id] = def_structure_type
-    print 'Added ' + str(def_structure_type) ### TESTING
+    if __debug__:
+        log.info('  Added %s' % str(def_structure_type) )
 
     structure_types_sections = filter_sections(cp.sections(), 'STRUCTURETYPE')
     # Now read in the the structure types and add them to the new model
@@ -490,12 +504,17 @@ def load_state(filename):
             m.add_structure_type(structure_type)
             assert id_to_int(structure_type.id) == id            
             structure_types_dict[id] = structure_type
-            print 'Added ' + str(structure_type) ### TESTING
+            if __debug__:
+                log.info('  Added %s' % str(structure_type) )
 
-    print 'structure_types_dict = ' + str(structure_types_dict) ### TESTING
+    if __debug__:
+        log.info('  structure_types_dict = %s' % str(structure_types_dict) )
 
 
     #### SPECIES ####
+    if __debug__:
+        log.info('Reconstructing species...')
+
     # Now the same for the species
     # Again we have to make sure we add the species in the right order => sort sections list
     species_dict = {}  # will map the old (read-in) ID to the Species
@@ -532,12 +551,17 @@ def load_state(filename):
         m.add_species_type(species)
         assert id_to_int(species.id) == id
         species_dict[id] = species
-        print 'Added ' + str(species) ### TESTING
+        if __debug__:
+            log.info('  Added %s' % str(species) )
 
-    print 'species_dict = ' + str(species_dict) ### TESTING
+    if __debug__:
+        log.info('  species_dict = %s' % str(species_dict) )
 
 
     #### RULES ####
+    if __debug__:
+        log.info('Reconstructing rules network...')
+
     rules_dict = {}  # will map the old (read-in) ID to the reaction rule
 
     rules_sections = filter_sections(cp.sections(), 'REACTIONRULE')
@@ -614,16 +638,24 @@ def load_state(filename):
             
             m.add_reaction_rule(rule)
             rules_dict[name_to_int(sectionname)] = rule
-            print 'Added ' + str(rule) + ', type = %s' % str(rtype) ### TESTING
+            if __debug__:
+                log.info('  Added %s, type = %s' % (rule, rtype) )
 
-    print 'rules_dict = ' + str(rules_dict) ### TESTING
+    if __debug__:
+        log.info('  rules_dict = %s' % str(rules_dict) )
 
     #### CREATE THE WORLD ####
+    if __debug__:
+        log.info('Creating the world...')
+
     w = create_world(m, matrix_size)
     # This will come in handy later
     def_structure_id = w.get_def_structure_id()
 
     #### STRUCTURES ####
+    if __debug__:
+        log.info('Reconstructing structures...')
+
     structures_dict = {}  # will map the old (read-in) ID to the structure
 
     # The default structure should be always ID 1 and has to be added
@@ -735,19 +767,25 @@ def load_state(filename):
             corner_pos = position - half_extent[0] * unit_x - half_extent[1] * unit_y
 
             # Create the structure
-            structure = model.create_planar_surface(structure_type.id, name, corner_pos, unit_x, unit_y, 2.0*half_extent[0], 2.0*half_extent[1], parent_structure.id)
+            structure = model.create_planar_surface(structure_type.id, name, corner_pos, unit_x, unit_y, \
+                                                    2.0*half_extent[0], 2.0*half_extent[1], parent_structure.id)
 
         # Add it to the world
         if structure:
             w.add_structure(structure)
             assert id_to_int(structure.id) == id # TODO
             structures_dict[id] = structure
-            print 'Added ' + str(structure) + ', type = %s, id = %s, parent = %s' \
-                        % (structure_type, structure.id, structure.structure_id) ### TESTING
+            if __debug__:
+                log.info('  Added %s, type = %s, id = %s, parent = %s' \
+                         % (structure, structure_type, structure.id, structure.structure_id) )
 
-    print 'structures_dict = ' + str(structures_dict) ### TESTING
+    if __debug__:
+        log.info('  structures_dict = %s' % str(structures_dict) )
 
     #### STRUCTURE CONNECTIONS ####
+    if __debug__:
+        log.info('Reconstructing structure connections...')
+
     connections_dict = {}  # will map the old (read-in) ID to the structure connection
 
     # Here we first read in all the connections and then figure out which sides are
@@ -784,7 +822,8 @@ def load_state(filename):
                     connections.append( (to_connect_id, side, n_id, n_side) )
                     break
 
-    print 'connections = ' + str(connections) ### TESTING
+    if __debug__:
+        log.info('  connections = %s' % str(connections) )
 
     # Establish the connections
     for struct_id0, side0, struct_id1, side1 in connections:
@@ -793,10 +832,14 @@ def load_state(filename):
         struct1 = structures_dict[struct_id1]
 
         w.connect_structures(struct0, side0, struct1, side1)
-        print 'Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
-                    % (side0, struct0, struct0.id, side1, struct1, struct1.id) ### TESTING
+        if __debug__:
+            log.info('  Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
+                     % (side0, struct0, struct0.id, side1, struct1, struct1.id) )
 
     #### PARTICLES ####
+    if __debug__:
+        log.info('Reconstructing particles...')
+
     # Here we first read in the scheduler order, i.e. the
     # order with which particles were sitting in the scheduler
     # before the output, and the particles as such.
@@ -807,6 +850,8 @@ def load_state(filename):
     # will be added to the system in the right order here.
 
     # Get the particle order and time counter values at output
+    if __debug__:
+        log.info('  Obtaining particle order in scheduler...')
     assert cp.has_section('SCHEDULER')
     particle_order = eval(cp.get('SCHEDULER', 'particle_order'))
     t  = cp.getfloat('SCHEDULER', 't')
@@ -815,9 +860,12 @@ def load_state(filename):
 
     time_info = (t, dt, step_counter)
 
-    print 'particle_order = ' + str(particle_order) ### TESTING
+    if __debug__:
+        log.info('  particle_order = %s' % str(particle_order) )
     
     # Read in the particle information
+    if __debug__:
+        log.info('  Reading particles info...')
     particles_dict = {}  # will map the old (read-in) ID to the particle info
 
     particle_sections = filter_sections(cp.sections(), 'PARTICLE')
@@ -843,13 +891,16 @@ def load_state(filename):
                    }
         particles_dict[pid] = particle
 
+    if __debug__:
+        log.info('  Placing particles...')
     for pid in particle_order:
 
         particle = particles_dict[pid]
         particle_species = species_dict[ particle['species_id'] ]
         
         placed = place_particle(w, particle_species, particle['position'])
-        print 'Placed particle %s.' % str(placed) ### TESTING
+        if __debug__:
+            log.info('  Placed particle %s' % str(placed) )
 
 
     # Return the world and the seed that was used 

From 25cdb9e86cbb292c610fd4fb843222b4e192cc13 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 24 Oct 2012 18:12:37 +0200
Subject: [PATCH 1196/1541] Cleanup

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index f4915410..11049f7d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -60,12 +60,12 @@
     MixedPair1DCaptestShell,
     )
 
-import logging
-import os
-
 import loadsave
 from histograms import *
 
+import logging
+import os
+
 log = logging.getLogger('ecell')
 
 ### Singles
@@ -3270,7 +3270,7 @@ def load_state(self, filename):
         world, seed, time_info = loadsave.load_state(filename)
 
         if __debug__:
-            log.info('Loaded state from file %s \nRe-initializing the simulator...' % filename)
+            log.info('Loaded state from file %s, re-initializing the simulator...' % filename)
 
         # Re-initialize the simulator using the seed
         # from the input file

From 8652c894faa44ab6e089c1fb8e5047546832d7ea Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 12:24:50 +0100
Subject: [PATCH 1197/1541] Run zero-dt updates before bursting all domains to
 ensure complete state update and avoid double bursting events

---
 egfrd.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index 11049f7d..01ad4761 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -880,6 +880,14 @@ def burst_volume(self, pos, radius, ignore=[]):
     def burst_all_domains(self):
         # Bursts all the domains in the simulator
 
+        # First apply all changes that may have been triggered by the last event
+        # These are for example new shellmaking steps with dt==0 which logically
+        # still are part of the last update. This is also to ensure that we do not
+        # attempt to "double burst" domains, i.e. run this routine on domains which
+        # are just bursted. In that case the checks below would fail.
+        while self.dt == 0.0:
+            self.step()
+
         all_domains = self.domains.items()
         all_domain_ids =[domain_id for domain_id, _ in all_domains]
         zero_singles, ignore = self.burst_domains(all_domain_ids, [])

From 4326c41b67606884622c1db31a46457cc0b7bfc4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 16:31:11 +0100
Subject: [PATCH 1198/1541] Revise 1D geminate (BD) rate for DiskSurface

---
 DiskSurface.hpp | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 44c12bde..5c12e054 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -78,10 +78,8 @@ class DiskSurface
     // Rate for binding to particle on the structure
     virtual Real get_1D_rate_geminate( Real const& k, length_type const& r01) const
     {
-        // This rate does not make sense on the ("zero-dimensional") disk object
-        // but is used to determine the maximal time step in a Multi object and
-        // therefore should be defined in a proper way.
-        return 0.0;
+        // Same as for particle-particle reactions on the cylinder
+        return k;
     }
     
     // Rate for binding to the structure
@@ -110,21 +108,25 @@ class DiskSurface
     {
         // This function produces a position for a particle unbinding from the disk onto the rod.
         // It should lie within the reaction volume around the disk.
-        // TODO: THIS IS THE CODE COPIED FROM CylindricalSurface
-        // FIXME WTF is all this calculation!! The dissociation vector is supposed to be super simple!
+        // Note that this is the same code as for the CylindricalSurface.
         Real X( rng.uniform(0.,1.) );
         length_type const rod_radius = base_type::shape().radius();
         position_type const unit_z = base_type::shape().unit_z();
 
+        // Calculate the length of the vector first
         length_type const rrl( rod_radius + r0 + rl );
         length_type const rrl_sq( gsl_pow_2(rrl) );
-        length_type const rr_sq( gsl_pow_2(rod_radius + r0) );
-        
-        length_type const diss_vec_length( sqrt( X * (rrl_sq - rr_sq) + rr_sq ) );
+        length_type const rr_sq( gsl_pow_2(rod_radius + r0) );        
+        // Create a random length between rr_sq and rrl_sq
+        length_type const diss_vec_length( sqrt( rr_sq + X * (rrl_sq - rr_sq) ) );
 
-        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);        
+        // Create a 3D vector with totally random orientation
+        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);
+        // Subtract the part parallel to the axis to get the orthogonal components and normalize
+        // This creates a normed random vector orthogonal to the cylinder axis
         v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
          
+        // Return the created vector with the right length
         return multiply( v, diss_vec_length); 
     }
     

From 950da78acd3fb7c4ae5820e5d3420b3344817236 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 16:31:53 +0100
Subject: [PATCH 1199/1541] Minor BD stuff cleanup

---
 CylindricalSurface.hpp | 6 +++---
 newBDPropagator.hpp    | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 6faa2987..f8249494 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -101,9 +101,9 @@ class CylindricalSurface
         // Calculate the length of the vector first
         length_type const rrl( rod_radius + r0 + rl );
         length_type const rrl_sq( gsl_pow_2(rrl) );
-        length_type const rr_sq( gsl_pow_2(rod_radius + r0) );
-        
-        length_type const diss_vec_length( sqrt( X * (rrl_sq - rr_sq) + rr_sq ) );
+        length_type const rr_sq( gsl_pow_2(rod_radius + r0) );        
+        // Create a random length between rr_sq and rrl_sq
+        length_type const diss_vec_length( sqrt( rr_sq + X * (rrl_sq - rr_sq) ) );
 
         // Create a 3D vector with totally random orientation
         position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 061522a7..989d2c13 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -268,7 +268,7 @@ class newBDPropagator
                                  accumulated_prob, reaction_length_, dt_));
                 }
                 
-                if( accumulated_prob > rnd ) // OK, try to fire the interaction
+                if(accumulated_prob > rnd) // OK, try to fire the interaction
                 {   
                     LOG_DEBUG( ("attempting surface interaction, acc_prob = %g", accumulated_prob) ); // TESTING
                     try

From e9cd8de74e9dbf57ced6e7c49cd9d9757c28aa7d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 16:48:48 +0100
Subject: [PATCH 1200/1541] Define a function that as a function of
 structure_type_id returns some structure of that type if present in the
 system

---
 ParticleContainer.hpp         |  4 +++-
 ParticleContainerBase.hpp     |  9 ++++++++-
 StructureContainer.hpp        | 19 ++++++++++++++++++-
 Transaction.hpp               |  4 ++++
 binding/ParticleContainer.hpp |  1 +
 5 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index 5bf5c44e..b326d284 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -104,8 +104,10 @@ class ParticleContainer
     virtual boost::shared_ptr<structure_type> get_structure(structure_id_type const& id) const = 0;
     
     virtual structures_range get_structures() const = 0;
+    
+    virtual boost::shared_ptr<structure_type> get_some_structure_of_type(structure_type_id_type const& sid) const = 0;
 
-//    virtual bool update_structure(structure_id_pair const& structid_pair) = 0;
+//    virtual bool update_structure(structure_id_pair const& structid_pair) = 0;    
 
     virtual bool remove_structure(structure_id_type const& id) = 0;
 
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 29f5f210..3b0cd865 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -109,6 +109,7 @@ class ParticleContainerBase
     typedef typename traits_type::size_type                 size_type;
     typedef typename traits_type::structure_id_type         structure_id_type;
     typedef typename traits_type::structure_type            structure_type;
+    typedef typename traits_type::structure_type_id_type    structure_type_id_type;
     typedef typename base_type::particle_id_set             particle_id_set;
     typedef typename base_type::particle_id_pair            particle_id_pair;
     typedef typename base_type::structure_id_set            structure_id_set;
@@ -400,12 +401,18 @@ class ParticleContainerBase
         return structures_.get_structures_range();
     }
     
+    // Getter structure_type_id -> some structure of that type
+    virtual boost::shared_ptr<structure_type> get_some_structure_of_type(structure_type_id_type const& sid) const
+    {
+        return structures_.get_some_structure_of_type(sid);
+    }
+    
     // Update structure wrapper
     template <typename Tstructid_pair_>
     bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         return structures_.update_structure(structid_pair);
-    }
+    }   
     
     // Remove structure wrapper
     virtual bool remove_structure(structure_id_type const& id)
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 0f50dc11..007a5638 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -61,7 +61,8 @@ class StructureContainer
 
     typedef typename structure_type::length_type                                    length_type;
     typedef typename structure_type::position_type                                  position_type;
-    typedef typename structure_type::position_type                                  vector_type;
+    typedef typename structure_type::position_type                                  vector_type;    
+    typedef typename structure_type::structure_type_id_type                         structure_type_id_type;
 
     typedef std::pair<structure_id_type, vector_type>                               neighbor_id_vector_type; // FIXME this is actually a datatype of the ConnectivityContainer.
 
@@ -257,6 +258,22 @@ class StructureContainer
         structure_iterator(structure_map_.end(),   structures_second_selector_type()),
         structure_map_.size());
     }
+    virtual boost::shared_ptr<structure_type> get_some_structure_of_type(structure_type_id_type const& sid) const
+    {
+        // This returns a structure of the structure type given as an argument, if it exists
+        // in the container. Otherwise it throws an exception.
+        typename structure_map::const_iterator i;
+        
+        for(i = structure_map_.begin(); i != structure_map_.end(); i++)
+          
+            if( (*i).second->sid() == sid )        break;
+        
+        if (structure_map_.end() == i)
+        {
+            throw not_found(std::string("Could not find any structure of specified structure type (sid=") + boost::lexical_cast<std::string>(sid) + ")");
+        }
+        return (*i).second;
+    }
     virtual bool remove_structure(structure_id_type const& id)
     {
         // TODO
diff --git a/Transaction.hpp b/Transaction.hpp
index fcd3cf53..cf4d4b23 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -219,6 +219,10 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.get_structures();
     }    
+    virtual boost::shared_ptr<structure_type> get_some_structure_of_type(structure_type_id_type const& sid) const
+    {
+        return pc_.get_some_structure_of_type(sid);
+    }
     template <typename Tstructid_pair_>
     bool update_structure(Tstructid_pair_ const& structid_pair)
     {
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 3aa41e80..0685348c 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -638,6 +638,7 @@ inline boost::python::objects::class_base register_particle_container_class(
         // Structure stuff
         .def("get_structure", pure_virtual(&impl_type::get_structure))
         .def("get_structures", pure_virtual(&impl_type::get_structures))
+        .def("get_some_structure_of_type", pure_virtual(&impl_type::get_some_structure_of_type))
 //        .def("update_structure", pure_virtual(&impl_type::update_structure))
 //        .def("update_structure", &impl_type::template update_structure<typename impl_type::cuboidal_region_id_pair_type>)
 //        .def("update_structure", &impl_type::template update_structure<typename impl_type::planar_surface_id_pair_type>)

From 726a5b99b56358767803bae2978ed716470bcf81 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 17:40:49 +0100
Subject: [PATCH 1201/1541] Corresponding binding into Python

---
 binding/ParticleContainer.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 0685348c..4ca32062 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -406,6 +406,11 @@ class ParticleContainerWrapper
     {
         return py_wrapper_type::get_override("get_structures")();
     }
+    
+    virtual boost::shared_ptr<structure_type> get_some_structure_of_type(structure_type_id_type const& sid) const
+    {
+        return py_wrapper_type::get_override("get_some_structure_of_type")(sid);
+    }
 /*
     virtual bool update_structure(cuboidal_region_id_pair_type const& structid_pair)
     {

From 695fb706eed37833d8e34cac37b1c29e53cb264e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 17:41:00 +0100
Subject: [PATCH 1202/1541] Include new function into Multi.hpp

---
 Multi.hpp | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index e863cd53..fc6f3986 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -106,12 +106,16 @@ class MultiParticleContainer
     {
         return world_.get_structures();     // TODO now gets all structures in world, -> make structure local to Multi
     }
+    virtual boost::shared_ptr<structure_type> get_some_structure_of_type(structure_type_id_type const& sid) const
+    {
+        return world_.get_some_structure_of_type(sid);
+    }
     // virtual structure_id_type add_structure(structure_type const& structure); // TODO add structure from the world to multi
     template <typename Tstructid_pair_>
     bool update_structure(Tstructid_pair_ const& structid_pair)
     {
         return world_.update_structure(structid_pair);
-    }
+    }    
     virtual bool remove_structure(structure_id_type const& id)
     {
         return world_.remove_structure(id);
@@ -352,14 +356,16 @@ class MultiParticleContainer
             //    get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
             
             // If structure is within specified range and this particle lives in the default structure
-            //    TODO Extend the last requirement to all "allowed" interactions using the new structure functions
-            if( struct_and_dist.second < 2.0 * s.radius() && s.structure_type_id() == get_def_structure_type_id() )
+            // Here we assume that the user defined the reaction rules for allowed combinations of origin and
+            // target structure type (if this is not the case the simulation will fail at a later stage when
+            // propagation is attempted).
+            if( struct_and_dist.second < 2.0 * s.radius() )
             {
                 // Get the reaction rule for this particle-structure interaction
                 structure_type_id_type const struct_sid( struct_and_dist.first->sid() );
                 reaction_rules const& rrules(rules.query_reaction_rule( s.id(), struct_sid ));
                 if (::size(rrules) == 0)
-                    continue;
+                    continue; // no reaction rule for this structure type
 
                 // If there is rules, determine the largest on-rate for this interaction
                 for (typename boost::range_const_iterator<reaction_rules>::type

From 3cac598c609ec77305bf097a228780935ce31084 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 18:27:19 +0100
Subject: [PATCH 1203/1541] Remove hack that overrode maximal BD rate
 calculation for particles living on different structures

---
 Multi.hpp | 64 ++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 45 insertions(+), 19 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index fc6f3986..b6c1788d 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -355,7 +355,7 @@ class MultiParticleContainer
             //structure_id_and_distance_pair const struct_id_and_dist( 
             //    get_closest_surface( pp.second.position(), pp.second.structure_id() ) );    // only ignore structure that the particle is on.
             
-            // If structure is within specified range and this particle lives in the default structure
+            // If the structure is within a specified range
             // Here we assume that the user defined the reaction rules for allowed combinations of origin and
             // target structure type (if this is not the case the simulation will fail at a later stage when
             // propagation is attempted).
@@ -395,30 +395,56 @@ class MultiParticleContainer
                 reaction_rules const& rrules(rules.query_reaction_rule( s0.id(), s1.id() ));
                 if (::size(rrules) == 0)
                     continue;
+                
+                // Get two example structures with the structure types of the two species.
+                // This is a necessary workaround because as yet the rate functions are methods
+                // to the structures and not the structure types.
+                // If the quried structures do not exist we do not have to bother further with 
+                // this combination of species and just continue.
+//                 structure_type s0_dummy_struct, s1_dummy_struct;
+//                 try{
+//                     s0_dummy_struct = get_some_structure_of_type(s0.structure_type_id());
+//                     s1_dummy_struct = get_some_structure_of_type(s1.structure_type_id());
+//                 }
+//                 catch(not_found const&)
+//                 {
+//                     // In fact this exception should never occur because every species 
+//                     // has a uniquely defined structure type, i.e. if we have this species 
+//                     // in the multi a structure of the right type must exist.
+//                     continue;   // TODO Output a warning?
+//                 }
                                             
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
                     const length_type r01( s0.radius() + s1.radius() );
-                    Real k;
+                    Real k0, k1;
                     
-                    if(s0.structure_type_id() != s1.structure_type_id())
-                    {
-                        if(s0.structure_type_id() == get_def_structure_type_id())
-                            k = 0.001;  // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
-                                        // TODO This is because we do not know the structure here, only structure type
-                                        // Use structure functions here?
-                        else
-                            k = 0.001;  // HACK k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
-                    }
-                    else
-                    {
-                        k = 0.001;      // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
-                    }
-                
-                    if ( k_max < k )
-                        k_max = k;
-                }          
+                    // To access the rate functions we first find some structure of the structure type of the 
+                    // species considered and then calculate the modified rate. This is a necessary workaround
+                    // because as yet the rate functions are methods to the structure, not the structure type.
+                    k0 = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                    k1 = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                    
+                    // Compare with the fasted rate found so far
+                    if ( k_max < k0 )    k_max = k0;
+                    if ( k_max < k1 )    k_max = k1;
+                 
+//                     // PREVIOUS VERSION
+//                     if(s0.structure_type_id() != s1.structure_type_id())
+//                     {
+//                         if(s0.structure_type_id() == get_def_structure_type_id())
+//                             k = 0.001;  // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+//                                         // TODO This is because we do not know the structure here, only structure type
+//                                         // Use structure functions here?
+//                         else
+//                             k = 0.001;  // HACK k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
+//                     }
+//                     else
+//                     {
+//                         k = 0.001;      // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
+//                     }                                    
+                }
             }
             i++;
         }

From 164ec6d4b090eb02d6dc6af0542a1ea296306456 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 18:40:37 +0100
Subject: [PATCH 1204/1541] Cleanup

---
 Multi.hpp | 45 +++++++++++----------------------------------
 1 file changed, 11 insertions(+), 34 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index b6c1788d..1dd28b86 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -394,29 +394,12 @@ class MultiParticleContainer
                 
                 reaction_rules const& rrules(rules.query_reaction_rule( s0.id(), s1.id() ));
                 if (::size(rrules) == 0)
-                    continue;
-                
-                // Get two example structures with the structure types of the two species.
-                // This is a necessary workaround because as yet the rate functions are methods
-                // to the structures and not the structure types.
-                // If the quried structures do not exist we do not have to bother further with 
-                // this combination of species and just continue.
-//                 structure_type s0_dummy_struct, s1_dummy_struct;
-//                 try{
-//                     s0_dummy_struct = get_some_structure_of_type(s0.structure_type_id());
-//                     s1_dummy_struct = get_some_structure_of_type(s1.structure_type_id());
-//                 }
-//                 catch(not_found const&)
-//                 {
-//                     // In fact this exception should never occur because every species 
-//                     // has a uniquely defined structure type, i.e. if we have this species 
-//                     // in the multi a structure of the right type must exist.
-//                     continue;   // TODO Output a warning?
-//                 }
+                    continue;   // no rule for reactions between these two species
                                             
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
+                    // We have found a valid rule - get the rate
                     const length_type r01( s0.radius() + s1.radius() );
                     Real k0, k1;
                     
@@ -425,25 +408,19 @@ class MultiParticleContainer
                     // because as yet the rate functions are methods to the structure, not the structure type.
                     k0 = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
                     k1 = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                    // NOTE: If a structure of the required structure type can not be found a not_found exception
+                    // is risen. This however should never happen, because whenever a particle of species s0 (s1)
+                    // is in the system also at least one structure of the associated structure type should exist.
                     
                     // Compare with the fasted rate found so far
                     if ( k_max < k0 )    k_max = k0;
                     if ( k_max < k1 )    k_max = k1;
-                 
-//                     // PREVIOUS VERSION
-//                     if(s0.structure_type_id() != s1.structure_type_id())
-//                     {
-//                         if(s0.structure_type_id() == get_def_structure_type_id())
-//                             k = 0.001;  // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
-//                                         // TODO This is because we do not know the structure here, only structure type
-//                                         // Use structure functions here?
-//                         else
-//                             k = 0.001;  // HACK k = get_structure( s1.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 );
-//                     }
-//                     else
-//                     {
-//                         k = 0.001;      // HACK k = get_structure( s0.structure_id() )->get_1D_rate_geminate( (*it).k(), r01 ); 
-//                     }                                    
+                    
+                    // TODO Right now we do not make any distinction here between two particles on structures of
+                    // the same type or of the different type. This way we possibly include rates here which are
+                    // higher than the actual reaction rate for this combination of species. We could improve
+                    // overall performance by dissecting the situation in a more detailed way and use the 
+                    // right function to modify the intrinsic rate.
                 }
             }
             i++;

From cf70dc112107ae939b46a8e46b0f1ed574f4ecdf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 29 Oct 2012 19:33:28 +0100
Subject: [PATCH 1205/1541] Introduce a flag that allows to override reset of
 counters to avoid loss of statistics at save events with reloading

---
 egfrd.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 01ad4761..12bb4082 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -192,7 +192,7 @@ class EGFRDSimulator(ParticleSimulatorBase):
     this 'world'.
     """
 
-    def __init__(self, world, rng=myrandom.rng, network_rules=None):
+    def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
         """Create a new EGFRDSimulator.
 
         Arguments:
@@ -260,7 +260,8 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None):
                                                 # consistent with the content of the world that it represents
                                                 # (or if we don't know for sure)
 
-        self.reset()                            # The Simulator is only initialized at the first step, allowing
+        if reset:
+            self.reset()                        # The Simulator is only initialized at the first step, allowing
                                                 # modifications to the world to be made before simulation starts
 
     def get_next_time(self):
@@ -3283,7 +3284,8 @@ def load_state(self, filename):
         # Re-initialize the simulator using the seed
         # from the input file
         self.reset_seed(seed)
-        self.__init__(world, myrandom.rng)
+        self.__init__(world, myrandom.rng, reset=False)
+            # reset=False ensures the statistics are not lost
 
         # Set the simulator time to the time it had at output
         # This is to avoid divergence between the original and the

From b8676b21731d0b03a7a8c8395921bb812bd81679 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 30 Oct 2012 14:39:51 +0100
Subject: [PATCH 1206/1541] Small fix to edge-hits-barrel cylinder scaling

---
 shells.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/shells.py b/shells.py
index 0eba2bef..7295deb6 100755
--- a/shells.py
+++ b/shells.py
@@ -1304,6 +1304,12 @@ def r1_eq(x):
             # the scaling cylinder hits the barrel of 'shell' with its edge
             shell_radius_sq = shell_radius*shell_radius
 
+            # If scale_angle == 0, the scale center is offset from the reference point,
+            # located at the barrel of the scaled cylinder. In order for the below calculation
+            # to succeed we have to take this into account. In general scale_center_r == 0
+            # so that this step only affects the scale_angle == 0 cases:
+            scale_center_to_shell_y -= scale_center_r
+
             ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_y**2)
             scale_center_to_shell = math.sqrt(ss_sq)
 
@@ -1313,8 +1319,10 @@ def r1_eq(x):
             cos_angle_diff = math.cos(angle_diff)
 
             # TODO TESTING Laurens' version
+            # Remove this when it is certain that the new version does not fail
             #scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
                                        #math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
+            
             assert scale_center_to_shell >= shell_radius
             ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
             scale_center_shell_dist = shell_radius * math.sin(math.pi-(angle_diff+ss_angle)) / math.sin(angle_diff)

From 72d8dbc187c5cf85cc36e88e6484740e8589ab08 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 30 Oct 2012 15:22:41 +0100
Subject: [PATCH 1207/1541] More explicit distinction for rate determination in
 Multi.hpp based on whether one particle is in the 3D bulk or not

---
 Multi.hpp | 37 ++++++++++++++++++++++++++-----------
 1 file changed, 26 insertions(+), 11 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 1dd28b86..f981d09a 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -401,26 +401,41 @@ class MultiParticleContainer
                 {
                     // We have found a valid rule - get the rate
                     const length_type r01( s0.radius() + s1.radius() );
-                    Real k0, k1;
+                    Real k(0.0), k0, k1;
                     
                     // To access the rate functions we first find some structure of the structure type of the 
                     // species considered and then calculate the modified rate. This is a necessary workaround
                     // because as yet the rate functions are methods to the structure, not the structure type.
-                    k0 = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
-                    k1 = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                    
+                    // If one of the two particles lives in the default structure (bulk) we always take the 
+                    // 3D rate, i.e. call the get_1D_rate_geminate() method of the bulk structure.
+                    if      (s0.structure_type_id() == get_def_structure_type_id() )
+                        
+                        k = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                    
+                    else if (s1.structure_type_id() == get_def_structure_type_id() )
+                        
+                        k = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                    
+                    else
+                    // If both particles live on lower dimensionality structures for now we take the maximal rate
+                    // as determined from get_1D_rate_geminate() of both structures. TODO This may lead to a maximal
+                    // rate which actually is higher than the one used in BD propagation and therefore waste resources.
+                    // Until now this case basically only comprises the rod-particle/cap-particle interaction. Since
+                    // both rates are equal in this case we do not make any approximation in that case. However, if we
+                    // allow for other types of lower dimensionality particle-particle reactions we should fix this.
+                    {
+                        k0 = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                        k1 = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                        
+                        k = k0 > k1 ? k0 : k1;
+                    }
                     // NOTE: If a structure of the required structure type can not be found a not_found exception
                     // is risen. This however should never happen, because whenever a particle of species s0 (s1)
                     // is in the system also at least one structure of the associated structure type should exist.
                     
                     // Compare with the fasted rate found so far
-                    if ( k_max < k0 )    k_max = k0;
-                    if ( k_max < k1 )    k_max = k1;
-                    
-                    // TODO Right now we do not make any distinction here between two particles on structures of
-                    // the same type or of the different type. This way we possibly include rates here which are
-                    // higher than the actual reaction rate for this combination of species. We could improve
-                    // overall performance by dissecting the situation in a more detailed way and use the 
-                    // right function to modify the intrinsic rate.
+                    k_max = k > k_max ? k : k_max;
                 }
             }
             i++;

From e869772b55c0784fe5987c1e2f580f50dc121761 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 30 Oct 2012 16:03:22 +0100
Subject: [PATCH 1208/1541] A (somewhat crude but effective) fix to treat quick
 rebindings in pair domains

The 2D Greens functions have problems to determine the next event type for very
small timesteps which can occur at pair formation directly after a dissociation
into two single particles that can immediately rebind (high forward rate limit).

Python limits floating point precision which causes very small times to be
recognized as zero. This is why we set them to a very low but still finite
value (TIME_TOLERANCE) in case they fall below that limit.
---
 pair.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index c63b1bfe..50902683 100644
--- a/pair.py
+++ b/pair.py
@@ -136,8 +136,12 @@ def determine_next_event(self, r0):
                    self.draw_single_reaction_time_tuple()) 
 
     def draw_iv_event_type(self, r0):
-        gf = self.iv_greens_function(r0)
-        event_kind = draw_event_type_wrapper(gf, self.dt)
+        gf = self.iv_greens_function(r0)        
+        if self.dt < TIME_TOLERANCE:
+            dt = TIME_TOLERANCE
+        else:
+            dt = self.dt
+        event_kind = draw_event_type_wrapper(gf, dt)
         if event_kind == PairEventKind.IV_REACTION:
             return EventType.IV_REACTION
         elif event_kind == PairEventKind.IV_ESCAPE:

From ac95569a8df6b7a29c23242f100a8afeddbd5309 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 30 Oct 2012 16:26:49 +0100
Subject: [PATCH 1209/1541] Use TIME_TOLERANCE**2 instead of TIME_TOLERANCE

which should be more accurate.
---
 pair.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 50902683..5e1445bc 100644
--- a/pair.py
+++ b/pair.py
@@ -137,8 +137,8 @@ def determine_next_event(self, r0):
 
     def draw_iv_event_type(self, r0):
         gf = self.iv_greens_function(r0)        
-        if self.dt < TIME_TOLERANCE:
-            dt = TIME_TOLERANCE
+        if self.dt < TIME_TOLERANCE**2:
+            dt = TIME_TOLERANCE**2
         else:
             dt = self.dt
         event_kind = draw_event_type_wrapper(gf, dt)

From 7254dc04b6e41011b2404f4761155b36816942d8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 30 Oct 2012 17:47:21 +0100
Subject: [PATCH 1210/1541] Some more debug output for non-converging pairs

---
 egfrd.py |  3 +++
 pair.py  | 14 ++++++++------
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 12bb4082..e1adfdec 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2035,6 +2035,9 @@ def process_pair_event(self, pair, ignore):
             # Draw actual pair event for iv at very last minute.
             pair.event_type = pair.draw_iv_event_type(pair.r0)
 
+            if __debug__:
+                log.info('Specified event type: IV_EVENT = %s' % pair.event_type)
+
 
         ### 3. Process the event produced by the pair
 
diff --git a/pair.py b/pair.py
index 5e1445bc..e4966526 100644
--- a/pair.py
+++ b/pair.py
@@ -275,7 +275,9 @@ def determine_radii(self, r0, shell_size):
 
         # Make sure that D1 != 0 to avoid division by zero in the followings.
         if D1 == 0:
-            D1, D2 = D2, D1     # shouldn't we also here swap the particle radii if we're swapping diffusion contants?
+            D1, D2 = D2, D1     # FIXME shouldn't we also here swap the particle radii if we're swapping diffusion contants?
+            if __debug__:
+                log.info('Swapping D1 and D2 because D1==0 (to avoid division by zero).')
 
         shell_size /= SAFETY    #??
 
@@ -314,7 +316,7 @@ def determine_radii(self, r0, shell_size):
             a_r = a_r_max
             a_R = shell_size - radiusa - a_r * Da / D_tot
             if __debug__:
-                log.info('domainsize changed for convergence.')
+                log.info('Domainsize changed for convergence: a_r = a_r_max = %s, a_R = %s' % (a_r, a_R))
 
         assert a_R + a_r * Da / D_tot + radiusa >= \
                a_R + a_r * Db / D_tot + radiusb
@@ -324,15 +326,15 @@ def determine_radii(self, r0, shell_size):
 
 
         if __debug__:
-          log.debug('a %g, r %g, R %g r0 %g' % 
+          log.debug('shell_size = %g, a_r = %g, a_R = %g r0 = %g' % 
                  (shell_size, a_r, a_R, r0))
         if __debug__:
-            tr = ((a_r - r0)**2) / (6 * self.D_r)       # the expected escape time of the iv
+            tr = ((a_r - r0)**2) / (6 * self.D_r)       # the expected escape time of the IV
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
                 tR = (a_R**2) / (6 * self.D_R)          # the expected escape time of the CoM
-            log.debug('tr %g, tR %g' % (tr, tR))
+            log.debug('tr = %g, tR = %g' % (tr, tR))
 
 
         assert a_r > 0
@@ -1114,7 +1116,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # D_r and D_R are inherited from Pair class;
         # This results in D_r = particle1D.D and D_R = 0
 
-        self.LD_MAX = numpy.inf # TODO what is that for?
+        self.LD_MAX = numpy.inf
 
     def get_shell_size(self):   # TODO Is that even used?
         return self.shell.shape.half_length

From 8ea7d6a64f97700e879be1bd6d3e31169c11b7c3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 30 Oct 2012 19:09:16 +0100
Subject: [PATCH 1211/1541] Temporarily increase numerical error tolerance to
 1e-9 in 2d Rad-Abs GF

---
 GreensFunction2DRadAbs.hpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index d1f049e5..9b4cd11d 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -42,13 +42,13 @@ class GreensFunction2DRadAbs
 
     static const Real L_TYPICAL = 1E-7; // typical length scale
     static const Real T_TYPICAL = 1E-5; // typical time scale
-    static const Real EPSILON = 1E-12;  // relative numeric error
+    static const Real EPSILON = 1E-9    // relative numeric error  // TESTING temporarily increased; was 1e-12
 
     // DEFAULT = 30
-    static const unsigned int MAX_ORDER = 30;		// The maximum number of m 
-                                                    // terms
-    static const unsigned int MAX_ALPHA_SEQ = 500;	// The maximum number of n 
-                                                    // terms
+    static const unsigned int MAX_ORDER = 30;         // The maximum number of m 
+                                                      // terms
+    static const unsigned int MAX_ALPHA_SEQ = 500;    // The maximum number of n 
+                                                      // terms
     
     // Parameters for alpha-root finding
     // ======

From 7f1a306f9c464c1a6d71bc10e3d8ab0e3c23049a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 31 Oct 2012 14:10:29 +0100
Subject: [PATCH 1212/1541] More informative debug output when placing
 particles

---
 gfrdbase.py | 25 ++++++++++++++++---------
 loadsave.py |  3 +--
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 67f23cac..9695d109 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -429,6 +429,13 @@ def place_particle(world, sid, position):
     model.ParticleModel.add_species_type.
 
     """
+    if __debug__:
+        name = world.model.get_species_type_by_id(sid)["name"]
+        if name[0] != '(':
+            name = '(' + name + ')'
+        log.info('Attempting to place particle of species %s at position %s' %
+                 (name, position) )
+
     species = world.get_species(sid)
     radius = species.radius
 
@@ -436,7 +443,7 @@ def place_particle(world, sid, position):
 
     # check that particle doesn't overlap with other particles.
     if world.check_overlap((position, radius)):
-        raise NoSpace, 'Placing particle failed: overlaps with other particle.'
+        raise NoSpace, '  Placing particle failed: overlaps with other particle.'
 
     # Get the IDs of all structures of the structure type that this particle species lives on
     structure_ids = world.get_structure_ids(world.get_structure_type(species.structure_type_id))
@@ -470,17 +477,17 @@ def place_particle(world, sid, position):
         structure_id = world.get_def_structure_id()
         if world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
                                        position, structure_id, radius):#(surface and distance < surface.minimal_distance(species.radius)):
-            raise RuntimeError('Placing particle failed: %s %s. '
-                               'Too close to surface: %s.' %
-                               (sid, position, distance))
+            raise RuntimeError('  Placing particle failed: %s %s. '
+                               '  Too close to surface: %s.' %
+                                  (sid, position, distance) )
     else:
         # If the particle lives on a surface then the position should be in the closest surface.
         # The closest surface should also be of the structure_type associated with the species.        
         if not (surface and 
                 distance < TOLERANCE*radius and 
                 surface.id in structure_ids):
-            raise RuntimeError('Placing particle failed: %s %s. Position should be in structure of structure_type \"%s\".' %
-                                (sid, position, world.get_structure_type(species.structure_type_id)['name']))
+            raise RuntimeError('  Placing particle failed: %s %s. Position should be in structure of structure_type \"%s\".' %
+                                  (sid, position, world.get_structure_type(species.structure_type_id)['name']) )
         else:
             structure_id = surface.id
 
@@ -488,14 +495,14 @@ def place_particle(world, sid, position):
         name = world.model.get_species_type_by_id(sid)["name"]
         if name[0] != '(':
             name = '(' + name + ')'
-        log.info('\n\tplacing particle of type %s to structure \"%s\" at position %s' %
-                 (name, world.get_structure(structure_id).name, position))
+        log.info('  Placed particle of species %s on structure \"%s\" at position %s' %
+                    (name, world.get_structure(structure_id).name, position))
 
     position, structure_id = world.apply_boundary((position, structure_id))
     particle = world.new_particle(sid, structure_id, position)
 
     if __debug__:
-        log.info('(%s,\n %s' % (particle[0], particle[1]))
+        log.info('  Particle info: (%s, %s)' % (particle[0], particle[1]) )
 
     return particle
 
diff --git a/loadsave.py b/loadsave.py
index a8c39f85..2fe96500 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -899,8 +899,7 @@ def load_state(filename):
         particle_species = species_dict[ particle['species_id'] ]
         
         placed = place_particle(w, particle_species, particle['position'])
-        if __debug__:
-            log.info('  Placed particle %s' % str(placed) )
+        # place_particle generates log info when placing
 
 
     # Return the world and the seed that was used 

From bb5f6a5b4dc4d00c63ca6f83ad684702cd10bde3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 31 Oct 2012 14:13:49 +0100
Subject: [PATCH 1213/1541] 2 more warnings

---
 gfrdbase.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 9695d109..1e3b004b 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -452,7 +452,7 @@ def place_particle(world, sid, position):
     surfaces = get_all_surfaces(world, position, [])
     if surfaces:
         # Get the closest surface of the structure type 
-        # for this particle species: we cannot simply take
+        # for this particle species. We cannot simply take
         # the closest structure because for a disk-bound
         # particle this can be either the disk or cylinder
         # => choose the one with the right structure type
@@ -467,9 +467,13 @@ def place_particle(world, sid, position):
                 # there is no such structure, placement
                 # will be impossible
                 surface, distance = None, numpy.inf
+                if __debug__:
+                    log.warning('  Could not find any structure with required structure type in the system!')
     else:
         # no structure around, we can't place the particle
         surface, distance = None, numpy.inf
+        if __debug__:
+            log.warning('  No structures around, cannot place particle!')
 
     # Check if not too close to neighbouring structures for particles 
     # added to the world, or added to a self-defined box.

From 16e715c8b61ef8a0781af48d1c2aa73fc4b7f64c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 31 Oct 2012 14:19:56 +0100
Subject: [PATCH 1214/1541] Only check whether in the right structure when not
 living on default structure type

---
 gfrdbase.py | 56 ++++++++++++++++++++++++++++-------------------------
 1 file changed, 30 insertions(+), 26 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 1e3b004b..5507b63f 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -448,32 +448,36 @@ def place_particle(world, sid, position):
     # Get the IDs of all structures of the structure type that this particle species lives on
     structure_ids = world.get_structure_ids(world.get_structure_type(species.structure_type_id))
 
-    # Get all neighboring surfaces ordered by their distance to the particle
-    surfaces = get_all_surfaces(world, position, [])
-    if surfaces:
-        # Get the closest surface of the structure type 
-        # for this particle species. We cannot simply take
-        # the closest structure because for a disk-bound
-        # particle this can be either the disk or cylinder
-        # => choose the one with the right structure type
-        for s in range(0, len(surfaces)):
-            surface, distance = surfaces[s]
-
-            if surface.id in structure_ids:
-                # we have found the closest surface with
-                # the required structure type
-                break;
-            else:
-                # there is no such structure, placement
-                # will be impossible
-                surface, distance = None, numpy.inf
-                if __debug__:
-                    log.warning('  Could not find any structure with required structure type in the system!')
-    else:
-        # no structure around, we can't place the particle
-        surface, distance = None, numpy.inf
-        if __debug__:
-            log.warning('  No structures around, cannot place particle!')
+    # If this particle does not live on the default structure first check whether
+    # the position is indeed within a structure of the right structure type
+    if species.structure_type_id != world.get_def_structure_type_id():
+        # Get all neighboring surfaces ordered by their distance to the particle
+        surfaces = get_all_surfaces(world, position, [])
+        if surfaces:
+            # Get the closest surface of the structure type 
+            # for this particle species. We cannot simply take
+            # the closest structure because for a disk-bound
+            # particle this can be either the disk or cylinder
+            # => choose the one with the right structure type
+            for s in range(0, len(surfaces)):
+                surface, distance = surfaces[s]
+
+                if surface.id in structure_ids:
+                    # we have found the closest surface with
+                    # the required structure type
+                    break;
+                else:
+                    # there is no such structure, placement
+                    # will be impossible
+                    surface, distance = None, numpy.inf
+
+            if __debug__ and surface == None:
+                log.warning('  Could not find any structure with required structure type in the system!')
+        else:
+            # no structure around, we can't place the particle
+            surface, distance = None, numpy.inf
+            if __debug__:
+                log.warning('  No structures around, cannot place particle!')
 
     # Check if not too close to neighbouring structures for particles 
     # added to the world, or added to a self-defined box.

From bd4643263ff1d40100c3445cc15fc5f966c968de Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 31 Oct 2012 15:16:09 +0100
Subject: [PATCH 1215/1541] Allow bulk particles to overlap with planes when
 placing particles

---
 gfrdbase.py | 37 +++++++++++++++++++++++++++++--------
 1 file changed, 29 insertions(+), 8 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 5507b63f..2273ff5a 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -8,6 +8,15 @@
 
 
 import _gfrd
+from _gfrd import (
+    CuboidalRegion,
+    SphericalSurface,
+    CylindricalSurface,
+    DiskSurface,
+    PlanarSurface,
+    Surface
+    )  # to perform instance checks
+
 from utils import *
 
 import os
@@ -448,11 +457,13 @@ def place_particle(world, sid, position):
     # Get the IDs of all structures of the structure type that this particle species lives on
     structure_ids = world.get_structure_ids(world.get_structure_type(species.structure_type_id))
 
+    # Get all neighboring surfaces ordered by their distance to the particle
+    surfaces = get_all_surfaces(world, position, [])
+
     # If this particle does not live on the default structure first check whether
     # the position is indeed within a structure of the right structure type
     if species.structure_type_id != world.get_def_structure_type_id():
-        # Get all neighboring surfaces ordered by their distance to the particle
-        surfaces = get_all_surfaces(world, position, [])
+
         if surfaces:
             # Get the closest surface of the structure type 
             # for this particle species. We cannot simply take
@@ -472,22 +483,32 @@ def place_particle(world, sid, position):
                     surface, distance = None, numpy.inf
 
             if __debug__ and surface == None:
-                log.warning('  Could not find any structure with required structure type in the system!')
+                log.warning('  Could not find any structure with required structure type in the system.')
         else:
             # no structure around, we can't place the particle
             surface, distance = None, numpy.inf
             if __debug__:
-                log.warning('  No structures around, cannot place particle!')
+                log.warning('  No surfaces around, cannot place particle of surface-bound species %s.' % str(species)) 
 
     # Check if not too close to neighbouring structures for particles 
     # added to the world, or added to a self-defined box.
     if species.structure_type_id == world.get_def_structure_type_id():
-        structure_id = world.get_def_structure_id()
-        if world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
-                                       position, structure_id, radius):#(surface and distance < surface.minimal_distance(species.radius)):
+        
+        structure_id = world.get_def_structure_id()        
+        surface, distance = surfaces[0]  # the closest surface
+        overlaps = world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
+                                                position, structure_id, radius)
+
+        # Raise an error in case of overlap with a surface other than PlanarSurface
+        # (the latter we allow to overlap with bulk particles)
+        if overlaps and not isinstance(surface, PlanarSurface):
             raise RuntimeError('  Placing particle failed: %s %s. '
                                '  Too close to surface: %s.' %
-                                  (sid, position, distance) )
+                                  (sid, position, surface) )
+
+        if overlaps and isinstance(surface, PlanarSurface):
+            log.warning('  Particle of species %s placed at position %s overlaps with surface %s.' % \
+                           (sid, position, surface) )
     else:
         # If the particle lives on a surface then the position should be in the closest surface.
         # The closest surface should also be of the structure_type associated with the species.        

From 75df4ce28ef93cd82ee2f6a1577c2a2d07d31a14 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 31 Oct 2012 17:32:53 +0100
Subject: [PATCH 1216/1541] Count (single) steps spent in make_new_domain in
 statistics

---
 egfrd.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index e1adfdec..a0791f32 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -290,7 +290,8 @@ def reset(self):
         self.step_counter = 0
         self.single_steps = {EventType.SINGLE_ESCAPE:0,
                              EventType.SINGLE_REACTION:0,
-                             EventType.BURST:0}
+                             EventType.BURST:0,
+                             'MAKE_NEW_DOMAIN':0}
         self.interaction_steps = {EventType.IV_INTERACTION:0,
                                   EventType.IV_ESCAPE:0,
                                   EventType.BURST:0}
@@ -1740,6 +1741,8 @@ def make_new_domain(self, single):
         if self.CREATION_HISTOGRAMS:
             self.DomainCreationHists.bin_domain(bin_domain)
 
+        self.single_steps['MAKE_NEW_DOMAIN'] += 1
+
         return domain
 
 
@@ -1936,7 +1939,7 @@ def process_single_event(self, single, ignore):
                 # Update statistics
                 if single.event_type == EventType.SINGLE_ESCAPE or\
                    single.event_type == EventType.BURST:
-                    self.single_steps[single.event_type] += 1                
+                    self.single_steps[single.event_type] += 1
                 elif __debug__:
                     log.warning('Omitting to count a single event with unforeseen event type (%s).' % single.event_type)
                     
@@ -2679,7 +2682,7 @@ def print_report(self, out=None):
 t = %g
 \tNonmulti: %g\tMulti: %g
 steps = %d 
-\tSingle:\t%d\t(%.2f %%)\t(escape: %d, reaction: %d, bursted: %d)
+\tSingle:\t%d\t(%.2f %%)\t(escape: %d, reaction: %d, bursted: %d, make_new_domain: %d)
 \tInteraction: %d\t(%.2f %%)\t(escape: %d, interaction: %d, bursted: %d)
 \tPair:\t%d\t(%.2f %%)\t(r-escape: %d, R-escape: %d, reaction pair: %d, single: %d, bursted: %d)
 \tMulti:\t%d\t(%.2f %%)\t(diffusion: %d, escape: %d, reaction pair: %d, single: %d, bursted: %d)
@@ -2692,6 +2695,7 @@ def print_report(self, out=None):
                self.single_steps[EventType.SINGLE_ESCAPE],
                self.single_steps[EventType.SINGLE_REACTION],
                self.single_steps[EventType.BURST],
+               self.single_steps['MAKE_NEW_DOMAIN'],
                interaction_steps,
                (100.0*interaction_steps) / total_steps,
                self.interaction_steps[EventType.IV_ESCAPE],

From d207506aaf7b6904affc7d14bddefd8fc979682d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 31 Oct 2012 18:48:54 +0100
Subject: [PATCH 1217/1541] More accurate statistics report

- report average multi time step and reaction length
- make a distinction between steps and updates;
  updates include actions that are the consequence of a
  a regular step which is initiated by picking a next event
  time from the scheduler, such as bursting events.
---
 egfrd.py | 20 ++++++++++++++------
 multi.py |  3 ---
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a0791f32..2339984b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -311,6 +311,8 @@ def reset(self):
         self.multi_time = 0.0
         self.nonmulti_time = 0.0
 
+        self.multi_rl = 0.0
+
         self.rejected_moves = 0
         self.reaction_events = 0
         self.last_event = None
@@ -2248,6 +2250,7 @@ def process_multi_event(self, multi, ignore):
         self.multi_steps[multi.last_event] += 1
         self.multi_steps[3] += 1  # multi_steps[3]: total multi steps
         self.multi_time += multi.dt
+        self.multi_rl   += multi.reaction_length
         multi.step()
 
         if(multi.last_event == EventType.MULTI_UNIMOLECULAR_REACTION or
@@ -2671,25 +2674,28 @@ def print_report(self, out=None):
         Arguments:
             - None
 
-        """
-        total_steps = self.step_counter
+        """        
         single_steps = numpy.array(self.single_steps.values()).sum()
         interaction_steps = numpy.array(self.interaction_steps.values()).sum()
         pair_steps = numpy.array(self.pair_steps.values()).sum()
         multi_steps = self.multi_steps[3] # total multi steps
+        total_steps = single_steps + interaction_steps + pair_steps + multi_steps
 
         report = '''
 t = %g
 \tNonmulti: %g\tMulti: %g
-steps = %d 
+steps: %d 
+updates: %d
 \tSingle:\t%d\t(%.2f %%)\t(escape: %d, reaction: %d, bursted: %d, make_new_domain: %d)
 \tInteraction: %d\t(%.2f %%)\t(escape: %d, interaction: %d, bursted: %d)
 \tPair:\t%d\t(%.2f %%)\t(r-escape: %d, R-escape: %d, reaction pair: %d, single: %d, bursted: %d)
 \tMulti:\t%d\t(%.2f %%)\t(diffusion: %d, escape: %d, reaction pair: %d, single: %d, bursted: %d)
-total reactions = %d
-rejected moves = %d
+\tavg. multi time step: %d, avg. multi reaction length: %d
+total reactions: %f
+rejected moves:  %f
 ''' \
-            % (self.t, self.nonmulti_time, self.multi_time, total_steps,
+            % (self.t, self.nonmulti_time, self.multi_time,
+               self.step_counter, total_steps,
                single_steps,
                (100.0*single_steps) / total_steps,
                self.single_steps[EventType.SINGLE_ESCAPE],
@@ -2715,6 +2721,8 @@ def print_report(self, out=None):
                self.multi_steps[EventType.MULTI_BIMOLECULAR_REACTION],
                self.multi_steps[EventType.MULTI_UNIMOLECULAR_REACTION],
                self.multi_steps[EventType.BURST],
+               1.0 * self.multi_time / multi_steps,
+               1.0 * self.multi_rl   / multi_steps,
                self.reaction_events,
                self.rejected_moves
                )
diff --git a/multi.py b/multi.py
index b4dad6d5..249d9b2b 100644
--- a/multi.py
+++ b/multi.py
@@ -35,9 +35,6 @@ def initialize(self, t):
         self.start_time = t
         main = self.main()
         self.set_dt_and_reaction_length()
-        # DEBUG stuff
-        print "Multi init, dt = %s, rl = %s" %(self.dt,self.reaction_length) # TESTING
-        #self.dt = self.dt_factor * self.calculate_bd_dt(main.world.get_species(sid) for sid in main.world.species)
 
     def calculate_bd_dt(species_list):
         D_list = []

From 4b6ff9dcd9b880b6f34efe8aeb005cf6676715f9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 31 Oct 2012 19:49:49 +0100
Subject: [PATCH 1218/1541] Small fix to stats

---
 egfrd.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2339984b..9b8d8b89 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2690,9 +2690,9 @@ def print_report(self, out=None):
 \tInteraction: %d\t(%.2f %%)\t(escape: %d, interaction: %d, bursted: %d)
 \tPair:\t%d\t(%.2f %%)\t(r-escape: %d, R-escape: %d, reaction pair: %d, single: %d, bursted: %d)
 \tMulti:\t%d\t(%.2f %%)\t(diffusion: %d, escape: %d, reaction pair: %d, single: %d, bursted: %d)
-\tavg. multi time step: %d, avg. multi reaction length: %d
-total reactions: %f
-rejected moves:  %f
+\tavg. multi time step: %e, avg. multi reaction length: %e
+total reactions: %d
+rejected moves:  %d
 ''' \
             % (self.t, self.nonmulti_time, self.multi_time,
                self.step_counter, total_steps,

From b09ddadc8c9ddb4e10f39e9e76c65aab34227b0a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 1 Nov 2012 12:44:57 +0100
Subject: [PATCH 1219/1541] Increase single shell factor to 3.0 again

Maybe we can reduce it again when the small-cylinder bursting
problems are resolved.
---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index d36ee3c3..be56d498 100644
--- a/utils.py
+++ b/utils.py
@@ -43,7 +43,7 @@
                      # IMPORTANT NOTE: MULTI_SHELL_FACTOR should be AT LEAST sqrt(2) !
                      # This stems from the fact that there is vacant space in the cylinder
 
-SINGLE_SHELL_FACTOR = 2.5 #2.0*MULTI_SHELL_FACTOR
+SINGLE_SHELL_FACTOR = 3.0 #2.0*MULTI_SHELL_FACTOR
                       # This is the threshold for when the algorithm switches from forming
                       # NonInteractionSingles to forming a Pair or Interaction. It also defines
                       # the radius in which the NonInteractionSingle will burst intruding domains.

From 735b1878cca7d0cfe1911db1b5c541e7286f2758 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 1 Nov 2012 16:57:27 +0100
Subject: [PATCH 1220/1541] Pass radius*SINGLE_SHELL_FACTOR as burst radius to
 burst_volume()

---
 egfrd.py  | 10 +++++-----
 shells.py |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 9b8d8b89..190781e5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -876,7 +876,7 @@ def burst_volume(self, pos, radius, ignore=[]):
         # Then we may want to burst in a cylindrical volume, not a sphere.
         # Same for the 1D particles on rods.
 
-        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, radius, ignore)
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, SAFETY*radius, ignore)
 
         return self.burst_domains(neighbor_ids, ignore)
 
@@ -1086,7 +1086,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             if not ((product_pos_list[0] == reactant_pos).all()) or product_radius > reactant_radius:
                 product_pos = self.world.apply_boundary(product_pos_list[0])
                 radius = self.world.distance(product_pos, reactant_pos) + product_radius
-                zero_singles, ignore = self.burst_volume(product_pos, radius, ignore)
+                zero_singles, ignore = self.burst_volume(product_pos, radius*SINGLE_SHELL_FACTOR, ignore)
 
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
@@ -1307,7 +1307,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             product2_pos = self.world.apply_boundary(product_pos_list[0][1])
             radius = max(self.world.distance(product1_pos, reactant_pos) + product1_radius,
                          self.world.distance(product2_pos, reactant_pos) + product2_radius)
-            zero_singles, ignore = self.burst_volume(reactant_pos, radius, ignore)
+            zero_singles, ignore = self.burst_volume(reactant_pos, radius*SINGLE_SHELL_FACTOR, ignore)
 
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
@@ -1419,7 +1419,7 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
             #    reactant particle moving into the surface.
             #    Note that the burst is recursive!!
             if product_radius > reactant_radius:
-                zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
+                zero_singles, ignore = self.burst_volume(product_pos, product_radius*SINGLE_SHELL_FACTOR, ignore)
 
             # 3. check that there is space for the products 
             # Note that we do not check for interfering surfaces (we assume this is no problem)
@@ -1518,7 +1518,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, reactant1_struc
             # 2.1 if the product particle sticks out of the shell
 
             #if self.world.distance(old_com, product_pos) > (pair.get_shell_size() - product_radius): # TODO What is that?
-            zero_singles, ignore = self.burst_volume(product_pos, product_radius, ignore)
+            zero_singles, ignore = self.burst_volume(product_pos, product_radius*SINGLE_SHELL_FACTOR, ignore)
 
             # 3. check that there is space for the products ignoring the reactants
             # Note that we do not check for interfering surfaces (we assume this is no problem)
diff --git a/shells.py b/shells.py
index 7295deb6..ab7a2201 100755
--- a/shells.py
+++ b/shells.py
@@ -92,10 +92,10 @@ def __init__(self):
     def shell_list_for_single(self):
         # The shell dimensions for the Other classes are unmodified, regardless of the asker.
         return self.shell_list
+
     def shell_list_for_other(self):
         return self.shell_list
 
-
     # The next method is only relevant for TESTSHELL subclasses that derive from this class.
     def get_neighbor_shell_list(self, neighbor):
         # This gets the shells of an existing domain given that the testShell is of the type Other
@@ -108,7 +108,7 @@ def __init__(self):
         pass    # do nothing
 
     # The next two methods are only relevant for HASSHELL subclasses that derive from this class.
-    # NOTE below two methods have quite a different purpose!
+    # NOTE the two methods below have quite a different purpose!
     def shell_list_for_single(self):
         # In case the asker is also a NonInteractionSingle, the shell dimensions of the current domain
         # is modified such that the domain is at least the size of the Multi shell.
@@ -132,8 +132,8 @@ def shell_list_for_other(self):
         # NOTE: Since the burst radius is spherical, a spherical shell of the size of the burst radius is returned
         # when the real shell is small enough to fit inside the burst radius. When the real shell no longer fits inside
         # the burst radius the real shell is returned.
-        # This means that more bursting will take place than necessary because cylindrical domain do not keep the domains
-        # that are out of the 'diffusion dimension' at the proper distance -> TODO
+        # This means that more bursting will take place than necessary because cylindrical domains do not keep the 
+        # domains that are out of the 'diffusion dimension' at the proper distance -> TODO
 
         pass    # needs to be specified in the subclass
 

From 7499f8709dd70508862a251b7faa6feb5c97d571 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:27:33 +0100
Subject: [PATCH 1221/1541] Assert IV > sigma at dissociation in BD mode

---
 PlanarSurface.hpp | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 52b16fe1..934e5435 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -125,8 +125,8 @@ class PlanarSurface
     }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
-    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
-        length_type const& rl ) const
+    virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, 
+                                                                position_type const& op, length_type const& rl ) const
     {
         length_type const r01( s0.radius() + s1.radius() );
         Real const D01( s0.D() + s1.D() );
@@ -137,8 +137,10 @@ class PlanarSurface
         length_type const r01l_sq( r01l * r01l );
         length_type const r01_sq( r01 * r01 );
         
-        length_type const diss_vec_length( sqrt( X * (r01l_sq - r01_sq) + r01_sq ) );
-
+        // The square takes into account the radial character of the sampled length
+        length_type const diss_vec_length( sqrt( r01_sq + X * (r01l_sq - r01_sq) ) );
+        assert(diss_vec_length >= r01);
+        
         position_type const m( random_vector( diss_vec_length, rng ) );
 
         return position_pair_type( op - m * s0.D() / D01,

From 97e6456af4bedb9b7e8cba098b56cbc3e702a540 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:28:13 +0100
Subject: [PATCH 1222/1541] More specific debug output of GF2DRadAbs

---
 GreensFunction2DRadAbs.cpp | 7 ++++---
 GreensFunction2DRadAbs.hpp | 2 +-
 funcSum.cpp                | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 2deefe30..b569ca1f 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -1612,11 +1612,12 @@ std::string GreensFunction2DRadAbs::dump() const
 {
     
     std::ostringstream ss;
-    ss << "D = " << this->getD()   << ", sigma = " << this->getSigma() <<
-        ", a = " << this->geta()   <<
+    ss << "Parameters dump: ";
+    ss << "D = "  << this->getD()  << ", sigma = " << this->getSigma() <<
+        ", a = "  << this->geta()  <<
         ", kf = " << this->getkf() <<
         ", r0 = " << this->getr0() <<
-        ", h = " << this->geth()   << std::endl;
+        ", h = "  << this->geth()  << std::endl;
     return ss.str();
 }    
 
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 9b4cd11d..b2626346 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -42,7 +42,7 @@ class GreensFunction2DRadAbs
 
     static const Real L_TYPICAL = 1E-7; // typical length scale
     static const Real T_TYPICAL = 1E-5; // typical time scale
-    static const Real EPSILON = 1E-9    // relative numeric error  // TESTING temporarily increased; was 1e-12
+    static const Real EPSILON = 1E-10;  // relative numeric error  // TESTING temporarily increased; was 1e-12
 
     // DEFAULT = 30
     static const unsigned int MAX_ORDER = 30;         // The maximum number of m 
diff --git a/funcSum.cpp b/funcSum.cpp
index d628646b..c570a373 100644
--- a/funcSum.cpp
+++ b/funcSum.cpp
@@ -157,7 +157,7 @@ funcSum(boost::function<Real(unsigned int i)> f, size_t max_i, Real tolerance)
         gsl_sum_levin_utrunc_workspace* 
             workspace(gsl_sum_levin_utrunc_alloc(i));
         gsl_sum_levin_utrunc_accel(&pTable[0], pTable.size(), workspace, 
-        &sum, &error);
+            &sum, &error);
         if (fabs(error) >= fabs(sum * tolerance * 10))
         {
             _log.error("series acceleration error: %.16g"

From c27fffc1beab477495219b7b0a7ec0bec6a46b9a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:28:42 +0100
Subject: [PATCH 1223/1541] Output transformed positions into debug stream of
 newBDpropagator

---
 newBDPropagator.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 989d2c13..a0a55329 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -659,10 +659,15 @@ class newBDPropagator
                             // Remember the new structure IDs
                             product0_struct_id = pos0pos1_pair.first.second;
                             product1_struct_id = pos0pos1_pair.second.second;
+                            LOG_DEBUG(("  Applying boundaries to sampled positions: pos0=%s, pos1=%s", boost::lexical_cast<std::string>(pos0pos1_pair.first.first).c_str(),
+                                                           boost::lexical_cast<std::string>(pos0pos1_pair.second.first).c_str() ));
                             // Apply the boundary conditions
                             const position_structid_pair_type pos_structid0 (tx_.apply_boundary( pos0pos1_pair.first  ));
                             const position_structid_pair_type pos_structid1 (tx_.apply_boundary( pos0pos1_pair.second ));
                             pos0pos1_pair = std::make_pair(pos_structid0, pos_structid1);
+                            
+                            LOG_DEBUG(("  New positions: pos0=%s, pos1=%s", boost::lexical_cast<std::string>(pos0pos1_pair.first.first).c_str(),
+                                                           boost::lexical_cast<std::string>(pos0pos1_pair.second.first).c_str() ));
 
 
                             //// 1b - CHECK FOR OVERLAPS

From 6e5cabeb3f00a134a1ef453a08d6acbe8c777a18 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:29:40 +0100
Subject: [PATCH 1224/1541] Fix a bug that caused erroneous structure
 connections at reloading

---
 loadsave.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 2fe96500..96bf7ffc 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -809,12 +809,12 @@ def load_state(filename):
 
         # For each neighbor_id find the side with which the neighbor is
         # connected to the structure with con_id
-        for side in range(0,3):
+        for side in range(0,4):
 
             n_id = neighbor_list[side]
             nn_list = connections_dict[n_id]
 
-            for n_side in range(0,3):
+            for n_side in range(0,4):
             
                 nn_id = nn_list[n_side]
                 if nn_id == to_connect_id:

From acd96a500ae67c7f9beb53f9c069c77c014028cf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:30:18 +0100
Subject: [PATCH 1225/1541] Add logger to shells.py

---
 shells.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/shells.py b/shells.py
index ab7a2201..2121b317 100755
--- a/shells.py
+++ b/shells.py
@@ -54,6 +54,10 @@
     'MixedPair1DCaptestShell',
     ]
 
+import logging
+log = logging.getLogger('ecell')
+
+
 # These are exceptions that are raise when trying to make a new domain
 class ShellmakingError(Exception):
     # This ShellmakingError is raised when a Spherical or Cylindrical shell could
@@ -271,6 +275,9 @@ def get_sigma(self):
     def do_transform(self):
         # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
 
+        if __debug__:
+            log.info('Running testSimplePair.do_transform()')
+
         pos1 = self.pid_particle_pair1[1].position
         pos2 = self.pid_particle_pair2[1].position
         D_1 = self.pid_particle_pair1[1].D
@@ -283,6 +290,7 @@ def do_transform(self):
 
         pos2t = self.world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
+        log.info('pos1=%s, pos2=%s, iv=%s, sigma=%s' % (pos1, pos2, iv, self.sigma))
 
         return com, iv
 

From 44b7186401972ff2d24b7c1f51c6ca0255eb8070 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:31:01 +0100
Subject: [PATCH 1226/1541] Remove unneeded debug output again

---
 shells.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/shells.py b/shells.py
index 2121b317..199778d7 100755
--- a/shells.py
+++ b/shells.py
@@ -275,9 +275,6 @@ def get_sigma(self):
     def do_transform(self):
         # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
 
-        if __debug__:
-            log.info('Running testSimplePair.do_transform()')
-
         pos1 = self.pid_particle_pair1[1].position
         pos2 = self.pid_particle_pair2[1].position
         D_1 = self.pid_particle_pair1[1].D
@@ -290,7 +287,6 @@ def do_transform(self):
 
         pos2t = self.world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
-        log.info('pos1=%s, pos2=%s, iv=%s, sigma=%s' % (pos1, pos2, iv, self.sigma))
 
         return com, iv
 

From c060b77f23139ddb3a93af5345ebe821e2809838 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:32:06 +0100
Subject: [PATCH 1227/1541] Also add logging to pair.py, single.py and multi.py
 for completeness

---
 multi.py  | 4 ++++
 pair.py   | 3 +++
 single.py | 3 +++
 3 files changed, 10 insertions(+)

diff --git a/multi.py b/multi.py
index 249d9b2b..29dcc0bc 100644
--- a/multi.py
+++ b/multi.py
@@ -12,6 +12,10 @@
 
 import os
 
+import logging
+log = logging.getLogger('ecell')
+
+
 class Multi(Domain, hasSphericalShell, Others):
     def __init__(self, domain_id, main, step_size_factor, dt_hardcore_min = -1):
         Domain.__init__(self, domain_id)
diff --git a/pair.py b/pair.py
index e4966526..85970cd0 100644
--- a/pair.py
+++ b/pair.py
@@ -26,6 +26,9 @@
     'MixedPair1DCap',
     ]
 
+import logging
+log = logging.getLogger('ecell')
+
 
 class Pair(ProtectiveDomain, Others):
     """There are 3 types of pairs:
diff --git a/single.py b/single.py
index c1e4c237..331da234 100644
--- a/single.py
+++ b/single.py
@@ -37,6 +37,9 @@
     'PlanarSurfaceTransitionSingle',
     ]
 
+import logging
+log = logging.getLogger('ecell')
+
 
 class Single(ProtectiveDomain):
     """There are 2 main types of Singles:

From 2a59a89d05fa1e352998bc9abd004c89f938181a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:32:43 +0100
Subject: [PATCH 1228/1541] dito

---
 egfrd.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 190781e5..6d713aef 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -64,10 +64,10 @@
 from histograms import *
 
 import logging
-import os
-
 log = logging.getLogger('ecell')
 
+import os
+
 ### Singles
 def create_default_single(domain_id, shell_id, pid_particle_pair, structure, reaction_rules, geometrycontainer, domains):
     if isinstance(structure, CuboidalRegion):

From b419b90d637f53282b89225c9e7e106439745e21 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 2 Nov 2012 16:37:24 +0100
Subject: [PATCH 1229/1541] Increase convergence error tolerance to 1e-9 for
 GF2DRadAbs

---
 GreensFunction2DRadAbs.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index b2626346..05624915 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -42,7 +42,7 @@ class GreensFunction2DRadAbs
 
     static const Real L_TYPICAL = 1E-7; // typical length scale
     static const Real T_TYPICAL = 1E-5; // typical time scale
-    static const Real EPSILON = 1E-10;  // relative numeric error  // TESTING temporarily increased; was 1e-12
+    static const Real EPSILON   = 1E-9; // relative numeric error  // TESTING temporarily increased; was 1e-12
 
     // DEFAULT = 30
     static const unsigned int MAX_ORDER = 30;         // The maximum number of m 

From a4dfbaca9093c605e0fb7045062b4a18006d6194 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 8 Nov 2012 12:15:10 +0100
Subject: [PATCH 1230/1541] Warn when pair.dt gets ridiculously small

---
 pair.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 85970cd0..bb465045 100644
--- a/pair.py
+++ b/pair.py
@@ -139,11 +139,16 @@ def determine_next_event(self, r0):
                    self.draw_single_reaction_time_tuple()) 
 
     def draw_iv_event_type(self, r0):
-        gf = self.iv_greens_function(r0)        
+
+        gf = self.iv_greens_function(r0)
+
         if self.dt < TIME_TOLERANCE**2:
+            log.warning('Ridiculously small pair next-event time: pair.dt < TIME_TOLERANCE^2, setting pair.dt = TIME_TOLERANCE^2 = %s' \
+                       % str(TIME_TOLERANCE**2))
             dt = TIME_TOLERANCE**2
         else:
             dt = self.dt
+
         event_kind = draw_event_type_wrapper(gf, dt)
         if event_kind == PairEventKind.IV_REACTION:
             return EventType.IV_REACTION

From d0006e549909a70aad24744480d19736308a37fe Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 8 Nov 2012 16:43:18 +0100
Subject: [PATCH 1231/1541] Fix an incorrect angle calculation in
 EDGE_HITS_BARREL cyl. scaling

---
 shells.py | 35 ++++++++++++++++++++++-------------
 1 file changed, 22 insertions(+), 13 deletions(-)

diff --git a/shells.py b/shells.py
index 199778d7..e4c0160f 100755
--- a/shells.py
+++ b/shells.py
@@ -1112,14 +1112,14 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
                     h1_min = r1_min/math.tan(scale_angle)
 
-        # TODO TESTING Debug info
-        #print "  *** QUADRANT = %s ***" % str(quadrant)
-        #print "  *** Situation = ", situation_string[situation]
-        #print "  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1)
-        #print "  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r)
-        #print "  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length)
-        #print "  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z)
-        #print "  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z)
+        ##TODO TESTING Debug info
+        #log.info("  *** QUADRANT = %s ***" % str(quadrant) )
+        #log.info("  *** Situation = %s" % str(situation_string[situation]) )
+        #log.info("  *** testShell=%s, r=%s, z1=%s" % (str(testShell), r, z1) )
+        #log.info("  *** scale_angle=%s, tan_scale_angle=%s, scale_center_z=%s, scale_center_r=%s" % (scale_angle, tan_scale_angle, scale_center_z, scale_center_r) )
+        #log.info("  *** shell_radius=%s, shell_half_length=%s" % (shell_radius, shell_half_length) )
+        #log.info("  *** ref_to_shell_x=%s, ref_to_shell_y=%s, ref_to_shell_z=%s" % (ref_to_shell_x, ref_to_shell_y, ref_to_shell_z) )
+        #log.info("  *** scale_center_to_shell_x=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s" % (scale_center_to_shell_x, scale_center_to_shell_y, scale_center_to_shell_z) )
 
         ##### (2) Treat the situation accordingly        
         if situation == BARREL_HITS_FLAT:
@@ -1322,15 +1322,24 @@ def r1_eq(x):
             sin_angle_diff = math.sin(angle_diff)
             cos_angle_diff = math.cos(angle_diff)
 
-            # TODO TESTING Laurens' version
+            # TODO TESTING Laurens' version, remove when the other works well
             # Remove this when it is certain that the new version does not fail
             #scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
                                        #math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
             
-            assert scale_center_to_shell >= shell_radius
-            ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
+            assert scale_center_to_shell >= shell_radius # should never fail
+            ss_angle = math.pi - math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
+            assert(ss_angle >= math.pi/2.0), 'EDGE_HITS_BARREL: ss_angle must be >= Pi/2.0; ss_angle = %s' % str(ss_angle)
+                    # We know that this angle must be larger than Pi/2 here by construction of the problem
+
             scale_center_shell_dist = shell_radius * math.sin(math.pi-(angle_diff+ss_angle)) / math.sin(angle_diff)
-            assert scale_center_shell_dist>0 # TESTING
+            assert scale_center_shell_dist>0, 'EDGE_HITS_BARREL: scale_center_shell_dist not positive, scale_center_shell_dist = %s'\
+                                              % str(scale_center_shell_dist)
+
+            # Check whether the calculated distance is within the forseen bounds and warn if not
+            if not scale_center_shell_dist <= scale_center_to_shell_y && scale_center_shell_dist <= scale_center_to_shell_z:
+                log.warning('EDGE_HITS_BARREL: scale-center-to-shell distance is out of forseen bounds, distance=%s') \
+                              % str(scale_center_shell_dist)
 
             if scale_angle <= Pi/4.0:
                 cos_scale_angle = math.cos(scale_angle)
@@ -1726,7 +1735,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
 
         # then check against all the shells of the neighboring domains (remember that domains can have
         # multiple shells).
-        for neighbor, distance in neighbor_domains:
+        for neighbor, distance in neighbor_domains:            
 
             shell_list = self.get_neighbor_shell_list(neighbor)
             for _, shell_appearance in shell_list:

From 75d5fd048f88ab3f040da2e04ca35a949693ea82 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 8 Nov 2012 19:01:50 +0100
Subject: [PATCH 1232/1541] A rudimentary overlap check for orthogonal
 cylinders

---
 egfrd.py | 39 +++++++++++++++++++++++++++++++++++++--
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6d713aef..0ad67017 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1560,7 +1560,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, reactant1_struc
 
     def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
         # No reactions/Interactions have taken place -> no identity change of the particle
-        # Just only move the particles and process putative structure change
+        # Just move the particles and process putative structure change
 
         # Note that the reactant_structure_id is the id of the structure on which the particle was located at the time of the move.
 
@@ -2051,6 +2051,7 @@ def process_pair_event(self, pair, ignore):
 
         ### 3.1 Get new position and current structures of particles
         if pair.dt > 0.0:
+            log.debug('process_pair_event: Entering routine that calls pair.draw_new_positions(), dt=%s' % str(pair.dt))  ## TESTING remove when done
             newpos1, newpos2, struct1_id, struct2_id = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
             newpos1, struct1_id = self.world.apply_boundary((newpos1, struct1_id))
             newpos2, struct2_id = self.world.apply_boundary((newpos2, struct2_id))
@@ -2969,7 +2970,41 @@ def check_shape_overlap(self, shape1, shape2):
 
                 # If the unit_z of cylinder1 (disk1) is perpendicular to the axis of cylinder2 (disk2).
                 if feq(relative_orientation, 0.0):
-                    return 1                                      # TODO Why does this always return 1 ?
+
+                    # Project the inter-cylinder distance on the axes of the two cylinders (disks)
+                    inter_pos_proj_1 = numpy.dot(inter_pos, shape1.unit_z) * shape1.unit_z
+                    inter_pos_proj_2 = numpy.dot(inter_pos, shape2.unit_z) * shape2.unit_z
+                    # Also calculate the part orthogonal to both projections
+                    inter_pos_proj_3 = inter_pos - inter_pos_proj_1 - inter_pos_proj_2
+
+                    delta_1 = length(inter_pos_proj_1)
+                    delta_2 = length(inter_pos_proj_2)
+                    delta_3 = length(inter_pos_proj_3)                    
+
+                    # Collision is impossible if the half-length of the cylinder that we projected on
+                    # plus the radius of the other cylinder are smaller then the projected distance
+                    if delta_1 > shape1_hl + shape2.radius:
+                        return 1
+                    # Also check for the vice-versa projection
+                    if delta_2 > shape2_hl + shape1.radius:
+                        return 1                                                                               
+
+                    # Treat the obvious collisions:
+                    # If the following criterion is fulfilled we certainly have one
+                    if delta_3 <= shape1.radius + shape2.radius and \
+                       shape1_hl > delta_1 and shape2_hl > delta_2:
+
+                        return -1
+
+                    else:
+                        # The cylinders overlap in one of the planes defined by the cylinder axes
+                        # as plane normal vectors. That does not necessarily mean that they also overlap
+                        # in 3D precisely because of the missing corner volume (when compared to a box).
+                        # Collision here of course is possible but it is nontrivial to calculate it
+                        # in a generic way. For now we just warn.
+                        # TODO We need really sth. more sophisticated here!
+                        log.warning('check_shape_overlap: Incomplete check for orthogonal cylinders overlap.')
+                        return 1
 
                 # If the two objects (cylinder or disk) are parallel
                 elif feq(abs(relative_orientation), 1.0):

From 7552f6e6d0d1b84f4e3b22fa651e4bf602650513 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 8 Nov 2012 19:05:15 +0100
Subject: [PATCH 1233/1541] Some commenting

---
 shells.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index e4c0160f..5d0eb274 100755
--- a/shells.py
+++ b/shells.py
@@ -1328,6 +1328,7 @@ def r1_eq(x):
                                        #math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
             
             assert scale_center_to_shell >= shell_radius # should never fail
+            #ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius) ## TESTING Old version
             ss_angle = math.pi - math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
             assert(ss_angle >= math.pi/2.0), 'EDGE_HITS_BARREL: ss_angle must be >= Pi/2.0; ss_angle = %s' % str(ss_angle)
                     # We know that this angle must be larger than Pi/2 here by construction of the problem
@@ -1337,9 +1338,9 @@ def r1_eq(x):
                                               % str(scale_center_shell_dist)
 
             # Check whether the calculated distance is within the forseen bounds and warn if not
-            if not scale_center_shell_dist <= scale_center_to_shell_y && scale_center_shell_dist <= scale_center_to_shell_z:
-                log.warning('EDGE_HITS_BARREL: scale-center-to-shell distance is out of forseen bounds, distance=%s') \
-                              % str(scale_center_shell_dist)
+            if not(scale_center_shell_dist <= scale_center_to_shell_y and scale_center_shell_dist <= scale_center_to_shell_z):
+                log.warning('EDGE_HITS_BARREL: scale-center-to-shell distance is out of forseen bounds, distance=%s' \
+                              % str(scale_center_shell_dist) )
 
             if scale_angle <= Pi/4.0:
                 cos_scale_angle = math.cos(scale_angle)

From 74a05cd9094511536fc70e707fa80d74b3ee1d05 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 8 Nov 2012 19:45:49 +0100
Subject: [PATCH 1234/1541] Increase scheduler digits to overcome dt=0 pair
 formation problem

---
 utils.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/utils.py b/utils.py
index be56d498..56e802fc 100644
--- a/utils.py
+++ b/utils.py
@@ -29,8 +29,10 @@
 # precision before putting them into the scheduler. This was originally introduced
 # to overcome nasty divergence effects in reloaded simulations caused by limited
 # Python float precision. Put this at a high value if you want to sample accurately
-# very small time steps by purpose. 
-SCHEDULER_DIGITS = int(-1.0*numpy.log10(TIME_TOLERANCE))
+# very small time steps by purpose.
+# Note that a low number of digits may cause cascades of subsequent dt=0 updates
+# for example in pair formation which ultimately will lead to abortion of the simulation.
+SCHEDULER_DIGITS = 2*int(-1.0*numpy.log10(TIME_TOLERANCE))
 
 # Multiplication factor used for seperating 2 particles or a particle and a 
 # surface after unbinding.

From 893f5a9580ab3e2c6e6cbc5dd5933c2b94edfe5b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 8 Nov 2012 19:46:43 +0100
Subject: [PATCH 1235/1541] Increase output precision in small-dt warning in
 pair.py

---
 pair.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index bb465045..03903c40 100644
--- a/pair.py
+++ b/pair.py
@@ -143,8 +143,8 @@ def draw_iv_event_type(self, r0):
         gf = self.iv_greens_function(r0)
 
         if self.dt < TIME_TOLERANCE**2:
-            log.warning('Ridiculously small pair next-event time: pair.dt < TIME_TOLERANCE^2, setting pair.dt = TIME_TOLERANCE^2 = %s' \
-                       % str(TIME_TOLERANCE**2))
+            log.warning('Ridiculously small pair next-event time: pair.dt = %.30g < TIME_TOLERANCE^2, setting pair.dt = TIME_TOLERANCE^2 = %.30g' \
+                       % (self.dt, TIME_TOLERANCE**2) )
             dt = TIME_TOLERANCE**2
         else:
             dt = self.dt

From 763e807265b545dc91c8f492552c96e27471c8e1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 8 Nov 2012 19:49:30 +0100
Subject: [PATCH 1236/1541] Cleanup

---
 egfrd.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0ad67017..90fc02e9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2035,7 +2035,6 @@ def process_pair_event(self, pair, ignore):
         oldpos1 = pid_particle_pair1[1].position
         oldpos2 = pid_particle_pair2[1].position
 
-
         if pair.event_type == EventType.IV_EVENT:
             # Draw actual pair event for iv at very last minute.
             pair.event_type = pair.draw_iv_event_type(pair.r0)
@@ -2051,7 +2050,6 @@ def process_pair_event(self, pair, ignore):
 
         ### 3.1 Get new position and current structures of particles
         if pair.dt > 0.0:
-            log.debug('process_pair_event: Entering routine that calls pair.draw_new_positions(), dt=%s' % str(pair.dt))  ## TESTING remove when done
             newpos1, newpos2, struct1_id, struct2_id = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
             newpos1, struct1_id = self.world.apply_boundary((newpos1, struct1_id))
             newpos2, struct2_id = self.world.apply_boundary((newpos2, struct2_id))

From ee2e08ba8e04be0fec5176f765a4f3a8f3d31e2c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 12 Nov 2012 16:11:36 +0100
Subject: [PATCH 1237/1541] Test-allow domains with dt=0 to be bursted

This is to resolve overlap issues that happen in the event of two
Multis being dissolved at the same moment in time. The domains
created in the event of the first dissolution will then not be
bursted during the second, which may cause overlaps.
---
 egfrd.py | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 90fc02e9..044ad5d4 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -940,16 +940,20 @@ def burst_non_multis(self, pos, radius, ignore):
 
                 if isinstance(domain, NonInteractionSingle) and domain.is_reset():
                     # If the domain was already bursted, but was not on the ignore list yet, put it there.
-                    # NOTE: we assume that the domain has already bursted around it when it was made!
+                    # NOTE: we assume that the domain has already bursted around it when it was made!                    
                     ignore.append(domain_id)
 
-                elif (not isinstance(domain, Multi)) and (self.t != domain.last_time):
+                elif (not isinstance(domain, Multi)): #and (self.t != domain.last_time): ## TESTING TESTING TESTING
                     # Burst domain only if (AND):
                     # -within burst radius
                     # -not already bursted before (not on 'ignore' list)
                     # -domain is not zero dt NonInteractionSingle
                     # -domain is not a multi
-                    # -domain has time passed
+                    # -domain has time passed # TESTING we switch this off because sometimes indeed it is needed to
+                                              # burst newly created domains. For example, when two Multis are dissolved
+                                              # at the same time. Then the first Multi-breakup will result in the creation
+                                              # of new domains that will not be bursted at the second Multi-breakup 
+                                              # because dt=0. This may lead to overlaps.
  
                     # add the domain_id to the list of domains that is already bursted (ignore list),
                     # and burst the domain.
@@ -2501,7 +2505,7 @@ def form_multi(self, single, multi_partners):
 
 
         # Add all partner domains (multi and dt=0 NonInteractionSingles) in the horizon to the multi
-        for partner in neighbors:
+        for partner in neighbors:            
             if (isinstance(partner, NonInteractionSingle) and partner.is_reset()) or \
                isinstance(partner, Multi):
                 self.add_to_multi_recursive(partner, multi)
@@ -2530,7 +2534,7 @@ def add_to_multi_recursive(self, domain, multi):
 
 
         if __debug__:
-            log.debug('add_to_multi_recursive.\n domain: %s, multi: %s' % (domain, multi))
+            log.debug('add_to_multi_recursive:\t domain: %s, multi: %s' % (domain, multi))
 
         if isinstance(domain, NonInteractionSingle):
             assert domain.is_reset()        # domain must be zero-dt NonInteractionSingle
@@ -2560,6 +2564,7 @@ def add_to_multi_recursive(self, domain, multi):
             #    - are Multi or
             #    - are just bursted (initialized) NonInteractionSingles
             for neighbor, dist_to_shell in neighbor_distances:
+
                 if (isinstance (neighbor, NonInteractionSingle) and neighbor.is_reset()):
                     multi_horizon = (domain.pid_particle_pair[1].radius + neighbor.pid_particle_pair[1].radius) * \
                                     MULTI_SHELL_FACTOR
@@ -2608,7 +2613,7 @@ def add_to_multi(self, single, multi):
     # adding a single to the multi instead of creating a pair or interaction out of single(s)
 
         if __debug__:
-            log.info('add to multi:\n  %s\n  %s' % (single, multi))
+            log.info('add_to_multi:\t Adding %s to %s' % (single, multi))
 
         shell_id = self.shell_id_generator()
         shell = multi.create_new_shell(single.pid_particle_pair[1].position,
@@ -2625,7 +2630,7 @@ def add_to_multi(self, single, multi):
     def merge_multis(self, multi1, multi2):
         # merge multi1 into multi2. multi1 will be removed.
         if __debug__:
-            log.info('merging %s to %s' % (multi1.domain_id, multi2.domain_id))
+            log.info('merge_multis: merging %s to %s' % (multi1.domain_id, multi2.domain_id))
             log.info('  %s' % multi1)
             log.info('  %s' % multi2)
 

From da5d6474c2f593a9567a73019ac18ab55ac63700 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 12 Nov 2012 16:24:46 +0100
Subject: [PATCH 1238/1541] Beautify some info output in multi.py

---
 multi.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/multi.py b/multi.py
index 29dcc0bc..bca174ee 100644
--- a/multi.py
+++ b/multi.py
@@ -63,13 +63,13 @@ def within_shell(self, pp):
 
     def add_shell(self, shell_id_shell_pair):
         if __debug__:
-            log.info("add shell to multi:\n  (%s,\n   %s)" %
+            log.info("add shell to multi:\t (%s,\t%s)" %
                      (shell_id_shell_pair[0], shell_id_shell_pair[1]))
         self.sphere_container.update(shell_id_shell_pair)
 
     def add_particle(self, pid_particle_pair):
         if __debug__:
-            log.info("add particle to multi:\n  (%s,\n   %s)" % 
+            log.info("add particle to multi:\t (%s,\t\t%s)" % 
                      (pid_particle_pair[0], pid_particle_pair[1]))
         self.particle_container.update_particle(pid_particle_pair)
         

From a833c1985036ead1b417cbe73c3e42bd76e7ebd6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 12 Nov 2012 17:15:32 +0100
Subject: [PATCH 1239/1541] Increase sampling precision of GF 2DRadAbs again

---
 GreensFunction2DRadAbs.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index 05624915..e123d05c 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -42,7 +42,7 @@ class GreensFunction2DRadAbs
 
     static const Real L_TYPICAL = 1E-7; // typical length scale
     static const Real T_TYPICAL = 1E-5; // typical time scale
-    static const Real EPSILON   = 1E-9; // relative numeric error  // TESTING temporarily increased; was 1e-12
+    static const Real EPSILON   = 1E-12; // relative numeric error  // TESTING temporarily increased; was 1e-12
 
     // DEFAULT = 30
     static const unsigned int MAX_ORDER = 30;         // The maximum number of m 

From 6c296fd938df5a64ce6eec62114c25e9dfa72d59 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Nov 2012 15:55:55 +0100
Subject: [PATCH 1240/1541] Use apply_boundary correctly in BD reactions
 between different structures

---
 newBDPropagator.hpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index a0a55329..2b835198 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -861,11 +861,13 @@ class newBDPropagator
                         LOG_DEBUG(("  Note: product_structure_type_id = %s", boost::lexical_cast<std::string>( product_structure_type_id).c_str() ));                        
                         LOG_DEBUG(("  Note: reactants_CoM=%s", boost::lexical_cast<std::string>(reactants_CoM).c_str() ));
                         
-                        const position_structid_pair_type product_pos_struct_id( reactant0_structure->get_pos_sid_pair_2o(*reactant1_structure, product_structure_type_id,
-                                                                                                                          reactants_CoM, typical_length, reaction_length_, rng_ ) );
+                        const position_structid_pair_type product_info_in_reactant_structure( reactant0_structure->get_pos_sid_pair_2o(*reactant1_structure,
+                                                                                                                                        product_structure_type_id,
+                                                                                                                                        reactants_CoM, typical_length, 
+                                                                                                                                        reaction_length_, rng_ ) );
                         // Apply the boundary conditions; this is particularly important here because the CoM projection as produced by the function above
                         // in some cases might end up out of the target_structure (e.g. in case the two reactants are coming from adjacent planes
-                        tx_.apply_boundary(product_pos_struct_id);
+                        const position_structid_pair_type product_pos_struct_id = tx_.apply_boundary(product_info_in_reactant_structure);
                           // TODO cyclic_transpose ?
                           // TODO check whether the new position is in the target structure?
                           

From b7ff793f1753fbd472bc4f2beace2ac2eb86c4aa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Nov 2012 15:57:35 +0100
Subject: [PATCH 1241/1541] Another safety check to prevent math domain errors
 in cylinder scaling

---
 shells.py | 62 ++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 41 insertions(+), 21 deletions(-)

diff --git a/shells.py b/shells.py
index 5d0eb274..ae24b673 100755
--- a/shells.py
+++ b/shells.py
@@ -1196,18 +1196,28 @@ def h1_eq(x):
                         #rhs = (scale_center_to_shell_z - \
                               #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
 
-                        eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
-                                  (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2 ) )**2
-
                         # TODO TESTING REMOVE THIS WHEN DONE
-                        #print "***** ROOTFINDER CALL: Calling h1_eq() with: *****"
-                        #print "  h1 = %s, value = %s" % (x, eq_value )
-                        #print "  r1 = %s" % (r1_function(x+scale_center_z))
-                        #print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                        #print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                        #print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
-                        #print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
+                        log.debug( "***** ROOTFINDER CALL: Calling h1_eq() with: *****" )
+                        log.debug( "  r1 = %s" % (r1_function(x+scale_center_z)) )
+                        log.debug( "  sqrt_arg = %s" % ((x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2) )
+                        log.debug( "    tan_scale_angle = %s" % (tan_scale_angle) )
+                        log.debug( "    x*tan_scale_angle = %s" % (x*tan_scale_angle) )
+                        log.debug( "    scale_center_to_shell_edge_x = %s" % scale_center_to_shell_edge_x )
+
+                        # We will take the square root of the following below
+                        sqrt_arg = (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2
+
+                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x**2:
+
+                            sqrt_arg = 0.0      # This safety check is to prevent math domain errors
+                                                # in case sqrt_arg is close to zero and taking the
+                                                # difference results in very small negative numbers
+
+                        eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
+                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ))**2
                                             
+                        log.debug( "  h1 = %s, value = %s" % (x, eq_value ) )
+
                         return eq_value
 
                     # Self-adaptive initial value guessing for the rootfinder procedure:
@@ -1232,13 +1242,13 @@ def h1_eq(x):
                     assert(h1_interval_end   >= h1_interval_end)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    #print "***** NEW ROOTFINDER ITERATION *****"
-                    #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                    #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                    #print "  h1_interval_start = %s" % h1_interval_start
-                    #print "  h1_interval_end = %s"   % h1_interval_end
-                    #print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
-                    #print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
+                    log.debug( "***** NEW ROOTFINDER ITERATION *****" )
+                    log.debug( "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius) )
+                    log.debug( "  Dx-h2 = %s" % scale_center_to_shell_edge_x )
+                    log.debug( "  h1_interval_start = %s" % h1_interval_start )
+                    log.debug( "  h1_interval_end = %s"   % h1_interval_end )
+                    log.debug( "  h1(i_start) = %s"       % h1_eq(h1_interval_start) )
+                    log.debug( "  h1(i_end) = %s"         % h1_eq(h1_interval_end) )
 
                     h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                     z1_new = min(z1, h_touch)
@@ -1248,13 +1258,23 @@ def h1_eq(x):
                     # This uses the same rootfinding equation and interval as above with r1=h1/tan_scale_angle
                     # instead of h1; notice that scale_angle > 0 here, so we can divide by it
                     def r1_eq(x):
+
+                        # We will take the square root of the following below
+                        sqrt_arg = x**2 - scale_center_to_shell_edge_x**2
+
+                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x**2:
+
+                            sqrt_arg = 0.0      # This safety check is to prevent math domain errors
+                                                # in case sqrt_arg is close to zero and taking the
+                                                # difference results in very small negative numbers
+
                         eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
-                                  (scale_center_to_shell_y - math.sqrt( x**2 - scale_center_to_shell_edge_x**2 ) )**2
+                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ) )**2
 
                         # TODO TESTING REMOVE THIS WHEN DONE
-                        #print "***** ROOTFINDER CALL: Calling r1_eq() with: *****"
-                        #print "  r1 = %s, value = %s" % (x, eq_value )
-                        #print "  h1 = %s" % (z1_function(x))
+                        #log.debug( "***** ROOTFINDER CALL: Calling r1_eq() with: *****" )
+                        #log.debug( "  r1 = %s, value = %s" % (x, eq_value ) )
+                        #log.debug( "  h1 = %s" % (z1_function(x)) )
 
                         return eq_value
 

From c6f8d65f7e333ca48b36a728fffc194a74182e1c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Nov 2012 17:48:27 +0100
Subject: [PATCH 1242/1541] Cleanup

---
 shells.py | 45 ++++++++++++++++++++++-----------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/shells.py b/shells.py
index ae24b673..f0e31d92 100755
--- a/shells.py
+++ b/shells.py
@@ -1197,12 +1197,12 @@ def h1_eq(x):
                               #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
 
                         # TODO TESTING REMOVE THIS WHEN DONE
-                        log.debug( "***** ROOTFINDER CALL: Calling h1_eq() with: *****" )
-                        log.debug( "  r1 = %s" % (r1_function(x+scale_center_z)) )
-                        log.debug( "  sqrt_arg = %s" % ((x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2) )
-                        log.debug( "    tan_scale_angle = %s" % (tan_scale_angle) )
-                        log.debug( "    x*tan_scale_angle = %s" % (x*tan_scale_angle) )
-                        log.debug( "    scale_center_to_shell_edge_x = %s" % scale_center_to_shell_edge_x )
+                        #log.debug( "***** ROOTFINDER CALL: Calling h1_eq() with: *****" )
+                        #log.debug( "  r1 = %s" % (r1_function(x+scale_center_z)) )
+                        #log.debug( "  sqrt_arg = %s" % ((x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2) )
+                        #log.debug( "    tan_scale_angle = %s" % (tan_scale_angle) )
+                        #log.debug( "    x*tan_scale_angle = %s" % (x*tan_scale_angle) )
+                        #log.debug( "    scale_center_to_shell_edge_x = %s" % scale_center_to_shell_edge_x )
 
                         # We will take the square root of the following below
                         sqrt_arg = (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2
@@ -1212,11 +1212,13 @@ def h1_eq(x):
                             sqrt_arg = 0.0      # This safety check is to prevent math domain errors
                                                 # in case sqrt_arg is close to zero and taking the
                                                 # difference results in very small negative numbers
+                            log.warn('Orthogonal cylinder scaling, EDGE_HITS_EDGE case: Setting negative sqrt argument to zero within TOLERANCE.')
 
                         eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
                                       (scale_center_to_shell_y - math.sqrt( sqrt_arg ))**2
-                                            
-                        log.debug( "  h1 = %s, value = %s" % (x, eq_value ) )
+                        
+                        # TODO TESTING REMOVE THIS WHEN DONE                    
+                        #log.debug( "  h1 = %s, value = %s" % (x, eq_value ) )
 
                         return eq_value
 
@@ -1242,13 +1244,13 @@ def h1_eq(x):
                     assert(h1_interval_end   >= h1_interval_end)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    log.debug( "***** NEW ROOTFINDER ITERATION *****" )
-                    log.debug( "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius) )
-                    log.debug( "  Dx-h2 = %s" % scale_center_to_shell_edge_x )
-                    log.debug( "  h1_interval_start = %s" % h1_interval_start )
-                    log.debug( "  h1_interval_end = %s"   % h1_interval_end )
-                    log.debug( "  h1(i_start) = %s"       % h1_eq(h1_interval_start) )
-                    log.debug( "  h1(i_end) = %s"         % h1_eq(h1_interval_end) )
+                    #log.debug( "***** NEW ROOTFINDER ITERATION *****" )
+                    #log.debug( "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius) )
+                    #log.debug( "  Dx-h2 = %s" % scale_center_to_shell_edge_x )
+                    #log.debug( "  h1_interval_start = %s" % h1_interval_start )
+                    #log.debug( "  h1_interval_end = %s"   % h1_interval_end )
+                    #log.debug( "  h1(i_start) = %s"       % h1_eq(h1_interval_start) )
+                    #log.debug( "  h1(i_end) = %s"         % h1_eq(h1_interval_end) )
 
                     h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                     z1_new = min(z1, h_touch)
@@ -1267,6 +1269,7 @@ def r1_eq(x):
                             sqrt_arg = 0.0      # This safety check is to prevent math domain errors
                                                 # in case sqrt_arg is close to zero and taking the
                                                 # difference results in very small negative numbers
+                            log.warn('Orthogonal cylinder scaling, EDGE_HITS_EDGE case: Setting negative sqrt argument to zero within TOLERANCE.')
 
                         eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
                                       (scale_center_to_shell_y - math.sqrt( sqrt_arg ) )**2
@@ -1341,11 +1344,6 @@ def r1_eq(x):
             angle_diff = abs(shell_angle_yz - scale_angle)
             sin_angle_diff = math.sin(angle_diff)
             cos_angle_diff = math.cos(angle_diff)
-
-            # TODO TESTING Laurens' version, remove when the other works well
-            # Remove this when it is certain that the new version does not fail
-            #scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
-                                       #math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
             
             assert scale_center_to_shell >= shell_radius # should never fail
             #ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius) ## TESTING Old version
@@ -1358,9 +1356,10 @@ def r1_eq(x):
                                               % str(scale_center_shell_dist)
 
             # Check whether the calculated distance is within the forseen bounds and warn if not
-            if not(scale_center_shell_dist <= scale_center_to_shell_y and scale_center_shell_dist <= scale_center_to_shell_z):
-                log.warning('EDGE_HITS_BARREL: scale-center-to-shell distance is out of forseen bounds, distance=%s' \
-                              % str(scale_center_shell_dist) )
+            if scale_center_shell_dist > math.sqrt(scale_center_to_shell_y**2+scale_center_to_shell_z**2)*(1.0+TOLERANCE):
+                log.warning('Orthogonal cylinder scaling, EDGE_HITS_BARREL case: scale-center-to-shell distance is out of foreseen bounds:')
+                log.warning('   distance=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s' \
+                             % (scale_center_shell_dist, scale_center_to_shell_y, scale_center_to_shell_z) )
 
             if scale_angle <= Pi/4.0:
                 cos_scale_angle = math.cos(scale_angle)

From 0e3ba96f1cdccdbb0c1768ecf2ab82c4943d5b71 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Nov 2012 18:18:27 +0100
Subject: [PATCH 1243/1541] Switch on MixedPair2D3D formation

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 044ad5d4..707e0291 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -147,10 +147,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return CylindricalSurfacePairtestShell  (single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
         return PlanarSurfaceTransitionPairtestShell (single1, single2, geometrycontainer, domains) 
-    #elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        #return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
-    #elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        #return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
+    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
         return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):

From 0a56649cc6ffca74e202cf991d3abd83180985c4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 12:04:24 +0100
Subject: [PATCH 1244/1541] Improve clarity of definitions for MixedPair2D3D

---
 shells.py | 94 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 58 insertions(+), 36 deletions(-)

diff --git a/shells.py b/shells.py
index f0e31d92..8d1990b9 100755
--- a/shells.py
+++ b/shells.py
@@ -235,7 +235,7 @@ def __init__(self, single1, single2):
         self.structure1 = single1.structure
         self.structure2 = single2.structure
 
-        self.com, self.iv = self.do_transform()         # NOTE The IV always points from particle1 to particle2
+        self.com, self.iv = self.do_transform()   # NOTE The IV always points from particle1 to particle2
         self.r0 = length(self.iv)
         if self.r0 < self.sigma:
             raise protoDomainError('distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
@@ -320,10 +320,9 @@ class testMixedPair2D3D(testPair):
 
     def __init__(self, single2D, single3D):
 
-        # First define 
-        # for clarity:
+        # First define for clarity:
         self.structure2D = single2D.structure   # equal to self.structure1
-        self.structure3D = single3D.structure   # equal to self.structure2
+        self.structure3D = single3D.structure   # equal to self.structure2        
 
         # These methods need above definitions.
         if __debug__: 
@@ -332,36 +331,45 @@ def __init__(self, single2D, single3D):
         testPair.__init__(self, single2D, single3D)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
           #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
-          
-        # TODO: modification by Martijn Wehrens (jintram@gmail.com) -- not absolutely sure this is correct place
+
+        # Again for clarity define:
+        self.ppp2D      = self.pid_particle_pair1
+        self.ppp3D      = self.pid_particle_pair2
+        self.particle2D = self.ppp2D[1]
+        self.particle3D = self.ppp3D[1]
+
+        # The following will be needed by some domain overlap checking functions
+        # TODO: modification by Martijn Wehrens (jintram@gmail.com)
+        #       -- not absolutely sure this is correct place
         self.origin_structure = self.structure3D
         self.target_structure = self.structure2D        
 
     def get_sigma(self):
         # rescale sigma to correct for the rescaling of the coordinate system
-        # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
-        # different than the sums of the radii of the particleso
+        # This is the sigma that is used for the evaluation of the Green's function and is in this case 
+        # slightly different than the sums of the radii of the particles
         xi = self.get_scaling_factor()
         xi_inv = 1.0/xi
         alpha = math.acos(xi_inv)
-        sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
+        sigma = self.particle2D.radius + self.particle3D.radius
         rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
         return rho
     sigma = property(get_sigma)
 
     def do_transform(self):
         # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
-        pos1 = self.pid_particle_pair1[1].position
-        pos2 = self.pid_particle_pair2[1].position
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        pos2D = self.particle2D.position
+        pos3D = self.particle3D.position
+        D_2D  = self.particle2D.D
+        D_3D  = self.particle3D.D
 
+        # CoM calculation
         # the CoM is calculated in a similar way to a normal 3D pair
-        com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
+        com = self.world.calculate_pair_CoM(pos2D, pos3D, D_2D, D_3D)
 
         # and then projected onto the plane to make sure the CoM is in the surface
         com = self.world.cyclic_transpose(com, self.structure2D.shape.position)
-        com, (_, dist) = self.structure2D.project_point (com)
+        com, (_, dist) = self.structure2D.project_point(com)
         if dist >= 0:
             raise testShellError('(testMixedPair2D3D). Projected point of CoM is not in surface.')
         else:
@@ -369,9 +377,9 @@ def do_transform(self):
 
         com = self.world.apply_boundary(com)
 
-        # calculate the interparticle vector
-        pos2t = self.world.cyclic_transpose(pos2, pos1)
-        iv = pos2t - pos1
+        # IV calculation
+        pos3D_t = self.world.cyclic_transpose(pos3D, pos2D)
+        iv      = pos3D_t - pos2D
 
         # rescale the iv in the axis normal to the plane
         iv_z_component = numpy.dot (iv, self.structure2D.shape.unit_z)
@@ -385,9 +393,9 @@ def do_transform(self):
     def get_scaling_factor(self):
         # This returns the scaling factor needed to make the anisotropic diffusion problem of the IV
         # into a isotropic one.
-        D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
+        D_3D = self.pid_particle_pair3D[1].D    # 3D particle is the only contributor to diffusion
                                                 # normal to the plane
-        return math.sqrt(self.D_r/D_2)
+        return math.sqrt(self.D_r/D_3D)
 
 class testMixedPair1DCap(testPair):
 
@@ -2512,47 +2520,59 @@ def get_max_dr_dzright_dzleft(self):
         dr       = min(dr_sr, dr_edge)
         dz_left  = self.pid_particle_pair1[1].radius
 
-        # now adjust dz_right such that they obey the scaling laws and are still with the search_radius
+        # now adjust dz_right such that they obey the scaling laws and are still within the search_radius
         # We assume that dz_right needs to be adjusted to dr and not the other way around since the cylinder is
         # always a bit flatter.
-        dz_right = self.z_right(dr)
-#        print "max= ", dr, dz_right, dz_left
-        assert dr > dz_right
+        dz_right = self.z_right(dr)        
+        ## Debug output for TESTING
+        #log.debug( "max_dr=%s, max_dz_right=%s, max_dz_left=%s" % (dr, dz_right, dz_left) )
+        #log.debug( "min_dist_proj_to_edge=%s" % str(self.min_dist_proj_to_edge) )
+        #assert dr > dz_right   ## Removed for TESTING
 
         return dr, dz_right, dz_left
 
     def z_right(self, r_right):
-        # if the radius is known and we want to determine the height z_right
+        # This calculates the height z_right of the newly constructed domain
+        # (above the plane) if the radius r is known
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
-        # calculate a_r such that the expected first-passage for the CoM and IV are equal
+        # calculate a_r such that the expected first-passage for the CoM and IV are equal        
+        #sqrt_DRDr_1 = math.sqrt( 2.0/3.0 * self.D_R/D_1 )  # TESTING
+        #sqrt_DRDr_2 = math.sqrt( 2.0/3.0 * self.D_R/D_2 )
         a_r1 = (r_right - radius1 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_1/self.D_tot) )
-        a_r2 = (r_right - radius2 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2/self.D_tot) )
+        a_r2 = (r_right - radius2 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2/self.D_tot) )        
         # take the smallest that, if entered in the function for r below, would lead to this z_right
-        a_r = min (a_r1, a_r2)
+        a_r = min (a_r1, a_r2)        
 
         z_right = (a_r/self.get_scaling_factor()) + radius2
 
-#        assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
-#                                                     r_right= %s, r_right(z_right)=%s ' % \
-#                                                     (r_right, self.r_right(z_right))
+        ## Debug output for TESTING
+        #log.debug( " a_r1=%s, a_r2=%s, z_right=%s, r_right=%s" % (a_r1, a_r2, z_right, r_right))
 
+        #assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
+                                                    #r_right= %s, r_right(z_right)=%s ' % \
+                                                    #(r_right, self.r_right(z_right))
         return z_right
 
     def r_right(self, z_right):
-        # if the z_right is known and we want to know the radius r
+        # This calculates the radius r of the newly constructed domain
+        # if the height z_right is known
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
-        # we first calculate the a_r, since it is the only radius that depends on z_right only.
+        # We first calculate the a_r, since it is the only radius that depends on z_right only.
+        # The dependence is given by the scaling factor that converts spherical coordinates into
+        # prolate spheroidal coordinates
         a_r = (z_right - radius2) * self.get_scaling_factor()
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
+        # via a_R/(a_r-self.r0) == sqrt(4 D_R t)/sqrt(6 D_r t) (for an arbitrary t).
+        # This gives us a CoM domain radius a_R as a function of a_r at equal expected first passage time.
         # Note that for the IV we only take the distance to the outer boundary into account.
         a_R = (a_r - self.r0)*self.sqrt_DRDr
 
@@ -2560,18 +2580,20 @@ def r_right(self, z_right):
         iv_max = max( (D_1/self.D_tot * a_r + radius1),
                       (D_2/self.D_tot * a_r + radius2))
 
+        # The total domain radius is then given by the sum of the max. IV displacement and
+        # the estimated a_R value for the same first passage time
         r_right = a_R + iv_max
 
         assert feq(self.z_right(r_right), z_right), 'inconsistent r_right function \
-                                                  z_right= %s, z_right(r_right)=%s ' % \
-                                                  (z_right, self.z_right(r_right))
-
+                                                     z_right= %s, z_right(r_right)=%s ' % \
+                                                     (z_right, self.z_right(r_right))
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
         SAFETY = 1.1 # FIXME What is that? Why is that not the standard?
         return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, z_left
 
+
 class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):
 
     def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?

From 552868548b0f4a9aec56218a51df60e0d57a63a9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 12:14:28 +0100
Subject: [PATCH 1245/1541] Continue...

---
 shells.py | 112 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 62 insertions(+), 50 deletions(-)

diff --git a/shells.py b/shells.py
index 8d1990b9..35b13367 100755
--- a/shells.py
+++ b/shells.py
@@ -321,8 +321,15 @@ class testMixedPair2D3D(testPair):
     def __init__(self, single2D, single3D):
 
         # First define for clarity:
+        self.single2D = single2D
+        self.single3D = single3D
+        self.ppp2D      = single2D.pid_particle_pair
+        self.ppp3D      = single3D.pid_particle_pair
+        self.particle2D = single2D.pid_particle_pair[1]
+        self.particle3D = single3D.pid_particle_pair[1]
+
         self.structure2D = single2D.structure   # equal to self.structure1
-        self.structure3D = single3D.structure   # equal to self.structure2        
+        self.structure3D = single3D.structure   # equal to self.structure2
 
         # These methods need above definitions.
         if __debug__: 
@@ -330,13 +337,11 @@ def __init__(self, single2D, single3D):
                 assert isinstance(single3D.structure, CuboidalRegion)
         testPair.__init__(self, single2D, single3D)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
-          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
+          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle              
 
-        # Again for clarity define:
-        self.ppp2D      = self.pid_particle_pair1
-        self.ppp3D      = self.pid_particle_pair2
-        self.particle2D = self.ppp2D[1]
-        self.particle3D = self.ppp3D[1]
+        assert self.single2D == self.single1           and self.single3D == self.single2
+        assert self.ppp2D == self.pid_particle_pair1   and self.ppp3D == self.pid_particle_pair2
+        assert self.structure2D == self.structure1     and self.structure3D == self.structure2
 
         # The following will be needed by some domain overlap checking functions
         # TODO: modification by Martijn Wehrens (jintram@gmail.com)
@@ -345,15 +350,19 @@ def __init__(self, single2D, single3D):
         self.target_structure = self.structure2D        
 
     def get_sigma(self):
-        # rescale sigma to correct for the rescaling of the coordinate system
+        # rescale sigma to correct for the rescaling of the coordinate system.
         # This is the sigma that is used for the evaluation of the Green's function and is in this case 
-        # slightly different than the sums of the radii of the particles
+        # slightly different from the sums of the radii of the particles. We rescale sigma in a way
+        # that the total flux over the reactive surface of the prolate spheroidal boundary with greater radius
+        # sigma is equal to the total flux over a spherical reactive surface with radius = rescaled sigma.
         xi = self.get_scaling_factor()
         xi_inv = 1.0/xi
         alpha = math.acos(xi_inv)
+
         sigma = self.particle2D.radius + self.particle3D.radius
-        rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
-        return rho
+        rescaled_sigma = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
+
+        return rescaled_sigma
     sigma = property(get_sigma)
 
     def do_transform(self):
@@ -393,8 +402,8 @@ def do_transform(self):
     def get_scaling_factor(self):
         # This returns the scaling factor needed to make the anisotropic diffusion problem of the IV
         # into a isotropic one.
-        D_3D = self.pid_particle_pair3D[1].D    # 3D particle is the only contributor to diffusion
-                                                # normal to the plane
+        D_3D = self.particle3D.D    # 3D particle is the only contributor to diffusion
+                                    # normal to the plane
         return math.sqrt(self.D_r/D_3D)
 
 class testMixedPair1DCap(testPair):
@@ -2428,31 +2437,33 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         # initialize commonly used constants
         self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
 
-        # initialize the scaling parameters
-        bla = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.pid_particle_pair1[1].D/self.D_tot,
-                                                                  self.pid_particle_pair2[1].D/self.D_tot ))
-        minimum = self.r0+self.pid_particle_pair1[1].radius
+        # initialize the scaling parameters        
+        minimum = self.r0 + self.particle2D.radius
         self.drdz_right = self.r_right(minimum + 1.0) - self.r_right(minimum)
-        assert feq(bla, self.drdz_right), 'bla= %s, drdz_right=%s' % (bla, self.drdz_right)
+        self.dzdr_right = 1.0/self.drdz_right
 
-        bla2 = self.z_right(minimum + 1.0) - self.z_right(minimum)
+        #bla = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.particle2D.D/self.D_tot,
+                                                                  #self.particle3D.D/self.D_tot ))
+        #assert feq(bla, self.drdz_right), 'bla= %s, drdz_right=%s' % (bla, self.drdz_right)
+        #bla2 = self.z_right(minimum + 1.0) - self.z_right(minimum)
 
         minr, minz_right, _ = self.get_min_dr_dzright_dzleft()
-        self.dzdr_right = 1.0/self.drdz_right
-        assert feq(self.dzdr_right, bla2), 'bla2= %s, dzdr_right= %s' % (bla2, self.dzdr_right)
+
+        #assert feq(self.dzdr_right, bla2), 'bla2= %s, dzdr_right= %s' % (bla2, self.dzdr_right)
+
         self.r0_right   = 0.0
         self.z0_right   = self.z_right(self.r0_right)
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
-        self.z0_left    = self.pid_particle_pair1[1].radius
+        self.z0_left    = self.particle2D.radius
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure3D.id, [self.single1.domain_id, self.single2.domain_id],
+                            self.determine_possible_shell(self.structure3D.id, [self.single2D.domain_id, self.single3D.domain_id],
                                                           [self.structure2D.id])
         except ShellmakingError as e:
             raise testShellError('(MixedPair2D3D). %s' %
@@ -2465,7 +2476,7 @@ def get_orientation_vector(self):
 
     def get_searchpoint(self):
         # TODO this can be improved, now same as PlanarSurfaceInteraction
-        search_distance = self.get_searchradius()/math.sqrt(2) - self.z0_left
+        search_distance = self.get_searchradius()/math.sqrt(2.0) - self.z0_left
         return self.get_referencepoint() + search_distance * self.get_orientation_vector()
 
     def get_referencepoint(self):
@@ -2475,15 +2486,15 @@ def get_min_dr_dzright_dzleft(self):
         # defines the minimum parameters of the testShell.
         # Note that also the minimum testShell must obey the scaling rules
 
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
 
         ### calculate the minimal height z_right1 of the shell including burst radius
         iv_z = self.r0      # approximation, actually the height of the domain can be slightly lower.
-        dz_right1 = iv_z + radius2 * SINGLE_SHELL_FACTOR
+        dz_right1 = iv_z + radius3D * SINGLE_SHELL_FACTOR
         # with the accompanying radius r1
         dr_1 = self.r_right(dz_right1)
 
@@ -2509,8 +2520,9 @@ def get_min_dr_dzright_dzleft(self):
         dr = dr_1
         dz_right = dz_right1
 
-        dz_left  = self.pid_particle_pair1[1].radius
+        dz_left  = self.particle2D.radius
 #        print "min= ", dr, dz_right, dz_left
+
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
@@ -2518,7 +2530,7 @@ def get_max_dr_dzright_dzleft(self):
         dr_sr    = self.get_searchradius()/math.sqrt(2)
         dr_edge  = self.min_dist_proj_to_edge
         dr       = min(dr_sr, dr_edge)
-        dz_left  = self.pid_particle_pair1[1].radius
+        dz_left  = self.particle2D.radius
 
         # now adjust dz_right such that they obey the scaling laws and are still within the search_radius
         # We assume that dz_right needs to be adjusted to dr and not the other way around since the cylinder is
@@ -2534,23 +2546,23 @@ def get_max_dr_dzright_dzleft(self):
     def z_right(self, r_right):
         # This calculates the height z_right of the newly constructed domain
         # (above the plane) if the radius r is known
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
         # calculate a_r such that the expected first-passage for the CoM and IV are equal        
-        #sqrt_DRDr_1 = math.sqrt( 2.0/3.0 * self.D_R/D_1 )  # TESTING
-        #sqrt_DRDr_2 = math.sqrt( 2.0/3.0 * self.D_R/D_2 )
-        a_r1 = (r_right - radius1 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_1/self.D_tot) )
-        a_r2 = (r_right - radius2 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2/self.D_tot) )        
+        #sqrt_DRDr_2D = math.sqrt( 2.0/3.0 * self.D_R/D_2D )  # TESTING
+        #sqrt_DRDr_3D = math.sqrt( 2.0/3.0 * self.D_R/D_3D )
+        a_r_2D = (r_right - radius2D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2D/self.D_tot) )
+        a_r_3D = (r_right - radius3D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_3D/self.D_tot) )        
         # take the smallest that, if entered in the function for r below, would lead to this z_right
-        a_r = min (a_r1, a_r2)        
+        a_r = min (a_r_2D, a_r_3D)
 
-        z_right = (a_r/self.get_scaling_factor()) + radius2
+        z_right = (a_r/self.get_scaling_factor()) + radius3D
 
         ## Debug output for TESTING
-        #log.debug( " a_r1=%s, a_r2=%s, z_right=%s, r_right=%s" % (a_r1, a_r2, z_right, r_right))
+        #log.debug( " a_r_2D=%s, a_r_3D=%s, z_right=%s, r_right=%s" % (a_r_2D, a_r_3D, z_right, r_right))
 
         #assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
                                                     #r_right= %s, r_right(z_right)=%s ' % \
@@ -2560,15 +2572,15 @@ def z_right(self, r_right):
     def r_right(self, z_right):
         # This calculates the radius r of the newly constructed domain
         # if the height z_right is known
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
         # We first calculate the a_r, since it is the only radius that depends on z_right only.
         # The dependence is given by the scaling factor that converts spherical coordinates into
         # prolate spheroidal coordinates
-        a_r = (z_right - radius2) * self.get_scaling_factor()
+        a_r = (z_right - radius3D) * self.get_scaling_factor()
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
         # via a_R/(a_r-self.r0) == sqrt(4 D_R t)/sqrt(6 D_r t) (for an arbitrary t).
@@ -2577,8 +2589,8 @@ def r_right(self, z_right):
         a_R = (a_r - self.r0)*self.sqrt_DRDr
 
         # We calculate the maximum space needed for particles A and B based on maximum IV displacement
-        iv_max = max( (D_1/self.D_tot * a_r + radius1),
-                      (D_2/self.D_tot * a_r + radius2))
+        iv_max = max( (D_2D/self.D_tot * a_r + radius2D),
+                      (D_3D/self.D_tot * a_r + radius3D))
 
         # The total domain radius is then given by the sum of the max. IV displacement and
         # the estimated a_R value for the same first passage time
@@ -2590,7 +2602,7 @@ def r_right(self, z_right):
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
-        SAFETY = 1.1 # FIXME What is that? Why is that not the standard?
+        SAFETY = 1.1 # FIXME What the hell is that? Why is that not the standard?
         return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, z_left
 
 

From e4c975c1b1685e436740b1e5e54bec7be6d5f5ae Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 14:26:14 +0100
Subject: [PATCH 1246/1541] Also improve naming consitency and comments in
 pair.py

---
 pair.py | 83 +++++++++++++++++++++++++++++----------------------------
 1 file changed, 42 insertions(+), 41 deletions(-)

diff --git a/pair.py b/pair.py
index 03903c40..3315488e 100644
--- a/pair.py
+++ b/pair.py
@@ -855,7 +855,9 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         
         # Some definitions 
         self.structure2D = self.testShell.structure2D   # the surface on which particle1 lives
-        self.structure3D = self.testShell.structure3D   # structure on which both particles live
+        self.structure3D = self.testShell.structure3D   # structure on which particle2 lives
+        self.particle2D  = self.testShell.particle2D
+        self.particle3D  = self.testShell.particle3D
 
         # initialize some useful constants
         self.z_scaling_factor = self.testShell.get_scaling_factor()
@@ -866,52 +868,50 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # The latter is defined for completeness and used by check_domain() in egfrd.py:
         # (Note that that origin and target end up in same list.)
         self.origin_structure = self.testShell.origin_structure
-        self.target_structure = self.testShell.target_structure         
-#        self.origin_structure = self.structure3D
-#        self.target_structure = self.structure2D
-
+        self.target_structure = self.testShell.target_structure
 
     def determine_radii(self):
-        # determines the dimensions of the domains used for the Green's functions from the dimensions
-        # of the cylindrical shell.
+        # determines the dimensions of the domains used for the Green's functions 
+        # from the dimensions of the cylindrical shell.
         # Note that the function assumes that the cylinder is dimensioned properly
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
-        radius      = self.shell.shape.radius
-        half_length = self.shell.shape.half_length
+        shell_radius      = self.shell.shape.radius
+        shell_half_length = self.shell.shape.half_length
 
         # Use class methods to check dimensions of the cylinder
-        r_check  = self.testShell.r_right (half_length*2 - radius1)
-        hl_check = (self.testShell.z_right (radius) + self.testShell.z_left (radius))/2
+        r_check  = self.testShell.r_right(2.0*shell_half_length - radius2D)  # FIXME that can't work, can it???
+        hl_check = (self.testShell.z_right(shell_radius) + self.testShell.z_left(shell_radius)) / 2.0
         if __debug__:
-            assert feq(r_check, radius) and feq(hl_check, half_length), \
+            assert feq(r_check, shell_radius) and feq(hl_check, shell_half_length), \
                 'MixedPair2D3D: Domain did not obey scaling relationship. ' \
-                'radius = %s, half_length = %s, radius_check = %s, half_length_check = %s' % \
-                 (FORMAT_DOUBLE % radius,  FORMAT_DOUBLE % half_length,
-                  FORMAT_DOUBLE % r_check, FORMAT_DOUBLE % hl_check)
+                'shell_radius = %s, shell_half_length = %s, radius_check = %s, half_length_check = %s' % \
+                 (FORMAT_DOUBLE % shell_radius, FORMAT_DOUBLE % shell_half_length,
+                  FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check)
 
 
         # Partition the space in the protective domain over the IV and the CoM domains
-        z_left  = radius1
-        z_right = half_length * 2 - z_left
-        a_r = (z_right - radius2) * self.z_scaling_factor
-
-        # calculate the maximal displacement of a particle given an a_r. Also include its radius
-        space_for_iv = max( (D_1/self.D_tot) * a_r + radius1,
-                            (D_2/self.D_tot) * a_r + radius2)
-        a_R = radius - space_for_iv
+        z_left  = radius2D
+        z_right = 2.0*shell_half_length - z_left
+        a_r = (z_right - radius3D) * self.z_scaling_factor
 
+        # calculate the maximal displacement of a particle given an interparticle vector bound a_r.
+        # Also include its radius.
+        space_for_iv = max( (D_2D/self.D_tot) * a_r + radius2D,
+                            (D_3D/self.D_tot) * a_r + radius3D)
+        # This determines the CoM vector bound via
+        a_R = shell_radius - space_for_iv
 
         # Print the domain sizes and their estimated first passage times.
         if __debug__:
-            tr = ((a_r - self.r0)**2) / (6 * self.D_r)  # the expected escape time of the iv
+            tr = ((a_r - self.r0)**2.0) / (6.0 * self.D_r)  # the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
-                tR = (a_R**2) / (4 * self.D_R)          # the expected escape time of the CoM
+                tR = (a_R**2.0) / (4.0 * self.D_R)          # the expected escape time of the CoM
             log.debug('determine_radii: a_r= %s, tr= %s, a_R= %s, tR= %s, delta_tRr= %s' % \
                       (FORMAT_DOUBLE % a_r, FORMAT_DOUBLE % tr,
                        FORMAT_DOUBLE % a_R, FORMAT_DOUBLE % tR,
@@ -919,8 +919,9 @@ def determine_radii(self):
 
 #        assert feq(tr, tR), 'estimate first passage times were not equal'
 
-        assert (self.sigma < a_r) and (a_r < half_length*2)
-        assert (0 < a_R) and (a_R < radius)
+        # Some checks that shall never fail
+        assert (self.sigma < a_r) and (a_r < 2.0*shell_half_length)
+        assert (0 < a_R) and (a_R < shell_radius)
 
         return a_R, a_r
 
@@ -965,9 +966,9 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
         return pos1, pos2, structure2D.id, structure3D.id
 
     @ classmethod
-    def calc_z_scaling_factor(cls, D2d, D3d):
+    def calc_z_scaling_factor(cls, D_2D, D_3D):
         # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
-        return math.sqrt( (D2d + D3d) / D3d)
+        return math.sqrt( (D_2D + D_3D) / D_3D)
 
     def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
@@ -977,8 +978,8 @@ def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greens_function(self, r0):
-        # diffusion of the interparticle vector is three dimensional
-        # TODO Fix ugly hack to prevent particle overlap problem
+        # Diffusion of the interparticle vector is three dimensional
+        # TODO Fix this ugly HACK to prevent particle overlap problem
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, max(r0, self.sigma),
                                       self.sigma, self.a_r)
 
@@ -1019,17 +1020,17 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
     def check(self):
     # perform internal consistency check 
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
         radius      = self.shell.shape.radius
         half_length = self.shell.shape.half_length
 
         # check that the shell obeys the scaling rules dimensions of the cylinder
-        r_check  = self.testShell.r_right (half_length*2 - radius1)
-        hl_check = (self.testShell.z_right (radius) + self.testShell.z_left (radius))/2
+        r_check  = self.testShell.r_right(2.0*half_length - radius2D)
+        hl_check = (self.testShell.z_right(radius) + self.testShell.z_left(radius))/2.0
         assert feq(r_check, radius) and feq(hl_check, half_length), \
             'MixedPair2D3D: Domain did not obey scaling relationship. '
 

From 25e41cfa090bfd61a25013b9ab75c3a7ea37b032 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 14:29:41 +0100
Subject: [PATCH 1247/1541] Yes it can!

---
 pair.py | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/pair.py b/pair.py
index 3315488e..4b11e525 100644
--- a/pair.py
+++ b/pair.py
@@ -871,9 +871,9 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.target_structure = self.testShell.target_structure
 
     def determine_radii(self):
-        # determines the dimensions of the domains used for the Green's functions 
+        # Determines the dimensions of the domains used for the Green's functions 
         # from the dimensions of the cylindrical shell.
-        # Note that the function assumes that the cylinder is dimensioned properly
+        # Note that the function assumes that the cylinder is dimensioned properly.
         radius2D = self.particle2D.radius
         radius3D = self.particle3D.radius
         D_2D = self.particle2D.D
@@ -881,9 +881,11 @@ def determine_radii(self):
 
         shell_radius      = self.shell.shape.radius
         shell_half_length = self.shell.shape.half_length
+        z_left            = radius2D
+        z_right           = 2.0*shell_half_length - z_left
 
         # Use class methods to check dimensions of the cylinder
-        r_check  = self.testShell.r_right(2.0*shell_half_length - radius2D)  # FIXME that can't work, can it???
+        r_check  = self.testShell.r_right(z_right)
         hl_check = (self.testShell.z_right(shell_radius) + self.testShell.z_left(shell_radius)) / 2.0
         if __debug__:
             assert feq(r_check, shell_radius) and feq(hl_check, shell_half_length), \
@@ -892,17 +894,17 @@ def determine_radii(self):
                  (FORMAT_DOUBLE % shell_radius, FORMAT_DOUBLE % shell_half_length,
                   FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check)
 
-
         # Partition the space in the protective domain over the IV and the CoM domains
-        z_left  = radius2D
-        z_right = 2.0*shell_half_length - z_left
+        # The outer bound of the interparticle vector is set by the particle diffusing in 3D via:
         a_r = (z_right - radius3D) * self.z_scaling_factor
 
-        # calculate the maximal displacement of a particle given an interparticle vector bound a_r.
-        # Also include its radius.
+        # Calculate the maximal displacement of a particle given an interparticle vector bound a_r
+        # taking into account the radius for both the 2D and 3D particle. This sets the remaining
+        # space for the CoM diffusion.
         space_for_iv = max( (D_2D/self.D_tot) * a_r + radius2D,
                             (D_3D/self.D_tot) * a_r + radius3D)
-        # This determines the CoM vector bound via
+
+        # It then determines the CoM vector bound via
         a_R = shell_radius - space_for_iv
 
         # Print the domain sizes and their estimated first passage times.

From aacbb04937c5c5fd4f2f966d7c7fa46440c0ff32 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 14:50:40 +0100
Subject: [PATCH 1248/1541] More info output

---
 pair.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 4b11e525..4f496bf3 100644
--- a/pair.py
+++ b/pair.py
@@ -890,9 +890,11 @@ def determine_radii(self):
         if __debug__:
             assert feq(r_check, shell_radius) and feq(hl_check, shell_half_length), \
                 'MixedPair2D3D: Domain did not obey scaling relationship. ' \
-                'shell_radius = %s, shell_half_length = %s, radius_check = %s, half_length_check = %s' % \
+                'shell_radius = %s, shell_half_length = %s, radius_check = %s, half_length_check = %s, ' \
+                'z_left = %s, z_right = %s' % \
                  (FORMAT_DOUBLE % shell_radius, FORMAT_DOUBLE % shell_half_length,
-                  FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check)
+                  FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check,
+                  FORMAT_DOUBLE % z_left,       FORMAT_DOUBLE % z_right          )
 
         # Partition the space in the protective domain over the IV and the CoM domains
         # The outer bound of the interparticle vector is set by the particle diffusing in 3D via:

From 230ae0d580883dcccb6fc0ed627154b6a6f596a1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 18:39:43 +0100
Subject: [PATCH 1249/1541] More safety checks

---
 pair.py   |  2 +-
 shells.py | 41 ++++++++++++++++++++++++++++++++---------
 2 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/pair.py b/pair.py
index 4f496bf3..152df954 100644
--- a/pair.py
+++ b/pair.py
@@ -971,7 +971,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
 
     @ classmethod
     def calc_z_scaling_factor(cls, D_2D, D_3D):
-        # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
+        # calculates the scaling factor to make the anisotropic diffusion problem into an isotropic one
         return math.sqrt( (D_2D + D_3D) / D_3D)
 
     def choose_pair_greens_function(self, r0, t):
diff --git a/shells.py b/shells.py
index 35b13367..8be9996a 100755
--- a/shells.py
+++ b/shells.py
@@ -2556,17 +2556,26 @@ def z_right(self, r_right):
         #sqrt_DRDr_3D = math.sqrt( 2.0/3.0 * self.D_R/D_3D )
         a_r_2D = (r_right - radius2D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2D/self.D_tot) )
         a_r_3D = (r_right - radius3D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_3D/self.D_tot) )        
-        # take the smallest that, if entered in the function for r below, would lead to this z_right
-        a_r = min (a_r_2D, a_r_3D)
+        # take the smaller a_r that, if entered in the function for r below, would lead to this r_right
+        a_r = min(a_r_2D, a_r_3D)
 
         z_right = (a_r/self.get_scaling_factor()) + radius3D
 
         ## Debug output for TESTING
         #log.debug( " a_r_2D=%s, a_r_3D=%s, z_right=%s, r_right=%s" % (a_r_2D, a_r_3D, z_right, r_right))
+        #log.debug('r_right= %s, r_right(z_right)=%s, z_right=%s' % (r_right, self.r_right(z_right), z_right) )
+
+        #assert feq(self.r_right(z_right), r_right), 'Inconsistent z_right function in MixedPair2D3DtestShell: \
+                                                     #r_right= %s, r_right(z_right)=%s, z_right=%s' % \
+                                                     #(r_right, self.r_right(z_right), z_right)
+
+        if r_right < 0.0 or z_right <0.0:
+            log.warning('Negative cylinder dimensions in MixedPair2D3DtestShell: z_right= %s, r_right=%s' % (z_right, r_right) )
+
+        if abs(z_right) < abs(r_right) * TOLERANCE:
+            log.warning('Setting z_right to zero within TOLERANCE in MixedPair2D3DtestShell, z_right=%s' % str(z_right))
+            z_right = 0.0
 
-        #assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
-                                                    #r_right= %s, r_right(z_right)=%s ' % \
-                                                    #(r_right, self.r_right(z_right))
         return z_right
 
     def r_right(self, z_right):
@@ -2589,6 +2598,7 @@ def r_right(self, z_right):
         a_R = (a_r - self.r0)*self.sqrt_DRDr
 
         # We calculate the maximum space needed for particles A and B based on maximum IV displacement
+        # taking into account the particle radii
         iv_max = max( (D_2D/self.D_tot * a_r + radius2D),
                       (D_3D/self.D_tot * a_r + radius3D))
 
@@ -2596,14 +2606,27 @@ def r_right(self, z_right):
         # the estimated a_R value for the same first passage time
         r_right = a_R + iv_max
 
-        assert feq(self.z_right(r_right), z_right), 'inconsistent r_right function \
-                                                     z_right= %s, z_right(r_right)=%s ' % \
-                                                     (z_right, self.z_right(r_right))
+        ### TESTING
+        log.info('MixedPair2D3DtestShell: z_right= %s, z_right(r_right)=%s, r_right=%s' % (z_right, self.z_right(r_right), r_right) )
+
+        if r_right < 0.0 or z_right <0.0:
+            log.warning('Negative cylinder dimensions in MixedPair2D3DtestShell: z_right= %s, r_right=%s' % (z_right, r_right) )
+
+        assert feq(self.z_right(r_right), z_right), 'Inconsistent r_right function in MixedPair2D3DtestShell: \
+                                                     z_right= %s, z_right(r_right)=%s, r_right=%s' % \
+                                                     (z_right, self.z_right(r_right), r_right)
+
+        if abs(r_right) < abs(z_right) * TOLERANCE:
+            log.warning('Setting r_right to zero within TOLERANCE in MixedPair2D3DtestShell, r_right=%s' % str(r_right))
+            r_right = 0.0
+
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
         SAFETY = 1.1 # FIXME What the hell is that? Why is that not the standard?
-        return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, z_left
+        # Make sure to keep the right scaling ratio when applying SAFETY
+        # because we determine the math. domains for IV and CoM from the shell dimensions
+        return r/SAFETY, self.z_right(r/SAFETY), z_left
 
 
 class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):

From 564b71a604cd9b5619b6f73bd6cb27e342429911 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 16 Nov 2012 14:39:42 +0100
Subject: [PATCH 1250/1541] Fix an erroneous default setting in newBDPropagator

---
 newBDPropagator.hpp | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 2b835198..bc677b8b 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -555,7 +555,8 @@ class newBDPropagator
                     {                        
                         //// 0 - SOME NECESSARY DEFINITONS
                         const position_type                             reactant_pos(pp.second.position());                        
-                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
+                        const structure_id_type                         reactant_structure_id( pp.second.structure_id() );
+                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );                        
                         const structure_type_id_type                    reactant_structure_type_id( reactant_structure->sid() );
                         const structure_id_type                         parent_structure_id( reactant_structure->structure_id() );
                         const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure(parent_structure_id) );
@@ -572,32 +573,35 @@ class newBDPropagator
                         // Determine the structures on which the products will end up.
                         // By default we set both product structure to reactant_structure.
                         const boost::shared_ptr<const structure_type> product0_structure(reactant_structure);
-                        const boost::shared_ptr<const structure_type> product1_structure(reactant_structure);
+                        boost::shared_ptr<const structure_type>       product1_structure(reactant_structure);
+                        // Also for the structure IDs
+                        structure_id_type product0_structure_id( reactant_structure_id );
+                        structure_id_type product1_structure_id( reactant_structure_id );
                         // Now check whether one of the products actually leaves reactant_structure according to the reaction rules.
                         species_type product0_species(tx_.get_species(products[0]));
-                        species_type product1_species(tx_.get_species(products[1]));                        
+                        species_type product1_species(tx_.get_species(products[1]));
 
                         LOG_DEBUG(("Attempting single reaction with two products." ));
                         
                         // If the products live on different structures, one must be the parent of the other or the default structure.
                         // In this case we have to bring the products into the right order.
                         // We set: species 0 lives on the current structure; species 1 lives in the product structure (if applicable).
-                        // Compare the structure type IDs of the product species to determine where products will end up:                                                                                                                                                                    
-
-                        // Initialize: by default the dissociating particle goes into the bulk
-                        structure_id_type product1_structure_id( tx_.get_def_structure_id() );
+                        // Compare the structure type IDs of the product species to determine where products will end up:                                                                                                                                                                                            
                         
+                        // If product structure types are different
                         if( product0_species.structure_type_id() != product1_species.structure_type_id() )
-                        {                          
+                        {                        
                             // First check whether the reaction rule defines a legal dissociation reaction
+                            // One of the products must stay in the reactant structure
                             if( !( product0_species.structure_type_id() == reactant_structure_type_id ||
                                    product1_species.structure_type_id() == reactant_structure_type_id    )
                               )
                                 throw not_implemented("Invalid product structure for first product in single reaction: One particle must stay behind on structure of origin!");
-                                
+
+                            // One of the products must go into the parent or default structure
                             if( !( product0_species.structure_type_id() == parent_structure_type_id  ||
-                                   product0_species.structure_type_id() == default_structure_type_id || 
-                                   product1_species.structure_type_id() == parent_structure_type_id  ||                                  
+                                   product0_species.structure_type_id() == default_structure_type_id ||
+                                   product1_species.structure_type_id() == parent_structure_type_id  ||                                 
                                    product1_species.structure_type_id() == default_structure_type_id    )
                               )
                                 throw not_implemented("Invalid product structure for second product in single reaction: Must be either parent or default structure!");
@@ -608,11 +612,11 @@ class newBDPropagator
                             
                             // Determine where the dissociating particle (product1) goes
                             if( product1_species.structure_type_id() == default_structure_type_id )
-                                ; // the dissociating product lives in the bulk; do nothing, set correctly already above
+                                product1_structure_id = default_structure_id;
                             
                             else if( product1_species.structure_type_id() == parent_structure_type_id )
                                 // the product lives on the parent structure 
-                                product1_structure_id =  parent_structure_id;
+                                product1_structure_id = parent_structure_id;
                             
                             else
                               
@@ -620,7 +624,7 @@ class newBDPropagator
                                                         
                             // If no exception was thrown, everything should be OK now.
                             // Change the default setting for product1
-                            const boost::shared_ptr<const structure_type> product1_structure( tx_.get_structure(product1_structure_id) );
+                            product1_structure = tx_.get_structure(product1_structure_id);
                         }
                         // TODO Can we not outsource this part to the structure functions, too?
 
@@ -668,6 +672,8 @@ class newBDPropagator
                             
                             LOG_DEBUG(("  New positions: pos0=%s, pos1=%s", boost::lexical_cast<std::string>(pos0pos1_pair.first.first).c_str(),
                                                            boost::lexical_cast<std::string>(pos0pos1_pair.second.first).c_str() ));
+                            LOG_DEBUG(("  New structure IDs: id0=%s, id1=%s", boost::lexical_cast<std::string>(pos0pos1_pair.first.second).c_str(),
+                                                           boost::lexical_cast<std::string>(pos0pos1_pair.second.second).c_str() ));
 
 
                             //// 1b - CHECK FOR OVERLAPS

From 3472465f09693310d935d93f2f74f73a327327dc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 16 Nov 2012 14:40:31 +0100
Subject: [PATCH 1251/1541] Some more log info

---
 shells.py | 51 ++++++++++++++++++++++++++++++++-------------------
 1 file changed, 32 insertions(+), 19 deletions(-)

diff --git a/shells.py b/shells.py
index 8be9996a..cd19d33e 100755
--- a/shells.py
+++ b/shells.py
@@ -2426,30 +2426,23 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         # The initialization of r0 can fail in testPair.__init__
 
-#        raise testShellError('(MixedPair2D3D).')
-
         try:
             testMixedPair2D3D.__init__(self, single2D, single3D)
         except protoDomainError as e:
             raise testShellError('(MixedPair2D3D). %s' %
                                  (str(e)))
 
-        # initialize commonly used constants
+        # Initialize commonly used constants
         self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
 
-        # initialize the scaling parameters        
-        minimum = self.r0 + self.particle2D.radius
-        self.drdz_right = self.r_right(minimum + 1.0) - self.r_right(minimum)
-        self.dzdr_right = 1.0/self.drdz_right
-
-        #bla = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.particle2D.D/self.D_tot,
-                                                                  #self.particle3D.D/self.D_tot ))
-        #assert feq(bla, self.drdz_right), 'bla= %s, drdz_right=%s' % (bla, self.drdz_right)
-        #bla2 = self.z_right(minimum + 1.0) - self.z_right(minimum)
-
-        minr, minz_right, _ = self.get_min_dr_dzright_dzleft()
-
-        #assert feq(self.dzdr_right, bla2), 'bla2= %s, dzdr_right= %s' % (bla2, self.dzdr_right)
+        # Initialize the scaling parameters
+        # To determine the scale angle we calculate the radius r corresponding to the minimal z_right
+        # of the cylinder in a way that the first passage time of the CoM (towards r) and of the
+        # interparticle vector (towards z_right) are equal (see self.r_right(), self.z_right() below).
+        self.iv_z_minimum = self.r0 + self.particle3D.radius * SINGLE_SHELL_FACTOR
+            # this is an upper bound, actually the height of the domain could be slightly lower than this
+        self.drdz_right = self.r_right(self.iv_z_minimum) / self.iv_z_minimum
+        self.dzdr_right = 1.0/self.drdz_right        
 
         self.r0_right   = 0.0
         self.z0_right   = self.z_right(self.r0_right)
@@ -2458,6 +2451,16 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.particle2D.radius
 
+        log.info(' MixedPair2D3D: Initalized shellscaling: scale_angle = %s, drdz  = %s' % (self.right_scalingangle, self.drdz_right))
+        log.info('                                         r0_right = %s, z0_right = %s' % (self.r0_right, self.z0_right))
+        log.info('                                         r0_left  = %s, z0_left  = %s' % (self.r0_left,  self.z0_left))
+
+        log.info('      min_dr_dzright_dzleft = %s' % str(self.get_min_dr_dzright_dzleft() ))
+        log.info('      max_dr_dzright_dzleft = %s' % str(self.get_max_dr_dzright_dzleft() ))
+
+        # TODO This is probably not needed any more:
+        min_r, min_dz_right, _ = self.get_min_dr_dzright_dzleft()
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2493,8 +2496,7 @@ def get_min_dr_dzright_dzleft(self):
 
 
         ### calculate the minimal height z_right1 of the shell including burst radius
-        iv_z = self.r0      # approximation, actually the height of the domain can be slightly lower.
-        dz_right1 = iv_z + radius3D * SINGLE_SHELL_FACTOR
+        dz_right1 = self.iv_z_minimum
         # with the accompanying radius r1
         dr_1 = self.r_right(dz_right1)
 
@@ -2521,7 +2523,6 @@ def get_min_dr_dzright_dzleft(self):
         dz_right = dz_right1
 
         dz_left  = self.particle2D.radius
-#        print "min= ", dr, dz_right, dz_left
 
         return dr, dz_right, dz_left
         
@@ -2546,6 +2547,12 @@ def get_max_dr_dzright_dzleft(self):
     def z_right(self, r_right):
         # This calculates the height z_right of the newly constructed domain
         # (above the plane) if the radius r is known
+
+        # The trivial case
+        if r_right == 0.0:
+            return 0.0
+
+        # Some constants that we need
         radius2D = self.particle2D.radius
         radius3D = self.particle3D.radius
         D_2D = self.particle2D.D
@@ -2581,6 +2588,12 @@ def z_right(self, r_right):
     def r_right(self, z_right):
         # This calculates the radius r of the newly constructed domain
         # if the height z_right is known
+
+        # The trivial case
+        if z_right == 0.0:
+            return 0.0
+
+        # Some constants that we need
         radius2D = self.particle2D.radius
         radius3D = self.particle3D.radius
         D_2D = self.particle2D.D

From c836f605cca2b7c8fc4ec5477de43dd379aeba6e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 11:20:14 +0100
Subject: [PATCH 1252/1541] Two small fixes that caused zero-division errors

---
 egfrd.py    | 11 +++++++++--
 gfrdbase.py | 42 ++++++++++++++++++++++++++----------------
 2 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 707e0291..eeb4416f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2685,6 +2685,13 @@ def print_report(self, out=None):
         multi_steps = self.multi_steps[3] # total multi steps
         total_steps = single_steps + interaction_steps + pair_steps + multi_steps
 
+        if multi_steps:
+            avg_multi_time = 1.0 * self.multi_time / multi_steps
+            avg_multi_rl   = 1.0 * self.multi_rl   / multi_steps
+        else:
+            avg_multi_time = None
+            avg_multi_rl   = None
+
         report = '''
 t = %g
 \tNonmulti: %g\tMulti: %g
@@ -2725,8 +2732,8 @@ def print_report(self, out=None):
                self.multi_steps[EventType.MULTI_BIMOLECULAR_REACTION],
                self.multi_steps[EventType.MULTI_UNIMOLECULAR_REACTION],
                self.multi_steps[EventType.BURST],
-               1.0 * self.multi_time / multi_steps,
-               1.0 * self.multi_rl   / multi_steps,
+               avg_multi_time,
+               avg_multi_rl,
                self.reaction_events,
                self.rejected_moves
                )
diff --git a/gfrdbase.py b/gfrdbase.py
index 2273ff5a..3db2bea5 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -364,9 +364,13 @@ def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
     """
     species = world.get_species(sid)
     structure_type = world.get_structure_type(species.structure_type_id)
-    structure_list = list(world.get_structure_ids(structure_type))
+    structure_list = list(world.get_structure_ids(structure_type))    
 
     ws = world.world_size
+
+    if species.radius >= 0.05 * ws:
+        log.warn('Particle radius >= 0.05*world_size - this may break simulation efficiency!')
+
     # For comparison purposes:
     bound_1 = numpy.array(bound_1)
     bound_2 = numpy.array(bound_2)
@@ -448,6 +452,9 @@ def place_particle(world, sid, position):
     species = world.get_species(sid)
     radius = species.radius
 
+    if radius >= 0.05 * world.world_size:
+        log.warn('Particle radius >= 0.05*world_size - this may break simulation efficiency!')
+
     # FIXME This is a mess!!
 
     # check that particle doesn't overlap with other particles.
@@ -494,21 +501,24 @@ def place_particle(world, sid, position):
     # added to the world, or added to a self-defined box.
     if species.structure_type_id == world.get_def_structure_type_id():
         
-        structure_id = world.get_def_structure_id()        
-        surface, distance = surfaces[0]  # the closest surface
-        overlaps = world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
-                                                position, structure_id, radius)
-
-        # Raise an error in case of overlap with a surface other than PlanarSurface
-        # (the latter we allow to overlap with bulk particles)
-        if overlaps and not isinstance(surface, PlanarSurface):
-            raise RuntimeError('  Placing particle failed: %s %s. '
-                               '  Too close to surface: %s.' %
-                                  (sid, position, surface) )
-
-        if overlaps and isinstance(surface, PlanarSurface):
-            log.warning('  Particle of species %s placed at position %s overlaps with surface %s.' % \
-                           (sid, position, surface) )
+        structure_id = world.get_def_structure_id()
+
+        if surfaces:
+
+            surface, distance = surfaces[0]  # the closest surface
+            overlaps = world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
+                                                    position, structure_id, radius)
+
+            # Raise an error in case of overlap with a surface other than PlanarSurface
+            # (the latter we allow to overlap with bulk particles)
+            if overlaps and not isinstance(surface, PlanarSurface):
+                raise RuntimeError('  Placing particle failed: %s %s. '
+                                  '  Too close to surface: %s.' %
+                                      (sid, position, surface) )
+
+            if overlaps and isinstance(surface, PlanarSurface):
+                log.warning('  Particle of species %s placed at position %s overlaps with surface %s.' % \
+                              (sid, position, surface) )
     else:
         # If the particle lives on a surface then the position should be in the closest surface.
         # The closest surface should also be of the structure_type associated with the species.        

From f4ba2be1a995fa2f57bec0798b8c0385eb578991 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 13:58:51 +0100
Subject: [PATCH 1253/1541] Fix a problem with calculation of reference_vector
 when constructing PlanarSurfaceInteraction testShell

---
 shells.py | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index cd19d33e..a23eac04 100755
--- a/shells.py
+++ b/shells.py
@@ -194,7 +194,21 @@ def __init__(self, single, origin_structure, target_structure):
 
         # The reference_vector is the normalized vector from the reference_point to the particle
         if any(pos_transposed != self.reference_point) :
-            self.reference_vector = normalize(pos_transposed - self.reference_point)
+            diff_vector = pos_transposed - self.reference_point
+
+            # Compare to the largest component of the difference vector
+            # If a component is TOLERANCE times smaller, regard it as zero
+            # This is to avoid calculation errors when the distance to the
+            # surface is very small
+            max_component = max(diff_vector, key = lambda x : abs(x))
+            for c in range(0,3):
+                if abs(diff_vector[c]) <= TOLERANCE * abs(max_component):                    
+                    diff_vector[c] = 0.0
+                    log.debug('Setting diff-vector component %s to zero.' % str(c))   ### TESTING
+
+            self.reference_vector = normalize(diff_vector)
+            log.debug('setting reference_vector = %s, pos=%s, pos_transposed=%s, reference_point=%s, pos_transposed-reference_point=%s' \
+                      % (self.reference_vector, self.pid_particle_pair[1].position, pos_transposed, self.reference_point, pos_transposed-self.reference_point) )   ### TESTING
         else:
             self.reference_vector = 0
             raise testShellError('(testInteractionSingle). reference vector = 0.')
@@ -1451,6 +1465,7 @@ def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
 
     # determine what parameter of the cylinder (dr of dz) to scale.
     relative_orientation = numpy.dot(orientation_vector, shape.unit_z)
+    log.debug('relative_orientation = %s, orientation_vector = %s, shape.unit_z = %s' % (relative_orientation, orientation_vector, shape.unit_z) )   ### TESTING
     if feq(relative_orientation, 0):
 
         distance = testShell.world.distance(shape, reference_point)

From e6b9cfad8b2ffe61ff1e101bf4496f43a7a43759 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 15:05:02 +0100
Subject: [PATCH 1254/1541] Increase tolerance for vector component comparison

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index a23eac04..19c2207b 100755
--- a/shells.py
+++ b/shells.py
@@ -202,7 +202,7 @@ def __init__(self, single, origin_structure, target_structure):
             # surface is very small
             max_component = max(diff_vector, key = lambda x : abs(x))
             for c in range(0,3):
-                if abs(diff_vector[c]) <= TOLERANCE * abs(max_component):                    
+                if abs(diff_vector[c]) <= 1.0e-6 * abs(max_component):  # FIXME using TOLERANCE does not always work here
                     diff_vector[c] = 0.0
                     log.debug('Setting diff-vector component %s to zero.' % str(c))   ### TESTING
 

From 865874cb5cb80979aeff9988d3a71bd32ab8fd0e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 15:08:43 +0100
Subject: [PATCH 1255/1541] Cleanup

---
 shells.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/shells.py b/shells.py
index 19c2207b..4c6f422f 100755
--- a/shells.py
+++ b/shells.py
@@ -199,16 +199,14 @@ def __init__(self, single, origin_structure, target_structure):
             # Compare to the largest component of the difference vector
             # If a component is TOLERANCE times smaller, regard it as zero
             # This is to avoid calculation errors when the distance to the
-            # surface is very small
+            # surface is very small / has very small nonzero components
             max_component = max(diff_vector, key = lambda x : abs(x))
             for c in range(0,3):
-                if abs(diff_vector[c]) <= 1.0e-6 * abs(max_component):  # FIXME using TOLERANCE does not always work here
+                if abs(diff_vector[c]) <= 1.0e-6 * abs(max_component):  # FIXME using TOLERANCE does not always work here                    
+                    log.warning('Setting component %s of difference vector %s to zero.' % (c, diff_vector))
                     diff_vector[c] = 0.0
-                    log.debug('Setting diff-vector component %s to zero.' % str(c))   ### TESTING
 
             self.reference_vector = normalize(diff_vector)
-            log.debug('setting reference_vector = %s, pos=%s, pos_transposed=%s, reference_point=%s, pos_transposed-reference_point=%s' \
-                      % (self.reference_vector, self.pid_particle_pair[1].position, pos_transposed, self.reference_point, pos_transposed-self.reference_point) )   ### TESTING
         else:
             self.reference_vector = 0
             raise testShellError('(testInteractionSingle). reference vector = 0.')
@@ -1465,7 +1463,7 @@ def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
 
     # determine what parameter of the cylinder (dr of dz) to scale.
     relative_orientation = numpy.dot(orientation_vector, shape.unit_z)
-    log.debug('relative_orientation = %s, orientation_vector = %s, shape.unit_z = %s' % (relative_orientation, orientation_vector, shape.unit_z) )   ### TESTING
+
     if feq(relative_orientation, 0):
 
         distance = testShell.world.distance(shape, reference_point)

From a49824527b10c12570f3626c65ab3adb52ce6855 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Nov 2012 15:57:35 +0100
Subject: [PATCH 1256/1541] Another safety check to prevent math domain errors
 in cylinder scaling

---
 shells.py | 62 ++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 41 insertions(+), 21 deletions(-)

diff --git a/shells.py b/shells.py
index 5d0eb274..ae24b673 100755
--- a/shells.py
+++ b/shells.py
@@ -1196,18 +1196,28 @@ def h1_eq(x):
                         #rhs = (scale_center_to_shell_z - \
                               #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
 
-                        eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
-                                  (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2 ) )**2
-
                         # TODO TESTING REMOVE THIS WHEN DONE
-                        #print "***** ROOTFINDER CALL: Calling h1_eq() with: *****"
-                        #print "  h1 = %s, value = %s" % (x, eq_value )
-                        #print "  r1 = %s" % (r1_function(x+scale_center_z))
-                        #print "  lambda = %s" % (math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                        #print "  Dy-lambda = %s" % (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))
-                        #print "  (Dy-lambda)^2 = %s" % ((scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ))**2 )
-                        #print "  outer = %s" % (shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2)
+                        log.debug( "***** ROOTFINDER CALL: Calling h1_eq() with: *****" )
+                        log.debug( "  r1 = %s" % (r1_function(x+scale_center_z)) )
+                        log.debug( "  sqrt_arg = %s" % ((x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2) )
+                        log.debug( "    tan_scale_angle = %s" % (tan_scale_angle) )
+                        log.debug( "    x*tan_scale_angle = %s" % (x*tan_scale_angle) )
+                        log.debug( "    scale_center_to_shell_edge_x = %s" % scale_center_to_shell_edge_x )
+
+                        # We will take the square root of the following below
+                        sqrt_arg = (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2
+
+                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x**2:
+
+                            sqrt_arg = 0.0      # This safety check is to prevent math domain errors
+                                                # in case sqrt_arg is close to zero and taking the
+                                                # difference results in very small negative numbers
+
+                        eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
+                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ))**2
                                             
+                        log.debug( "  h1 = %s, value = %s" % (x, eq_value ) )
+
                         return eq_value
 
                     # Self-adaptive initial value guessing for the rootfinder procedure:
@@ -1232,13 +1242,13 @@ def h1_eq(x):
                     assert(h1_interval_end   >= h1_interval_end)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    #print "***** NEW ROOTFINDER ITERATION *****"
-                    #print "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius)
-                    #print "  Dx-h2 = %s" % scale_center_to_shell_edge_x
-                    #print "  h1_interval_start = %s" % h1_interval_start
-                    #print "  h1_interval_end = %s"   % h1_interval_end
-                    #print "  h1(i_start) = %s"       % h1_eq(h1_interval_start)
-                    #print "  h1(i_end) = %s"         % h1_eq(h1_interval_end)
+                    log.debug( "***** NEW ROOTFINDER ITERATION *****" )
+                    log.debug( "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius) )
+                    log.debug( "  Dx-h2 = %s" % scale_center_to_shell_edge_x )
+                    log.debug( "  h1_interval_start = %s" % h1_interval_start )
+                    log.debug( "  h1_interval_end = %s"   % h1_interval_end )
+                    log.debug( "  h1(i_start) = %s"       % h1_eq(h1_interval_start) )
+                    log.debug( "  h1(i_end) = %s"         % h1_eq(h1_interval_end) )
 
                     h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                     z1_new = min(z1, h_touch)
@@ -1248,13 +1258,23 @@ def h1_eq(x):
                     # This uses the same rootfinding equation and interval as above with r1=h1/tan_scale_angle
                     # instead of h1; notice that scale_angle > 0 here, so we can divide by it
                     def r1_eq(x):
+
+                        # We will take the square root of the following below
+                        sqrt_arg = x**2 - scale_center_to_shell_edge_x**2
+
+                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x**2:
+
+                            sqrt_arg = 0.0      # This safety check is to prevent math domain errors
+                                                # in case sqrt_arg is close to zero and taking the
+                                                # difference results in very small negative numbers
+
                         eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
-                                  (scale_center_to_shell_y - math.sqrt( x**2 - scale_center_to_shell_edge_x**2 ) )**2
+                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ) )**2
 
                         # TODO TESTING REMOVE THIS WHEN DONE
-                        #print "***** ROOTFINDER CALL: Calling r1_eq() with: *****"
-                        #print "  r1 = %s, value = %s" % (x, eq_value )
-                        #print "  h1 = %s" % (z1_function(x))
+                        #log.debug( "***** ROOTFINDER CALL: Calling r1_eq() with: *****" )
+                        #log.debug( "  r1 = %s, value = %s" % (x, eq_value ) )
+                        #log.debug( "  h1 = %s" % (z1_function(x)) )
 
                         return eq_value
 

From c06bfab2b9cb6a22aca7b661bdcc8bdbdd044298 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Nov 2012 17:48:27 +0100
Subject: [PATCH 1257/1541] Cleanup

---
 shells.py | 45 ++++++++++++++++++++++-----------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/shells.py b/shells.py
index ae24b673..f0e31d92 100755
--- a/shells.py
+++ b/shells.py
@@ -1197,12 +1197,12 @@ def h1_eq(x):
                               #math.sqrt(shell_radius**2 - (scale_center_to_shell_y - math.sqrt( (x*tan_scale_angle)**2 - (scale_center_to_shell_x - shell_half_length)**2 ) )**2 ) )
 
                         # TODO TESTING REMOVE THIS WHEN DONE
-                        log.debug( "***** ROOTFINDER CALL: Calling h1_eq() with: *****" )
-                        log.debug( "  r1 = %s" % (r1_function(x+scale_center_z)) )
-                        log.debug( "  sqrt_arg = %s" % ((x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2) )
-                        log.debug( "    tan_scale_angle = %s" % (tan_scale_angle) )
-                        log.debug( "    x*tan_scale_angle = %s" % (x*tan_scale_angle) )
-                        log.debug( "    scale_center_to_shell_edge_x = %s" % scale_center_to_shell_edge_x )
+                        #log.debug( "***** ROOTFINDER CALL: Calling h1_eq() with: *****" )
+                        #log.debug( "  r1 = %s" % (r1_function(x+scale_center_z)) )
+                        #log.debug( "  sqrt_arg = %s" % ((x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2) )
+                        #log.debug( "    tan_scale_angle = %s" % (tan_scale_angle) )
+                        #log.debug( "    x*tan_scale_angle = %s" % (x*tan_scale_angle) )
+                        #log.debug( "    scale_center_to_shell_edge_x = %s" % scale_center_to_shell_edge_x )
 
                         # We will take the square root of the following below
                         sqrt_arg = (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2
@@ -1212,11 +1212,13 @@ def h1_eq(x):
                             sqrt_arg = 0.0      # This safety check is to prevent math domain errors
                                                 # in case sqrt_arg is close to zero and taking the
                                                 # difference results in very small negative numbers
+                            log.warn('Orthogonal cylinder scaling, EDGE_HITS_EDGE case: Setting negative sqrt argument to zero within TOLERANCE.')
 
                         eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
                                       (scale_center_to_shell_y - math.sqrt( sqrt_arg ))**2
-                                            
-                        log.debug( "  h1 = %s, value = %s" % (x, eq_value ) )
+                        
+                        # TODO TESTING REMOVE THIS WHEN DONE                    
+                        #log.debug( "  h1 = %s, value = %s" % (x, eq_value ) )
 
                         return eq_value
 
@@ -1242,13 +1244,13 @@ def h1_eq(x):
                     assert(h1_interval_end   >= h1_interval_end)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
-                    log.debug( "***** NEW ROOTFINDER ITERATION *****" )
-                    log.debug( "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius) )
-                    log.debug( "  Dx-h2 = %s" % scale_center_to_shell_edge_x )
-                    log.debug( "  h1_interval_start = %s" % h1_interval_start )
-                    log.debug( "  h1_interval_end = %s"   % h1_interval_end )
-                    log.debug( "  h1(i_start) = %s"       % h1_eq(h1_interval_start) )
-                    log.debug( "  h1(i_end) = %s"         % h1_eq(h1_interval_end) )
+                    #log.debug( "***** NEW ROOTFINDER ITERATION *****" )
+                    #log.debug( "  Dy-r2 = %s" % (scale_center_to_shell_y-shell_radius) )
+                    #log.debug( "  Dx-h2 = %s" % scale_center_to_shell_edge_x )
+                    #log.debug( "  h1_interval_start = %s" % h1_interval_start )
+                    #log.debug( "  h1_interval_end = %s"   % h1_interval_end )
+                    #log.debug( "  h1(i_start) = %s"       % h1_eq(h1_interval_start) )
+                    #log.debug( "  h1(i_end) = %s"         % h1_eq(h1_interval_end) )
 
                     h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                     z1_new = min(z1, h_touch)
@@ -1267,6 +1269,7 @@ def r1_eq(x):
                             sqrt_arg = 0.0      # This safety check is to prevent math domain errors
                                                 # in case sqrt_arg is close to zero and taking the
                                                 # difference results in very small negative numbers
+                            log.warn('Orthogonal cylinder scaling, EDGE_HITS_EDGE case: Setting negative sqrt argument to zero within TOLERANCE.')
 
                         eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
                                       (scale_center_to_shell_y - math.sqrt( sqrt_arg ) )**2
@@ -1341,11 +1344,6 @@ def r1_eq(x):
             angle_diff = abs(shell_angle_yz - scale_angle)
             sin_angle_diff = math.sin(angle_diff)
             cos_angle_diff = math.cos(angle_diff)
-
-            # TODO TESTING Laurens' version, remove when the other works well
-            # Remove this when it is certain that the new version does not fail
-            #scale_center_shell_dist = (scale_center_to_shell * cos_angle_diff -
-                                       #math.sqrt(shell_radius_sq - (ss_sq * sin_angle_diff * sin_angle_diff) ))
             
             assert scale_center_to_shell >= shell_radius # should never fail
             #ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius) ## TESTING Old version
@@ -1358,9 +1356,10 @@ def r1_eq(x):
                                               % str(scale_center_shell_dist)
 
             # Check whether the calculated distance is within the forseen bounds and warn if not
-            if not(scale_center_shell_dist <= scale_center_to_shell_y and scale_center_shell_dist <= scale_center_to_shell_z):
-                log.warning('EDGE_HITS_BARREL: scale-center-to-shell distance is out of forseen bounds, distance=%s' \
-                              % str(scale_center_shell_dist) )
+            if scale_center_shell_dist > math.sqrt(scale_center_to_shell_y**2+scale_center_to_shell_z**2)*(1.0+TOLERANCE):
+                log.warning('Orthogonal cylinder scaling, EDGE_HITS_BARREL case: scale-center-to-shell distance is out of foreseen bounds:')
+                log.warning('   distance=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s' \
+                             % (scale_center_shell_dist, scale_center_to_shell_y, scale_center_to_shell_z) )
 
             if scale_angle <= Pi/4.0:
                 cos_scale_angle = math.cos(scale_angle)

From 5d21184843966715e6a7060f51ac8ce23897869c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 13 Nov 2012 18:18:27 +0100
Subject: [PATCH 1258/1541] Switch on MixedPair2D3D formation

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 044ad5d4..707e0291 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -147,10 +147,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
             return CylindricalSurfacePairtestShell  (single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
         return PlanarSurfaceTransitionPairtestShell (single1, single2, geometrycontainer, domains) 
-    #elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        #return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
-    #elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        #return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
+    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
+        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
         return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):

From 2b7dadfe5a8e6ec2d7f1bde0f18f2c7855de2a87 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 12:04:24 +0100
Subject: [PATCH 1259/1541] Improve clarity of definitions for MixedPair2D3D

---
 shells.py | 94 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 58 insertions(+), 36 deletions(-)

diff --git a/shells.py b/shells.py
index f0e31d92..8d1990b9 100755
--- a/shells.py
+++ b/shells.py
@@ -235,7 +235,7 @@ def __init__(self, single1, single2):
         self.structure1 = single1.structure
         self.structure2 = single2.structure
 
-        self.com, self.iv = self.do_transform()         # NOTE The IV always points from particle1 to particle2
+        self.com, self.iv = self.do_transform()   # NOTE The IV always points from particle1 to particle2
         self.r0 = length(self.iv)
         if self.r0 < self.sigma:
             raise protoDomainError('distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
@@ -320,10 +320,9 @@ class testMixedPair2D3D(testPair):
 
     def __init__(self, single2D, single3D):
 
-        # First define 
-        # for clarity:
+        # First define for clarity:
         self.structure2D = single2D.structure   # equal to self.structure1
-        self.structure3D = single3D.structure   # equal to self.structure2
+        self.structure3D = single3D.structure   # equal to self.structure2        
 
         # These methods need above definitions.
         if __debug__: 
@@ -332,36 +331,45 @@ def __init__(self, single2D, single3D):
         testPair.__init__(self, single2D, single3D)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
           #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
-          
-        # TODO: modification by Martijn Wehrens (jintram@gmail.com) -- not absolutely sure this is correct place
+
+        # Again for clarity define:
+        self.ppp2D      = self.pid_particle_pair1
+        self.ppp3D      = self.pid_particle_pair2
+        self.particle2D = self.ppp2D[1]
+        self.particle3D = self.ppp3D[1]
+
+        # The following will be needed by some domain overlap checking functions
+        # TODO: modification by Martijn Wehrens (jintram@gmail.com)
+        #       -- not absolutely sure this is correct place
         self.origin_structure = self.structure3D
         self.target_structure = self.structure2D        
 
     def get_sigma(self):
         # rescale sigma to correct for the rescaling of the coordinate system
-        # This is the sigma that is used for the evaluation of the Green's function and is in this case slightly
-        # different than the sums of the radii of the particleso
+        # This is the sigma that is used for the evaluation of the Green's function and is in this case 
+        # slightly different than the sums of the radii of the particles
         xi = self.get_scaling_factor()
         xi_inv = 1.0/xi
         alpha = math.acos(xi_inv)
-        sigma = self.pid_particle_pair1[1].radius + self.pid_particle_pair2[1].radius
+        sigma = self.particle2D.radius + self.particle3D.radius
         rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
         return rho
     sigma = property(get_sigma)
 
     def do_transform(self):
         # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
-        pos1 = self.pid_particle_pair1[1].position
-        pos2 = self.pid_particle_pair2[1].position
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        pos2D = self.particle2D.position
+        pos3D = self.particle3D.position
+        D_2D  = self.particle2D.D
+        D_3D  = self.particle3D.D
 
+        # CoM calculation
         # the CoM is calculated in a similar way to a normal 3D pair
-        com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
+        com = self.world.calculate_pair_CoM(pos2D, pos3D, D_2D, D_3D)
 
         # and then projected onto the plane to make sure the CoM is in the surface
         com = self.world.cyclic_transpose(com, self.structure2D.shape.position)
-        com, (_, dist) = self.structure2D.project_point (com)
+        com, (_, dist) = self.structure2D.project_point(com)
         if dist >= 0:
             raise testShellError('(testMixedPair2D3D). Projected point of CoM is not in surface.')
         else:
@@ -369,9 +377,9 @@ def do_transform(self):
 
         com = self.world.apply_boundary(com)
 
-        # calculate the interparticle vector
-        pos2t = self.world.cyclic_transpose(pos2, pos1)
-        iv = pos2t - pos1
+        # IV calculation
+        pos3D_t = self.world.cyclic_transpose(pos3D, pos2D)
+        iv      = pos3D_t - pos2D
 
         # rescale the iv in the axis normal to the plane
         iv_z_component = numpy.dot (iv, self.structure2D.shape.unit_z)
@@ -385,9 +393,9 @@ def do_transform(self):
     def get_scaling_factor(self):
         # This returns the scaling factor needed to make the anisotropic diffusion problem of the IV
         # into a isotropic one.
-        D_2 = self.pid_particle_pair2[1].D      # particle 2 is in 3D and is the only contributor to diffusion
+        D_3D = self.pid_particle_pair3D[1].D    # 3D particle is the only contributor to diffusion
                                                 # normal to the plane
-        return math.sqrt(self.D_r/D_2)
+        return math.sqrt(self.D_r/D_3D)
 
 class testMixedPair1DCap(testPair):
 
@@ -2512,47 +2520,59 @@ def get_max_dr_dzright_dzleft(self):
         dr       = min(dr_sr, dr_edge)
         dz_left  = self.pid_particle_pair1[1].radius
 
-        # now adjust dz_right such that they obey the scaling laws and are still with the search_radius
+        # now adjust dz_right such that they obey the scaling laws and are still within the search_radius
         # We assume that dz_right needs to be adjusted to dr and not the other way around since the cylinder is
         # always a bit flatter.
-        dz_right = self.z_right(dr)
-#        print "max= ", dr, dz_right, dz_left
-        assert dr > dz_right
+        dz_right = self.z_right(dr)        
+        ## Debug output for TESTING
+        #log.debug( "max_dr=%s, max_dz_right=%s, max_dz_left=%s" % (dr, dz_right, dz_left) )
+        #log.debug( "min_dist_proj_to_edge=%s" % str(self.min_dist_proj_to_edge) )
+        #assert dr > dz_right   ## Removed for TESTING
 
         return dr, dz_right, dz_left
 
     def z_right(self, r_right):
-        # if the radius is known and we want to determine the height z_right
+        # This calculates the height z_right of the newly constructed domain
+        # (above the plane) if the radius r is known
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
-        # calculate a_r such that the expected first-passage for the CoM and IV are equal
+        # calculate a_r such that the expected first-passage for the CoM and IV are equal        
+        #sqrt_DRDr_1 = math.sqrt( 2.0/3.0 * self.D_R/D_1 )  # TESTING
+        #sqrt_DRDr_2 = math.sqrt( 2.0/3.0 * self.D_R/D_2 )
         a_r1 = (r_right - radius1 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_1/self.D_tot) )
-        a_r2 = (r_right - radius2 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2/self.D_tot) )
+        a_r2 = (r_right - radius2 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2/self.D_tot) )        
         # take the smallest that, if entered in the function for r below, would lead to this z_right
-        a_r = min (a_r1, a_r2)
+        a_r = min (a_r1, a_r2)        
 
         z_right = (a_r/self.get_scaling_factor()) + radius2
 
-#        assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
-#                                                     r_right= %s, r_right(z_right)=%s ' % \
-#                                                     (r_right, self.r_right(z_right))
+        ## Debug output for TESTING
+        #log.debug( " a_r1=%s, a_r2=%s, z_right=%s, r_right=%s" % (a_r1, a_r2, z_right, r_right))
 
+        #assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
+                                                    #r_right= %s, r_right(z_right)=%s ' % \
+                                                    #(r_right, self.r_right(z_right))
         return z_right
 
     def r_right(self, z_right):
-        # if the z_right is known and we want to know the radius r
+        # This calculates the radius r of the newly constructed domain
+        # if the height z_right is known
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
-        # we first calculate the a_r, since it is the only radius that depends on z_right only.
+        # We first calculate the a_r, since it is the only radius that depends on z_right only.
+        # The dependence is given by the scaling factor that converts spherical coordinates into
+        # prolate spheroidal coordinates
         a_r = (z_right - radius2) * self.get_scaling_factor()
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
+        # via a_R/(a_r-self.r0) == sqrt(4 D_R t)/sqrt(6 D_r t) (for an arbitrary t).
+        # This gives us a CoM domain radius a_R as a function of a_r at equal expected first passage time.
         # Note that for the IV we only take the distance to the outer boundary into account.
         a_R = (a_r - self.r0)*self.sqrt_DRDr
 
@@ -2560,18 +2580,20 @@ def r_right(self, z_right):
         iv_max = max( (D_1/self.D_tot * a_r + radius1),
                       (D_2/self.D_tot * a_r + radius2))
 
+        # The total domain radius is then given by the sum of the max. IV displacement and
+        # the estimated a_R value for the same first passage time
         r_right = a_R + iv_max
 
         assert feq(self.z_right(r_right), z_right), 'inconsistent r_right function \
-                                                  z_right= %s, z_right(r_right)=%s ' % \
-                                                  (z_right, self.z_right(r_right))
-
+                                                     z_right= %s, z_right(r_right)=%s ' % \
+                                                     (z_right, self.z_right(r_right))
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
         SAFETY = 1.1 # FIXME What is that? Why is that not the standard?
         return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, z_left
 
+
 class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):
 
     def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?

From 985a8cb7cbb1c2541010c7da9e5d82269cf3c3a0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 12:14:28 +0100
Subject: [PATCH 1260/1541] Continue...

---
 shells.py | 112 ++++++++++++++++++++++++++++++------------------------
 1 file changed, 62 insertions(+), 50 deletions(-)

diff --git a/shells.py b/shells.py
index 8d1990b9..35b13367 100755
--- a/shells.py
+++ b/shells.py
@@ -321,8 +321,15 @@ class testMixedPair2D3D(testPair):
     def __init__(self, single2D, single3D):
 
         # First define for clarity:
+        self.single2D = single2D
+        self.single3D = single3D
+        self.ppp2D      = single2D.pid_particle_pair
+        self.ppp3D      = single3D.pid_particle_pair
+        self.particle2D = single2D.pid_particle_pair[1]
+        self.particle3D = single3D.pid_particle_pair[1]
+
         self.structure2D = single2D.structure   # equal to self.structure1
-        self.structure3D = single3D.structure   # equal to self.structure2        
+        self.structure3D = single3D.structure   # equal to self.structure2
 
         # These methods need above definitions.
         if __debug__: 
@@ -330,13 +337,11 @@ def __init__(self, single2D, single3D):
                 assert isinstance(single3D.structure, CuboidalRegion)
         testPair.__init__(self, single2D, single3D)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
-          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle
+          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle              
 
-        # Again for clarity define:
-        self.ppp2D      = self.pid_particle_pair1
-        self.ppp3D      = self.pid_particle_pair2
-        self.particle2D = self.ppp2D[1]
-        self.particle3D = self.ppp3D[1]
+        assert self.single2D == self.single1           and self.single3D == self.single2
+        assert self.ppp2D == self.pid_particle_pair1   and self.ppp3D == self.pid_particle_pair2
+        assert self.structure2D == self.structure1     and self.structure3D == self.structure2
 
         # The following will be needed by some domain overlap checking functions
         # TODO: modification by Martijn Wehrens (jintram@gmail.com)
@@ -345,15 +350,19 @@ def __init__(self, single2D, single3D):
         self.target_structure = self.structure2D        
 
     def get_sigma(self):
-        # rescale sigma to correct for the rescaling of the coordinate system
+        # rescale sigma to correct for the rescaling of the coordinate system.
         # This is the sigma that is used for the evaluation of the Green's function and is in this case 
-        # slightly different than the sums of the radii of the particles
+        # slightly different from the sums of the radii of the particles. We rescale sigma in a way
+        # that the total flux over the reactive surface of the prolate spheroidal boundary with greater radius
+        # sigma is equal to the total flux over a spherical reactive surface with radius = rescaled sigma.
         xi = self.get_scaling_factor()
         xi_inv = 1.0/xi
         alpha = math.acos(xi_inv)
+
         sigma = self.particle2D.radius + self.particle3D.radius
-        rho = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
-        return rho
+        rescaled_sigma = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
+
+        return rescaled_sigma
     sigma = property(get_sigma)
 
     def do_transform(self):
@@ -393,8 +402,8 @@ def do_transform(self):
     def get_scaling_factor(self):
         # This returns the scaling factor needed to make the anisotropic diffusion problem of the IV
         # into a isotropic one.
-        D_3D = self.pid_particle_pair3D[1].D    # 3D particle is the only contributor to diffusion
-                                                # normal to the plane
+        D_3D = self.particle3D.D    # 3D particle is the only contributor to diffusion
+                                    # normal to the plane
         return math.sqrt(self.D_r/D_3D)
 
 class testMixedPair1DCap(testPair):
@@ -2428,31 +2437,33 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         # initialize commonly used constants
         self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
 
-        # initialize the scaling parameters
-        bla = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.pid_particle_pair1[1].D/self.D_tot,
-                                                                  self.pid_particle_pair2[1].D/self.D_tot ))
-        minimum = self.r0+self.pid_particle_pair1[1].radius
+        # initialize the scaling parameters        
+        minimum = self.r0 + self.particle2D.radius
         self.drdz_right = self.r_right(minimum + 1.0) - self.r_right(minimum)
-        assert feq(bla, self.drdz_right), 'bla= %s, drdz_right=%s' % (bla, self.drdz_right)
+        self.dzdr_right = 1.0/self.drdz_right
 
-        bla2 = self.z_right(minimum + 1.0) - self.z_right(minimum)
+        #bla = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.particle2D.D/self.D_tot,
+                                                                  #self.particle3D.D/self.D_tot ))
+        #assert feq(bla, self.drdz_right), 'bla= %s, drdz_right=%s' % (bla, self.drdz_right)
+        #bla2 = self.z_right(minimum + 1.0) - self.z_right(minimum)
 
         minr, minz_right, _ = self.get_min_dr_dzright_dzleft()
-        self.dzdr_right = 1.0/self.drdz_right
-        assert feq(self.dzdr_right, bla2), 'bla2= %s, dzdr_right= %s' % (bla2, self.dzdr_right)
+
+        #assert feq(self.dzdr_right, bla2), 'bla2= %s, dzdr_right= %s' % (bla2, self.dzdr_right)
+
         self.r0_right   = 0.0
         self.z0_right   = self.z_right(self.r0_right)
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
-        self.z0_left    = self.pid_particle_pair1[1].radius
+        self.z0_left    = self.particle2D.radius
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure3D.id, [self.single1.domain_id, self.single2.domain_id],
+                            self.determine_possible_shell(self.structure3D.id, [self.single2D.domain_id, self.single3D.domain_id],
                                                           [self.structure2D.id])
         except ShellmakingError as e:
             raise testShellError('(MixedPair2D3D). %s' %
@@ -2465,7 +2476,7 @@ def get_orientation_vector(self):
 
     def get_searchpoint(self):
         # TODO this can be improved, now same as PlanarSurfaceInteraction
-        search_distance = self.get_searchradius()/math.sqrt(2) - self.z0_left
+        search_distance = self.get_searchradius()/math.sqrt(2.0) - self.z0_left
         return self.get_referencepoint() + search_distance * self.get_orientation_vector()
 
     def get_referencepoint(self):
@@ -2475,15 +2486,15 @@ def get_min_dr_dzright_dzleft(self):
         # defines the minimum parameters of the testShell.
         # Note that also the minimum testShell must obey the scaling rules
 
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
 
         ### calculate the minimal height z_right1 of the shell including burst radius
         iv_z = self.r0      # approximation, actually the height of the domain can be slightly lower.
-        dz_right1 = iv_z + radius2 * SINGLE_SHELL_FACTOR
+        dz_right1 = iv_z + radius3D * SINGLE_SHELL_FACTOR
         # with the accompanying radius r1
         dr_1 = self.r_right(dz_right1)
 
@@ -2509,8 +2520,9 @@ def get_min_dr_dzright_dzleft(self):
         dr = dr_1
         dz_right = dz_right1
 
-        dz_left  = self.pid_particle_pair1[1].radius
+        dz_left  = self.particle2D.radius
 #        print "min= ", dr, dz_right, dz_left
+
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
@@ -2518,7 +2530,7 @@ def get_max_dr_dzright_dzleft(self):
         dr_sr    = self.get_searchradius()/math.sqrt(2)
         dr_edge  = self.min_dist_proj_to_edge
         dr       = min(dr_sr, dr_edge)
-        dz_left  = self.pid_particle_pair1[1].radius
+        dz_left  = self.particle2D.radius
 
         # now adjust dz_right such that they obey the scaling laws and are still within the search_radius
         # We assume that dz_right needs to be adjusted to dr and not the other way around since the cylinder is
@@ -2534,23 +2546,23 @@ def get_max_dr_dzright_dzleft(self):
     def z_right(self, r_right):
         # This calculates the height z_right of the newly constructed domain
         # (above the plane) if the radius r is known
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
         # calculate a_r such that the expected first-passage for the CoM and IV are equal        
-        #sqrt_DRDr_1 = math.sqrt( 2.0/3.0 * self.D_R/D_1 )  # TESTING
-        #sqrt_DRDr_2 = math.sqrt( 2.0/3.0 * self.D_R/D_2 )
-        a_r1 = (r_right - radius1 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_1/self.D_tot) )
-        a_r2 = (r_right - radius2 + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2/self.D_tot) )        
+        #sqrt_DRDr_2D = math.sqrt( 2.0/3.0 * self.D_R/D_2D )  # TESTING
+        #sqrt_DRDr_3D = math.sqrt( 2.0/3.0 * self.D_R/D_3D )
+        a_r_2D = (r_right - radius2D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2D/self.D_tot) )
+        a_r_3D = (r_right - radius3D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_3D/self.D_tot) )        
         # take the smallest that, if entered in the function for r below, would lead to this z_right
-        a_r = min (a_r1, a_r2)        
+        a_r = min (a_r_2D, a_r_3D)
 
-        z_right = (a_r/self.get_scaling_factor()) + radius2
+        z_right = (a_r/self.get_scaling_factor()) + radius3D
 
         ## Debug output for TESTING
-        #log.debug( " a_r1=%s, a_r2=%s, z_right=%s, r_right=%s" % (a_r1, a_r2, z_right, r_right))
+        #log.debug( " a_r_2D=%s, a_r_3D=%s, z_right=%s, r_right=%s" % (a_r_2D, a_r_3D, z_right, r_right))
 
         #assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
                                                     #r_right= %s, r_right(z_right)=%s ' % \
@@ -2560,15 +2572,15 @@ def z_right(self, r_right):
     def r_right(self, z_right):
         # This calculates the radius r of the newly constructed domain
         # if the height z_right is known
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
         # We first calculate the a_r, since it is the only radius that depends on z_right only.
         # The dependence is given by the scaling factor that converts spherical coordinates into
         # prolate spheroidal coordinates
-        a_r = (z_right - radius2) * self.get_scaling_factor()
+        a_r = (z_right - radius3D) * self.get_scaling_factor()
 
         # We equalize the estimated first passage time for the CoM (2D) and IV (3D) for a given a_r
         # via a_R/(a_r-self.r0) == sqrt(4 D_R t)/sqrt(6 D_r t) (for an arbitrary t).
@@ -2577,8 +2589,8 @@ def r_right(self, z_right):
         a_R = (a_r - self.r0)*self.sqrt_DRDr
 
         # We calculate the maximum space needed for particles A and B based on maximum IV displacement
-        iv_max = max( (D_1/self.D_tot * a_r + radius1),
-                      (D_2/self.D_tot * a_r + radius2))
+        iv_max = max( (D_2D/self.D_tot * a_r + radius2D),
+                      (D_3D/self.D_tot * a_r + radius3D))
 
         # The total domain radius is then given by the sum of the max. IV displacement and
         # the estimated a_R value for the same first passage time
@@ -2590,7 +2602,7 @@ def r_right(self, z_right):
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
-        SAFETY = 1.1 # FIXME What is that? Why is that not the standard?
+        SAFETY = 1.1 # FIXME What the hell is that? Why is that not the standard?
         return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, z_left
 
 

From 720e6ba48056569a1f6d0161c731f2a31b89c3f7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 14:26:14 +0100
Subject: [PATCH 1261/1541] Also improve naming consitency and comments in
 pair.py

---
 pair.py | 83 +++++++++++++++++++++++++++++----------------------------
 1 file changed, 42 insertions(+), 41 deletions(-)

diff --git a/pair.py b/pair.py
index 03903c40..3315488e 100644
--- a/pair.py
+++ b/pair.py
@@ -855,7 +855,9 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         
         # Some definitions 
         self.structure2D = self.testShell.structure2D   # the surface on which particle1 lives
-        self.structure3D = self.testShell.structure3D   # structure on which both particles live
+        self.structure3D = self.testShell.structure3D   # structure on which particle2 lives
+        self.particle2D  = self.testShell.particle2D
+        self.particle3D  = self.testShell.particle3D
 
         # initialize some useful constants
         self.z_scaling_factor = self.testShell.get_scaling_factor()
@@ -866,52 +868,50 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         # The latter is defined for completeness and used by check_domain() in egfrd.py:
         # (Note that that origin and target end up in same list.)
         self.origin_structure = self.testShell.origin_structure
-        self.target_structure = self.testShell.target_structure         
-#        self.origin_structure = self.structure3D
-#        self.target_structure = self.structure2D
-
+        self.target_structure = self.testShell.target_structure
 
     def determine_radii(self):
-        # determines the dimensions of the domains used for the Green's functions from the dimensions
-        # of the cylindrical shell.
+        # determines the dimensions of the domains used for the Green's functions 
+        # from the dimensions of the cylindrical shell.
         # Note that the function assumes that the cylinder is dimensioned properly
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
-        radius      = self.shell.shape.radius
-        half_length = self.shell.shape.half_length
+        shell_radius      = self.shell.shape.radius
+        shell_half_length = self.shell.shape.half_length
 
         # Use class methods to check dimensions of the cylinder
-        r_check  = self.testShell.r_right (half_length*2 - radius1)
-        hl_check = (self.testShell.z_right (radius) + self.testShell.z_left (radius))/2
+        r_check  = self.testShell.r_right(2.0*shell_half_length - radius2D)  # FIXME that can't work, can it???
+        hl_check = (self.testShell.z_right(shell_radius) + self.testShell.z_left(shell_radius)) / 2.0
         if __debug__:
-            assert feq(r_check, radius) and feq(hl_check, half_length), \
+            assert feq(r_check, shell_radius) and feq(hl_check, shell_half_length), \
                 'MixedPair2D3D: Domain did not obey scaling relationship. ' \
-                'radius = %s, half_length = %s, radius_check = %s, half_length_check = %s' % \
-                 (FORMAT_DOUBLE % radius,  FORMAT_DOUBLE % half_length,
-                  FORMAT_DOUBLE % r_check, FORMAT_DOUBLE % hl_check)
+                'shell_radius = %s, shell_half_length = %s, radius_check = %s, half_length_check = %s' % \
+                 (FORMAT_DOUBLE % shell_radius, FORMAT_DOUBLE % shell_half_length,
+                  FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check)
 
 
         # Partition the space in the protective domain over the IV and the CoM domains
-        z_left  = radius1
-        z_right = half_length * 2 - z_left
-        a_r = (z_right - radius2) * self.z_scaling_factor
-
-        # calculate the maximal displacement of a particle given an a_r. Also include its radius
-        space_for_iv = max( (D_1/self.D_tot) * a_r + radius1,
-                            (D_2/self.D_tot) * a_r + radius2)
-        a_R = radius - space_for_iv
+        z_left  = radius2D
+        z_right = 2.0*shell_half_length - z_left
+        a_r = (z_right - radius3D) * self.z_scaling_factor
 
+        # calculate the maximal displacement of a particle given an interparticle vector bound a_r.
+        # Also include its radius.
+        space_for_iv = max( (D_2D/self.D_tot) * a_r + radius2D,
+                            (D_3D/self.D_tot) * a_r + radius3D)
+        # This determines the CoM vector bound via
+        a_R = shell_radius - space_for_iv
 
         # Print the domain sizes and their estimated first passage times.
         if __debug__:
-            tr = ((a_r - self.r0)**2) / (6 * self.D_r)  # the expected escape time of the iv
+            tr = ((a_r - self.r0)**2.0) / (6.0 * self.D_r)  # the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
             else:
-                tR = (a_R**2) / (4 * self.D_R)          # the expected escape time of the CoM
+                tR = (a_R**2.0) / (4.0 * self.D_R)          # the expected escape time of the CoM
             log.debug('determine_radii: a_r= %s, tr= %s, a_R= %s, tR= %s, delta_tRr= %s' % \
                       (FORMAT_DOUBLE % a_r, FORMAT_DOUBLE % tr,
                        FORMAT_DOUBLE % a_R, FORMAT_DOUBLE % tR,
@@ -919,8 +919,9 @@ def determine_radii(self):
 
 #        assert feq(tr, tR), 'estimate first passage times were not equal'
 
-        assert (self.sigma < a_r) and (a_r < half_length*2)
-        assert (0 < a_R) and (a_R < radius)
+        # Some checks that shall never fail
+        assert (self.sigma < a_r) and (a_r < 2.0*shell_half_length)
+        assert (0 < a_R) and (a_R < shell_radius)
 
         return a_R, a_r
 
@@ -965,9 +966,9 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
         return pos1, pos2, structure2D.id, structure3D.id
 
     @ classmethod
-    def calc_z_scaling_factor(cls, D2d, D3d):
+    def calc_z_scaling_factor(cls, D_2D, D_3D):
         # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
-        return math.sqrt( (D2d + D3d) / D3d)
+        return math.sqrt( (D_2D + D_3D) / D_3D)
 
     def choose_pair_greens_function(self, r0, t):
         return self.iv_greens_function(r0)
@@ -977,8 +978,8 @@ def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 
     def iv_greens_function(self, r0):
-        # diffusion of the interparticle vector is three dimensional
-        # TODO Fix ugly hack to prevent particle overlap problem
+        # Diffusion of the interparticle vector is three dimensional
+        # TODO Fix this ugly HACK to prevent particle overlap problem
         return GreensFunction3DRadAbs(self.D_r, self.interparticle_ktot, max(r0, self.sigma),
                                       self.sigma, self.a_r)
 
@@ -1019,17 +1020,17 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
 
     def check(self):
     # perform internal consistency check 
-        radius1 = self.pid_particle_pair1[1].radius
-        radius2 = self.pid_particle_pair2[1].radius
-        D_1 = self.pid_particle_pair1[1].D
-        D_2 = self.pid_particle_pair2[1].D
+        radius2D = self.particle2D.radius
+        radius3D = self.particle3D.radius
+        D_2D = self.particle2D.D
+        D_3D = self.particle3D.D
 
         radius      = self.shell.shape.radius
         half_length = self.shell.shape.half_length
 
         # check that the shell obeys the scaling rules dimensions of the cylinder
-        r_check  = self.testShell.r_right (half_length*2 - radius1)
-        hl_check = (self.testShell.z_right (radius) + self.testShell.z_left (radius))/2
+        r_check  = self.testShell.r_right(2.0*half_length - radius2D)
+        hl_check = (self.testShell.z_right(radius) + self.testShell.z_left(radius))/2.0
         assert feq(r_check, radius) and feq(hl_check, half_length), \
             'MixedPair2D3D: Domain did not obey scaling relationship. '
 

From fb27e2f8d8aba334e2b476219dcc482851921fcd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 14:29:41 +0100
Subject: [PATCH 1262/1541] Yes it can!

---
 pair.py | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/pair.py b/pair.py
index 3315488e..4b11e525 100644
--- a/pair.py
+++ b/pair.py
@@ -871,9 +871,9 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.target_structure = self.testShell.target_structure
 
     def determine_radii(self):
-        # determines the dimensions of the domains used for the Green's functions 
+        # Determines the dimensions of the domains used for the Green's functions 
         # from the dimensions of the cylindrical shell.
-        # Note that the function assumes that the cylinder is dimensioned properly
+        # Note that the function assumes that the cylinder is dimensioned properly.
         radius2D = self.particle2D.radius
         radius3D = self.particle3D.radius
         D_2D = self.particle2D.D
@@ -881,9 +881,11 @@ def determine_radii(self):
 
         shell_radius      = self.shell.shape.radius
         shell_half_length = self.shell.shape.half_length
+        z_left            = radius2D
+        z_right           = 2.0*shell_half_length - z_left
 
         # Use class methods to check dimensions of the cylinder
-        r_check  = self.testShell.r_right(2.0*shell_half_length - radius2D)  # FIXME that can't work, can it???
+        r_check  = self.testShell.r_right(z_right)
         hl_check = (self.testShell.z_right(shell_radius) + self.testShell.z_left(shell_radius)) / 2.0
         if __debug__:
             assert feq(r_check, shell_radius) and feq(hl_check, shell_half_length), \
@@ -892,17 +894,17 @@ def determine_radii(self):
                  (FORMAT_DOUBLE % shell_radius, FORMAT_DOUBLE % shell_half_length,
                   FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check)
 
-
         # Partition the space in the protective domain over the IV and the CoM domains
-        z_left  = radius2D
-        z_right = 2.0*shell_half_length - z_left
+        # The outer bound of the interparticle vector is set by the particle diffusing in 3D via:
         a_r = (z_right - radius3D) * self.z_scaling_factor
 
-        # calculate the maximal displacement of a particle given an interparticle vector bound a_r.
-        # Also include its radius.
+        # Calculate the maximal displacement of a particle given an interparticle vector bound a_r
+        # taking into account the radius for both the 2D and 3D particle. This sets the remaining
+        # space for the CoM diffusion.
         space_for_iv = max( (D_2D/self.D_tot) * a_r + radius2D,
                             (D_3D/self.D_tot) * a_r + radius3D)
-        # This determines the CoM vector bound via
+
+        # It then determines the CoM vector bound via
         a_R = shell_radius - space_for_iv
 
         # Print the domain sizes and their estimated first passage times.

From bb3b0b40a0feeff41f119e3763cdbe79ecc4643d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 14:50:40 +0100
Subject: [PATCH 1263/1541] More info output

---
 pair.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 4b11e525..4f496bf3 100644
--- a/pair.py
+++ b/pair.py
@@ -890,9 +890,11 @@ def determine_radii(self):
         if __debug__:
             assert feq(r_check, shell_radius) and feq(hl_check, shell_half_length), \
                 'MixedPair2D3D: Domain did not obey scaling relationship. ' \
-                'shell_radius = %s, shell_half_length = %s, radius_check = %s, half_length_check = %s' % \
+                'shell_radius = %s, shell_half_length = %s, radius_check = %s, half_length_check = %s, ' \
+                'z_left = %s, z_right = %s' % \
                  (FORMAT_DOUBLE % shell_radius, FORMAT_DOUBLE % shell_half_length,
-                  FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check)
+                  FORMAT_DOUBLE % r_check,      FORMAT_DOUBLE % hl_check,
+                  FORMAT_DOUBLE % z_left,       FORMAT_DOUBLE % z_right          )
 
         # Partition the space in the protective domain over the IV and the CoM domains
         # The outer bound of the interparticle vector is set by the particle diffusing in 3D via:

From bfb23853ca851b7b4413ab687f0ef83b3c4981db Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 15 Nov 2012 18:39:43 +0100
Subject: [PATCH 1264/1541] More safety checks

---
 pair.py   |  2 +-
 shells.py | 41 ++++++++++++++++++++++++++++++++---------
 2 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/pair.py b/pair.py
index 4f496bf3..152df954 100644
--- a/pair.py
+++ b/pair.py
@@ -971,7 +971,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
 
     @ classmethod
     def calc_z_scaling_factor(cls, D_2D, D_3D):
-        # calculates the scaling factor to make the anisotropic diffusion problem into a isotropic one
+        # calculates the scaling factor to make the anisotropic diffusion problem into an isotropic one
         return math.sqrt( (D_2D + D_3D) / D_3D)
 
     def choose_pair_greens_function(self, r0, t):
diff --git a/shells.py b/shells.py
index 35b13367..8be9996a 100755
--- a/shells.py
+++ b/shells.py
@@ -2556,17 +2556,26 @@ def z_right(self, r_right):
         #sqrt_DRDr_3D = math.sqrt( 2.0/3.0 * self.D_R/D_3D )
         a_r_2D = (r_right - radius2D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2D/self.D_tot) )
         a_r_3D = (r_right - radius3D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_3D/self.D_tot) )        
-        # take the smallest that, if entered in the function for r below, would lead to this z_right
-        a_r = min (a_r_2D, a_r_3D)
+        # take the smaller a_r that, if entered in the function for r below, would lead to this r_right
+        a_r = min(a_r_2D, a_r_3D)
 
         z_right = (a_r/self.get_scaling_factor()) + radius3D
 
         ## Debug output for TESTING
         #log.debug( " a_r_2D=%s, a_r_3D=%s, z_right=%s, r_right=%s" % (a_r_2D, a_r_3D, z_right, r_right))
+        #log.debug('r_right= %s, r_right(z_right)=%s, z_right=%s' % (r_right, self.r_right(z_right), z_right) )
+
+        #assert feq(self.r_right(z_right), r_right), 'Inconsistent z_right function in MixedPair2D3DtestShell: \
+                                                     #r_right= %s, r_right(z_right)=%s, z_right=%s' % \
+                                                     #(r_right, self.r_right(z_right), z_right)
+
+        if r_right < 0.0 or z_right <0.0:
+            log.warning('Negative cylinder dimensions in MixedPair2D3DtestShell: z_right= %s, r_right=%s' % (z_right, r_right) )
+
+        if abs(z_right) < abs(r_right) * TOLERANCE:
+            log.warning('Setting z_right to zero within TOLERANCE in MixedPair2D3DtestShell, z_right=%s' % str(z_right))
+            z_right = 0.0
 
-        #assert feq(self.r_right(z_right), r_right), 'inconsistent z_right function \
-                                                    #r_right= %s, r_right(z_right)=%s ' % \
-                                                    #(r_right, self.r_right(z_right))
         return z_right
 
     def r_right(self, z_right):
@@ -2589,6 +2598,7 @@ def r_right(self, z_right):
         a_R = (a_r - self.r0)*self.sqrt_DRDr
 
         # We calculate the maximum space needed for particles A and B based on maximum IV displacement
+        # taking into account the particle radii
         iv_max = max( (D_2D/self.D_tot * a_r + radius2D),
                       (D_3D/self.D_tot * a_r + radius3D))
 
@@ -2596,14 +2606,27 @@ def r_right(self, z_right):
         # the estimated a_R value for the same first passage time
         r_right = a_R + iv_max
 
-        assert feq(self.z_right(r_right), z_right), 'inconsistent r_right function \
-                                                     z_right= %s, z_right(r_right)=%s ' % \
-                                                     (z_right, self.z_right(r_right))
+        ### TESTING
+        log.info('MixedPair2D3DtestShell: z_right= %s, z_right(r_right)=%s, r_right=%s' % (z_right, self.z_right(r_right), r_right) )
+
+        if r_right < 0.0 or z_right <0.0:
+            log.warning('Negative cylinder dimensions in MixedPair2D3DtestShell: z_right= %s, r_right=%s' % (z_right, r_right) )
+
+        assert feq(self.z_right(r_right), z_right), 'Inconsistent r_right function in MixedPair2D3DtestShell: \
+                                                     z_right= %s, z_right(r_right)=%s, r_right=%s' % \
+                                                     (z_right, self.z_right(r_right), r_right)
+
+        if abs(r_right) < abs(z_right) * TOLERANCE:
+            log.warning('Setting r_right to zero within TOLERANCE in MixedPair2D3DtestShell, r_right=%s' % str(r_right))
+            r_right = 0.0
+
         return r_right
 
     def apply_safety(self, r, z_right, z_left):
         SAFETY = 1.1 # FIXME What the hell is that? Why is that not the standard?
-        return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, z_left
+        # Make sure to keep the right scaling ratio when applying SAFETY
+        # because we determine the math. domains for IV and CoM from the shell dimensions
+        return r/SAFETY, self.z_right(r/SAFETY), z_left
 
 
 class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):

From ae00b8e7af94b570cd977c2e441ec0c9e3de7fbc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 16 Nov 2012 14:39:42 +0100
Subject: [PATCH 1265/1541] Fix an erroneous default setting in newBDPropagator

---
 newBDPropagator.hpp | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 2b835198..bc677b8b 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -555,7 +555,8 @@ class newBDPropagator
                     {                        
                         //// 0 - SOME NECESSARY DEFINITONS
                         const position_type                             reactant_pos(pp.second.position());                        
-                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );
+                        const structure_id_type                         reactant_structure_id( pp.second.structure_id() );
+                        const boost::shared_ptr<const structure_type>   reactant_structure( tx_.get_structure( pp.second.structure_id() ) );                        
                         const structure_type_id_type                    reactant_structure_type_id( reactant_structure->sid() );
                         const structure_id_type                         parent_structure_id( reactant_structure->structure_id() );
                         const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure(parent_structure_id) );
@@ -572,32 +573,35 @@ class newBDPropagator
                         // Determine the structures on which the products will end up.
                         // By default we set both product structure to reactant_structure.
                         const boost::shared_ptr<const structure_type> product0_structure(reactant_structure);
-                        const boost::shared_ptr<const structure_type> product1_structure(reactant_structure);
+                        boost::shared_ptr<const structure_type>       product1_structure(reactant_structure);
+                        // Also for the structure IDs
+                        structure_id_type product0_structure_id( reactant_structure_id );
+                        structure_id_type product1_structure_id( reactant_structure_id );
                         // Now check whether one of the products actually leaves reactant_structure according to the reaction rules.
                         species_type product0_species(tx_.get_species(products[0]));
-                        species_type product1_species(tx_.get_species(products[1]));                        
+                        species_type product1_species(tx_.get_species(products[1]));
 
                         LOG_DEBUG(("Attempting single reaction with two products." ));
                         
                         // If the products live on different structures, one must be the parent of the other or the default structure.
                         // In this case we have to bring the products into the right order.
                         // We set: species 0 lives on the current structure; species 1 lives in the product structure (if applicable).
-                        // Compare the structure type IDs of the product species to determine where products will end up:                                                                                                                                                                    
-
-                        // Initialize: by default the dissociating particle goes into the bulk
-                        structure_id_type product1_structure_id( tx_.get_def_structure_id() );
+                        // Compare the structure type IDs of the product species to determine where products will end up:                                                                                                                                                                                            
                         
+                        // If product structure types are different
                         if( product0_species.structure_type_id() != product1_species.structure_type_id() )
-                        {                          
+                        {                        
                             // First check whether the reaction rule defines a legal dissociation reaction
+                            // One of the products must stay in the reactant structure
                             if( !( product0_species.structure_type_id() == reactant_structure_type_id ||
                                    product1_species.structure_type_id() == reactant_structure_type_id    )
                               )
                                 throw not_implemented("Invalid product structure for first product in single reaction: One particle must stay behind on structure of origin!");
-                                
+
+                            // One of the products must go into the parent or default structure
                             if( !( product0_species.structure_type_id() == parent_structure_type_id  ||
-                                   product0_species.structure_type_id() == default_structure_type_id || 
-                                   product1_species.structure_type_id() == parent_structure_type_id  ||                                  
+                                   product0_species.structure_type_id() == default_structure_type_id ||
+                                   product1_species.structure_type_id() == parent_structure_type_id  ||                                 
                                    product1_species.structure_type_id() == default_structure_type_id    )
                               )
                                 throw not_implemented("Invalid product structure for second product in single reaction: Must be either parent or default structure!");
@@ -608,11 +612,11 @@ class newBDPropagator
                             
                             // Determine where the dissociating particle (product1) goes
                             if( product1_species.structure_type_id() == default_structure_type_id )
-                                ; // the dissociating product lives in the bulk; do nothing, set correctly already above
+                                product1_structure_id = default_structure_id;
                             
                             else if( product1_species.structure_type_id() == parent_structure_type_id )
                                 // the product lives on the parent structure 
-                                product1_structure_id =  parent_structure_id;
+                                product1_structure_id = parent_structure_id;
                             
                             else
                               
@@ -620,7 +624,7 @@ class newBDPropagator
                                                         
                             // If no exception was thrown, everything should be OK now.
                             // Change the default setting for product1
-                            const boost::shared_ptr<const structure_type> product1_structure( tx_.get_structure(product1_structure_id) );
+                            product1_structure = tx_.get_structure(product1_structure_id);
                         }
                         // TODO Can we not outsource this part to the structure functions, too?
 
@@ -668,6 +672,8 @@ class newBDPropagator
                             
                             LOG_DEBUG(("  New positions: pos0=%s, pos1=%s", boost::lexical_cast<std::string>(pos0pos1_pair.first.first).c_str(),
                                                            boost::lexical_cast<std::string>(pos0pos1_pair.second.first).c_str() ));
+                            LOG_DEBUG(("  New structure IDs: id0=%s, id1=%s", boost::lexical_cast<std::string>(pos0pos1_pair.first.second).c_str(),
+                                                           boost::lexical_cast<std::string>(pos0pos1_pair.second.second).c_str() ));
 
 
                             //// 1b - CHECK FOR OVERLAPS

From 97dd6b4cb0f00ee470b055eb307d1e0cfd75024a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 16 Nov 2012 14:40:31 +0100
Subject: [PATCH 1266/1541] Some more log info

---
 shells.py | 51 ++++++++++++++++++++++++++++++++-------------------
 1 file changed, 32 insertions(+), 19 deletions(-)

diff --git a/shells.py b/shells.py
index 8be9996a..cd19d33e 100755
--- a/shells.py
+++ b/shells.py
@@ -2426,30 +2426,23 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         # The initialization of r0 can fail in testPair.__init__
 
-#        raise testShellError('(MixedPair2D3D).')
-
         try:
             testMixedPair2D3D.__init__(self, single2D, single3D)
         except protoDomainError as e:
             raise testShellError('(MixedPair2D3D). %s' %
                                  (str(e)))
 
-        # initialize commonly used constants
+        # Initialize commonly used constants
         self.sqrt_DRDr = math.sqrt((2*self.D_R)/(3*self.D_r))
 
-        # initialize the scaling parameters        
-        minimum = self.r0 + self.particle2D.radius
-        self.drdz_right = self.r_right(minimum + 1.0) - self.r_right(minimum)
-        self.dzdr_right = 1.0/self.drdz_right
-
-        #bla = self.get_scaling_factor() * ( self.sqrt_DRDr + max( self.particle2D.D/self.D_tot,
-                                                                  #self.particle3D.D/self.D_tot ))
-        #assert feq(bla, self.drdz_right), 'bla= %s, drdz_right=%s' % (bla, self.drdz_right)
-        #bla2 = self.z_right(minimum + 1.0) - self.z_right(minimum)
-
-        minr, minz_right, _ = self.get_min_dr_dzright_dzleft()
-
-        #assert feq(self.dzdr_right, bla2), 'bla2= %s, dzdr_right= %s' % (bla2, self.dzdr_right)
+        # Initialize the scaling parameters
+        # To determine the scale angle we calculate the radius r corresponding to the minimal z_right
+        # of the cylinder in a way that the first passage time of the CoM (towards r) and of the
+        # interparticle vector (towards z_right) are equal (see self.r_right(), self.z_right() below).
+        self.iv_z_minimum = self.r0 + self.particle3D.radius * SINGLE_SHELL_FACTOR
+            # this is an upper bound, actually the height of the domain could be slightly lower than this
+        self.drdz_right = self.r_right(self.iv_z_minimum) / self.iv_z_minimum
+        self.dzdr_right = 1.0/self.drdz_right        
 
         self.r0_right   = 0.0
         self.z0_right   = self.z_right(self.r0_right)
@@ -2458,6 +2451,16 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.particle2D.radius
 
+        log.info(' MixedPair2D3D: Initalized shellscaling: scale_angle = %s, drdz  = %s' % (self.right_scalingangle, self.drdz_right))
+        log.info('                                         r0_right = %s, z0_right = %s' % (self.r0_right, self.z0_right))
+        log.info('                                         r0_left  = %s, z0_left  = %s' % (self.r0_left,  self.z0_left))
+
+        log.info('      min_dr_dzright_dzleft = %s' % str(self.get_min_dr_dzright_dzleft() ))
+        log.info('      max_dr_dzright_dzleft = %s' % str(self.get_max_dr_dzright_dzleft() ))
+
+        # TODO This is probably not needed any more:
+        min_r, min_dz_right, _ = self.get_min_dr_dzright_dzleft()
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2493,8 +2496,7 @@ def get_min_dr_dzright_dzleft(self):
 
 
         ### calculate the minimal height z_right1 of the shell including burst radius
-        iv_z = self.r0      # approximation, actually the height of the domain can be slightly lower.
-        dz_right1 = iv_z + radius3D * SINGLE_SHELL_FACTOR
+        dz_right1 = self.iv_z_minimum
         # with the accompanying radius r1
         dr_1 = self.r_right(dz_right1)
 
@@ -2521,7 +2523,6 @@ def get_min_dr_dzright_dzleft(self):
         dz_right = dz_right1
 
         dz_left  = self.particle2D.radius
-#        print "min= ", dr, dz_right, dz_left
 
         return dr, dz_right, dz_left
         
@@ -2546,6 +2547,12 @@ def get_max_dr_dzright_dzleft(self):
     def z_right(self, r_right):
         # This calculates the height z_right of the newly constructed domain
         # (above the plane) if the radius r is known
+
+        # The trivial case
+        if r_right == 0.0:
+            return 0.0
+
+        # Some constants that we need
         radius2D = self.particle2D.radius
         radius3D = self.particle3D.radius
         D_2D = self.particle2D.D
@@ -2581,6 +2588,12 @@ def z_right(self, r_right):
     def r_right(self, z_right):
         # This calculates the radius r of the newly constructed domain
         # if the height z_right is known
+
+        # The trivial case
+        if z_right == 0.0:
+            return 0.0
+
+        # Some constants that we need
         radius2D = self.particle2D.radius
         radius3D = self.particle3D.radius
         D_2D = self.particle2D.D

From add1f47e28f6a155127eecb9f08d95ee94308f30 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 11:20:14 +0100
Subject: [PATCH 1267/1541] Two small fixes that caused zero-division errors

---
 egfrd.py    | 11 +++++++++--
 gfrdbase.py | 42 ++++++++++++++++++++++++++----------------
 2 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 707e0291..eeb4416f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2685,6 +2685,13 @@ def print_report(self, out=None):
         multi_steps = self.multi_steps[3] # total multi steps
         total_steps = single_steps + interaction_steps + pair_steps + multi_steps
 
+        if multi_steps:
+            avg_multi_time = 1.0 * self.multi_time / multi_steps
+            avg_multi_rl   = 1.0 * self.multi_rl   / multi_steps
+        else:
+            avg_multi_time = None
+            avg_multi_rl   = None
+
         report = '''
 t = %g
 \tNonmulti: %g\tMulti: %g
@@ -2725,8 +2732,8 @@ def print_report(self, out=None):
                self.multi_steps[EventType.MULTI_BIMOLECULAR_REACTION],
                self.multi_steps[EventType.MULTI_UNIMOLECULAR_REACTION],
                self.multi_steps[EventType.BURST],
-               1.0 * self.multi_time / multi_steps,
-               1.0 * self.multi_rl   / multi_steps,
+               avg_multi_time,
+               avg_multi_rl,
                self.reaction_events,
                self.rejected_moves
                )
diff --git a/gfrdbase.py b/gfrdbase.py
index 2273ff5a..3db2bea5 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -364,9 +364,13 @@ def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
     """
     species = world.get_species(sid)
     structure_type = world.get_structure_type(species.structure_type_id)
-    structure_list = list(world.get_structure_ids(structure_type))
+    structure_list = list(world.get_structure_ids(structure_type))    
 
     ws = world.world_size
+
+    if species.radius >= 0.05 * ws:
+        log.warn('Particle radius >= 0.05*world_size - this may break simulation efficiency!')
+
     # For comparison purposes:
     bound_1 = numpy.array(bound_1)
     bound_2 = numpy.array(bound_2)
@@ -448,6 +452,9 @@ def place_particle(world, sid, position):
     species = world.get_species(sid)
     radius = species.radius
 
+    if radius >= 0.05 * world.world_size:
+        log.warn('Particle radius >= 0.05*world_size - this may break simulation efficiency!')
+
     # FIXME This is a mess!!
 
     # check that particle doesn't overlap with other particles.
@@ -494,21 +501,24 @@ def place_particle(world, sid, position):
     # added to the world, or added to a self-defined box.
     if species.structure_type_id == world.get_def_structure_type_id():
         
-        structure_id = world.get_def_structure_id()        
-        surface, distance = surfaces[0]  # the closest surface
-        overlaps = world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
-                                                position, structure_id, radius)
-
-        # Raise an error in case of overlap with a surface other than PlanarSurface
-        # (the latter we allow to overlap with bulk particles)
-        if overlaps and not isinstance(surface, PlanarSurface):
-            raise RuntimeError('  Placing particle failed: %s %s. '
-                               '  Too close to surface: %s.' %
-                                  (sid, position, surface) )
-
-        if overlaps and isinstance(surface, PlanarSurface):
-            log.warning('  Particle of species %s placed at position %s overlaps with surface %s.' % \
-                           (sid, position, surface) )
+        structure_id = world.get_def_structure_id()
+
+        if surfaces:
+
+            surface, distance = surfaces[0]  # the closest surface
+            overlaps = world.check_surface_overlap((position, radius*MINIMAL_SEPARATION_FACTOR),
+                                                    position, structure_id, radius)
+
+            # Raise an error in case of overlap with a surface other than PlanarSurface
+            # (the latter we allow to overlap with bulk particles)
+            if overlaps and not isinstance(surface, PlanarSurface):
+                raise RuntimeError('  Placing particle failed: %s %s. '
+                                  '  Too close to surface: %s.' %
+                                      (sid, position, surface) )
+
+            if overlaps and isinstance(surface, PlanarSurface):
+                log.warning('  Particle of species %s placed at position %s overlaps with surface %s.' % \
+                              (sid, position, surface) )
     else:
         # If the particle lives on a surface then the position should be in the closest surface.
         # The closest surface should also be of the structure_type associated with the species.        

From 834f02ce989a5621df97c949aecc4d5dd2bf475f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 13:58:51 +0100
Subject: [PATCH 1268/1541] Fix a problem with calculation of reference_vector
 when constructing PlanarSurfaceInteraction testShell

---
 shells.py | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index cd19d33e..a23eac04 100755
--- a/shells.py
+++ b/shells.py
@@ -194,7 +194,21 @@ def __init__(self, single, origin_structure, target_structure):
 
         # The reference_vector is the normalized vector from the reference_point to the particle
         if any(pos_transposed != self.reference_point) :
-            self.reference_vector = normalize(pos_transposed - self.reference_point)
+            diff_vector = pos_transposed - self.reference_point
+
+            # Compare to the largest component of the difference vector
+            # If a component is TOLERANCE times smaller, regard it as zero
+            # This is to avoid calculation errors when the distance to the
+            # surface is very small
+            max_component = max(diff_vector, key = lambda x : abs(x))
+            for c in range(0,3):
+                if abs(diff_vector[c]) <= TOLERANCE * abs(max_component):                    
+                    diff_vector[c] = 0.0
+                    log.debug('Setting diff-vector component %s to zero.' % str(c))   ### TESTING
+
+            self.reference_vector = normalize(diff_vector)
+            log.debug('setting reference_vector = %s, pos=%s, pos_transposed=%s, reference_point=%s, pos_transposed-reference_point=%s' \
+                      % (self.reference_vector, self.pid_particle_pair[1].position, pos_transposed, self.reference_point, pos_transposed-self.reference_point) )   ### TESTING
         else:
             self.reference_vector = 0
             raise testShellError('(testInteractionSingle). reference vector = 0.')
@@ -1451,6 +1465,7 @@ def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
 
     # determine what parameter of the cylinder (dr of dz) to scale.
     relative_orientation = numpy.dot(orientation_vector, shape.unit_z)
+    log.debug('relative_orientation = %s, orientation_vector = %s, shape.unit_z = %s' % (relative_orientation, orientation_vector, shape.unit_z) )   ### TESTING
     if feq(relative_orientation, 0):
 
         distance = testShell.world.distance(shape, reference_point)

From e9d332c6b05cf4e5ecec46ffb3f6ac059a8e8519 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 15:05:02 +0100
Subject: [PATCH 1269/1541] Increase tolerance for vector component comparison

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index a23eac04..19c2207b 100755
--- a/shells.py
+++ b/shells.py
@@ -202,7 +202,7 @@ def __init__(self, single, origin_structure, target_structure):
             # surface is very small
             max_component = max(diff_vector, key = lambda x : abs(x))
             for c in range(0,3):
-                if abs(diff_vector[c]) <= TOLERANCE * abs(max_component):                    
+                if abs(diff_vector[c]) <= 1.0e-6 * abs(max_component):  # FIXME using TOLERANCE does not always work here
                     diff_vector[c] = 0.0
                     log.debug('Setting diff-vector component %s to zero.' % str(c))   ### TESTING
 

From 4d3ad8685f7eb05e083a519e3249daac6e750829 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 15:08:43 +0100
Subject: [PATCH 1270/1541] Cleanup

---
 shells.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/shells.py b/shells.py
index 19c2207b..4c6f422f 100755
--- a/shells.py
+++ b/shells.py
@@ -199,16 +199,14 @@ def __init__(self, single, origin_structure, target_structure):
             # Compare to the largest component of the difference vector
             # If a component is TOLERANCE times smaller, regard it as zero
             # This is to avoid calculation errors when the distance to the
-            # surface is very small
+            # surface is very small / has very small nonzero components
             max_component = max(diff_vector, key = lambda x : abs(x))
             for c in range(0,3):
-                if abs(diff_vector[c]) <= 1.0e-6 * abs(max_component):  # FIXME using TOLERANCE does not always work here
+                if abs(diff_vector[c]) <= 1.0e-6 * abs(max_component):  # FIXME using TOLERANCE does not always work here                    
+                    log.warning('Setting component %s of difference vector %s to zero.' % (c, diff_vector))
                     diff_vector[c] = 0.0
-                    log.debug('Setting diff-vector component %s to zero.' % str(c))   ### TESTING
 
             self.reference_vector = normalize(diff_vector)
-            log.debug('setting reference_vector = %s, pos=%s, pos_transposed=%s, reference_point=%s, pos_transposed-reference_point=%s' \
-                      % (self.reference_vector, self.pid_particle_pair[1].position, pos_transposed, self.reference_point, pos_transposed-self.reference_point) )   ### TESTING
         else:
             self.reference_vector = 0
             raise testShellError('(testInteractionSingle). reference vector = 0.')
@@ -1465,7 +1463,7 @@ def get_dr_dzright_dzleft_to_PlanarShape(shape, testShell, r, z_right, z_left):
 
     # determine what parameter of the cylinder (dr of dz) to scale.
     relative_orientation = numpy.dot(orientation_vector, shape.unit_z)
-    log.debug('relative_orientation = %s, orientation_vector = %s, shape.unit_z = %s' % (relative_orientation, orientation_vector, shape.unit_z) )   ### TESTING
+
     if feq(relative_orientation, 0):
 
         distance = testShell.world.distance(shape, reference_point)

From 01a36a6f9e42c5850c06496d417f7ae2b575d0c6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 20 Nov 2012 19:06:25 +0100
Subject: [PATCH 1271/1541] Small fix in statistics output

---
 egfrd.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index eeb4416f..fd42aac3 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2689,8 +2689,8 @@ def print_report(self, out=None):
             avg_multi_time = 1.0 * self.multi_time / multi_steps
             avg_multi_rl   = 1.0 * self.multi_rl   / multi_steps
         else:
-            avg_multi_time = None
-            avg_multi_rl   = None
+            avg_multi_time = 0.0
+            avg_multi_rl   = 0.0
 
         report = '''
 t = %g

From bf728fa3c252542909f42a92c040583da2ad3787 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 21 Nov 2012 11:52:18 +0100
Subject: [PATCH 1272/1541] Base cylindrical domain radius only on particle
 radii, not on surface radii

---
 shells.py | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/shells.py b/shells.py
index 4c6f422f..a2eac3c1 100755
--- a/shells.py
+++ b/shells.py
@@ -2082,7 +2082,7 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         #       - dz_left stays constant and is equal to the cap-bound particle radius
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
-        self.dr_const   = max(self.pid_particle_pair[1].radius*CYLINDER_R_FACTOR, self.structure.shape.radius)
+        self.dr_const   = self.pid_particle_pair[1].radius*CYLINDER_R_FACTOR
 
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
@@ -2316,8 +2316,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         #       - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
-        self.dr_const   = max([self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR, \
-                               self.origin_structure.shape.radius, self.target_structure.shape.radius])
+        self.dr_const   = self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR
 
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
@@ -2674,8 +2673,7 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
         CRF             = CYLINDER_R_FACTOR
-        self.dr_const   = max([CRF * self.cap_particle.radius, CRF * self.particle1D.radius,\
-                               self.cap_structure.shape.radius, self.structure1D.shape.radius])
+        self.dr_const   = max([CRF * self.cap_particle.radius, CRF * self.particle1D.radius])
 
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0

From 778ede91652408aaee1295d9aa0f5fcd8c4ed750 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 23 Nov 2012 11:31:41 +0100
Subject: [PATCH 1273/1541] Some debugging output

---
 egfrd.py | 32 +++++++++++++++++++++++++-------
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fd42aac3..ace8325d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -761,6 +761,7 @@ def burst_domain(self, domain, ignore):
     # - list of zero_singles that was the result of the bursting
     # - updated ignore list
 
+        log.debug('  Bursting domain %s, ignore=%s' % (domain, ignore)) ### TESTING
         domain_id = domain.domain_id
 
         if __debug__:
@@ -1568,23 +1569,33 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
 
         # Note that the reactant_structure_id is the id of the structure on which the particle was located at the time of the move.
 
-        if __debug__:
+        if __debug__:            
             assert isinstance(single, Single)
 
         # 0. get reactant info
         reactant = single.pid_particle_pair
+        log.debug('  Enter fire_move for %s' % str(single))   ### TESTING            
+        log.debug('  reactant_pos=%s, reactant_radius=%s' % (reactant_pos, reactant[1].radius))   ### TESTING
         # 1. No product->no info
         # 1.5 No additional positional/structure change is needed
         # 2. Position is in protective shell
 
         # 3. check that there is space for the reactants
         if ignore_p:
-            if self.world.check_overlap((reactant_pos, reactant[1].radius),
-                                        reactant[0], ignore_p[0]):
+            co = self.world.check_overlap((reactant_pos, reactant[1].radius),
+                                        reactant[0], ignore_p[0])
+            log.debug('co = %s, list(co) = %s' % (co, list(co)) )
+            for pp, d in co:
+              log.debug('  check_overlap = (%s, %s), ignore_p = %s' % (pp, d, ignore_p[0]) )   ### TESTING
+            if co:
                 raise RuntimeError('fire_move: particle overlap failed.')
         else:
-            if self.world.check_overlap((reactant_pos, reactant[1].radius),
-                                        reactant[0]):
+            co = self.world.check_overlap((reactant_pos, reactant[1].radius),
+                                        reactant[0])
+            log.debug('co = %s, list(co) = %s' % (co, list(co)) )
+            for pp, d in co:
+                log.debug('  check_overlap = (%s, %s)' % (pp, d) )   ### TESTING
+            if co:
                 raise RuntimeError('fire_move: particle overlap failed.')
 
         # 4. process the changes (move particles, change structure)
@@ -1904,18 +1915,20 @@ def process_single_event(self, single, ignore):
             # in case of an interaction domain: determine real event before doing anything
             if single.event_type == EventType.IV_EVENT:
                 single.event_type = single.draw_iv_event_type()
-
-
+            
             # get the (new) position and structure on which the particle is located.
             if single.getD() != 0 and single.dt > 0.0:
                 # If the particle had the possibility to diffuse
                 newpos, struct_id = single.draw_new_position(single.dt, single.event_type)
+                log.debug('  draw: newpos, struct_id = (%s, %s)' % (newpos, struct_id))   ### TESTING
                 newpos, struct_id = self.world.apply_boundary((newpos,struct_id))
+                log.debug('  after apply_boundary: newpos, struct_id = (%s, %s)' % (newpos, struct_id))   ### TESTING
             else:
                 # no change in position has taken place
                 newpos    = pid_particle_pair[1].position
                 struct_id = pid_particle_pair[1].structure_id
             # TODO? Check if the new positions are within domain
+            log.debug('  final: newpos, struct_id = (%s, %s)' % (newpos, struct_id))   ### TESTING
 
             # newpos now hold the new position of the particle (not yet committed to the world)
             # if we would here move the particles and make new shells, then it would be similar to a propagate
@@ -1940,6 +1953,7 @@ def process_single_event(self, single, ignore):
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, struct_id, ignore)
 
             else:
+                log.debug('  Calling fire_move with single=%s, newpos=%s, struct_id=%s' % (single, newpos, struct_id) )   ### TESTING
                 particles = self.fire_move(single, newpos, struct_id)
                 zero_singles_b = []   # no bursting takes place, ignore list remains unchanged
                 # Update statistics
@@ -2054,9 +2068,12 @@ def process_pair_event(self, pair, ignore):
 
         ### 3.1 Get new position and current structures of particles
         if pair.dt > 0.0:
+            
             newpos1, newpos2, struct1_id, struct2_id = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
+            log.debug('  draw: newpos1, newpos2, sid1, sid2 = (%s, %s, %s, %s)' % (newpos1, newpos2, struct1_id, struct2_id))   ### TESTING
             newpos1, struct1_id = self.world.apply_boundary((newpos1, struct1_id))
             newpos2, struct2_id = self.world.apply_boundary((newpos2, struct2_id))
+            log.debug('  after apply_boundary: newpos1, newpos2, sid1, sid2 = (%s, %s, %s, %s)' % (newpos1, newpos2, struct1_id, struct2_id))   ### TESTING
 
             # check that the particles do not overlap with any other particles in the world
             assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
@@ -2204,6 +2221,7 @@ def process_pair_event(self, pair, ignore):
 
         ### 6. Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
         for zero_single in zero_singles:
+            log.debug('  Starting recursive burst for zero_single %s' % str(zero_single))   ### TESTING
             more_zero_singles, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
                                                               zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
                                                               ignore)

From 180b698fc8341f0049791b5a97e068764f734ad0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 27 Nov 2012 20:06:32 +0100
Subject: [PATCH 1274/1541] More info output and useful comments

---
 StructureContainer.hpp | 54 +++++++++++++++++++++---------------------
 gfrdbase.py            |  8 +++++++
 pair.py                |  6 +++++
 3 files changed, 41 insertions(+), 27 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 007a5638..81fae03e 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -396,8 +396,8 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
     // and that the position is already transposed for the plane.
-    const plane_type origin_plane (planar_surface.shape());
-    boost::array<length_type, 2> half_extends(origin_plane.half_extent());
+    const plane_type origin_plane( planar_surface.shape() );
+    boost::array<length_type, 2> half_extents( origin_plane.half_extent() );
 
     const position_type pos_vector( subtract(pos_structure_id.first, origin_plane.position()) );
     const length_type component_x ( dot_product(pos_vector, origin_plane.unit_x()) );
@@ -408,7 +408,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     position_type neighbor_plane_par;
     position_type neighbor_plane_inl;
 
-    if ( abs(component_x) <= half_extends[0] && abs(component_y) <= half_extends[1] )
+    if ( abs(component_x) <= half_extents[0] && abs(component_y) <= half_extents[1] )
     {
         // we are still in the plane (did not pass any of the boundaries)
         // don't have to do anything
@@ -417,10 +417,10 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     else
     {
         // We are outside of the plane.
-        if ( half_extends[1]*abs(component_x) < half_extends[0]*abs(component_y) )
+        if ( half_extents[1]*abs(component_x) < half_extents[0]*abs(component_y) )
         {
             // Top or bottom (and may also be in one of the corners)
-            if ( half_extends[1] < component_y )
+            if ( half_extents[1] < component_y )
             {
                 // we are at the 'top' of the plane (side nr. 0)
                 // the 'vector' is the unit vector pointing from the edge between the two planes to the center of the plane
@@ -428,48 +428,48 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
 
                 new_id = neighbor_id_vector.first;
                 neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     half_extends[1]),
-                                         multiply(neighbor_id_vector.second, (component_y - half_extends[1]) ) );
+                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     half_extents[1]),
+                                         multiply(neighbor_id_vector.second, (component_y - half_extents[1]) ) );
             }
-            else if ( component_y < -half_extends[1] )
+            else if ( component_y < -half_extents[1] )
             {
                 // we are at the 'bottom' of the plane (side nr. 1)
                 const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 1));
 
                 new_id = neighbor_id_vector.first;
                 neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     -half_extends[1] ),
-                                         multiply(neighbor_id_vector.second, (-component_y - half_extends[1]) ) );
+                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     -half_extents[1] ),
+                                         multiply(neighbor_id_vector.second, (-component_y - half_extents[1]) ) );
             }
         }
-        else // half_extends[1]*abs(component_x) >= half_extends[0]*abs(component_y)
+        else // half_extents[1]*abs(component_x) >= half_extents[0]*abs(component_y)
         {
-            if ( component_x < -half_extends[0] )
+            if ( component_x < -half_extents[0] )
             {
                 // we are at the 'left' of the plane (side nr. 2)
                 const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 2));
 
                 new_id = neighbor_id_vector.first;
                 neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     -half_extends[0]),
-                                         multiply(neighbor_id_vector.second, (-component_x - half_extends[0]) ) );
+                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     -half_extents[0]),
+                                         multiply(neighbor_id_vector.second, (-component_x - half_extents[0]) ) );
             }
-            else if ( half_extends[0] < component_x )
+            else if ( half_extents[0] < component_x )
             {
                 // we are at the 'right' of the plane (side nr. 3)
                 const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 3));
 
                 new_id = neighbor_id_vector.first;
                 neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     half_extends[0]),
-                                         multiply(neighbor_id_vector.second, (component_x - half_extends[0]) ) );
+                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     half_extents[0]),
+                                         multiply(neighbor_id_vector.second, (component_x - half_extents[0]) ) );
             }
         }
 
         const position_type new_pos ( add(origin_plane.position(), add(neighbor_plane_par, neighbor_plane_inl)));
 
         // Check if we are in one of the corners. If yes -> do another round of border crossing from neighboring plane.
-        if ( abs(component_x) > half_extends[0] && abs(component_y) > half_extends[1] )
+        if ( abs(component_x) > half_extents[0] && abs(component_y) > half_extents[1] )
         {
             return sc.get_structure(new_id)->apply_boundary(std::make_pair(new_pos, new_id), sc);
         }
@@ -516,51 +516,51 @@ cyclic_transpose (std::pair<typename Ttraits_::position_type, typename Ttraits_:
     // TODO use iterator so that we can check whether match was found or that we escaped by reaching the end of the list.
 
     const plane_type plane (planar_surface.shape());
-    boost::array<length_type, 2> half_extends(plane.half_extent());
+    boost::array<length_type, 2> half_extents(plane.half_extent());
     switch ( side_nr )
     {
         case 0:     // top side
         {
             const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
                                                                           multiply(plane.unit_y(),
-                                                                                   half_extends[1]) ) ));
+                                                                                   half_extents[1]) ) ));
             const length_type plane_par (dot_product(pos, plane.unit_x()));     // TODO replace by subtraction?
             const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
             new_pos_par = multiply(plane.unit_x(), plane_par);
-            new_pos_inl = multiply(plane.unit_y(), half_extends[1] + plane_inl);
+            new_pos_inl = multiply(plane.unit_y(), half_extents[1] + plane_inl);
             break;
         }
         case 1:     // botom
         {
             const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
                                                                           multiply(plane.unit_y(),
-                                                                                   -half_extends[1]) ) ));
+                                                                                   -half_extents[1]) ) ));
             const length_type plane_par (dot_product(pos, plane.unit_x()));     // TODO replace by subtraction?
             const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
             new_pos_par = multiply(plane.unit_x(), plane_par);
-            new_pos_inl = multiply(plane.unit_y(), -(half_extends[1] + plane_inl) );
+            new_pos_inl = multiply(plane.unit_y(), -(half_extents[1] + plane_inl) );
             break;
         }
         case 2:     // left
         {
             const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
                                                                           multiply(plane.unit_x(),
-                                                                                   -half_extends[0]) ) ));
+                                                                                   -half_extents[0]) ) ));
             const length_type plane_par (dot_product(pos, plane.unit_y()));     // TODO replace by subtraction?
             const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
             new_pos_par = multiply(plane.unit_y(), plane_par);
-            new_pos_inl = multiply(plane.unit_x(), -(half_extends[0] + plane_inl) );
+            new_pos_inl = multiply(plane.unit_x(), -(half_extents[0] + plane_inl) );
             break;
         }
         case 3:     // right
         {
             const position_type pos (subtract(pos_structure_id.first, add(plane.position(),
                                                                           multiply(plane.unit_x(),
-                                                                                   half_extends[0]) ) ));
+                                                                                   half_extents[0]) ) ));
             const length_type plane_par (dot_product(pos, plane.unit_y()));     // TODO replace by subtraction?
             const length_type plane_inl (dot_product(pos, neighbor_id_vector.second));
             new_pos_par = multiply(plane.unit_y(), plane_par);
-            new_pos_inl = multiply(plane.unit_x(), half_extends[0] + plane_inl );
+            new_pos_inl = multiply(plane.unit_x(), half_extents[0] + plane_inl );
             break;
         }
     }
diff --git a/gfrdbase.py b/gfrdbase.py
index 3db2bea5..eb833c5c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -242,6 +242,14 @@ def create_box(world, structure_type, center, size, one_sided=True):
 
     # Update the connectivity container
     # This has to follow the plane side convention strictly!
+    # The convention is:
+    #
+    # - neighbor 0 is the one in positive unit_y direction ("top neighbor")
+    # - neighbor 1 is the one in negative unit_y direction ("bottom neighbor")
+    # - neighbor 2 is the one in negative unit_x direction ("left neighbor")
+    # - neighbor 3 is the one in positive unit_x direction ("right neighbor")
+    #
+    # See StructureContainer.hpp for more details.
     world.connect_structures( front, 3, top, 2)
     world.connect_structures( front, 2, bottom, 1)
     world.connect_structures( front, 1, left, 2)
diff --git a/pair.py b/pair.py
index 152df954..6911c1c9 100644
--- a/pair.py
+++ b/pair.py
@@ -676,9 +676,15 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # In some cases the new positions may end up on adjacent planar surfaces.
         # This may lead to an overlap which has to be checked for and removed if present
         # in the next step.
+        log.debug('    do_back_transform: Sampling new positions:')   ### TESTING
         new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
         new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
 
+        log.debug('    pos_and_sid1 = (%s, %s), pos_and_sid2 = (%s, %s)' \
+                                        % (pos1, structure1.id, pos2, structure1.id) )   ### TESTING
+        log.debug('    new_pos_and_sid1 = (%s, %s), new_pos_and_sid2 = (%s, %s) (after apply_boundary)' \
+                                        % (new_pos1, new_sid1, new_pos2, new_sid2) )   ### TESTING
+
         # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
         if world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR :
 

From c21d277bae6fe99d7a11d7aa77af6e5ce22b1966 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 27 Nov 2012 20:07:06 +0100
Subject: [PATCH 1275/1541] Apply structure->apply_boundary without previous
 cyclic_transpose

Because otherwise we transform to a non-adjacent plane when a position
gets so far out of the origin plane that it crosses the system boundary
and will be transposed.
---
 ParticleContainerBase.hpp | 33 +++++++++++++++++++++------------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 3b0cd865..50b06c19 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -187,27 +187,36 @@ class ParticleContainerBase
         return traits_type::apply_boundary(v, world_size());
     }
 
-    // apply_boundary that takes the structure on which the particle lives into account
+    // Version of apply_boundary that takes the structure on which the particle lives into account  
     // This also applies the 'local' boundary conditions of the individual structures (reflecting, periodic, moving
     // onto another adjacent structure etc).
-
+    //
     // To call the right function for a particular Surface we:
-    // -first need to call the 'apply_boundary method of the structure in question with the StructureContainer as an argument (to get
-    //  the StructureContainer that we need to use ->structures don't know about the container they're in!)
-    // -second call the apply_boundary method of the structure_container using the structure (which is now of a fully speciefied type!!!)
-    //  as an argument (see for example PlanarSurface.hpp, NOT surface.hpp)
-    // -Use this fully defined type to call the right function through the template method 'apply_boundary' of the StructureContainer.
-    //  (See StructureContainer.hpp)
+    //
+    // - first need to call the 'apply_boundary method of the structure in question with the StructureContainer as an argument (to get
+    //   the StructureContainer that we need to use ->structures don't know about the container they're in!)
+    //
+    // - second call the apply_boundary method of the structure_container using the structure (which is now of a fully specified type!!!)
+    //   as an argument (for example see PlanarSurface.hpp, NOT Surface.hpp)
+    //
+    // - Use this fully defined type to call the right function through the template method 'apply_boundary' of the StructureContainer.
+    //   (See StructureContainer.hpp)
     virtual position_structid_pair_type apply_boundary(position_structid_pair_type const& pos_struct_id) const
     {
-        // cyclic transpose the position with the structure
-        const boost::shared_ptr<const structure_type> structure (get_structure(pos_struct_id.second));
-        const position_structid_pair_type cyc_pos_struct_id (std::make_pair(cyclic_transpose(pos_struct_id.first, structure->position()),
-                                                                            pos_struct_id.second));
+//         // cyclic transpose the position with the structure
+//         const boost::shared_ptr<const structure_type> structure (get_structure(pos_struct_id.second));
+//         const position_structid_pair_type cyc_pos_struct_id (std::make_pair(cyclic_transpose(pos_struct_id.first, structure->position()),
+//                                                                             pos_struct_id.second));
 
+        // TESTING: cyclic transpose should not be applied when going around an edge!
+        // TODO Clean this up when it is clear that cyclic_transpose is unnecessary here.
+        const position_structid_pair_type cyc_pos_struct_id( pos_struct_id );
+        // Get the structure
+        const boost::shared_ptr<const structure_type> structure (get_structure(pos_struct_id.second));
         // The generalized boundary condition application first:
         // 1. applies the boundary of the structure/surface (go around the corner etc)
         const position_structid_pair_type new_pos_struct_id(structure->apply_boundary(cyc_pos_struct_id, structures_));
+        
         // 2. Then also apply the boundary condition of the world
         return std::make_pair(apply_boundary(new_pos_struct_id.first), new_pos_struct_id.second);
     }

From 903c3cc928116373f912476a25f82afd6c3d47fa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 18:05:03 +0100
Subject: [PATCH 1276/1541] Calculate tan(scale_angle) only in the beginning

Because math.tan is actually a very expensive function!
---
 shells.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index a2eac3c1..73340bf1 100755
--- a/shells.py
+++ b/shells.py
@@ -684,6 +684,9 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     scale_center_to_shell_r = ref_to_shell_r - scale_center_r
     scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
+    # Get tangent of the scale_angle
+    tan_scale_angle = math.tan(scale_angle)
+
     # calculate the angle 'shell_angle' of the vector from the 'scale_center' to the shell with the vector
     # from the 'reference_point' to the 'scale_center' (which is +- the orientation_vector).
     shell_angle = math.atan(scale_center_to_shell_r/scale_center_to_shell_z)
@@ -709,7 +712,7 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
             scale_center_to_shell_z_thres = 0
         else:
             # scale_angle == 0 should not get here
-            scale_center_to_shell_z_thres = abs(scale_center_to_shell_r)/math.tan(scale_angle)
+            scale_center_to_shell_z_thres = abs(scale_center_to_shell_r)/tan_scale_angle
 
         shell_radius_thres = scale_center_to_shell_z - scale_center_to_shell_z_thres
         if shell_radius < shell_radius_thres:
@@ -719,7 +722,7 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
 
     elif scale_angle <= shell_angle and shell_angle < Pi/2.0:
     # The (spherical) shell can touch the cylinder on its edge or its radial side
-        tan_scale_angle = math.tan(scale_angle)                             # scale_angle == Pi/2 should not get here
+        # scale_angle == Pi/2 should not get here
         shell_radius_thres = scale_center_to_shell_r - scale_center_to_shell_z * tan_scale_angle  # TODO same here
 
         if shell_radius > shell_radius_thres:
@@ -858,6 +861,9 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     # This must always be the case:
     assert scale_angle >= 0.0
 
+    # Get tangent of the scale angle
+    tan_scale_angle = math.tan(scale_angle)
+
     # Check how the cylinders are oriented with respect to each other
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
 
@@ -938,9 +944,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         BARREL_HITS_FLAT, EDGE_HITS_EDGE, BARREL_HITS_EDGE, FLAT_HITS_BARREL, EDGE_HITS_BARREL, BARREL_HITS_BARREL = range(6)
         situation_string = ["BARREL_HITS_FLAT", "EDGE_HITS_EDGE", "BARREL_HITS_EDGE", "FLAT_HITS_BARREL", "EDGE_HITS_BARREL", "BARREL_HITS_BARREL"]
 
-        # Define some constants
-        tan_scale_angle = math.tan(scale_angle)
-
         #### (1) Now first determine which type of collision happens:
 
         if (ref_to_shell_x2 < 0) and (ref_to_shell_y2 < 0):
@@ -1025,7 +1028,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                             scale_angle < scale_center_to_shell_low_angle_y
                     situation = EDGE_HITS_EDGE
                     r1_min = (scale_center_to_shell_x - shell_half_length)*(1.0+TOLERANCE)
-                    h1_min = r1_min/math.tan(scale_angle)
+                    h1_min = r1_min/tan_scale_angle
 
         elif (ref_to_shell_x2 < 0) and (ref_to_shell_y2 >= 0):
             # Quadrant 3
@@ -1139,7 +1142,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                     assert scale_center_to_shell_crit_angle_xy < scale_angle and scale_angle < scale_center_to_shell_low_angle_xy and scale_angle > 0.0
                     situation = EDGE_HITS_EDGE
                     r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
-                    h1_min = r1_min/math.tan(scale_angle)
+                    h1_min = r1_min/tan_scale_angle
 
         ##TODO TESTING Debug info
         #log.info("  *** QUADRANT = %s ***" % str(quadrant) )

From d41a03d9c80fbad971dd8a6de23f41c1b6d25de5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 18:15:56 +0100
Subject: [PATCH 1277/1541] Store tan(scale_angle) as a property of the shells
 to save even more calculation effort

---
 shells.py | 85 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 84 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 73340bf1..7b04a466 100755
--- a/shells.py
+++ b/shells.py
@@ -1873,7 +1873,7 @@ def get_right_scalingangle(self):
         else:
             right_scaling_angle = math.atan(self.drdz_right)
         return right_scaling_angle
-    right_scalingangle = property(get_right_scalingangle)
+    right_scalingangle = property(get_right_scalingangle)    
 
     def get_left_scalingangle(self):
         if self.drdz_left == numpy.inf:
@@ -1885,6 +1885,12 @@ def get_left_scalingangle(self):
         return left_scaling_angle
     left_scalingangle = property(get_left_scalingangle)
 
+    def get_tan right_scalingangle(self):
+        return self.tan_right_scalingangle
+
+    def get_tan left_scalingangle(self):
+        return self.tan_left_scalingangle
+
     def get_min_dr_dzright_dzleft(self):
         # This defines the minimal dimensions in terms of r, z_right, z_left of the cylindrical domain
         # that we're trying to make. The exact values vary between type of domain.
@@ -1920,6 +1926,13 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.pid_particle_pair[1].radius
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # sizing up the shell to a zero shell
         self.dz_right = self.pid_particle_pair[1].radius
         self.dz_left  = self.pid_particle_pair[1].radius
@@ -1974,6 +1987,13 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.z0_right
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2031,6 +2051,13 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.r0_left    = self.dr_const
         self.z0_left    = 0.0
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # Sizing up the shell to a zero shell
         # Important: leave this as it is, because we always want to construct
         # a zero-single by default!
@@ -2096,6 +2123,13 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.r0_left    = self.dr_const
         self.z0_left    = 0.0
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # Sizing up the shell to a zero shell
         # Important: leave this as it is, because we always want to construct
         # a zero-single by default!
@@ -2149,6 +2183,13 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         self.r0_left    = self.dr_const
         self.z0_left    = 0.0
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2208,6 +2249,13 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.pid_particle_pair[1].radius
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2266,6 +2314,13 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.r0_left    = self.r0_right
         self.z0_left    = self.z0_right
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2330,6 +2385,13 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.r0_left    = self.dr_const
         self.z0_left    = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2385,6 +2447,13 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.r0_left    = self.dr_const
         self.z0_left    = self.z0_right
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2476,6 +2545,13 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         # TODO This is probably not needed any more:
         min_r, min_dz_right, _ = self.get_min_dr_dzright_dzleft()
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2687,6 +2763,13 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         self.r0_left    = self.dr_const
         self.z0_left    = self.cap_particle.radius * SINGLE_SHELL_FACTOR
 
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!

From c2370a0f0320417630cc73e12de3de077489a7a0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 18:18:34 +0100
Subject: [PATCH 1278/1541] Query tan(scale_angle) from testShell instead of
 calculating

---
 shells.py | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/shells.py b/shells.py
index 7b04a466..d37863a3 100755
--- a/shells.py
+++ b/shells.py
@@ -656,7 +656,8 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     if ref_to_shell_z >= 0:
         direction = 1           # improve direction specification such that following calculations still work
                                 # Otherwise problems when direction = 0
-        scale_angle = testShell.right_scalingangle
+        scale_angle     = testShell.right_scalingangle
+        tan_scale_angle = testShell.tan_right_scalingangle
         scale_center_r, scale_center_z = testShell.right_scalingcenter 
         r1_function =  testShell.r_right
         z1_function = testShell.z_right
@@ -667,6 +668,7 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     else:
         direction = -1
         scale_angle = testShell.left_scalingangle
+        tan_scale_angle = testShell.tan_left_scalingangle
         scale_center_r, scale_center_z = testShell.left_scalingcenter 
         r1_function =  testShell.r_left
         z1_function = testShell.z_left
@@ -684,9 +686,6 @@ def get_dr_dzright_dzleft_to_SphericalShape(shape, testShell, r, z_right, z_left
     scale_center_to_shell_r = ref_to_shell_r - scale_center_r
     scale_center_to_shell_z = ref_to_shell_z - scale_center_z
 
-    # Get tangent of the scale_angle
-    tan_scale_angle = math.tan(scale_angle)
-
     # calculate the angle 'shell_angle' of the vector from the 'scale_center' to the shell with the vector
     # from the 'reference_point' to the 'scale_center' (which is +- the orientation_vector).
     shell_angle = math.atan(scale_center_to_shell_r/scale_center_to_shell_z)
@@ -840,7 +839,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     if ref_to_shell_z >= 0:
         direction = 1           # improve direction specification such that following calculations still work
                                 # Otherwise problems when direction = 0
-        scale_angle = testShell.right_scalingangle
+        scale_angle     = testShell.right_scalingangle
+        tan_scale_angle = testShell.tan_right_scalingangle
         scale_center_r, scale_center_z = testShell.right_scalingcenter 
         r1_function = testShell.r_right
         z1_function = testShell.z_right
@@ -850,7 +850,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     # else -> use z_left
     else:
         direction = -1
-        scale_angle = testShell.left_scalingangle
+        scale_angle     = testShell.left_scalingangle
+        tan_scale_angle = testShell.tan_left_scalingangle
         scale_center_r, scale_center_z = testShell.left_scalingcenter 
         r1_function = testShell.r_left
         z1_function = testShell.z_left
@@ -861,9 +862,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     # This must always be the case:
     assert scale_angle >= 0.0
 
-    # Get tangent of the scale angle
-    tan_scale_angle = math.tan(scale_angle)
-
     # Check how the cylinders are oriented with respect to each other
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
 

From 2bfdb0eee289da9e2edd65ea7a763c2d3164ddc4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 18:32:53 +0100
Subject: [PATCH 1279/1541] typo

---
 shells.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index d37863a3..2af7f07f 100755
--- a/shells.py
+++ b/shells.py
@@ -1883,10 +1883,10 @@ def get_left_scalingangle(self):
         return left_scaling_angle
     left_scalingangle = property(get_left_scalingangle)
 
-    def get_tan right_scalingangle(self):
+    def get_tan_right_scalingangle(self):
         return self.tan_right_scalingangle
 
-    def get_tan left_scalingangle(self):
+    def get_tan_left_scalingangle(self):
         return self.tan_left_scalingangle
 
     def get_min_dr_dzright_dzleft(self):

From 0f27fafe7211a43e608578b63f8f75ff59f3702a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 18:44:23 +0100
Subject: [PATCH 1280/1541] Set scale_angle properties from derived classes

---
 shells.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 2af7f07f..09c916f9 100755
--- a/shells.py
+++ b/shells.py
@@ -1871,7 +1871,7 @@ def get_right_scalingangle(self):
         else:
             right_scaling_angle = math.atan(self.drdz_right)
         return right_scaling_angle
-    right_scalingangle = property(get_right_scalingangle)    
+    # property self.right_scalingangle set by constructor of derived classes
 
     def get_left_scalingangle(self):
         if self.drdz_left == numpy.inf:
@@ -1881,7 +1881,7 @@ def get_left_scalingangle(self):
         else:
             left_scaling_angle = math.atan(self.drdz_left)
         return left_scaling_angle
-    left_scalingangle = property(get_left_scalingangle)
+    # property self.left_scalingangle set by constructor of derived classes
 
     def get_tan_right_scalingangle(self):
         return self.tan_right_scalingangle

From 12ed1e7d3fb2c8001901c496ce6a785c6ec0ed0d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 18:51:11 +0100
Subject: [PATCH 1281/1541] Right order of referencing in
 MixedPair2D3DtestShell

---
 shells.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index 09c916f9..59b4cfa5 100755
--- a/shells.py
+++ b/shells.py
@@ -2533,13 +2533,6 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         self.r0_left    = 0.0
         self.z0_left    = self.particle2D.radius
 
-        log.info(' MixedPair2D3D: Initalized shellscaling: scale_angle = %s, drdz  = %s' % (self.right_scalingangle, self.drdz_right))
-        log.info('                                         r0_right = %s, z0_right = %s' % (self.r0_right, self.z0_right))
-        log.info('                                         r0_left  = %s, z0_left  = %s' % (self.r0_left,  self.z0_left))
-
-        log.info('      min_dr_dzright_dzleft = %s' % str(self.get_min_dr_dzright_dzleft() ))
-        log.info('      max_dr_dzright_dzleft = %s' % str(self.get_max_dr_dzright_dzleft() ))
-
         # TODO This is probably not needed any more:
         min_r, min_dz_right, _ = self.get_min_dr_dzright_dzleft()
 
@@ -2550,6 +2543,15 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
         self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
 
+        ### TESTING TESTING TESTING remove when done
+        log.info(' MixedPair2D3D: Initalized shellscaling: scale_angle = %s, drdz  = %s' % (self.right_scalingangle, self.drdz_right))
+        log.info('                                         r0_right = %s, z0_right = %s' % (self.r0_right, self.z0_right))
+        log.info('                                         r0_left  = %s, z0_left  = %s' % (self.r0_left,  self.z0_left))
+
+        log.info('      min_dr_dzright_dzleft = %s' % str(self.get_min_dr_dzright_dzleft() ))
+        log.info('      max_dr_dzright_dzleft = %s' % str(self.get_max_dr_dzright_dzleft() ))
+
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!

From 2600749afd9103996399028525de89c472705f65 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 19:48:01 +0100
Subject: [PATCH 1282/1541] Get rid of an unnecessary calculation

---
 shells.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/shells.py b/shells.py
index 59b4cfa5..31cc6b74 100755
--- a/shells.py
+++ b/shells.py
@@ -953,10 +953,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # If this is the case, we have the flat side of cyl. 1 hitting the barrel of cyl. 2. Else we have the edge hitting the barrel.
             r1_touch = (scale_center_to_shell_z - shell_radius)*tan_scale_angle
 
-            # TODO Probably not needed any more, remove!
-            dist_to_projected_edge_1 = math.sqrt(scale_center_to_shell_y**2 + (shell_half_length + scale_center_to_shell_y)**2)
-            dist_to_projected_edge_2 = math.sqrt(scale_center_to_shell_y**2 + (shell_half_length - scale_center_to_shell_y)**2)
-
             if r1_touch >= scale_center_to_shell_y:
                 # At least a part of the projected axis is within r_touch => flat side of scaled cyl. hits the barrel of cyl. 2
                 # Note that we know that at least a part of the shell is above the top side of the scaled cylinder (quadrant 1 condition)

From 28005f2fe7d24aaa33ff39346b784ff7a194bc9b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Nov 2012 20:01:08 +0100
Subject: [PATCH 1283/1541] Replace powers by multiplications in cylinder
 scaling routine

---
 shells.py | 67 ++++++++++++++++++++++++++++++++++---------------------
 1 file changed, 41 insertions(+), 26 deletions(-)

diff --git a/shells.py b/shells.py
index 31cc6b74..ebfeaa4b 100755
--- a/shells.py
+++ b/shells.py
@@ -964,11 +964,14 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             # Quadrant 2
             quadrant = 2
 
+            scale_center_to_shell_x_minus_half_length = scale_center_to_shell_x - shell_half_length
+
             # The case scale_angle=0, i.e. radius remaining constant at scaling, has to be treated separately
             # because in this case the mathematics in the standard case misdetect the collision situation
             if scale_angle == 0:
                 
-                if math.sqrt( (scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) < r :
+                if math.sqrt( scale_center_to_shell_x_minus_half_length*scale_center_to_shell_x_minus_half_length + \
+                              scale_center_to_shell_y*scale_center_to_shell_y) < r :
                 # The lowest point of the static cylinder is within the radius/flat side circle of the scaling cylinder.
                 # Therefore, when the height is scaled, the flat side must hit the barrel of the static cylinder at the lowpoint.
                     situation = FLAT_HITS_BARREL
@@ -983,10 +986,11 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 # Two points on the edge of the static cylinder are of interest here:
                 # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy-plane
                 # - the "critpoint" (critical point), which is the point on the edge with the shortest distance to the scale center                  
-                scale_center_to_flatend_x   = (scale_center_to_shell_x - shell_half_length) - scale_center_r
-                scale_center_to_lowpoint_x  = math.sqrt(( scale_center_to_shell_x - shell_half_length)**2 + scale_center_to_shell_y**2) - scale_center_r
+                scale_center_to_flatend_x   = scale_center_to_shell_x_minus_half_length - scale_center_r
+                scale_center_to_lowpoint_x  = math.sqrt( scale_center_to_shell_x_minus_half_length*scale_center_to_shell_x_minus_half_length +\
+                                                         scale_center_to_shell_y*scale_center_to_shell_y ) - scale_center_r
                     # TODO Is there no better way to include scale_center_r here?
-                scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius**2 - scale_center_to_shell_y**2) 
+                scale_center_to_critpoint_z = scale_center_to_shell_z - math.sqrt(shell_radius*shell_radius - scale_center_to_shell_y*scale_center_to_shell_y) 
                 scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
 
                 # Strategy:
@@ -1051,7 +1055,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 # - the "critpoint" (critical point), which is the point on the edge with the shortest distance to the scale center   
                 scale_center_to_shell_y -= scale_center_r  # TODO Is there no better way to include scale_center_r here?
                 scale_center_to_critpoint_y = scale_center_to_shell_y - shell_radius
-                scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius
+                scale_center_to_lowpoint_z  = scale_center_to_shell_z - shell_radius
 
                 # Calculate the angle between the scaled cylinder's axis and the line that links the scale center and critpoint
                 if scale_center_to_shell_z == 0.0:
@@ -1089,13 +1093,18 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
             assert (ref_to_shell_x2 >= 0) and (ref_to_shell_y2 >= 0)
 
+            scale_center_to_shell_x_minus_half_length = scale_center_to_shell_x - shell_half_length
+            scale_center_to_shell_y_minus_radius      = scale_center_to_shell_y - shell_radius
+
             # Two points on the edge of the static cylinder are of interest here:
             # - the "lowpoint", which is the point on the edge with the minimal z-distance to the scale center in the zy-plane
             # - the "critpoint" (critical point), which is the point on the edge with the minimal y-distance to
             #   the scale center in the zy-plane
-            scale_center_to_critpoint_r = math.sqrt((scale_center_to_shell_y - shell_radius)**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r    # a_r
-            scale_center_to_lowpoint_r = math.sqrt(scale_center_to_shell_y**2 + (scale_center_to_shell_x - shell_half_length)**2) - scale_center_r                      # b_r
-            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius                                                                                         # b_z
+            scale_center_to_critpoint_r = math.sqrt(scale_center_to_shell_y_minus_radius*scale_center_to_shell_y_minus_radius + \
+                                                    scale_center_to_shell_x_minus_half_length*scale_center_to_shell_x_minus_half_length) - scale_center_r  # a_r
+            scale_center_to_lowpoint_r = math.sqrt(scale_center_to_shell_y*scale_center_to_shell_y + \
+                                                   scale_center_to_shell_x_minus_half_length*scale_center_to_shell_x_minus_half_length) - scale_center_r   # b_r
+            scale_center_to_lowpoint_z = scale_center_to_shell_z - shell_radius                                                                            # b_z
 
             # Calculate the angle between the z-axis of the scaled cylinder and the line that
             # connects this axis with the "critpoint" on the static cylinder's edge
@@ -1135,7 +1144,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 else:
                     assert scale_center_to_shell_crit_angle_xy < scale_angle and scale_angle < scale_center_to_shell_low_angle_xy and scale_angle > 0.0
                     situation = EDGE_HITS_EDGE
-                    r1_min = math.sqrt((scale_center_to_shell_x-shell_half_length)**2 + (scale_center_to_shell_y-shell_radius)**2)*(1.0+TOLERANCE)
+                    r1_min = math.sqrt(scale_center_to_shell_x_minus_half_length*scale_center_to_shell_x_minus_half_length + \
+                                       scale_center_to_shell_y_minus_radius*scale_center_to_shell_y_minus_radius) * (1.0+TOLERANCE)
                     h1_min = r1_min/tan_scale_angle
 
         ##TODO TESTING Debug info
@@ -1156,7 +1166,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         elif situation == EDGE_HITS_EDGE:             
             # the scaling cylinder hits the edge of 'shell' with its edge
             # TODO we have a solution but it can only be found with a root finder -> slow
-            shell_radius_sq = shell_radius**2
+            shell_radius_sq = shell_radius*shell_radius
             scale_center_to_shell_edge_x = scale_center_to_shell_x - shell_half_length
             scale_center_to_shell_edge_y = scale_center_to_shell_y - shell_radius
             scale_center_to_shell_edge_z = scale_center_to_shell_z - shell_radius
@@ -1166,7 +1176,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 # scale_angle = 0 means that the radius r will stay constant at scaling
                 # Therefore, if the projected edge of the static shell lies outside of the 
                 # circle defined by r there will be no collision:
-                if r < math.sqrt(scale_center_to_shell_edge_x**2 + scale_center_to_shell_edge_y**2) :
+                if r < math.sqrt( scale_center_to_shell_edge_x*scale_center_to_shell_edge_x + \
+                                  scale_center_to_shell_edge_y*scale_center_to_shell_edge_y ) :
 
                     # The height and radius of the scaled cylinder remain unaltered
                     r_new = r
@@ -1175,9 +1186,9 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
                 else:
                 # There is a collision possible when z1 is scaled
                     
-                    y1_collide = math.sqrt(r**2 - scale_center_to_shell_edge_x**2)
+                    y1_collide = math.sqrt(r*r - scale_center_to_shell_edge_x*scale_center_to_shell_edge_x)
                     y2_collide = scale_center_to_shell_y - y1_collide
-                    h_collide = math.sqrt(shell_radius**2 - y2_collide**2)
+                    h_collide = math.sqrt(shell_radius*shell_radius - y2_collide*y2_collide)
 
                     h_touch = scale_center_to_shell_z - h_collide
                     z1_new = min(z1, h_touch)
@@ -1231,17 +1242,17 @@ def h1_eq(x):
                         #log.debug( "    scale_center_to_shell_edge_x = %s" % scale_center_to_shell_edge_x )
 
                         # We will take the square root of the following below
-                        sqrt_arg = (x*tan_scale_angle)**2 - scale_center_to_shell_edge_x**2
+                        sqrt_arg = (x*tan_scale_angle)*(x*tan_scale_angle) - scale_center_to_shell_edge_x*scale_center_to_shell_edge_x
 
-                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x**2:
+                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x*scale_center_to_shell_edge_x:
 
                             sqrt_arg = 0.0      # This safety check is to prevent math domain errors
                                                 # in case sqrt_arg is close to zero and taking the
                                                 # difference results in very small negative numbers
                             log.warn('Orthogonal cylinder scaling, EDGE_HITS_EDGE case: Setting negative sqrt argument to zero within TOLERANCE.')
 
-                        eq_value = (scale_center_to_shell_z - x)**2 - shell_radius_sq +\
-                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ))**2
+                        eq_value = (scale_center_to_shell_z - x)*(scale_center_to_shell_z - x) - shell_radius_sq +\
+                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ))*(scale_center_to_shell_y - math.sqrt( sqrt_arg ))
                         
                         # TODO TESTING REMOVE THIS WHEN DONE                    
                         #log.debug( "  h1 = %s, value = %s" % (x, eq_value ) )
@@ -1258,7 +1269,8 @@ def h1_eq(x):
                     while h1_eq_product > 0.0:
 
                         h1_interval_start = (1.0+TOLERANCE**n) * (z1_function(scale_center_to_shell_edge_x) - scale_center_z)
-                        h1_interval_end   = (1.0-TOLERANCE**n) * (z1_function( math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 ) ) - scale_center_z)
+                        h1_interval_end   = (1.0-TOLERANCE**n) * (z1_function( math.sqrt( scale_center_to_shell_y*scale_center_to_shell_y + \
+                                                                                          scale_center_to_shell_edge_x*scale_center_to_shell_edge_x ) ) - scale_center_z)
                         h1_eq_product     = h1_eq(h1_interval_start) * h1_eq(h1_interval_end)
 
                         n = n+1
@@ -1288,17 +1300,17 @@ def h1_eq(x):
                     def r1_eq(x):
 
                         # We will take the square root of the following below
-                        sqrt_arg = x**2 - scale_center_to_shell_edge_x**2
+                        sqrt_arg = x*x - scale_center_to_shell_edge_x*scale_center_to_shell_edge_x
 
-                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x**2:
+                        if sqrt_arg < 0.0 and abs(sqrt_arg) <= TOLERANCE*scale_center_to_shell_edge_x*scale_center_to_shell_edge_x:
 
                             sqrt_arg = 0.0      # This safety check is to prevent math domain errors
                                                 # in case sqrt_arg is close to zero and taking the
                                                 # difference results in very small negative numbers
                             log.warn('Orthogonal cylinder scaling, EDGE_HITS_EDGE case: Setting negative sqrt argument to zero within TOLERANCE.')
 
-                        eq_value = (scale_center_to_shell_z - x/tan_scale_angle)**2 - shell_radius_sq +\
-                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ) )**2
+                        eq_value = (scale_center_to_shell_z - x/tan_scale_angle)*(scale_center_to_shell_z - x/tan_scale_angle) - shell_radius_sq +\
+                                      (scale_center_to_shell_y - math.sqrt( sqrt_arg ) )*(scale_center_to_shell_y - math.sqrt( sqrt_arg ) )
 
                         # TODO TESTING REMOVE THIS WHEN DONE
                         #log.debug( "***** ROOTFINDER CALL: Calling r1_eq() with: *****" )
@@ -1314,7 +1326,8 @@ def r1_eq(x):
                     while r1_eq_product > 0.0:
 
                         r1_interval_start = (1.0+TOLERANCE**n) * scale_center_to_shell_edge_x
-                        r1_interval_end   = (1.0-TOLERANCE**n) * math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
+                        r1_interval_end   = (1.0-TOLERANCE**n) * math.sqrt( scale_center_to_shell_y*scale_center_to_shell_y + \
+                                                                            scale_center_to_shell_edge_x*scale_center_to_shell_edge_x )
                         r1_eq_product     = r1_eq(r1_interval_start) * r1_eq(r1_interval_end)
                         
                         n = n+1
@@ -1345,7 +1358,8 @@ def r1_eq(x):
 
         elif situation == BARREL_HITS_EDGE:
             # the scaling cylinder hits the edge of 'shell' with its barrel side
-            r_new = min(r, math.sqrt( (ref_to_shell_x-shell_half_length)**2 + (ref_to_shell_y - shell_radius)**2))
+            r_new = min(r, math.sqrt( (ref_to_shell_x-shell_half_length)*(ref_to_shell_x-shell_half_length) \
+                                      + (ref_to_shell_y - shell_radius)*(ref_to_shell_y - shell_radius)))
             z1_new = min(z1, z1_function(r_new))
 
         elif situation == FLAT_HITS_BARREL:
@@ -1363,7 +1377,7 @@ def r1_eq(x):
             # so that this step only affects the scale_angle == 0 cases:
             scale_center_to_shell_y -= scale_center_r
 
-            ss_sq = (scale_center_to_shell_z**2 + scale_center_to_shell_y**2)
+            ss_sq = (scale_center_to_shell_z*scale_center_to_shell_z + scale_center_to_shell_y*scale_center_to_shell_y)
             scale_center_to_shell = math.sqrt(ss_sq)
 
             shell_angle_yz = math.atan(scale_center_to_shell_y/scale_center_to_shell_z)
@@ -1382,7 +1396,8 @@ def r1_eq(x):
                                               % str(scale_center_shell_dist)
 
             # Check whether the calculated distance is within the forseen bounds and warn if not
-            if scale_center_shell_dist > math.sqrt(scale_center_to_shell_y**2+scale_center_to_shell_z**2)*(1.0+TOLERANCE):
+            if scale_center_shell_dist > math.sqrt(scale_center_to_shell_y*scale_center_to_shell_y \
+                                                   + scale_center_to_shell_z*scale_center_to_shell_z) * (1.0+TOLERANCE):
                 log.warning('Orthogonal cylinder scaling, EDGE_HITS_BARREL case: scale-center-to-shell distance is out of foreseen bounds:')
                 log.warning('   distance=%s, scale_center_to_shell_y=%s, scale_center_to_shell_z=%s' \
                              % (scale_center_shell_dist, scale_center_to_shell_y, scale_center_to_shell_z) )

From ea96d29a945f70421c9a44c0cdced54d613df39f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 13:49:15 +0100
Subject: [PATCH 1284/1541] Impose bounds by neighboring orthogonal surfaces
 when sampling dissociation positions in fire_single() for PlanarSurface bound
 particle

---
 egfrd.py | 50 +++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 45 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ace8325d..ca30d2b6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -498,7 +498,8 @@ def step(self):
                     raise RuntimeError('too many dt=zero steps. '
                                        'Simulator halted?'
                                     'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
-                    log.warning('dt=zero step, working in s.t >> dt~0 Python limit.')
+
+                log.warning('dt=zero step, working in s.t >> dt~0 Python limit.')
             else:
                 self.zero_steps = 0
 
@@ -1180,6 +1181,21 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     # draw a number of new positions for the two product particles
                     # TODO make this a generator
 
+                    # Make sure that the new positions lie within the region bounded by neighboring orthogonal
+                    # planes to avoid particles leaking out of a box
+                    # NOTE surface lists have format (surface, distance_to_surface_from_reactant_position)
+                    neighbor_surfaces = get_neighbor_surfaces(self.world, reactant_pos, reactant_structure.id, ignores=[])
+
+                    # Determine which of the neighbor surfaces set bounds to the dissociation region
+                    bounding_surfaces = []
+                    for surface, surface_distance in neighbor_surfaces:
+
+                        if isinstance(surface, PlanarSurface) and \
+                            feq(numpy.dot(surface.unit_z, reactant_structure.unit_z), 0.0) :
+
+                            bounding_surfaces.append( (surface, surface_distance) )
+
+                    # OK, now sample new positions
                     product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
                         # draw the random angle for the 3D particle relative to the particle left in the membrane
@@ -1195,13 +1211,37 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             unit_z = reactant_structure.shape.unit_z
                         else:
                             unit_z = reactant_structure.shape.unit_z * myrandom.choice(-1, 1)
-
-                        # calculate the new positions and structure IDs
-                        newposA, newposB, sidA, sidB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
+                        
+                        Ns = 0
+                        positions_legal = False
+                        while not positions_legal:
+                            # calculate the new positions and structure IDs
+                            newposA, newposB, sidA, sidB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
                                                                                        productA_radius, productB_radius,
                                                                                        reactant_structure, reactant_structure,
                                                                                        unit_z, self.world)
-                        # the second reactant_structure parameter passed is ignored here
+                            # the second reactant_structure parameter passed is ignored here
+
+                            # Test whether the created positions are within the bounds imposed by 
+                            # neighboring orthogonal planar surfaces                          
+                            dist_to_proj_posA = length( reactant_structure.project_point(newposA)[0] - reactant_pos )
+                            dist_to_proj_posB = length( reactant_structure.project_point(newposB)[0] - reactant_pos )
+                            
+                            if all([dist_to_proj_posA < sd[1] for sd in bounding_surfaces]) and\
+                               all([dist_to_proj_posB < sd[1] for sd in bounding_surfaces]):
+                                  # sd[1] is the distance to the surface from reactant_pos
+
+                                  positions_legal = True
+
+                            elif __debug__:
+                            
+                                log.warning('Dissociation positions in fire_single on PlanarSurface with two products out of bounds => resampling')
+
+                            Ns++
+                            if Ns > self.MAX_NUM_DT0_STEPS:
+                                raise RuntimeError('Too many resampling attempts in fire_single on PlanarSurface with two products: Ns = %s > %s' \
+                                                    % (Ns, self.MAX_NUM_DT0_STEPS) )
+                                # TODO This should not raise RuntimeError but just a warning; this is for TESTING only; replace by something better
 
                         if default:
                             newpos1, newpos2 = newposA, newposB

From b411e781f2c0f87fdf033a708ea383a622ef8050 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 13:57:48 +0100
Subject: [PATCH 1285/1541] Do not resample if both new positions are in the
 plane

Then apply_boundary will work correctly.
---
 egfrd.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ca30d2b6..9f721a23 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1226,12 +1226,17 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             # neighboring orthogonal planar surfaces                          
                             dist_to_proj_posA = length( reactant_structure.project_point(newposA)[0] - reactant_pos )
                             dist_to_proj_posB = length( reactant_structure.project_point(newposB)[0] - reactant_pos )
-                            
-                            if all([dist_to_proj_posA < sd[1] for sd in bounding_surfaces]) and\
-                               all([dist_to_proj_posB < sd[1] for sd in bounding_surfaces]):
-                                  # sd[1] is the distance to the surface from reactant_pos
 
-                                  positions_legal = True
+                            if sidA == reactant_structure_id and sidB == reactant_structure_id:
+                                # Both particles end up back on the surface, apply_boundary should
+                                # take care of reflection etc. correctly, thus here we pass
+                                positions_legal = True
+
+                            elif all([dist_to_proj_posA < sd[1] for sd in bounding_surfaces]) and\
+                                 all([dist_to_proj_posB < sd[1] for sd in bounding_surfaces]):
+                                    # sd[1] is the distance to the surface from reactant_pos
+
+                                positions_legal = True
 
                             elif __debug__:
                             

From 16a6c56c366d4589ff9c865e55c0015498f5fc0b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 14:00:31 +0100
Subject: [PATCH 1286/1541] Python is not C++ ...

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 9f721a23..bdcc94c2 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1242,7 +1242,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             
                                 log.warning('Dissociation positions in fire_single on PlanarSurface with two products out of bounds => resampling')
 
-                            Ns++
+                            Ns = Ns + 1
                             if Ns > self.MAX_NUM_DT0_STEPS:
                                 raise RuntimeError('Too many resampling attempts in fire_single on PlanarSurface with two products: Ns = %s > %s' \
                                                     % (Ns, self.MAX_NUM_DT0_STEPS) )

From 19138393fbf106f4e92fa30a20bbb80256c550e1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 14:06:13 +0100
Subject: [PATCH 1287/1541] Small fix

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index bdcc94c2..d98ac2ca 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1191,7 +1191,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     for surface, surface_distance in neighbor_surfaces:
 
                         if isinstance(surface, PlanarSurface) and \
-                            feq(numpy.dot(surface.unit_z, reactant_structure.unit_z), 0.0) :
+                            feq(numpy.dot(surface.shape.unit_z, reactant_structure.shape.unit_z), 0.0) :
 
                             bounding_surfaces.append( (surface, surface_distance) )
 

From 4a3ad4d43e8a2b1cfad31960ea883d1f4c88184d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 16:08:15 +0100
Subject: [PATCH 1288/1541] A simpler solution: Just make sure that
 dissociation position is always above the planar surface of origin

This is less costly and also easier to implement into the BD part.
---
 egfrd.py | 65 +++++++++++++++++++++++++++-----------------------------
 1 file changed, 31 insertions(+), 34 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index d98ac2ca..33ec422e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1186,25 +1186,20 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     # NOTE surface lists have format (surface, distance_to_surface_from_reactant_position)
                     neighbor_surfaces = get_neighbor_surfaces(self.world, reactant_pos, reactant_structure.id, ignores=[])
 
+                    # Code snippet to get surfaces that might bound the dissociation positions;
+                    # not used at the moment...
                     # Determine which of the neighbor surfaces set bounds to the dissociation region
-                    bounding_surfaces = []
-                    for surface, surface_distance in neighbor_surfaces:
+                    #bounding_surfaces = []
+                    #for surface, surface_distance in neighbor_surfaces:
 
-                        if isinstance(surface, PlanarSurface) and \
-                            feq(numpy.dot(surface.shape.unit_z, reactant_structure.shape.unit_z), 0.0) :
+                        #if isinstance(surface, PlanarSurface) and \
+                            #feq(numpy.dot(surface.shape.unit_z, reactant_structure.shape.unit_z), 0.0) :
 
-                            bounding_surfaces.append( (surface, surface_distance) )
+                            #bounding_surfaces.append( (surface, surface_distance) )
 
                     # OK, now sample new positions
                     product_pos_list = []
-                    for _ in range(self.dissociation_retry_moves):
-                        # draw the random angle for the 3D particle relative to the particle left in the membrane
-
-                        # do the backtransform with a random iv with length such that the particles are at contact
-                        # Note we make the iv slightly longer because otherwise the anisotropic transform will produce illegal
-                        # positions
-                        iv = random_vector(particle_radius12 * MixedPair2D3D.calc_z_scaling_factor(DA, DB))
-                        iv *= MINIMAL_SEPARATION_FACTOR
+                    for _ in range(self.dissociation_retry_moves):                        
 
                         # determine the side of the membrane the dissociation takes place
                         if(reactant_structure.shape.is_one_sided):
@@ -1215,27 +1210,29 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         Ns = 0
                         positions_legal = False
                         while not positions_legal:
-                            # calculate the new positions and structure IDs
-                            newposA, newposB, sidA, sidB = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
-                                                                                       productA_radius, productB_radius,
-                                                                                       reactant_structure, reactant_structure,
-                                                                                       unit_z, self.world)
-                            # the second reactant_structure parameter passed is ignored here
 
-                            # Test whether the created positions are within the bounds imposed by 
-                            # neighboring orthogonal planar surfaces                          
-                            dist_to_proj_posA = length( reactant_structure.project_point(newposA)[0] - reactant_pos )
-                            dist_to_proj_posB = length( reactant_structure.project_point(newposB)[0] - reactant_pos )
+                            # draw the random angle for the 3D particle relative to the particle left in the membrane
+                            # do the backtransform with a random iv with length such that the particles are at contact
+                            # Note we make the iv slightly longer because otherwise the anisotropic transform will produce illegal
+                            # positions
+                            iv = random_vector(particle_radius12 * MixedPair2D3D.calc_z_scaling_factor(DA, DB))
+                            iv *= MINIMAL_SEPARATION_FACTOR
 
-                            if sidA == reactant_structure_id and sidB == reactant_structure_id:
-                                # Both particles end up back on the surface, apply_boundary should
-                                # take care of reflection etc. correctly, thus here we pass
-                                positions_legal = True
+                            # calculate the new positions and structure IDs
+                            newposA, newposB, _, _ = MixedPair2D3D.do_back_transform(reactant_pos, iv, DA, DB,
+                                                                                     productA_radius, productB_radius,
+                                                                                     reactant_structure, reactant_structure,
+                                                                                     unit_z, self.world)
+                            # the second reactant_structure parameter passed is ignored here
+                            # therefore also the structure IDs returned by the classmethod will not be right
 
-                            elif all([dist_to_proj_posA < sd[1] for sd in bounding_surfaces]) and\
-                                 all([dist_to_proj_posB < sd[1] for sd in bounding_surfaces]):
-                                    # sd[1] is the distance to the surface from reactant_pos
+                            # Test whether the created positions are above the plane
+                            # This is to ensure that 3D particles will stay inside a box made from planes
+                            dist_to_edgeA = reactant_structure.project_point(newposA)[1][1]
+                            dist_to_edgeB = reactant_structure.project_point(newposB)[1][1]                            
 
+                            if dist_to_edgeA < 0.0 and dist_to_edgeB < 0.0 :
+                                # Note that project_point()[1][1] returns the negative length to the closest edge
                                 positions_legal = True
 
                             elif __debug__:
@@ -1263,10 +1260,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
                         unit_z = reactant_structure.shape.unit_z
 
-                        newposA, newposB, sidA, sidB = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
-                                                                                       productA_radius, productB_radius,
-                                                                                       reactant_structure, reactant_structure,
-                                                                                       unit_z, self.world)
+                        newposA, newposB, _, _ = MixedPair1D3D.do_back_transform(reactant_pos, iv, DA, DB,
+                                                                                 productA_radius, productB_radius,
+                                                                                 reactant_structure, reactant_structure,
+                                                                                 unit_z, self.world)
                         # the second reactant_structure parameter passed is ignored here
                         # unit_z is passed here for completeness but not used in the method
 

From 0d8cfdaf8811ba20450f52c3d1385807c8580cd7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 16:10:29 +0100
Subject: [PATCH 1289/1541] Cleanup

---
 egfrd.py | 27 +++++++--------------------
 pair.py  |  6 ------
 2 files changed, 7 insertions(+), 26 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 33ec422e..55615c67 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -762,7 +762,6 @@ def burst_domain(self, domain, ignore):
     # - list of zero_singles that was the result of the bursting
     # - updated ignore list
 
-        log.debug('  Bursting domain %s, ignore=%s' % (domain, ignore)) ### TESTING
         domain_id = domain.domain_id
 
         if __debug__:
@@ -1240,10 +1239,12 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                 log.warning('Dissociation positions in fire_single on PlanarSurface with two products out of bounds => resampling')
 
                             Ns = Ns + 1
-                            if Ns > self.MAX_NUM_DT0_STEPS:
+                            if Ns > self.MAX_NUM_DT0_STEPS:   # To avoid an infinite loop we need some kind of break condition
+                                                              # We take the same looping limit as for dt=0 steps because this is a similar situation
                                 raise RuntimeError('Too many resampling attempts in fire_single on PlanarSurface with two products: Ns = %s > %s' \
-                                                    % (Ns, self.MAX_NUM_DT0_STEPS) )
-                                # TODO This should not raise RuntimeError but just a warning; this is for TESTING only; replace by something better
+                                                  % (Ns, self.MAX_NUM_DT0_STEPS) )
+                                                  # TODO This should not necessarily raise RuntimeError but just a warning;
+                                                  # this is for TESTING only; replace by something better
 
                         if default:
                             newpos1, newpos2 = newposA, newposB
@@ -1616,8 +1617,6 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
 
         # 0. get reactant info
         reactant = single.pid_particle_pair
-        log.debug('  Enter fire_move for %s' % str(single))   ### TESTING            
-        log.debug('  reactant_pos=%s, reactant_radius=%s' % (reactant_pos, reactant[1].radius))   ### TESTING
         # 1. No product->no info
         # 1.5 No additional positional/structure change is needed
         # 2. Position is in protective shell
@@ -1626,17 +1625,11 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
         if ignore_p:
             co = self.world.check_overlap((reactant_pos, reactant[1].radius),
                                         reactant[0], ignore_p[0])
-            log.debug('co = %s, list(co) = %s' % (co, list(co)) )
-            for pp, d in co:
-              log.debug('  check_overlap = (%s, %s), ignore_p = %s' % (pp, d, ignore_p[0]) )   ### TESTING
             if co:
                 raise RuntimeError('fire_move: particle overlap failed.')
         else:
             co = self.world.check_overlap((reactant_pos, reactant[1].radius),
-                                        reactant[0])
-            log.debug('co = %s, list(co) = %s' % (co, list(co)) )
-            for pp, d in co:
-                log.debug('  check_overlap = (%s, %s)' % (pp, d) )   ### TESTING
+                                        reactant[0])            
             if co:
                 raise RuntimeError('fire_move: particle overlap failed.')
 
@@ -1962,15 +1955,12 @@ def process_single_event(self, single, ignore):
             if single.getD() != 0 and single.dt > 0.0:
                 # If the particle had the possibility to diffuse
                 newpos, struct_id = single.draw_new_position(single.dt, single.event_type)
-                log.debug('  draw: newpos, struct_id = (%s, %s)' % (newpos, struct_id))   ### TESTING
                 newpos, struct_id = self.world.apply_boundary((newpos,struct_id))
-                log.debug('  after apply_boundary: newpos, struct_id = (%s, %s)' % (newpos, struct_id))   ### TESTING
             else:
                 # no change in position has taken place
                 newpos    = pid_particle_pair[1].position
                 struct_id = pid_particle_pair[1].structure_id
             # TODO? Check if the new positions are within domain
-            log.debug('  final: newpos, struct_id = (%s, %s)' % (newpos, struct_id))   ### TESTING
 
             # newpos now hold the new position of the particle (not yet committed to the world)
             # if we would here move the particles and make new shells, then it would be similar to a propagate
@@ -1995,7 +1985,6 @@ def process_single_event(self, single, ignore):
                     particles, zero_singles_b, ignore = self.fire_interaction(single, newpos, struct_id, ignore)
 
             else:
-                log.debug('  Calling fire_move with single=%s, newpos=%s, struct_id=%s' % (single, newpos, struct_id) )   ### TESTING
                 particles = self.fire_move(single, newpos, struct_id)
                 zero_singles_b = []   # no bursting takes place, ignore list remains unchanged
                 # Update statistics
@@ -2112,10 +2101,8 @@ def process_pair_event(self, pair, ignore):
         if pair.dt > 0.0:
             
             newpos1, newpos2, struct1_id, struct2_id = pair.draw_new_positions(pair.dt, pair.r0, pair.iv, pair.event_type)
-            log.debug('  draw: newpos1, newpos2, sid1, sid2 = (%s, %s, %s, %s)' % (newpos1, newpos2, struct1_id, struct2_id))   ### TESTING
             newpos1, struct1_id = self.world.apply_boundary((newpos1, struct1_id))
             newpos2, struct2_id = self.world.apply_boundary((newpos2, struct2_id))
-            log.debug('  after apply_boundary: newpos1, newpos2, sid1, sid2 = (%s, %s, %s, %s)' % (newpos1, newpos2, struct1_id, struct2_id))   ### TESTING
 
             # check that the particles do not overlap with any other particles in the world
             assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
@@ -2263,7 +2250,7 @@ def process_pair_event(self, pair, ignore):
 
         ### 6. Recursively burst around the newly made zero-dt NonInteractionSingles that surround the particles.
         for zero_single in zero_singles:
-            log.debug('  Starting recursive burst for zero_single %s' % str(zero_single))   ### TESTING
+            
             more_zero_singles, ignore = self.burst_non_multis(zero_single.pid_particle_pair[1].position,
                                                               zero_single.pid_particle_pair[1].radius*SINGLE_SHELL_FACTOR,
                                                               ignore)
diff --git a/pair.py b/pair.py
index 6911c1c9..152df954 100644
--- a/pair.py
+++ b/pair.py
@@ -676,15 +676,9 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # In some cases the new positions may end up on adjacent planar surfaces.
         # This may lead to an overlap which has to be checked for and removed if present
         # in the next step.
-        log.debug('    do_back_transform: Sampling new positions:')   ### TESTING
         new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
         new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
 
-        log.debug('    pos_and_sid1 = (%s, %s), pos_and_sid2 = (%s, %s)' \
-                                        % (pos1, structure1.id, pos2, structure1.id) )   ### TESTING
-        log.debug('    new_pos_and_sid1 = (%s, %s), new_pos_and_sid2 = (%s, %s) (after apply_boundary)' \
-                                        % (new_pos1, new_sid1, new_pos2, new_sid2) )   ### TESTING
-
         # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
         if world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR :
 

From 6597a3c0087edd432e1334898a1236bc3656d930 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 16:11:02 +0100
Subject: [PATCH 1290/1541] Also impose the same unbinding restriction in BD
 mode

---
 StructureFunctions.hpp | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index eb6176b6..599f9d41 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -1187,12 +1187,28 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
     
-    std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
-    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
-    // the types of origin_structure and target_structure and the properties of the two product species
-    // (the displacements from old_pos are weighted by the diffusion constants);
-    // the first pair entry is the particle staying on the surface, the second entry the particle
-    // that goes into the bulk
+    std::pair<position_type, position_type> new_positions;
+    length_type dist_to_edge_1;
+    length_type dist_to_edge_2;
+    
+    bool positions_legal(false);
+    
+    do{
+        // Produce two new positions
+        new_positions = origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length);
+          // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+          // the types of origin_structure and target_structure and the properties of the two product species
+          // (the displacements from old_pos are weighted by the diffusion constants);
+          // the first pair entry is the particle staying on the surface, the second entry the particle
+          // that goes into the bulk
+        
+        // Check whether the newly produced positions are above the origin plane
+        dist_to_edge_1 = origin_structure.project_point(new_positions.first).second.second;
+        dist_to_edge_2 = origin_structure.project_point(new_positions.second).second.second;
+        
+        positions_legal = (dist_to_edge_1 < 0.0) and (dist_to_edge_2 < 0.0);    
+    }
+    while( not(positions_legal) );
             
     return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id()),
                                 std::make_pair(new_positions.second, target_structure.id())    );    

From b13114c3d50a66f7a00163d357638649cf070aba Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 6 Dec 2012 17:23:03 +0100
Subject: [PATCH 1291/1541] Just two useful comments

---
 pair.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 152df954..6a8545d3 100644
--- a/pair.py
+++ b/pair.py
@@ -963,8 +963,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
 
         iv_z = unit_z * iv_z_length
 
-        pos1 = com - weight1 * (iv_x + iv_y)
-        pos2 = com + weight2 * (iv_x + iv_y) + iv_z 
+        pos1 = com - weight1 * (iv_x + iv_y)            # the new 2D particle position
+        pos2 = com + weight2 * (iv_x + iv_y) + iv_z     # the new 3D particle position
 
         # Class method; so don't use self.(..)
         return pos1, pos2, structure2D.id, structure3D.id

From 6d3d89b77cf18d70f77e5de86897c350cb1e9fe9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 11 Dec 2012 16:52:04 +0100
Subject: [PATCH 1292/1541] Allow the user to define 'control bounds', i.e.
 bounding boxes to check whether particles leak out of them

---
 egfrd.py    | 23 +++++++++++++++++++++++
 gfrdbase.py | 40 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 63 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index 55615c67..7bdcaf55 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -439,6 +439,9 @@ def step(self):
         if __debug__:
             if int("0" + os.environ.get("ECELL_CHECK", ""), 10):
                 self.check()
+
+        if __debug__ and self.control_bounds:
+            self.check_particle_consistency()
         
         self.step_counter += 1
 
@@ -3155,6 +3158,26 @@ def check_particle_consistency(self):
             raise RuntimeError('population %d != domain_population %d' %
                                (world_population, domain_population))
 
+        # If control bounds are defined, check whether all particles are within
+        # (with a certain tolerance):
+        world_particles = list(self.world)
+
+        for particle in world_particles:
+            
+            pos = self.get_position(particle)
+
+            for corner1, corner2 in self.control_bounds:
+
+                  tolerance = length(corner2) * TOLERANCE  
+
+                  if not(      all([diff >= -tolerance for diff in numpy.subtract(pos, corner1)]) \
+                          and  all([diff >= -tolerance for diff in numpy.subtract(corner2, pos)]) ):
+
+                      log.warn('Particle out of control bounds: particle = %s, bounds = %s, tolerance = %s' \
+                               % (particle, (corner1, corner2), tolerance) )
+
+          
+
        ## Next, check that every particle in the domains is once and only once in the world.
        #already_in_domain = set()
        #world_particles = list(self.world)
diff --git a/gfrdbase.py b/gfrdbase.py
index eb833c5c..67d7115b 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -588,6 +588,11 @@ def __init__(self, world, rng, network_rules):
 
         self.last_reaction = None
 
+        # control bounds
+        # to allow the user to check whether particles leak out
+        # of certain parts of the system
+        self.control_bounds = []
+
     def initialize(self):
         pass
 
@@ -718,6 +723,41 @@ def check(self):
     def print_report(self):
         pass
 
+    def add_control_bound(self, corner1, corner2):
+        """
+        Adds a control bounding box to the system.
+    
+        Given that logging is on, the system will warn
+        whenever particles leave the predefined bounds.
+    
+        Arguments:
+
+          - corner1
+              3D array defining the lower-left corner
+              of the bounding box
+    
+          - corner2
+              3D array defining the upper right corner
+              of the bounding box
+    
+        Make sure you pass it in the right format.    
+        """
+
+        assert len(corner1)==3 and len(corner2)==3
+
+        if all([c > 0.0 for c in numpy.subtract(corner2, corner1)]):
+            
+            self.control_bounds.append((corner1, corner2))
+            if __debug__:
+                log.info('Added control bound %s' % str((corner1, corner2)) )
+                log.info('Control bounds list: %s' % str(self.control_bounds) )
+
+        else:
+
+            raise RuntimeError('Illegal control bounds; make sure '
+                               'all corner coordinates are positive '
+                               'and corner2 coordinates are larger than corner1 coordinates.')
+
 class NoSpace(Exception):
     pass
 

From 7ae2076dacf987d88d4276c8fdd3b730f966cfee Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 12 Dec 2012 17:58:31 +0100
Subject: [PATCH 1293/1541] Replace "flag_type" by bool

because the typedef has no advantages and causes unnecessary problems...
---
 Plane.hpp          | 9 ++++-----
 StructureUtils.hpp | 8 +++-----
 2 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/Plane.hpp b/Plane.hpp
index dee53f2f..885dc6a4 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -18,7 +18,6 @@ class Plane
     typedef T_ value_type;
     typedef Vector3<T_> position_type;
     typedef T_ length_type;
-    typedef bool flag_type;
     typedef enum side_enum_type {TOP=0, BOTTOM=1, LEFT=2, RIGHT=3} side_enum_type;  // The typedef is a little bit C style but doesn't matter for C++
 
 public:
@@ -72,7 +71,7 @@ class Plane
         position_type const& vy,
         length_type const& half_lx,
         length_type const& half_ly,
-        flag_type const& is_one_sided)
+        bool const& is_one_sided)
         : position_(position), units_(array_gen(vx, vy, cross_product(vx, vy))),
           half_extent_(array_gen<length_type>(half_lx, half_ly)), is_one_sided_(is_one_sided) {}
 
@@ -156,12 +155,12 @@ class Plane
         return half_extent_;
     }
     
-    flag_type const& is_one_sided() const
+    bool const& is_one_sided() const
     {
         return is_one_sided_;
     }
     
-    flag_type& is_one_sided()
+    bool& is_one_sided()
     {
         return is_one_sided_;
     }
@@ -189,7 +188,7 @@ class Plane
     position_type position_;
     boost::array<position_type, 3> units_;
     boost::array<length_type, 2> half_extent_;
-    flag_type is_one_sided_;
+    bool is_one_sided_;
 };
 
 template<typename T_>
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index ab36b714..73bc741b 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -35,9 +35,7 @@ struct StructureUtils
     typedef typename simulator_type::disk_surface_type          disk_surface_type;
     typedef typename simulator_type::planar_surface_type        planar_surface_type;
     typedef typename simulator_type::cuboidal_region_type       cuboidal_region_type;
-    typedef typename simulator_type::world_type::traits_type::rng_type rng_type;
-    
-    typedef bool flag_type;
+    typedef typename simulator_type::world_type::traits_type::rng_type rng_type;   
  
     static planar_surface_type* create_planar_surface(
             structure_type_id_type const& sid,          // This refers to the structure type of the planar surface
@@ -61,7 +59,7 @@ struct StructureUtils
 
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
                                                 multiply(unit_y, half_ly)));
-        const flag_type is_one_sided(true);
+        const bool is_one_sided(true);
 
         return new planar_surface_type(name, sid, parent_struct_id,
                                        plane_type(pos, unit_x, unit_y,
@@ -90,7 +88,7 @@ struct StructureUtils
 
         const position_type pos(add(add(corner, multiply(unit_x, half_lx)),
                                                 multiply(unit_y, half_ly)));
-        const flag_type is_one_sided(false);
+        const bool is_one_sided(false);
 
         return new planar_surface_type(name, sid, parent_struct_id,
                                        plane_type(pos, unit_x, unit_y,

From 127e51ba778d3d5de724adb3af7d2c942d30f532 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 12 Dec 2012 18:19:03 +0100
Subject: [PATCH 1294/1541] Assert that planes are constructed correctly when
 loading unit vectors

---
 loadsave.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/loadsave.py b/loadsave.py
index 96bf7ffc..acd2ef64 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -769,6 +769,8 @@ def load_state(filename):
             # Create the structure
             structure = model.create_planar_surface(structure_type.id, name, corner_pos, unit_x, unit_y, \
                                                     2.0*half_extent[0], 2.0*half_extent[1], parent_structure.id)
+            
+            assert all( [structure.shape.unit_z[c]==unit_z[c] for c in range(0,len(unit_z))] )
 
         # Add it to the world
         if structure:

From 38dd02525eaaf8161e4febe35e1c91969d394ec3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 12 Dec 2012 18:37:47 +0100
Subject: [PATCH 1295/1541] Fix flag_type thing in binding, too

---
 binding/Plane.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/binding/Plane.hpp b/binding/Plane.hpp
index 7c6085a2..eb417267 100644
--- a/binding/Plane.hpp
+++ b/binding/Plane.hpp
@@ -107,14 +107,14 @@ inline boost::python::objects::class_base register_plane_class(char const* name)
             make_function(
                 &peer::util::reference_accessor_wrapper<
                     impl_type,
-                    typename impl_type::flag_type,
+                    bool,
                     &impl_type::is_one_sided,
                     &impl_type::is_one_sided>::get,
                 return_value_policy<return_by_value>()),
             make_function(
                 &peer::util::reference_accessor_wrapper<
                     impl_type,
-                    typename impl_type::flag_type,
+                    bool,
                     &impl_type::is_one_sided,
                     &impl_type::is_one_sided>::set))
         ;

From d85396e089600a579ce205a05aab1043c2deb224 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 12 Dec 2012 18:41:56 +0100
Subject: [PATCH 1296/1541] Make unbinding from plane deterministic in
 special_geminate_dissociation_positions if the plane is indeed one-sided

This caused unbinding into the wrong direction and therefore particles
leaking out of the box.
---
 PlanarSurface.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 934e5435..bf731efe 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -195,7 +195,7 @@ class PlanarSurface
         pp01.second = add( op_surf, 
                        add( base_type::shape().unit_x() * (x * D_bulk_D01),
                          add( base_type::shape().unit_y() * (y * D_bulk_D01),
-                                unit_z * z ) ) );
+                                unit_z * abs(z) ) ) );
 
         return pp01;
         

From a980c788068df7cfb024e494df35e8edddd70ac4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Dec 2012 17:50:18 +0100
Subject: [PATCH 1297/1541] When moving the second of two particles
 check_overlap should not ignore the first

Also added some more info output in case of overlap.
---
 egfrd.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7bdcaf55..b4fe36dd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1629,11 +1629,15 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
             co = self.world.check_overlap((reactant_pos, reactant[1].radius),
                                         reactant[0], ignore_p[0])
             if co:
+                for c in co:
+                    log.debug('fire_move: detected overlap with %s' % str(c))
                 raise RuntimeError('fire_move: particle overlap failed.')
         else:
             co = self.world.check_overlap((reactant_pos, reactant[1].radius),
                                         reactant[0])            
             if co:
+                for c in co:
+                    log.debug('fire_move: detected overlap with %s' % str(c))
                 raise RuntimeError('fire_move: particle overlap failed.')
 
         # 4. process the changes (move particles, change structure)
@@ -2107,7 +2111,9 @@ def process_pair_event(self, pair, ignore):
             newpos1, struct1_id = self.world.apply_boundary((newpos1, struct1_id))
             newpos2, struct2_id = self.world.apply_boundary((newpos2, struct2_id))
 
-            # check that the particles do not overlap with any other particles in the world
+            # Check that the particles do not overlap with any other particles in the world
+            # Ignore the two singles because they are still at there old positions and most 
+            # certainly would cause check_overlap to find them!
             assert not self.world.check_overlap((newpos1, pid_particle_pair1[1].radius),
                                                 pid_particle_pair1[0], pid_particle_pair2[0])
             assert not self.world.check_overlap((newpos2, pid_particle_pair2[1].radius),
@@ -2182,7 +2188,7 @@ def process_pair_event(self, pair, ignore):
              pair.event_type == EventType.BURST):
 
             particles      = self.fire_move (single1, newpos1, struct1_id, pid_particle_pair2)
-            particles.extend(self.fire_move (single2, newpos2, struct2_id, pid_particle_pair1))
+            particles.extend(self.fire_move (single2, newpos2, struct2_id))
             zero_singles_b = []
             # ignore is unchanged
 

From 762f8dd342a6413a7087f774f72a19e40cef0896 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Dec 2012 17:51:20 +0100
Subject: [PATCH 1298/1541] Enlarge interparticle vector for MixedPair2D3D if
 shorter than sum of radii after inverse transform

---
 pair.py | 44 ++++++++++++++++++++++++++++++++++----------
 1 file changed, 34 insertions(+), 10 deletions(-)

diff --git a/pair.py b/pair.py
index 6a8545d3..b6bc1d41 100644
--- a/pair.py
+++ b/pair.py
@@ -936,36 +936,60 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
     #
     # structure3D is not used here but has to be passed because of the classmethod property
 
+        ### TESTING
+        log.debug('MixedPair2D3D: Entering draw_new_positions')
+        log.debug('  com = %s, iv = %s, length(iv) = %s, radius1 = %s, radius2 = %s' % (com, iv, length(iv), radius1, radius2) )        
+
         D_tot = D1 + D2
         weight1 = D1 / D_tot
         weight2 = D2 / D_tot
 
-#       min_iv_z_length = radius2
-        # get a sence of scale of the separation between the particle and the membrane
-        min_iv_z_length = (radius1 + radius2) * 0.5 * (MINIMAL_SEPARATION_FACTOR - 1.0)
+        z_btf = math.sqrt(D2/D_tot)     # z back transform factor
 
         # get the coordinates of the iv relative to the system of the surface (or actually the shell)
         iv_x = structure2D.shape.unit_x * numpy.dot(iv, structure2D.shape.unit_x)
         iv_y = structure2D.shape.unit_y * numpy.dot(iv, structure2D.shape.unit_y)
 
+        iv_x_length = length(iv_x)
+        iv_y_length = length(iv_y)
+
         # reflect the coordinates in the unit_z direction back to the side of the membrane
         # where the domain is. Note that it's implied that the origin of the coordinate system lies in the
         # plane of the membrane
         iv_z_length = abs(numpy.dot(iv, unit_z))   # FIXME maybe first project the shell unit_z onto the 
                                                    # surface unit_z to prevent numerical problems?
-        # do the reverse scaling
-        iv_z_length = iv_z_length / math.sqrt(D_tot/D2)
+        # do the reverse scaling in z-direction
+        iv_z_length_btf = iv_z_length * z_btf
+
+        # The following is to avoid overlaps in case that the z-component of the IV is scaled down
+        # so much that it would cause a particle overlap.
+        # This can happen because the inner boundary in the space of transformed coordinates is not a
+        # prolate spheroid, as it should, but approximated by a sphere. This can lead to IV exit points
+        # within the prolate spheroid, i.e. within the sphere with radius sigma = radius1 + radius2 in
+        # the real space after inverse transform.  FIXME This works, but is still somewhat of a HACK!
+        min_iv_length = (radius1 + radius2) * MINIMAL_SEPARATION_FACTOR
+
+        if (iv_x_length*iv_x_length + iv_y_length*iv_y_length + iv_z_length_btf*iv_z_length_btf) < min_iv_length*min_iv_length:
 
-        # if the particle is overlapping with the membrane, make sure it doesn't
-        # IS THIS STILL NECESSARY?
-        if iv_z_length < min_iv_z_length:
-            iv_z_length = min_iv_z_length #* MINIMAL_SEPARATION_FACTOR
+            z_safety_factor_sq = (min_iv_length*min_iv_length - iv_x_length*iv_x_length - iv_y_length*iv_y_length) \
+                                 / (iv_z_length_btf*iv_z_length_btf)
 
-        iv_z = unit_z * iv_z_length
+            assert(z_safety_factor_sq >= 0.0)
+
+            iv_z_length_btf = math.sqrt( z_safety_factor_sq ) * iv_z_length_btf
+
+            log.debug('  z_safety_factor = %s' % str(math.sqrt(z_safety_factor_sq)) )
+
+        # TODO Also check for membrane overlapping?
+
+        # Construct the z-vector-component and the new position vectors
+        iv_z = unit_z * iv_z_length_btf
 
         pos1 = com - weight1 * (iv_x + iv_y)            # the new 2D particle position
         pos2 = com + weight2 * (iv_x + iv_y) + iv_z     # the new 3D particle position
 
+        log.debug('  new_iv = %s, new_iv_length = %s, iv_z_length = %s, iv_z_length_btf = %s' % (pos2-pos1, length(pos2-pos1), iv_z_length, iv_z_length_btf) )
+
         # Class method; so don't use self.(..)
         return pos1, pos2, structure2D.id, structure3D.id
 

From 5bda00c4d56e3d0a991115001b025c58ce3e56d4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 13 Dec 2012 18:07:00 +0100
Subject: [PATCH 1299/1541] Cleanup

---
 pair.py | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/pair.py b/pair.py
index b6bc1d41..33b86d2f 100644
--- a/pair.py
+++ b/pair.py
@@ -934,11 +934,7 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
     # here we assume that the com and iv are really in the structure and no adjustments have to be
     # made
     #
-    # structure3D is not used here but has to be passed because of the classmethod property
-
-        ### TESTING
-        log.debug('MixedPair2D3D: Entering draw_new_positions')
-        log.debug('  com = %s, iv = %s, length(iv) = %s, radius1 = %s, radius2 = %s' % (com, iv, length(iv), radius1, radius2) )        
+    # structure3D is not used here but has to be passed because of the classmethod property        
 
         D_tot = D1 + D2
         weight1 = D1 / D_tot
@@ -975,10 +971,10 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
                                  / (iv_z_length_btf*iv_z_length_btf)
 
             assert(z_safety_factor_sq >= 0.0)
+            log.warn('MixedPair2D3D: Applying z_safety_factor = %s to enlarge too small interparticle vector.' % str(math.sqrt(z_safety_factor_sq)) )
 
             iv_z_length_btf = math.sqrt( z_safety_factor_sq ) * iv_z_length_btf
-
-            log.debug('  z_safety_factor = %s' % str(math.sqrt(z_safety_factor_sq)) )
+            
 
         # TODO Also check for membrane overlapping?
 
@@ -988,8 +984,6 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure2D, struc
         pos1 = com - weight1 * (iv_x + iv_y)            # the new 2D particle position
         pos2 = com + weight2 * (iv_x + iv_y) + iv_z     # the new 3D particle position
 
-        log.debug('  new_iv = %s, new_iv_length = %s, iv_z_length = %s, iv_z_length_btf = %s' % (pos2-pos1, length(pos2-pos1), iv_z_length, iv_z_length_btf) )
-
         # Class method; so don't use self.(..)
         return pos1, pos2, structure2D.id, structure3D.id
 

From f5d12125eea33e9ebb5ff4f7799c702a7f433da4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Dec 2012 15:49:26 +0100
Subject: [PATCH 1300/1541] Unify rate argument name in reaction creation
 methods

---
 model.py | 64 ++++++++++++++++++++++++++++----------------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/model.py b/model.py
index fd31b402..56d1d49b 100644
--- a/model.py
+++ b/model.py
@@ -384,7 +384,7 @@ def create_creation_reaction_rule(product, k):
     rr['k'] = '%.16g' % k
     return rr
 
-def create_annihilation_reaction_rule(reactant1, reactant2, ka):
+def create_annihilation_reaction_rule(reactant1, reactant2, k):
     """Example: A + B -> 0.
 
     Arguments:
@@ -392,28 +392,28 @@ def create_annihilation_reaction_rule(reactant1, reactant2, ka):
             a Species.
         - reactant2
             a Species.
-        - ka
+        - k
             intrinsic reaction rate. Units: meters^3 per second. (Rough 
             order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s).
 
     The reactants should be in/on the same Region or Surface.
 
-    ka should be an *intrinsic* reaction rate. You can convert an 
-    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
+    k should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (kon) to an intrinsic reaction rate (k) with 
     the function utils.k_a(kon, kD), but only for reaction rules in 3D.
 
     By default an EGFRDSimulator will assume a repulsive 
-    bimolecular reaction rule (ka=0) for each possible combination of 
+    bimolecular reaction rule (k=0) for each possible combination of 
     reactants for which no bimolecular reaction rule is specified. 
     You can explicitly add these reaction rules to the model with the 
     method model.ParticleModel.set_all_repulsive.
 
     """
     rr = _gfrd.ReactionRule([reactant1, reactant2], [])
-    rr['k'] = '%.16g' % ka
+    rr['k'] = '%.16g' % k
     return rr
 
-def create_binding_reaction_rule(reactant1, reactant2, product, ka):
+def create_binding_reaction_rule(reactant1, reactant2, product, k):
     """Example: A + B -> C.
 
     Arguments:
@@ -423,7 +423,7 @@ def create_binding_reaction_rule(reactant1, reactant2, product, ka):
             a Species.
         - product
             a Species.
-        - ka
+        - k
             intrinsic reaction rate. Units: meters^3 per second. (Rough 
             order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
 
@@ -432,22 +432,22 @@ def create_binding_reaction_rule(reactant1, reactant2, product, ka):
 
     A binding reaction rule always has exactly one product.
 
-    ka should be an *intrinsic* reaction rate. You can convert an 
-    overall reaction rate (kon) to an intrinsic reaction rate (ka) with 
+    k should be an *intrinsic* reaction rate. You can convert an 
+    overall reaction rate (kon) to an intrinsic reaction rate (k) with 
     the function utils.k_a(kon, kD), but only for reaction rules in 3D.
 
     By default an EGFRDSimulator will assume a repulsive 
-    bimolecular reaction rule (ka=0) for each possible combination of 
+    bimolecular reaction rule (k=0) for each possible combination of 
     reactants for which no bimolecular reaction rule is specified. 
     You can explicitly add these reaction rules to the model with the 
     method model.ParticleModel.set_all_repulsive.
 
     """
     rr = _gfrd.ReactionRule([reactant1, reactant2], [product])
-    rr['k'] = '%.16g' % ka
+    rr['k'] = '%.16g' % k
     return rr
 
-def create_unbinding_reaction_rule(reactant, product1, product2, kd):
+def create_unbinding_reaction_rule(reactant, product1, product2, k):
     """Example: A -> B + C.
 
     Arguments:
@@ -457,7 +457,7 @@ def create_unbinding_reaction_rule(reactant, product1, product2, kd):
             a Species.
         - product2
             a Species.
-        - kd
+        - k
             intrinsic reaction rate. Units: per second. (Rough order of 
             magnitude: 1e-2 /s to 1e2 /s).
 
@@ -466,19 +466,19 @@ def create_unbinding_reaction_rule(reactant, product1, product2, kd):
 
     An unbinding reaction rule always has exactly two products.
 
-    kd should be an *intrinsic* reaction rate. You can convert an 
+    k should be an *intrinsic* reaction rate. You can convert an 
     overall reaction rate (koff) for this reaction rule to an intrinsic 
-    reaction rate (kd) with the function utils.k_d(koff, kon, kD) or 
+    reaction rate (k) with the function utils.k_d(koff, kon, kD) or 
     utils.k_d_using_ka(koff, ka, kD).
 
     An unbinding reaction rule defines a Poissonian process.
 
     """
     rr = _gfrd.ReactionRule([reactant], [product1, product2])
-    rr['k'] = '%.16g' % kd
+    rr['k'] = '%.16g' % k
     return rr
 
-def create_surface_absorption_reaction_rule(reactant, surface, ka):
+def create_surface_absorption_reaction_rule(reactant, surface, k):
     """Example: A + some_surface -> 0 + some_surface
 
     Arguments:
@@ -487,17 +487,17 @@ def create_surface_absorption_reaction_rule(reactant, surface, ka):
         - surface
             a Surface created with one of the functions 
             model.create_<>_surface.
-        - ka
+        - k
             intrinsic reaction rate. Units: meters^3 per second. (Rough 
             order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
 
-    ka should be an *intrinsic* reaction rate. No analytical expression 
+    k should be an *intrinsic* reaction rate. No analytical expression 
     is currently known to convert an overall reaction rate (kon) to 
-    an intrinsic reaction rate (ka) for surface binding or absorption 
+    an intrinsic reaction rate (k) for surface binding or absorption 
     reaction rules.
 
     By default an EGFRDSimulator will assume a repulsive 
-    surface binding reaction rule (ka=0) for each possible 
+    surface binding reaction rule (k=0) for each possible 
     combination of reactant and Surface for which no surface 
     binding or absorption reaction rule is specified. You can 
     explicitly add these reaction rules to the model by calling 
@@ -506,7 +506,7 @@ def create_surface_absorption_reaction_rule(reactant, surface, ka):
     """
     assert isinstance(reactant['structure'], _gfrd.BoxShapedRegion)
 
-def create_surface_binding_reaction_rule(reactant, surface, product, ka):
+def create_surface_binding_reaction_rule(reactant, surface, product, k):
     """Example: A + some_surface -> A_on_surface + some_surface
 
     Arguments:
@@ -521,19 +521,19 @@ def create_surface_binding_reaction_rule(reactant, surface, product, ka):
             Surface to the variable some_surface, then a valid product 
             Species would be:
             model.Species('A_on_surface', some_D, some_r, some_surface)
-        - ka
+        - k
             intrinsic reaction rate. Units: meters^3 per second. (Rough 
             order of magnitude: 1e-16 m^3/s to 1e-20 m^3/s)
 
     A surface binding reaction rule always has exactly one product.
 
-    ka should be an *intrinsic* reaction rate. No analytical expression 
+    k should be an *intrinsic* reaction rate. No analytical expression 
     is currently known to convert an overall reaction rate (kon) to 
-    an intrinsic reaction rate (ka) for surface binding or absorption 
+    an intrinsic reaction rate (k) for surface binding or absorption 
     reaction rules.
 
     By default an EGFRDSimulator will assume a repulsive 
-    surface binding reaction rule (ka=0) for each possible 
+    surface binding reaction rule (k=0) for each possible 
     combination of reactant and Surface for which no surface 
     binding or absorption reaction rule is specified. You can 
     explicitly add these reaction rules to the model by calling 
@@ -542,7 +542,7 @@ def create_surface_binding_reaction_rule(reactant, surface, product, ka):
     """
     assert product['structure'] == surface
 
-def create_surface_unbinding_reaction_rule(reactant, surface, product, kd):
+def create_surface_unbinding_reaction_rule(reactant, surface, product, k):
     """Example: A_on_surface + some_surface -> A + some_surface
 
     Arguments:
@@ -557,15 +557,15 @@ def create_surface_unbinding_reaction_rule(reactant, surface, product, kd):
             model.create_<>_surface.
         - product
             a Species in the "world" or in a Region.
-        - kd
+        - k
             intrinsic reaction rate. Units: per second. (Rough order of 
             magnitude: 1e-2 /s to 1e2 /s).
 
     A surface unbinding reaction rule always has exactly one product.
 
-    kd should be an *intrinsic* reaction rate. No analytical expression 
+    k should be an *intrinsic* reaction rate. No analytical expression 
     is currently known to convert an overall reaction rate (koff) to 
-    an intrinsic reaction rate (kd) for surface unbinding reaction rules.
+    an intrinsic reaction rate (k) for surface unbinding reaction rules.
 
     A surface unbinding reaction rule defines a Poissonian process.
 
@@ -573,7 +573,7 @@ def create_surface_unbinding_reaction_rule(reactant, surface, product, kd):
     assert reactant['structure'] == surface
 
 def create_membrane_traversal_reaction_rule(reactant, surface1, 
-                                            product, surface2, ka):
+                                            product, surface2, k):
     """
 
     """

From 4dad6bf44404797abd23bbe774ae6fe8f1c76c39 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Dec 2012 15:57:05 +0100
Subject: [PATCH 1301/1541] Remove some old TESTING statements

---
 shells.py | 38 +++-----------------------------------
 1 file changed, 3 insertions(+), 35 deletions(-)

diff --git a/shells.py b/shells.py
index ebfeaa4b..ba7074dd 100755
--- a/shells.py
+++ b/shells.py
@@ -1386,7 +1386,7 @@ def r1_eq(x):
             cos_angle_diff = math.cos(angle_diff)
             
             assert scale_center_to_shell >= shell_radius # should never fail
-            #ss_angle = math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius) ## TESTING Old version
+
             ss_angle = math.pi - math.asin(math.sin(angle_diff)*scale_center_to_shell/shell_radius)
             assert(ss_angle >= math.pi/2.0), 'EDGE_HITS_BARREL: ss_angle must be >= Pi/2.0; ss_angle = %s' % str(ss_angle)
                     # We know that this angle must be larger than Pi/2 here by construction of the problem
@@ -1766,12 +1766,6 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # initialize the parameters to start the scaling of the cylinder
         min_dr, min_dz_right, min_dz_left = self.apply_safety(min_dr, min_dz_right, min_dz_left)
         dr, dz_right, dz_left             = max_dr, max_dz_right, max_dz_left
-
-        ## TESTING
-        #assert dr >= min_dr and dz_right >= min_dz_right and dz_left >= min_dz_left, \
-               #'CylindricaltestShell dimensions smaller than the minimum, \
-                #dr = %s, dz_right = %s, dz_left = %s, min_dr = %s, min_dz_right = %s, min_dz_left = %s.' % \
-               #(dr, dz_right, dz_left, min_dr, min_dz_right, min_dz_left)
  
         # first check the maximum dr, dz_right, dz_left against the surfaces
         # NOTE: we assume that all relevant surfaces are cylindrical and parallel to the testCylinder
@@ -2554,15 +2548,6 @@ def __init__(self, single2D, single3D, geometrycontainer, domains):
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
         self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
 
-        ### TESTING TESTING TESTING remove when done
-        log.info(' MixedPair2D3D: Initalized shellscaling: scale_angle = %s, drdz  = %s' % (self.right_scalingangle, self.drdz_right))
-        log.info('                                         r0_right = %s, z0_right = %s' % (self.r0_right, self.z0_right))
-        log.info('                                         r0_left  = %s, z0_left  = %s' % (self.r0_left,  self.z0_left))
-
-        log.info('      min_dr_dzright_dzleft = %s' % str(self.get_min_dr_dzright_dzleft() ))
-        log.info('      max_dr_dzright_dzleft = %s' % str(self.get_max_dr_dzright_dzleft() ))
-
-
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2638,11 +2623,7 @@ def get_max_dr_dzright_dzleft(self):
         # now adjust dz_right such that they obey the scaling laws and are still within the search_radius
         # We assume that dz_right needs to be adjusted to dr and not the other way around since the cylinder is
         # always a bit flatter.
-        dz_right = self.z_right(dr)        
-        ## Debug output for TESTING
-        #log.debug( "max_dr=%s, max_dz_right=%s, max_dz_left=%s" % (dr, dz_right, dz_left) )
-        #log.debug( "min_dist_proj_to_edge=%s" % str(self.min_dist_proj_to_edge) )
-        #assert dr > dz_right   ## Removed for TESTING
+        dz_right = self.z_right(dr)
 
         return dr, dz_right, dz_left
 
@@ -2661,8 +2642,6 @@ def z_right(self, r_right):
         D_3D = self.particle3D.D
 
         # calculate a_r such that the expected first-passage for the CoM and IV are equal        
-        #sqrt_DRDr_2D = math.sqrt( 2.0/3.0 * self.D_R/D_2D )  # TESTING
-        #sqrt_DRDr_3D = math.sqrt( 2.0/3.0 * self.D_R/D_3D )
         a_r_2D = (r_right - radius2D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2D/self.D_tot) )
         a_r_3D = (r_right - radius3D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_3D/self.D_tot) )        
         # take the smaller a_r that, if entered in the function for r below, would lead to this r_right
@@ -2670,14 +2649,6 @@ def z_right(self, r_right):
 
         z_right = (a_r/self.get_scaling_factor()) + radius3D
 
-        ## Debug output for TESTING
-        #log.debug( " a_r_2D=%s, a_r_3D=%s, z_right=%s, r_right=%s" % (a_r_2D, a_r_3D, z_right, r_right))
-        #log.debug('r_right= %s, r_right(z_right)=%s, z_right=%s' % (r_right, self.r_right(z_right), z_right) )
-
-        #assert feq(self.r_right(z_right), r_right), 'Inconsistent z_right function in MixedPair2D3DtestShell: \
-                                                     #r_right= %s, r_right(z_right)=%s, z_right=%s' % \
-                                                     #(r_right, self.r_right(z_right), z_right)
-
         if r_right < 0.0 or z_right <0.0:
             log.warning('Negative cylinder dimensions in MixedPair2D3DtestShell: z_right= %s, r_right=%s' % (z_right, r_right) )
 
@@ -2721,10 +2692,7 @@ def r_right(self, z_right):
         # the estimated a_R value for the same first passage time
         r_right = a_R + iv_max
 
-        ### TESTING
-        log.info('MixedPair2D3DtestShell: z_right= %s, z_right(r_right)=%s, r_right=%s' % (z_right, self.z_right(r_right), r_right) )
-
-        if r_right < 0.0 or z_right <0.0:
+        if r_right < 0.0 or z_right <0.0:  ### TESTING; remove when stable
             log.warning('Negative cylinder dimensions in MixedPair2D3DtestShell: z_right= %s, r_right=%s' % (z_right, r_right) )
 
         assert feq(self.z_right(r_right), z_right), 'Inconsistent r_right function in MixedPair2D3DtestShell: \

From bc02d005a49ae16e707e99dd2adf5ad9ce305ffe Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 14 Dec 2012 15:59:34 +0100
Subject: [PATCH 1302/1541] comment

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index ba7074dd..78eb388b 100755
--- a/shells.py
+++ b/shells.py
@@ -2692,7 +2692,7 @@ def r_right(self, z_right):
         # the estimated a_R value for the same first passage time
         r_right = a_R + iv_max
 
-        if r_right < 0.0 or z_right <0.0:  ### TESTING; remove when stable
+        if r_right < 0.0 or z_right <0.0:  ### TESTING; remove when stable (or should we keep it?)
             log.warning('Negative cylinder dimensions in MixedPair2D3DtestShell: z_right= %s, r_right=%s' % (z_right, r_right) )
 
         assert feq(self.z_right(r_right), z_right), 'Inconsistent r_right function in MixedPair2D3DtestShell: \

From 272c974f2a7bfc8481fe95e70f97890e0c3704cf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 18 Dec 2012 11:53:34 +0100
Subject: [PATCH 1303/1541] Fix an assert in MixedPair2D3D that fails if 2D and
 3D diff. const. are of comparable magnitude

The assert itself is not a necessary condition to be met. It checked for
whether the z-rescaled IV (math.) domain fits into the cyl. shell of the
mixed pair. This is however not necessary because lengths will be transformed
back into the shell via dividing by the scaling factor in the end.
---
 pair.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pair.py b/pair.py
index 33b86d2f..3611fe49 100644
--- a/pair.py
+++ b/pair.py
@@ -921,10 +921,10 @@ def determine_radii(self):
                        FORMAT_DOUBLE % a_R, FORMAT_DOUBLE % tR,
                        FORMAT_DOUBLE % (tr-tR) ))
 
-#        assert feq(tr, tR), 'estimate first passage times were not equal'
+#        assert feq(tr, tR), 'estimate first passage times were not equal'  ## FIXME
 
-        # Some checks that shall never fail
-        assert (self.sigma < a_r) and (a_r < 2.0*shell_half_length)
+        # Some checks that shall never fail        
+        assert (self.sigma < a_r) and (a_r < 2.0*shell_half_length * self.z_scaling_factor)
         assert (0 < a_R) and (a_R < shell_radius)
 
         return a_R, a_r

From 27e5de5f4cb16f7475d0147621cb27a2d2f2bf88 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 20 Dec 2012 15:34:55 +0100
Subject: [PATCH 1304/1541] Increase minimal z-size of MixedPair2D3D shells to
 1.5*length(IV) to prevent series of short exits through the absorbing
 boundary

---
 pair.py   | 7 +++++++
 shells.py | 4 +++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/pair.py b/pair.py
index 3611fe49..1c288bae 100644
--- a/pair.py
+++ b/pair.py
@@ -109,11 +109,17 @@ def draw_com_escape_or_iv_event_time_tuple(self, r0):
         """Returns a (event time, event type, reactingsingle=None) tuple.
         
         """
+        log.debug('*** Entering draw_com_escape_or_iv_event_time_tuple')   ### TESTING
+        log.debug('*** draw com time')   ### TESTING
         dt_com = draw_time_wrapper(self.com_greens_function())
+        log.debug('*** draw iv time')   ### TESTING
         dt_iv = draw_time_wrapper(self.iv_greens_function(r0))  # uses the full solution to draw IV first event time
+        log.debug('*** Done.')   ### TESTING
         if dt_com < dt_iv:
+            log.debug('*** dt_com < dt_iv')   ### TESTING
             return dt_com, EventType.COM_ESCAPE, None
         else:
+            log.debug('*** dt_iv < dt_com')   ### TESTING
             # Note: we are not calling pair.draw_iv_event_type yet, but 
             # postpone it to the very last minute (when this event is 
             # executed in fire_pair). So IV_EVENT can still be an iv 
@@ -124,6 +130,7 @@ def draw_single_reaction_time_tuple(self):
         """Return a (reaction time, event type, reactingsingle)-tuple.
 
         """
+        log.debug('*** Entering draw_single_reaction_time_tuple')   ### TESTING
         dt_reaction1, event_type1 = self.single1.draw_reaction_time_tuple()
         dt_reaction2, event_type2 = self.single2.draw_reaction_time_tuple()
         if dt_reaction1 < dt_reaction2:
diff --git a/shells.py b/shells.py
index 78eb388b..a028f9f4 100755
--- a/shells.py
+++ b/shells.py
@@ -2583,10 +2583,12 @@ def get_min_dr_dzright_dzleft(self):
 
 
         ### calculate the minimal height z_right1 of the shell including burst radius
-        dz_right1 = self.iv_z_minimum
+        dz_right1 = 1.5 * self.iv_z_minimum
         # with the accompanying radius r1
         dr_1 = self.r_right(dz_right1)
 
+  
+
 
 #        ### calculate the minimal radius r2 of the shell including the burst radius
 #        # First calculate the minimal size of the iv shell (r0 is at outer boundary)

From 4c386f36942f0bd81d37c64cee711b410ccc78ed Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 20 Dec 2012 15:36:16 +0100
Subject: [PATCH 1305/1541] Remove debug lines

---
 pair.py | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/pair.py b/pair.py
index 1c288bae..3611fe49 100644
--- a/pair.py
+++ b/pair.py
@@ -109,17 +109,11 @@ def draw_com_escape_or_iv_event_time_tuple(self, r0):
         """Returns a (event time, event type, reactingsingle=None) tuple.
         
         """
-        log.debug('*** Entering draw_com_escape_or_iv_event_time_tuple')   ### TESTING
-        log.debug('*** draw com time')   ### TESTING
         dt_com = draw_time_wrapper(self.com_greens_function())
-        log.debug('*** draw iv time')   ### TESTING
         dt_iv = draw_time_wrapper(self.iv_greens_function(r0))  # uses the full solution to draw IV first event time
-        log.debug('*** Done.')   ### TESTING
         if dt_com < dt_iv:
-            log.debug('*** dt_com < dt_iv')   ### TESTING
             return dt_com, EventType.COM_ESCAPE, None
         else:
-            log.debug('*** dt_iv < dt_com')   ### TESTING
             # Note: we are not calling pair.draw_iv_event_type yet, but 
             # postpone it to the very last minute (when this event is 
             # executed in fire_pair). So IV_EVENT can still be an iv 
@@ -130,7 +124,6 @@ def draw_single_reaction_time_tuple(self):
         """Return a (reaction time, event type, reactingsingle)-tuple.
 
         """
-        log.debug('*** Entering draw_single_reaction_time_tuple')   ### TESTING
         dt_reaction1, event_type1 = self.single1.draw_reaction_time_tuple()
         dt_reaction2, event_type2 = self.single2.draw_reaction_time_tuple()
         if dt_reaction1 < dt_reaction2:

From e93310e3346d76cd052e5ff920f29464e3d9cab4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 20 Dec 2012 20:03:04 +0100
Subject: [PATCH 1306/1541] Warn user when adding a reaction rule with zero
 rate

---
 model.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/model.py b/model.py
index 56d1d49b..0570121f 100644
--- a/model.py
+++ b/model.py
@@ -24,6 +24,8 @@
     'create_double_sided_planar_surface',
     ]
 
+import logging
+log = logging.getLogger('ecell')
 
 # Define _gfrd docstrings here, much easier to format than in C++.
 # TODO These functions should be moved to gfrdbase.py because structures are no longer a part of the model,
@@ -288,6 +290,9 @@ def add_reaction_rule(self, reaction_rule):
                 model.create_<>_reaction_rule.
 
         """
+        if __debug__ and reaction_rule['k'] == 0:
+            log.warn('Warning: adding reaction rule with zero reaction rate. That creates unnecessary overhead and should be avoided.')
+
         self.network_rules.add_reaction_rule(reaction_rule)
 
     def set_all_repulsive(self):
@@ -342,7 +347,7 @@ def create_unimolecular_reaction_rule(reactant, product, k):
 
     A unimolecular reaction rule defines a Poissonian process.
 
-    """
+    """        
     rr = _gfrd.ReactionRule([reactant], [product])
     rr['k'] = '%.16g' % k
     return rr
@@ -379,7 +384,6 @@ def create_creation_reaction_rule(product, k):
     A creation reaction rule defines a Poissonian process.
 
     """
-
     rr = _gfrd.ReactionRule([], [product])
     rr['k'] = '%.16g' % k
     return rr

From 65fbfb8b121127f6e84d6f89055b125d0a2f9f00 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 20 Dec 2012 20:04:34 +0100
Subject: [PATCH 1307/1541] Debug statements to track down the zero-rate bug

---
 newBDPropagator.hpp | 30 ++++++++++++++++++++++--------
 1 file changed, 22 insertions(+), 8 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index bc677b8b..6e7f45a5 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -135,7 +135,7 @@ class newBDPropagator
             ++rejected_move_count_;
             return true;
         }
-        
+        LOG_DEBUG(("Continue..." ));   // TESTING
 
         /*** 3. COLLECT INFO ***/
         // Get info of the particle
@@ -149,6 +149,7 @@ class newBDPropagator
         structure_id_type               new_structure_id( old_struct_id );
 
         /*** 2. DISPLACEMENT TRIAL ***/
+        LOG_DEBUG(("Displacement trial..." ));   // TESTING
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particle bounces, and is returned
            to it's original position. For a particle with D = 0, new_pos = old_pos 
@@ -167,6 +168,7 @@ class newBDPropagator
         }
 
         /*** 4. CHECK OVERLAPS ***/
+        LOG_DEBUG(("Check overlaps..." ));   // TESTING
         bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
@@ -199,6 +201,7 @@ class newBDPropagator
         }
          
         /*** 5. TREAT BOUNCING => CHECK FOR POTENTIAL REACTIONS / INTERACTIONS ***/
+        LOG_DEBUG(("Treat bouncing..." ));   // TESTING
         /* If particle is bounced, restore old position and check reaction_volume for reaction partners at old_pos. */
         if(bounced)
         {
@@ -228,6 +231,8 @@ class newBDPropagator
         
 
         /*** 6. REACTIONS & INTERACTIONS ***/
+        LOG_DEBUG(("Reaction trials..." ));   // TESTING
+        LOG_DEBUG(("   with structures..." ));   // TESTING
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
         Real accumulated_prob (0);
@@ -309,6 +314,7 @@ class newBDPropagator
         }
         
         //// 6.1 REACTIONS WITH OTHER PARTICLES
+        LOG_DEBUG(("   with particles..." ));   // TESTING
         /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
         prob_increase = 0;
@@ -372,6 +378,7 @@ class newBDPropagator
         }
         
         /*** 7. DEFAULT CASE: ACCEPT DISPLACEMENT TRIAL ***/
+        LOG_DEBUG(("Default: Accept displacement..." ));   // TESTING
         // If the particle did neither react, interact or bounce, update it to it's new position.
         if(!bounced)
         {   
@@ -381,19 +388,23 @@ class newBDPropagator
                                                                      new_structure_id,
                                                                      pp_species.D(),
                                                                      pp_species.v()) );
-                
-            if (vc_)
+                                                                     
+            LOG_DEBUG(("Defined particle to update" ));   // TESTING    
+            if (vc_)            
             {
+                LOG_DEBUG(("Volume clearer present" ));   // TESTING    
                 if (!(*vc_)(particle_to_update.second.shape(), particle_to_update.first))
                 {
                     log_.info("propagation move rejected.");
                     return true;
                 }
             }
-                
+
+            LOG_DEBUG(("Calling update_particle" ));   // TESTING
             tx_.update_particle(particle_to_update);
         }
 
+        LOG_DEBUG(("Done. Return true" ));   // TESTING
         return true;
     }
 
@@ -416,16 +427,18 @@ class newBDPropagator
     bool attempt_single_reaction(particle_id_pair const& pp)
     // Handles all monomolecular reactions
     {
+        LOG_DEBUG(("Attempting single reaction with species %s",
+                    boost::lexical_cast<std::string>(pp.second.sid()).c_str() ));       // TESTING
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
         if (::size(rules) == 0)
         {
             return false;
         }
-
+     
         const Real rnd(rng_() / dt_);
         Real k_cumm = 0.;
 
-        // select one of the available reaction rules that led to the monomolecular reaction
+        // select one of the available reaction rules that led to the monomolecular reaction        
         for (typename boost::range_const_iterator<reaction_rules>::type
                 i(boost::begin(rules)), e(boost::end(rules)); i != e; ++i)
         {
@@ -435,7 +448,7 @@ class newBDPropagator
             if (k_cumm > rnd)
             // We have found the reaction rule that is in effect
             {
-                // get the products
+                // get the products                
                 typename reaction_rule_type::species_id_range products(reaction_rule.get_products());
 
                 switch (::size(products))
@@ -747,7 +760,8 @@ class newBDPropagator
                 return true;
             }
         }
-        // No monomolecular reaction has taken place. 
+        // No monomolecular reaction has taken place.
+        LOG_DEBUG(("Returning false ..." ));   // TESTING
         return false;
     }
 

From 557ea9b1f0f07afb5fb5e4bf637b79c380ef2317 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 20 Dec 2012 20:13:45 +0100
Subject: [PATCH 1308/1541] By default do not add reactions with zero rate, but
 allow the user to override this, warning when doing so

---
 model.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/model.py b/model.py
index 0570121f..c8d17f05 100644
--- a/model.py
+++ b/model.py
@@ -281,7 +281,7 @@ def __init__(self, world_size):
 #    def get_structure(self, id): 
 #        return self.structures[id]
 
-    def add_reaction_rule(self, reaction_rule):
+    def add_reaction_rule(self, reaction_rule, safe=True):
         """Add a ReactionRule to the ParticleModel.
 
         Argument:
@@ -289,11 +289,19 @@ def add_reaction_rule(self, reaction_rule):
                 a ReactionRule created by one of the functions
                 model.create_<>_reaction_rule.
 
-        """
-        if __debug__ and reaction_rule['k'] == 0:
+        """        
+        if safe and reaction_rule['k'] == 0:
+
+            log.warn('Warning: Omitting to add reaction rule with zero reaction rate..')
+
+        else if reaction_rule['k'] == 0:
+
             log.warn('Warning: adding reaction rule with zero reaction rate. That creates unnecessary overhead and should be avoided.')
+            self.network_rules.add_reaction_rule(reaction_rule)
+
+        else:
 
-        self.network_rules.add_reaction_rule(reaction_rule)
+            self.network_rules.add_reaction_rule(reaction_rule)
 
     def set_all_repulsive(self):
         """Set all 'other' possible ReactionRules to be repulsive.

From f7bfa8588e28f41015a58c94807af23705dd2b4d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 20 Dec 2012 20:24:07 +0100
Subject: [PATCH 1309/1541] Fixes

---
 model.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/model.py b/model.py
index c8d17f05..1476eba7 100644
--- a/model.py
+++ b/model.py
@@ -289,14 +289,14 @@ def add_reaction_rule(self, reaction_rule, safe=True):
                 a ReactionRule created by one of the functions
                 model.create_<>_reaction_rule.
 
-        """        
-        if safe and reaction_rule['k'] == 0:
+        """
+        if safe and float(reaction_rule['k']) == 0.0:
 
-            log.warn('Warning: Omitting to add reaction rule with zero reaction rate..')
+            log.warn('Omitting to add reaction rule with zero reaction rate..')
 
-        else if reaction_rule['k'] == 0:
+        elif float(reaction_rule['k']) == 0.0:
 
-            log.warn('Warning: adding reaction rule with zero reaction rate. That creates unnecessary overhead and should be avoided.')
+            log.warn('Adding reaction rule with zero reaction rate. That creates unnecessary overhead and should be avoided.')
             self.network_rules.add_reaction_rule(reaction_rule)
 
         else:

From 0328aa360b6e129625b89ece4cc4fb6406510077 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 11:21:07 +0100
Subject: [PATCH 1310/1541] More debug output

---
 newBDPropagator.hpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 6e7f45a5..8cb6927a 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -430,6 +430,8 @@ class newBDPropagator
         LOG_DEBUG(("Attempting single reaction with species %s",
                     boost::lexical_cast<std::string>(pp.second.sid()).c_str() ));       // TESTING
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
+        
+        LOG_DEBUG(("size(rules)=%f", (double)::size(rules) ))   // TESTING
         if (::size(rules) == 0)
         {
             return false;

From 6fc70f59c445c4dc643d6cb5d4c26863321272d1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 11:57:46 +0100
Subject: [PATCH 1311/1541] And even more

---
 binding/MatrixSpace.hpp |  5 +++++
 multi.py                | 14 ++++++++++++++
 newBDPropagator.hpp     |  6 +++---
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/binding/MatrixSpace.hpp b/binding/MatrixSpace.hpp
index 04052603..7cb74a47 100644
--- a/binding/MatrixSpace.hpp
+++ b/binding/MatrixSpace.hpp
@@ -10,6 +10,8 @@
 #include <string>
 #include <vector>
 
+#include <iostream>
+
 #include <boost/shared_ptr.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/type_traits.hpp>
@@ -369,11 +371,14 @@ class MatrixSpaceExtras: public MatrixSpaceExtrasBase
 
         typename Builders::result_type retval(alloc);
 
+        std::cerr << "get_neighbors_within_radius_cyclic: invoking build_neighbors_array()" << std::endl;
         Builders::build_neighbors_array_cyclic(retval, impl,
                 ::Sphere<length_type>( pos, radius ) );
 
         // take over the ownership of the arrays to the Numpy facility
+        std::cerr << "get_neighbors_within_radius_cyclic: giveup_ownership()" << std::endl;
         alloc.giveup_ownership();
+        std::cerr << "get_neighbors_within_radius_cyclic: return" << std::endl;
         return retval;
     }
 
diff --git a/multi.py b/multi.py
index bca174ee..67d4e268 100644
--- a/multi.py
+++ b/multi.py
@@ -92,24 +92,38 @@ def __call__(self, ri):
 
         class clear_volume(object):
             def __init__(self, outer):
+                log.debug('Init clear_volume')  ### TESTING
                 self.outer_ = outer
+                log.debug('  clear_volume.outer_ = %s' % str(self.outer_))  ### TESTING
 
             def __call__(self, shape, ignore0, ignore1=None):
+                log.debug('Call to clear_volume()')  ### TESTING
+                test_wr = self.outer_.sphere_container.get_neighbors_within_radius(
+                               shape.position, -(shape.radius + self.outer_.reaction_length) )
+                log_debug('  determined test_wr')       ### TESTING
+                log_debug('  test_wr = %s' % str(test_wr))      ### TESTING
+
                 within_radius = bool(
                     self.outer_.sphere_container.get_neighbors_within_radius(
                         shape.position, -(shape.radius + self.outer_.reaction_length) ))
+                log.debug('  determined within_radius')  ### TESTING
                 if not within_radius:
+                    log.debug('  not within_radius')  ### TESTING
                     main = self.outer_.main()
                     if self.outer_.last_event == EventType.MULTI_DIFFUSION: #None:
                         self.outer_.last_event = EventType.MULTI_ESCAPE
                     main.burst_volume(shape.position, shape.radius, 
                                       ignore=[self.outer_.domain_id, ])
                     if ignore1 is None:
+                        log.debug('  ignore1 = %s' % str(ignore1) )  ### TESTING
                         return not main.world.check_overlap(
                             (shape.position, shape.radius), ignore0)
                     else:
+                        log.debug('  ignore1 = %s' % str(ignore1) )  ### TESTING
                         return not main.world.check_overlap(
                             (shape.position, shape.radius), ignore0, ignore1)
+
+                log.debug('  return True' )  ### TESTING
                 return True
 
         cr = check_reaction()
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 8cb6927a..f96193ab 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -392,7 +392,7 @@ class newBDPropagator
             LOG_DEBUG(("Defined particle to update" ));   // TESTING    
             if (vc_)            
             {
-                LOG_DEBUG(("Volume clearer present" ));   // TESTING    
+                LOG_DEBUG(("Volume clearer present" ));   // TESTING
                 if (!(*vc_)(particle_to_update.second.shape(), particle_to_update.first))
                 {
                     log_.info("propagation move rejected.");
@@ -431,8 +431,8 @@ class newBDPropagator
                     boost::lexical_cast<std::string>(pp.second.sid()).c_str() ));       // TESTING
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
         
-        LOG_DEBUG(("size(rules)=%f", (double)::size(rules) ))   // TESTING
-        if (::size(rules) == 0)
+        LOG_DEBUG(("size(rules)=%u", (int)::size(rules) ));   // TESTING
+        if ((int)::size(rules) == 0)
         {
             return false;
         }

From 34439e63826ca54d49e196471e173de89404258e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 15:10:49 +0100
Subject: [PATCH 1312/1541] Convert a boost-python allocated list to Python
 list instead of bool to prevent occasional gory segfault problems

---
 multi.py | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/multi.py b/multi.py
index 67d4e268..5caa0e2e 100644
--- a/multi.py
+++ b/multi.py
@@ -98,16 +98,18 @@ def __init__(self, outer):
 
             def __call__(self, shape, ignore0, ignore1=None):
                 log.debug('Call to clear_volume()')  ### TESTING
-                test_wr = self.outer_.sphere_container.get_neighbors_within_radius(
+                log.debug('  test call')   ### TESTING
+                within_radius = self.outer_.sphere_container.get_neighbors_within_radius(
                                shape.position, -(shape.radius + self.outer_.reaction_length) )
-                log_debug('  determined test_wr')       ### TESTING
-                log_debug('  test_wr = %s' % str(test_wr))      ### TESTING
-
-                within_radius = bool(
-                    self.outer_.sphere_container.get_neighbors_within_radius(
-                        shape.position, -(shape.radius + self.outer_.reaction_length) ))
-                log.debug('  determined within_radius')  ### TESTING
-                if not within_radius:
+                log.debug('  determined test_wr')       ### TESTING
+                log.debug('  test_wr = %s' % str(list(test_wr)))      ### TESTING                
+
+                if not list(test_wr) == []:
+                    log.debug('  test_wr is not empty')
+
+                if list(within_radius) == []:
+                   # Convert to list first because of tricky C++/Python binding here
+                   # Type casting bool(within_radius) caused segfaults in some simulations                                                
                     log.debug('  not within_radius')  ### TESTING
                     main = self.outer_.main()
                     if self.outer_.last_event == EventType.MULTI_DIFFUSION: #None:

From a5adc8c94bee8a444a346a5c033a93a45e7a42c2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 15:16:58 +0100
Subject: [PATCH 1313/1541] Define destructor for pyarray_backed_allocator for
 completeness

---
 peer/numpy/pyarray_backed_allocator.hpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/peer/numpy/pyarray_backed_allocator.hpp b/peer/numpy/pyarray_backed_allocator.hpp
index 70fe0b82..f21aeb8c 100644
--- a/peer/numpy/pyarray_backed_allocator.hpp
+++ b/peer/numpy/pyarray_backed_allocator.hpp
@@ -3,6 +3,7 @@
 
 #include <cstddef>
 #include <limits>
+#include <iostream>
 #include <numpy/arrayobject.h>
 
 namespace peer {
@@ -117,6 +118,10 @@ namespace util
 
         pyarray_backed_allocator(const pyarray_backed_allocator_base& that)
             : pyarray_backed_allocator_base(that) {}
+            
+        ~pyarray_backed_allocator()
+        {
+        }
 
         pointer address(reference r) const
         {

From ecd1c1f63df9234e9995d97dfe73f356609797b0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 15:17:34 +0100
Subject: [PATCH 1314/1541] Cleanup

---
 binding/MatrixSpace.hpp |  4 +---
 newBDPropagator.hpp     | 16 ----------------
 2 files changed, 1 insertion(+), 19 deletions(-)

diff --git a/binding/MatrixSpace.hpp b/binding/MatrixSpace.hpp
index 7cb74a47..6e609f27 100644
--- a/binding/MatrixSpace.hpp
+++ b/binding/MatrixSpace.hpp
@@ -371,14 +371,12 @@ class MatrixSpaceExtras: public MatrixSpaceExtrasBase
 
         typename Builders::result_type retval(alloc);
 
-        std::cerr << "get_neighbors_within_radius_cyclic: invoking build_neighbors_array()" << std::endl;
         Builders::build_neighbors_array_cyclic(retval, impl,
                 ::Sphere<length_type>( pos, radius ) );
 
         // take over the ownership of the arrays to the Numpy facility
-        std::cerr << "get_neighbors_within_radius_cyclic: giveup_ownership()" << std::endl;
         alloc.giveup_ownership();
-        std::cerr << "get_neighbors_within_radius_cyclic: return" << std::endl;
+        
         return retval;
     }
 
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index f96193ab..74e7c286 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -135,7 +135,6 @@ class newBDPropagator
             ++rejected_move_count_;
             return true;
         }
-        LOG_DEBUG(("Continue..." ));   // TESTING
 
         /*** 3. COLLECT INFO ***/
         // Get info of the particle
@@ -149,7 +148,6 @@ class newBDPropagator
         structure_id_type               new_structure_id( old_struct_id );
 
         /*** 2. DISPLACEMENT TRIAL ***/
-        LOG_DEBUG(("Displacement trial..." ));   // TESTING
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particle bounces, and is returned
            to it's original position. For a particle with D = 0, new_pos = old_pos 
@@ -168,7 +166,6 @@ class newBDPropagator
         }
 
         /*** 4. CHECK OVERLAPS ***/
-        LOG_DEBUG(("Check overlaps..." ));   // TESTING
         bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
@@ -201,7 +198,6 @@ class newBDPropagator
         }
          
         /*** 5. TREAT BOUNCING => CHECK FOR POTENTIAL REACTIONS / INTERACTIONS ***/
-        LOG_DEBUG(("Treat bouncing..." ));   // TESTING
         /* If particle is bounced, restore old position and check reaction_volume for reaction partners at old_pos. */
         if(bounced)
         {
@@ -231,8 +227,6 @@ class newBDPropagator
         
 
         /*** 6. REACTIONS & INTERACTIONS ***/
-        LOG_DEBUG(("Reaction trials..." ));   // TESTING
-        LOG_DEBUG(("   with structures..." ));   // TESTING
         /* Attempt a reaction (and/or interaction) with all the particles (and/or a surface) that 
            are/is inside the reaction volume. */
         Real accumulated_prob (0);
@@ -314,7 +308,6 @@ class newBDPropagator
         }
         
         //// 6.1 REACTIONS WITH OTHER PARTICLES
-        LOG_DEBUG(("   with particles..." ));   // TESTING
         /* Now attempt a reaction with all particles inside the reaction volume. */
         j = 0;
         prob_increase = 0;
@@ -378,7 +371,6 @@ class newBDPropagator
         }
         
         /*** 7. DEFAULT CASE: ACCEPT DISPLACEMENT TRIAL ***/
-        LOG_DEBUG(("Default: Accept displacement..." ));   // TESTING
         // If the particle did neither react, interact or bounce, update it to it's new position.
         if(!bounced)
         {   
@@ -389,10 +381,8 @@ class newBDPropagator
                                                                      pp_species.D(),
                                                                      pp_species.v()) );
                                                                      
-            LOG_DEBUG(("Defined particle to update" ));   // TESTING    
             if (vc_)            
             {
-                LOG_DEBUG(("Volume clearer present" ));   // TESTING
                 if (!(*vc_)(particle_to_update.second.shape(), particle_to_update.first))
                 {
                     log_.info("propagation move rejected.");
@@ -400,11 +390,9 @@ class newBDPropagator
                 }
             }
 
-            LOG_DEBUG(("Calling update_particle" ));   // TESTING
             tx_.update_particle(particle_to_update);
         }
 
-        LOG_DEBUG(("Done. Return true" ));   // TESTING
         return true;
     }
 
@@ -427,11 +415,8 @@ class newBDPropagator
     bool attempt_single_reaction(particle_id_pair const& pp)
     // Handles all monomolecular reactions
     {
-        LOG_DEBUG(("Attempting single reaction with species %s",
-                    boost::lexical_cast<std::string>(pp.second.sid()).c_str() ));       // TESTING
         reaction_rules const& rules(rules_.query_reaction_rule(pp.second.sid()));
         
-        LOG_DEBUG(("size(rules)=%u", (int)::size(rules) ));   // TESTING
         if ((int)::size(rules) == 0)
         {
             return false;
@@ -763,7 +748,6 @@ class newBDPropagator
             }
         }
         // No monomolecular reaction has taken place.
-        LOG_DEBUG(("Returning false ..." ));   // TESTING
         return false;
     }
 

From 7daa044504e4707ea84fa1bb8ec19e337750e785 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 15:17:55 +0100
Subject: [PATCH 1315/1541] Treat zero-rates properly in load routine

---
 loadsave.py | 10 ++++++----
 model.py    |  3 +++
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index acd2ef64..3e99ca4d 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -636,10 +636,12 @@ def load_state(filename):
         # and to the internal rules dictionary
         if rule:
             
-            m.add_reaction_rule(rule)
-            rules_dict[name_to_int(sectionname)] = rule
-            if __debug__:
-                log.info('  Added %s, type = %s' % (rule, rtype) )
+            added = m.add_reaction_rule(rule)
+            
+            if added:
+                rules_dict[name_to_int(sectionname)] = rule
+                if __debug__:
+                    log.info('  Added %s, type = %s' % (rule, rtype) )
 
     if __debug__:
         log.info('  rules_dict = %s' % str(rules_dict) )
diff --git a/model.py b/model.py
index 1476eba7..e6905a0b 100644
--- a/model.py
+++ b/model.py
@@ -293,15 +293,18 @@ def add_reaction_rule(self, reaction_rule, safe=True):
         if safe and float(reaction_rule['k']) == 0.0:
 
             log.warn('Omitting to add reaction rule with zero reaction rate..')
+            return 0
 
         elif float(reaction_rule['k']) == 0.0:
 
             log.warn('Adding reaction rule with zero reaction rate. That creates unnecessary overhead and should be avoided.')
             self.network_rules.add_reaction_rule(reaction_rule)
+            return 1
 
         else:
 
             self.network_rules.add_reaction_rule(reaction_rule)
+            return 1
 
     def set_all_repulsive(self):
         """Set all 'other' possible ReactionRules to be repulsive.

From 726c263fcc42150632adfe09669e3a6da4fcfdc9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 15:18:35 +0100
Subject: [PATCH 1316/1541] Further cleanup

---
 multi.py | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/multi.py b/multi.py
index 5caa0e2e..a67df435 100644
--- a/multi.py
+++ b/multi.py
@@ -92,40 +92,28 @@ def __call__(self, ri):
 
         class clear_volume(object):
             def __init__(self, outer):
-                log.debug('Init clear_volume')  ### TESTING
                 self.outer_ = outer
-                log.debug('  clear_volume.outer_ = %s' % str(self.outer_))  ### TESTING
 
             def __call__(self, shape, ignore0, ignore1=None):
-                log.debug('Call to clear_volume()')  ### TESTING
-                log.debug('  test call')   ### TESTING
+
                 within_radius = self.outer_.sphere_container.get_neighbors_within_radius(
                                shape.position, -(shape.radius + self.outer_.reaction_length) )
-                log.debug('  determined test_wr')       ### TESTING
-                log.debug('  test_wr = %s' % str(list(test_wr)))      ### TESTING                
-
-                if not list(test_wr) == []:
-                    log.debug('  test_wr is not empty')
 
                 if list(within_radius) == []:
                    # Convert to list first because of tricky C++/Python binding here
-                   # Type casting bool(within_radius) caused segfaults in some simulations                                                
-                    log.debug('  not within_radius')  ### TESTING
+                   # Type casting bool(within_radius) caused segfaults in some simulations
                     main = self.outer_.main()
                     if self.outer_.last_event == EventType.MULTI_DIFFUSION: #None:
                         self.outer_.last_event = EventType.MULTI_ESCAPE
                     main.burst_volume(shape.position, shape.radius, 
                                       ignore=[self.outer_.domain_id, ])
                     if ignore1 is None:
-                        log.debug('  ignore1 = %s' % str(ignore1) )  ### TESTING
                         return not main.world.check_overlap(
                             (shape.position, shape.radius), ignore0)
                     else:
-                        log.debug('  ignore1 = %s' % str(ignore1) )  ### TESTING
                         return not main.world.check_overlap(
                             (shape.position, shape.radius), ignore0, ignore1)
 
-                log.debug('  return True' )  ### TESTING
                 return True
 
         cr = check_reaction()

From c0a5a992e343521133f3e0cf8111ab31175204c2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 21 Dec 2012 19:09:38 +0100
Subject: [PATCH 1317/1541] Increase single shell factor to 3.5 so that it is
 >= 2* multi shell factor

---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index 56e802fc..f64d69c8 100644
--- a/utils.py
+++ b/utils.py
@@ -45,7 +45,7 @@
                      # IMPORTANT NOTE: MULTI_SHELL_FACTOR should be AT LEAST sqrt(2) !
                      # This stems from the fact that there is vacant space in the cylinder
 
-SINGLE_SHELL_FACTOR = 3.0 #2.0*MULTI_SHELL_FACTOR
+SINGLE_SHELL_FACTOR = 3.5 #2.0*MULTI_SHELL_FACTOR
                       # This is the threshold for when the algorithm switches from forming
                       # NonInteractionSingles to forming a Pair or Interaction. It also defines
                       # the radius in which the NonInteractionSingle will burst intruding domains.

From c522c23d7d7a9275b47c93df65914840b3c27812 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 15:33:10 +0100
Subject: [PATCH 1318/1541] Another revision of the rootfinding in
 EDGE_HITS_EDGE cylinder scaling

- Introducing an adaptive enlargement factor; just using TOLERANCE
  sometimes caused the steps to be too large in the first iteration
  and produced rootfinder search intervals with inverted bounds.
---
 shells.py | 67 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 53 insertions(+), 14 deletions(-)

diff --git a/shells.py b/shells.py
index a028f9f4..bb3edfa6 100755
--- a/shells.py
+++ b/shells.py
@@ -1259,18 +1259,34 @@ def h1_eq(x):
 
                         return eq_value
 
-                    # Self-adaptive initial value guessing for the rootfinder procedure:
-                    # Start with prefactors (1+TOLERANCE), (1-TOLERANCE) and check whether the h1_eq values for these
-                    # interval boundaries have different signs; if not, slightly enlarge the interval.
+                    # To ensure that we always search on an interval within which h1_eq() contains only one zero root
+                    # we enlarge the rootfinder interval, starting from safe bounds, towards the bounds beyond which we
+                    # know there are unwanted solutions. We stop the enlargement when function h1_eq() certainly 
+                    # changes sign within the interval.
+                    # We use a multiplicative factor tau to enlarge the domain. tau is set such that 
+                    # (1-tau)*h1_interval_max - (1+tau)*h1_interval_min >= 0.5*(h1_interval_max-h1_interval_min)
+                    # in order to ensure that the interval is nonzero and positive in the first iteration.
+
+                    # Set some repeating and default values
+                    # r1_interval min, r1_interval_max are the outer interval bounds for which there is only one root
+                    h1_interval_min = z1_function(scale_center_to_shell_edge_x) - scale_center_z
+                    h1_interval_max = z1_function( math.sqrt( scale_center_to_shell_y*scale_center_to_shell_y + \
+                                                      scale_center_to_shell_edge_x*scale_center_to_shell_edge_x ) ) - scale_center_z
+                    h1_interval_start = h1_interval_min
+                    h1_interval_end   = h1_interval_max
+                    # Set the enlargement factor; we want it to be at least as small as TOLERANCE
+                    tau = min(TOLERANCE, 0.5*(h1_interval_max-h1_interval_min)/(h1_interval_max+h1_interval_min))
+                    assert tau>0.0 and tau<1.0
+
+                    # Start the iteration
                     n=1
                     nmax=100
-                    h1_eq_product = 1
-                    assert TOLERANCE>0.0 and TOLERANCE<1.0
+                      # Since tau is very small, the iteration hardly ever should get to nmax; but to be safe...
+                    h1_eq_product = 1                    
                     while h1_eq_product > 0.0:
 
-                        h1_interval_start = (1.0+TOLERANCE**n) * (z1_function(scale_center_to_shell_edge_x) - scale_center_z)
-                        h1_interval_end   = (1.0-TOLERANCE**n) * (z1_function( math.sqrt( scale_center_to_shell_y*scale_center_to_shell_y + \
-                                                                                          scale_center_to_shell_edge_x*scale_center_to_shell_edge_x ) ) - scale_center_z)
+                        h1_interval_start = (1.0+tau**n) * h1_interval_min
+                        h1_interval_end   = (1.0-tau**n) * h1_interval_max
                         h1_eq_product     = h1_eq(h1_interval_start) * h1_eq(h1_interval_end)
 
                         n = n+1
@@ -1290,6 +1306,7 @@ def h1_eq(x):
                     #log.debug( "  h1(i_start) = %s"       % h1_eq(h1_interval_start) )
                     #log.debug( "  h1(i_end) = %s"         % h1_eq(h1_interval_end) )
 
+                    # Finally, start the rootfinding
                     h_touch = scale_center_z + findroot(h1_eq, h1_interval_start, h1_interval_end)
                     z1_new = min(z1, h_touch)
                     r_new  = min(r,  r1_function(z1_new))
@@ -1319,16 +1336,37 @@ def r1_eq(x):
 
                         return eq_value
 
+                    # To ensure that we always search on an interval within which r1_eq() contains only one zero root
+                    # we enlarge the rootfinder interval, starting from safe bounds, towards the bounds beyond which we
+                    # know there are unwanted solutions. We stop the enlargement when function r1_eq() certainly 
+                    # changes sign within the interval.
+                    # We use a multiplicative factor tau to enlarge the domain. tau is set such that 
+                    # (1-tau)*r1_interval_max - (1+tau)*r1_interval_min >= 0.5*(r1_interval_max-r1_interval_min)
+                    # in order to ensure that the interval is nonzero and positive in the first iteration.
+
+                    # Set some repeating and default values
+                    # r1_interval min, r1_interval_max are the outer interval bounds for which there is only one root
+                    r1_interval_min = scale_center_to_shell_edge_x
+                    r1_interval_max = math.sqrt( scale_center_to_shell_y*scale_center_to_shell_y + \
+                                                    scale_center_to_shell_edge_x*scale_center_to_shell_edge_x )
+                    r1_interval_start = r1_interval_min
+                    r1_interval_end   = r1_interval_max
+                    # Set the enlargement factor; we want it to be at least as small as TOLERANCE
+                    tau = min(TOLERANCE, 0.5*(r1_interval_max-r1_interval_min)/(r1_interval_max+r1_interval_min))
+                    assert tau>0.0 and tau<1.0
+
+                    # Start the iteration
                     n=1
                     nmax=100
+                      # Since tau is very small, the iteration hardly ever should get to nmax; but to be safe...
                     r1_eq_product = 1
-                    assert TOLERANCE>0.0 and TOLERANCE<1.0
                     while r1_eq_product > 0.0:
 
-                        r1_interval_start = (1.0+TOLERANCE**n) * scale_center_to_shell_edge_x
-                        r1_interval_end   = (1.0-TOLERANCE**n) * math.sqrt( scale_center_to_shell_y*scale_center_to_shell_y + \
-                                                                            scale_center_to_shell_edge_x*scale_center_to_shell_edge_x )
+                        r1_interval_start = (1.0+tau**n) * r1_interval_min
+                        r1_interval_end   = (1.0-tau**n) * r1_interval_max
                         r1_eq_product     = r1_eq(r1_interval_start) * r1_eq(r1_interval_end)
+
+			print n, r1_eq(r1_interval_start), r1_eq(r1_interval_end)	# DEBUG TODO REMOVE
                         
                         n = n+1
 
@@ -1338,8 +1376,8 @@ def r1_eq(x):
                     # Non-adaptive version; TODO Remove this after TESTING
                     #r1_interval_start = scale_center_to_shell_edge_x
                     #r1_interval_end   = math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2 )
-                    assert(r1_interval_start >= 0)
-                    assert(r1_interval_end   >= r1_interval_start)
+                    assert(r1_interval_start >= 0), 'r1_interval_start = %s, n_iterations=%s' % (r1_interval_start, n)
+                    assert(r1_interval_end   >= r1_interval_start), 'r1_interval_start = %s, r1_interval_end=%s, n_iterations=%s' % (r1_interval_start, r1_interval_end, n)
 
                     # TODO TESTING REMOVE THIS WHEN DONE
                     #print "***** NEW ROOTFINDER ITERATION *****"
@@ -1350,6 +1388,7 @@ def r1_eq(x):
                     #print "  r1(i_start) = %s"       % r1_eq(scale_center_to_shell_edge_x)
                     #print "  r1(i_end) = %s"         % r1_eq(math.sqrt( scale_center_to_shell_y**2 + scale_center_to_shell_edge_x**2))
 
+                    # Finally, start the rootfinding
                     r_touch = findroot(r1_eq, r1_interval_start, r1_interval_end)
                               
                     r_new  = min(r, r_touch)

From bb04e1bc7811cbd6f1e12a65e0140981b1e2491f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 15:51:42 +0100
Subject: [PATCH 1319/1541] Cleanup

---
 shells.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index bb3edfa6..ef25d463 100755
--- a/shells.py
+++ b/shells.py
@@ -866,7 +866,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
 
     if feq(relative_orientation, 1.0):
-    #### If the cylinders are oriented parallelly ####
+    #### If the cylinders are parallel ####
 
         # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
         ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
@@ -1365,8 +1365,6 @@ def r1_eq(x):
                         r1_interval_start = (1.0+tau**n) * r1_interval_min
                         r1_interval_end   = (1.0-tau**n) * r1_interval_max
                         r1_eq_product     = r1_eq(r1_interval_start) * r1_eq(r1_interval_end)
-
-			print n, r1_eq(r1_interval_start), r1_eq(r1_interval_end)	# DEBUG TODO REMOVE
                         
                         n = n+1
 

From 4dfe420bcc799627aa4225fe9dea57071c6013f5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 15:53:31 +0100
Subject: [PATCH 1320/1541] Tolerate a certain overlap with overlap_tolerance =
 TOLERANCE*shell_size

---
 egfrd.py | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b4fe36dd..ebaa257b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2895,14 +2895,25 @@ def check_domain(self, domain):
 
         for shell_id, shell in domain.shell_list:
 
-            ### check that shells do not overlap with non associated surfaces
+            ### Determine the size of the shell; take sth. representative
+            if (type(shell.shape) is Cylinder):
+                # the cylinder should at least fit in the maximal sphere
+                shell_size = math.sqrt(shell.shape.radius**2 + shell.shape.half_length**2)
+            elif (type(shell.shape) is Sphere):
+                shell_size = shell.shape.radius
+            else:
+                raise RuntimeError('check_domain error: Shell shape was not Cylinder of Sphere')
+
+            overlap_tolerance = shell_size*TOLERANCE
+
+            ### Check that shells do not overlap with non associated surfaces
             surfaces = get_all_surfaces(self.world, shell.shape.position, ignores + associated)
             for surface, _ in surfaces:
-                assert self.check_shape_overlap(shell.shape, surface.shape) >= 0.0, \
+                assert self.check_shape_overlap(shell.shape, surface.shape) >= -1.0*overlap_tolerance, \
                     '%s (%s) overlaps with %s.' % \
                     (str(domain), str(shell), str(surface))
 
-            ### check that shells DO overlap with associated surfaces.
+            ### Check that shells DO overlap with associated surfaces.
             surfaces = get_all_surfaces(self.world, shell.shape.position, ignores)
             for surface, _ in surfaces:
                 if surface.id in associated:
@@ -2924,20 +2935,11 @@ def check_domain(self, domain):
 
                     for _, neighbor_shell in neighbor.shell_list:
                         overlap = self.check_shape_overlap(shell.shape, neighbor_shell.shape)
-                        assert overlap >= 0.0, \
+                        assert overlap >= -1.0*overlap_tolerance, \
                             '%s (%s) overlaps with %s (%s) by %s.' % \
                             (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
 
-
-            ### checking if the shell don't exceed the maximum size
-            if (type(shell.shape) is Cylinder):
-                # the cylinder should at least fit in the maximal sphere
-                shell_size = math.sqrt(shell.shape.radius**2 + shell.shape.half_length**2)
-            elif (type(shell.shape) is Sphere):
-                shell_size = shell.shape.radius
-            else:
-                raise RuntimeError('check_domain error: Shell shape was not Cylinder of Sphere')
-
+            ### Check if the shell does not exceed the maximum size
             assert shell_size <= self.geometrycontainer.get_user_max_shell_size(), \
                 '%s shell size larger than user-set max shell size, shell_size = %s, max = %s.' % \
                 (str(shell_id), FORMAT_DOUBLE % shell_size, FORMAT_DOUBLE % self.geometrycontainer.get_user_max_shell_size())

From f55fedbe10d52bb7fc2043b1c4facdbed9496690 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 16:01:30 +0100
Subject: [PATCH 1321/1541] Warn when continuing with overlap within
 overlap_tolerance

---
 egfrd.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ebaa257b..2d87d325 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2909,9 +2909,13 @@ def check_domain(self, domain):
             ### Check that shells do not overlap with non associated surfaces
             surfaces = get_all_surfaces(self.world, shell.shape.position, ignores + associated)
             for surface, _ in surfaces:
-                assert self.check_shape_overlap(shell.shape, surface.shape) >= -1.0*overlap_tolerance, \
-                    '%s (%s) overlaps with %s.' % \
-                    (str(domain), str(shell), str(surface))
+                overlap = self.check_shape_overlap(shell.shape, surface.shape)
+                if __debug__ and overlap < 0.0:
+                            log.warn('%s (%s) overlaps with %s by %s.' % \
+                                      (str(domain), str(shell), str(surface), FORMAT_DOUBLE % overlap) )
+                assert overlap >= -1.0*overlap_tolerance, \
+                    'Overlap out of overlap_tolerance = %s.' % str(overlap_tolerance)
+                    
 
             ### Check that shells DO overlap with associated surfaces.
             surfaces = get_all_surfaces(self.world, shell.shape.position, ignores)
@@ -2935,9 +2939,11 @@ def check_domain(self, domain):
 
                     for _, neighbor_shell in neighbor.shell_list:
                         overlap = self.check_shape_overlap(shell.shape, neighbor_shell.shape)
+                        if __debug__ and overlap < 0.0:
+                            log.warn('%s (%s) overlaps with %s (%s) by %s.' %\
+                                      (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap) )
                         assert overlap >= -1.0*overlap_tolerance, \
-                            '%s (%s) overlaps with %s (%s) by %s.' % \
-                            (domain, str(shell), str(neighbor), str(neighbor_shell), FORMAT_DOUBLE % overlap)
+                            'Overlap out of overlap_tolerance = %s.' % str(overlap_tolerance)
 
             ### Check if the shell does not exceed the maximum size
             assert shell_size <= self.geometrycontainer.get_user_max_shell_size(), \

From 51c51f55e06eabc75bc818b14e2c9cbff29514b9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 21:31:49 +0100
Subject: [PATCH 1322/1541] Fix transition pair shell construction problem

The shells have to be constructed at the "real" position of the CoM,
i.e. the one with applied boundaries and projections.

In contrast, the calculations have all to be performed using the
CoM as calculated in one of the two structures (structure1).

That was not the case and is fixed by this commit.

Yet to be cleaned up after testing.
---
 shells.py | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index ef25d463..bff72bb6 100755
--- a/shells.py
+++ b/shells.py
@@ -484,8 +484,10 @@ def __init__(self, single1, single2):
         if __debug__: 
                 assert isinstance(single1.structure, PlanarSurface) 
                 assert isinstance(single2.structure, PlanarSurface) 
-
-        testPair.__init__(self, single1, single2) # note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
+        
+        testPair.__init__(self, single1, single2) # Note: this makes self.single1/self.pid_particle_pair1 and the same for particle2
+                                                  # and also will run do_transform(); do_transform sets self.com_with_apply_bnd which
+                                                  # will be the position at which the shell will be later constructed.
         self.structure  = self.structure1         # some pair methods need this to be defined
 
     def get_sigma(self):
@@ -497,8 +499,9 @@ def get_sigma(self):
 
     def do_transform(self):
         # Transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
-        # As an indermediate step project position of single2 into plane of single1 and add its
+        # As an intermediate step project position of single2 into plane of single1 and add its
         # orthogonal component rotated by 90 deg. to transform the whole problem into a single 2D plane
+        # The latter is now taken care of by world.cyclic_transpose()
         pos1 = self.pid_particle_pair1[1].position
 #        pos2 = self.structure1.deflect_back(self.pid_particle_pair2[1].position, self.structure2.shape.unit_z)
         pos2, _ = self.world.cyclic_transpose((self.pid_particle_pair2[1].position, self.pid_particle_pair2[1].structure_id), self.structure1)
@@ -507,9 +510,26 @@ def do_transform(self):
 
         com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
         com = self.world.apply_boundary(com)
+        # Attention! This is the CoM in plane1! It may well lie outside of the structure if it is
+        # closer to particle2 than to particle1. This is correct since we want to perform the whole
+        # calculation in structure1 and later correctly project the results if necessary.
         # TODO make sure that the com is in the structure of the particle
         # (assume that this is done correctly in calculate_pair_CoM)
 
+        # We also want the "real" CoM, i.e. projected to structure2 if outside of structure1.
+        # The test shell will be constructed with its center at this point
+        dist_to_edge_of_struct1 = self.structure1.project_point(com)[1][1]   # returns the negative length to the closest edge of structure1
+
+        if dist_to_edge_of_struct1 > 0.0: # com is outside of plane1
+            com_struct = self.structure2
+        else:
+            com_struct = self.structure1
+
+        self.com_with_apply_bnd, self.com_struct_id = self.world.apply_boundary( (com, self.structure1.id) )
+
+        log.debug('PSTP: self.com = %s, self.com_with_apply_bnd = %s, pos1=%s, pos2=%s, com_struct_id=%s, p1_sid=%s, p2_sid=%s, dist_com_s1_edge=%s' % \
+                  (com, self.com_with_apply_bnd, pos1, pos2, self.com_struct_id, self.pid_particle_pair1[1].structure_id, self.pid_particle_pair2[1].structure_id, dist_to_edge_of_struct1)) # DEBUG TODO REMOVE THIS
+
         pos2t = self.world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
 
@@ -1760,7 +1780,8 @@ def __init__(self, single1, single2, geometrycontainer, domains):
             raise testShellError('(PlanarSurfaceTransitionPair). %s' %
                                  (str(e)))
 
-        self.center = self.com
+        self.center = self.com_with_apply_bnd
+        log.debug('PSTP: Setting self.center = %s' % str(self.center))       # DEBUG TODO REMOVE THIS
         try:
             self.radius = self.determine_possible_shell(self.structure1.id, [self.single1.domain_id, self.single2.domain_id],
                                                         [self.structure2.id])

From 57a298331f7352bfea30d573b80d133267d66d39 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 21:33:59 +0100
Subject: [PATCH 1323/1541] One more warn statement

---
 pair.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/pair.py b/pair.py
index 3611fe49..9f792baa 100644
--- a/pair.py
+++ b/pair.py
@@ -682,6 +682,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
         if world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR :
 
+            log.warn('Removing overlap in PlanarSurfaceTransitionPair')
+
             new_structure1 = world.get_structure(new_sid1)
             new_structure2 = world.get_structure(new_sid2)
 
@@ -724,8 +726,11 @@ def draw_new_com(self, dt, event_type):
 
         if event_type == EventType.IV_REACTION:
             # Express the new CoM in plane1 and deflect it to plane2 if necessary
+            # TODO This should be taken care of by apply_boundary() in the main routine            
             s1_ctr = self.structure1.shape.position
             new_com, changeflag = self.structure2.deflect(s1_ctr, new_com - s1_ctr)
+            if __debug__:
+                log.debug('Deflected new_com on structure2, changeflag=%s' % str(changeflag))
 
         # TODO: Check whether the new CoM is in the right structure
         return new_com

From ba6d959f292d0a31bcf6e6dccd2b34e66d94c57d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 21:37:09 +0100
Subject: [PATCH 1324/1541] Basic code structure for overlap remover routine

Does not work yet, but also does not change anything yet.
---
 egfrd.py | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2d87d325..ef62b752 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -705,6 +705,13 @@ def move_particle(self, pid_particle_pair, position, structure_id):
         return new_pid_particle_pair
 
 
+    def remove_overlap(self, pid_particle_pair, target_position, ignore_p):
+
+        #co = self.world.check_overlap((reactant_pos, reactant[1].radius),
+        #                                        reactant[0], ignore_p[0])
+
+        pass
+
     def remove_domain(self, obj):
         # Removes all the ties to a domain (single, pair, multi) from the system.
         # Note that the particles that it represented still exist
@@ -1554,7 +1561,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, reactant1_struc
 
 
             # 1.5 get new position and structure_id for product particle
-            product_pos = pair.draw_new_com (pair.dt, pair.event_type)
+            product_pos = pair.draw_new_com(pair.dt, pair.event_type)
             product_pos = self.world.apply_boundary(product_pos)
 
             # select the structure_id for the product particle to live on.
@@ -1631,14 +1638,22 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
             if co:
                 for c in co:
                     log.debug('fire_move: detected overlap with %s' % str(c))
-                raise RuntimeError('fire_move: particle overlap failed.')
+
+                if REMOVE_OVERLAPS:
+                    self.remove_overlap(reactant, reactant_pos, ignore_p)
+                else:
+                    raise RuntimeError('fire_move: particle overlap failed.')
         else:
             co = self.world.check_overlap((reactant_pos, reactant[1].radius),
                                         reactant[0])            
             if co:
                 for c in co:
                     log.debug('fire_move: detected overlap with %s' % str(c))
-                raise RuntimeError('fire_move: particle overlap failed.')
+
+                if REMOVE_OVERLAPS:
+                    self.remove_overlap(reactant, reactant_pos, ignore_p)
+                else:
+                    raise RuntimeError('fire_move: particle overlap failed.')
 
         # 4. process the changes (move particles, change structure)
         moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
@@ -2170,7 +2185,7 @@ def process_pair_event(self, pair, ignore):
         #
         elif pair.event_type == EventType.IV_REACTION:
 
-            particles, zero_singles_b, ignore = self.fire_pair_reaction (pair, newpos1, newpos2, struct1_id, struct2_id, ignore)
+            particles, zero_singles_b, ignore = self.fire_pair_reaction(pair, newpos1, newpos2, struct1_id, struct2_id, ignore)
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
             zero_singles = []

From 5e98365a33ee41f9f2789d9d752228b2e0f22f47 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 16 Jan 2013 13:28:54 +0100
Subject: [PATCH 1325/1541] Continue

---
 egfrd.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ef62b752..8e4d3281 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -706,9 +706,11 @@ def move_particle(self, pid_particle_pair, position, structure_id):
 
 
     def remove_overlap(self, pid_particle_pair, target_position, ignore_p):
+    # TODO
 
-        #co = self.world.check_overlap((reactant_pos, reactant[1].radius),
-        #                                        reactant[0], ignore_p[0])
+        # Get overlaps when moved to target position
+        #co = self.world.check_overlap((target_pos, reactant[1].radius),
+        #                                           reactant[0], ignore_p[0])
 
         pass
 
@@ -1641,6 +1643,7 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
 
                 if REMOVE_OVERLAPS:
                     self.remove_overlap(reactant, reactant_pos, ignore_p)
+                        # not implemented yet
                 else:
                     raise RuntimeError('fire_move: particle overlap failed.')
         else:
@@ -1652,6 +1655,7 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
 
                 if REMOVE_OVERLAPS:
                     self.remove_overlap(reactant, reactant_pos, ignore_p)
+                        # not implemented yet
                 else:
                     raise RuntimeError('fire_move: particle overlap failed.')
 

From c959a38e6192a8832fba79f3b6e21e04874343b3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 16 Jan 2013 13:36:21 +0100
Subject: [PATCH 1326/1541] Some cleanup in shells.py

---
 shells.py | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/shells.py b/shells.py
index bff72bb6..46a866cf 100755
--- a/shells.py
+++ b/shells.py
@@ -517,19 +517,11 @@ def do_transform(self):
         # (assume that this is done correctly in calculate_pair_CoM)
 
         # We also want the "real" CoM, i.e. projected to structure2 if outside of structure1.
-        # The test shell will be constructed with its center at this point
-        dist_to_edge_of_struct1 = self.structure1.project_point(com)[1][1]   # returns the negative length to the closest edge of structure1
-
-        if dist_to_edge_of_struct1 > 0.0: # com is outside of plane1
-            com_struct = self.structure2
-        else:
-            com_struct = self.structure1
-
+        # The test shell will be constructed with its center at this point.
+        # To construct this point we need to take into account a possible change to the other plane.
+        # apply_boundary() called with the structure into which the problem was transformed does the job:
         self.com_with_apply_bnd, self.com_struct_id = self.world.apply_boundary( (com, self.structure1.id) )
 
-        log.debug('PSTP: self.com = %s, self.com_with_apply_bnd = %s, pos1=%s, pos2=%s, com_struct_id=%s, p1_sid=%s, p2_sid=%s, dist_com_s1_edge=%s' % \
-                  (com, self.com_with_apply_bnd, pos1, pos2, self.com_struct_id, self.pid_particle_pair1[1].structure_id, self.pid_particle_pair2[1].structure_id, dist_to_edge_of_struct1)) # DEBUG TODO REMOVE THIS
-
         pos2t = self.world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
 
@@ -1781,7 +1773,7 @@ def __init__(self, single1, single2, geometrycontainer, domains):
                                  (str(e)))
 
         self.center = self.com_with_apply_bnd
-        log.debug('PSTP: Setting self.center = %s' % str(self.center))       # DEBUG TODO REMOVE THIS
+        
         try:
             self.radius = self.determine_possible_shell(self.structure1.id, [self.single1.domain_id, self.single2.domain_id],
                                                         [self.structure2.id])

From facc6bdf953c6298f6ab071b327b6b30829259b7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 13 Feb 2013 19:23:36 +0100
Subject: [PATCH 1327/1541] Reject single reactions in which a product crosses
 a plane

This caused problems with particles leaking out of the box structure.
---
 egfrd.py | 29 +++++++++++++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2d87d325..25faed09 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1363,6 +1363,30 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             # 3. check that there is space for the products (try different positions if possible)
             # accept the new positions if there is enough space.
             for newpos1, newpos2 in product_pos_list:
+
+                # First, for each neighboring plane, we check whether the new positions lie 
+                # on the same side of the plane as the reactant; if not, this trial will be rejected                
+                product_crossed_plane = False # by default everything is OK
+                neighbor_surfaces = get_neighbor_surfaces(self.world, reactant_pos, reactant_structure.id, ignores=[])
+                    # NOTE surface lists have format (surface, distance_to_surface_from_reactant_position)
+                for surface, surf_dist in neighbor_surfaces:
+                
+                    if isinstance(surface, PlanarSurface):
+                    
+                        # Products and reactant are on the same side if the dot product of the position minus
+                        # a point on the plane with the normal vector of the plane has the same sign
+                        unit_z = surface.shape.unit_z
+                        center = surface.shape.position
+                        newpos1_crossed = numpy.dot(reactant_pos - center, unit_z) * numpy.dot(newpos1 - center, unit_z)
+                        newpos2_crossed = numpy.dot(reactant_pos - center, unit_z) * numpy.dot(newpos2 - center, unit_z)
+                        
+                        if newpos1_crossed < 0.0 or newpos2_crossed < 0.0:
+
+                            product_crossed_plane = True
+                            
+                            if __debug__:
+                                log.info('single reaction: product crosses plane, reaction will be rejected.')
+
                 newpos1 = self.world.apply_boundary(newpos1)
                 newpos2 = self.world.apply_boundary(newpos2)
 
@@ -1371,8 +1395,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
                 # check that there is space for the products 
                 # Note that we do not check overlap with surfaces -> TODO
-                if (not self.world.check_overlap((newpos1, product1_radius), reactant[0]) and \
-                    not self.world.check_overlap((newpos2, product2_radius), reactant[0])):
+                if not self.world.check_overlap((newpos1, product1_radius), reactant[0]) and \
+                   not self.world.check_overlap((newpos2, product2_radius), reactant[0]) and \
+                   not product_crossed_plane:
                     
                     # 4. process the changes (remove particle, make new ones)
                     self.world.remove_particle(reactant[0])

From 377e5fe516ac1190cac905fc5b6f1fbda37c38f0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 13 Feb 2013 20:03:50 +0100
Subject: [PATCH 1328/1541] Same thing for the BD mode, slightly more effort
 required

---
 CuboidalRegion.hpp     |  7 +++++++
 CylindricalSurface.hpp |  7 +++++++
 DiskSurface.hpp        |  7 +++++++
 PlanarSurface.hpp      |  7 +++++++
 SphericalSurface.hpp   |  7 +++++++
 Structure.hpp          |  1 +
 newBDPropagator.hpp    | 45 ++++++++++++++++++++++++++++++++++++++++++
 7 files changed, 81 insertions(+)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 66fbbb0c..010ee441 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -102,6 +102,13 @@ class CuboidalRegion
     {
         return position_type(); //No surface dissociation 'from' the bulk
     }
+    
+    // Vector used to determine whether a particle has crossed the structure
+    // Here we return the zero-vector because there is no "sides" to cross
+    virtual position_type const& crossing_comparison_vector() const
+    {
+        return create_vector<position_type>(0.0, 0.0, 0.0);
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index f8249494..051ac391 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -127,6 +127,13 @@ class CylindricalSurface
         
         return v;
     }
+    
+    // Vector used to determine whether a particle has crossed the structure
+    // Here we return the zero-vector because there is no "sides" to cross
+    virtual position_type const& crossing_comparison_vector() const
+    {
+        return create_vector<position_type>(0.0, 0.0, 0.0);
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 5c12e054..7c2cedf2 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -135,6 +135,13 @@ class DiskSurface
     {
         return base_type::shape().unit_z();
     }
+    
+    // Vector used to determine whether a particle has crossed the structure
+    // Here we return the zero-vector because there is no "sides" to cross
+    virtual position_type const& crossing_comparison_vector() const
+    {
+        return create_vector<position_type>(0.0, 0.0, 0.0);
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, 
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index bf731efe..b2478a58 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -123,6 +123,13 @@ class PlanarSurface
     {
         return base_type::shape().unit_z();
     }
+    
+    // Vector used to determine whether a particle has crossed the structure
+    // For the plane the normal vector is the natural choice
+    virtual position_type const& crossing_comparison_vector() const
+    {
+        return base_type::shape().unit_z();
+    }
 
     // Positions created at dissociation of one particle on the structure into two particles on the structure
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, 
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index eaaa6c2e..4f9cb351 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -81,6 +81,13 @@ class SphericalSurface
         return position_type(); //TODO  
     }
     
+    // Vector used to determine whether a particle has crossed the structure
+    // Here we return the zero-vector because there is no "sides" to cross
+    virtual position_type const& crossing_comparison_vector() const
+    {
+        return create_vector<position_type>(0.0, 0.0, 0.0);
+    }
+    
     virtual position_pair_type geminate_dissociation_positions( rng_type& rng, species_type const& s0, species_type const& s1, position_type const& op, length_type const& rl ) const
     {
         return position_pair_type(); //TODO
diff --git a/Structure.hpp b/Structure.hpp
index 5ecaf799..455919c2 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -143,6 +143,7 @@ class Structure
     virtual projected_type project_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;
+    virtual position_type const& crossing_comparison_vector() const = 0;
 
     // Methods used for edge crossing (only for the planes so far)
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 74e7c286..4d0b5126 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -705,6 +705,51 @@ class newBDPropagator
                             {
                                 continue;   // try other positions pair
                             }
+                                                        
+                            //// 1c - CHECK FOR PLANE CROSSINGS                            
+                            // FIXME As it is now, this also rejects new positions that end up on
+                            // different "sides" of cylinders or disks
+                            // To fix this we have to define a plane-specific check
+                            // (=> old problem: how to find out it's a plane...)
+                            
+                            // first determine which one is the largest involved particle radius
+                            length_type max_radius( pp.second.radius() ); // initialized with the reactant radius
+                            if( product0_species.radius() > max_radius)         max_radius = product0_species.radius();
+                            if( product1_species.radius() > max_radius)         max_radius = product1_species.radius();
+                            
+                            // get the "close" structures, i.e. the ones that are within max radius distance
+                            boost::scoped_ptr<structure_id_pair_and_distance_list> close_structures( 
+                                    tx_.check_surface_overlap( particle_shape_type( reactant_pos, max_radius + reaction_length_ ), reactant_pos, reactant_structure->id(), max_radius) );                                    
+                            int N_close_structures(close_structures ? close_structures->size(): 0);
+                            
+                            // loop over all close structures
+                            int j = 0;
+                            while(j < N_close_structures)
+                            {
+                                // get the next close structure
+                                const structure_id_pair_and_distance & close_struct( close_structures->at(j) );
+                                // and its center point and normal vector
+                                position_type cs_center( close_struct.first.second->position() );
+                                position_type cs_comp_v( close_struct.first.second->crossing_comparison_vector() );
+                                
+                                // project the distance of reactant and product positions to the center
+                                // onto the normal vector of the structure
+                                Real deltaR( dot_product(cs_comp_v, subtract(reactant_pos, cs_center)) );
+                                Real delta0( dot_product(cs_comp_v, subtract(pos0pos1_pair.first.first, cs_center)) );
+                                Real delta1( dot_product(cs_comp_v, subtract(pos0pos1_pair.second.first, cs_center)) );
+                                
+                                // if the sign of the projections for the products is different from the one
+                                // for the reactant the particle crossed the plane; in that case reject this
+                                // set of new positions
+                                if( deltaR * delta0 < 0.0 || deltaR * delta1 < 0.0)
+                                {
+                                      LOG_WARNING(("Rejecting new product positions because of structure crossing." ));
+                                      continue;   // try other positions pair
+                                }
+                            
+                                j++;
+                            }
+                            
                             // If no overlap occured -> positions are ok
                             break;
                         }

From dea0c2e91793922387c237af79bda074d93e5d5b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 14 Feb 2013 10:38:36 +0100
Subject: [PATCH 1329/1541] Rename crossing_comparison_vector ->
 side_comparison_vector

This just makes more sense.
---
 CuboidalRegion.hpp     | 2 +-
 CylindricalSurface.hpp | 2 +-
 DiskSurface.hpp        | 2 +-
 PlanarSurface.hpp      | 2 +-
 SphericalSurface.hpp   | 2 +-
 Structure.hpp          | 2 +-
 newBDPropagator.hpp    | 4 ++--
 7 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 010ee441..3cb86511 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -105,7 +105,7 @@ class CuboidalRegion
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& crossing_comparison_vector() const
+    virtual position_type const& side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 051ac391..c31226bb 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -130,7 +130,7 @@ class CylindricalSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& crossing_comparison_vector() const
+    virtual position_type const& side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 7c2cedf2..a8520092 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -138,7 +138,7 @@ class DiskSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& crossing_comparison_vector() const
+    virtual position_type const& side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index b2478a58..9f521163 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -126,7 +126,7 @@ class PlanarSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // For the plane the normal vector is the natural choice
-    virtual position_type const& crossing_comparison_vector() const
+    virtual position_type const& side_comparison_vector() const
     {
         return base_type::shape().unit_z();
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 4f9cb351..99c272c3 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -83,7 +83,7 @@ class SphericalSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& crossing_comparison_vector() const
+    virtual position_type const& side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/Structure.hpp b/Structure.hpp
index 455919c2..454c60b3 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -143,7 +143,7 @@ class Structure
     virtual projected_type project_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;
-    virtual position_type const& crossing_comparison_vector() const = 0;
+    virtual position_type const& side_comparison_vector() const = 0;
 
     // Methods used for edge crossing (only for the planes so far)
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 4d0b5126..ec94c014 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -730,7 +730,7 @@ class newBDPropagator
                                 const structure_id_pair_and_distance & close_struct( close_structures->at(j) );
                                 // and its center point and normal vector
                                 position_type cs_center( close_struct.first.second->position() );
-                                position_type cs_comp_v( close_struct.first.second->crossing_comparison_vector() );
+                                position_type cs_comp_v( close_struct.first.second->side_comparison_vector() );
                                 
                                 // project the distance of reactant and product positions to the center
                                 // onto the normal vector of the structure
@@ -743,7 +743,7 @@ class newBDPropagator
                                 // set of new positions
                                 if( deltaR * delta0 < 0.0 || deltaR * delta1 < 0.0)
                                 {
-                                      LOG_WARNING(("Rejecting new product positions because of structure crossing." ));
+                                      LOG_WARNING(("Rejecting new product positions because of structure side crossing." ));
                                       continue;   // try other positions pair
                                 }
                             

From c6a08deea90b7cf4ce0ee90f023b6b02d745de9c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 14 Feb 2013 10:39:12 +0100
Subject: [PATCH 1330/1541] Remove comment that is not true any more

---
 newBDPropagator.hpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index ec94c014..992cde72 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -706,12 +706,7 @@ class newBDPropagator
                                 continue;   // try other positions pair
                             }
                                                         
-                            //// 1c - CHECK FOR PLANE CROSSINGS                            
-                            // FIXME As it is now, this also rejects new positions that end up on
-                            // different "sides" of cylinders or disks
-                            // To fix this we have to define a plane-specific check
-                            // (=> old problem: how to find out it's a plane...)
-                            
+                            //// 1c - CHECK FOR PLANE CROSSINGS
                             // first determine which one is the largest involved particle radius
                             length_type max_radius( pp.second.radius() ); // initialized with the reactant radius
                             if( product0_species.radius() > max_radius)         max_radius = product0_species.radius();

From c284444d7b32adfba1b55ed93a8c5ae6940e35b4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 15 Jan 2013 21:37:09 +0100
Subject: [PATCH 1331/1541] Basic code structure for overlap remover routine

Does not work yet, but also does not change anything yet.
---
 egfrd.py | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 25faed09..af605ff0 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -705,6 +705,13 @@ def move_particle(self, pid_particle_pair, position, structure_id):
         return new_pid_particle_pair
 
 
+    def remove_overlap(self, pid_particle_pair, target_position, ignore_p):
+
+        #co = self.world.check_overlap((reactant_pos, reactant[1].radius),
+        #                                        reactant[0], ignore_p[0])
+
+        pass
+
     def remove_domain(self, obj):
         # Removes all the ties to a domain (single, pair, multi) from the system.
         # Note that the particles that it represented still exist
@@ -1579,7 +1586,7 @@ def fire_pair_reaction(self, pair, reactant1_pos, reactant2_pos, reactant1_struc
 
 
             # 1.5 get new position and structure_id for product particle
-            product_pos = pair.draw_new_com (pair.dt, pair.event_type)
+            product_pos = pair.draw_new_com(pair.dt, pair.event_type)
             product_pos = self.world.apply_boundary(product_pos)
 
             # select the structure_id for the product particle to live on.
@@ -1656,14 +1663,22 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
             if co:
                 for c in co:
                     log.debug('fire_move: detected overlap with %s' % str(c))
-                raise RuntimeError('fire_move: particle overlap failed.')
+
+                if REMOVE_OVERLAPS:
+                    self.remove_overlap(reactant, reactant_pos, ignore_p)
+                else:
+                    raise RuntimeError('fire_move: particle overlap failed.')
         else:
             co = self.world.check_overlap((reactant_pos, reactant[1].radius),
                                         reactant[0])            
             if co:
                 for c in co:
                     log.debug('fire_move: detected overlap with %s' % str(c))
-                raise RuntimeError('fire_move: particle overlap failed.')
+
+                if REMOVE_OVERLAPS:
+                    self.remove_overlap(reactant, reactant_pos, ignore_p)
+                else:
+                    raise RuntimeError('fire_move: particle overlap failed.')
 
         # 4. process the changes (move particles, change structure)
         moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
@@ -2195,7 +2210,7 @@ def process_pair_event(self, pair, ignore):
         #
         elif pair.event_type == EventType.IV_REACTION:
 
-            particles, zero_singles_b, ignore = self.fire_pair_reaction (pair, newpos1, newpos2, struct1_id, struct2_id, ignore)
+            particles, zero_singles_b, ignore = self.fire_pair_reaction(pair, newpos1, newpos2, struct1_id, struct2_id, ignore)
 
             # Make new NonInteractionSingle domains for every particle after the reaction.
             zero_singles = []

From 5ccc63df63b8402e3c8272612a56268fa57be3b9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 16 Jan 2013 13:28:54 +0100
Subject: [PATCH 1332/1541] Continue

---
 egfrd.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index af605ff0..906d3587 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -706,9 +706,11 @@ def move_particle(self, pid_particle_pair, position, structure_id):
 
 
     def remove_overlap(self, pid_particle_pair, target_position, ignore_p):
+    # TODO
 
-        #co = self.world.check_overlap((reactant_pos, reactant[1].radius),
-        #                                        reactant[0], ignore_p[0])
+        # Get overlaps when moved to target position
+        #co = self.world.check_overlap((target_pos, reactant[1].radius),
+        #                                           reactant[0], ignore_p[0])
 
         pass
 
@@ -1666,6 +1668,7 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
 
                 if REMOVE_OVERLAPS:
                     self.remove_overlap(reactant, reactant_pos, ignore_p)
+                        # not implemented yet
                 else:
                     raise RuntimeError('fire_move: particle overlap failed.')
         else:
@@ -1677,6 +1680,7 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
 
                 if REMOVE_OVERLAPS:
                     self.remove_overlap(reactant, reactant_pos, ignore_p)
+                        # not implemented yet
                 else:
                     raise RuntimeError('fire_move: particle overlap failed.')
 

From da1d57880d223f059341a5d647e01db14b6bc0a7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 19 Aug 2013 12:31:08 +0200
Subject: [PATCH 1333/1541] WIP + fix weird merge conflict

---
 egfrd.py | 49 ++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 42 insertions(+), 7 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 906d3587..166fac8a 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -234,6 +234,8 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
                                                 # to calculate ridiculously small timesteps, but will break detail balance.
                                                 # Take care: This is for testing only! Keep this at a negative value for normal sims!
 
+        self.REMOVE_OVERLAPS = True             # Ignore overlaps, only warn when they happen and move particles apart
+
         # used datastructrures
         self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
 
@@ -705,14 +707,47 @@ def move_particle(self, pid_particle_pair, position, structure_id):
         return new_pid_particle_pair
 
 
-    def remove_overlap(self, pid_particle_pair, target_position, ignore_p):
+    def remove_overlap(self, reactant, target_position, ignore_p=None):
     # TODO
 
         # Get overlaps when moved to target position
-        #co = self.world.check_overlap((target_pos, reactant[1].radius),
-        #                                           reactant[0], ignore_p[0])
+        if ignore_p:
+            co = self.world.check_overlap((target_position, reactant[1].radius),
+                                                                    reactant[0], ignore_p[0])
+        else:
+            co = self.world.check_overlap((target_position, reactant[1].radius), reactant[0])
+
+        # Extract the overlap data for the closest particle
+        closest = co[0]
+        overlap_PID      = closest[0][0]
+        overlap_particle = closest[0][1]        
+        overlap_length = closest[1]
+
+        log.debug('Target position: %s', target_position)
+        log.debug('Overlapping particle: %s, overlap: %s', overlap_particle, overlap_length)
+        log.debug('ID: %s',  overlap_PID)
+        log.debug('pos: %s', overlap_particle.position)
+
+        target_position_t = self.world.cyclic_transpose(target_position, overlap_particle.position)
+        corr_vector = target_position_t - overlap_particle.position
+        correction       = 1.1 * overlap_length        
+
+        new_position = self.world.apply_boundary( target_position + correction * normalize(corr_vector) )
+
+        log.debug('IP vector = %s, length = %s', corr_vector, length(corr_vector))
+        log.debug('new_pos = %s', new_position) 
+
+        co = self.world.check_overlap((new_position, reactant[1].radius), reactant[0])
+        
+        if co:
+            for c in co:
+                log.debug('remove_overlap: RE-detected overlap with %s' % str(c))
+        else:
+            log.debug('Overlap removed!')
+
+
+        raise RuntimeError('fire_move: particle overlap failed.')
 
-        pass
 
     def remove_domain(self, obj):
         # Removes all the ties to a domain (single, pair, multi) from the system.
@@ -1666,7 +1701,7 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
                 for c in co:
                     log.debug('fire_move: detected overlap with %s' % str(c))
 
-                if REMOVE_OVERLAPS:
+                if self.REMOVE_OVERLAPS:
                     self.remove_overlap(reactant, reactant_pos, ignore_p)
                         # not implemented yet
                 else:
@@ -1678,8 +1713,8 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
                 for c in co:
                     log.debug('fire_move: detected overlap with %s' % str(c))
 
-                if REMOVE_OVERLAPS:
-                    self.remove_overlap(reactant, reactant_pos, ignore_p)
+                if self.REMOVE_OVERLAPS:
+                    self.remove_overlap(reactant, reactant_pos)
                         # not implemented yet
                 else:
                     raise RuntimeError('fire_move: particle overlap failed.')

From 6b7fa9fedc8c335598f85bfce631b8b61b0bd223 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 19 Aug 2013 13:15:32 +0200
Subject: [PATCH 1334/1541] Finish first version of a working overlap remover

Still lacking some features, like checking whether particle is
in the right structure after overlap removal.

Apart from that there seems to be some problem with planar surface
pairs updated close to the edge of the system (with periodic BC)
that shall be fixed separately.
---
 egfrd.py | 54 ++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 34 insertions(+), 20 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 166fac8a..3d094e51 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -235,6 +235,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
                                                 # Take care: This is for testing only! Keep this at a negative value for normal sims!
 
         self.REMOVE_OVERLAPS = True             # Ignore overlaps, only warn when they happen and move particles apart
+        self.max_overlap_error = 0.0            # This remembers the largest relative error produced by removing overlaps
 
         # used datastructrures
         self.scheduler = EventScheduler()       # contains the events. Note that every domains has exactly one event
@@ -708,7 +709,6 @@ def move_particle(self, pid_particle_pair, position, structure_id):
 
 
     def remove_overlap(self, reactant, target_position, ignore_p=None):
-    # TODO
 
         # Get overlaps when moved to target position
         if ignore_p:
@@ -720,33 +720,47 @@ def remove_overlap(self, reactant, target_position, ignore_p=None):
         # Extract the overlap data for the closest particle
         closest = co[0]
         overlap_PID      = closest[0][0]
-        overlap_particle = closest[0][1]        
-        overlap_length = closest[1]
+        overlap_particle = closest[0][1]
+        overlap_length   = closest[1]
 
-        log.debug('Target position: %s', target_position)
-        log.debug('Overlapping particle: %s, overlap: %s', overlap_particle, overlap_length)
-        log.debug('ID: %s',  overlap_PID)
-        log.debug('pos: %s', overlap_particle.position)
+        log.warn('Removing overlap: reported overlap length = %s', overlap_length)
+
+        #log.debug('Target position: %s', target_position)
+        #log.debug('Overlapping particle: %s, overlap: %s', overlap_particle, overlap_length)
+        #log.debug('ID: %s',  overlap_PID)
+        #log.debug('pos: %s', overlap_particle.position)
+        # TODO remove that debugging stuff
 
         target_position_t = self.world.cyclic_transpose(target_position, overlap_particle.position)
-        corr_vector = target_position_t - overlap_particle.position
-        correction       = 1.1 * overlap_length        
+        IP_vector         = target_position_t - overlap_particle.position
+        correction        = SAFETY * (reactant[1].radius + overlap_particle.radius)
 
-        new_position = self.world.apply_boundary( target_position + correction * normalize(corr_vector) )
+        new_position = self.world.apply_boundary( target_position + correction * normalize(IP_vector) )
+        # TODO: Check that new position is in reactant structure!!!
 
-        log.debug('IP vector = %s, length = %s', corr_vector, length(corr_vector))
-        log.debug('new_pos = %s', new_position) 
+        #log.debug('target_position_t = %s', target_position_t) 
+        #log.debug('IP_vector = %s, length = %s, normalized = %s', IP_vector, length(IP_vector), normalize(IP_vector) )
+        #log.debug('new_pos = %s', new_position)
+        # TODO remove that debugging stuff
 
         co = self.world.check_overlap((new_position, reactant[1].radius), reactant[0])
         
         if co:
+
             for c in co:
+                # Failed to remove overlap, sth. serious going on
                 log.debug('remove_overlap: RE-detected overlap with %s' % str(c))
-        else:
-            log.debug('Overlap removed!')
+                RuntimeError('remove_overlap: failed.')
 
+        else:
 
-        raise RuntimeError('fire_move: particle overlap failed.')
+            # The overlap error is defined as the artificially added displacement divided by the smallest particle radius involved
+            overlap_error = abs(correction - length(IP_vector)) / min(reactant[1].radius, overlap_particle.radius)            
+            self.max_overlap_error = max(self.max_overlap_error, overlap_error)
+            # Drop a warning
+            log.warn('Removing overlap: error = %s, maximal error of overlap removal = %s', overlap_error, self.max_overlap_error)
+            
+            return new_position            
 
 
     def remove_domain(self, obj):
@@ -1702,8 +1716,8 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
                     log.debug('fire_move: detected overlap with %s' % str(c))
 
                 if self.REMOVE_OVERLAPS:
-                    self.remove_overlap(reactant, reactant_pos, ignore_p)
-                        # not implemented yet
+                    reactant_pos = self.remove_overlap(reactant, reactant_pos, ignore_p)
+                        # still TESTING
                 else:
                     raise RuntimeError('fire_move: particle overlap failed.')
         else:
@@ -1714,13 +1728,13 @@ def fire_move(self, single, reactant_pos, reactant_structure_id, ignore_p=None):
                     log.debug('fire_move: detected overlap with %s' % str(c))
 
                 if self.REMOVE_OVERLAPS:
-                    self.remove_overlap(reactant, reactant_pos)
-                        # not implemented yet
+                    reactant_pos = self.remove_overlap(reactant, reactant_pos)
+                        # still TESTING
                 else:
                     raise RuntimeError('fire_move: particle overlap failed.')
 
         # 4. process the changes (move particles, change structure)
-        moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)
+        moved_reactant = self.move_particle(reactant, reactant_pos, reactant_structure_id)        
         # 5. No counting
         # 6. No Logging
         return [moved_reactant]

From bb8207df278b9a785360867532925e4ca632942b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 19 Aug 2013 15:20:42 +0200
Subject: [PATCH 1335/1541] Introduce a function to default-connect one plane
 in periodic BCs

Otherwise the Bossonic new version of apply_boundary does not work
correctly.
---
 gfrdbase.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/gfrdbase.py b/gfrdbase.py
index 67d7115b..349f11e2 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -37,6 +37,7 @@
     'create_world',
     'create_box',
     'create_rod',
+    'periodic_connect',
     'ParticleSimulatorBase',
     'get_all_surfaces',
     'get_neighbor_surfaces',
@@ -342,6 +343,17 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
 
     return rod.id
 
+def periodic_connect(world, planar_surface):
+    """ Makes connections between the opposite edges of a plane.
+
+        Use this to simulate particles on an infinite plane
+        with periodic boundary conditions.
+        
+    """
+    world.connect_structures(planar_surface, 0, planar_surface, 1)
+    world.connect_structures(planar_surface, 2, planar_surface, 3)
+    # TODO bind this function into world directly
+
 def create_network_rules_wrapper(model):
     return _gfrd.NetworkRulesWrapper(model.network_rules)
 

From b1d9fb1996c798544cbb2f68dfd874632d601ced Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 19 Aug 2013 15:40:29 +0200
Subject: [PATCH 1336/1541] Use do_back_transform correctly

I.e. apply overlap prevention only if particles are to end up
on orthogonal planes.
---
 pair.py | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/pair.py b/pair.py
index 9f792baa..014e1726 100644
--- a/pair.py
+++ b/pair.py
@@ -664,10 +664,15 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z, world):
 
-        # structure should be = structure1, but for safety we use the structures
-        # inherited from the test shell
+        # This function is called every time a PlanarSurfaceSingle dissociates. Sometimes this may
+        # require to deflect the particle towards an orthogonal neighboring plane. Then an additional
+        # seperation factor is applied to the interparticle vector to overcome predictable overlaps.
+        #
+        # Note that this function also is called when singles dissociate on one single plane
+        # in periodic boundary conditions. An extra check prevents that the correction factor
+        # is erronously applied in these cases.
 
-        # Calculate the new positions (still in structure1)
+        # Calculate the new positions (should be still in structure1)
         D_tot = D1 + D2
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
@@ -679,14 +684,16 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
         new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
 
-        # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
-        if world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR :
-
-            log.warn('Removing overlap in PlanarSurfaceTransitionPair')
+        new_structure1 = world.get_structure(new_sid1)
+        new_structure2 = world.get_structure(new_sid2)
 
-            new_structure1 = world.get_structure(new_sid1)
-            new_structure2 = world.get_structure(new_sid2)
+        # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
+        # Only to this correction if the two planes are really orthogonal
+        if  world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR \
+        and feq( numpy.dot(new_structure1.shape.unit_z, new_structure2.shape.unit_z), 0.0 ) :
 
+            log.warn('do_back_transform: Removing overlap resulting from deflection for particles ending up on orthogonal planes.')
+            
             # Calculate the distances from the two new positions to the edge between the planes
             # in which the particles temporarily ended up
             # This is easily done by projecting new_pos1 into new_structure2 + vice versa and

From 4e4c94f7173935a5dc05a4434ac9c74e433a8768 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 19 Aug 2013 15:49:02 +0200
Subject: [PATCH 1337/1541] Include overlap error into print_report

---
 egfrd.py | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3d094e51..a1370030 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2851,8 +2851,10 @@ def print_report(self, out=None):
 \tPair:\t%d\t(%.2f %%)\t(r-escape: %d, R-escape: %d, reaction pair: %d, single: %d, bursted: %d)
 \tMulti:\t%d\t(%.2f %%)\t(diffusion: %d, escape: %d, reaction pair: %d, single: %d, bursted: %d)
 \tavg. multi time step: %e, avg. multi reaction length: %e
-total reactions: %d
-rejected moves:  %d
+total reactions:     %d
+rejected moves:      %d
+overlap remover was: %s
+max. overlap error:  %g
 ''' \
             % (self.t, self.nonmulti_time, self.multi_time,
                self.step_counter, total_steps,
@@ -2884,7 +2886,9 @@ def print_report(self, out=None):
                avg_multi_time,
                avg_multi_rl,
                self.reaction_events,
-               self.rejected_moves
+               self.rejected_moves,
+               ('active' if self.REMOVE_OVERLAPS else 'inactive'),
+               self.max_overlap_error               
                )
 
         print >> out, report

From b9cfc3199104f0925ce784350d4c2b94f3727f34 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 19 Aug 2013 16:39:17 +0200
Subject: [PATCH 1338/1541] Reconstruct periodic connection correctly upon
 reloading via the loadsave system

---
 loadsave.py | 56 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 23 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 3e99ca4d..4e22695a 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -808,37 +808,47 @@ def load_state(filename):
                                            neighbor_id_2, neighbor_id_3] 
 
     # Figure out which sides are connected
-    connections = []
-    for to_connect_id, neighbor_list in connections_dict.iteritems():
+    # First treat the special case in which a plane is connected to itself (periodic BCs)
+    # Then all neighbor_id's are identical to to_connect_id, and we use a special
+    # function from gfrdbase.py to establish the connections automatically.
+    if [ to_connect_id==i for i in connections_dict[to_connect_id] ]:
 
-        # For each neighbor_id find the side with which the neighbor is
-        # connected to the structure with con_id
-        for side in range(0,4):
+        periodic_connect(w, structures_dict[to_connect_id])
+        log.info('  Running periodic_connect for %s' % structures_dict[to_connect_id])
 
-            n_id = neighbor_list[side]
-            nn_list = connections_dict[n_id]
+    else:
 
-            for n_side in range(0,4):
-            
-                nn_id = nn_list[n_side]
-                if nn_id == to_connect_id:
-                # We have found the neighbor_id that links to con_id
-                    connections.append( (to_connect_id, side, n_id, n_side) )
-                    break
+        connections = []
+        for to_connect_id, neighbor_list in connections_dict.iteritems():
 
-    if __debug__:
-        log.info('  connections = %s' % str(connections) )
+            # For each neighbor_id find the side with which the neighbor is
+            # connected to the structure with con_id
+            for side in range(0,4):
 
-    # Establish the connections
-    for struct_id0, side0, struct_id1, side1 in connections:
+                n_id = neighbor_list[side]
+                nn_list = connections_dict[n_id]
 
-        struct0 = structures_dict[struct_id0]
-        struct1 = structures_dict[struct_id1]
+                for n_side in range(0,4):
+                
+                    nn_id = nn_list[n_side]
+                    if nn_id == to_connect_id:
+                    # We have found the neighbor_id that links to con_id
+                        connections.append( (to_connect_id, side, n_id, n_side) )
+                        break
 
-        w.connect_structures(struct0, side0, struct1, side1)
         if __debug__:
-            log.info('  Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
-                     % (side0, struct0, struct0.id, side1, struct1, struct1.id) )
+            log.info('  connections = %s' % str(connections) )
+
+        # Establish the connections
+        for struct_id0, side0, struct_id1, side1 in connections:
+
+            struct0 = structures_dict[struct_id0]
+            struct1 = structures_dict[struct_id1]
+
+            w.connect_structures(struct0, side0, struct1, side1)
+            if __debug__:
+                log.info('  Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
+                        % (side0, struct0, struct0.id, side1, struct1, struct1.id) )
 
     #### PARTICLES ####
     if __debug__:

From f5b5cafc8833a0daa19ca4c61e069ae3efed7134 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 22 Aug 2013 15:19:48 +0200
Subject: [PATCH 1339/1541] Fix an object creation loop that caused huge memory
 leaks

---
 StructureContainer.hpp | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 81fae03e..28858be4 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -375,9 +375,11 @@ class StructureContainer
 //// functions for Planes
 template<typename Ttraits_ >
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
-apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type> const& pos_structure_id,
-                PlanarSurface<Ttraits_> const& planar_surface,
-                StructureContainer<typename Ttraits_::structure_type, typename Ttraits_::structure_id_type, Ttraits_> const& sc)
+apply_boundary (std::pair<typename Ttraits_::position_type,
+                          typename Ttraits_::structure_id_type> const&                     pos_structure_id,
+                PlanarSurface<Ttraits_> const&                                             planar_surface,
+                StructureContainer<typename Ttraits_::structure_type, 
+                                   typename Ttraits_::structure_id_type, Ttraits_> const&  sc)
 // The template needs to be parameterized with the appropriate shape (which then parameterizes the type
 // of the ConnectivityContainer that we use.
 // We supply the structure container as an argument so that we can get the structures that we need, and to
@@ -397,16 +399,16 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
     // and that the position is already transposed for the plane.
     const plane_type origin_plane( planar_surface.shape() );
-    boost::array<length_type, 2> half_extents( origin_plane.half_extent() );
+    const boost::array<length_type, 2> half_extents( origin_plane.half_extent() );
 
     const position_type pos_vector( subtract(pos_structure_id.first, origin_plane.position()) );
-    const length_type component_x ( dot_product(pos_vector, origin_plane.unit_x()) );
-    const length_type component_y ( dot_product(pos_vector, origin_plane.unit_y()) );
+    const length_type   component_x ( dot_product(pos_vector, origin_plane.unit_x()) );
+    const length_type   component_y ( dot_product(pos_vector, origin_plane.unit_y()) );
 
     // declare the variables that will be written
-    structure_id_type new_id(pos_structure_id.second);
-    position_type neighbor_plane_par;
-    position_type neighbor_plane_inl;
+    structure_id_type new_id( pos_structure_id.second );
+    position_type     neighbor_plane_par;
+    position_type     neighbor_plane_inl;
 
     if ( abs(component_x) <= half_extents[0] && abs(component_y) <= half_extents[1] )
     {
@@ -469,7 +471,9 @@ apply_boundary (std::pair<typename Ttraits_::position_type, typename Ttraits_::s
         const position_type new_pos ( add(origin_plane.position(), add(neighbor_plane_par, neighbor_plane_inl)));
 
         // Check if we are in one of the corners. If yes -> do another round of border crossing from neighboring plane.
-        if ( abs(component_x) > half_extents[0] && abs(component_y) > half_extents[1] )
+        // Only do this if the particle does not end up on another side of the same plane (the scenario of one plane 
+        // with periodic BCs), as this may cause infinite loops.
+        if( not new_id==pos_structure_id.second && abs(component_x) > half_extents[0] && abs(component_y) > half_extents[1] )
         {
             return sc.get_structure(new_id)->apply_boundary(std::make_pair(new_pos, new_id), sc);
         }

From 8976f07b5ff7605227c50dd2a256ada6d1015c8d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 22 Aug 2013 16:48:51 +0200
Subject: [PATCH 1340/1541] WIP - some debug statements

---
 egfrd.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index a1370030..6c8af523 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1448,6 +1448,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                 newpos1 = self.world.apply_boundary(newpos1)
                 newpos2 = self.world.apply_boundary(newpos2)
 
+                log.debug('newpos1=%s, newpos2=%s, distance=%s', newpos1, newpos2, self.world.distance(newpos1, newpos2) )
+                # TODO Remove, this is for DEBUGGING only
+
                 if __debug__:
                     assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
 

From b96d8327696e1d32451e11e1d22855aa556a5f55 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 22 Aug 2013 20:08:54 +0200
Subject: [PATCH 1341/1541] This is not the right way to treat it...

---
 gfrdbase.py |  9 +++++----
 loadsave.py | 35 +++++++++++++++++------------------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 349f11e2..1f6eff1b 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -349,10 +349,11 @@ def periodic_connect(world, planar_surface):
         Use this to simulate particles on an infinite plane
         with periodic boundary conditions.
         
-    """
-    world.connect_structures(planar_surface, 0, planar_surface, 1)
-    world.connect_structures(planar_surface, 2, planar_surface, 3)
-    # TODO bind this function into world directly
+    """    
+    #world.connect_structures(planar_surface, 0, planar_surface, 1)
+    #world.connect_structures(planar_surface, 2, planar_surface, 3)    
+    pass 
+    # FIXME DOES NOT YET WORK CORRECTLY, THE STRUCTURE CONTAINER IS ASSUMING TRANSFER TO ADJACENT PLANES ONLY!
 
 def create_network_rules_wrapper(model):
     return _gfrd.NetworkRulesWrapper(model.network_rules)
diff --git a/loadsave.py b/loadsave.py
index 4e22695a..429d3f2f 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -808,17 +808,16 @@ def load_state(filename):
                                            neighbor_id_2, neighbor_id_3] 
 
     # Figure out which sides are connected
-    # First treat the special case in which a plane is connected to itself (periodic BCs)
-    # Then all neighbor_id's are identical to to_connect_id, and we use a special
-    # function from gfrdbase.py to establish the connections automatically.
+    connections = []
+
     if [ to_connect_id==i for i in connections_dict[to_connect_id] ]:
 
-        periodic_connect(w, structures_dict[to_connect_id])
-        log.info('  Running periodic_connect for %s' % structures_dict[to_connect_id])
+        # Drop a warning in case someone tries to connect a plane to itself (currently unsupported)
+        log.warn('  Avoiding connecting plane to itself. This may result in incorrectly applied boundary conditions and further errors!')
 
     else:
-
-        connections = []
+        
+        # Everything fine, find the connections
         for to_connect_id, neighbor_list in connections_dict.iteritems():
 
             # For each neighbor_id find the side with which the neighbor is
@@ -834,21 +833,21 @@ def load_state(filename):
                     if nn_id == to_connect_id:
                     # We have found the neighbor_id that links to con_id
                         connections.append( (to_connect_id, side, n_id, n_side) )
-                        break
+                        break        
 
-        if __debug__:
-            log.info('  connections = %s' % str(connections) )
+    if __debug__:
+        log.info('  connections = %s' % str(connections) )
 
-        # Establish the connections
-        for struct_id0, side0, struct_id1, side1 in connections:
+    # Establish the connections
+    for struct_id0, side0, struct_id1, side1 in connections:
 
-            struct0 = structures_dict[struct_id0]
-            struct1 = structures_dict[struct_id1]
+        struct0 = structures_dict[struct_id0]
+        struct1 = structures_dict[struct_id1]
 
-            w.connect_structures(struct0, side0, struct1, side1)
-            if __debug__:
-                log.info('  Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
-                        % (side0, struct0, struct0.id, side1, struct1, struct1.id) )
+        w.connect_structures(struct0, side0, struct1, side1)
+        if __debug__:
+            log.info('  Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
+                    % (side0, struct0, struct0.id, side1, struct1, struct1.id) )
 
     #### PARTICLES ####
     if __debug__:

From 537f676b45c0c893a72d745dc92f42492a9b2d6f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 22 Aug 2013 20:15:28 +0200
Subject: [PATCH 1342/1541] further WIP

---
 ParticleContainerBase.hpp |  4 ++--
 egfrd.py                  |  3 ++-
 pair.py                   | 11 +++++++++--
 3 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 50b06c19..f57b194d 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -212,10 +212,10 @@ class ParticleContainerBase
         // TODO Clean this up when it is clear that cyclic_transpose is unnecessary here.
         const position_structid_pair_type cyc_pos_struct_id( pos_struct_id );
         // Get the structure
-        const boost::shared_ptr<const structure_type> structure (get_structure(pos_struct_id.second));
+        const boost::shared_ptr<const structure_type> structure( get_structure(pos_struct_id.second) );
         // The generalized boundary condition application first:
         // 1. applies the boundary of the structure/surface (go around the corner etc)
-        const position_structid_pair_type new_pos_struct_id(structure->apply_boundary(cyc_pos_struct_id, structures_));
+        const position_structid_pair_type new_pos_struct_id( structure->apply_boundary(cyc_pos_struct_id, structures_) );
         
         // 2. Then also apply the boundary condition of the world
         return std::make_pair(apply_boundary(new_pos_struct_id.first), new_pos_struct_id.second);
diff --git a/egfrd.py b/egfrd.py
index 6c8af523..2e44ff4d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1445,10 +1445,11 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             if __debug__:
                                 log.info('single reaction: product crosses plane, reaction will be rejected.')
 
+                log.debug('BEFORE: newpos1=%s, newpos2=%s, distance=%s, radii=%s', newpos1, newpos2, self.world.distance(newpos1, newpos2), particle_radius12 )
                 newpos1 = self.world.apply_boundary(newpos1)
                 newpos2 = self.world.apply_boundary(newpos2)
 
-                log.debug('newpos1=%s, newpos2=%s, distance=%s', newpos1, newpos2, self.world.distance(newpos1, newpos2) )
+                log.debug('AFTER: newpos1=%s, newpos2=%s, distance=%s, radii=%s', newpos1, newpos2, self.world.distance(newpos1, newpos2), particle_radius12 )
                 # TODO Remove, this is for DEBUGGING only
 
                 if __debug__:
diff --git a/pair.py b/pair.py
index 014e1726..9fdad1fc 100644
--- a/pair.py
+++ b/pair.py
@@ -683,16 +683,23 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # in the next step.
         new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
         new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
+        # FIXME Make sure this does not result in odd output in case a plane is NOT connected to any other!
+        # This may be in particular problematic if a "periodic" plane is as large as the world.
+        # To avoid problems, define a plane that is supposed to be periodic larger than the world.
 
         new_structure1 = world.get_structure(new_sid1)
         new_structure2 = world.get_structure(new_sid2)
 
+        log.debug('com=%s, iv=%s; parameters: radius1=%s, radius2=%s, D1=%s, D2=%s, D_tot=%s', com, iv, radius1, radius2, D1, D2, D_tot)
+        log.debug('pos1=%s, pos2=%s, sid=%s', pos1, pos2, structure1.id)
+        log.debug('new_pos1=%s, new_pos2=%s, new_sid1=%s, new_sid2=%s', new_pos1, new_pos2, new_sid1, new_sid2)
+
         # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
-        # Only to this correction if the two planes are really orthogonal
+        # Only to this correction if the two planes are really orthogonal (assumed in the calculation)
         if  world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR \
         and feq( numpy.dot(new_structure1.shape.unit_z, new_structure2.shape.unit_z), 0.0 ) :
 
-            log.warn('do_back_transform: Removing overlap resulting from deflection for particles ending up on orthogonal planes.')
+            log.warn('do_back_transform: Removing overlap resulting from deflection of particles at the edge of orthogonal planes.')
             
             # Calculate the distances from the two new positions to the edge between the planes
             # in which the particles temporarily ended up

From fe16a8d3edb869eb9d587029906fdcb0842d7f2b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 23 Aug 2013 14:45:38 +0200
Subject: [PATCH 1343/1541] Only try to establish connections at loading if
 such are declared in the input file.

---
 loadsave.py | 85 +++++++++++++++++++++++++++++------------------------
 1 file changed, 47 insertions(+), 38 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 429d3f2f..35d9baca 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -795,59 +795,68 @@ def load_state(filename):
     # Here we first read in all the connections and then figure out which sides are
     # connected in order to actually connect them.
     sc_sections = filter_sections(cp.sections(), 'STRUCTURECONNECTION')
-    for sectionname in sorted(sc_sections, key = lambda name : name_to_int(name)):
 
-        to_connect_id = name_to_int(sectionname)
+    if sc_sections:
 
-        neighbor_id_0 = cp.getint(sectionname, 'neighbor_id_0')
-        neighbor_id_1 = cp.getint(sectionname, 'neighbor_id_1')
-        neighbor_id_2 = cp.getint(sectionname, 'neighbor_id_2')
-        neighbor_id_3 = cp.getint(sectionname, 'neighbor_id_3')
+        for sectionname in sorted(sc_sections, key = lambda name : name_to_int(name)):
 
-        connections_dict[to_connect_id] = [neighbor_id_0, neighbor_id_1, \
-                                           neighbor_id_2, neighbor_id_3] 
+            to_connect_id = name_to_int(sectionname)
 
-    # Figure out which sides are connected
-    connections = []
+            neighbor_id_0 = cp.getint(sectionname, 'neighbor_id_0')
+            neighbor_id_1 = cp.getint(sectionname, 'neighbor_id_1')
+            neighbor_id_2 = cp.getint(sectionname, 'neighbor_id_2')
+            neighbor_id_3 = cp.getint(sectionname, 'neighbor_id_3')
 
-    if [ to_connect_id==i for i in connections_dict[to_connect_id] ]:
+            connections_dict[to_connect_id] = [neighbor_id_0, neighbor_id_1, \
+                                              neighbor_id_2, neighbor_id_3] 
 
-        # Drop a warning in case someone tries to connect a plane to itself (currently unsupported)
-        log.warn('  Avoiding connecting plane to itself. This may result in incorrectly applied boundary conditions and further errors!')
+        # Figure out which sides are connected
+        connections = []
 
-    else:
-        
-        # Everything fine, find the connections
-        for to_connect_id, neighbor_list in connections_dict.iteritems():
+        if [ to_connect_id==i for i in connections_dict[to_connect_id] ]:
+
+            # Drop a warning in case someone tries to connect a plane to itself (currently unsupported)
+            log.warn('  Avoiding connecting plane to itself. This may result in incorrectly applied boundary conditions and further errors!')
 
-            # For each neighbor_id find the side with which the neighbor is
-            # connected to the structure with con_id
-            for side in range(0,4):
+        else:
+            
+            # Everything fine, find the connections
+            for to_connect_id, neighbor_list in connections_dict.iteritems():
 
-                n_id = neighbor_list[side]
-                nn_list = connections_dict[n_id]
+                # For each neighbor_id find the side with which the neighbor is
+                # connected to the structure with con_id
+                for side in range(0,4):
 
-                for n_side in range(0,4):
-                
-                    nn_id = nn_list[n_side]
-                    if nn_id == to_connect_id:
-                    # We have found the neighbor_id that links to con_id
-                        connections.append( (to_connect_id, side, n_id, n_side) )
-                        break        
+                    n_id = neighbor_list[side]
+                    nn_list = connections_dict[n_id]
 
-    if __debug__:
-        log.info('  connections = %s' % str(connections) )
+                    for n_side in range(0,4):
+                    
+                        nn_id = nn_list[n_side]
+                        if nn_id == to_connect_id:
+                        # We have found the neighbor_id that links to con_id
+                            connections.append( (to_connect_id, side, n_id, n_side) )
+                            break        
 
-    # Establish the connections
-    for struct_id0, side0, struct_id1, side1 in connections:
+        if __debug__:
+            log.info('  connections = %s' % str(connections) )
+
+        # Establish the connections
+        for struct_id0, side0, struct_id1, side1 in connections:
+
+            struct0 = structures_dict[struct_id0]
+            struct1 = structures_dict[struct_id1]
 
-        struct0 = structures_dict[struct_id0]
-        struct1 = structures_dict[struct_id1]
+            w.connect_structures(struct0, side0, struct1, side1)
+            if __debug__:
+                log.info('  Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
+                        % (side0, struct0, struct0.id, side1, struct1, struct1.id) )
+
+    else: # sc_sections empty
 
-        w.connect_structures(struct0, side0, struct1, side1)
         if __debug__:
-            log.info('  Connected side %s of structure %s (id=%s) with side %s of structure %s (id=%s)' \
-                    % (side0, struct0, struct0.id, side1, struct1, struct1.id) )
+            log.info('No connections found in input file.')
+
 
     #### PARTICLES ####
     if __debug__:

From f2d247d37944ba670c2a63dd7010c4b8cc4bd9d2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 23 Aug 2013 15:14:40 +0200
Subject: [PATCH 1344/1541] Avoid applying boundary cond. to self-connected
 planes + warn + link logger into StructureContainer.hpp

---
 ConnectivityContainer.hpp |  9 ++++++---
 StructureContainer.hpp    | 29 +++++++++++++++++++++++++----
 2 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/ConnectivityContainer.hpp b/ConnectivityContainer.hpp
index f81746b4..8e13bd01 100644
--- a/ConnectivityContainer.hpp
+++ b/ConnectivityContainer.hpp
@@ -3,6 +3,7 @@
 
 #include <boost/lexical_cast.hpp>
 #include "exceptions.hpp"
+#include <iostream>
 
 
 template<typename Tobj_, typename Tdata_, std::size_t num_neighbors>
@@ -49,12 +50,14 @@ class ConnectivityContainer
         if ( n >= max )
             throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
 
-        typename obj_neighbor_objdata_array_map::const_iterator i(neighbor_mapping_.find(id));
-        if (neighbor_mapping_.end() == i)
+        typename obj_neighbor_objdata_array_map::const_iterator it(neighbor_mapping_.find(id));
+        std::cout << "Checking neighbor info, id=" << boost::lexical_cast<std::string>(id) << ", it=" << it->first << std::endl; // TODO remove after debugging
+        if (it==neighbor_mapping_.end())
         {
             throw not_found(std::string("Object not found(id=") + boost::lexical_cast<std::string>(id) + ")");
         }
-        return (*i).second[n];
+        // all fine
+        return (*it).second[n];
     }
 
     ConnectivityContainer() {}
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 28858be4..19f93cd7 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -3,6 +3,7 @@
 
 #include <boost/lexical_cast.hpp>
 #include "exceptions.hpp"
+#include "Logger.hpp"
 #include "linear_algebra.hpp"
 #include "ConnectivityContainer.hpp"
 #include "CuboidalRegion.hpp"
@@ -366,12 +367,19 @@ class StructureContainer
     cylindrical_surface_bc_type cylindrical_structs_bc_;
     planar_surface_bc_type      planar_structs_bc_;
     cuboidal_region_bc_type     cuboidal_structs_bc_;
-};
+    static Logger&              log_;
+    
+}; // end of class definition
 
 
+//////// Link logger to the global logging system
+template <typename Tobj_, typename Tid_, typename Ttraits_>
+Logger& StructureContainer<Tobj_, Tid_, Ttraits_>::log_(Logger::get_logger("ecell.newBDPropagator"));
+//////// Also define one that can be used by the inline functions below
+static Logger& log_(Logger::get_logger("ecell.newBDPropagator"));
 
-//////// Inline functions applicable to the StructureContainer
 
+//////// Inline functions applicable to the StructureContainer
 //// functions for Planes
 template<typename Ttraits_ >
 inline std::pair<typename Ttraits_::position_type, typename Ttraits_::structure_id_type>
@@ -409,8 +417,21 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
     structure_id_type new_id( pos_structure_id.second );
     position_type     neighbor_plane_par;
     position_type     neighbor_plane_inl;
-
-    if ( abs(component_x) <= half_extents[0] && abs(component_y) <= half_extents[1] )
+    
+    // Check for (currently unsupported) self-connections
+    for( int i=0; i<4; i++ )
+    {
+        const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 0));
+        new_id = neighbor_id_vector.first;
+        
+        if( new_id == pos_structure_id.second )
+        {
+            log_.warn("Plane is connected to itself, which is unsupported; no boundary condition will be applied at this call.");
+            return pos_structure_id;
+        }
+    };
+    
+    if( (abs(component_x) <= half_extents[0] && abs(component_y) <= half_extents[1]) )
     {
         // we are still in the plane (did not pass any of the boundaries)
         // don't have to do anything

From 2ffcd07a7f21036679a3191a4ee88a8b58268cd4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 23 Aug 2013 15:15:36 +0200
Subject: [PATCH 1345/1541] WIP

---
 egfrd.py | 5 +++--
 pair.py  | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 2e44ff4d..debe2bb9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1445,12 +1445,13 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             if __debug__:
                                 log.info('single reaction: product crosses plane, reaction will be rejected.')
 
-                log.debug('BEFORE: newpos1=%s, newpos2=%s, distance=%s, radii=%s', newpos1, newpos2, self.world.distance(newpos1, newpos2), particle_radius12 )
+                log.debug('BEFORE: newpos1=%s, newpos2=%s, diff=%s, w.distance=%s, length(diff)=%s, radii=%s', newpos1, newpos2, newpos1-newpos2, self.world.distance(newpos1, newpos2), length(newpos1-newpos2), particle_radius12 )
                 newpos1 = self.world.apply_boundary(newpos1)
                 newpos2 = self.world.apply_boundary(newpos2)
 
-                log.debug('AFTER: newpos1=%s, newpos2=%s, distance=%s, radii=%s', newpos1, newpos2, self.world.distance(newpos1, newpos2), particle_radius12 )
+                log.debug('AFTER: newpos1=%s, newpos2=%s, diff=%s, w.distance=%s, length(diff)=%s, radii=%s', newpos1, newpos2, newpos1-newpos2, self.world.distance(newpos1, newpos2), length(newpos1-newpos2), particle_radius12 )
                 # TODO Remove, this is for DEBUGGING only
+                # FIXME!!!! world.distance seems not to work correctly when one of the positions is close the the world boundary!!!
 
                 if __debug__:
                     assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
diff --git a/pair.py b/pair.py
index 9fdad1fc..bb02bee7 100644
--- a/pair.py
+++ b/pair.py
@@ -690,8 +690,8 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         new_structure1 = world.get_structure(new_sid1)
         new_structure2 = world.get_structure(new_sid2)
 
-        log.debug('com=%s, iv=%s; parameters: radius1=%s, radius2=%s, D1=%s, D2=%s, D_tot=%s', com, iv, radius1, radius2, D1, D2, D_tot)
-        log.debug('pos1=%s, pos2=%s, sid=%s', pos1, pos2, structure1.id)
+        log.debug('com=%s, iv=%s, length=%s; parameters: radius1=%s, radius2=%s, D1=%s, D2=%s, D_tot=%s', com, iv, length(iv), radius1, radius2, D1, D2, D_tot)
+        log.debug('pos1=%s, pos2=%s, sid=%s, distance=%s', pos1, pos2, structure1.id, length(pos2-pos1))
         log.debug('new_pos1=%s, new_pos2=%s, new_sid1=%s, new_sid2=%s', new_pos1, new_pos2, new_sid1, new_sid2)
 
         # If the new positions lead to an overlap we have to enlarge the IV by a safety factor

From 608ac938ccb7c72c10c0bc9ad64e34ca290516ff Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 23 Aug 2013 15:20:14 +0200
Subject: [PATCH 1346/1541] Some cleanup

---
 egfrd.py |  5 -----
 pair.py  | 11 +++--------
 2 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index debe2bb9..a1370030 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1445,14 +1445,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             if __debug__:
                                 log.info('single reaction: product crosses plane, reaction will be rejected.')
 
-                log.debug('BEFORE: newpos1=%s, newpos2=%s, diff=%s, w.distance=%s, length(diff)=%s, radii=%s', newpos1, newpos2, newpos1-newpos2, self.world.distance(newpos1, newpos2), length(newpos1-newpos2), particle_radius12 )
                 newpos1 = self.world.apply_boundary(newpos1)
                 newpos2 = self.world.apply_boundary(newpos2)
 
-                log.debug('AFTER: newpos1=%s, newpos2=%s, diff=%s, w.distance=%s, length(diff)=%s, radii=%s', newpos1, newpos2, newpos1-newpos2, self.world.distance(newpos1, newpos2), length(newpos1-newpos2), particle_radius12 )
-                # TODO Remove, this is for DEBUGGING only
-                # FIXME!!!! world.distance seems not to work correctly when one of the positions is close the the world boundary!!!
-
                 if __debug__:
                     assert (self.world.distance(newpos1, newpos2) >= particle_radius12)
 
diff --git a/pair.py b/pair.py
index bb02bee7..6898717f 100644
--- a/pair.py
+++ b/pair.py
@@ -681,19 +681,14 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         # In some cases the new positions may end up on adjacent planar surfaces.
         # This may lead to an overlap which has to be checked for and removed if present
         # in the next step.
+        # Note that this will be also done for unconnected planes, so it has to be
+        # made sure that apply_boundary does work correctly in these cases.
         new_pos1, new_sid1 = world.apply_boundary((pos1, structure1.id))
-        new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))
-        # FIXME Make sure this does not result in odd output in case a plane is NOT connected to any other!
-        # This may be in particular problematic if a "periodic" plane is as large as the world.
-        # To avoid problems, define a plane that is supposed to be periodic larger than the world.
+        new_pos2, new_sid2 = world.apply_boundary((pos2, structure1.id))        
 
         new_structure1 = world.get_structure(new_sid1)
         new_structure2 = world.get_structure(new_sid2)
 
-        log.debug('com=%s, iv=%s, length=%s; parameters: radius1=%s, radius2=%s, D1=%s, D2=%s, D_tot=%s', com, iv, length(iv), radius1, radius2, D1, D2, D_tot)
-        log.debug('pos1=%s, pos2=%s, sid=%s, distance=%s', pos1, pos2, structure1.id, length(pos2-pos1))
-        log.debug('new_pos1=%s, new_pos2=%s, new_sid1=%s, new_sid2=%s', new_pos1, new_pos2, new_sid1, new_sid2)
-
         # If the new positions lead to an overlap we have to enlarge the IV by a safety factor
         # Only to this correction if the two planes are really orthogonal (assumed in the calculation)
         if  world.distance(new_pos1, new_pos2) <= (radius1+radius2) * MINIMAL_SEPARATION_FACTOR \

From 7f3b20c2e9381fd0edccc08351baf3bed8b179cc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 23 Aug 2013 15:27:50 +0200
Subject: [PATCH 1347/1541] Mark a problematic feature in
 StructureContainer.hpp

Making finite planes reflective by default if they are not connected
to others is dangerous: Particles that will dissociate close to the boundary
such that one of them reaches out of the plane will be reflected back,
causing overlaps! This has to be rethought!
---
 StructureContainer.hpp | 2 +-
 loadsave.py            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 19f93cd7..2b2cebbb 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -141,7 +141,7 @@ class StructureContainer
         if ( update_structure_base(structid_plane))
         {
             // We now assume that the structure was not already in the boundary_conditions_thing
-            // add to Connectivity container for planar surfaces and set reflective boundary conditions.
+            // add to Connectivity container for planar surfaces and set *reflective* boundary conditions. // TODO This may cause many problems in single reactions!!! Overthink!!!
             planar_structs_bc_.set_neighbor_info(structid_plane.first, 0, std::make_pair(structid_plane.first, multiply(structid_plane.second->shape().unit_y(), -1.0) ));
             planar_structs_bc_.set_neighbor_info(structid_plane.first, 1, std::make_pair(structid_plane.first,          structid_plane.second->shape().unit_y() ));
             planar_structs_bc_.set_neighbor_info(structid_plane.first, 2, std::make_pair(structid_plane.first,          structid_plane.second->shape().unit_x() ));
diff --git a/loadsave.py b/loadsave.py
index 35d9baca..f573dc3c 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -855,7 +855,7 @@ def load_state(filename):
     else: # sc_sections empty
 
         if __debug__:
-            log.info('No connections found in input file.')
+            log.info('  No connections found in input file.')
 
 
     #### PARTICLES ####

From 37feaa03ada9d5ec432dade2b8243a21f95919b1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 26 Aug 2013 11:52:13 +0200
Subject: [PATCH 1348/1541] Temporarily remove debug statement

---
 ConnectivityContainer.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ConnectivityContainer.hpp b/ConnectivityContainer.hpp
index 8e13bd01..657d73f8 100644
--- a/ConnectivityContainer.hpp
+++ b/ConnectivityContainer.hpp
@@ -51,7 +51,7 @@ class ConnectivityContainer
             throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
 
         typename obj_neighbor_objdata_array_map::const_iterator it(neighbor_mapping_.find(id));
-        std::cout << "Checking neighbor info, id=" << boost::lexical_cast<std::string>(id) << ", it=" << it->first << std::endl; // TODO remove after debugging
+        //std::cout << "Checking neighbor info, id=" << boost::lexical_cast<std::string>(id) << ", it=" << it->first << std::endl; // TODO remove after debugging
         if (it==neighbor_mapping_.end())
         {
             throw not_found(std::string("Object not found(id=") + boost::lexical_cast<std::string>(id) + ")");

From df83ed2649f58c18b6048478d2d459305d924736 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 27 Aug 2013 12:31:11 +0200
Subject: [PATCH 1349/1541] Forgot an important any() in if-statement

---
 loadsave.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/loadsave.py b/loadsave.py
index f573dc3c..b19a1437 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -813,7 +813,7 @@ def load_state(filename):
         # Figure out which sides are connected
         connections = []
 
-        if [ to_connect_id==i for i in connections_dict[to_connect_id] ]:
+        if any([ to_connect_id==i for i in connections_dict[to_connect_id] ]):
 
             # Drop a warning in case someone tries to connect a plane to itself (currently unsupported)
             log.warn('  Avoiding connecting plane to itself. This may result in incorrectly applied boundary conditions and further errors!')

From 21e63813d859be744296a32013bc9bffbaffdf79 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Aug 2013 16:08:04 +0200
Subject: [PATCH 1350/1541] Set overlap removing to False as default

---
 egfrd.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index a1370030..a4d42ee1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -234,7 +234,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
                                                 # to calculate ridiculously small timesteps, but will break detail balance.
                                                 # Take care: This is for testing only! Keep this at a negative value for normal sims!
 
-        self.REMOVE_OVERLAPS = True             # Ignore overlaps, only warn when they happen and move particles apart
+        self.REMOVE_OVERLAPS = False            # Ignore overlaps, only warn when they happen and move particles apart
         self.max_overlap_error = 0.0            # This remembers the largest relative error produced by removing overlaps
 
         # used datastructrures

From 048824e4f72b58f962e3c78947118e3b743003fa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Aug 2013 16:16:27 +0200
Subject: [PATCH 1351/1541] Simple on/off functions for overlap remover

---
 egfrd.py | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index a1370030..085246a6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -708,6 +708,32 @@ def move_particle(self, pid_particle_pair, position, structure_id):
         return new_pid_particle_pair
 
 
+    def activate_overlap_remover():
+        """
+        Sets internal variable REMOVE_OVERLAPS to True (False by default),
+        activating the removal of overlaps while monitoring the relative 
+        error produced by that.
+
+        The rel. error is defined as the separation added between particles 
+        divided by the largest involved radius.
+
+        Use deactivate_overlap_remover() to reverse this.
+        """
+
+        self.REMOVE_OVERLAPS = True
+
+
+    def deactivate_overlap_remover():
+        """
+        Sets internal variable REMOVE_OVERLAPS to False, 
+        deactivating the removal of overlaps.
+        
+        Use activate_overlap_remover() to activate it.
+        """
+
+        self.REMOVE_OVERLAPS = False
+
+
     def remove_overlap(self, reactant, target_position, ignore_p=None):
 
         # Get overlaps when moved to target position

From 189c3657fc2165511ab1238cd9b064b788a540b7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Aug 2013 16:43:25 +0200
Subject: [PATCH 1352/1541] Compactify fire_single_reactino() a bit

---
 egfrd.py | 49 +++++++++++++++++++++++++------------------------
 1 file changed, 25 insertions(+), 24 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0a643ea4..6a0ca535 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1119,7 +1119,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             product_structure_type_id = product_species.structure_type_id
 
             # 1.5 get new position and structure_id of particle
-            # If the particle falls off a surface (non CuboidalRegion)
+            # If the particle falls off a surface (other than CuboidalRegion)
             if product_structure_type_id != reactant_structure_type_id:
                 assert (product_structure_type_id == self.world.get_def_structure_type_id())
 
@@ -1153,6 +1153,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     #vector_length = 1.0*product_radius * MINIMAL_SEPARATION_FACTOR
                     #vector        = reactant_pos + vector_length * reactant_structure.shape.unit_z
                     #product_pos_list.append(vector)
+
                     # unbinding perpendicularly to disk unit vector (i.e. like on cylinder)
                     vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
                     for _ in range(self.dissociation_retry_moves):
@@ -1167,6 +1168,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
                 product_structure_id = self.world.get_def_structure_id()    # product structure is always the default structure (bulk)
+                # FIXME This should rather be the parent structure!
 
             # If decay happens to same structure_type
             else:
@@ -1242,12 +1244,12 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                 assert ((product1_structure_type_id == self.world.get_def_structure_type_id()) ^ \
                         (product2_structure_type_id == self.world.get_def_structure_type_id()))
 
-                # Figure out which product stays in the surface and which one goes to 3D
+                # Figure out which product stays in the surface and which one goes to 3D # FIXME It rather should go to the parent structure!
                 # Note that A is a particle in the surface and B is in the 3D
                 if (product2_structure_type_id == self.world.get_def_structure_type_id()):
                     # product2 goes to 3D and is now particleB (product1 is particleA and is on the surface)
                     product1_structure_id = reactant_structure_id # TODO after the displacement the structure can change!
-                    product2_structure_id = self.world.get_def_structure_id()
+                    product2_structure_id = self.world.get_def_structure_id() # FIXME see above
                     productA_radius = product1_radius
                     productB_radius = product2_radius
                     DA = D1
@@ -1256,13 +1258,27 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                 else:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
                     product2_structure_id = reactant_structure_id
-                    product1_structure_id = self.world.get_def_structure_id()
+                    product1_structure_id = self.world.get_def_structure_id() # FIXME see above
                     productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2
                     DB = D1
                     default = False
 
+                # We have to readjust this again in the end, when creating product positions, etc.
+                # This is handled by the following function.
+                def conditional_swap(newposA, newposB):
+
+                    if default:
+                        return (newposA, newposB)
+                    else:
+                        return (newposB, newposA)
+
+                # Initialize product positions list
+                product_pos_list = []
+
+                # OK.
+                # Now let's check what actually happens.
                 if isinstance(reactant_structure, PlanarSurface):
                     # draw a number of new positions for the two product particles
                     # TODO make this a generator
@@ -1284,8 +1300,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                             #bounding_surfaces.append( (surface, surface_distance) )
 
                     # OK, now sample new positions
-                    product_pos_list = []
-                    for _ in range(self.dissociation_retry_moves):                        
+                    for _ in range(self.dissociation_retry_moves):
 
                         # determine the side of the membrane the dissociation takes place
                         if(reactant_structure.shape.is_one_sided):
@@ -1333,15 +1348,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                                   # TODO This should not necessarily raise RuntimeError but just a warning;
                                                   # this is for TESTING only; replace by something better
 
-                        if default:
-                            newpos1, newpos2 = newposA, newposB
-                        else:
-                            newpos1, newpos2 = newposB, newposA
-                        product_pos_list.append((newpos1, newpos2))
+                        product_pos_list.append(conditional_swap(newposA, newposB))
 
                 elif isinstance(reactant_structure, CylindricalSurface):
 
-                    product_pos_list = []
                     for _ in range(self.dissociation_retry_moves):
                         iv = random_vector(particle_radius12 * MixedPair1D3D.calc_r_scaling_factor(DA, DB))
                         iv *= MINIMAL_SEPARATION_FACTOR
@@ -1359,16 +1369,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         if __debug__:
                             assert (self.world.distance(reactant_structure.shape, newposB) >= productB_radius)
 
-                        if default:
-                            newpos1, newpos2 = newposA, newposB
-                        else:
-                            newpos1, newpos2 = newposB, newposA
-                        product_pos_list.append((newpos1, newpos2))
+                        product_pos_list.append(conditional_swap(newposA, newposB))
 
                 elif isinstance(reactant_structure, DiskSurface):
 
-                    product_pos_list = []
-
                     # productA always must stay on the disk, in the position of the reactant
                     newposA = reactant_pos
 
@@ -1381,16 +1385,13 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                                         (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
                         newposB = reactant_pos + vector_length * unit_vector2D                    
 
-                        if default:
-                            newpos1, newpos2 = newposA, newposB
-                        else:
-                            newpos1, newpos2 = newposB, newposA
-                        product_pos_list.append((newpos1, newpos2))
+                        product_pos_list.append(conditional_swap(newposA, newposB))
 
                 else:
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
+
             # 1.5 Get new positions and structure_ids of particles
             #     If the two particles stay on the same structure type as the reactant
             #     (but not necessarily on the same structure!)

From 69d0c176d84d8241d81f39d287efabebd5f9dd0b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Aug 2013 19:23:13 +0200
Subject: [PATCH 1353/1541] Allow user to specify custom parent structures for
 caps

---
 gfrdbase.py | 36 ++++++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 10 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 1f6eff1b..988d0d56 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -264,7 +264,9 @@ def create_box(world, structure_type, center, size, one_sided=True):
     world.connect_structures(bottom, 3, right, 2)
     world.connect_structures(bottom, 2, left, 1)
 
-def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length, front_cap_structure_type=None, back_cap_structure_type=None):
+def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length, \
+               front_cap_structure_type=None,   back_cap_structure_type=None,  \
+               front_cap_parent_structure=None, back_cap_parent_structure=None ):
     """ Creates a cylinder with two disk-caps at its ends and adds it to the world.
 
         The function ensures that the orientation vectors of the disks point
@@ -299,11 +301,15 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
                 the rod length
 
         Optional arguments:
-            - front_cap = [True/False]
-                if set to false, the front cap will not be placed;
-                True by default
-            - back_cap = [True/False]
-                same as above
+            - front_cap_structure_type
+                overrides the default structure type for the front cap
+            - back_cap_structure_type
+                same for the back cap
+            - front_cap_parent_structure
+                overrides the default parent structure (= the created rod)
+                of the front cap
+            - back_cap_parent_structure
+                same for the back cap
     """    
     # Assert that the location and size is ok
     position = numpy.array(position)
@@ -326,19 +332,29 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
     if front_cap_structure_type:
         front_cap_sid = front_cap_structure_type.id
     if back_cap_structure_type:
-        back_cap_sid  = back_cap_structure_type.id
+        back_cap_sid  = back_cap_structure_type.id    
          
     # Create the cylinder of the rod
     rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', position, radius, orientation, length, def_struct_id)
     world.add_structure(rod) # This must happen directly here otherwise rod.id will be undefined
-
+    
+    # By default the parent structure of the caps is the rod:
+    front_cap_parent_id = rod.id
+    back_cap_parent_id = rod.id
+    # Check whether the user wishes to make the caps child structures of sth. else than the rod
+    if front_cap_parent_structure:
+        front_cap_parent_id = front_cap_parent_structure.id
+    # same for the other cap
+    if back_cap_parent_structure:
+        back_cap_parent_id = back_cap_parent_structure.id
+    
     # Create the caps
     front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
-    front_cap = model.create_disk_surface(front_cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, rod.id)
+    front_cap = model.create_disk_surface(front_cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, front_cap_parent_id)
     world.add_structure(front_cap)
 
     back_cap_pos = position
-    back_cap = model.create_disk_surface(back_cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], rod.id)
+    back_cap = model.create_disk_surface(back_cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], back_cap_parent_id)
     world.add_structure(back_cap)    
 
     return rod.id

From 36fc72b729a6a28572a444374d9903b31e1516a7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 30 Aug 2013 19:35:59 +0200
Subject: [PATCH 1354/1541] Put dissociating particle on parent structure, not
 automatically into the bulk, in eGFRD mode

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6a0ca535..30db114b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1167,8 +1167,8 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
-                product_structure_id = self.world.get_def_structure_id()    # product structure is always the default structure (bulk)
-                # FIXME This should rather be the parent structure!
+                #product_structure_id = self.world.get_def_structure_id()    # product structure is always the default structure (bulk)
+                product_structure_id = reactant_structure.structure_id    # product structure is always the parent structure; in most cases this is the bulk
 
             # If decay happens to same structure_type
             else:
@@ -1249,7 +1249,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                 if (product2_structure_type_id == self.world.get_def_structure_type_id()):
                     # product2 goes to 3D and is now particleB (product1 is particleA and is on the surface)
                     product1_structure_id = reactant_structure_id # TODO after the displacement the structure can change!
-                    product2_structure_id = self.world.get_def_structure_id() # FIXME see above
+                    product2_structure_id = reactant_structure.structure_id     # the parent structure
                     productA_radius = product1_radius
                     productB_radius = product2_radius
                     DA = D1
@@ -1258,7 +1258,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                 else:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
                     product2_structure_id = reactant_structure_id
-                    product1_structure_id = self.world.get_def_structure_id() # FIXME see above
+                    product1_structure_id = reactant_structure.structure_id     # the parent structure
                     productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2

From 784e11bf20566ecde867cefbaa73922a1541e5f9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Sep 2013 14:28:24 +0200
Subject: [PATCH 1355/1541] Return structure IDs when creating a box + feed in
 IDs for optional parent structures of rod instead of structure object itself

---
 gfrdbase.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 988d0d56..52e1b19a 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -199,6 +199,9 @@ def create_world(m, matrix_size=10):
 def create_box(world, structure_type, center, size, one_sided=True):
     """ Creates a box of PlanarSurface sections and adds it to the world.
 
+        Returns a list of the IDs of the separate planes in the following
+        order: [front.id, back.id, left.id, right.id, top.id, bottom.id].
+
         Arguments:
             - world
                 the world that the geometry is constructed in
@@ -264,9 +267,13 @@ def create_box(world, structure_type, center, size, one_sided=True):
     world.connect_structures(bottom, 3, right, 2)
     world.connect_structures(bottom, 2, left, 1)
 
+    # Return a list containing the IDs of the created planes
+    # in case that the user wishes to operate on them separately
+    return [front.id, back.id, left.id, right.id, top.id, bottom.id]
+
 def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length, \
-               front_cap_structure_type=None,   back_cap_structure_type=None,  \
-               front_cap_parent_structure=None, back_cap_parent_structure=None ):
+               front_cap_structure_type=None,      back_cap_structure_type=None,  \
+               front_cap_parent_structure_id=None, back_cap_parent_structure_id=None ):
     """ Creates a cylinder with two disk-caps at its ends and adds it to the world.
 
         The function ensures that the orientation vectors of the disks point
@@ -343,10 +350,10 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
     back_cap_parent_id = rod.id
     # Check whether the user wishes to make the caps child structures of sth. else than the rod
     if front_cap_parent_structure:
-        front_cap_parent_id = front_cap_parent_structure.id
+        front_cap_parent_id = front_cap_parent_structure_id
     # same for the other cap
     if back_cap_parent_structure:
-        back_cap_parent_id = back_cap_parent_structure.id
+        back_cap_parent_id = back_cap_parent_structure_id
     
     # Create the caps
     front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]

From 011f5f697d979242d4cf1c9d13cd8de00096de59 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Sep 2013 15:10:01 +0200
Subject: [PATCH 1356/1541] Revise naming convention for planes in box object

---
 gfrdbase.py | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 52e1b19a..9185c406 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -202,6 +202,15 @@ def create_box(world, structure_type, center, size, one_sided=True):
         Returns a list of the IDs of the separate planes in the following
         order: [front.id, back.id, left.id, right.id, top.id, bottom.id].
 
+        Naming convention:
+
+        front  = yz-plane intersecting the x-axis at the larger value
+        back   = yz-plane intersecting the x-axis at the smaller value
+        left   = xz-plane intersecting the y-axis at the smaller value
+        right  = xz-plane intersecting the y-axis at the larger value
+        top    = xy-plane intersecting the z-axis at the larger value
+        bottom = xy-plane intersecting the z-axis at the smaller value                
+
         Arguments:
             - world
                 the world that the geometry is constructed in
@@ -230,13 +239,14 @@ def create_box(world, structure_type, center, size, one_sided=True):
     else:
         create_planar_surface = model.create_double_sided_planar_surface
 
-    # Create the planes and add them to the world
-    front  = create_planar_surface(sid, name+'_front', [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
-    back   = create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
-    right  = create_planar_surface(sid, name+'_right', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
-    left   = create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
+    # Create the planes and add them to the world                          
+    front  = create_planar_surface(sid, name+'_front', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id) 
+    back   = create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
+    left   = create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
+    right  = create_planar_surface(sid, name+'_right', [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
     top    = create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
     bottom = create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
+
     world.add_structure(front)
     world.add_structure(back)
     world.add_structure(right)

From 5b7cfa99fb0c661b05adcb5b151ee0a04fd370b5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Sep 2013 15:16:07 +0200
Subject: [PATCH 1357/1541] Small fix

---
 gfrdbase.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 9185c406..f014b844 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -359,10 +359,10 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
     front_cap_parent_id = rod.id
     back_cap_parent_id = rod.id
     # Check whether the user wishes to make the caps child structures of sth. else than the rod
-    if front_cap_parent_structure:
+    if front_cap_parent_structure_id:
         front_cap_parent_id = front_cap_parent_structure_id
     # same for the other cap
-    if back_cap_parent_structure:
+    if back_cap_parent_structure_id:
         back_cap_parent_id = back_cap_parent_structure_id
     
     # Create the caps

From 71cf0133c5f3cd584110f93162e6bf18467be6cf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Sep 2013 18:30:09 +0200
Subject: [PATCH 1358/1541] Allow user to specify more details of the rod

---
 gfrdbase.py | 43 ++++++++++++++++++++++++++++++-------------
 1 file changed, 30 insertions(+), 13 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index f014b844..fffcb921 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -281,9 +281,12 @@ def create_box(world, structure_type, center, size, one_sided=True):
     # in case that the user wishes to operate on them separately
     return [front.id, back.id, left.id, right.id, top.id, bottom.id]
 
-def create_rod(world, cyl_structure_type, cap_structure_type, name, position, radius, orientation, length, \
-               front_cap_structure_type=None,      back_cap_structure_type=None,  \
-               front_cap_parent_structure_id=None, back_cap_parent_structure_id=None ):
+def create_rod(world, cyl_structure_type, cap_structure_type, name, \
+               position, radius, orientation, length, \
+               parent_structure_id = None, \
+               place_front_cap = True,               place_back_cap = True, \
+               front_cap_structure_type = None,      back_cap_structure_type = None,  \
+               front_cap_parent_structure_id = None, back_cap_parent_structure_id = None ):
     """ Creates a cylinder with two disk-caps at its ends and adds it to the world.
 
         The function ensures that the orientation vectors of the disks point
@@ -318,6 +321,14 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
                 the rod length
 
         Optional arguments:
+            - parent_structure_id
+                if the rod is not in the topmost structure hierarchy,
+                i.e. substructure of the bulk, the parent structure can
+                be specified here by the user. Only rarely needed.
+            - place_front_cap
+                True by default
+            - place_back_cap
+                True by default
             - front_cap_structure_type
                 overrides the default structure type for the front cap
             - back_cap_structure_type
@@ -349,10 +360,14 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
     if front_cap_structure_type:
         front_cap_sid = front_cap_structure_type.id
     if back_cap_structure_type:
-        back_cap_sid  = back_cap_structure_type.id    
-         
+        back_cap_sid  = back_cap_structure_type.id
+
+    parent_id = def_struct_id
+    if parent_structure_id:
+        parent_id = parent_structure_id
+
     # Create the cylinder of the rod
-    rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', position, radius, orientation, length, def_struct_id)
+    rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', position, radius, orientation, length, parent_id)
     world.add_structure(rod) # This must happen directly here otherwise rod.id will be undefined
     
     # By default the parent structure of the caps is the rod:
@@ -366,13 +381,15 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, position, ra
         back_cap_parent_id = back_cap_parent_structure_id
     
     # Create the caps
-    front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
-    front_cap = model.create_disk_surface(front_cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, front_cap_parent_id)
-    world.add_structure(front_cap)
-
-    back_cap_pos = position
-    back_cap = model.create_disk_surface(back_cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], back_cap_parent_id)
-    world.add_structure(back_cap)    
+    if place_front_cap:
+        front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
+        front_cap = model.create_disk_surface(front_cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, front_cap_parent_id)
+        world.add_structure(front_cap)
+
+    if place_back_cap:
+        back_cap_pos = position
+        back_cap = model.create_disk_surface(back_cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], back_cap_parent_id)
+        world.add_structure(back_cap)
 
     return rod.id
 

From 8d8c15e662cdb9d565a6fcae9635ba7217b51512 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 2 Sep 2013 20:57:22 +0200
Subject: [PATCH 1359/1541] Introduce Cylinder to Plane Interaction Domain

---
 egfrd.py  | 19 ++++++++++++++-----
 shells.py | 18 ++++++++++++++++++
 single.py | 17 +++++++++++++++++
 3 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 30db114b..ff865dee 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -55,6 +55,7 @@
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceCapInteractiontestShell,
+    CylindricalSurfacePlanarSurfaceTransitionSingletestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
     MixedPair1DCaptestShell,
@@ -103,6 +104,8 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
             return CylindricalSurfaceCapInteractiontestShell (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, CylindricalSurface):
             return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
+        elif isinstance(target_structure, PlanarSurface):
+            return CylindricalSurfacePlanarSurfaceTransitionSingletestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported')
     else:
@@ -115,6 +118,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
         return CylindricalSurfaceCapInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceTransitionSingletestShell):
+        return CylindricalSurfacePlanarSurfaceTransitionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink           (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
@@ -124,17 +129,17 @@ def try_default_testtransition(single, target_structure, geometrycontainer, doma
             raise testShellError('(Transition). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
         if isinstance(target_structure, PlanarSurface):
-            return PlanarSurfaceTransitionSingletestShell(single, target_structure, geometrycontainer, domains)
+            return PlanarSurfaceTransitionSingletestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Transition). Combination of (2D particle, target_structure other than plane) is not supported')
-    elif isinstance(single.structure, CylindricalSurface):        
+    elif isinstance(single.structure, CylindricalSurface):
             raise testShellError('(Transition). Combination of (1D particle, target_structure) is not supported')
     else:
         raise testShellError('(Transition). structure of particle was of invalid type')
 
 def create_default_transition(domain_id, shell_id, testShell, reaction_rules):
     if isinstance(testShell, PlanarSurfaceTransitionSingletestShell):
-        return PlanarSurfaceTransitionSingle       (domain_id, shell_id, testShell, reaction_rules)
+        return PlanarSurfaceTransitionSingle                   (domain_id, shell_id, testShell, reaction_rules)
 
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
@@ -599,7 +604,9 @@ def create_transition(self, testShell):
     # Currently only plane-plane transitions are supported.
     # We assume here that the testShell was successfully created.
 
-        assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell) # TODO should be generalized
+        assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell) or \
+               isinstance(testShell, CylindricalSurfacePlanarSurfaceTransitionSingletestShell)
+               # TODO should be generalized
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
         # the scheduler
@@ -1819,7 +1826,7 @@ def make_new_domain(self, single):
                 pair_interaction_partners.append((domain, pair_distance - pair_horizon))
         
         for surface, surface_distance in surface_distances:            
-            if isinstance(surface, PlanarSurface):# or isinstance(surface, DiskSurface):
+            if isinstance(surface, PlanarSurface) or isinstance(surface, DiskSurface):
                 # with a planar surface it is the center of mass that 'looks around'
                 surface_horizon = single_radius * (SINGLE_SHELL_FACTOR - 1.0)            
             else:
@@ -1846,10 +1853,12 @@ def make_new_domain(self, single):
                 domain = self.try_pair (single, obj)
 
             elif isinstance(obj, PlanarSurface) and isinstance(single.structure, PlanarSurface):
+                # currently we only support transitions from plane to plane and from cylinder to plane
                 domain = self.try_transition(single, obj)
 
             elif ( isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface) ):
                 # try making an Interaction
+                log.debug('testing obj = %s, pair_interaction_partners = %s' % (obj, pair_interaction_partners) ) # TODO remove after debugging
                 domain = self.try_interaction (single, obj)
 
 
diff --git a/shells.py b/shells.py
index 46a866cf..26a7064e 100755
--- a/shells.py
+++ b/shells.py
@@ -49,6 +49,7 @@
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
     'CylindricalSurfaceCapInteractiontestShell',
+    'CylindricalSurfacePlanarSurfaceTransitionSingletestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
     'MixedPair1DCaptestShell',
@@ -2482,6 +2483,23 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left
 
+class CylindricalSurfacePlanarSurfaceTransitionSingletestShell(CylindricalSurfaceCapInteractiontestShell):
+
+    def __init__(self, single, target_structure, geometrycontainer, domains):
+        CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
+        # This is essentially the same as CylindricalSurfaceCapInteractiontestShell, only that
+        # the orientation vector has to be calculated in a different way.
+
+        assert isinstance(target_structure, PlanarSurface)
+
+    def get_orientation_vector(self):
+        # The orientation vector is the (normalized) difference vector pointing from
+        # the particle position towards its projection onto the plane
+        particle_position = self.pid_particle_pair[1].position
+        projected_position = self.target_structure.project_point(particle_position)[0]
+        log.debug('%s, %s' % (particle_position, projected_position))
+        return normalize(particle_position - projected_position)
+
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
diff --git a/single.py b/single.py
index 331da234..e278a075 100644
--- a/single.py
+++ b/single.py
@@ -31,6 +31,7 @@
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'CylindricalSurfaceCapInteraction',
+    'CylindricalSurfacePlanarSurfaceTransitionSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'TransitionSingle',
@@ -1150,6 +1151,22 @@ def draw_new_position(self, dt, event_type):
     def __str__(self):
         return 'CylindricalSurfaceCapInteraction ' + Single.__str__(self)
 
+class CylindricalSurfacePlanarSurfaceTransitionSingle(CylindricalSurfaceCapInteraction):
+    """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
+       limited by a plane. The plane is a reactive surface to the particle
+       and its intersection with the cylinder axis defines the exit point 
+       from the cylinder.
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceTransitionSingletestShell)
+        CylindricalSurfaceCapInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+        # For now this just does the same as the cap interaction, but the test shells
+        # slightly differ and we like to keep things apart and organized.
 
 class TransitionSingle(Single, TransitionTools, Others):
     """TransitionSingles are used when a particle changes from

From e88113b858c9047e14d42506d1c30a6bb356e555 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Sep 2013 11:43:39 +0200
Subject: [PATCH 1360/1541] Some renaming

---
 egfrd.py  | 10 +++++-----
 shells.py |  4 ++--
 single.py |  6 +++---
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ff865dee..ab24dc0d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -55,7 +55,7 @@
     PlanarSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceCapInteractiontestShell,
-    CylindricalSurfacePlanarSurfaceTransitionSingletestShell,
+    CylindricalSurfacePlanarSurfaceInteractionSingletestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
     MixedPair1DCaptestShell,
@@ -105,7 +105,7 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
         elif isinstance(target_structure, CylindricalSurface):
             return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, PlanarSurface):
-            return CylindricalSurfacePlanarSurfaceTransitionSingletestShell (single, target_structure, geometrycontainer, domains)
+            return CylindricalSurfacePlanarSurfaceInteractionSingletestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported')
     else:
@@ -118,8 +118,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
         return CylindricalSurfaceCapInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceTransitionSingletestShell):
-        return CylindricalSurfacePlanarSurfaceTransitionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell):
+        return CylindricalSurfacePlanarSurfaceInteractionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink           (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
@@ -605,7 +605,7 @@ def create_transition(self, testShell):
     # We assume here that the testShell was successfully created.
 
         assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell) or \
-               isinstance(testShell, CylindricalSurfacePlanarSurfaceTransitionSingletestShell)
+               isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell)
                # TODO should be generalized
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
diff --git a/shells.py b/shells.py
index 26a7064e..4f2461d4 100755
--- a/shells.py
+++ b/shells.py
@@ -49,7 +49,7 @@
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
     'CylindricalSurfaceCapInteractiontestShell',
-    'CylindricalSurfacePlanarSurfaceTransitionSingletestShell',
+    'CylindricalSurfacePlanarSurfaceInteractionSingletestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
     'MixedPair1DCaptestShell',
@@ -2483,7 +2483,7 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left
 
-class CylindricalSurfacePlanarSurfaceTransitionSingletestShell(CylindricalSurfaceCapInteractiontestShell):
+class CylindricalSurfacePlanarSurfaceInteractionSingletestShell(CylindricalSurfaceCapInteractiontestShell):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
diff --git a/single.py b/single.py
index e278a075..b30c7676 100644
--- a/single.py
+++ b/single.py
@@ -31,7 +31,7 @@
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'CylindricalSurfaceCapInteraction',
-    'CylindricalSurfacePlanarSurfaceTransitionSingle',
+    'CylindricalSurfacePlanarSurfaceInteractionSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'TransitionSingle',
@@ -1151,7 +1151,7 @@ def draw_new_position(self, dt, event_type):
     def __str__(self):
         return 'CylindricalSurfaceCapInteraction ' + Single.__str__(self)
 
-class CylindricalSurfacePlanarSurfaceTransitionSingle(CylindricalSurfaceCapInteraction):
+class CylindricalSurfacePlanarSurfaceInteractionSingle(CylindricalSurfaceCapInteraction):
     """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
        limited by a plane. The plane is a reactive surface to the particle
        and its intersection with the cylinder axis defines the exit point 
@@ -1163,7 +1163,7 @@ class CylindricalSurfacePlanarSurfaceTransitionSingle(CylindricalSurfaceCapInter
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
-        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceTransitionSingletestShell)
+        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell)
         CylindricalSurfaceCapInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
         # For now this just does the same as the cap interaction, but the test shells
         # slightly differ and we like to keep things apart and organized.

From f835cc374e4e4da01dfe2def321757f91fc24132 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Sep 2013 18:44:55 +0200
Subject: [PATCH 1361/1541] Introduce a new ('fake') interaction domain that
 encloses a particle at the interface between a cyl. and a plane

This is also defining the correpsonding test shell.

Even though the particle actually does not go to the cylinder,
we have to treat this case as an interaction of a plane-bound particle
with the closeby cylinder. Otherwise the current framework will not
ignore the cylinder, failing to construct a membrane-bound domain.

Since we want to construct these domains only in the situation in
which a particle just arrived to the plane, coming from the touching
cylinder, we check explicitly whether the particle is below the
(orthogonal) cylinder before we construct it.

This prevents construction attempts if particles are only close to
the cylinder. In that case, we want to construct regular plane
singles or other domains.
---
 egfrd.py  |  9 ++++++--
 shells.py | 47 +++++++++++++++++++++++++++++++++++++---
 single.py | 65 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 115 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ab24dc0d..a5ea4577 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -56,6 +56,7 @@
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceCapInteractiontestShell,
     CylindricalSurfacePlanarSurfaceInteractionSingletestShell,
+    CylindricalSurfacePlanarSurfaceInterfaceSingletestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
     MixedPair1DCaptestShell,
@@ -98,6 +99,8 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
         else:
             raise testShellError('(Interaction). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
+        if isinstance(target_structure, CylindricalSurface):
+            return CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (single, target_structure, geometrycontainer, domains)
         raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(target_structure, DiskSurface):
@@ -116,10 +119,12 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction    (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell): # must be first because it is a special case of CylindricalSurfaceCapInteractiontestShell
+        return CylindricalSurfacePlanarSurfaceInteractionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell): # this is actually not really an interaction, but we need to put it here to ignore the target structure
+        return CylindricalSurfacePlanarSurfaceInterfaceSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
         return CylindricalSurfaceCapInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell):
-        return CylindricalSurfacePlanarSurfaceInteractionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
         return CylindricalSurfaceSink           (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
diff --git a/shells.py b/shells.py
index 4f2461d4..96651e2b 100755
--- a/shells.py
+++ b/shells.py
@@ -50,6 +50,7 @@
     'CylindricalSurfaceInteractiontestShell',
     'CylindricalSurfaceCapInteractiontestShell',
     'CylindricalSurfacePlanarSurfaceInteractionSingletestShell',
+    'CylindricalSurfacePlanarSurfaceInterfaceSingletestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
     'MixedPair1DCaptestShell',
@@ -180,7 +181,7 @@ def __init__(self, single, origin_structure, target_structure):
 
         ### initialize some constants that are common for the testInteractionSingle domains.
 
-        # calculate the Projected_point and distance to the target_structure
+        # Calculate the projected_point and distance to the target_structure
         # Cyclic transpose needed when calling target_structure.project_point!
         pos_transposed = self.world.cyclic_transpose(self.pid_particle_pair[1].position,
                                                      self.target_structure.shape.position)
@@ -210,7 +211,7 @@ def __init__(self, single, origin_structure, target_structure):
             self.reference_vector = normalize(diff_vector)
         else:
             self.reference_vector = 0
-            raise testShellError('(testInteractionSingle). reference vector = 0.')
+            log.warning('(testInteractionSingle). reference vector = 0.')
 
 class testTransitionSingle(testSingle, Others):
 
@@ -2497,9 +2498,49 @@ def get_orientation_vector(self):
         # the particle position towards its projection onto the plane
         particle_position = self.pid_particle_pair[1].position
         projected_position = self.target_structure.project_point(particle_position)[0]
-        log.debug('%s, %s' % (particle_position, projected_position))
         return normalize(particle_position - projected_position)
 
+class CylindricalSurfacePlanarSurfaceInterfaceSingletestShell(CylindricalSurfaceCapInteractiontestShell):
+
+    def __init__(self, single, target_structure, geometrycontainer, domains):
+
+        # We want to form this domain only when the particle just arrived onto the plane exiting from a perpendicular cylinder
+        # Here we check in advance whether the particle is on the cylinder axis by projecting the difference vector between
+        # particle position and cylinder midpoint onto the plane (the projection is zero if both lie on the cyl. axis)
+        distance_from_axis = target_structure.project_point(single.pid_particle_pair[1].position)[1][0]
+        if not feq(distance_from_axis, 0.0, typical=single.pid_particle_pair[1].radius):
+
+            raise testShellError(('Particle is not directly below cylinder, distance from axis = %s' % distance_from_axis))
+
+        # If everything seems OK, we can proceed with creating the test shell
+        CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)               
+
+        # Override the shellsize determined for CylindricalSurfacePlanarSurfaceInteractionSingletestShell
+        # This one has the size of a zero single; the scaling parameters can stay the same, since we are not scaling anyhow
+        self.dz_right = self.pid_particle_pair[1].radius
+        self.dz_left  = self.pid_particle_pair[1].radius
+        self.dr       = self.pid_particle_pair[1].radius
+
+    def get_searchpoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_referencepoint(self):
+        return self.pid_particle_pair[1].position
+
+    def get_min_dr_dzright_dzleft(self):
+        # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
+        dr       = self.dr_const
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        dz_left  = dz_right
+        return dr, dz_right, dz_left
+        
+    def get_max_dr_dzright_dzleft(self):
+        # Radius is not scaled here so we do not to check for distance to shape edge
+        dr       = self.dr_const
+        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
+        dz_left  = dz_right
+        return dr, dz_right, dz_left
+
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
diff --git a/single.py b/single.py
index b30c7676..7e3ad9e5 100644
--- a/single.py
+++ b/single.py
@@ -32,6 +32,7 @@
     'CylindricalSurfaceInteraction',
     'CylindricalSurfaceCapInteraction',
     'CylindricalSurfacePlanarSurfaceInteractionSingle',
+    'CylindricalSurfacePlanarSurfaceInterfaceSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'TransitionSingle',
@@ -587,7 +588,8 @@ class DiskSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
-        assert isinstance(testShell, DiskSurfaceSingletestShell)
+        assert isinstance(testShell, DiskSurfaceSingletestShell) or \
+               isinstance(testShell,CylindricalSurfacePlanarSurfaceInterfaceSingletestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
@@ -1168,6 +1170,67 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # For now this just does the same as the cap interaction, but the test shells
         # slightly differ and we like to keep things apart and organized.
 
+    def __str__(self):
+        return 'CylindricalSurfacePlanarSurfaceInteraction ' + Single.__str__(self)
+
+class CylindricalSurfacePlanarSurfaceInterfaceSingle(CylindricalSurfaceCapInteraction):
+    """1 Particle inside a (cylindrical) shell at the interface of a
+       PlanarSurface and CylindricalSurface.
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+        * Selected randomly when drawing displacement vector: none.
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell)
+        CylindricalSurfaceCapInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+
+    def getv(self):
+        
+        pass
+
+    def get_inner_dz_left(self):
+       
+        pass
+
+    def get_inner_dz_right(self):
+        
+        pass
+
+    def determine_next_event(self):
+        """Return an (event_time, event_type)-tuple.
+
+        """
+        return self.draw_reaction_time_tuple() # can only produce SINGLE_REACTION events
+
+    def iv_greens_function(self):
+
+        # We do not draw new positions in this domain anyhow
+        # TODO Do we really have to define that here?
+        inner_half_length = self.pid_particle_pair[1].position
+        return GreensFunction1DAbsAbs(0.0, 0.0, 0.0, -inner_half_length, inner_half_length)
+
+    def draw_new_position(self, dt, event_type):
+
+        if event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 1:
+
+            # The particle does not move in this domain, but upon monomolecular reaction it is
+            # placed in contact with the cylinder that hits the plane, at a random angle.
+            # Since the origin structure (plane) does not change, we have to sample this position here.
+            x, y = random_vector2D( (self.target_structure.shape.radius + self.pid_particle_pair[1].radius) * MINIMAL_SEPARATION_FACTOR)
+            displacement = x * self.origin_structure.shape.unit_x + y * self.origin_structure.shape.unit_y
+            new_pos = self.pid_particle_pair[1].position + displacement
+
+            return new_pos, self.origin_structure.id
+
+        else:
+            raise Exception('Disallowed event type other than SINGLE_REACTION or wrong no. of products in CylindricalSurfacePlanarSurfaceInterfaceSingle.')
+
+    def __str__(self):
+        return 'CylindricalSurfacePlanarSurfaceInterface ' + Single.__str__(self)
+
 class TransitionSingle(Single, TransitionTools, Others):
     """TransitionSingles are used when a particle changes from
        one structure to another. The difference to an InteractionSingle

From f945e50074788c28d3bfc0b3e06f3595b8e699bc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Sep 2013 18:48:34 +0200
Subject: [PATCH 1362/1541] Just some useful debugging statements

---
 newBDPropagator.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 992cde72..8613fd16 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -419,6 +419,7 @@ class newBDPropagator
         
         if ((int)::size(rules) == 0)
         {
+            LOG_DEBUG(("No single reaction rules." ));
             return false;
         }
      
@@ -431,6 +432,8 @@ class newBDPropagator
         {
             reaction_rule_type const& reaction_rule(*i);
             k_cumm += reaction_rule.k();
+            
+            LOG_DEBUG(("k_cumm=%g", k_cumm));
 
             if (k_cumm > rnd)
             // We have found the reaction rule that is in effect

From 750c7322f8034567770f574ada6a13f0b3931411 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 4 Sep 2013 14:11:54 +0200
Subject: [PATCH 1363/1541] Forgot burst event type in new single class

---
 single.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 7e3ad9e5..8546dbbc 100644
--- a/single.py
+++ b/single.py
@@ -1225,8 +1225,15 @@ def draw_new_position(self, dt, event_type):
 
             return new_pos, self.origin_structure.id
 
+        elif event_type == EventType.BURST:
+
+            # When we burst it nothing happens to the particle
+            new_pos = self.pid_particle_pair[1].position
+
+            return new_pos, self.origin_structure.id            
+
         else:
-            raise Exception('Disallowed event type other than SINGLE_REACTION or wrong no. of products in CylindricalSurfacePlanarSurfaceInterfaceSingle.')
+            raise Exception('Disallowed event type or wrong no. of products in CylindricalSurfacePlanarSurfaceInterfaceSingle.')
 
     def __str__(self):
         return 'CylindricalSurfacePlanarSurfaceInterface ' + Single.__str__(self)

From 50015f1847ff9fd6e14bc8ecdd147e1962cfb2e3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 4 Sep 2013 17:47:11 +0200
Subject: [PATCH 1364/1541] Just a memo

---
 single.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/single.py b/single.py
index 8546dbbc..19868f39 100644
--- a/single.py
+++ b/single.py
@@ -1225,6 +1225,8 @@ def draw_new_position(self, dt, event_type):
 
             return new_pos, self.origin_structure.id
 
+        # TODO What if we have 2 products? Compare to DiskSurfaceSingle
+
         elif event_type == EventType.BURST:
 
             # When we burst it nothing happens to the particle

From 9dfdea39b71a1b456514df3ca9c44fb3ab343132 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 4 Sep 2013 17:47:27 +0200
Subject: [PATCH 1365/1541] Basic treatment for the "Interface Pair", i.e. a
 PlanarSurfacePair in which one of the reactants is static and below a cyl.
 touching the plane

---
 egfrd.py  |  2 +-
 shells.py | 42 +++++++++++++++++++++++++++++++++++++++---
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a5ea4577..f1106872 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1389,7 +1389,7 @@ def conditional_swap(newposA, newposB):
                     newposA = reactant_pos
 
                     # Create the position of the particle that goes into the bulk (productB)
-                    # This is the same as for the single reaction of a disk-bound particle (see above)
+                    # This is the same as for the single reaction of a completely dissociating disk-bound particle (see above)
                     vector_length = (productB_radius + max(productA_radius, reactant_structure.shape.radius)) * MINIMAL_SEPARATION_FACTOR
                     for _ in range(self.dissociation_retry_moves):
                         unit_vector3D = random_unit_vector()
diff --git a/shells.py b/shells.py
index 96651e2b..42556e42 100755
--- a/shells.py
+++ b/shells.py
@@ -2047,15 +2047,17 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         self.left_scalingangle  = self.get_left_scalingangle()
         # In particular store the tangent, because math.tan is expensive!
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
-        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)        
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        self.ignored_structures = self.set_structure_ignore_list()
+
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
-                                                          [])
+                                                          self.ignored_structures)
         except ShellmakingError as e:
             raise testShellError('(PlanarSurfacePair). %s' %
                                  (str(e)))
@@ -2087,6 +2089,36 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right, z_left
 
+    def set_structure_ignore_list(self):
+
+        ignored_structures = [] # by default
+
+        # The "interface pair", i.e. one of the particles is static (D=0) and located below
+        # the cylinder from which it moved on the membrane. In that case we want to ignore 
+        # the cylindrical surface.
+        if self.pid_particle_pair1[1].D == 0 or self.pid_particle_pair2[1].D == 0:
+
+            ignored_structures = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
+            # TODO This should check whether the static particle is also indeed below a cylinder,
+            # and only ignore that cylinder!
+
+        return ignored_structures
+
+####
+class CylindricalSurfacePlanarSurfaceInterfacePairtestShell(PlanarSurfacePairtestShell):
+
+    def __init__(self, single1, single2, geometrycontainer, domains):
+
+        # This special domain is constructed when a 2D particle tries to interact with a static
+        # particle located at the interface between a cylinder and a plane.
+        # In that case we have to ignore the cylindrical structure at shell construction.
+        # Otherwise it does the same as the regular PlanarSurfacePair.
+
+        self.ignored_structures = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
+        # TODO only ignore the cylinder closest to the "static" single
+
+        PlanarSurfacePairtestShell(self, single1, single2, geometrycontainer, domains)
+
 #####
 class CylindricalSurfaceSingletestShell(CylindricaltestShell, testNonInteractionSingle):
 
@@ -2421,6 +2453,10 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
+        # We want to form this domain only if the cap actually is a substructure of the cylinder of origin
+        #if not target_structure.id == single.structure.structure_id:
+            #raise testShellError('(CylindricalSurfaceCapInteraction). Target structure is not a substructure of the origin structure.')
+
         # Initialize scaling parameters
         # - the reference point is at the cap disk position
         # - the orientation vector points from the cap towards the rod particle, i.e.:
@@ -2510,7 +2546,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         distance_from_axis = target_structure.project_point(single.pid_particle_pair[1].position)[1][0]
         if not feq(distance_from_axis, 0.0, typical=single.pid_particle_pair[1].radius):
 
-            raise testShellError(('Particle is not directly below cylinder, distance from axis = %s' % distance_from_axis))
+            raise testShellError(('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Particle is not directly below cylinder, distance from axis = %s' % distance_from_axis))
 
         # If everything seems OK, we can proceed with creating the test shell
         CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)               

From a547e4f922ee0abddf7f4754031a52d2667b6655 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 4 Sep 2013 18:58:29 +0200
Subject: [PATCH 1366/1541] Forgot to rename box planes in connecting routine

---
 gfrdbase.py | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index fffcb921..e1aa3088 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -264,18 +264,18 @@ def create_box(world, structure_type, center, size, one_sided=True):
     # - neighbor 3 is the one in positive unit_x direction ("right neighbor")
     #
     # See StructureContainer.hpp for more details.
-    world.connect_structures( front, 3, top, 2)
-    world.connect_structures( front, 2, bottom, 1)
-    world.connect_structures( front, 1, left, 2)
-    world.connect_structures( front, 0, right, 1)
-    world.connect_structures(  back, 3, right, 0)
-    world.connect_structures(  back, 2, left, 3)
-    world.connect_structures(  back, 1, bottom, 0)
-    world.connect_structures(  back, 0, top, 3)
-    world.connect_structures(   top, 1, left, 0)
-    world.connect_structures(   top, 0, right, 3)
-    world.connect_structures(bottom, 3, right, 2)
-    world.connect_structures(bottom, 2, left, 1)
+    world.connect_structures( left, 3, top, 2)
+    world.connect_structures( left, 2, bottom, 1)
+    world.connect_structures( left, 1, back, 2)
+    world.connect_structures( left, 0, front, 1)
+    world.connect_structures(  right, 3, front, 0)
+    world.connect_structures(  right, 2, back, 3)
+    world.connect_structures(  right, 1, bottom, 0)
+    world.connect_structures(  right, 0, top, 3)
+    world.connect_structures(   top, 1, back, 0)
+    world.connect_structures(   top, 0, front, 3)
+    world.connect_structures(bottom, 3, front, 2)
+    world.connect_structures(bottom, 2, back, 1)
 
     # Return a list containing the IDs of the created planes
     # in case that the user wishes to operate on them separately

From 1f4eb3f8abfe575eea3868e9306986ab74b70557 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Sep 2013 12:00:55 +0200
Subject: [PATCH 1367/1541] Fix ignorelists in overlap checking

---
 egfrd.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index f1106872..1ce90faf 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3005,7 +3005,7 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
         elif isinstance(domain, DiskSurfaceSingle):
-            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring structure
+            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring/parent rods
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
             associated = [domain.structure.id]
         elif isinstance(domain, CylindricalSurfaceInteraction):
@@ -3016,6 +3016,11 @@ def check_domain(self, domain):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.origin_structure.id, domain.target_structure.id]
+        elif isinstance(domain, PlanarSurfacePair):
+            # PlanarSurface domains sometimes are formed with a particle that just exited from a rod onto the plane.
+            # In these cases, the rod shall be ignored.
+            ignores = domain.ignored_structures # this is a list already
+            associated = [domain.structure.id]
         elif isinstance(domain, PlanarSurfaceTransitionSingle) or isinstance(domain, PlanarSurfaceTransitionPair):
             # Ignore surface of the particle and interaction surface
             ignores = []

From c77178b8277f7aa90ef8e6da049474887ccdd877 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Sep 2013 12:01:24 +0200
Subject: [PATCH 1368/1541] Basic implementation of
 PlanarSurfaceCylindricalSurfaceInteraction (testShell)

---
 shells.py | 44 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 42556e42..25dc7e1e 100755
--- a/shells.py
+++ b/shells.py
@@ -2099,7 +2099,11 @@ def set_structure_ignore_list(self):
         if self.pid_particle_pair1[1].D == 0 or self.pid_particle_pair2[1].D == 0:
 
             ignored_structures = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
-            # TODO This should check whether the static particle is also indeed below a cylinder,
+
+            if __debug__:
+                log.info('(PlanarSurfacePair). Ignoring cylindrical structures, ignore list = %s' % str(ignored_structures))
+
+            # TODO FIXME This should check whether the static particle is also indeed below a cylinder,
             # and only ignore that cylinder!
 
         return ignored_structures
@@ -2447,6 +2451,44 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, self.z_left(r/SAFETY)/SAFETY
 
+class PlanarSurfaceCylindricalSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
+
+    # This class is in essence the same as CylindricalSurfaceInteractiontestShell, but with
+    # different shellscaling parameters. Therefore a new constructor has to be defined.
+    def __init__(self, single, target_structure, geometrycontainer, domains):
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testInteractionSingle.__init__(self, single, single.structure, target_structure)
+        
+        # Initialize the scaling parameters
+        # These are copied from PlanarSurfacePairtestShell
+        self.dzdr_right = 0.0
+        self.drdz_right = numpy.inf
+        self.r0_right   = 0.0
+        self.z0_right   = self.pid_particle_pair[1].radius
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = 0.0
+        self.z0_left    = self.z0_right
+
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        # Note that here we know all structures that have to be ignored (origin and target structure).
+        try:
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
+        except ShellmakingError as e:
+            raise testShellError('(PlanarSurfaceCylindricalSurfaceInteraction). %s' %
+                                 (str(e)))
+    
+
 class CylindricalSurfaceCapInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):

From f05fd4a99370246cdeb945d194dc2a219e7c8dc8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Sep 2013 12:31:12 +0200
Subject: [PATCH 1369/1541] Basic implementation of
 PlanarSurfaceCylindricalSurfaceInteraction (domain)

---
 single.py | 68 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/single.py b/single.py
index 19868f39..b5f587f2 100644
--- a/single.py
+++ b/single.py
@@ -957,6 +957,74 @@ def __str__(self):
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))
 
+class PlanarSurfaceCylindricalSurfaceInteraction(CylindricalSurfaceInteraction):
+    """1 Particle on a PlanarSurface close to a CylindricalSurface, 
+       inside a cylindrical shell that surrounds the CylindricalSurface.
+
+        * Particle coordinates inside shell: r, theta, z.
+        * Domains: composite r-theta, cartesian z.
+        * Initial position: r = r, theta = 0, z = z.
+        * Selected randomly when drawing displacement vector: none.
+
+    """
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        # This domain is basically equivalent to CylindricalSurfaceInteraction. It uses
+        # the same Green's function for binding, but the particle's z-coordinate does not
+        # change here. Thus we have to modify draw_new_position() accordingly.
+        assert isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell)
+        # Initialize the parent class. This should be fine since the test shell also has
+        # CylindricalSurfaceInteractiontestShell as a parent class.
+        CylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+
+    def draw_new_position(self, dt, event_type):
+        oldpos = self.pid_particle_pair[1].position
+
+        if self.D == 0:
+            newpos = oldpos
+        elif event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 0:
+            newpos = oldpos
+        else:
+            # 1) Draw z.
+            # Here z does not change, the particle stays on the plane
+            # => do nothing here
+
+            # The rest is the same as in the parent class.
+
+            # 2) Draw r and theta.
+            # If the event was not yet fully specified
+            if event_type == EventType.IV_EVENT:        
+                self.event_type = self.draw_iv_event_type()
+                event_type = self.event_type
+
+            sigma = self.get_inner_sigma()
+            a_r = self.get_inner_a()
+            gf_iv = self.iv_greens_function()
+
+            if event_type == EventType.IV_ESCAPE:
+                r = a_r
+            elif event_type == EventType.IV_INTERACTION:
+                r = sigma
+            else:
+                r = draw_r_wrapper(gf_iv, dt, a_r, sigma)
+            theta = draw_theta_wrapper(gf_iv, r, dt)
+
+            r_vector = r * rotate_vector(self.unit_r, self.shell.shape.unit_z,
+                                     theta)
+
+            # Add displacement to shell.shape.position, not to particle.position.  
+            newpos = self.shell.shape.position + r_vector
+
+        # The structure on which the particle ended is always the same as on which it began.
+        structure_id = self.origin_structure.id
+
+        return newpos, structure_id
+
+    def __str__(self):
+        return ('PlanarSurfaceCylindricalSurfaceInteraction' + Single.__str__(self) + \
+               'radius = %s, half_length = %s' %
+                (self.shell.shape.radius, self.shell.shape.half_length))
+
 
 class CylindricalSurfaceSink(InteractionSingle):
     """1 Particle inside a (Cylindrical) shell on a CylindricalSurface.

From 5a655be176d388ae066f34b14516fbb0d6b68667 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 5 Sep 2013 12:31:34 +0200
Subject: [PATCH 1370/1541] Small fix

---
 pair.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pair.py b/pair.py
index 6898717f..d91557e1 100644
--- a/pair.py
+++ b/pair.py
@@ -476,6 +476,8 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.LD_MAX = 20 # Required by SimplePair.__init__
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
+        self.ignored_structures = testShell.ignored_structures
+
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
 

From 612fd21f0ca97ffaa8b79391c6ea78d2919d2f64 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 6 Sep 2013 18:14:32 +0200
Subject: [PATCH 1371/1541] Always return next-event time = inf for
 SINGLE_ESCAPE in PlanarSurfaceCylindricalSurfaceInteraction Single

---
 single.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/single.py b/single.py
index b5f587f2..aa0e8b07 100644
--- a/single.py
+++ b/single.py
@@ -35,6 +35,7 @@
     'CylindricalSurfacePlanarSurfaceInterfaceSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
+    'PlanarSurfaceCylindricalSurfaceInteraction',
     'TransitionSingle',
     'PlanarSurfaceTransitionSingle',
     ]
@@ -977,6 +978,12 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # CylindricalSurfaceInteractiontestShell as a parent class.
         CylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
+    def draw_escape_time_tuple(self):
+        # This draws the time for escape in z-direction; since the particle in this domain
+        # remains bound to the plane, we do not want to draw any z-escape time and just
+        # return t=infinity for the SINGLE_ESCAPE event here.
+        return numpy.inf, EventType.SINGLE_ESCAPE
+
     def draw_new_position(self, dt, event_type):
         oldpos = self.pid_particle_pair[1].position
 

From ce2d809acd8d185952113e8a0ec6548ca3bf9a44 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 6 Sep 2013 18:16:11 +0200
Subject: [PATCH 1372/1541] Fix domain construction gearbox taking into account
 the new domain

---
 egfrd.py | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 1ce90faf..cd1e0a68 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -39,6 +39,7 @@
 from shellcontainer import ShellContainer
 from shells import (
     testShellError,
+    ShellmakingError,
     testPair,
     testInteractionSingle,
     hasSphericalShell,
@@ -53,6 +54,7 @@
     CylindricalSurfacePairtestShell,
     DiskSurfaceSingletestShell,
     PlanarSurfaceInteractiontestShell,
+    PlanarSurfaceCylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceCapInteractiontestShell,
     CylindricalSurfacePlanarSurfaceInteractionSingletestShell,
@@ -100,8 +102,17 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
             raise testShellError('(Interaction). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
         if isinstance(target_structure, CylindricalSurface):
-            return CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (single, target_structure, geometrycontainer, domains)
-        raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
+            # here we have 2 possibilities; first we try the less probable one (special conditions apply that are checked
+            # upon test shell construction), then the more common one.
+            try:
+                return CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (single, target_structure, geometrycontainer, domains)
+            except testShellError as e:
+                if __debug__:
+                    log.warn('Could not make CylindricalSurfacePlanarSurfaceInterfaceSingletestShell, %s; now trying PlanarSurfaceCylindricalSurfaceInteractiontestShell.' % str(e))
+                return PlanarSurfaceCylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
+                # if both shells do not work in this situation the second try will result in raising another shellmaking exception
+        else:
+            raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(target_structure, DiskSurface):
             return CylindricalSurfaceCapInteractiontestShell (single, target_structure, geometrycontainer, domains)
@@ -115,13 +126,15 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
         raise testShellError('(Interaction). structure of particle was of invalid type')
 
 def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, interaction_rules):
-    if isinstance(testShell, CylindricalSurfaceInteractiontestShell):
+    if isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceInteractiontestShell
+        return PlanarSurfaceCylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfaceInteractiontestShell):
         return CylindricalSurfaceInteraction    (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell): # must be first because it is a special case of CylindricalSurfaceCapInteractiontestShell
         return CylindricalSurfacePlanarSurfaceInteractionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell): # this is actually not really an interaction, but we need to put it here to ignore the target structure
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell): # this is actually not a regular interaction, but we need to put it here to ignore the target structure
         return CylindricalSurfacePlanarSurfaceInterfaceSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
         return CylindricalSurfaceCapInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)

From 6a96f586138f81a7e81d978aecb96294333f5e40 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 6 Sep 2013 19:16:41 +0200
Subject: [PATCH 1373/1541] Introduce a distinction between target and product
 structure in handling interaction events

---
 egfrd.py  | 15 ++++++++++++---
 single.py |  2 ++
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index cd1e0a68..48395130 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1587,7 +1587,16 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
             # 1. get product info
             product_species      = self.world.get_species(rr.products[0])
             product_radius       = product_species.radius
-            product_structure    = single.target_structure
+            # In some special domains that are formally an interaction the product actually stays
+            # behind on the origin structure (e.g. in the PlanarSurfaceCylindricalSurfaceInteraction,
+            # which is a plane particle interacting with a cylinder touching the plane).
+            # Therefore we have to make a distinction here. TODO FIXME this is not very elegant!
+            if single.product_structure:
+                product_structure    = single.product_structure # treating some special cases
+                target_structure     = single.target_structure
+            else:
+                product_structure    = single.target_structure # the default
+                target_structure     = single.target_structure
 
             # TODO make sure that the product species lives on the same type of the interaction surface
            #product_structure_type = self.world.get_structure(product_species.structure_id)
@@ -1596,8 +1605,8 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
 
             # 1.5 get new position and structure_id of particle
             transposed_pos       = self.world.cyclic_transpose(reactant_pos, product_structure.shape.position)
-            product_pos, _       = product_structure.project_point(transposed_pos)
-            product_pos          = self.world.apply_boundary(product_pos)        # not sure this is still necessary
+            product_pos, _       = target_structure.project_point(transposed_pos) # we always project on the target structure, even if it is not the product structure
+            product_pos          = self.world.apply_boundary(product_pos)         # not sure this is still necessary
             product_structure_id = product_structure.id
 
             # 2. burst the volume that will contain the products.
diff --git a/single.py b/single.py
index aa0e8b07..8a7f6252 100644
--- a/single.py
+++ b/single.py
@@ -978,6 +978,8 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # CylindricalSurfaceInteractiontestShell as a parent class.
         CylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
+        self.product_structure = self.origin_structure
+
     def draw_escape_time_tuple(self):
         # This draws the time for escape in z-direction; since the particle in this domain
         # remains bound to the plane, we do not want to draw any z-escape time and just

From eefc07ab88020a0a7e45b2db488b15409e973d73 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 6 Sep 2013 19:18:45 +0200
Subject: [PATCH 1374/1541] Cleanup

---
 shells.py | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index 25dc7e1e..4ac91c8d 100755
--- a/shells.py
+++ b/shells.py
@@ -43,6 +43,7 @@
     'PlanarSurfacePairtestShell',
     'PlanarSurfaceTransitionSingletestShell',
     'PlanarSurfaceTransitionPairtestShell',
+    'PlanarSurfaceCylindricalSurfaceInteractiontestShell',
     'CylindricalSurfaceSingletestShell',
     'DiskSurfaceSingletestShell',
     'CylindricalSurfacePairtestShell',
@@ -836,7 +837,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
 
     # Get the reference point and orientation of the domain to scale
     reference_point = testShell.get_referencepoint()
-    orientation_vector = testShell.get_orientation_vector()
+    orientation_vector = testShell.get_orientation_vector()    
 
     # FIXME DIRTY HACK TO MAKE DOMAINS LESS GREEDY
 #    r = min(r, testShell.world.distance(shape.position, reference_point)/2)
@@ -874,7 +875,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         z2 = z_right
     
     # This must always be the case:
-    assert scale_angle >= 0.0
+    assert scale_angle >= 0.0    
 
     # Check how the cylinders are oriented with respect to each other
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
@@ -888,7 +889,6 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
         ref_to_shell_r = length(ref_to_shell_r_vec)         # the radius is always positive
         ref_to_shell_z = ref_to_shell_z * direction         # ref_to_shell_z is positive on the scaling side (right/left)
 
-
         # calculate the distances in r/z from the scaling center to the shell
         scale_center_to_shell_r = ref_to_shell_r - scale_center_r
         scale_center_to_shell_z = ref_to_shell_z - scale_center_z
@@ -2477,6 +2477,8 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
         self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
 
+        log.debug('left_scalingangle = %s, right_scalingangle = %s' % (self.left_scalingangle, self.right_scalingangle) )
+
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
@@ -2488,6 +2490,20 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             raise testShellError('(PlanarSurfaceCylindricalSurfaceInteraction). %s' %
                                  (str(e)))
     
+    def get_min_dr_dzright_dzleft(self):        
+        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + (self.particle_surface_distance + self.target_structure.shape.radius)
+        dz_right = self.pid_particle_pair[1].radius
+        dz_left  = dz_right
+        return dr, dz_right, dz_left
+
+    def get_max_dr_dzright_dzleft(self): # same as for PlanarSurfaceSingletestShell
+        dz_right = self.pid_particle_pair[1].radius
+        dz_left  = dz_right
+        dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
+#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint()) # TODO rethink this
+#        dr       = min(dr_sr, dr_edge)
+        dr = dr_sr
+        return dr, dz_right, dz_left
 
 class CylindricalSurfaceCapInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
@@ -2591,7 +2607,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             raise testShellError(('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Particle is not directly below cylinder, distance from axis = %s' % distance_from_axis))
 
         # If everything seems OK, we can proceed with creating the test shell
-        CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)               
+        CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
 
         # Override the shellsize determined for CylindricalSurfacePlanarSurfaceInteractionSingletestShell
         # This one has the size of a zero single; the scaling parameters can stay the same, since we are not scaling anyhow

From 2c6a14aa801d30f7c1a325b7cc34aeda242fe825 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:02:08 +0200
Subject: [PATCH 1375/1541] Check whether static particle is below cylinder in
 PlanarSurfacePair formation

---
 egfrd.py  |  2 +-
 pair.py   |  2 +-
 shells.py | 48 +++++++++++++++++++++++++++++++++++++-----------
 3 files changed, 39 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 48395130..ab1c8e75 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3041,7 +3041,7 @@ def check_domain(self, domain):
         elif isinstance(domain, PlanarSurfacePair):
             # PlanarSurface domains sometimes are formed with a particle that just exited from a rod onto the plane.
             # In these cases, the rod shall be ignored.
-            ignores = domain.ignored_structures # this is a list already
+            ignores = domain.ignored_structure_ids # this is a list already
             associated = [domain.structure.id]
         elif isinstance(domain, PlanarSurfaceTransitionSingle) or isinstance(domain, PlanarSurfaceTransitionPair):
             # Ignore surface of the particle and interaction surface
diff --git a/pair.py b/pair.py
index d91557e1..57e3da94 100644
--- a/pair.py
+++ b/pair.py
@@ -476,7 +476,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         self.LD_MAX = 20 # Required by SimplePair.__init__
         SimplePair.__init__(self, domain_id, shell_id, rrs)
 
-        self.ignored_structures = testShell.ignored_structures
+        self.ignored_structure_ids = testShell.ignored_structure_ids
 
     def com_greens_function(self):
         return GreensFunction2DAbsSym(self.D_R, self.a_R)
diff --git a/shells.py b/shells.py
index 4ac91c8d..7f237f18 100755
--- a/shells.py
+++ b/shells.py
@@ -2052,12 +2052,12 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
-        self.ignored_structures = self.set_structure_ignore_list()
+        self.ignored_structure_ids = self.set_structure_ignore_list()
 
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
-                                                          self.ignored_structures)
+                                                          self.ignored_structure_ids)
         except ShellmakingError as e:
             raise testShellError('(PlanarSurfacePair). %s' %
                                  (str(e)))
@@ -2091,22 +2091,48 @@ def apply_safety(self, r, z_right, z_left):
 
     def set_structure_ignore_list(self):
 
-        ignored_structures = [] # by default
+        ignored_structure_ids = [] # by default
 
         # The "interface pair", i.e. one of the particles is static (D=0) and located below
         # the cylinder from which it moved on the membrane. In that case we want to ignore 
         # the cylindrical surface.
         if self.pid_particle_pair1[1].D == 0 or self.pid_particle_pair2[1].D == 0:
 
-            ignored_structures = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
+            non_cylindrical_structures = [s.id for s in self.world.structures if not(isinstance(s, CylindricalSurface))]
 
-            if __debug__:
-                log.info('(PlanarSurfacePair). Ignoring cylindrical structures, ignore list = %s' % str(ignored_structures))
+            # Determine which particle is the one that is probably below the cylinder
+            if self.pid_particle_pair1[1].D == 0 and self.pid_particle_pair2[1].D > 0:
+                static_particle = self.pid_particle_pair1[1]
+                search_pos = self.pid_particle_pair1[1].position
+            elif self.pid_particle_pair2[1].D == 0 and self.pid_particle_pair1[1].D > 0:
+                static_particle = self.pid_particle_pair2[1]
+                search_pos = self.pid_particle_pair2[1].position
+            else:
+                raise testShellError('Both diffusion constants zero in Pair, something is wrong.')           
+
+            # Determine the distance to the closest cylinder
+            # First get all close cylinders, then sort, then get the distance to the closest
+            close_structures = get_neighbor_surfaces(self.world, search_pos, self.structure.id, [])
+            close_cylindrical_structures = [surface_and_dist for surface_and_dist in close_structures if isinstance(surface_and_dist[0], CylindricalSurface)]
+
+            if close_cylindrical_structures != []:
+                sorted_close_cylindrical_structures = sorted(close_cylindrical_structures, key=lambda surface_and_dist : surface_and_dist[1])
+
+                closest_cylindrical_struct         = sorted_close_cylindrical_structures[0][0]
+                closest_cylindrical_struct_dist    = sorted_close_cylindrical_structures[0][1]
+
+                distance_from_closest_axis = closest_cylindrical_struct.project_point(search_pos)[1][0]
+
+                if feq(distance_from_closest_axis, 0.0, typical = static_particle.radius):
+                    ignored_structure_ids = [closest_cylindrical_struct.id]    
+
+                    if __debug__:
+                        log.info('(PlanarSurfacePair). Ignoring cylindrical structure, distance = %s, ignore list = %s' % (distance_from_closest_axis, ignored_structure_ids))
 
-            # TODO FIXME This should check whether the static particle is also indeed below a cylinder,
-            # and only ignore that cylinder!
+                elif __debug__:
+                        log.info('(PlanarSurfacePair). Static particle is not below closest cyl. structure, distance = %s' % str(distance_from_closest_axis))
 
-        return ignored_structures
+        return ignored_structure_ids
 
 ####
 class CylindricalSurfacePlanarSurfaceInterfacePairtestShell(PlanarSurfacePairtestShell):
@@ -2118,7 +2144,7 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         # In that case we have to ignore the cylindrical structure at shell construction.
         # Otherwise it does the same as the regular PlanarSurfacePair.
 
-        self.ignored_structures = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
+        self.ignored_structure_ids = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
         # TODO only ignore the cylinder closest to the "static" single
 
         PlanarSurfacePairtestShell(self, single1, single2, geometrycontainer, domains)
@@ -2477,7 +2503,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
         self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
 
-        log.debug('left_scalingangle = %s, right_scalingangle = %s' % (self.left_scalingangle, self.right_scalingangle) )
+        log.debug('left_scalingangle = %s, right_scalingangle = %s' % (self.left_scalingangle, self.right_scalingangle) ) # TODO DEBUG remove
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.

From cba2a4b038da1ae255a57ffa45dfa483ba9c27f9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:02:44 +0200
Subject: [PATCH 1376/1541] Some cleanup

---
 shells.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/shells.py b/shells.py
index 7f237f18..9f466cf6 100755
--- a/shells.py
+++ b/shells.py
@@ -2503,8 +2503,6 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
         self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
 
-        log.debug('left_scalingangle = %s, right_scalingangle = %s' % (self.left_scalingangle, self.right_scalingangle) ) # TODO DEBUG remove
-
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!

From 4523a5d82aea2207da578e6ec4d564db7923f9fc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:06:04 +0200
Subject: [PATCH 1377/1541] Rename 'testMixedPair1DCap' into
 'testMixedPair1DStatic' to generalize

We will use this domain both for the case in which a 1D particle on the rod
interacts with a static cap-bound particle and for the case in which it
interacts with a static plane-bound particle (CylindricalSurfacePlanarSurfaceTransferSingle).
---
 shells.py | 54 +++++++++++++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/shells.py b/shells.py
index 9f466cf6..eb589af1 100755
--- a/shells.py
+++ b/shells.py
@@ -34,7 +34,7 @@
     'testSimplePair',
     'testPlanarSurfaceTransitionPair',
     'testMixedPair2D3D',
-    'testMixedPair1DCap',
+    'testMixedPair1DStatic',
     'hasSphericalShell',
     'hasCylindricalShell',   
     'SphericalSingletestShell',
@@ -54,7 +54,7 @@
     'CylindricalSurfacePlanarSurfaceInterfaceSingletestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
-    'MixedPair1DCaptestShell',
+    'MixedPair1DStatictestShell',
     ]
 
 import logging
@@ -421,14 +421,14 @@ def get_scaling_factor(self):
                                     # normal to the plane
         return math.sqrt(self.D_r/D_3D)
 
-class testMixedPair1DCap(testPair):
+class testMixedPair1DStatic(testPair):
 
-    def __init__(self, single1D, cap_single):
+    def __init__(self, single1D, static_single):
 
         if __debug__: 
                 assert isinstance(single1D.structure, CylindricalSurface) 
-                assert isinstance(cap_single.structure, DiskSurface)
-        testPair.__init__(self, single1D, cap_single)
+                assert isinstance(static_single.structure, DiskSurface)
+        testPair.__init__(self, single1D, static_single)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 1D particle
           #              and self.single2/self.pid_particle_pair2/self.structure2 for the cap particle
 
@@ -436,17 +436,17 @@ def __init__(self, single1D, cap_single):
         self.single1D       = single1D
         self.particle1D     = self.pid_particle_pair1[1]
         self.structure1D    = single1D.structure    # equal to self.structure1  
-        self.cap_single     = cap_single
-        self.cap_particle   = self.pid_particle_pair2[1]        
-        self.cap_structure  = cap_single.structure  # equal to self.structure2
-        # This will be inherited by MixedPair1DCaptestShell and MixedPair1DCap.
+        self.static_single     = static_single
+        self.static_particle   = self.pid_particle_pair2[1]        
+        self.static_structure  = static_single.structure  # equal to self.structure2
+        # This will be inherited by MixedPair1DStatictestShell and MixedPair1DStatic.
         # Note that we have to use pid_particle_pair1(2) in the methods defined below
         # because they are called at the initialization of testPair().
 
         # Make sure cap particle is immobile; this is required for testSimplePair routines
         # to give the proper results for this case.
-        assert self.cap_particle.D == 0
-        assert self.cap_particle.v == 0
+        assert self.static_particle.D == 0
+        assert self.static_particle.v == 0
 
     def get_sigma(self):
         # Copied from SimplePair
@@ -462,7 +462,7 @@ def do_transform(self):
         D_1 = self.pid_particle_pair1[1].D
         D_2 = self.pid_particle_pair2[1].D
 
-        # In the MixedPair1DCap only the 1D particle moves. We therefore use
+        # In the MixedPair1DStatic only the 1D particle moves. We therefore use
         # iv to sample its position and com for the position of the static
         # cap particle; this is initialized here:
         com = pos2
@@ -2941,15 +2941,15 @@ def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, self.z_right(r/SAFETY), z_left
 
 
-class MixedPair1DCaptestShell(CylindricaltestShell, testMixedPair1DCap):
+class MixedPair1DStatictestShell(CylindricaltestShell, testMixedPair1DStatic):
 
     def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testMixedPair1DCap.__init__(self, single1D, cap_single)
+        testMixedPair1DStatic.__init__(self, single1D, cap_single)
 
-        # NOTE: The following is already defined by testMixedPair1DCap:
+        # NOTE: The following is already defined by testMixedPair1DStatic:
         # - self.single1D, self.structure1D, self.particle1D
-        # - self.cap_single, self.cap_structure, self.cap_particle
+        # - self.static_single, self.static_structure, self.static_particle
 
         # Initialize scaling parameters
         # - the reference point is at the cap disk position
@@ -2960,7 +2960,7 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
         CRF             = CYLINDER_R_FACTOR
-        self.dr_const   = max([CRF * self.cap_particle.radius, CRF * self.particle1D.radius])
+        self.dr_const   = max([CRF * self.static_particle.radius, CRF * self.particle1D.radius])
 
         self.dzdr_right = numpy.inf
         self.drdz_right = 0.0
@@ -2969,7 +2969,7 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
         self.r0_left    = self.dr_const
-        self.z0_left    = self.cap_particle.radius * SINGLE_SHELL_FACTOR
+        self.z0_left    = self.static_particle.radius * SINGLE_SHELL_FACTOR
 
         # Now we can also define the scaling angle
         self.right_scalingangle = self.get_right_scalingangle()
@@ -2983,31 +2983,31 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure1D.id, [self.single1D.domain_id, self.cap_single.domain_id], [self.cap_structure.id])
+                            self.determine_possible_shell(self.structure1D.id, [self.single1D.domain_id, self.static_single.domain_id], [self.static_structure.id])
         except ShellmakingError as e:
-            raise testShellError('(MixedPair1DCap). %s' %
+            raise testShellError('(MixedPair1DStatic). %s' %
                                  (str(e)))
 
     def get_orientation_vector(self):        
         # The orientation vector is the (normalized) vector that points from the cap
         # towards the particle on the rod
-        return normalize(self.particle1D.position - self.cap_structure.shape.position)
+        return normalize(self.particle1D.position - self.static_particle.position)
 
     def get_searchpoint(self):
         return self.particle1D.position
 
     def get_referencepoint(self):        
-        return self.cap_structure.shape.position
+        return self.static_particle.position
 
     def get_min_dr_dzright_dzleft(self):
         dr       = self.dr_const
-        dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR
+        dz_left  = self.static_particle.radius * SINGLE_SHELL_FACTOR
         dz_right = self.get_min_pair_size() # TODO make sure this does the right thing!
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.dr_const
-        dz_left  = self.cap_particle.radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
+        dz_left  = self.static_particle.radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
         dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
         return dr, dz_right, dz_left
 
@@ -3022,9 +3022,9 @@ def get_min_pair_size(self):
         # CylindricalSurfacePair -> size = half_length
 
         D_1 = self.particle1D.D
-        D_2 = self.cap_particle.D
+        D_2 = self.static_particle.D
         radius1 = self.particle1D.radius
-        radius2 = self.cap_particle.radius
+        radius2 = self.static_particle.radius
 
         dist_from_com1 = self.r0 * D_1 / self.D_tot     # particle distance from CoM
         dist_from_com2 = self.r0 * D_2 / self.D_tot

From 91e5443e3b7ba48f34c7044571ec96c35cefd0bb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:11:24 +0200
Subject: [PATCH 1378/1541] Same renaming for the associated pair domain

---
 pair.py   | 36 ++++++++++++++++++------------------
 shells.py |  2 +-
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/pair.py b/pair.py
index 57e3da94..00ff7c67 100644
--- a/pair.py
+++ b/pair.py
@@ -23,7 +23,7 @@
     'SimplePair',
     'MixedPair2D3D',
     'MixedPair1D3D',
-    'MixedPair1DCap',
+    'MixedPair1DStatic',
     ]
 
 import logging
@@ -1126,9 +1126,9 @@ def calc_r_scaling_factor(cls, D1, D2):
         return math.sqrt((D1 + D2)/D2)
 
 
-class MixedPair1DCap(Pair, hasCylindricalShell):
+class MixedPair1DStatic(Pair, hasCylindricalShell):
     # This domain is for the interaction of a particle drifting and diffusing on a cylinder (1D particle)
-    # and another (static) particle which is bound to a cap of the same cylinder.
+    # and another (static) particle which is bound to a cap of the same cylinder or its interface with a plane.
     # Since the cap particle is immobile, we effectively have a one-particle problem
     # and the CoM is not used. The displacement of the 1D particle is sampled via iv_greens_function.
     # However, we have to make this a pair domain because we have two particles involved which
@@ -1138,28 +1138,28 @@ class MixedPair1DCap(Pair, hasCylindricalShell):
     def __init__(self, domain_id, shell_id, testShell, rrs):
         # Calls required parent inits and sets variables.
         #
-        # Sets:             particle1D, structure1D, cap_particle, cap_structure
+        # Sets:             particle1D, structure1D, static_particle, static_structure
         # Requires:         nothing to be set       
 
-        assert isinstance(testShell, MixedPair1DCaptestShell)
+        assert isinstance(testShell, MixedPair1DStatictestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         Pair.__init__(self, domain_id, shell_id, rrs)
 
-        assert isinstance(self.testShell, MixedPair1DCaptestShell)
+        assert isinstance(self.testShell, MixedPair1DStatictestShell)
 
         # Some useful definitions 
         self.particle1D    = self.testShell.particle1D
         self.structure1D   = self.testShell.structure1D
-        self.cap_particle  = self.testShell.cap_particle
-        self.cap_structure = self.testShell.cap_structure
+        self.static_particle  = self.testShell.static_particle
+        self.static_structure = self.testShell.static_structure
 
         # The latter is defined for completeness and used by check_domain() in egfrd.py:
         self.origin_structure = self.structure1D
-        self.target_structure = self.cap_structure
+        self.target_structure = self.static_structure
 
-        # The cap_particle should be immobile; check to be sure:
-        assert self.cap_particle.D == 0
-        assert self.cap_particle.v == 0
+        # The static_particle should be immobile; check to be sure:
+        assert self.static_particle.D == 0
+        assert self.static_particle.v == 0
         # D_r and D_R are inherited from Pair class;
         # This results in D_r = particle1D.D and D_R = 0
 
@@ -1171,7 +1171,7 @@ def get_shell_size(self):   # TODO Is that even used?
     def get_a_r(self):
       
         ref_pt = self.testShell.get_referencepoint()
-        assert ( all(self.cap_structure.shape.position - ref_pt == 0) )
+        assert ( all(self.static_particle.position - ref_pt == 0) )
 
         return abs(self.testShell.dz_right) - self.particle1D.radius
     a_r = property(get_a_r)
@@ -1209,15 +1209,15 @@ def choose_pair_greens_function(self, r0, t):
 
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z, world):
-    # here we assume that structure1 = structure1D and structure2 = cap_structure
+    # here we assume that structure1 = structure1D and structure2 = static_structure
     # and that com has been correctly initialized with the initial (and constant) position
-    # of the cap particle.
+    # of the static particle.
 
-        pos2 = com          # cap particle (no. 2) stays in place
+        pos2 = com          # static particle (no. 2) stays in place
         pos1 = pos2 - iv    # IV always points from particle1 to particle2      
 
         return pos1, pos2, structure1.id, structure2.id
-        # TODO Does this give the correct new positions in case of a single reaction of cap_particle ?
+        # TODO Does this give the correct new positions in case of a single reaction of static_particle ?
 
     def create_com_vector(self, z):        
     # This returns the displacement of the com, which is zero here.
@@ -1238,5 +1238,5 @@ def create_interparticle_vector(self, gf, r, dt, r0, old_iv):
         return new_iv_z
 
     def __str__(self):
-        return 'MixedPair1DCap' + Pair.__str__(self)
+        return 'MixedPair1DStatic' + Pair.__str__(self)
 
diff --git a/shells.py b/shells.py
index eb589af1..dbf9a0d9 100755
--- a/shells.py
+++ b/shells.py
@@ -427,7 +427,7 @@ def __init__(self, single1D, static_single):
 
         if __debug__: 
                 assert isinstance(single1D.structure, CylindricalSurface) 
-                assert isinstance(static_single.structure, DiskSurface)
+                assert isinstance(static_single.structure, DiskSurface) or isinstance(static_single.structure, PlanarSurface)
         testPair.__init__(self, single1D, static_single)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 1D particle
           #              and self.single2/self.pid_particle_pair2/self.structure2 for the cap particle

From 64b262d92e5ae1b75220dda20d32715dcbe5ef94 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:21:27 +0200
Subject: [PATCH 1379/1541] One more important check

---
 shells.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index dbf9a0d9..2480a0ff 100755
--- a/shells.py
+++ b/shells.py
@@ -428,6 +428,7 @@ def __init__(self, single1D, static_single):
         if __debug__: 
                 assert isinstance(single1D.structure, CylindricalSurface) 
                 assert isinstance(static_single.structure, DiskSurface) or isinstance(static_single.structure, PlanarSurface)
+                
         testPair.__init__(self, single1D, static_single)
           # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 1D particle
           #              and self.single2/self.pid_particle_pair2/self.structure2 for the cap particle
@@ -448,6 +449,11 @@ def __init__(self, single1D, static_single):
         assert self.static_particle.D == 0
         assert self.static_particle.v == 0
 
+        # If the static particle is on a disk, make sure that its position coincides
+        # with the disk position
+        if isinstance(static_structure, DiskSurface) and __debug__:
+                assert all(static_structure.shape.position - static_particle.position == 0.0)
+
     def get_sigma(self):
         # Copied from SimplePair
         radius1 = self.pid_particle_pair1[1].radius
@@ -2996,7 +3002,7 @@ def get_orientation_vector(self):
     def get_searchpoint(self):
         return self.particle1D.position
 
-    def get_referencepoint(self):        
+    def get_referencepoint(self):
         return self.static_particle.position
 
     def get_min_dr_dzright_dzleft(self):

From 45ecf3d029ded25a30f3e69ed3d27bc44204a0e3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:24:26 +0200
Subject: [PATCH 1380/1541] Convert assert statement to exception that can be
 handled

---
 shells.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 2480a0ff..5facc955 100755
--- a/shells.py
+++ b/shells.py
@@ -446,8 +446,10 @@ def __init__(self, single1D, static_single):
 
         # Make sure cap particle is immobile; this is required for testSimplePair routines
         # to give the proper results for this case.
-        assert self.static_particle.D == 0
-        assert self.static_particle.v == 0
+        if not(self.static_particle.D == 0 and self.static_particle.v == 0):
+            raise testShellError('Particle %s is not static in testMixedPair1DStatic.' % str(self.static_particle))
+
+        # TODO Check whether particles are both on the cylinder axis
 
         # If the static particle is on a disk, make sure that its position coincides
         # with the disk position

From 412d1a1082eb41a54a9b1cf99bc572a60508dfa8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:28:46 +0200
Subject: [PATCH 1381/1541] Generalize construction of MixedPair1DCap to
 MixedPair1DStatic, i.e. also to the cases when the static particle is on the
 plane

---
 egfrd.py | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ab1c8e75..78135f32 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -61,7 +61,7 @@
     CylindricalSurfacePlanarSurfaceInterfaceSingletestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
-    MixedPair1DCaptestShell,
+    MixedPair1DStatictestShell,
     )
 
 import loadsave
@@ -175,9 +175,13 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
         return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
-        return MixedPair1DCaptestShell(single1, single2, geometrycontainer, domains)
+        return MixedPair1DStatictestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):
-        return MixedPair1DCaptestShell(single2, single1, geometrycontainer, domains)
+        return MixedPair1DStatictestShell(single2, single1, geometrycontainer, domains)
+    elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, PlanarSurface)):
+        return MixedPair1DStatictestShell(single1, single2, geometrycontainer, domains)
+    elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, PlanarSurface)):
+        return MixedPair1DStatictestShell(single2, single1, geometrycontainer, domains)
     else:
         # another mixed pair was supposed to be formed -> unsupported
         raise testShellError('(MixedPair). combination of structures not supported')
@@ -195,8 +199,8 @@ def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
     # or MixedPair (3D/2D or 1D/Cap)
     elif isinstance(testShell, MixedPair2D3DtestShell):
         return MixedPair2D3D               (domain_id, shell_id, testShell, reaction_rules)
-    elif isinstance(testShell, MixedPair1DCaptestShell):
-        return MixedPair1DCap              (domain_id, shell_id, testShell, reaction_rules)
+    elif isinstance(testShell, MixedPair1DStatictestShell):
+        return MixedPair1DStatic           (domain_id, shell_id, testShell, reaction_rules)
 
 class Delegate(object):
     def __init__(self, obj, method, arg):
@@ -3034,7 +3038,7 @@ def check_domain(self, domain):
             # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
             ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
             associated = [domain.origin_structure.id, domain.target_structure.id]
-        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D) or isinstance(domain, MixedPair1DCap):
+        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D) or isinstance(domain, MixedPair1DStatic):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.origin_structure.id, domain.target_structure.id]

From 2fdce3c9b2a9b63b3b67ccbd5f0bf2de320c6704 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:36:45 +0200
Subject: [PATCH 1382/1541] All interactions need property
 self.product_structure

---
 shells.py | 8 +++++---
 single.py | 4 +++-
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index 5facc955..967f770a 100755
--- a/shells.py
+++ b/shells.py
@@ -176,9 +176,11 @@ def __init__(self, single, origin_structure, target_structure):
         testSingle.__init__(self, single.pid_particle_pair, origin_structure)
         # Note: for the Others superclass nothing is to be initialized.
 
-        self.single           = single
-        self.origin_structure = origin_structure
-        self.target_structure = target_structure
+        self.single            = single
+        self.origin_structure  = origin_structure
+        self.target_structure  = target_structure
+        self.product_structure = target_structure
+                                 # by default; we allow for exceptions, though.
 
         ### initialize some constants that are common for the testInteractionSingle domains.
 
diff --git a/single.py b/single.py
index 8a7f6252..9589a26a 100644
--- a/single.py
+++ b/single.py
@@ -696,7 +696,9 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
 
         self.origin_structure = self.testShell.origin_structure
         self.target_structure = self.testShell.target_structure 
-             # The surface with which the particle is trying to interact                         
+             # The surface with which the particle is trying to interact
+        self.product_structure = self.testShell.product_structure
+             # The surface that later will hold the product (= target_structure in almost all cases)
 
     def get_interaction_rule(self):
         if self.intrule == None:

From ca82a5cb8dda44d1ef9ee7ad4395f30caa3ace78 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 13 Sep 2013 19:39:44 +0200
Subject: [PATCH 1383/1541] Not selfish enough...

---
 shells.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 967f770a..b29ea97f 100755
--- a/shells.py
+++ b/shells.py
@@ -455,8 +455,8 @@ def __init__(self, single1D, static_single):
 
         # If the static particle is on a disk, make sure that its position coincides
         # with the disk position
-        if isinstance(static_structure, DiskSurface) and __debug__:
-                assert all(static_structure.shape.position - static_particle.position == 0.0)
+        if isinstance(self.static_structure, DiskSurface) and __debug__:
+                assert all(self.static_structure.shape.position - self.static_particle.position == 0.0)
 
     def get_sigma(self):
         # Copied from SimplePair

From 7c1655e0cf21c26ead0d535364b65a4c736a83d9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 16 Sep 2013 19:54:28 +0200
Subject: [PATCH 1384/1541] Fix min-size of plane-cylinder interface shell

---
 shells.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index b29ea97f..f82746c3 100755
--- a/shells.py
+++ b/shells.py
@@ -2658,14 +2658,14 @@ def get_referencepoint(self):
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
         dr       = self.dr_const
-        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         # Radius is not scaled here so we do not to check for distance to shape edge
         dr       = self.dr_const
-        dz_right = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
+        dz_right = self.pid_particle_pair[1].radius # same as the minimum, i.e. no scaling of this length
         dz_left  = dz_right
         return dr, dz_right, dz_left
 

From 1d5b3c8e94c37d09c04141c9cfd05d7151824f73 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 16 Sep 2013 19:54:46 +0200
Subject: [PATCH 1385/1541] WIP on newBDpropagator

The problem is that we get ridiculously high rates now because the
interface particle is on the plane and the rate is rescaled with
the wrong dimension factor for reactions with particles coming
from the rod.

We have to come up with a smarter way to deal with this here.
---
 Multi.hpp | 88 +++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 73 insertions(+), 15 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index f981d09a..56e7981c 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -5,6 +5,8 @@
 #include <boost/algorithm/string/join.hpp>
 #include <boost/foreach.hpp>
 
+#include <gsl/gsl_math.h>
+
 #include "exceptions.hpp"
 #include "Domain.hpp"
 #include "ParticleContainer.hpp"
@@ -315,20 +317,65 @@ class MultiParticleContainer
             species_.size());
     }
     
-    /* Returns largest diffusion constant en smallest particle radius inside the mpc. */
-    real_pair maxD_minsigma() const
+    /* Determines the largest diffusion constant and largest drift coefficient inside the mpc. 
+       and whether movement is dominated by diffusion or drift for a given length scale.
+       Then it returns the typical time to travel that length scale based on which type
+       of movement is dominant.                                                             */
+    Real get_min_tau_Dv(Real r_typical) const
+    {
+        Real D(0.0), v(0.0), tau_D(0.0), tau_v(0.0);
+        Real tau_dominant(0.0), tau_min(-1.0); // keep tau_min negative initially!
+        
+        const Real LARGE_PREF( GSL_POSINF );
+        assert( r_typical > 0.0 );
+                
+        BOOST_FOREACH(species_type s, get_species_in_multi())
+        {            
+            // First we calculate the typical times to travel r_typical by
+            // diffusion and convection, respectively.
+            if( s.D()==0 && s.v()==0)
+              
+                tau_dominant = GSL_POSINF; // static particle, will never move
+            
+            else{
+              
+                tau_D = s.D() > 0.0 ? 2.0 * gsl_pow_2(r_typical) / s.D() : LARGE_PREF * r_typical / s.v();
+                tau_v = s.v() > 0.0 ? r_typical / s.v() : LARGE_PREF * 2.0 * gsl_pow_2(r_typical) / s.D() ;
+                
+                tau_dominant = tau_v < 0.1 * tau_D ? tau_v : tau_D;
+                // We believe that convective movement is dominant if it takes a tenth of the
+                // time to travel the typical distance by convection as compared to diffusion,
+                // and then also the associated time is the relevant timescale.
+                // Note that the 0.1 prefactor is to ensure that we pick the convective
+                // timescale only when the movement is clearly dominated by convection,
+                // i.e. when both timescales are comparable we prefer the diffusion timescale.
+                LOG_DEBUG(("tau_v = %g, tau_D = %g, v=%g, D=%g", tau_v, tau_D, s.v(), s.D() ));
+            }
+            
+            // Now compare if within the current set of species this is the
+            // smallest time scale.
+            assert( tau_dominant > 0.0 );
+            if( tau_min < 0.0 || tau_dominant < tau_min )
+                  tau_min = tau_dominant;
+        }
+        
+        assert( tau_min > 0.0 );
+        
+        return tau_min;
+    }
+    
+    /* Returns smallest particle radius inside the mpc. */
+    Real get_min_radius() const
     {
-        Real D_max(0.), radius_min(std::numeric_limits<Real>::max());
+        Real radius_min(std::numeric_limits<Real>::max());
 
         BOOST_FOREACH(species_type s, get_species_in_multi())
         {
-            if (D_max < s.D())
-                D_max = s.D();
             if (radius_min > s.radius())
                 radius_min = s.radius();
         }
         
-        return real_pair(D_max, radius_min);
+        return radius_min;
     }
     
     /* Functions returns largest _1D_ intrinsic reaction rate in the multi. */
@@ -372,6 +419,8 @@ class MultiParticleContainer
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
                     Real const k( struct_and_dist.first->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
+                    
+                    LOG_DEBUG(("k=%g, radius=%g", k, s.radius() ));
 
                     if ( k_max < k )
                         k_max = k;
@@ -428,6 +477,8 @@ class MultiParticleContainer
                         k0 = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
                         k1 = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
                         
+                        LOG_DEBUG(("k0=%g, k1=%g, k=%g", k0, k1, (*it).k() ));
+                        
                         k = k0 > k1 ? k0 : k1;
                     }
                     // NOTE: If a structure of the required structure type can not be found a not_found exception
@@ -460,26 +511,33 @@ class MultiParticleContainer
     */    
     real_pair determine_dt_and_reaction_length(network_rules_type const& rules, Real const& step_size_factor, Real const& dt_hardcore_min = -1.0) const
     {               
-        const real_pair maxD_minr( maxD_minsigma() );
+        
         const Real k_max( get_max_rate(rules) );
-        const Real D_max( maxD_minr.first );
-        const Real r_min( maxD_minr.second );
+        const Real r_min( get_min_radius() );
+        
+        // The following gives us the typical timescale to travel the length step_size_factor * r_min,
+        // taking into account all species in the Multi and automatically comparing whether their movement
+        // is dominated by convection or diffusion, respectively.
+        const Real tau_Dv( get_min_tau_Dv(step_size_factor * r_min) );
+        
         const Real Pacc_max( 0.1 ); // Maximum allowed value of the acceptance probability. // TESTING was 0.01
                                     // This should be kept very low (max. 0.01), otherwise the approximation of
-                                    // treating the reaction as two sequential attempts fails
-        Real dt;
-        const Real tau_D( 2. * gsl_pow_2(step_size_factor * r_min) / D_max );
+                                    // treating the reaction as two sequential attempts (first move, then react)
+                                    // might break down!
+        Real dt, dt_temp;
         
         if( k_max > 0)
         {
             // step_size_factor * r_min is the reaction length
             // Here it is assumed that the RL is linear in any dimension,
             // which requires it to be very small!
-            Real dt_temp( 2. * Pacc_max * step_size_factor * r_min / k_max );
-            dt = std::min( dt_temp, tau_D ); // tau_D is upper limit of dt.
+            dt_temp = 2. * Pacc_max * step_size_factor * r_min / k_max;
+            dt = std::min( dt_temp, tau_Dv ); // tau_Dv is upper limit of dt.
         }
         else
-            dt = tau_D;
+            dt = tau_Dv;
+        
+        LOG_DEBUG(("tau_Dv = %g, tau_k = %g, k_max = %g, r_min = %g, ssf = %g", tau_Dv, dt_temp, k_max, r_min, step_size_factor));
         
         if( dt < dt_hardcore_min )      dt = dt_hardcore_min;
 

From bd35f3b2628d861c7807daa25c247436a52cff37 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 17 Sep 2013 11:40:45 +0200
Subject: [PATCH 1386/1541] Better treatment of applying the right
 rate-modifier function when determining the maximal rate in Multi.hpp

We now check whether on of the two particles is static, and in that
case take the modified rate of the mobile particle.

This however does not resolve the principal problem yet, which is
that we do not acquire enough information about the actual situation
in this procedure.
---
 Multi.hpp | 49 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 30 insertions(+), 19 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 56e7981c..21860b04 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -323,8 +323,8 @@ class MultiParticleContainer
        of movement is dominant.                                                             */
     Real get_min_tau_Dv(Real r_typical) const
     {
-        Real D(0.0), v(0.0), tau_D(0.0), tau_v(0.0);
-        Real tau_dominant(0.0), tau_min(-1.0); // keep tau_min negative initially!
+        Real tau_D(0.0), tau_v(0.0); // the estimated times to travel r_typical by diffusion / convection
+        Real tau_dominant(0.0), tau_min(-1.0); // always keep tau_min negative initially!
         
         const Real LARGE_PREF( GSL_POSINF );
         assert( r_typical > 0.0 );
@@ -349,11 +349,9 @@ class MultiParticleContainer
                 // Note that the 0.1 prefactor is to ensure that we pick the convective
                 // timescale only when the movement is clearly dominated by convection,
                 // i.e. when both timescales are comparable we prefer the diffusion timescale.
-                LOG_DEBUG(("tau_v = %g, tau_D = %g, v=%g, D=%g", tau_v, tau_D, s.v(), s.D() ));
             }
             
-            // Now compare if within the current set of species this is the
-            // smallest time scale.
+            // Now compare if within the current set of species this is the smallest time scale.
             assert( tau_dominant > 0.0 );
             if( tau_min < 0.0 || tau_dominant < tau_min )
                   tau_min = tau_dominant;
@@ -371,8 +369,8 @@ class MultiParticleContainer
 
         BOOST_FOREACH(species_type s, get_species_in_multi())
         {
-            if (radius_min > s.radius())
-                radius_min = s.radius();
+            if(radius_min > s.radius())
+                    radius_min = s.radius();
         }
         
         return radius_min;
@@ -418,9 +416,7 @@ class MultiParticleContainer
                 for (typename boost::range_const_iterator<reaction_rules>::type
                 it(boost::begin(rrules)), e(boost::end(rrules)); it != e; ++it)
                 {
-                    Real const k( struct_and_dist.first->get_1D_rate_surface( (*it).k(), s.radius() ) ); 
-                    
-                    LOG_DEBUG(("k=%g, radius=%g", k, s.radius() ));
+                    Real const k( struct_and_dist.first->get_1D_rate_surface( (*it).k(), s.radius() ) );                     
 
                     if ( k_max < k )
                         k_max = k;
@@ -467,25 +463,40 @@ class MultiParticleContainer
                         k = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
                     
                     else
-                    // If both particles live on lower dimensionality structures for now we take the maximal rate
-                    // as determined from get_1D_rate_geminate() of both structures. TODO This may lead to a maximal
-                    // rate which actually is higher than the one used in BD propagation and therefore waste resources.
+                    // If both particles live on lower dimensionality structures more care has to be taken in determining
+                    // what is the right modifier function for the bare rate.
+                    // For now by default we take the maximal rate as determined from get_1D_rate_geminate() of both structures.
+                    // However, if one of the two interacting species is static (D=0, v=0), the "dimensionality" of the motion
+                    // is exclusively determined by the mobile species, and we have to take the modifier function of that one.
+                    // FIXME Taking the max by default may lead to a rate which actually is higher than the one that should
+                    // be used in BD propagation and therefore wastes resources.
                     // Until now this case basically only comprises the rod-particle/cap-particle interaction. Since
                     // both rates are equal in this case we do not make any approximation in that case. However, if we
                     // allow for other types of lower dimensionality particle-particle reactions we should fix this.
                     {
-                        k0 = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
-                        k1 = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                        // In case that one of the two particles is static, make sure we modify the rate using the
+                        // modifier function of the structure that holds the *mobile* species:
+                        if(s0.D()==0.0 and s0.v()==0.0) // s1 is the mobile species
+                          k = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
                         
-                        LOG_DEBUG(("k0=%g, k1=%g, k=%g", k0, k1, (*it).k() ));
+                        else if(s1.D()==0.0 and s1.v()==0.0) // s0 is the mobile species
+                          k = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
                         
-                        k = k0 > k1 ? k0 : k1;
+                        else{
+                            // Pick the higher of the modified rates
+                            k0 = get_some_structure_of_type(s0.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );
+                            k1 = get_some_structure_of_type(s1.structure_type_id())->get_1D_rate_geminate( (*it).k(), r01 );                            
+                                                    
+                            k = k0 > k1 ? k0 : k1;
+                            // FIXME This is not very elegant yet and may cause that a rate that is way too high is picked 
+                            // if the species' structures have different dimensionalities
+                        }                        
                     }
                     // NOTE: If a structure of the required structure type can not be found a not_found exception
                     // is risen. This however should never happen, because whenever a particle of species s0 (s1)
                     // is in the system also at least one structure of the associated structure type should exist.
                     
-                    // Compare with the fasted rate found so far
+                    // Compare with the fastest rate found so far
                     k_max = k > k_max ? k : k_max;
                 }
             }
@@ -537,7 +548,7 @@ class MultiParticleContainer
         else
             dt = tau_Dv;
         
-        LOG_DEBUG(("tau_Dv = %g, tau_k = %g, k_max = %g, r_min = %g, ssf = %g", tau_Dv, dt_temp, k_max, r_min, step_size_factor));
+        //LOG_DEBUG(("tau_Dv = %g, tau_k = %g, k_max = %g, r_min = %g, ssf = %g", tau_Dv, dt_temp, k_max, r_min, step_size_factor)); TODO Cleanup
         
         if( dt < dt_hardcore_min )      dt = dt_hardcore_min;
 

From 30b68165c5a498f5d563a9eb4c532d3ed1a6ec9d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 17 Sep 2013 12:14:53 +0200
Subject: [PATCH 1387/1541] Treat case D_2D=0 in MixedPair2D3D

We now get these cases whenever a 3D particle attempts to form a
mixed pair with a static cylinder-plane interface particle, which
nominally is a plane/2D particle.
---
 shells.py | 40 ++++++++++++++++++++++++++++++----------
 1 file changed, 30 insertions(+), 10 deletions(-)

diff --git a/shells.py b/shells.py
index f82746c3..7cfe8ffd 100755
--- a/shells.py
+++ b/shells.py
@@ -372,14 +372,26 @@ def get_sigma(self):
         # slightly different from the sums of the radii of the particles. We rescale sigma in a way
         # that the total flux over the reactive surface of the prolate spheroidal boundary with greater radius
         # sigma is equal to the total flux over a spherical reactive surface with radius = rescaled sigma.
-        xi = self.get_scaling_factor()
-        xi_inv = 1.0/xi
-        alpha = math.acos(xi_inv)
-
+        xi    = self.get_scaling_factor()
         sigma = self.particle2D.radius + self.particle3D.radius
-        rescaled_sigma = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
+
+        if feq(xi, 1.0, typical=1.0):
+
+            # If the scaling factor happens to be equal to one (i.e. no rescaling) alpha and sin(alpha)
+            # in the rescaling formula for sigma below will be zero and cause zero-division problems.
+            # However, if xi=1 we know that we do not have to rescale sigma at all.
+            # The case xi=1 usually means that the 2D particle is static (D_2D=0).
+            rescaled_sigma = sigma
+
+        else:
+
+            xi_inv = 1.0/xi
+            alpha  = math.acos(xi_inv)
+            
+            rescaled_sigma = abs(sigma * math.sqrt(0.5 + (alpha * xi/(2.0*math.sin(alpha)))))
 
         return rescaled_sigma
+
     sigma = property(get_sigma)
 
     def do_transform(self):
@@ -2880,11 +2892,19 @@ def z_right(self, r_right):
         D_2D = self.particle2D.D
         D_3D = self.particle3D.D
 
-        # calculate a_r such that the expected first-passage for the CoM and IV are equal        
-        a_r_2D = (r_right - radius2D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2D/self.D_tot) )
-        a_r_3D = (r_right - radius3D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_3D/self.D_tot) )        
-        # take the smaller a_r that, if entered in the function for r below, would lead to this r_right
-        a_r = min(a_r_2D, a_r_3D)
+        # Calculate a_r, the maximally available length for r-diffusion, by equalizing
+        # equalizing the expected first-passage for the CoM and IV diffusion.
+        # First, treat the special case in which the 2D particle is static; then D_2D=0,
+        # implying D_R=0, D_tot=D_3D and sqrt_DRDr=0, and a_r is determined only by the
+        # 3D diffusion time / free path for 3D diffusion.
+        if self.D_R==0:
+            a_r_3D = r_right - radius3D
+            a_r    = a_r_3D
+        else: # standard case, D_R>0, D_r>0
+            a_r_2D = (r_right - radius2D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_2D/self.D_tot) )
+            a_r_3D = (r_right - radius3D + self.r0*self.sqrt_DRDr ) / (self.sqrt_DRDr + (D_3D/self.D_tot) )        
+            # take the smaller a_r that, if entered in the function for r below, would lead to this r_right
+            a_r = min(a_r_2D, a_r_3D)
 
         z_right = (a_r/self.get_scaling_factor()) + radius3D
 

From b848ac0b59e8567aa995b57bf13538e9f2479807 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 17 Sep 2013 14:28:50 +0200
Subject: [PATCH 1388/1541] Forgot to save and re-load decay reaction rules in
 load/save system

Now it works.
---
 loadsave.py | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index b19a1437..78977c01 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -158,7 +158,12 @@ def save_state(simulator, filename):
                   r0 = rr.reactants[0]
                   reactant_ids = ( id_to_int(r0), )
 
-                  if len(rr.products) == 1:
+                  if len(rr.products) == 0:
+
+                      rtype = 'decay'
+                      product_ids  = ()
+
+                  elif len(rr.products) == 1:
 
                       rtype = 'unimolecular'
                       p0 = rr.products[0]
@@ -573,7 +578,19 @@ def load_state(filename):
         product_ids  = eval(cp.get(sectionname, 'product_ids'))
 
         rule = None
-        if rtype == 'unimolecular':
+        if rtype == 'decay':
+
+            assert len(reactant_ids) == 1 and reactant_ids[0] != None and \
+                   len(product_ids)  == 0, \
+                     'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
+
+            # Get the reactant species
+            reactant = species_dict[int(reactant_ids[0])]
+
+            # Create the decay rule
+            rule = model.create_decay_reaction_rule(reactant, rate)
+
+        elif rtype == 'unimolecular':
 
             assert len(reactant_ids) == 1 and reactant_ids[0] != None and \
                    len(product_ids)  == 1 and product_ids[0]  != None, \

From 7192bfda6806c17051c5bf854c429d119544ade0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Sep 2013 14:57:41 +0200
Subject: [PATCH 1389/1541] Some important fixes

---
 egfrd.py | 35 ++++++++++++++++++++++++++---------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 78135f32..30850de1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1109,12 +1109,15 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
         if __debug__:
             assert isinstance(single, Single)
 
-        # 0. get reactant info
+        # 0. Get reactant info
         reactant                    = single.pid_particle_pair
         reactant_radius             = reactant[1].radius
-        species                     = self.world.get_species(reactant[1].sid)
-        reactant_structure_type_id  = species.structure_type_id
+        reactant_species            = self.world.get_species(reactant[1].sid)
+        reactant_structure_type_id  = reactant_species.structure_type_id
         reactant_structure          = self.world.get_structure(reactant_structure_id)
+        reactant_structure_parent_id = reactant_structure.structure_id
+        reactant_structure_parent_structure = self.world.get_structure(reactant_structure_parent_id)
+        # Get reaction rule
         rr = single.reactionrule
 
         # The zero_singles are the NonInteractionSingles that are the total result of the recursive
@@ -1150,7 +1153,8 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             # 1.5 get new position and structure_id of particle
             # If the particle falls off a surface (other than CuboidalRegion)
             if product_structure_type_id != reactant_structure_type_id:
-                assert (product_structure_type_id == self.world.get_def_structure_type_id())
+                assert (product_structure_type_id == self.world.get_def_structure_type_id()  \
+                     or product_structure_type_id == reactant_structure_parent_structure.sid )
 
                 # produce a number of new possible positions for the product particle
                 # TODO make these generators for efficiency
@@ -1201,8 +1205,17 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
             # If decay happens to same structure_type
             else:
-                product_pos_list     = [reactant_pos]           # no change of position is required if structure_type doesn't change
-                product_structure_id = reactant_structure_id    # The product structure is the structure where the reaction takes place.
+
+                # The following case has to be treated in a special way because particle "unbind" as if they came from a cylinder
+                # FIXME Make this more elegant; this whole method should be cleaned up and unified!
+                if isinstance(single, CylindricalSurfacePlanarSurfaceInterfaceSingle):
+                    product_pos, product_structure_id = single.draw_new_position(dt=0.0, event_type=EventType.SINGLE_REACTION)
+
+                else: # standard case
+                    product_pos = reactant_pos
+                    product_structure_id = reactant_structure_id
+
+                product_pos_list     = [product_pos]           # no change of position is required if structure_type doesn't change
 
 
             # 2. make space for the products (kinda brute force, but now we only have to burst once).
@@ -1917,11 +1930,15 @@ def make_new_domain(self, single):
 
             # Also add surfaces
             for surface, distance in surface_distances:
-                if isinstance(surface, PlanarSurface):
-                    # with a planar surface it is the center of mass that 'looks around'
+                if isinstance(surface, PlanarSurface) and single.structure.id == self.world.get_def_structure_id():
+                    # With a planar surface it is the center of mass that 'looks around',
+                    # but only for the classical situation of a 3D/bulk particle interacting with a plane.
+                    # In all other situations the horizon for surface collisions should be measured from
+                    # from the particle radius, otherwise we get situations in which a single cannot be
+                    # constructed any more, yet a close plane will not be identified as a Multi partner.
                     surface_horizon = single_radius * (MULTI_SHELL_FACTOR - 1.0)
                 else:
-                    # with a cylindrical surface it is the surface of the particle
+                    # With a cylindrical surface it is the surface of the particle
                     surface_horizon = single_radius * MULTI_SHELL_FACTOR
 
                 multi_partners.append((surface, distance - surface_horizon))

From e7491c77ef5d1549ae2d703d7cfeca046ba8ba64 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Sep 2013 16:27:40 +0200
Subject: [PATCH 1390/1541] Tentative version of Cylinder->Plane Interaction
 that places the interacting particle on a (sub-) disk on the plane

---
 shells.py | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 59 insertions(+), 3 deletions(-)

diff --git a/shells.py b/shells.py
index 7cfe8ffd..49e85814 100755
--- a/shells.py
+++ b/shells.py
@@ -2594,8 +2594,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
-            raise testShellError('(CylindricalSurfaceCapInteraction). %s' %
-                                 (str(e)))
+            raise testShellError('(CylindricalSurfaceCapInteraction). %s' % (str(e)) )
 
     def get_orientation_vector(self):
         # The orientation vector is the (normalized) vector that points from the cap
@@ -2630,8 +2629,15 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
         # This is essentially the same as CylindricalSurfaceCapInteractiontestShell, only that
         # the orientation vector has to be calculated in a different way.
-
+        
         assert isinstance(target_structure, PlanarSurface)
+        assert isinstance(self.origin_structure, CylindricalSurface)
+
+        try:
+            self.daughter_disk = self.find_daughter_disk()
+
+        except testShellError as e:
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInteractionSingle) %s' % (str(e)) )
 
     def get_orientation_vector(self):
         # The orientation vector is the (normalized) difference vector pointing from
@@ -2640,6 +2646,56 @@ def get_orientation_vector(self):
         projected_position = self.target_structure.project_point(particle_position)[0]
         return normalize(particle_position - projected_position)
 
+    def find_daughter_disk(self):
+
+        # Determine the distance to the closest disk
+        # First get all close disk surfaces, then sort, then get the distance to the closest
+        search_pos = self.pid_particle_pair[1].position
+        close_surfaces      = get_neighbor_surfaces(self.world, search_pos, self.structure.id, [])
+        close_disk_surfaces = [surface_and_dist for surface_and_dist in close_surfaces if isinstance(surface_and_dist[0], DiskSurface)]
+
+        found_good_disk = False
+
+        if close_disk_surfaces != []:
+
+            # To be sure, sort the list again by increasing distance
+            sorted_close_disk_surfaces = sorted(close_disk_surfaces, key=lambda surface_and_dist : surface_and_dist[1])
+
+            # Get the closest disk and its properties
+            closest_disk      = sorted_close_disk_surfaces[0][0]
+            closest_disk_dist = sorted_close_disk_surfaces[0][1]
+
+            disk_parent_structure       = self.world.get_structure(closest_disk.structure_id)
+            log.debug('disk_parent_structure = %s' % str(disk_parent_structure))
+            distance_from_plane         = self.target_structure.project_point(closest_disk.shape.position)[1][0]
+            distance_from_cylinder_axis = self.origin_structure.project_point(closest_disk.shape.position)[1][0]            
+            
+            # Check whether the disk is fulfilling the requirements
+            if not disk_parent_structure.id == self.target_structure.id:
+
+                found_good_disk = False
+                if __debug__:
+                    log.warn('(CylindricalSurfacePlanarSurfaceInteractionSingle) Disk surface does not have target plane as parent structure.')
+
+            if not feq(distance_from_plane, 0.0, typical = closest_disk.shape.radius):
+
+                found_good_disk = False
+                if __debug__:
+                    log.warn('(CylindricalSurfacePlanarSurfaceInteractionSingle) Disk surface is not situated in target plane.')
+
+            if not feq(distance_from_cylinder_axis, 0.0, typical = self.origin_structure.shape.radius):
+
+                found_good_disk = False
+                if __debug__:
+                    log.warn('(CylindricalSurfacePlanarSurfaceInteractionSingle) Disk surface is not situated below cylinder.')
+
+        # OK, if everything is good, return the disk. If not, we don't make this domain and the plane is an obstacle.
+        if found_good_disk:
+            return closest_disk
+
+        else:
+            raise testShellError('Could not find correct disk surface at the interface between cylinder and plane.')
+
 class CylindricalSurfacePlanarSurfaceInterfaceSingletestShell(CylindricalSurfaceCapInteractiontestShell):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):

From 9857e89e21bb567da8c8d6b6c65b0001302dbbc4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Sep 2013 18:00:01 +0200
Subject: [PATCH 1391/1541] Some informative commenting

---
 StructureContainer.hpp | 8 ++++++++
 StructureUtils.hpp     | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 2b2cebbb..136a166a 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -285,9 +285,14 @@ class StructureContainer
     }
     structure_id_set get_visible_structures(structure_id_type const& id) const
     {
+        // This function returns all structures that are visible form the structure with
+        // the ID passed to the function.
+        // A structure is visible if it is a substructure or if it has the same parent
+        // structure as the current structure.
         structure_id_set visible_structures;
 
         const boost::shared_ptr<const structure_type> structure(get_structure(id));
+        // First check the "sibling" structures
         if (structure->structure_id() == id)
         {
             visible_structures = structure_id_set();
@@ -297,8 +302,11 @@ class StructureContainer
             visible_structures = get_visible_structures(structure->structure_id());
             visible_structures.erase(id);
         }
+        
+        // Now the substructures
         const structure_id_set substructures (get_substructure_ids(id));
         visible_structures.insert(substructures.begin(), substructures.end());
+        
         return visible_structures;
     }
 
diff --git a/StructureUtils.hpp b/StructureUtils.hpp
index 73bc741b..207cd418 100644
--- a/StructureUtils.hpp
+++ b/StructureUtils.hpp
@@ -135,7 +135,7 @@ struct StructureUtils
         BOOST_ASSERT(is_cartesian_versor(unit_z));
 
         return new disk_surface_type(name, sid, parent_struct_id,
-                disk_type(center, radius, unit_z));
+                                     disk_type(center, radius, unit_z));
     }
 
     static cuboidal_region_type* create_cuboidal_region(

From 2f1b01afe6c98a6d1a389cb321570043bfb660e5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Sep 2013 18:00:29 +0200
Subject: [PATCH 1392/1541] Correctly handle Cylinder->Plane transfer in BD
 mode structure functions

---
 StructureFunctions.hpp | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 599f9d41..d92a4515 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -363,7 +363,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     structure_id_type   new_id(    target_structure.id() );
     position_type       new_pos(   target_structure.project_point(old_pos).first );
     length_type         proj_dist( target_structure.project_point(old_pos).second.second );
-        // the distance of the projection of old_pos on target_structure to target_structure
+        // the distance of the projection of old_pos on target_structure to the boundary of target_structure
     
     // Note that this function also correctly handles the pair reaction between a particle on a disk
     // and a particle on a cylinder. Since we assume that the product will end up on the disk, new_pos
@@ -392,10 +392,26 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Plane).");
+    structure_id_type   new_id(    target_structure.id() );
+    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    length_type         proj_dist( target_structure.project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to the boundary of target_structure
+        
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (Cylinder->Plane).");
     
-    return std::make_pair(position_type(), structure_id_type());
+    // TODO Does that also handle correctly the interaction of a rod particle with a particle located on the plane?
+    // (whether this is relevant for now is the other question...)
+    
+//     /*** COMBINATION NOT SUPPORTED ***/
+//     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Plane).");
+//     
+//     return std::make_pair(position_type(), structure_id_type());
 };
 
 /***************************/

From a10e784e91cda4676d3a18f5cf058a03f57303fc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Sep 2013 18:32:07 +0200
Subject: [PATCH 1393/1541] Small fix

---
 shells.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/shells.py b/shells.py
index 49e85814..ef263994 100755
--- a/shells.py
+++ b/shells.py
@@ -2651,7 +2651,7 @@ def find_daughter_disk(self):
         # Determine the distance to the closest disk
         # First get all close disk surfaces, then sort, then get the distance to the closest
         search_pos = self.pid_particle_pair[1].position
-        close_surfaces      = get_neighbor_surfaces(self.world, search_pos, self.structure.id, [])
+        close_surfaces      = get_neighbor_surfaces(self.world, search_pos, self.target_structure.id, [])        
         close_disk_surfaces = [surface_and_dist for surface_and_dist in close_surfaces if isinstance(surface_and_dist[0], DiskSurface)]
 
         found_good_disk = False
@@ -2663,14 +2663,15 @@ def find_daughter_disk(self):
 
             # Get the closest disk and its properties
             closest_disk      = sorted_close_disk_surfaces[0][0]
-            closest_disk_dist = sorted_close_disk_surfaces[0][1]
+            closest_disk_dist = sorted_close_disk_surfaces[0][1]            
 
-            disk_parent_structure       = self.world.get_structure(closest_disk.structure_id)
-            log.debug('disk_parent_structure = %s' % str(disk_parent_structure))
+            disk_parent_structure       = self.world.get_structure(closest_disk.structure_id)            
             distance_from_plane         = self.target_structure.project_point(closest_disk.shape.position)[1][0]
-            distance_from_cylinder_axis = self.origin_structure.project_point(closest_disk.shape.position)[1][0]            
+            distance_from_cylinder_axis = self.origin_structure.project_point(closest_disk.shape.position)[1][0]
+
+            found_good_disk = True
             
-            # Check whether the disk is fulfilling the requirements
+            # Check whether the disk indeed fulfills all requirements, if not drop warnings.
             if not disk_parent_structure.id == self.target_structure.id:
 
                 found_good_disk = False

From 2fa6e39ae04c484d88cae462bc79b4243a97a48a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Sep 2013 18:32:14 +0200
Subject: [PATCH 1394/1541] Update shell overlap ignore lists

---
 egfrd.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 30850de1..b8d9d6c1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3048,17 +3048,17 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
         elif isinstance(domain, DiskSurfaceSingle):
-            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring/parent rods
+            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring/parent rods!
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
             associated = [domain.structure.id]
-        elif isinstance(domain, CylindricalSurfaceInteraction):
-            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
+        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle):
+            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now. TODO Only ignore relevant disks!
             ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
             associated = [domain.origin_structure.id, domain.target_structure.id]
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D) or isinstance(domain, MixedPair1DStatic):
             # Ignore surface of the particle and interaction surface
             ignores = []
-            associated = [domain.origin_structure.id, domain.target_structure.id]
+            associated = [domain.origin_structure.id, domain.target_structure.id]        
         elif isinstance(domain, PlanarSurfacePair):
             # PlanarSurface domains sometimes are formed with a particle that just exited from a rod onto the plane.
             # In these cases, the rod shall be ignored.

From 3a94d5099aab6f21f10b0b50b7822f032d1bfb4c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 18 Sep 2013 18:53:45 +0200
Subject: [PATCH 1395/1541] Make Cyl.SurfacePlanarSurfaceInterfaceSingle an
 interaction from plane to disk

Does not work completely yet, have to fix shellscaling, in particular
ignore the cylinder, which is now not a priori visible to the shell any more.
---
 egfrd.py  |  8 +++++---
 shells.py | 10 +++++++---
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b8d9d6c1..72853a4f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -105,12 +105,14 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
             # here we have 2 possibilities; first we try the less probable one (special conditions apply that are checked
             # upon test shell construction), then the more common one.
             try:
-                return CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (single, target_structure, geometrycontainer, domains)
+                pass # TODO TODO TODO Fix this
             except testShellError as e:
                 if __debug__:
                     log.warn('Could not make CylindricalSurfacePlanarSurfaceInterfaceSingletestShell, %s; now trying PlanarSurfaceCylindricalSurfaceInteractiontestShell.' % str(e))
                 return PlanarSurfaceCylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
-                # if both shells do not work in this situation the second try will result in raising another shellmaking exception
+                # if both shells do not work in this situation the second try will result in raising another shellmaking exception       
+        elif isinstance(target_structure, DiskSurface):
+            return CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
@@ -3047,7 +3049,7 @@ def check_domain(self, domain):
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
-        elif isinstance(domain, DiskSurfaceSingle):
+        elif isinstance(domain, DiskSurfaceSingle) or isinstance(domain, CylindricalSurfacePlanarSurfaceInterfaceSingle):
             # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring/parent rods!
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
             associated = [domain.structure.id]
diff --git a/shells.py b/shells.py
index ef263994..e06a5cd5 100755
--- a/shells.py
+++ b/shells.py
@@ -2704,10 +2704,10 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         # We want to form this domain only when the particle just arrived onto the plane exiting from a perpendicular cylinder
         # Here we check in advance whether the particle is on the cylinder axis by projecting the difference vector between
         # particle position and cylinder midpoint onto the plane (the projection is zero if both lie on the cyl. axis)
-        distance_from_axis = target_structure.project_point(single.pid_particle_pair[1].position)[1][0]
-        if not feq(distance_from_axis, 0.0, typical=single.pid_particle_pair[1].radius):
+        distance_from_center = target_structure.project_point(single.pid_particle_pair[1].position)[1][0]
+        if not feq(distance_from_center, 0.0, typical=single.pid_particle_pair[1].radius):
 
-            raise testShellError(('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Particle is not directly below cylinder, distance from axis = %s' % distance_from_axis))
+            raise testShellError(('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_axis))
 
         # If everything seems OK, we can proceed with creating the test shell
         CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
@@ -2724,6 +2724,10 @@ def get_searchpoint(self):
     def get_referencepoint(self):
         return self.pid_particle_pair[1].position
 
+    def get_orientation_vector(self):
+        return self.target_structure.shape.unit_z
+        # just copy from disk structure
+
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
         dr       = self.dr_const

From 8988f78e2b18956c3dcc87595d0c013ef559580e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 11:24:45 +0200
Subject: [PATCH 1396/1541] New function that finds the closest structure form
 a point + revised other structure search functions

---
 gfrdbase.py | 97 ++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 84 insertions(+), 13 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index e1aa3088..5244ec0c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -41,6 +41,7 @@
     'ParticleSimulatorBase',
     'get_all_surfaces',
     'get_neighbor_surfaces',
+    'get_closest_structure',
     'create_network_rules_wrapper',
     ]
 
@@ -83,6 +84,7 @@ def setup_logging():
 
 
 def p_free(r, t, D):
+
     Dt4 = D * t * 4.0
     Pi4Dt = numpy.pi * Dt4
     rsq = r * r
@@ -93,19 +95,20 @@ def p_free(r, t, D):
 
     return p * jacobian
 
-def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[]):
-    
-    if ignores:
-        ignore = ignores[0]
-    else:
-        ignore = world.get_def_structure_id()   # smt random
-
-    surface_distances = [(structure, distance) for ((id, structure), distance) in world.get_close_structures(pos, current_struct_id, ignore)]
-
-    return surface_distances
 
 def get_all_surfaces(world, pos, ignores=[]):
-
+    """ Returns a list of all surfaces in the world, sorted by increasing distance.
+        The output format is (structure, distance from search position).
+        
+        Arguments:
+            - world
+                  the world that contains the structures
+            - pos
+                  the search position
+            - ignores (optional)
+                  a list of structure IDs that will define structures that will be
+                  ignored in the search        
+    """
     surface_distances = []
 
     for surface in world.structures:
@@ -115,10 +118,75 @@ def get_all_surfaces(world, pos, ignores=[]):
             distance = world.distance(surface.shape, pos_transposed)
             surface_distances.append((surface, distance))
 
-    return sorted(surface_distances, key=lambda surface_dist: surface_dist[1])
+    return sorted(surface_distances, key=lambda surface_and_dist: surface_and_dist[1])
+
+
+def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[], structure_class=None):
+    """ Returns a list of neighboring structures, optionally restricted to type 'structure_class',
+        sorted by increasing distance from the search position.
+        The output format is (structure, distance from search position).
+
+        Arguments:
+            - world
+                  the world that contains the structures
+            - pos
+                  the search position
+            - current_struct_id
+                  the structure that the search position is assumed to belong to
+                  (this defines which other structures are 'visible' from that point)
+            - ignores (optional)
+                  a list of structure IDs that will define structures that will be
+                  ignored in the search
+            - structure_class (optional)
+                  restrict the search to a certain structure class; must be one of
+                  CuboidalRegion, PlanarSurface, DiskSurface, CylindricalSurface, SphericalSurface
+    """    
+    if ignores:
+        ignore = ignores[0] # FIXME world.get_close_structures currently only supports one ignored structure
+    else:
+        ignore = world.get_def_structure_id() # Is that a good convention?
+
+    if structure_class != None:
+        # The user has specified a restriction of the search to a particular geometric class
+        assert(    structure_class==CuboidalRegion     or structure_class==PlanarSurface       \
+                or structure_class==Disk Surface       or structure_class==CylindricalSurface  \
+                or structure_class==SphericalSurface                                           )
+
+        surface_distances = [(structure, distance) for ((id, structure), distance) in world.get_close_structures(pos, current_struct_id, ignore) \
+                                                                                                      if isinstance(structure, structure_class)]
+    else:
+        # Take into account all surface types
+        surface_distances = [(structure, distance) for ((id, structure), distance) in world.get_close_structures(pos, current_struct_id, ignore)]
+
+    return sorted(surface_distances, key=lambda surface_and_dist: surface_and_dist[1])
+
+
+def get_closest_structure(world, pos, current_struct_id, ignores=[], structure_class=None):
+    """ Returns the closest structure of type 'structure_class' (optionally).
+        The output format is (structure, distance from search position).
+
+        Arguments:
+            - world
+                  the world that contains the structures
+            - pos
+                  the search position
+            - current_struct_id
+                  the structure that the search position is assumed to belong to
+                  (this defines which other structures are 'visible' from that point)
+            - ignores (optional)
+                  a list of structure IDs that will define structures that will be
+                  ignored in the search
+            - structure_class (optional)
+                  restrict the search to a certain structure class; must be one of
+                  CuboidalRegion, PlanarSurface, CylindricalSurface, DiskSurface, SphericalSurface
+    """
+    sorted_close_surfaces = get_neighbor_surfaces(self.world, pos, current_struct_id, ignores, structure_class)
+
+    return sorted_close_surfaces[0]
+
 
 def create_world(m, matrix_size=10):
-    """Create a world object.
+    """ Create a world object.
     
     The world object keeps track of the positions of the particles
     and the protective domains during an eGFRD simulation.
@@ -221,6 +289,9 @@ def create_box(world, structure_type, center, size, one_sided=True):
                 a 3D vector defining the center of the box
             - size
                 a 3D vector defining the box extensions
+            - one_sided (optional, 'True' by default)
+                create a box with 'one sided' planes, i.e. particles
+                can will unbind only towards the interior of the box
     """
 
     # Assert that the center and size is ok

From 7aeec0a0c2b9aef52704733f0659fbca17edcf9b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 11:40:36 +0200
Subject: [PATCH 1397/1541] Some consistent renaming and cleanup

---
 egfrd.py    |  6 ++--
 gfrdbase.py | 83 +++++++++++++++++++++++++++++++++--------------------
 shells.py   |  8 +++---
 3 files changed, 59 insertions(+), 38 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 72853a4f..66675f99 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1330,7 +1330,7 @@ def conditional_swap(newposA, newposB):
                     # Make sure that the new positions lie within the region bounded by neighboring orthogonal
                     # planes to avoid particles leaking out of a box
                     # NOTE surface lists have format (surface, distance_to_surface_from_reactant_position)
-                    neighbor_surfaces = get_neighbor_surfaces(self.world, reactant_pos, reactant_structure.id, ignores=[])
+                    neighbor_surfaces = get_neighbor_structures(self.world, reactant_pos, reactant_structure.id, ignores=[])
 
                     # Code snippet to get surfaces that might bound the dissociation positions;
                     # not used at the moment...
@@ -1496,7 +1496,7 @@ def conditional_swap(newposA, newposB):
                 # First, for each neighboring plane, we check whether the new positions lie 
                 # on the same side of the plane as the reactant; if not, this trial will be rejected                
                 product_crossed_plane = False # by default everything is OK
-                neighbor_surfaces = get_neighbor_surfaces(self.world, reactant_pos, reactant_structure.id, ignores=[])
+                neighbor_surfaces = get_neighbor_structures(self.world, reactant_pos, reactant_structure.id, ignores=[])
                     # NOTE surface lists have format (surface, distance_to_surface_from_reactant_position)
                 for surface, surf_dist in neighbor_surfaces:
                 
@@ -1849,7 +1849,7 @@ def make_new_domain(self, single):
         # 1.0 Get neighboring domains and surfaces
         neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])        
         # Get also surfaces but only if the particle is in 3D
-        surface_distances = get_neighbor_surfaces(self.world, single_pos, single.structure.id, ignores=[])
+        surface_distances = get_neighbor_structures(self.world, single_pos, single.structure.id, ignores=[])
 
         # 2.3 We prefer to make NonInteractionSingles for efficiency.
         #     But if objects (Shells and surfaces) get close enough (closer than
diff --git a/gfrdbase.py b/gfrdbase.py
index 5244ec0c..9038a191 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -40,7 +40,7 @@
     'periodic_connect',
     'ParticleSimulatorBase',
     'get_all_surfaces',
-    'get_neighbor_surfaces',
+    'get_neighbor_structures',
     'get_closest_structure',
     'create_network_rules_wrapper',
     ]
@@ -84,7 +84,9 @@ def setup_logging():
 
 
 def p_free(r, t, D):
+    """ The free Gaussian propagator.
 
+    """
     Dt4 = D * t * 4.0
     Pi4Dt = numpy.pi * Dt4
     rsq = r * r
@@ -98,30 +100,30 @@ def p_free(r, t, D):
 
 def get_all_surfaces(world, pos, ignores=[]):
     """ Returns a list of all surfaces in the world, sorted by increasing distance.
-        The output format is (structure, distance from search position).
+        The output format is (surface, distance from search position).
         
         Arguments:
             - world
-                  the world that contains the structures
+                  the world that contains the surfaces
             - pos
                   the search position
             - ignores (optional)
-                  a list of structure IDs that will define structures that will be
+                  a list of structure IDs that will define surfaces that will be
                   ignored in the search        
     """
-    surface_distances = []
+    surfaces_distances = []
+
+    for surf in world.structures:
+        if isinstance(surf, _gfrd.Surface) and surf.id not in ignores:
 
-    for surface in world.structures:
-        if isinstance(surface, _gfrd.Surface) and surface.id not in ignores:
-            pos_transposed = \
-                world.cyclic_transpose(pos, surface.shape.position)
-            distance = world.distance(surface.shape, pos_transposed)
-            surface_distances.append((surface, distance))
+            pos_transposed = world.cyclic_transpose(pos, surf.shape.position)
+            distance = world.distance(surf.shape, pos_transposed)
+            surfaces_distances.append((surf, distance))
 
-    return sorted(surface_distances, key=lambda surface_and_dist: surface_and_dist[1])
+    return sorted(surfaces_distances, key=lambda surf_and_dist: surf_and_dist[1])
 
 
-def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[], structure_class=None):
+def get_neighbor_structures(world, pos, current_struct_id, ignores=[], structure_class=None):
     """ Returns a list of neighboring structures, optionally restricted to type 'structure_class',
         sorted by increasing distance from the search position.
         The output format is (structure, distance from search position).
@@ -136,7 +138,8 @@ def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[], structure_c
                   (this defines which other structures are 'visible' from that point)
             - ignores (optional)
                   a list of structure IDs that will define structures that will be
-                  ignored in the search
+                  ignored in the search; the world's default structure will be ignored
+                  by default
             - structure_class (optional)
                   restrict the search to a certain structure class; must be one of
                   CuboidalRegion, PlanarSurface, DiskSurface, CylindricalSurface, SphericalSurface
@@ -144,7 +147,7 @@ def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[], structure_c
     if ignores:
         ignore = ignores[0] # FIXME world.get_close_structures currently only supports one ignored structure
     else:
-        ignore = world.get_def_structure_id() # Is that a good convention?
+        ignore = world.get_def_structure_id()
 
     if structure_class != None:
         # The user has specified a restriction of the search to a particular geometric class
@@ -152,13 +155,15 @@ def get_neighbor_surfaces(world, pos, current_struct_id, ignores=[], structure_c
                 or structure_class==Disk Surface       or structure_class==CylindricalSurface  \
                 or structure_class==SphericalSurface                                           )
 
-        surface_distances = [(structure, distance) for ((id, structure), distance) in world.get_close_structures(pos, current_struct_id, ignore) \
-                                                                                                      if isinstance(structure, structure_class)]
+        structure_distances = [(structure, distance) for ((id, structure), distance) \
+                                  in world.get_close_structures(pos, current_struct_id, ignore) \
+                                  if isinstance(structure, structure_class)]
     else:
-        # Take into account all surface types
-        surface_distances = [(structure, distance) for ((id, structure), distance) in world.get_close_structures(pos, current_struct_id, ignore)]
+        # Take into account all structure types
+        structure_distances = [(structure, distance) for ((id, structure), distance) \
+                                  in world.get_close_structures(pos, current_struct_id, ignore)]
 
-    return sorted(surface_distances, key=lambda surface_and_dist: surface_and_dist[1])
+    return sorted(structure_distances, key=lambda struct_and_dist: struct_and_dist[1])
 
 
 def get_closest_structure(world, pos, current_struct_id, ignores=[], structure_class=None):
@@ -180,9 +185,10 @@ def get_closest_structure(world, pos, current_struct_id, ignores=[], structure_c
                   restrict the search to a certain structure class; must be one of
                   CuboidalRegion, PlanarSurface, CylindricalSurface, DiskSurface, SphericalSurface
     """
-    sorted_close_surfaces = get_neighbor_surfaces(self.world, pos, current_struct_id, ignores, structure_class)
+    sorted_close_structures = \
+            get_neighbor_structures(self.world, pos, current_struct_id, ignores, structure_class)
 
-    return sorted_close_surfaces[0]
+    return sorted_close_structures[0]
 
 
 def create_world(m, matrix_size=10):
@@ -264,6 +270,7 @@ def create_world(m, matrix_size=10):
     world.model = m
     return world
 
+
 def create_box(world, structure_type, center, size, one_sided=True):
     """ Creates a box of PlanarSurface sections and adds it to the world.
 
@@ -311,12 +318,18 @@ def create_box(world, structure_type, center, size, one_sided=True):
         create_planar_surface = model.create_double_sided_planar_surface
 
     # Create the planes and add them to the world                          
-    front  = create_planar_surface(sid, name+'_front', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id) 
-    back   = create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
-    left   = create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
-    right  = create_planar_surface(sid, name+'_right', [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
-    top    = create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
-    bottom = create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
+    front  = create_planar_surface(sid, name+'_front', [center[0] + size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], \
+                                      [0, 0, 1], [0, 1, 0], size[2], size[1], def_struct_id)
+    back   = create_planar_surface(sid, name+'_back',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], \
+                                      [0, 1, 0], [0, 0, 1], size[1], size[2], def_struct_id)
+    left   = create_planar_surface(sid, name+'_left',  [center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], \
+                                      [0, 0, 1], [1, 0, 0], size[2], size[0], def_struct_id)
+    right  = create_planar_surface(sid, name+'_right', [center[0] - size[0]/2, center[1] + size[1]/2, center[2] - size[2]/2], \
+                                      [1, 0, 0], [0, 0, 1], size[0], size[2], def_struct_id)
+    top    = create_planar_surface(sid, name+'_top',   [center[0] - size[0]/2, center[1] - size[1]/2, center[2] + size[2]/2], \
+                                      [0, 1, 0], [1, 0, 0], size[1], size[0], def_struct_id)
+    bottom = create_planar_surface(sid, name+'_bottom',[center[0] - size[0]/2, center[1] - size[1]/2, center[2] - size[2]/2], \
+                                      [1, 0, 0], [0, 1, 0], size[0], size[1], def_struct_id)
 
     world.add_structure(front)
     world.add_structure(back)
@@ -352,6 +365,7 @@ def create_box(world, structure_type, center, size, one_sided=True):
     # in case that the user wishes to operate on them separately
     return [front.id, back.id, left.id, right.id, top.id, bottom.id]
 
+
 def create_rod(world, cyl_structure_type, cap_structure_type, name, \
                position, radius, orientation, length, \
                parent_structure_id = None, \
@@ -438,7 +452,8 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, \
         parent_id = parent_structure_id
 
     # Create the cylinder of the rod
-    rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', position, radius, orientation, length, parent_id)
+    rod = model.create_cylindrical_surface(cyl_sid, name+'_cylinder', \
+                                                position, radius, orientation, length, parent_id)
     world.add_structure(rod) # This must happen directly here otherwise rod.id will be undefined
     
     # By default the parent structure of the caps is the rod:
@@ -454,16 +469,19 @@ def create_rod(world, cyl_structure_type, cap_structure_type, name, \
     # Create the caps
     if place_front_cap:
         front_cap_pos = [p[0]+l*o[0], p[1]+l*o[1], p[2]+l*o[2]]
-        front_cap = model.create_disk_surface(front_cap_sid, name+'_front_cap', front_cap_pos, radius, orientation, front_cap_parent_id)
+        front_cap = model.create_disk_surface(front_cap_sid, name+'_front_cap', front_cap_pos, \
+                                                  radius, orientation, front_cap_parent_id)
         world.add_structure(front_cap)
 
     if place_back_cap:
         back_cap_pos = position
-        back_cap = model.create_disk_surface(back_cap_sid, name+'_back_cap', back_cap_pos, radius, [-o[0],-o[1],-o[2]], back_cap_parent_id)
+        back_cap = model.create_disk_surface(back_cap_sid, name+'_back_cap', back_cap_pos, \
+                                                  radius, [-o[0],-o[1],-o[2]], back_cap_parent_id)
         world.add_structure(back_cap)
 
     return rod.id
 
+
 def periodic_connect(world, planar_surface):
     """ Makes connections between the opposite edges of a plane.
 
@@ -476,9 +494,11 @@ def periodic_connect(world, planar_surface):
     pass 
     # FIXME DOES NOT YET WORK CORRECTLY, THE STRUCTURE CONTAINER IS ASSUMING TRANSFER TO ADJACENT PLANES ONLY!
 
+
 def create_network_rules_wrapper(model):
     return _gfrd.NetworkRulesWrapper(model.network_rules)
 
+
 def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
     """Add n particles of a certain Species to the specified world.
 
@@ -569,6 +589,7 @@ def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
             if out_of_bounds:
                 log.info('\t%d-th particle rejected. Out of bounding box. I will keep trying.' % i)
 
+
 def place_particle(world, sid, position):
     """Place a particle of a certain Species at a specific position in 
     the specified world.
diff --git a/shells.py b/shells.py
index e06a5cd5..66d64e9f 100755
--- a/shells.py
+++ b/shells.py
@@ -18,7 +18,7 @@
 
 from utils import *
 from gfrdbase import (
-    get_neighbor_surfaces,
+    get_neighbor_structures,
     )
 
 __all__ = [
@@ -1645,7 +1645,7 @@ def get_neighbors(self, base_structure_id, ignore, ignores):
         radius = self.get_searchradius()
 
         neighbor_domains  = self.geometrycontainer.get_neighbor_domains(searchpoint, self.domains, ignore)
-        neighbor_surfaces = get_neighbor_surfaces(self.world, searchpoint, base_structure_id, ignores)
+        neighbor_surfaces = get_neighbor_structures(self.world, searchpoint, base_structure_id, ignores)
         return neighbor_domains, neighbor_surfaces
 
     def get_orientation_vector(self):
@@ -2134,7 +2134,7 @@ def set_structure_ignore_list(self):
 
             # Determine the distance to the closest cylinder
             # First get all close cylinders, then sort, then get the distance to the closest
-            close_structures = get_neighbor_surfaces(self.world, search_pos, self.structure.id, [])
+            close_structures = get_neighbor_structures(self.world, search_pos, self.structure.id, [])
             close_cylindrical_structures = [surface_and_dist for surface_and_dist in close_structures if isinstance(surface_and_dist[0], CylindricalSurface)]
 
             if close_cylindrical_structures != []:
@@ -2651,7 +2651,7 @@ def find_daughter_disk(self):
         # Determine the distance to the closest disk
         # First get all close disk surfaces, then sort, then get the distance to the closest
         search_pos = self.pid_particle_pair[1].position
-        close_surfaces      = get_neighbor_surfaces(self.world, search_pos, self.target_structure.id, [])        
+        close_surfaces      = get_neighbor_structures(self.world, search_pos, self.target_structure.id, [])        
         close_disk_surfaces = [surface_and_dist for surface_and_dist in close_surfaces if isinstance(surface_and_dist[0], DiskSurface)]
 
         found_good_disk = False

From 95bbb3c81232c7f971f89fc7865f688f6fe5fcdb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 11:58:52 +0200
Subject: [PATCH 1398/1541] Small fixes

---
 gfrdbase.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 9038a191..86c3fb31 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -149,10 +149,10 @@ def get_neighbor_structures(world, pos, current_struct_id, ignores=[], structure
     else:
         ignore = world.get_def_structure_id()
 
-    if structure_class != None:
+    if structure_class is not None:
         # The user has specified a restriction of the search to a particular geometric class
         assert(    structure_class==CuboidalRegion     or structure_class==PlanarSurface       \
-                or structure_class==Disk Surface       or structure_class==CylindricalSurface  \
+                or structure_class==DiskSurface        or structure_class==CylindricalSurface  \
                 or structure_class==SphericalSurface                                           )
 
         structure_distances = [(structure, distance) for ((id, structure), distance) \
@@ -186,9 +186,12 @@ def get_closest_structure(world, pos, current_struct_id, ignores=[], structure_c
                   CuboidalRegion, PlanarSurface, CylindricalSurface, DiskSurface, SphericalSurface
     """
     sorted_close_structures = \
-            get_neighbor_structures(self.world, pos, current_struct_id, ignores, structure_class)
+            get_neighbor_structures(world, pos, current_struct_id, ignores, structure_class)
 
-    return sorted_close_structures[0]
+    if sorted_close_structures != []:
+        return sorted_close_structures[0]
+    else:
+        return None
 
 
 def create_world(m, matrix_size=10):

From a051c8fd80c872cc5878ec66d13a150a186ac386 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 12:22:08 +0200
Subject: [PATCH 1399/1541] Use new search function to find daughter disk

---
 shells.py | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/shells.py b/shells.py
index 66d64e9f..7a8d4e0c 100755
--- a/shells.py
+++ b/shells.py
@@ -19,6 +19,7 @@
 from utils import *
 from gfrdbase import (
     get_neighbor_structures,
+    get_closest_structure,
     )
 
 __all__ = [
@@ -2649,22 +2650,15 @@ def get_orientation_vector(self):
     def find_daughter_disk(self):
 
         # Determine the distance to the closest disk
-        # First get all close disk surfaces, then sort, then get the distance to the closest
-        search_pos = self.pid_particle_pair[1].position
-        close_surfaces      = get_neighbor_structures(self.world, search_pos, self.target_structure.id, [])        
-        close_disk_surfaces = [surface_and_dist for surface_and_dist in close_surfaces if isinstance(surface_and_dist[0], DiskSurface)]
-
+        # First get the closest disk, then check whether it is actually at the interface between plane and cylinder.
+        search_pos      = self.pid_particle_pair[1].position        
         found_good_disk = False
 
-        if close_disk_surfaces != []:
-
-            # To be sure, sort the list again by increasing distance
-            sorted_close_disk_surfaces = sorted(close_disk_surfaces, key=lambda surface_and_dist : surface_and_dist[1])
-
-            # Get the closest disk and its properties
-            closest_disk      = sorted_close_disk_surfaces[0][0]
-            closest_disk_dist = sorted_close_disk_surfaces[0][1]            
+        closest_disk, closest_disk_dist = \
+                get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
 
+        if closest_disk is not None:
+                                    
             disk_parent_structure       = self.world.get_structure(closest_disk.structure_id)            
             distance_from_plane         = self.target_structure.project_point(closest_disk.shape.position)[1][0]
             distance_from_cylinder_axis = self.origin_structure.project_point(closest_disk.shape.position)[1][0]

From 954915055fdd614578680f045dbfae938d4153d2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 15:13:27 +0200
Subject: [PATCH 1400/1541] Make sure get_neighbor_surfaces does correctly
 filter out the structures on the ignore list

---
 gfrdbase.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 86c3fb31..5e23e8a5 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -145,7 +145,10 @@ def get_neighbor_structures(world, pos, current_struct_id, ignores=[], structure
                   CuboidalRegion, PlanarSurface, DiskSurface, CylindricalSurface, SphericalSurface
     """    
     if ignores:
-        ignore = ignores[0] # FIXME world.get_close_structures currently only supports one ignored structure
+        ignore = ignores[0]
+        # FIXME world.get_close_structures currently only supports one ignored structure (why?).
+        # In case that there is more than one ignored structure, we have to filter out 
+        # the ignored structures manually afterwards until this is fixed.
     else:
         ignore = world.get_def_structure_id()
 
@@ -163,7 +166,10 @@ def get_neighbor_structures(world, pos, current_struct_id, ignores=[], structure
         structure_distances = [(structure, distance) for ((id, structure), distance) \
                                   in world.get_close_structures(pos, current_struct_id, ignore)]
 
-    return sorted(structure_distances, key=lambda struct_and_dist: struct_and_dist[1])
+    # Filter out the ignored structures
+    filtered_structure_distances = filter(lambda (s, d) : s.id not in ignores, structure_distances)
+
+    return sorted(filtered_structure_distances, key=lambda struct_and_dist: struct_and_dist[1])
 
 
 def get_closest_structure(world, pos, current_struct_id, ignores=[], structure_class=None):

From d83d4bc3fff51dbead0971c57a7e12432551bff7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 15:20:25 +0200
Subject: [PATCH 1401/1541] Ignore closest cylinder and check whether it is
 located correctly when constructing Cyl.SufracePlanarSurfaceInterfaceSingle

Remember this is actually an Interaction!
---
 shells.py | 45 ++++++++++++++++++++++++++++++++++++++++-----
 single.py |  3 +--
 2 files changed, 41 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index 7a8d4e0c..31ac2f3f 100755
--- a/shells.py
+++ b/shells.py
@@ -1667,7 +1667,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # This determines the largest possible radius of the spherical testShell or throws an
         # exception if the domain could not be made due to geometrical constraints.
 
-        neighbor_domains, neighbor_surfaces = self.get_neighbors (base_structure_id, ignore, ignores)
+        neighbor_domains, neighbor_surfaces = self.get_neighbors(base_structure_id, ignore, ignores)
         min_radius = self.apply_safety(self.get_min_radius())
         max_radius = self.get_max_radius()
 
@@ -1833,8 +1833,9 @@ def __init__(self, geometrycontainer, domains):
     def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # This determines the maximum dr, dz_right, dz_left of the cylindrical testShell or
         # throws an exception if the domain could not be made due to geometrical constraints.
+                
+        neighbor_domains, neighbor_surfaces = self.get_neighbors(base_structure_id, ignore, ignores)
 
-        neighbor_domains, neighbor_surfaces = self.get_neighbors (base_structure_id, ignore, ignores)
         min_dr, min_dz_right, min_dz_left = self.get_min_dr_dzright_dzleft()
         max_dr, max_dz_right, max_dz_left = self.get_max_dr_dzright_dzleft()
 
@@ -2587,13 +2588,16 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         # In particular store the tangent, because math.tan is expensive!
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
         self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
-
+        
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        self.ignored_structure_ids = self.set_structure_ignore_list()
+        
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], \
+                                                                                    self.ignored_structure_ids)
         except ShellmakingError as e:
             raise testShellError('(CylindricalSurfaceCapInteraction). %s' % (str(e)) )
 
@@ -2624,6 +2628,10 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left
 
+    def set_structure_ignore_list(self):
+
+        return [self.target_structure.id]
+
 class CylindricalSurfacePlanarSurfaceInteractionSingletestShell(CylindricalSurfaceCapInteractiontestShell):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
@@ -2698,10 +2706,12 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         # We want to form this domain only when the particle just arrived onto the plane exiting from a perpendicular cylinder
         # Here we check in advance whether the particle is on the cylinder axis by projecting the difference vector between
         # particle position and cylinder midpoint onto the plane (the projection is zero if both lie on the cyl. axis)
+        assert isinstance(target_structure, DiskSurface)
+
         distance_from_center = target_structure.project_point(single.pid_particle_pair[1].position)[1][0]
         if not feq(distance_from_center, 0.0, typical=single.pid_particle_pair[1].radius):
 
-            raise testShellError(('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_axis))
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_axis)
 
         # If everything seems OK, we can proceed with creating the test shell
         CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
@@ -2736,6 +2746,31 @@ def get_max_dr_dzright_dzleft(self):
         dz_left  = dz_right
         return dr, dz_right, dz_left
 
+    def set_structure_ignore_list(self):
+
+        # In this special domain we want to ignore the (disk) target structure and the cylinder that
+        # is closest to it. Since we assume that the disk is capping the closest cylinder we double-check
+        # here whether this is actually the case.
+        disk_pos    = self.target_structure.shape.position
+        disk_radius = self.target_structure.shape.radius
+        search_pos  = disk_pos
+
+        closest_cyl, closest_cyl_dist = \
+                get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
+
+        disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
+        if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
+
+              raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Disk is not below closest cylinder, distance to axis = %s' \
+                                                                                                                % disk_to_cylinder_axis_distance)
+        if closest_cyl is not None:
+            ignore_list = [self.target_structure.id, closest_cyl.id]
+        else:
+            ignore_list = [self.target_structure.id]
+
+        log.debug('Setting structure_ignore_list = %s, target_structure=%s' % (ignore_list, self.target_structure) )
+        return ignore_list
+
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
diff --git a/single.py b/single.py
index 9589a26a..c1cf4792 100644
--- a/single.py
+++ b/single.py
@@ -1253,8 +1253,7 @@ def __str__(self):
         return 'CylindricalSurfacePlanarSurfaceInteraction ' + Single.__str__(self)
 
 class CylindricalSurfacePlanarSurfaceInterfaceSingle(CylindricalSurfaceCapInteraction):
-    """1 Particle inside a (cylindrical) shell at the interface of a
-       PlanarSurface and CylindricalSurface.
+    """1 Particle on a DiskSurface at the interface of a PlanarSurface and CylindricalSurface.
 
         * Particle coordinates on surface: z.
         * Domain: cartesian z.

From 5f168e1882c86cbf6ee278d13059c1498dc19219 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 15:21:51 +0200
Subject: [PATCH 1402/1541] Fix ignore lists in check_domain()

TODO This should be somehow unified with the ignore lists defined
by the shells one day.
---
 egfrd.py | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 66675f99..df60de96 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3045,31 +3045,43 @@ def check_domain(self, domain):
             # surfaces.
             ignores = [s.id for s in self.world.structures]
             associated = []
+
         elif isinstance(domain, SphericalSingle) or isinstance(domain, SphericalPair) or isinstance(domain, PlanarSurfaceSingle): # TODO Why not PlanarSurfacePair ?
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
             ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
-        elif isinstance(domain, DiskSurfaceSingle) or isinstance(domain, CylindricalSurfacePlanarSurfaceInterfaceSingle):
+
+        elif isinstance(domain, DiskSurfaceSingle):
             # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring/parent rods!
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
             associated = [domain.structure.id]
+
         elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle):
-            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now. TODO Only ignore relevant disks!
+            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now. TODO Only ignore closest disk
             ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
             associated = [domain.origin_structure.id, domain.target_structure.id]
+
+        elif isinstance(domain, CylindricalSurfacePlanarSurfaceInterfaceSingle):
+            # Ignore the planar surface and sub-disk that holds/will hold the particle, and the neighboring cylinder
+            ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
+            associated = [domain.origin_structure.id, domain.target_structure.id]
+
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D) or isinstance(domain, MixedPair1DStatic):
             # Ignore surface of the particle and interaction surface
             ignores = []
-            associated = [domain.origin_structure.id, domain.target_structure.id]        
+            associated = [domain.origin_structure.id, domain.target_structure.id]
+
         elif isinstance(domain, PlanarSurfacePair):
             # PlanarSurface domains sometimes are formed with a particle that just exited from a rod onto the plane.
             # In these cases, the rod shall be ignored.
             ignores = domain.ignored_structure_ids # this is a list already
             associated = [domain.structure.id]
+
         elif isinstance(domain, PlanarSurfaceTransitionSingle) or isinstance(domain, PlanarSurfaceTransitionPair):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.structure1.id, domain.structure2.id]
+
         else:
             # Ignore the structure that the particles are associated with
             ignores = []

From 3258cff8bac94cbd7e7ce663b847d9bc2c687b1f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 15:29:25 +0200
Subject: [PATCH 1403/1541] Clean up single_reaction behavior for
 Cyl.SurfacePlanarSurfaceInterfaceSingle

Now that the interface particle is located on a disk which is a substructure
of the plane the unbinding should not require any special treatment, but just
follow the same routine as for the cylinder and cylinder cap unbinding.
---
 egfrd.py  | 21 ++++-----------------
 single.py | 21 +++++----------------
 2 files changed, 9 insertions(+), 33 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index df60de96..77b95354 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1184,12 +1184,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         product_pos_list.append(vector)
 
                 elif isinstance(reactant_structure, DiskSurface):
-                    # unbinding in direction of disk unit vector
-                    #vector_length = 1.0*product_radius * MINIMAL_SEPARATION_FACTOR
-                    #vector        = reactant_pos + vector_length * reactant_structure.shape.unit_z
-                    #product_pos_list.append(vector)
-
-                    # unbinding perpendicularly to disk unit vector (i.e. like on cylinder)
+                    # The particle unbinds perpendicularly to disk unit vector (i.e. like on cylinder)
                     vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
                     for _ in range(self.dissociation_retry_moves):
                         unit_vector3D = random_unit_vector()
@@ -1207,17 +1202,9 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
 
             # If decay happens to same structure_type
             else:
-
-                # The following case has to be treated in a special way because particle "unbind" as if they came from a cylinder
-                # FIXME Make this more elegant; this whole method should be cleaned up and unified!
-                if isinstance(single, CylindricalSurfacePlanarSurfaceInterfaceSingle):
-                    product_pos, product_structure_id = single.draw_new_position(dt=0.0, event_type=EventType.SINGLE_REACTION)
-
-                else: # standard case
-                    product_pos = reactant_pos
-                    product_structure_id = reactant_structure_id
-
-                product_pos_list     = [product_pos]           # no change of position is required if structure_type doesn't change
+                
+                product_structure_id = reactant_structure_id
+                product_pos_list     = [reactant_pos]           # no change of position is required if structure_type doesn't change
 
 
             # 2. make space for the products (kinda brute force, but now we only have to burst once).
diff --git a/single.py b/single.py
index c1cf4792..fa93d8df 100644
--- a/single.py
+++ b/single.py
@@ -1292,25 +1292,14 @@ def iv_greens_function(self):
 
     def draw_new_position(self, dt, event_type):
 
-        if event_type == EventType.SINGLE_REACTION and len(self.reactionrule.products) == 1:
+        if event_type == EventType.SINGLE_REACTION or event_type == EventType.BURST:
 
-            # The particle does not move in this domain, but upon monomolecular reaction it is
-            # placed in contact with the cylinder that hits the plane, at a random angle.
-            # Since the origin structure (plane) does not change, we have to sample this position here.
-            x, y = random_vector2D( (self.target_structure.shape.radius + self.pid_particle_pair[1].radius) * MINIMAL_SEPARATION_FACTOR)
-            displacement = x * self.origin_structure.shape.unit_x + y * self.origin_structure.shape.unit_y
-            new_pos = self.pid_particle_pair[1].position + displacement
-
-            return new_pos, self.origin_structure.id
-
-        # TODO What if we have 2 products? Compare to DiskSurfaceSingle
-
-        elif event_type == EventType.BURST:
-
-            # When we burst it nothing happens to the particle
+            # The particle does not move within this domain, in particular when bursted
+            # The displacement created when unbinding from the disk is treated in
+            # fire_single_reaction() in egfrd.py
             new_pos = self.pid_particle_pair[1].position
 
-            return new_pos, self.origin_structure.id            
+            return new_pos, self.origin_structure.id
 
         else:
             raise Exception('Disallowed event type or wrong no. of products in CylindricalSurfacePlanarSurfaceInterfaceSingle.')

From d74bd799b219c1380e8ba014e32ecc941c96f5bf Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 15:45:02 +0200
Subject: [PATCH 1404/1541] Put MixedPair1DStatic on correct ignore list in
 check_domain()

---
 egfrd.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 77b95354..a790f6a6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3043,7 +3043,8 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
             associated = [domain.structure.id]
 
-        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle):
+        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle) \
+          or isinstance(domain, MixedPair1DStatic):
             # Ignore surface of the particle and interaction surface and all DiskSurfaces for now. TODO Only ignore closest disk
             ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
             associated = [domain.origin_structure.id, domain.target_structure.id]
@@ -3053,7 +3054,7 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
             associated = [domain.origin_structure.id, domain.target_structure.id]
 
-        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D) or isinstance(domain, MixedPair1DStatic):
+        elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
             ignores = []
             associated = [domain.origin_structure.id, domain.target_structure.id]

From 0fec13f92f6f4c0290aa2d0c06c7850899fe6d7d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 18:13:03 +0200
Subject: [PATCH 1405/1541] Revise domains for Cyl.Surface->PlanarSurface
 transfer

- Rename Cyl.SurfacePlanarSurfaceInterface -> Cyl.SurfacePlanarSurfaceIntermediate

- Newly defined Cyl.SurfacePlanarSurfaceInterfacetestShell, which now is actually
  derived from DiskSurfaceSingletestShell

- Modified DiskSurfaceSingletestShell and DiskSurfaceSingle to carry a custom
  structure ignore list

- Updated switchbox for creation of the modified domains in egfrd.py

- Updated make_new_domain() to deal with custom structure ignore list

- Updated ignore lists in check_domain()
---
 egfrd.py  | 33 ++++++++++++++++++++++++---------
 shells.py | 50 +++++++++++++++++++++++++++++++++++++++++++++-----
 single.py | 51 ++++++++++++++++++++++++++++++++++++++++-----------
 3 files changed, 109 insertions(+), 25 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index a790f6a6..b93bc41d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -58,6 +58,7 @@
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceCapInteractiontestShell,
     CylindricalSurfacePlanarSurfaceInteractionSingletestShell,
+    CylindricalSurfacePlanarSurfaceIntermediateSingletestShell,
     CylindricalSurfacePlanarSurfaceInterfaceSingletestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
@@ -88,7 +89,14 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
         return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
     elif isinstance(structure, DiskSurface):
         # first make the test shell
-        testSingle = DiskSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+        try:
+            testSingle = CylindricalSurfacePlanarSurfaceInterfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+        except testShellError as e:
+            if __debug__:
+                log.warn('Could not make CylindricalSurfacePlanarSurfaceInterfaceSingletestShell, %s' % str(e))
+            # making the default testShell should never fail
+            testSingle = DiskSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+
         return DiskSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
 
 ### Interactions
@@ -108,11 +116,11 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
                 pass # TODO TODO TODO Fix this
             except testShellError as e:
                 if __debug__:
-                    log.warn('Could not make CylindricalSurfacePlanarSurfaceInterfaceSingletestShell, %s; now trying PlanarSurfaceCylindricalSurfaceInteractiontestShell.' % str(e))
+                    log.warn('Could not make CylindricalSurfacePlanarSurfaceIntermediateSingletestShell, %s; now trying PlanarSurfaceCylindricalSurfaceInteractiontestShell.' % str(e))
                 return PlanarSurfaceCylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
                 # if both shells do not work in this situation the second try will result in raising another shellmaking exception       
         elif isinstance(target_structure, DiskSurface):
-            return CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (single, target_structure, geometrycontainer, domains)
+            return CylindricalSurfacePlanarSurfaceIntermediateSingletestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
@@ -136,8 +144,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell): # must be first because it is a special case of CylindricalSurfaceCapInteractiontestShell
         return CylindricalSurfacePlanarSurfaceInteractionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell): # this is actually not a regular interaction, but we need to put it here to ignore the target structure
-        return CylindricalSurfacePlanarSurfaceInterfaceSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell): # this is actually not a "real" interaction, but we need to put it here to ignore the target structure
+        return CylindricalSurfacePlanarSurfaceIntermediateSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
         return CylindricalSurfaceCapInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell):
@@ -1835,8 +1843,15 @@ def make_new_domain(self, single):
 
         # 1.0 Get neighboring domains and surfaces
         neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])        
-        # Get also surfaces but only if the particle is in 3D
-        surface_distances = get_neighbor_structures(self.world, single_pos, single.structure.id, ignores=[])
+        # Get also surfaces
+        # Some singles have an extended ignore list, which we have to figure out first
+        ignores = [] # by default
+        if isinstance(single, DiskSurfaceSingle):
+            ignores = single.ignored_structure_ids
+            if __debug__:
+                log.info('Extended structure ignore list when making %s, ignored IDs = %s' % (single, ignores))
+
+        surface_distances = get_neighbor_structures(self.world, single_pos, single.structure.id, ignores)
 
         # 2.3 We prefer to make NonInteractionSingles for efficiency.
         #     But if objects (Shells and surfaces) get close enough (closer than
@@ -3041,7 +3056,7 @@ def check_domain(self, domain):
         elif isinstance(domain, DiskSurfaceSingle):
             # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring/parent rods!
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
-            associated = [domain.structure.id]
+            associated = [domain.structure.id, domain.structure.structure_id] # the latter is the ID of the parent structure
 
         elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle) \
           or isinstance(domain, MixedPair1DStatic):
@@ -3049,7 +3064,7 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
             associated = [domain.origin_structure.id, domain.target_structure.id]
 
-        elif isinstance(domain, CylindricalSurfacePlanarSurfaceInterfaceSingle):
+        elif isinstance(domain, CylindricalSurfacePlanarSurfaceIntermediateSingle):
             # Ignore the planar surface and sub-disk that holds/will hold the particle, and the neighboring cylinder
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
             associated = [domain.origin_structure.id, domain.target_structure.id]
diff --git a/shells.py b/shells.py
index 31ac2f3f..6e0d26ab 100755
--- a/shells.py
+++ b/shells.py
@@ -52,6 +52,7 @@
     'CylindricalSurfaceInteractiontestShell',
     'CylindricalSurfaceCapInteractiontestShell',
     'CylindricalSurfacePlanarSurfaceInteractionSingletestShell',
+    'CylindricalSurfacePlanarSurfaceIntermediateSingletestShell',
     'CylindricalSurfacePlanarSurfaceInterfaceSingletestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
@@ -2278,6 +2279,8 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         self.dz_left  = self.pid_particle_pair[1].radius
         self.dr       = self.pid_particle_pair[1].radius
 
+        self.ignored_structure_ids = [] # may be overriden by some derived classes
+
     def get_orientation_vector(self):
         return self.structure.shape.unit_z
         # just copy from disk structure
@@ -2305,6 +2308,44 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left/SAFETY
 
+class CylindricalSurfacePlanarSurfaceInterfaceSingletestShell(DiskSurfaceSingletestShell):
+
+    # This is a special testShell class derived from DiskSurfaceSingletestShell for the situation
+    # in which a particle is located on a sub-disk of a plane at the interface between plane and cylinder.
+    # In particular we have to make sure here that it will ignore the cylinder.    
+    def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
+
+        DiskSurfaceSingletestShell.__init__(self, pid_particle_pair, structure, geometrycontainer, domains)
+        
+        self.ignored_structure_ids = self.set_structure_ignore_list()
+
+        # TODO Check whether this shell should have the same dimensions as DiskSurfaceSingletestShell
+        # or rather have revisited scaling functions
+
+    def set_structure_ignore_list(self):
+
+        # In this special domain we want to ignore the (disk) target structure and the cylinder that
+        # is closest to it. Since we assume that the disk is capping the closest cylinder we double-check
+        # here whether this is actually the case.
+        disk_pos    = self.structure.shape.position
+        disk_radius = self.structure.shape.radius
+        search_pos  = disk_pos
+
+        closest_cyl, closest_cyl_dist = \
+                get_closest_structure(self.world, search_pos, self.structure.id, [], structure_class=CylindricalSurface)
+
+        disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
+        if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
+
+              raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Disk is not below closest cylinder, distance to axis = %s' \
+                                                                                                                % disk_to_cylinder_axis_distance)
+        if closest_cyl is not None:
+            ignore_list = [closest_cyl.id]
+        else:
+            ignore_list = []
+
+        return ignore_list
+
 #####
 class CylindricalSurfacePairtestShell(CylindricaltestShell, testSimplePair):
 
@@ -2699,7 +2740,7 @@ def find_daughter_disk(self):
         else:
             raise testShellError('Could not find correct disk surface at the interface between cylinder and plane.')
 
-class CylindricalSurfacePlanarSurfaceInterfaceSingletestShell(CylindricalSurfaceCapInteractiontestShell):
+class CylindricalSurfacePlanarSurfaceIntermediateSingletestShell(CylindricalSurfaceCapInteractiontestShell):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
 
@@ -2711,7 +2752,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         distance_from_center = target_structure.project_point(single.pid_particle_pair[1].position)[1][0]
         if not feq(distance_from_center, 0.0, typical=single.pid_particle_pair[1].radius):
 
-            raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_axis)
+            raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_axis)
 
         # If everything seems OK, we can proceed with creating the test shell
         CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
@@ -2761,14 +2802,13 @@ def set_structure_ignore_list(self):
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
         if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
 
-              raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Disk is not below closest cylinder, distance to axis = %s' \
+              raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) Disk is not below closest cylinder, distance to axis = %s' \
                                                                                                                 % disk_to_cylinder_axis_distance)
         if closest_cyl is not None:
             ignore_list = [self.target_structure.id, closest_cyl.id]
         else:
             ignore_list = [self.target_structure.id]
-
-        log.debug('Setting structure_ignore_list = %s, target_structure=%s' % (ignore_list, self.target_structure) )
+        
         return ignore_list
 
 class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingle):
diff --git a/single.py b/single.py
index fa93d8df..bb03dde3 100644
--- a/single.py
+++ b/single.py
@@ -32,7 +32,7 @@
     'CylindricalSurfaceInteraction',
     'CylindricalSurfaceCapInteraction',
     'CylindricalSurfacePlanarSurfaceInteractionSingle',
-    'CylindricalSurfacePlanarSurfaceInterfaceSingle',
+    'CylindricalSurfacePlanarSurfaceIntermediateSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'PlanarSurfaceCylindricalSurfaceInteraction',
@@ -159,7 +159,7 @@ def check(self):
     def __str__(self):
         pid = self.pid_particle_pair[0]
         sid = self.pid_particle_pair[1].sid
-        name = self.world.model.get_species_type_by_id(sid)["name"]
+        name = self.testShell.world.model.get_species_type_by_id(sid)["name"]
         if name[0] != '(':
             name = '(' + name + ')'
         return 'Single[%s: %s, ST%s, %s]' % (self.domain_id, pid, name,
@@ -589,11 +589,12 @@ class DiskSurfaceSingle(NonInteractionSingle, hasCylindricalShell):
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules):
 
-        assert isinstance(testShell, DiskSurfaceSingletestShell) or \
-               isinstance(testShell,CylindricalSurfacePlanarSurfaceInterfaceSingletestShell)
+        assert isinstance(testShell, DiskSurfaceSingletestShell)
         hasCylindricalShell.__init__(self, testShell, domain_id)
         NonInteractionSingle.__init__(self, domain_id, shell_id, reactionrules)
 
+        self.ignored_structure_ids = self.testShell.ignored_structure_ids
+
     def get_inner_a(self):
         return self.pid_particle_pair[1].radius
 
@@ -637,7 +638,8 @@ def create_updated_shell(self, position):
         # TODO what should we do with the position now?
         # maybe update the reference_point of the shell before updating the shell
         try:
-            dr, dz_right, dz_left = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], [])
+            ignores = self.ignored_structure_ids
+            dr, dz_right, dz_left = self.testShell.determine_possible_shell(self.structure.id, [self.domain_id], ignores)
             dz_right = min(dz_right, dz_left)       # make sure the domain is symmetric around the particle
             dz_left  = dz_right                     # This is not necessary but it's assumed later
             center, radius, half_length = self.r_zright_zleft_to_r_center_hl(self.testShell.get_referencepoint(),
@@ -1252,7 +1254,7 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
     def __str__(self):
         return 'CylindricalSurfacePlanarSurfaceInteraction ' + Single.__str__(self)
 
-class CylindricalSurfacePlanarSurfaceInterfaceSingle(CylindricalSurfaceCapInteraction):
+class CylindricalSurfacePlanarSurfaceIntermediateSingle(CylindricalSurfaceCapInteraction):
     """1 Particle on a DiskSurface at the interface of a PlanarSurface and CylindricalSurface.
 
         * Particle coordinates on surface: z.
@@ -1262,7 +1264,7 @@ class CylindricalSurfacePlanarSurfaceInterfaceSingle(CylindricalSurfaceCapIntera
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
-        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell)
+        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell)
         CylindricalSurfaceCapInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
     def getv(self):
@@ -1278,10 +1280,9 @@ def get_inner_dz_right(self):
         pass
 
     def determine_next_event(self):
-        """Return an (event_time, event_type)-tuple.
-
-        """
-        return self.draw_reaction_time_tuple() # can only produce SINGLE_REACTION events
+        # For this special domain, we always return dt=0, imagining that the plane particle
+        # interacts instantly with the sub-disk
+        return 0.0, EventType.IV_INTERACTION
 
     def iv_greens_function(self):
 
@@ -1290,6 +1291,34 @@ def iv_greens_function(self):
         inner_half_length = self.pid_particle_pair[1].position
         return GreensFunction1DAbsAbs(0.0, 0.0, 0.0, -inner_half_length, inner_half_length)
 
+    def draw_new_position(self, dt, event_type):
+
+        # The particle does not move within this domain, but always ends up on the target structure
+        new_pos = self.pid_particle_pair[1].position
+
+        return new_pos, self.target_structure.id        
+
+    def __str__(self):
+        return 'CylindricalSurfacePlanarSurfaceIntermediate ' + Single.__str__(self)
+
+class CylindricalSurfacePlanarSurfaceInterfaceSingle(CylindricalSurfaceCapInteraction):
+    """1 Particle on a DiskSurface at the interface of a PlanarSurface and CylindricalSurface.
+
+        * Particle coordinates on surface: z.
+        * Domain: cartesian z.
+        * Initial position: z = 0.
+        * Selected randomly when drawing displacement vector: none.
+    """
+    # DEPRECATED!
+    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+
+        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell)
+        CylindricalSurfacePlanarSurfaceIntermediateSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+
+    def determine_next_event(self):
+        # Here we can actually have single reactions, so we want to draw them
+        return self.draw_reaction_time_tuple() # can only produce SINGLE_REACTION events
+    
     def draw_new_position(self, dt, event_type):
 
         if event_type == EventType.SINGLE_REACTION or event_type == EventType.BURST:

From b599b9b0e65f9fefbe178a531e7cf54ff14ef135 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 18:20:34 +0200
Subject: [PATCH 1406/1541] Some cleanup of deprecated stuff

---
 egfrd.py  |  1 -
 single.py | 34 ----------------------------------
 2 files changed, 35 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index b93bc41d..bc2dde3b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1906,7 +1906,6 @@ def make_new_domain(self, single):
 
             elif ( isinstance(obj, CylindricalSurface) or isinstance(obj, PlanarSurface) or isinstance(obj, DiskSurface) ):
                 # try making an Interaction
-                log.debug('testing obj = %s, pair_interaction_partners = %s' % (obj, pair_interaction_partners) ) # TODO remove after debugging
                 domain = self.try_interaction (single, obj)
 
 
diff --git a/single.py b/single.py
index bb03dde3..90c8c8f6 100644
--- a/single.py
+++ b/single.py
@@ -1301,40 +1301,6 @@ def draw_new_position(self, dt, event_type):
     def __str__(self):
         return 'CylindricalSurfacePlanarSurfaceIntermediate ' + Single.__str__(self)
 
-class CylindricalSurfacePlanarSurfaceInterfaceSingle(CylindricalSurfaceCapInteraction):
-    """1 Particle on a DiskSurface at the interface of a PlanarSurface and CylindricalSurface.
-
-        * Particle coordinates on surface: z.
-        * Domain: cartesian z.
-        * Initial position: z = 0.
-        * Selected randomly when drawing displacement vector: none.
-    """
-    # DEPRECATED!
-    def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
-
-        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInterfaceSingletestShell)
-        CylindricalSurfacePlanarSurfaceIntermediateSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
-
-    def determine_next_event(self):
-        # Here we can actually have single reactions, so we want to draw them
-        return self.draw_reaction_time_tuple() # can only produce SINGLE_REACTION events
-    
-    def draw_new_position(self, dt, event_type):
-
-        if event_type == EventType.SINGLE_REACTION or event_type == EventType.BURST:
-
-            # The particle does not move within this domain, in particular when bursted
-            # The displacement created when unbinding from the disk is treated in
-            # fire_single_reaction() in egfrd.py
-            new_pos = self.pid_particle_pair[1].position
-
-            return new_pos, self.origin_structure.id
-
-        else:
-            raise Exception('Disallowed event type or wrong no. of products in CylindricalSurfacePlanarSurfaceInterfaceSingle.')
-
-    def __str__(self):
-        return 'CylindricalSurfacePlanarSurfaceInterface ' + Single.__str__(self)
 
 class TransitionSingle(Single, TransitionTools, Others):
     """TransitionSingles are used when a particle changes from

From d959184b31b21cc185b616ac7c10d26518087e78 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 18:39:53 +0200
Subject: [PATCH 1407/1541] Fixes to make MixedPair1DStatic work with the new
 interface situation

---
 egfrd.py  | 21 +++++++++------------
 shells.py | 10 +++++++++-
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index bc2dde3b..624b51d5 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -188,10 +188,6 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
         return MixedPair1DStatictestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):
         return MixedPair1DStatictestShell(single2, single1, geometrycontainer, domains)
-    elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, PlanarSurface)):
-        return MixedPair1DStatictestShell(single1, single2, geometrycontainer, domains)
-    elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, PlanarSurface)):
-        return MixedPair1DStatictestShell(single2, single1, geometrycontainer, domains)
     else:
         # another mixed pair was supposed to be formed -> unsupported
         raise testShellError('(MixedPair). combination of structures not supported')
@@ -3053,20 +3049,21 @@ def check_domain(self, domain):
             associated = []
 
         elif isinstance(domain, DiskSurfaceSingle):
-            # Particles bound to DiskSurfaces ignore all rods for now. TODO Only ignore neighboring/parent rods!
-            ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)]
+            # Particles bound to DiskSurfaces ignore all rods for now.
+            ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
             associated = [domain.structure.id, domain.structure.structure_id] # the latter is the ID of the parent structure
 
-        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle) \
-          or isinstance(domain, MixedPair1DStatic):
-            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now. TODO Only ignore closest disk
-            ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)]
+        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle):
+            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
+            ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)] # TODO Only ignore closest disk
             associated = [domain.origin_structure.id, domain.target_structure.id]
 
-        elif isinstance(domain, CylindricalSurfacePlanarSurfaceIntermediateSingle):
+        elif isinstance(domain, CylindricalSurfacePlanarSurfaceIntermediateSingle) or isinstance(domain, MixedPair1DStatic):
             # Ignore the planar surface and sub-disk that holds/will hold the particle, and the neighboring cylinder
+            # Note that the plane is the parent structure of the disk, which in both cases is the target structure
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
-            associated = [domain.origin_structure.id, domain.target_structure.id]
+            associated = [domain.origin_structure.id, domain.target_structure.id, domain.target_structure.structure_id]
+                                                                                  # the latter is the ID of the parent structure
 
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
diff --git a/shells.py b/shells.py
index 6e0d26ab..3b8e9074 100755
--- a/shells.py
+++ b/shells.py
@@ -3141,9 +3141,11 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        self.ignored_structure_ids = self.set_structure_ignore_list()
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.structure1D.id, [self.single1D.domain_id, self.static_single.domain_id], [self.static_structure.id])
+                            self.determine_possible_shell(self.structure1D.id, [self.single1D.domain_id, self.static_single.domain_id], \
+                                                          self.ignored_structure_ids)
         except ShellmakingError as e:
             raise testShellError('(MixedPair1DStatic). %s' %
                                  (str(e)))
@@ -3200,5 +3202,11 @@ def get_min_pair_size(self):
 
         return shell_size
 
+    def set_structure_ignore_list(self):
+
+        # Ignore the structure of the static particle and its parent structure
+        # (important in forming the mixed pair with a DiskSurfaceSingle at the plane-cylinder interface)
+        return [self.static_structure.id, self.static_structure.structure_id]
+
 #####
 #class MixedPair3D1DtestShell(CylindricaltestShell, Others):

From 059cb80d3a763b3f5dabb109e74a7e079dbe1afd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 19:07:46 +0200
Subject: [PATCH 1408/1541] PlanarSurfaceCylindricalSurfaceInteraction ->
 PlanarSurfaceDiskSurfaceInteraction + some necessary changes to adapt to new
 way of Cylinder->Plane transfer

---
 egfrd.py  | 22 +++++++++++-----------
 shells.py | 50 ++++++++++++++++++++++++++++++++++++++++++--------
 single.py | 14 +++++++-------
 3 files changed, 60 insertions(+), 26 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 624b51d5..20493ca1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -54,7 +54,7 @@
     CylindricalSurfacePairtestShell,
     DiskSurfaceSingletestShell,
     PlanarSurfaceInteractiontestShell,
-    PlanarSurfaceCylindricalSurfaceInteractiontestShell,
+    PlanarSurfaceDiskSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceCapInteractiontestShell,
     CylindricalSurfacePlanarSurfaceInteractionSingletestShell,
@@ -110,17 +110,17 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
             raise testShellError('(Interaction). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
         if isinstance(target_structure, CylindricalSurface):
-            # here we have 2 possibilities; first we try the less probable one (special conditions apply that are checked
+            raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
+        elif isinstance(target_structure, DiskSurface):
+            # Here we have 2 possibilities; first we try the less probable one (special conditions apply that are checked
             # upon test shell construction), then the more common one.
             try:
-                pass # TODO TODO TODO Fix this
+                return CylindricalSurfacePlanarSurfaceIntermediateSingletestShell (single, target_structure, geometrycontainer, domains)
             except testShellError as e:
                 if __debug__:
-                    log.warn('Could not make CylindricalSurfacePlanarSurfaceIntermediateSingletestShell, %s; now trying PlanarSurfaceCylindricalSurfaceInteractiontestShell.' % str(e))
-                return PlanarSurfaceCylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
+                    log.warn('Could not make CylindricalSurfacePlanarSurfaceIntermediateSingletestShell, %s; now trying PlanarSurfaceDiskSurfaceInteractiontestShell.' % str(e))
+                return PlanarSurfaceDiskSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
                 # if both shells do not work in this situation the second try will result in raising another shellmaking exception       
-        elif isinstance(target_structure, DiskSurface):
-            return CylindricalSurfacePlanarSurfaceIntermediateSingletestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
@@ -136,8 +136,8 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
         raise testShellError('(Interaction). structure of particle was of invalid type')
 
 def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, interaction_rules):
-    if isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceInteractiontestShell
-        return PlanarSurfaceCylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    if isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceInteractiontestShell
+        return PlanarSurfaceDiskSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceInteractiontestShell):
         return CylindricalSurfaceInteraction    (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
@@ -1598,9 +1598,9 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
             product_species      = self.world.get_species(rr.products[0])
             product_radius       = product_species.radius
             # In some special domains that are formally an interaction the product actually stays
-            # behind on the origin structure (e.g. in the PlanarSurfaceCylindricalSurfaceInteraction,
+            # behind on the origin structure (e.g. in the PlanarSurfaceDiskSurfaceInteraction,
             # which is a plane particle interacting with a cylinder touching the plane).
-            # Therefore we have to make a distinction here. TODO FIXME this is not very elegant!
+            # Therefore we have to make a distinction here. TODO FIXME this is not very elegant, and probably DEPRECATED by now
             if single.product_structure:
                 product_structure    = single.product_structure # treating some special cases
                 target_structure     = single.target_structure
diff --git a/shells.py b/shells.py
index 3b8e9074..aade55af 100755
--- a/shells.py
+++ b/shells.py
@@ -44,7 +44,7 @@
     'PlanarSurfacePairtestShell',
     'PlanarSurfaceTransitionSingletestShell',
     'PlanarSurfaceTransitionPairtestShell',
-    'PlanarSurfaceCylindricalSurfaceInteractiontestShell',
+    'PlanarSurfaceDiskSurfaceInteractiontestShell',
     'CylindricalSurfaceSingletestShell',
     'DiskSurfaceSingletestShell',
     'CylindricalSurfacePairtestShell',
@@ -2078,7 +2078,6 @@ def __init__(self, single1, single2, geometrycontainer, domains):
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
         self.ignored_structure_ids = self.set_structure_ignore_list()
-
         try:
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.structure.id, [self.single1.domain_id, self.single2.domain_id],
@@ -2506,9 +2505,11 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
         # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
+        self.ignored_structure_ids = self.set_structure_ignore_list()
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], \
+                                                                                    self.ignored_structure_ids)
         except ShellmakingError as e:
             raise testShellError('(CylindricalSurfaceInteraction). %s' %
                                  (str(e)))
@@ -2542,11 +2543,16 @@ def get_max_dr_dzright_dzleft(self):
     def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, self.z_right(r/SAFETY)/SAFETY, self.z_left(r/SAFETY)/SAFETY
 
-class PlanarSurfaceCylindricalSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
+    def set_structure_ignore_list(self):
+
+        return [self.target_structure.id]
+
+class PlanarSurfaceDiskSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
 
     # This class is in essence the same as CylindricalSurfaceInteractiontestShell, but with
     # different shellscaling parameters. Therefore a new constructor has to be defined.
     def __init__(self, single, target_structure, geometrycontainer, domains):
+        assert isinstance(target_structure, DiskSurface)
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
         
@@ -2570,13 +2576,14 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
-        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!
-        # Note that here we know all structures that have to be ignored (origin and target structure).
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!        
+        self.ignored_structure_ids = self.set_structure_ignore_list()
         try:
             self.dr, self.dz_right, self.dz_left = \
-                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], \
+                                                                                    self.ignored_structure_ids)
         except ShellmakingError as e:
-            raise testShellError('(PlanarSurfaceCylindricalSurfaceInteraction). %s' %
+            raise testShellError('(PlanarSurfaceDiskSurfaceInteraction). %s' %
                                  (str(e)))
     
     def get_min_dr_dzright_dzleft(self):        
@@ -2594,6 +2601,33 @@ def get_max_dr_dzright_dzleft(self): # same as for PlanarSurfaceSingletestShell
         dr = dr_sr
         return dr, dz_right, dz_left
 
+    def set_structure_ignore_list(self):
+        # In this special domain we want to ignore the (disk) target structure and the cylinder that
+        # is closest to it. Since we assume that the disk is capping the closest cylinder we double-check
+        # here whether this is actually the case.
+        disk_pos    = self.target_structure.shape.position
+        disk_radius = self.target_structure.shape.radius
+        search_pos  = disk_pos
+
+        closest_cyl, closest_cyl_dist = \
+                get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
+
+        disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
+        if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
+
+              raise testShellError('(PlanarSurfaceDiskSurfaceInteraction) Disk is not below closest cylinder, distance to axis = %s' \
+                                                                                                                % disk_to_cylinder_axis_distance)
+              # TODO Maybe we do not want to keep this requirement
+
+        if closest_cyl is not None:
+            ignore_list = [self.target_structure.id, closest_cyl.id]
+        else:
+            ignore_list = [self.target_structure.id]
+        
+        return ignore_list
+        # NOTE copied from CylindricalSurfacePlanarSurfaceIntermediateSingle
+        
+
 class CylindricalSurfaceCapInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
diff --git a/single.py b/single.py
index 90c8c8f6..0c4d0ce7 100644
--- a/single.py
+++ b/single.py
@@ -35,7 +35,7 @@
     'CylindricalSurfacePlanarSurfaceIntermediateSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
-    'PlanarSurfaceCylindricalSurfaceInteraction',
+    'PlanarSurfaceDiskSurfaceInteraction',
     'TransitionSingle',
     'PlanarSurfaceTransitionSingle',
     ]
@@ -962,9 +962,9 @@ def __str__(self):
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))
 
-class PlanarSurfaceCylindricalSurfaceInteraction(CylindricalSurfaceInteraction):
-    """1 Particle on a PlanarSurface close to a CylindricalSurface, 
-       inside a cylindrical shell that surrounds the CylindricalSurface.
+class PlanarSurfaceDiskSurfaceInteraction(CylindricalSurfaceInteraction):
+    """1 Particle on a PlanarSurface close to a DiskSurface, 
+       inside a cylindrical shell that surrounds the DiskSurface.
 
         * Particle coordinates inside shell: r, theta, z.
         * Domains: composite r-theta, cartesian z.
@@ -977,12 +977,12 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # This domain is basically equivalent to CylindricalSurfaceInteraction. It uses
         # the same Green's function for binding, but the particle's z-coordinate does not
         # change here. Thus we have to modify draw_new_position() accordingly.
-        assert isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell)
+        assert isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell)
         # Initialize the parent class. This should be fine since the test shell also has
         # CylindricalSurfaceInteractiontestShell as a parent class.
         CylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
-        self.product_structure = self.origin_structure
+        self.product_structure = self.origin_structure # DEPRECATED rethink this
 
     def draw_escape_time_tuple(self):
         # This draws the time for escape in z-direction; since the particle in this domain
@@ -1034,7 +1034,7 @@ def draw_new_position(self, dt, event_type):
         return newpos, structure_id
 
     def __str__(self):
-        return ('PlanarSurfaceCylindricalSurfaceInteraction' + Single.__str__(self) + \
+        return ('PlanarSurfaceDiskSurfaceInteraction' + Single.__str__(self) + \
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))
 

From c71422f29af9461e09212405d0e35d317a443724 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 19:28:03 +0200
Subject: [PATCH 1409/1541] New testShell type MixedPair2DStatictestShell,
 which is for making a PlanarSurfacePair with a static particle on a (sub)disk

---
 egfrd.py  |  9 +++++++--
 shells.py | 38 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 20493ca1..631a6115 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -184,6 +184,10 @@ def try_default_testpair(single1, single2, geometrycontainer, domains):
         return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
         return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+    elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, DiskSurface)):
+        return MixedPair2DStatictestShell(single1, single2, geometrycontainer, domains)
+    elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, DiskSurface)):
+        return MixedPair2DStatictestShell(single2, single1, geometrycontainer, domains)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
         return MixedPair1DStatictestShell(single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):
@@ -207,6 +211,7 @@ def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
         return MixedPair2D3D               (domain_id, shell_id, testShell, reaction_rules)
     elif isinstance(testShell, MixedPair1DStatictestShell):
         return MixedPair1DStatic           (domain_id, shell_id, testShell, reaction_rules)
+    # NOTE MixedPair2DStatic does not exist, a regular PlanarSurfacePair works well in that case
 
 class Delegate(object):
     def __init__(self, obj, method, arg):
@@ -3071,8 +3076,8 @@ def check_domain(self, domain):
             associated = [domain.origin_structure.id, domain.target_structure.id]
 
         elif isinstance(domain, PlanarSurfacePair):
-            # PlanarSurface domains sometimes are formed with a particle that just exited from a rod onto the plane.
-            # In these cases, the rod shall be ignored.
+            # PlanarSurfacePair domains are also formed with a static particle located on a (sub-) disk of the plane
+            # In these cases, the disk and--if present--a cylinder next to it shall be ignored.
             ignores = domain.ignored_structure_ids # this is a list already
             associated = [domain.structure.id]
 
diff --git a/shells.py b/shells.py
index aade55af..fef82cab 100755
--- a/shells.py
+++ b/shells.py
@@ -2115,6 +2115,8 @@ def apply_safety(self, r, z_right, z_left):
 
     def set_structure_ignore_list(self):
 
+        # TODO this is DEPRECATED, rethink!
+
         ignored_structure_ids = [] # by default
 
         # The "interface pair", i.e. one of the particles is static (D=0) and located below
@@ -2158,6 +2160,42 @@ def set_structure_ignore_list(self):
 
         return ignored_structure_ids
 
+class MixedPair2DStatictestShell(PlanarSurfacePairtestShell):
+
+    def __init__(self, single2D, static_single, geometrycontainer, domains):
+
+        assert static_single.pid_particle_pair[1].D==0 and static_single.pid_particle_pair[1].v==0
+        PlanarSurfacePairtestShell(self, single1D, static_single, geometrycontainer, domains)
+
+        self.static_single = static_single
+        self.single2D      = single2D
+
+    def set_structure_ignore_list(self):
+        # In this special domain we want to ignore the (disk) structure and the cylinder that
+        # is closest to it. Since we assume that the disk is capping the closest cylinder we double-check
+        # here whether this is actually the case.
+        disk_pos    = self.static_single.structure.shape.position
+        disk_radius = self.static_single.structure.shape.radius
+        search_pos  = disk_pos
+
+        closest_cyl, closest_cyl_dist = \
+                get_closest_structure(self.world, search_pos, self.static_single.structure.id, [], structure_class=CylindricalSurface)
+
+        disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
+        if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
+
+              raise testShellError('(PlanarSurfaceDiskSurfaceInteraction) Disk is not below closest cylinder, distance to axis = %s' \
+                                                                                                                % disk_to_cylinder_axis_distance)
+              # TODO Maybe we do not want to keep this requirement
+
+        if closest_cyl is not None:
+            ignore_list = [self.static_single.structure.id, closest_cyl.id]
+        else:
+            ignore_list = [self.static_single.structure.id]
+        
+        return ignore_list
+        # NOTE copied from CylindricalSurfacePlanarSurfaceIntermediateSingle
+        
 ####
 class CylindricalSurfacePlanarSurfaceInterfacePairtestShell(PlanarSurfacePairtestShell):
 

From 01d7ce8d1a6268d03ed3e462297b6cb2e1070070 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 19 Sep 2013 19:56:08 +0200
Subject: [PATCH 1410/1541] Minor fixes

---
 egfrd.py  | 1 +
 shells.py | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 631a6115..74e8858d 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -62,6 +62,7 @@
     CylindricalSurfacePlanarSurfaceInterfaceSingletestShell,
     CylindricalSurfaceSinktestShell,
     MixedPair2D3DtestShell,
+    MixedPair2DStatictestShell,
     MixedPair1DStatictestShell,
     )
 
diff --git a/shells.py b/shells.py
index fef82cab..0c2320bc 100755
--- a/shells.py
+++ b/shells.py
@@ -56,6 +56,7 @@
     'CylindricalSurfacePlanarSurfaceInterfaceSingletestShell',
     'CylindricalSurfaceSinktestShell',
     'MixedPair2D3DtestShell',
+    'MixedPair2DStatictestShell',
     'MixedPair1DStatictestShell',
     ]
 
@@ -2165,7 +2166,7 @@ class MixedPair2DStatictestShell(PlanarSurfacePairtestShell):
     def __init__(self, single2D, static_single, geometrycontainer, domains):
 
         assert static_single.pid_particle_pair[1].D==0 and static_single.pid_particle_pair[1].v==0
-        PlanarSurfacePairtestShell(self, single1D, static_single, geometrycontainer, domains)
+        PlanarSurfacePairtestShell.__init__(self, single2D, static_single, geometrycontainer, domains)
 
         self.static_single = static_single
         self.single2D      = single2D

From 57c609bdece4c566c795fbfe77144e98c2c27052 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Sep 2013 10:47:04 +0200
Subject: [PATCH 1411/1541] Clean up test pair class definitions a bit

In particular introduce define an intermediate class testStandardPair
that holds all the standard methods but does not require particles to
live on the same structure.
---
 shells.py | 116 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 60 insertions(+), 56 deletions(-)

diff --git a/shells.py b/shells.py
index 0c2320bc..8137d782 100755
--- a/shells.py
+++ b/shells.py
@@ -242,7 +242,7 @@ class testPair(Others):
     def __init__(self, single1, single2):
         # Note: for the Others superclass nothing is to be initialized.
 
-        # assert both reset
+        # Assert both singles are reset
         assert single1.is_reset()
         assert single2.is_reset()
 
@@ -255,7 +255,7 @@ def __init__(self, single1, single2):
         self.structure1 = single1.structure
         self.structure2 = single2.structure
 
-        self.com, self.iv = self.do_transform()   # NOTE The IV always points from particle1 to particle2
+        self.com, self.iv = self.do_transform()  # NOTE The IV always points from particle1 to particle2
         self.r0 = length(self.iv)
         if self.r0 < self.sigma:
             raise protoDomainError('distance_from_sigma (pair gap) between %s and %s = %s < 0' % \
@@ -273,15 +273,15 @@ def get_D_R(self):
     D_R = property(get_D_R)
 
     def do_transform(self):
-        # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
+        # Transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
         pass        # overridden in subclasses
 
-class testSimplePair(testPair):
-
+class testStandardPair(testPair):
+    # Standard pairs are pairs of particles in 'standard' situations in which
+    # we can use the methods defined below. In certain special cases we have to
+    # override some of them. These test pair classes are defined further below.
     def __init__(self, single1, single2):
 
-        # Simple pairs are pairs of particles that are on the same structure
-        assert single1.structure == single2.structure
         testPair.__init__(self, single1, single2)
         self.structure = single1.structure # equal to self.structure1 and self.structure2,
                                            # needed by some class methods downstream
@@ -293,7 +293,7 @@ def get_sigma(self):
     sigma = property(get_sigma)
 
     def do_transform(self):
-        # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
+        # Transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
 
         pos1 = self.pid_particle_pair1[1].position
         pos2 = self.pid_particle_pair2[1].position
@@ -302,8 +302,8 @@ def do_transform(self):
 
         com = self.world.calculate_pair_CoM(pos1, pos2, D_1, D_2)
         com = self.world.apply_boundary(com)
-        # make sure that the com is in the structure of the particle (assume that this is done correctly in
-        # calculate_pair_CoM)
+        # Make sure that the com is in the structure of the particle
+        # (assume that this is done correctly in calculate_pair_CoM)
 
         pos2t = self.world.cyclic_transpose(pos2, pos1)
         iv = pos2t - pos1
@@ -312,7 +312,9 @@ def do_transform(self):
 
     def get_min_pair_size(self):
         # This calculates the minimal 'size' of a simple pair.
-        # Note that the 'size' is interpreted differently dependent on the type of pair. When the pair is a
+        # Note that the 'size' is interpreted differently dependent on the type of pair.
+        # When the pair is a
+        # 
         # SphericalPair          -> size = radius
         # PlanarSurfacePair      -> size = radius
         # CylindricalSurfacePair -> size = half_length
@@ -322,24 +324,32 @@ def get_min_pair_size(self):
         radius1 = self.pid_particle_pair1[1].radius
         radius2 = self.pid_particle_pair2[1].radius
 
-        dist_from_com1 = self.r0 * D_1 / self.D_tot      # particle distance from CoM
+        dist_from_com1 = self.r0 * D_1 / self.D_tot  # particle distance from CoM
         dist_from_com2 = self.r0 * D_2 / self.D_tot
-        iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
+        iv_shell_size1 = dist_from_com1 + radius1    # the shell should surround the particles
         iv_shell_size2 = dist_from_com2 + radius2
 
-        # also fix the minimum shellsize for the CoM domain
+        # Also fix the minimum shellsize for the CoM domain
         com_shell_size = max(radius1, radius2)
 
-        # calculate total radii including the margin for the burst volume for the particles
+        # Calculate total radii including the margin for the burst volume for the particles
         shell_size = max(iv_shell_size1 + com_shell_size + radius1 * SINGLE_SHELL_FACTOR,
                          iv_shell_size2 + com_shell_size + radius2 * SINGLE_SHELL_FACTOR)
 
         return shell_size
 
-class testMixedPair2D3D(testPair):
+class testSimplePair(testStandardPair):
 
-    def __init__(self, single2D, single3D):
+    def __init__(self, single1, single2):
+        # Simple pairs are pairs of particles that are on the same structure
+        # Here we check explicitly
+        assert single1.structure == single2.structure
+        testStandardPair.__init__(self, single1, single2)
 
+class testMixedPair2D3D(testPair):
+    # A pair formed between a 2D particle diffusing on a plane and a 3D particle 
+    # diffusing in the bulk. The class differs from testSimplePair in most of its methods.
+    def __init__(self, single2D, single3D):
         # First define for clarity:
         self.single2D = single2D
         self.single3D = single3D
@@ -356,8 +366,8 @@ def __init__(self, single2D, single3D):
                 assert isinstance(single2D.structure, PlanarSurface) 
                 assert isinstance(single3D.structure, CuboidalRegion)
         testPair.__init__(self, single2D, single3D)
-          # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
-          #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle              
+        # Note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 2D particle
+        #              and self.single2/self.pid_particle_pair2/self.structure2 for the 3D particle              
 
         assert self.single2D == self.single1           and self.single3D == self.single2
         assert self.ppp2D == self.pid_particle_pair1   and self.ppp3D == self.pid_particle_pair2
@@ -370,7 +380,7 @@ def __init__(self, single2D, single3D):
         self.target_structure = self.structure2D        
 
     def get_sigma(self):
-        # rescale sigma to correct for the rescaling of the coordinate system.
+        # Rescale sigma to correct for the rescaling of the coordinate system.
         # This is the sigma that is used for the evaluation of the Green's function and is in this case 
         # slightly different from the sums of the radii of the particles. We rescale sigma in a way
         # that the total flux over the reactive surface of the prolate spheroidal boundary with greater radius
@@ -398,17 +408,17 @@ def get_sigma(self):
     sigma = property(get_sigma)
 
     def do_transform(self):
-        # transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
+        # Transform the pos1 and pos2 of particles1 and 2 to the CoM and IV vectors
         pos2D = self.particle2D.position
         pos3D = self.particle3D.position
         D_2D  = self.particle2D.D
         D_3D  = self.particle3D.D
 
-        # CoM calculation
-        # the CoM is calculated in a similar way to a normal 3D pair
+        # CoM calculation:
+        # The CoM is calculated in a similar way to a normal 3D pair...
         com = self.world.calculate_pair_CoM(pos2D, pos3D, D_2D, D_3D)
 
-        # and then projected onto the plane to make sure the CoM is in the surface
+        # ...and then projected onto the plane to make sure the CoM is in the surface
         com = self.world.cyclic_transpose(com, self.structure2D.shape.position)
         com, (_, dist) = self.structure2D.project_point(com)
         if dist >= 0:
@@ -422,7 +432,7 @@ def do_transform(self):
         pos3D_t = self.world.cyclic_transpose(pos3D, pos2D)
         iv      = pos3D_t - pos2D
 
-        # rescale the iv in the axis normal to the plane
+        # Rescale the iv in the axis normal to the plane
         iv_z_component = numpy.dot (iv, self.structure2D.shape.unit_z)
         iv_z     = self.structure2D.shape.unit_z * iv_z_component
         new_iv_z = self.structure2D.shape.unit_z * (iv_z_component * self.get_scaling_factor())
@@ -432,31 +442,32 @@ def do_transform(self):
         return com, iv
 
     def get_scaling_factor(self):
-        # This returns the scaling factor needed to make the anisotropic diffusion problem of the IV
-        # into a isotropic one.
+        # This returns the scaling factor needed to make the anisotropic diffusion problem
+        # of the IV into an isotropic one.
         D_3D = self.particle3D.D    # 3D particle is the only contributor to diffusion
                                     # normal to the plane
         return math.sqrt(self.D_r/D_3D)
 
 class testMixedPair1DStatic(testPair):
-
+    # A pair formed between a particle moving in 1D on a rod and a static particle on a disk.
+    # The class differs from testSimplePair mainly by its do_transform() method.
     def __init__(self, single1D, static_single):
-
+        
         if __debug__: 
                 assert isinstance(single1D.structure, CylindricalSurface) 
-                assert isinstance(static_single.structure, DiskSurface) or isinstance(static_single.structure, PlanarSurface)
+                assert isinstance(static_single.structure, DiskSurface)
                 
         testPair.__init__(self, single1D, static_single)
-          # note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 1D particle
-          #              and self.single2/self.pid_particle_pair2/self.structure2 for the cap particle
-
-        # for clarity define:
-        self.single1D       = single1D
-        self.particle1D     = self.pid_particle_pair1[1]
-        self.structure1D    = single1D.structure    # equal to self.structure1  
-        self.static_single     = static_single
-        self.static_particle   = self.pid_particle_pair2[1]        
-        self.static_structure  = static_single.structure  # equal to self.structure2
+        # Note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 1D particle
+        #              and self.single2/self.pid_particle_pair2/self.structure2 for the cap particle
+
+        # For clarity define:
+        self.single1D         = single1D
+        self.particle1D       = self.pid_particle_pair1[1]
+        self.structure1D      = single1D.structure       # equal to self.structure1  
+        self.static_single    = static_single
+        self.static_particle  = self.pid_particle_pair2[1]        
+        self.static_structure = static_single.structure  # equal to self.structure2
         # This will be inherited by MixedPair1DStatictestShell and MixedPair1DStatic.
         # Note that we have to use pid_particle_pair1(2) in the methods defined below
         # because they are called at the initialization of testPair().
@@ -468,9 +479,8 @@ def __init__(self, single1D, static_single):
 
         # TODO Check whether particles are both on the cylinder axis
 
-        # If the static particle is on a disk, make sure that its position coincides
-        # with the disk position
-        if isinstance(self.static_structure, DiskSurface) and __debug__:
+        # Make sure that the static particle's position coincides with the disk position
+        if __debug__:
                 assert all(self.static_structure.shape.position - self.static_particle.position == 0.0)
 
     def get_sigma(self):
@@ -499,14 +509,13 @@ def do_transform(self):
         return com, iv
 
 class testPlanarSurfaceTransitionPair(testPair):
-
     # This is essentially a copy of testSimplePair; however, the latter does
     # not allow for particles being on different structures. Ergo we have to
     # define a new class for that purpose.
     # The main difference is in do_transform and get_min_pair_size which use
     # the CoM calculated after projection of single2 into the plane of single1
     # via deflect_back.
-
+    # FIXME Derive this class from testStandardPair, not testSimplePair
     def __init__(self, single1, single2):
 
         if __debug__: 
@@ -556,11 +565,7 @@ def do_transform(self):
         return com, iv
 
     def get_min_pair_size(self):
-        # This calculates the minimal 'size' of a simple pair.
-        # Note that the 'size' is interpreted differently dependent on the type of pair. When the pair is a
-        # SphericalPair          -> size = radius
-        # PlanarSurfacePair      -> size = radius
-        # CylindricalSurfacePair -> size = half_length
+        # This calculates the minimal 'size' of a simple pair.        
 
         # TODO: Make sure this also works correctly when IP-vectors are enlarged to remove
         # overlaps at deflection.
@@ -575,16 +580,15 @@ def get_min_pair_size(self):
         iv_shell_size1 = dist_from_com1 + radius1       # the shell should surround the particles
         iv_shell_size2 = dist_from_com2 + radius2
 
-        # also fix the minimum shellsize for the CoM domain
+        # Also fix the minimum shellsize for the CoM domain
         com_shell_size = max(radius1, radius2)
 
-        # calculate total radii including the margin for the burst volume for the particles
+        # Calculate total radii including the margin for the burst volume for the particles
         shell_size = max(iv_shell_size1 + com_shell_size + radius1 * SINGLE_SHELL_FACTOR,
                          iv_shell_size2 + com_shell_size + radius2 * SINGLE_SHELL_FACTOR)
 
         return shell_size
 
-
 ##################################
 # These classes define the geometric aspect of the existing domains. When making a domain, the domain
 # has a Shell (hence the hasShell class name).
@@ -2052,13 +2056,13 @@ def apply_safety(self, r, z_right, z_left):
         return r/SAFETY, z_right, z_left
 
 #####
-class PlanarSurfacePairtestShell(CylindricaltestShell, testSimplePair):
+class PlanarSurfacePairtestShell(CylindricaltestShell, testStandardPair):
 
     def __init__(self, single1, single2, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testSimplePair.__init__(self, single1, single2)
+        testStandardPair.__init__(self, single1, single2)
 
-        # initialize the scaling parameters
+        # Initialize the scaling parameters
         self.dzdr_right = 0.0
         self.drdz_right = numpy.inf
         self.r0_right   = 0.0

From d018b65e3717f01f40e0a370b1a126e52d6ad22b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Sep 2013 12:04:40 +0200
Subject: [PATCH 1412/1541] Change order of initialization in
 MixedPair1DStatictestShell

---
 shells.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 8137d782..69b06d77 100755
--- a/shells.py
+++ b/shells.py
@@ -2170,11 +2170,12 @@ class MixedPair2DStatictestShell(PlanarSurfacePairtestShell):
     def __init__(self, single2D, static_single, geometrycontainer, domains):
 
         assert static_single.pid_particle_pair[1].D==0 and static_single.pid_particle_pair[1].v==0
-        PlanarSurfacePairtestShell.__init__(self, single2D, static_single, geometrycontainer, domains)
 
         self.static_single = static_single
         self.single2D      = single2D
 
+        PlanarSurfacePairtestShell.__init__(self, single2D, static_single, geometrycontainer, domains)
+
     def set_structure_ignore_list(self):
         # In this special domain we want to ignore the (disk) structure and the cylinder that
         # is closest to it. Since we assume that the disk is capping the closest cylinder we double-check

From fe9fa13db60ac5869f0e884fe92229c2e96f2ecb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Sep 2013 12:04:56 +0200
Subject: [PATCH 1413/1541] Same class reorganization for the pair classes

---
 pair.py | 55 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 43 insertions(+), 12 deletions(-)

diff --git a/pair.py b/pair.py
index 00ff7c67..4af24d12 100644
--- a/pair.py
+++ b/pair.py
@@ -227,7 +227,7 @@ def __str__(self):
             name1, name2,
             self.shell)
 
-class SimplePair(Pair):
+class StandardPair(Pair):
 
     def __init__(self, domain_id, shell_id, rrs):
         # Calls required parent inits and sets variables.
@@ -251,11 +251,16 @@ def __init__(self, domain_id, shell_id, rrs):
 
     @ classmethod
     def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z, world):
-    # here we assume that the com and iv are really in the structure and no adjustments have to be
-    # made
-
-        # For simple pairs the particles live on the same structure
-        assert(structure1.id == structure2.id)
+    # Here we assume that the com and iv are really in the structure and no adjustments 
+    # have to be made
+
+        # Since this is meant to be a general class, we do not check explicitly whether the structures
+        # are really the same, but drop a warning if they are not (A possible situation where this matters
+        # is when one particle is on a substructure of the other particle's structure; then the structure IDs
+        # are different, but the calculations then still work perfectly fine).
+        if __debug__ and structure1.id != structure2.id:
+            log.warn('Particles live on different structures in StandardPair, structure1=%s, structure2=%s' \
+                                                                               % (structure1, structure2) )
         D_tot = D1 + D2
         pos1 = com - iv * (D1 / D_tot)
         pos2 = com + iv * (D2 / D_tot)
@@ -309,12 +314,12 @@ def determine_radii(self, r0, shell_size):
             radiusb = radius1
 
 
-        #aR
+        # aR
         a_R = (D_geom * (Db * (shell_size - radiusa) + \
                          Da * (shell_size - r0 - radiusa))) /\
               (Da * Da + Da * Db + D_geom * D_tot)
 
-        #ar
+        # ar
         a_r = (D_geom * r0 + D_tot * (shell_size - radiusa)) / (Da + D_geom)
 
 
@@ -354,6 +359,30 @@ def determine_radii(self, r0, shell_size):
     def __str__(self):
         pass
 
+class SimplePair(StandardPair):
+    # Same as StandardPair, but we check explicitly whether the particles live on the same structure
+    # in the transform function. This function is widely used, so be careful in making changes, and
+    # make sure to also make them in the parent class.
+    def __init__(self, domain_id, shell_id, rrs):
+
+        # Inits from parent classes 
+        StandardPair.__init__(self, domain_id, shell_id, rrs)
+
+    @ classmethod
+    def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, structure2, unit_z, world):
+    # Here we assume that the com and iv are really in the structure and no adjustments 
+    # have to be made
+
+        # For simple pairs the particles live on the same structure
+        # Check explicitly
+        assert(structure1.id == structure2.id)
+
+        D_tot = D1 + D2
+        pos1 = com - iv * (D1 / D_tot)
+        pos2 = com + iv * (D2 / D_tot)
+
+        return pos1, pos2, structure1.id, structure2.id
+
 class SphericalPair(SimplePair, hasSphericalShell):
     """2 Particles inside a (spherical) shell not on any surface.
 
@@ -459,10 +488,12 @@ def __str__(self):
         return 'Spherical' + Pair.__str__(self)
 
 
-class PlanarSurfacePair(SimplePair, hasCylindricalShell):
-    """2 Particles inside a (cylindrical) shell on a PlanarSurface. 
-    (Hockey pucks).
+class PlanarSurfacePair(StandardPair, hasCylindricalShell):
+    """ 2 Particles inside a (cylindrical) shell on a PlanarSurface. 
+        (Hockey pucks).
 
+        Note that in this class they are in principle allowed to 
+        live on different structures.
     """
     def __init__(self, domain_id, shell_id, testShell, rrs):
         # Calls required parent inits and sets variables.
@@ -474,7 +505,7 @@ def __init__(self, domain_id, shell_id, testShell, rrs):
         hasCylindricalShell.__init__(self, testShell, domain_id)        
         
         self.LD_MAX = 20 # Required by SimplePair.__init__
-        SimplePair.__init__(self, domain_id, shell_id, rrs)
+        StandardPair.__init__(self, domain_id, shell_id, rrs)
 
         self.ignored_structure_ids = testShell.ignored_structure_ids
 

From c841d026478356c5add0afebaaa9bb9a400d0f2b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Sep 2013 14:15:37 +0200
Subject: [PATCH 1414/1541] Extend Disk.project_point() method to the case in
 which the position is in the plane of the disk, not 'above' it

---
 Disk.hpp | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/Disk.hpp b/Disk.hpp
index 2fee12fb..1e786cfa 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -117,6 +117,9 @@ project_point(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
 // for the normal component (z) of 'pos' in the basis of the disk and the distance of the
 // projected point to the 'edge' of the disk. Here a positive number means the projected
 // point is outside the disk, and a negative numbers means it is 'inside' the disk.
+// As a special case, we calculate the projection differently for a position that is in 
+// the plane of the disk. Then we imagine that the particle is always 'above' the structure
+// and return -1 as a standard, instead of the distance to the disk center.
 {
     typedef typename Disk<T_>::length_type   length_type;
     typedef typename Disk<T_>::position_type position_type;
@@ -127,10 +130,24 @@ project_point(Disk<T_> const& obj, typename Disk<T_>::position_type const& pos)
     const length_type   z ( dot_product(pos_vector, obj.unit_z()) );
     const position_type r_vector (subtract(pos_vector, multiply(obj.unit_z(), z)));
     const length_type   r (length(r_vector));
-    assert(r >= 0.0 );
+    assert(r >= 0.0);
     
-    return std::make_pair( add(obj.position(), r_vector),
-                           std::make_pair(z, r - obj.radius()) );
+    // The quantities that will be return, with default values
+    // for the standard case (pos is not in plane of disk)
+    position_type proj_pos( add(obj.position(), r_vector) );
+    length_type   normal_comp( z );
+    length_type   dist_to_edge( r - obj.radius() );
+    
+    // Special case: pos is in the same plane as the disk
+    if( feq(z, 0.0, obj.radius()) ){ // third argument is typical scale
+     
+        proj_pos = obj.position(); // projected position = disk center
+        normal_comp = r;
+        dist_to_edge = -1.0;
+    }        
+    
+    return std::make_pair( proj_pos,
+                           std::make_pair(normal_comp, dist_to_edge) );
 }
 
 // The same as in case of the plane: project_point_on_surface = project_point

From 40ea20ac6732159692147815c64c2d1db3185546 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Sep 2013 15:24:11 +0200
Subject: [PATCH 1415/1541] Minor fixes

---
 egfrd.py  | 13 +++++++------
 shells.py |  4 ++--
 single.py |  2 +-
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 74e8858d..810897a1 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3059,18 +3059,19 @@ def check_domain(self, domain):
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
             associated = [domain.structure.id, domain.structure.structure_id] # the latter is the ID of the parent structure
 
-        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle):
-            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
-            ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)] # TODO Only ignore closest disk
-            associated = [domain.origin_structure.id, domain.target_structure.id]
-
-        elif isinstance(domain, CylindricalSurfacePlanarSurfaceIntermediateSingle) or isinstance(domain, MixedPair1DStatic):
+        elif isinstance(domain, CylindricalSurfacePlanarSurfaceIntermediateSingle) or isinstance(domain, MixedPair1DStatic) \
+          or isinstance(domain, PlanarSurfaceDiskSurfaceInteraction):
             # Ignore the planar surface and sub-disk that holds/will hold the particle, and the neighboring cylinder
             # Note that the plane is the parent structure of the disk, which in both cases is the target structure
             ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
             associated = [domain.origin_structure.id, domain.target_structure.id, domain.target_structure.structure_id]
                                                                                   # the latter is the ID of the parent structure
 
+        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle):
+            # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
+            ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)] # TODO Only ignore closest disk
+            associated = [domain.origin_structure.id, domain.target_structure.id]
+
         elif isinstance(domain, InteractionSingle) or isinstance(domain, MixedPair2D3D):
             # Ignore surface of the particle and interaction surface
             ignores = []
diff --git a/shells.py b/shells.py
index 69b06d77..dfc77356 100755
--- a/shells.py
+++ b/shells.py
@@ -2190,7 +2190,7 @@ def set_structure_ignore_list(self):
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
         if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
 
-              raise testShellError('(PlanarSurfaceDiskSurfaceInteraction) Disk is not below closest cylinder, distance to axis = %s' \
+              raise testShellError('(MixedPair2DStatic) Disk is not below closest cylinder, distance to axis = %s' \
                                                                                                                 % disk_to_cylinder_axis_distance)
               # TODO Maybe we do not want to keep this requirement
 
@@ -2830,7 +2830,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         distance_from_center = target_structure.project_point(single.pid_particle_pair[1].position)[1][0]
         if not feq(distance_from_center, 0.0, typical=single.pid_particle_pair[1].radius):
 
-            raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_axis)
+            raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_center)
 
         # If everything seems OK, we can proceed with creating the test shell
         CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
diff --git a/single.py b/single.py
index 0c4d0ce7..a898c191 100644
--- a/single.py
+++ b/single.py
@@ -982,7 +982,7 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # CylindricalSurfaceInteractiontestShell as a parent class.
         CylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
-        self.product_structure = self.origin_structure # DEPRECATED rethink this
+        self.product_structure = self.target_structure # DEPRECATED rethink this
 
     def draw_escape_time_tuple(self):
         # This draws the time for escape in z-direction; since the particle in this domain

From c115d7b17a10bfbb355cc4d4235b9ce449929a8e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 20 Sep 2013 17:59:02 +0200
Subject: [PATCH 1416/1541] Fix structure functions for Plane->Disk case

---
 StructureFunctions.hpp | 36 ++++++++++++++++++++++++++++--------
 1 file changed, 28 insertions(+), 8 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index d92a4515..e6004c12 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -606,9 +606,24 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
-
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Disk).");
+   
+    structure_id_type   new_id(    target_structure.id() );
+    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    length_type         proj_dist( target_structure.project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to the boundary of target_structure
+    
+    // Note that this function also correctly handles the pair reaction between a particle on a disk
+    // and a particle on a cylinder. Since we assume that the product will end up on the disk, new_pos
+    // (which is the projection of the center of mass of both particles on the disk) will be the
+    // correct product position.
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+                       // Note: Disk.project_point also returns a neg. value if the position is in one plane with the disk
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (Plane->Disk).");        
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -1177,11 +1192,16 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Disk/Plane).");
-    
-    return std::make_pair(      std::make_pair(position_type(), structure_id_type()),
-                                std::make_pair(position_type(), structure_id_type())    );
+    std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
+    // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
+    // the types of origin_structure and target_structure and the properties of the two product species
+    // (the displacements from old_pos are weighted by the diffusion constants).
+    // Here this works in the same way as for the corresponding function for Disk->Disk/CuboidalRegion;
+    // the first pair entry is the particle staying on the surface, the second entry the particle
+    // that goes onto the plane
+            
+    return std::make_pair(      std::make_pair(new_positions.first,  origin_structure.id()),
+                                std::make_pair(new_positions.second, target_structure.id())    );
 };
 
 /*****************************/

From 85d7f0f21440494b274c9d8ef4750b9c82297ba4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Sep 2013 15:12:04 +0200
Subject: [PATCH 1417/1541] Useful comments

---
 shells.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/shells.py b/shells.py
index dfc77356..ee6642e1 100755
--- a/shells.py
+++ b/shells.py
@@ -121,17 +121,19 @@ def __init__(self):
     # NOTE the two methods below have quite a different purpose!
     def shell_list_for_single(self):
         # In case the asker is also a NonInteractionSingle, the shell dimensions of the current domain
-        # is modified such that the domain is at least the size of the Multi shell.
+        # is "modified" such that the apparent domain is at least the size of the Multi shell.
+        # The modification is not applied to the current domain, instead a "fake shell" with the right
+        # dimensions is created which defines the apparent dimensions for the asker.
 
-        # NOTE: the Multi shell is spherical whereas the real shell of the NonInteractionSingle can
-        # be cylinderical. This method should therefore always return at the Multi shell.
+        # NOTE: the Multi shell is spherical whereas the real shell of the NonInteractionSingle can be cylinderical.
+        # This method should therefore always return the Multi shell.
         # In practice it will return the multi shell when the real shell fits inside the multi shell (typically when
         # the domain is just initialized), and will return the real shell when the domain exceeds the multi shell.
         # This means that there may not be space for the multi shell when the domain has non-null dimensions.
-        # This should be ok, because no multi will be directly made when the domain has non-null dimensions but
-        # will only be made after first bursting nearby domains.
+        # This should be ok, because no multi will be directly made when the domain has non-null dimensions,
+        # but will only be made after first bursting nearby domains.
 
-        pass    # needs to be specified in the subclass
+        pass    # needs to be specified in the subclasses
 
 
     def shell_list_for_other(self):
@@ -145,7 +147,7 @@ def shell_list_for_other(self):
         # This means that more bursting will take place than necessary because cylindrical domains do not keep the 
         # domains that are out of the 'diffusion dimension' at the proper distance -> TODO
 
-        pass    # needs to be specified in the subclass
+        pass    # needs to be specified in the subclasses
 
 
     # The next method is only relevant for TESTSHELL subclasses that derive from this class.

From 6a3f533cd24fe0fa25fcd7cb976dbe5bd7d34ba5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 24 Sep 2013 15:12:14 +0200
Subject: [PATCH 1418/1541] Fixes in fire_single_reaction() and
 make_new_domain()

In particular product particles are not required to end up in the bulk,
but also may go to the parent structure.

Also we replace a couple of hard-coded asserts by warnings.

Most important change: If update_single() fails we make a Multi.

This pertains to the situation in which a particle exits close to a
zero-DiskSingle. In that case the DiskSingle shell is wrapped by a
fake shell of the size of the corresponding Multi shell, but if the
single that is to be updated is smaller it will not burst the cylindrical
DiskSingle domain. Then update_single() will fail and we need a fallback.

This is certainly not the most elegant solution, but it works for now.
On the long term we should revise make_new_domain(), fire_single_reaction(),
etc. completely.
---
 egfrd.py | 69 ++++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 47 insertions(+), 22 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 810897a1..740867ca 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1132,6 +1132,10 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
         # Get reaction rule
         rr = single.reactionrule
 
+        # Some abbreviations used below
+        def_sid = self.world.get_def_structure_type_id()
+        parent_sid = reactant_structure_parent_structure.sid
+
         # The zero_singles are the NonInteractionSingles that are the total result of the recursive
         # bursting process.
         zero_singles = []
@@ -1165,8 +1169,16 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             # 1.5 get new position and structure_id of particle
             # If the particle falls off a surface (other than CuboidalRegion)
             if product_structure_type_id != reactant_structure_type_id:
-                assert (product_structure_type_id == self.world.get_def_structure_type_id()  \
-                     or product_structure_type_id == reactant_structure_parent_structure.sid )
+
+                # Figure out where the product goes. Only default structure or parent structure allowed.
+                if product_structure_type_id == def_sid:
+                    product_structure_id = self.world.get_def_structure_id()    # the default structure
+
+                elif product_structure_type_id == parent_sid:
+                    product_structure_id = reactant_structure.structure_id      # the parent structure
+
+                else:
+                    raise RuntimeError('fire_single_reaction: Product structure must be default structure or parent structure of reactant structure.')
 
                 # produce a number of new possible positions for the product particle
                 # TODO make these generators for efficiency
@@ -1207,8 +1219,6 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     # cannot decay from 3D to other structure
                     raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
 
-                #product_structure_id = self.world.get_def_structure_id()    # product structure is always the default structure (bulk)
-                product_structure_id = reactant_structure.structure_id    # product structure is always the parent structure; in most cases this is the bulk
 
             # If decay happens to same structure_type
             else:
@@ -1271,40 +1281,46 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
             product2_radius             = product2_species.radius
             D1 = product1_species.D
             D2 = product2_species.D
-            particle_radius12           = product1_radius + product2_radius
+            particle_radius12           = product1_radius + product2_radius            
 
 
             # 1.5 Get new positions and structure_ids of particles
             # FIXME     This should be made more elegant, using as much as possible the
             #           structure functions from the BD mode.
-            #     If one of the particle is not on the surface of the reactant.
+            # If one of the particle is not on the surface of the reactant.
             if product1_structure_type_id != product2_structure_type_id:
-                # Make sure that the reactant was on a 2D or 1D surface
-                assert reactant_structure_type_id != self.world.get_def_structure_type_id()
-                # Make sure that only either one of the target structures is the 3D ('^' is exclusive-OR)
-                assert ((product1_structure_type_id == self.world.get_def_structure_type_id()) ^ \
-                        (product2_structure_type_id == self.world.get_def_structure_type_id()))
+                # Make sure that the reactant was on a surface, not in the bulk
+                if reactant_structure_type_id != def_sid:
+                    log.warn('Reactant structure is default structure, but products do not end up in bulk. Something seems wrong!')
 
-                # Figure out which product stays in the surface and which one goes to 3D # FIXME It rather should go to the parent structure!
+                # Figure out which product stays in the surface and which one goes to the bulk or parent structure
                 # Note that A is a particle in the surface and B is in the 3D
-                if (product2_structure_type_id == self.world.get_def_structure_type_id()):
-                    # product2 goes to 3D and is now particleB (product1 is particleA and is on the surface)
+                if product2_structure_type_id == def_sid or product2_structure_type_id == parent_sid:
+                    # product2 goes to bulk or parent structure and is now particleB (product1 is particleA and is on the surface)
                     product1_structure_id = reactant_structure_id # TODO after the displacement the structure can change!
-                    product2_structure_id = reactant_structure.structure_id     # the parent structure
+                    if product2_structure_type_id == def_sid:
+                        product2_structure_id = self.world.get_def_structure_id()   # the parent structure
+                    else:
+                        product2_structure_id = reactant_structure.structure_id     # the parent structure
                     productA_radius = product1_radius
                     productB_radius = product2_radius
                     DA = D1
                     DB = D2
                     default = True      # we like to think of this as the default
-                else:
+                elif product1_structure_type_id == def_sid or product1_structure_type_id == parent_sid:
                     # product1 goes to 3D and is now particleB (product2 is particleA)
                     product2_structure_id = reactant_structure_id
-                    product1_structure_id = reactant_structure.structure_id     # the parent structure
+                    if product1_structure_type_id == def_sid:
+                        product1_structure_id = self.world.get_def_structure_id()   # the parent structure
+                    else:
+                        product1_structure_id = reactant_structure.structure_id     # the parent structure
                     productA_radius = product2_radius
                     productB_radius = product1_radius
                     DA = D2
                     DB = D1
                     default = False
+                else:
+                    raise RuntimeError('fire_single_reaction: One product particle must go to the default structure or parent structure of reactant structure.')
 
                 # We have to readjust this again in the end, when creating product positions, etc.
                 # This is handled by the following function.
@@ -1925,6 +1941,7 @@ def make_new_domain(self, single):
                     multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * MULTI_SHELL_FACTOR
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
                     multi_partners.append((domain, distance - multi_horizon))
+                    log.debug('domain = %s, multi_horizon = %s' % (domain, multi_horizon))
 
                 elif isinstance(domain, Multi):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle
@@ -1954,19 +1971,27 @@ def make_new_domain(self, single):
                 multi_partners = sorted(multi_partners, key=lambda domain_overlap: domain_overlap[1])
                 #log.debug('multi_partners: %s' % str(multi_partners))
                 closest_overlap = multi_partners[0][1]
+                log.debug('multi_partners = %s' % str(multi_partners))
             else:
                 # In case there is really nothing
                 closest_overlap = numpy.inf
 
             if __debug__:
-                log.debug('Single or Multi: closest_overlap: %s' % (FORMAT_DOUBLE % closest_overlap))
+                log.debug('Single or Multi: closest_overlap = %s' % (FORMAT_DOUBLE % closest_overlap))
+                if closest_overlap < numpy.inf:
+                    log.debug('Overlap partner = %s' % str(multi_partners[0][0]))
 
             # If the closest partner is within the multi horizon we do Multi, otherwise Single
             if closest_overlap > 0.0 and not self.BD_ONLY_FLAG : 
-                # just make a normal NonInteractionSingle
-                self.update_single(single)
-                bin_domain = single
-
+                try:
+                    # just make a normal NonInteractionSingle
+                    self.update_single(single)
+                    bin_domain = single
+                except:
+                    # if single update fails, make a multi an warn
+                    log.warn('Single update failed, making a Multi domain instead. Single = %s, multi_partners = %s')
+                    domain = self.form_multi(single, multi_partners)
+                    bin_domain = domain
             else:
                 # An object was closer than the Multi horizon
                 # Form a multi with everything that is in the multi_horizon

From 489d3a089e0f1ea58a292752f750c244510f2abd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Sep 2013 12:27:28 +0200
Subject: [PATCH 1419/1541] New exception 'ShellUpdateError' to be able to
 catch it specifically

---
 single.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/single.py b/single.py
index a898c191..eaad0d83 100644
--- a/single.py
+++ b/single.py
@@ -22,6 +22,7 @@
 from shells import *
 
 __all__ = [
+    'ShellUpdateError',
     'CylindricalSurfaceSingle',
     'DiskSurfaceSingle',
     'PlanarSurfaceSingle',
@@ -44,6 +45,12 @@
 log = logging.getLogger('ecell')
 
 
+class ShellUpdateError(Exception):
+    # The ShellUpdateError is raised when a domain (typically a Single)
+    # could not be updated although that was excpected in the given situation.
+    pass
+
+
 class Single(ProtectiveDomain):
     """There are 2 main types of Singles:
         * NonInteractionSingle
@@ -325,7 +332,7 @@ def create_updated_shell(self, position):
             return self.create_new_shell(position, radius, self.domain_id)
 
         except ShellmakingError as e:
-            raise Exception('SphericalSingle, create_updated_shell failed: %s' %
+            raise ShellUpdateError('SphericalSingle, create_updated_shell failed: %s' %
                             (str(e)))
 
     def create_position_vector(self, r):
@@ -414,7 +421,7 @@ def create_updated_shell(self, position):
             
             return self.create_new_shell(center, radius, half_length, self.domain_id)
         except ShellmakingError as e:
-            raise Exception('PlanarSurfaceSingle, create_updated_shell failed: %s' % str(e) )
+            raise ShellUpdateError('PlanarSurfaceSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, r):
         # project the vector onto the surface unit vectors to make sure that the coordinates are in the surface
@@ -523,7 +530,7 @@ def create_updated_shell(self, position):
                                                                              dr, dz_right, dz_left)
             return self.create_new_shell(center, radius, half_length, self.domain_id)
         except ShellmakingError as e:
-            raise Exception('CylindricalSurfaceSingle, create_updated_shell failed: %s' % str(e) )
+            raise ShellUpdateError('CylindricalSurfaceSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, z):
         # 'z' can be interpreted in two different ways here, it may a coordinate in the z direction or it may
@@ -647,7 +654,7 @@ def create_updated_shell(self, position):
                                                                              dr, dz_right, dz_left)
             return self.create_new_shell(center, radius, half_length, self.domain_id)
         except ShellmakingError as e:
-            raise Exception('DiskSurfaceSingle, create_updated_shell failed: %s' % str(e) )
+            raise ShellUpdateError('DiskSurfaceSingle, create_updated_shell failed: %s' % str(e) )
 
     def create_position_vector(self, z):
         # Particles on DiskStructures are immobile; always keep them in the center of the structure

From 56c1fbcb8e8d75eeb0e5631a7c3028e4bc42fdd9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Sep 2013 14:04:44 +0200
Subject: [PATCH 1420/1541] Only add new single to the scheduler after all
 checks have been made

---
 egfrd.py | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 740867ca..4b0fb9bf 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -4,6 +4,7 @@
 from weakref import ref
 import math
 import numpy
+import sys
 
 from _gfrd import (
     Event,
@@ -1971,7 +1972,6 @@ def make_new_domain(self, single):
                 multi_partners = sorted(multi_partners, key=lambda domain_overlap: domain_overlap[1])
                 #log.debug('multi_partners: %s' % str(multi_partners))
                 closest_overlap = multi_partners[0][1]
-                log.debug('multi_partners = %s' % str(multi_partners))
             else:
                 # In case there is really nothing
                 closest_overlap = numpy.inf
@@ -1984,12 +1984,15 @@ def make_new_domain(self, single):
             # If the closest partner is within the multi horizon we do Multi, otherwise Single
             if closest_overlap > 0.0 and not self.BD_ONLY_FLAG : 
                 try:
-                    # just make a normal NonInteractionSingle
+                    # Just make a normal NonInteractionSingle
                     self.update_single(single)
                     bin_domain = single
-                except:
-                    # if single update fails, make a multi an warn
-                    log.warn('Single update failed, making a Multi domain instead. Single = %s, multi_partners = %s')
+
+                except Exception as e:
+                    # If in rare cases the single update fails, make at least a Multi and warn
+                    # Note that this case is supposed to occur extremely rarely, and that it means sth. is not quite working well.
+                    log.warn('Single update failed, exception: %s / %s' % (str(e), str(sys.exc_info()) ) )
+                    log.warn('Single update: creating a Multi domain instead. Single = %s, multi_partners = %s' % (single, multi_partners))
                     domain = self.form_multi(single, multi_partners)
                     bin_domain = domain
             else:
@@ -2067,9 +2070,11 @@ def update_single(self, single):
         singlepos = single.pid_particle_pair[1].position    # TODO get the position as an argument
 
 
-        # create a new updated shell
+        # Create a new updated shell
+        # If this does not work for some reason an exception is risen;
+        # then make_new_domain() will make a Multi as a default fallback
         new_shell = single.create_updated_shell(singlepos)
-        assert new_shell, 'single.create_updated_shell() returned None.'
+        assert new_shell, 'Method single.create_updated_shell() returned None.'
 
         # Replace shell in domain and geometrycontainer.
         # Note: this should be done before determine_next_event.
@@ -2088,12 +2093,17 @@ def update_single(self, single):
 
         single.last_time = self.t
 
-        # add to scheduler
-        self.add_domain_event(single)
-        # check everything is ok
+        # Check whether everything is OK
         if __debug__:
             assert self.check_domain(single)
 
+        # Add to scheduler
+        # Make sure this is really at the end of the process, i.e. that we only 
+        # get here if no exceptions have been risen. If exceptions will be
+        # produced after adding the (erroneous) single to the scheduler we will
+        # have a zombie domain in it and break the whole scheduler queue!
+        self.add_domain_event(single)
+
         return single
 
 

From c5877202da2161ec2bdd8797b2389f1d264f31ee Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 25 Sep 2013 14:36:18 +0200
Subject: [PATCH 1421/1541] Replacement '!= None' -> 'is not None'

This is better Python style.
---
 loadsave.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index 78977c01..dafba738 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -580,7 +580,7 @@ def load_state(filename):
         rule = None
         if rtype == 'decay':
 
-            assert len(reactant_ids) == 1 and reactant_ids[0] != None and \
+            assert len(reactant_ids) == 1 and reactant_ids[0] is not None and \
                    len(product_ids)  == 0, \
                      'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
 
@@ -592,8 +592,8 @@ def load_state(filename):
 
         elif rtype == 'unimolecular':
 
-            assert len(reactant_ids) == 1 and reactant_ids[0] != None and \
-                   len(product_ids)  == 1 and product_ids[0]  != None, \
+            assert len(reactant_ids) == 1 and reactant_ids[0] is not None and \
+                   len(product_ids)  == 1 and product_ids[0]  is not None, \
                      'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
 
             # Get the involved species
@@ -605,8 +605,8 @@ def load_state(filename):
 
         elif rtype == 'unbinding':
 
-            assert len(reactant_ids) == 1 and reactant_ids[0] != None and \
-                   product_ids[0] != None and product_ids[1]  != None, \
+            assert len(reactant_ids) == 1     and reactant_ids[0] is not None and \
+                   product_ids[0] is not None and product_ids[1]  is not None, \
                      'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
 
             # Get the involved species
@@ -619,8 +619,8 @@ def load_state(filename):
 
         elif rtype == 'binding_particle':
             
-            assert reactant_ids[0] != None and reactant_ids[1] != None and \
-                   len(product_ids) == 1   and product_ids[0]  != None, \
+            assert reactant_ids[0] is not None and reactant_ids[1] is not None and \
+                   len(product_ids) == 1       and product_ids[0]  is not None, \
                      'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
 
             # Get the involved species
@@ -633,8 +633,8 @@ def load_state(filename):
 
         elif rtype == 'binding_surface':
             
-            assert reactant_ids[0] != None and reactant_ids[1] != None and \
-                   len(product_ids) == 1   and product_ids[0]  != None, \
+            assert reactant_ids[0] is not None and reactant_ids[1] is not None and \
+                   len(product_ids) == 1       and product_ids[0]  is not None, \
                      'Saved reaction rule does not have the proper signature: rule = %s' % sectionname
 
             # Get the involved species

From 875e19185945a7102cec213bc01ac1c7960e420f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Sep 2013 15:22:33 +0200
Subject: [PATCH 1422/1541] New method dof() which returns degrees of freedom
 for particle movement for different geometric objects (Box, Plane, Cyl.,
 Disk, Sphere)

---
 Box.hpp      | 5 +++++
 Cylinder.hpp | 5 +++++
 Disk.hpp     | 5 +++++
 Plane.hpp    | 5 +++++
 Sphere.hpp   | 5 +++++
 5 files changed, 25 insertions(+)

diff --git a/Box.hpp b/Box.hpp
index 8fc49132..197fbb5f 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -163,6 +163,11 @@ class Box
     {
         return half_extent_;
     }
+    
+    int dof()
+    {   // degrees of freedom for particle movement
+        return 3;
+    }
 
     bool operator==(const Box& rhs) const
     {
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 9266de36..48cb7cc7 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -77,6 +77,11 @@ class Cylinder
     {
         return half_length_;
     }
+    
+    int dof()
+    {   // degrees of freedom for particle movement
+        return 1;
+    }
 
     std::string show(int precision)
     {
diff --git a/Disk.hpp b/Disk.hpp
index 1e786cfa..b8179027 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -65,6 +65,11 @@ class Disk
     {
         return unit_z_;
     }
+    
+    int dof()
+    {   // degrees of freedom for particle movement
+        return 0;
+    }
 
     std::string show(int precision)
     {
diff --git a/Plane.hpp b/Plane.hpp
index 885dc6a4..3b3b5f59 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -164,6 +164,11 @@ class Plane
     {
         return is_one_sided_;
     }
+    
+    int dof()
+    {   // degrees of freedom for particle movement
+        return 2;
+    }
 
     bool operator==(const Plane& rhs) const
     {
diff --git a/Sphere.hpp b/Sphere.hpp
index 41d0de1c..19d786d0 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -51,6 +51,11 @@ class Sphere
     {
         return radius_;
     }
+    
+    int dof()
+    {   // degrees of freedom for particle movement
+        return 2;
+    }
 
     std::string show(int precision)
     {

From 8b931fc7dc9cbc5a2a1e36646d22fe194a1cb192 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Sep 2013 19:11:07 +0200
Subject: [PATCH 1423/1541] Make dof() function accessible to Structure etc.

---
 Box.hpp                |  2 +-
 CuboidalRegion.hpp     | 31 +++++++++++++++++++++++++++++--
 Cylinder.hpp           |  2 +-
 CylindricalSurface.hpp | 33 ++++++++++++++++++++++++++++++---
 Disk.hpp               |  2 +-
 DiskSurface.hpp        | 38 +++++++++++++++++++++++++++++++++++---
 PlanarSurface.hpp      | 31 +++++++++++++++++++++++++++++--
 Plane.hpp              |  2 +-
 Sphere.hpp             |  2 +-
 SphericalSurface.hpp   | 31 +++++++++++++++++++++++++++++--
 Structure.hpp          | 12 +++++-------
 Surface.hpp            |  2 +-
 12 files changed, 163 insertions(+), 25 deletions(-)

diff --git a/Box.hpp b/Box.hpp
index 197fbb5f..4b21dbfe 100644
--- a/Box.hpp
+++ b/Box.hpp
@@ -164,7 +164,7 @@ class Box
         return half_extent_;
     }
     
-    int dof()
+    const int dof() const
     {   // degrees of freedom for particle movement
         return 3;
     }
diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 3cb86511..0465eb89 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -37,6 +37,18 @@ class CuboidalRegion
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
+    
+    /*** Info functions ***/
+    virtual position_type const& position() const
+    {
+        return base_type::shape().position();
+    }
+    
+//     virtual const int dof() const
+//     {
+//         //return base_type::shape().dof();
+//         return 3;
+//     }
 
     /*** Simple structure-specific sampling functions ***/
     virtual position_type random_position(rng_type& rng) const
@@ -293,6 +305,12 @@ class CuboidalRegion
     position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
+        // This method has to figure out where the product will be placed in case of a bimolecular reaction.
+        // As a default, we place particles on the substructure or the lower-dimensional structure. If the structures
+        // have the same structure type (=> same dimensionality) it does not matter on which structure we put the product,
+        // as long as it has the structure type id of the product species. This is handled in cases '1' below.
+        
+        // 1 - Check whether one of the structures is the parent of the other. If yes, the daughter structure is the target.
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
             return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
@@ -300,8 +318,17 @@ class CuboidalRegion
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
             return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+        
+        // 2 - Check which structures has the lower dimensionality / particle degrees of freedom, and put the product there.
+        else if( origin_structure1.shape().dof() < this->shape().dof() && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+        
+        else if( this->shape().dof() < origin_structure1.shape().dof() && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+        
+        else throw propagation_error("Invalid target structure type: does not match product species structure type or has wrong hierarchy or dimensionality.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 48cb7cc7..67a99ea0 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -78,7 +78,7 @@ class Cylinder
         return half_length_;
     }
     
-    int dof()
+    const int dof() const
     {   // degrees of freedom for particle movement
         return 1;
     }
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index c31226bb..995c0d28 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -40,7 +40,19 @@ class CylindricalSurface
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
-
+    
+    /*** Info functions ***/
+    virtual position_type const& position() const
+    {
+        return base_type::shape().position();
+    }
+    
+//     virtual const int dof() const
+//     {
+//         //return base_type::shape().dof();
+//         return 1;
+//     }
+    
     /*** Simple structure-specific sampling functions ***/
     // Produce a random position in the cylinder (1D)
     virtual position_type random_position(rng_type& rng) const    
@@ -368,6 +380,12 @@ class CylindricalSurface
     position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
+        // This method has to figure out where the product will be placed in case of a bimolecular reaction.
+        // As a default, we place particles on the substructure or the lower-dimensional structure. If the structures
+        // have the same structure type (=> same dimensionality) it does not matter on which structure we put the product,
+        // as long as it has the structure type id of the product species. This is handled in cases '1' below.
+        
+        // 1 - Check whether one of the structures is the parent of the other. If yes, the daughter structure is the target.
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
             return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
@@ -375,8 +393,17 @@ class CylindricalSurface
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
             return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+        
+        // 2 - Check which structures has the lower dimensionality / particle degrees of freedom, and put the product there.
+        else if( origin_structure1.shape().dof() < this->shape().dof() && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+        
+        else if( this->shape().dof() < origin_structure1.shape().dof() && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+        
+        else throw propagation_error("Invalid target structure type: does not match product species structure type or has wrong hierarchy or dimensionality.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/Disk.hpp b/Disk.hpp
index b8179027..b722d9d6 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -66,7 +66,7 @@ class Disk
         return unit_z_;
     }
     
-    int dof()
+    const int dof() const
     {   // degrees of freedom for particle movement
         return 0;
     }
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index a8520092..3914f79c 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -54,6 +54,18 @@ class DiskSurface
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
     
+    /*** Info functions ***/
+    virtual position_type const& position() const
+    {
+        return base_type::shape().position();
+    }
+    
+//     virtual const int dof() const
+//     {
+//         //return base_type::shape().dof();
+//         return 0;
+//     }
+    
     /*** Simple structure-specific sampling functions ***/
     // Produce a "random position" in the disk, which is always its center (the only legal pos.)
     virtual position_type random_position(rng_type& rng) const        
@@ -91,8 +103,13 @@ class DiskSurface
     // Reaction volume for binding to particle in the structure
     virtual Real particle_reaction_volume( length_type const& r01, length_type const& rl ) const
     {
-        // The disk can only hold 1 particle; this function therefore never should be called.
+        // The disk can only hold 1 particle; this function therefore never should be called.        
         return rl;
+        
+        // FIXME: This reaction volume is only correct for particles coming from a rod.
+        // If the interaction partner of the disk particle comes from a plane or from
+        // the bulk, a different volume factor shall be used. Then the return value of
+        // this function would depend on properties of the asker -> how to do???
     }
 
     // Reaction volume for binding to the structure
@@ -383,6 +400,12 @@ class DiskSurface
     position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
+        // This method has to figure out where the product will be placed in case of a bimolecular reaction.
+        // As a default, we place particles on the substructure or the lower-dimensional structure. If the structures
+        // have the same structure type (=> same dimensionality) it does not matter on which structure we put the product,
+        // as long as it has the structure type id of the product species. This is handled in cases '1' below.
+        
+        // 1 - Check whether one of the structures is the parent of the other. If yes, the daughter structure is the target.
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
             return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
@@ -390,8 +413,17 @@ class DiskSurface
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
             return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+        
+        // 2 - Check which structures has the lower dimensionality / particle degrees of freedom, and put the product there.
+        else if( origin_structure1.shape().dof() < this->shape().dof() && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+        
+        else if( this->shape().dof() < origin_structure1.shape().dof() && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+        
+        else throw propagation_error("Invalid target structure type: does not match product species structure type or has wrong hierarchy or dimensionality.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 9f521163..3acc727c 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -37,6 +37,18 @@ class PlanarSurface
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
+    
+    /*** Info functions ***/
+    virtual position_type const& position() const
+    {
+        return base_type::shape().position();
+    }
+    
+//     virtual const int dof() const
+//     {
+//         //return base_type::shape().dof();
+//         return 2;
+//     }
 
     /*** Simple structure-specific sampling functions ***/
     // Draw a random position in the plane
@@ -380,6 +392,12 @@ class PlanarSurface
     position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
+        // This method has to figure out where the product will be placed in case of a bimolecular reaction.
+        // As a default, we place particles on the substructure or the lower-dimensional structure. If the structures
+        // have the same structure type (=> same dimensionality) it does not matter on which structure we put the product,
+        // as long as it has the structure type id of the product species. This is handled in cases '1' below.       
+        
+        // 1 - Check whether one of the structures is the parent of the other. If yes, the daughter structure is the target.
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
             return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
@@ -387,8 +405,17 @@ class PlanarSurface
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
             return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+        
+        // 2 - Check which structures has the lower dimensionality / particle degrees of freedom, and put the product there.
+        else if( origin_structure1.shape().dof() < this->shape().dof() && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+        
+        else if( this->shape().dof() < origin_structure1.shape().dof() && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+        
+        else throw propagation_error("Invalid target structure type: does not match product species structure type or has wrong hierarchy or dimensionality.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/Plane.hpp b/Plane.hpp
index 3b3b5f59..a2a4734e 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -165,7 +165,7 @@ class Plane
         return is_one_sided_;
     }
     
-    int dof()
+    const int dof() const
     {   // degrees of freedom for particle movement
         return 2;
     }
diff --git a/Sphere.hpp b/Sphere.hpp
index 19d786d0..eabf8d70 100644
--- a/Sphere.hpp
+++ b/Sphere.hpp
@@ -52,7 +52,7 @@ class Sphere
         return radius_;
     }
     
-    int dof()
+    const int dof() const
     {   // degrees of freedom for particle movement
         return 2;
     }
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 99c272c3..e735a352 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -33,6 +33,18 @@ class SphericalSurface
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
+    
+    /*** Info functions ***/
+    virtual position_type const& position() const
+    {
+        return base_type::shape().position();
+    }
+    
+//     virtual const int dof() const
+//     {
+//         //return base_type::shape().dof();
+//         return 2;
+//     }
 
     /*** Simple structure-specific sampling functions ***/
     virtual position_type random_position(rng_type& rng) const
@@ -257,6 +269,12 @@ class SphericalSurface
     position_structid_pair_type get_pos_sid_pair_2o_helper_any(Tstruct_ const& origin_structure1, structure_type_id_type const& target_sid, position_type const& CoM,
                                                                         length_type const& offset, length_type const& reaction_length, rng_type& rng) const
     {
+        // This method has to figure out where the product will be placed in case of a bimolecular reaction.
+        // As a default, we place particles on the substructure or the lower-dimensional structure. If the structures
+        // have the same structure type (=> same dimensionality) it does not matter on which structure we put the product,
+        // as long as it has the structure type id of the product species. This is handled in cases '1' below.
+        
+        // 1 - Check whether one of the structures is the parent of the other. If yes, the daughter structure is the target.
         if( this->is_parent_of_or_has_same_sid_as(origin_structure1) && origin_structure1.has_valid_target_sid(target_sid) )
             // origin_structure1 is target
             return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
@@ -264,8 +282,17 @@ class SphericalSurface
         else if( origin_structure1.is_parent_of_or_has_same_sid_as(*this) && this->has_valid_target_sid(target_sid) )
             // this structure is target
             return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
-            
-        else throw propagation_error("Invalid target structure type / particles can be at most one hierarchical level apart for a pair reaction.");
+        
+        // 2 - Check which structures has the lower dimensionality / particle degrees of freedom, and put the product there.
+        else if( origin_structure1.shape().dof() < this->shape().dof() && origin_structure1.has_valid_target_sid(target_sid) )
+            // origin_structure1 is target
+            return ::get_pos_sid_pair<traits_type>(*this, origin_structure1, CoM, offset, reaction_length, rng);
+        
+        else if( this->shape().dof() < origin_structure1.shape().dof() && this->has_valid_target_sid(target_sid) )
+            // this structure is target
+            return ::get_pos_sid_pair<traits_type>(origin_structure1, *this, CoM, offset, reaction_length, rng);
+        
+        else throw propagation_error("Invalid target structure type: does not match product species structure type or has wrong hierarchy or dimensionality.");
     }
     
 //     // *** 4 *** - Generalized functions for pair reactions with two origin structures and one target structure
diff --git a/Structure.hpp b/Structure.hpp
index 454c60b3..81d3d61b 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -113,10 +113,8 @@ class Structure
     }
 
     virtual position_type random_position(rng_type& rng) const = 0;
-
     virtual position_type random_vector(length_type const& r, rng_type& rng) const = 0;
 
-
     // Methods used in the 'old' BDPropagator // DEPRECATED
     virtual position_type dissociation_vector(rng_type& rng, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
     virtual length_type drawR_gbd(Real const& rnd, length_type const& r01, Real const& dt, Real const& D01, Real const& v) const = 0;
@@ -144,6 +142,7 @@ class Structure
     virtual length_type distance(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;
     virtual position_type const& side_comparison_vector() const = 0;
+    //virtual const int dof() const;
 
     // Methods used for edge crossing (only for the planes so far)
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
@@ -305,11 +304,10 @@ class Structure
 
 ////// Member variables
 protected:
-    structure_name_type     name_;                  // just the name
-    structure_type_id_type  sid_;                   // id of the structure_type of the structure
-    structure_id_type       parent_struct_id_;
-
-    structure_id_type       id_;        // id of the structure (filled in later)
+    structure_name_type     name_;              // just the name
+    structure_type_id_type  sid_;               // id of the structure_type of the structure    
+    structure_id_type       id_;                // id of the structure (filled in later)
+    structure_id_type       parent_struct_id_;  // id of the parent structure (filled in later)    
 };
 
 
diff --git a/Surface.hpp b/Surface.hpp
index e01afc84..aeffda08 100644
--- a/Surface.hpp
+++ b/Surface.hpp
@@ -71,7 +71,7 @@ class BasicSurfaceImpl: public Surface<Ttraits_>
     {
         return shape_;
     }
-
+    
     virtual bool operator==(Structure<Ttraits_> const& rhs) const
     {
         BasicSurfaceImpl const* _rhs(dynamic_cast<BasicSurfaceImpl const*>(&rhs));

From f6db75a6df49253d9f32d388939843a4acb26f46 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Sep 2013 20:07:25 +0200
Subject: [PATCH 1424/1541] New surface overlap checker method that allows for
 two ignored structures + Python binding

This is not the best solution, but will do the job until we know how
to treat an ignore list of arbitrary length.
---
 Multi.hpp                     |  6 ++++++
 ParticleContainer.hpp         |  5 ++++-
 ParticleContainerBase.hpp     | 16 ++++++++++++----
 Transaction.hpp               |  6 ++++++
 binding/ParticleContainer.hpp | 13 +++++++++++--
 5 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 21860b04..196cf52d 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -246,6 +246,12 @@ class MultiParticleContainer
     {
         return world_.check_surface_overlap(s, old_pos, current, sigma, ignore);
     }
+    
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore1, structure_id_type const& ignore2) const
+    {
+        return world_.check_surface_overlap(s, old_pos, current, sigma, ignore1, ignore2);
+    }
 
     virtual particle_id_pair_generator* get_particles() const
     {
diff --git a/ParticleContainer.hpp b/ParticleContainer.hpp
index b326d284..7a8659d2 100644
--- a/ParticleContainer.hpp
+++ b/ParticleContainer.hpp
@@ -117,12 +117,15 @@ class ParticleContainer
 
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const = 0;
-
+                                                                       
     virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma) const = 0;
 
     virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const = 0;
+                                                                       
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore1, structure_id_type const& ignore2) const = 0;
 
     // Particle stuff
     virtual particle_id_pair new_particle(species_id_type const& sid, structure_id_type const& structure_id,
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index f57b194d..46ebc122 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -290,8 +290,16 @@ class ParticleContainerBase
         typename utils::template overlap_checker<particle_id_pair_and_distance_list, boost::array<particle_id_type, 0> > oc;
         traits_type::take_neighbor(pmat_, oc, s);
         return oc.result();
+    }    
+    
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma) const
+    {
+        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
+        surface_overlap_checker(s, old_pos, current, sigma, checker);
+        return checker.result();
     }
-
+    
     virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
                                                                        length_type const& sigma, structure_id_type const& ignore) const
     {
@@ -299,11 +307,11 @@ class ParticleContainerBase
         surface_overlap_checker(s, old_pos, current, sigma, checker);
         return checker.result();
     }
-
+    
     virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
-                                                                       length_type const& sigma) const
+                                                                       length_type const& sigma, structure_id_type const& ignore1, structure_id_type const& ignore2) const
     {
-        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 0> > checker;
+        typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 2> > checker(array_gen(ignore1, ignore2));
         surface_overlap_checker(s, old_pos, current, sigma, checker);
         return checker.result();
     }
diff --git a/Transaction.hpp b/Transaction.hpp
index cf4d4b23..c19e2ce3 100644
--- a/Transaction.hpp
+++ b/Transaction.hpp
@@ -179,6 +179,12 @@ class TransactionImpl: public Transaction<typename Tpc_::traits_type>
     {
         return pc_.check_surface_overlap(s, old_pos, current, sigma, ignore);
     }
+    
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore1, structure_id_type const& ignore2) const
+    {
+        return pc_.check_surface_overlap(s, old_pos, current, sigma, ignore1, ignore2);
+    }
 
     virtual Transaction<traits_type>* create_transaction()
     {
diff --git a/binding/ParticleContainer.hpp b/binding/ParticleContainer.hpp
index 4ca32062..d8565b09 100644
--- a/binding/ParticleContainer.hpp
+++ b/binding/ParticleContainer.hpp
@@ -554,6 +554,14 @@ class ParticleContainerWrapper
                 s, old_pos, current, sigma, ignore)
                .template unchecked<structure_id_pair_and_distance_list*>();
     }
+    
+    virtual structure_id_pair_and_distance_list* check_surface_overlap(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
+                                                                       length_type const& sigma, structure_id_type const& ignore1, structure_id_type const& ignore2) const
+    {
+        return py_wrapper_type::get_override("check_surface_overlap")(
+                s, old_pos, current, sigma, ignore1, ignore2)
+               .template unchecked<structure_id_pair_and_distance_list*>();
+    }
 
     virtual particle_id_pair_generator* get_particles() const
     {
@@ -661,9 +669,10 @@ inline boost::python::objects::class_base register_particle_container_class(
         .def("get_particle", pure_virtual(&impl_type::get_particle))
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
         .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::particle_id_type const&, typename impl_type::particle_id_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
-        .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())
-        .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&, typename impl_type::length_type const&, typename impl_type::structure_id_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
+        .def("check_overlap", pure_virtual((typename impl_type::particle_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&) const)&impl_type::check_overlap), return_value_policy<return_by_value>())        
         .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&, typename impl_type::length_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
+        .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&, typename impl_type::length_type const&, typename impl_type::structure_id_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
+        .def("check_surface_overlap", pure_virtual((typename impl_type::structure_id_pair_and_distance_list*(impl_type::*)(typename impl_type::particle_type::shape_type const&, typename impl_type::position_type const&, typename impl_type::structure_id_type const&, typename impl_type::length_type const&, typename impl_type::structure_id_type const&, typename impl_type::structure_id_type const&) const)&impl_type::check_surface_overlap), return_value_policy<return_by_value>())
         .def("create_transaction", pure_virtual(&impl_type::create_transaction),
                 return_value_policy<manage_new_object>())
         .def("distance", pure_virtual(&impl_type::distance))

From 4e300b3aa0957158409df58108fbc9df72623e2c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Sep 2013 20:09:02 +0200
Subject: [PATCH 1425/1541] Ignore reactant structures when placing product in
 BD mode + some useful comments and more debug log output

This was still missing and causing artificially rejected reactions
for particles on a cylinder interacting with disk particles.
---
 newBDPropagator.hpp | 68 +++++++++++++++++++++++++++++----------------
 1 file changed, 44 insertions(+), 24 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 8613fd16..2e44bd97 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -111,9 +111,20 @@ class newBDPropagator
         particle_id_type pid(queue_.back());
         queue_.pop_back();
         particle_id_pair pp(tx_.get_particle(pid));
-        // Log
-        LOG_DEBUG(("propagating particle %s", boost::lexical_cast<std::string>(pp.first).c_str()));
+        // Log some info
+        LOG_DEBUG(("propagating particle %s, dt = %g, reaction_length = %g", 
+                    boost::lexical_cast<std::string>(pp.first).c_str(),
+                    dt_,
+                    reaction_length_
+                 ));
         
+        // Particles that are immobile cannot move nor hit another particle,
+        // so exit immediately if this is the case
+        if(pp.second.D() == 0.0 && pp.second.v() == 0.0) // particle is immobile
+        {
+            LOG_DEBUG(("particle is immobile (D=0, v=0), no further action"));
+            return true;
+        }            
 
         /*** 2. TRY SINGLE (DECAY) REACTION ***/
         // Consider decay reactions first. Particles can move after decay, but this is done
@@ -136,7 +147,7 @@ class newBDPropagator
             return true;
         }
 
-        /*** 3. COLLECT INFO ***/
+        /*** 3.1 COLLECT INFO ***/
         // Get info of the particle
         const species_type                      pp_species(tx_.get_species(pp.second.sid()));
         const length_type                       r0( pp_species.radius() );
@@ -147,7 +158,7 @@ class newBDPropagator
         position_type                   new_pos(old_pos);
         structure_id_type               new_structure_id( old_struct_id );
 
-        /*** 2. DISPLACEMENT TRIAL ***/
+        /*** 3.2 DISPLACEMENT TRIAL ***/
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particle bounces, and is returned
            to it's original position. For a particle with D = 0, new_pos = old_pos 
@@ -165,7 +176,7 @@ class newBDPropagator
             new_structure_id = pos_structid.second;
         }
 
-        /*** 4. CHECK OVERLAPS ***/
+        /*** 4 CHECK OVERLAPS ***/
         bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
@@ -174,13 +185,13 @@ class newBDPropagator
                 tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
         int particles_in_overlap(overlap_particles ? overlap_particles->size(): 0);
 
-        //// 3.1 CHECK FOR CORE OVERLAPS WITH PARTICLES
+        //// 4.1 CHECK FOR CORE OVERLAPS WITH PARTICLES
         /* Check if the particle at new_pos overlaps with any particle cores. */        
         int j( 0 );
         while(!bounced && j < particles_in_overlap)
             bounced = overlap_particles->at(j++).second < r0;
         
-        //// 3.2 CHECK FOR CORE OVERLAPS WITH STRUCTURES
+        //// 4.2 CHECK FOR CORE OVERLAPS WITH STRUCTURES
         /* If the particle has not bounced with another particle check for overlap with a surface. */
         boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures;
         int structures_in_overlap(0);
@@ -234,7 +245,7 @@ class newBDPropagator
         Real rnd( rng_() );
         
         const boost::shared_ptr<const structure_type> current_struct( tx_.get_structure( new_structure_id) );
-        //// 5.1 INTERACTIONS WITH STRUCTURES
+        //// 6.1 INTERACTIONS WITH STRUCTURES
         // First, if a surface is inside the reaction volume, and the particle is in the 3D attempt an interaction.
         // TODO Rework this using the new structure functions?
         // TODO Don't check only the closest but check all overlapping surfaces.
@@ -286,20 +297,20 @@ class newBDPropagator
                         // prob. increment zero there.
                         // Conceptually this means that the prob. for the reaction that was just attempted
                         // and failed was zero in the first place (due to lack of space).
-                        log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
+                        log_.info("treating reaction as forbidden and reducing acc. probability by %s", prob_increase);
                         accumulated_prob -= prob_increase;
                     }
                     catch (illegal_propagation_attempt const& reason)
                     {
                         log_.info("surface interaction: illegal propagation attempt (reason: %s)", reason.what());
                         ++rejected_move_count_;
-                        log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
+                        log_.info("treating reaction as forbidden and reducing acc. probability by %s", prob_increase);
                         accumulated_prob -= prob_increase;
                     }
                 }
                 else
                 {
-                    LOG_DEBUG( ("Particle attempted an interaction with the non-interactive surface %s.", 
+                    LOG_DEBUG( ("particle attempted an interaction with the non-interactive surface %s.", 
                                 boost::lexical_cast<std::string>(overlap_struct.first.first).c_str()) );
                 }
             }
@@ -337,16 +348,23 @@ class newBDPropagator
                                 ( 2. * s1_struct->particle_reaction_volume( s0.radius() + s1.radius(), reaction_length_ ) ); 
             accumulated_prob += prob_increase;
             
+            LOG_DEBUG(( 
+                       "checking for reaction between %s and %s, prob. increase = %g.",
+                       boost::lexical_cast<std::string>(s0).c_str(),
+                       boost::lexical_cast<std::string>(s1).c_str(),
+                       prob_increase
+                     ));
+            
             if (accumulated_prob >= 1.)
             {
                 LOG_WARNING((
-                    "the accumulated acceptance probability inside a reaction volume exeededs one in particle-particle reaction: p_acc = %f, reaction_length = %e, dt = %e.",
+                    "the accumulated acceptance probability inside a reaction volume exeededs one in particle-particle reaction: p_acc = %g, reaction_length = %e, dt = %e.",
                      accumulated_prob, reaction_length_, dt_));
             } 
             
             if(accumulated_prob > rnd)
             {
-                LOG_DEBUG(("fire reaction"));
+                LOG_DEBUG(("attempting to fire reaction."));
     		    try
                 {
                     if( attempt_pair_reaction(pp, overlap_particle.first, s0, s1) )
@@ -357,13 +375,13 @@ class newBDPropagator
                     log_.info("second-order reaction rejected (reason: %s)", reason.what());
                     ++rejected_move_count_;
                     // Set the increase to zero a posteriori
-                    log_.info("treating reaction as forbidden and resetting acc. probability by %s", prob_increase);
+                    log_.info("treating reaction as forbidden and reducing acc. probability by %g", prob_increase);
                     accumulated_prob -= prob_increase;
                 }
             }
             else                
             {
-                LOG_DEBUG(("Particle attempted a reaction with particle %s and failed.", 
+                LOG_DEBUG(("particle attempted a reaction with particle %s and failed.", 
                     boost::lexical_cast<std::string>(overlap_particle.first.first).c_str()));
             }
             
@@ -419,7 +437,7 @@ class newBDPropagator
         
         if ((int)::size(rules) == 0)
         {
-            LOG_DEBUG(("No single reaction rules." ));
+            //LOG_DEBUG(("No single reaction rules." ));
             return false;
         }
      
@@ -524,7 +542,7 @@ class newBDPropagator
                         }
                         // check overlap with surfaces
                         const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
-                                tx_.check_surface_overlap(new_shape, reactant_pos, product_pos_struct_id.second, product_species.radius()));
+                                tx_.check_surface_overlap(new_shape, reactant_pos, product_pos_struct_id.second, product_species.radius(), reactant_structure_id ));
                         if (overlap_surfaces && overlap_surfaces->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");
@@ -858,10 +876,11 @@ class newBDPropagator
                         position_type                       reactant0_pos (pp0.second.position());
                         position_type                       reactant1_pos (pp1.second.position());
 
-                        const species_type                  product_species(tx_.get_species(products[0]));
-                        const structure_type_id_type        product_structure_type_id(product_species.structure_type_id());
-                        structure_id_type                   product_structure_id(reactant0_structure_id);
-                        position_type                       product_pos(reactant0_pos);
+                        const species_type                  product_species (tx_.get_species(products[0]));
+                        const structure_type_id_type        product_structure_type_id (product_species.structure_type_id());
+                        structure_id_type                   product_structure_id (reactant0_structure_id);
+                        boost::shared_ptr<structure_type>   product_structure (tx_.get_structure( product_structure_id ));
+                        position_type                       product_pos (reactant0_pos);                        
 
                         
                         //// 1 - GENERATE NEW POSITION AND STRUCTURE ID
@@ -907,7 +926,7 @@ class newBDPropagator
                         LOG_DEBUG(("  reactant1_structure = %s, sid = %s",
                                       boost::lexical_cast<std::string>(*reactant1_structure).c_str(),
                                       boost::lexical_cast<std::string>( reactant1_structure->sid()).c_str() ));
-                        LOG_DEBUG(("  Note: product_structure_type_id = %s", boost::lexical_cast<std::string>( product_structure_type_id).c_str() ));                        
+                        LOG_DEBUG(("  Note: product_structure_type_id = %s", boost::lexical_cast<std::string>( product_structure_type_id).c_str() ));
                         LOG_DEBUG(("  Note: reactants_CoM=%s", boost::lexical_cast<std::string>(reactants_CoM).c_str() ));
                         
                         const position_structid_pair_type product_info_in_reactant_structure( reactant0_structure->get_pos_sid_pair_2o(*reactant1_structure,
@@ -934,9 +953,10 @@ class newBDPropagator
                         {
                             throw propagation_error("no space due to particle");
                         }
-                        // Check overlap with surfaces
+                        // Check overlap with surfaces                        
                         const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
-                                tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius()));
+                                tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius(), 
+                                                                                  reactant0_structure_id, reactant1_structure_id  ));
                         if (overlap_structures && overlap_structures->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");

From 7d70d7d7c322afdaa6c366dd2a266f0a592226e3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 26 Sep 2013 20:13:29 +0200
Subject: [PATCH 1426/1541] Some cleanup of stuff that did not work

---
 CuboidalRegion.hpp     | 6 ------
 CylindricalSurface.hpp | 6 ------
 DiskSurface.hpp        | 6 ------
 PlanarSurface.hpp      | 6 ------
 SphericalSurface.hpp   | 8 +-------
 Structure.hpp          | 1 -
 6 files changed, 1 insertion(+), 32 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index 0465eb89..ca627fbd 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -43,12 +43,6 @@ class CuboidalRegion
     {
         return base_type::shape().position();
     }
-    
-//     virtual const int dof() const
-//     {
-//         //return base_type::shape().dof();
-//         return 3;
-//     }
 
     /*** Simple structure-specific sampling functions ***/
     virtual position_type random_position(rng_type& rng) const
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index 995c0d28..a2155163 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -47,12 +47,6 @@ class CylindricalSurface
         return base_type::shape().position();
     }
     
-//     virtual const int dof() const
-//     {
-//         //return base_type::shape().dof();
-//         return 1;
-//     }
-    
     /*** Simple structure-specific sampling functions ***/
     // Produce a random position in the cylinder (1D)
     virtual position_type random_position(rng_type& rng) const    
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 3914f79c..7e75346f 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -60,12 +60,6 @@ class DiskSurface
         return base_type::shape().position();
     }
     
-//     virtual const int dof() const
-//     {
-//         //return base_type::shape().dof();
-//         return 0;
-//     }
-    
     /*** Simple structure-specific sampling functions ***/
     // Produce a "random position" in the disk, which is always its center (the only legal pos.)
     virtual position_type random_position(rng_type& rng) const        
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 3acc727c..599cc987 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -43,12 +43,6 @@ class PlanarSurface
     {
         return base_type::shape().position();
     }
-    
-//     virtual const int dof() const
-//     {
-//         //return base_type::shape().dof();
-//         return 2;
-//     }
 
     /*** Simple structure-specific sampling functions ***/
     // Draw a random position in the plane
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index e735a352..7d004634 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -38,13 +38,7 @@ class SphericalSurface
     virtual position_type const& position() const
     {
         return base_type::shape().position();
-    }
-    
-//     virtual const int dof() const
-//     {
-//         //return base_type::shape().dof();
-//         return 2;
-//     }
+    }   
 
     /*** Simple structure-specific sampling functions ***/
     virtual position_type random_position(rng_type& rng) const
diff --git a/Structure.hpp b/Structure.hpp
index 81d3d61b..a8c0dc87 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -142,7 +142,6 @@ class Structure
     virtual length_type distance(position_type const& pos) const = 0;
     virtual position_type const& position() const = 0;
     virtual position_type const& side_comparison_vector() const = 0;
-    //virtual const int dof() const;
 
     // Methods used for edge crossing (only for the planes so far)
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;

From adc21ff85055b2dfab1d3b46ae0866ab43d130b6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 30 Sep 2013 11:24:43 +0200
Subject: [PATCH 1427/1541] New function all_feq to check whether all entries
 of a difference vector are zero subject to a tolerance

---
 utils.py | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/utils.py b/utils.py
index f64d69c8..f48e40b9 100644
--- a/utils.py
+++ b/utils.py
@@ -80,6 +80,17 @@ def feq(a, b, typical=1, tolerance=TOLERANCE):
 
     return abs(a - b) < tolerance * (typical + min(abs(a), abs(b)))
 
+def all_feq(a, b, typical=1, tolerance=TOLERANCE):
+    """ Return True if array-like objects a and b are equal,
+        subject to given tolerances.  
+
+        Float comparison.
+
+        This is basically a wrapper around numpy.allclose().
+    """
+    
+    return numpy.allclose(a, b, rtol=TOLERANCE, atol=TOLERANCE*typical)
+    
 
 def fgreater(a, b, typical=1, tolerance=TOLERANCE):
     """Return True if a is greater than b, subject to given tolerances.  

From 3803c541f9c71f4d3b3721241c1245b5e8397adc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 30 Sep 2013 11:40:44 +0200
Subject: [PATCH 1428/1541] Replace '==' by feq() or feq_all() in assert
 statements

---
 loadsave.py |  3 ++-
 pair.py     | 11 ++++++-----
 shells.py   |  3 ++-
 single.py   | 18 +++++++++---------
 4 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/loadsave.py b/loadsave.py
index dafba738..9d12909d 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -34,6 +34,7 @@
 
 from gfrdbase import *
 from gfrdbase import DomainEvent
+from utils import *
 import model
 import _gfrd
 
@@ -789,7 +790,7 @@ def load_state(filename):
             structure = model.create_planar_surface(structure_type.id, name, corner_pos, unit_x, unit_y, \
                                                     2.0*half_extent[0], 2.0*half_extent[1], parent_structure.id)
             
-            assert all( [structure.shape.unit_z[c]==unit_z[c] for c in range(0,len(unit_z))] )
+            assert all_feq(structure.shape.unit_z, unit_z, tolerance=TOLERANCE)
 
         # Add it to the world
         if structure:
diff --git a/pair.py b/pair.py
index 4af24d12..609f2386 100644
--- a/pair.py
+++ b/pair.py
@@ -350,9 +350,9 @@ def determine_radii(self, r0, shell_size):
             log.debug('tr = %g, tR = %g' % (tr, tR))
 
 
-        assert a_r > 0
-        assert a_r > r0, '%g %g' % (a_r, r0)
-        assert a_R > 0 or (a_R == 0 and (D1 == 0 or D2 == 0))
+        assert fgreater(a_r, 0, typical=radiusa)
+        assert fgreater(a_r, r0, typical=radiusa), '%g %g' % (a_r, r0)
+        assert fgreater(a_R, 0, typical=radiusa) or (feq(a_R, 0) and (D1 == 0 or D2 == 0))
 
         return a_R, a_r
 
@@ -1104,7 +1104,8 @@ def check(self):
             'MixedPair2D3D: Domain did not obey scaling relationship. '
 
         # check that the CoM is in the surface
-        assert numpy.dot( (self.com-self.structure2D.shape.position), self.structure2D.shape.unit_z) == 0.0
+        assert feq(numpy.dot(self.com-self.structure2D.shape.position, self.structure2D.shape.unit_z), 0.0, \
+                   typical=radius)
         # check that the IV is NOT in the surface
 
     def __str__(self):
@@ -1202,7 +1203,7 @@ def get_shell_size(self):   # TODO Is that even used?
     def get_a_r(self):
       
         ref_pt = self.testShell.get_referencepoint()
-        assert ( all(self.static_particle.position - ref_pt == 0) )
+        assert all_feq(self.static_particle.position - ref_pt, 0.0)
 
         return abs(self.testShell.dz_right) - self.particle1D.radius
     a_r = property(get_a_r)
diff --git a/shells.py b/shells.py
index ee6642e1..8222818e 100755
--- a/shells.py
+++ b/shells.py
@@ -483,7 +483,8 @@ def __init__(self, single1D, static_single):
 
         # Make sure that the static particle's position coincides with the disk position
         if __debug__:
-                assert all(self.static_structure.shape.position - self.static_particle.position == 0.0)
+                assert all_feq(self.static_structure.shape.position - self.static_particle.position, 0.0, \
+                               typical = self.static_structure.shape.radius) 
 
     def get_sigma(self):
         # Copied from SimplePair
diff --git a/single.py b/single.py
index eaad0d83..3725c5c6 100644
--- a/single.py
+++ b/single.py
@@ -347,7 +347,7 @@ def check(self):
         if not self.is_reset():
             assert self.shell.shape.radius*SAFETY >= self.testShell.get_min_radius()
         if self.is_reset():
-            assert self.shell.shape.radius == self.pid_particle_pair[1].radius
+            assert feq(self.shell.shape.radius, self.pid_particle_pair[1].radius)
 
         assert self.is_reset() ^ (self.dt != 0.0)
         assert isinstance(self.structure, CuboidalRegion)
@@ -439,15 +439,15 @@ def check(self):
         if not self.is_reset():
             min_radius, _, _ = self.testShell.get_min_dr_dzright_dzleft()
             assert self.shell.shape.radius*SAFETY >= min_radius
-        assert self.shell.shape.half_length == self.testShell.z_right(self.shell.shape.radius) 
-        assert self.shell.shape.half_length == self.testShell.z_left (self.shell.shape.radius)
+        assert feq(self.shell.shape.half_length, self.testShell.z_right(self.shell.shape.radius))
+        assert feq(self.shell.shape.half_length, self.testShell.z_left (self.shell.shape.radius))
         if self.is_reset():
-            assert self.shell.shape.radius == self.pid_particle_pair[1].radius
+            assert feq(self.shell.shape.radius, self.pid_particle_pair[1].radius)
 
         assert self.is_reset() ^ (self.dt != 0.0)
         assert isinstance(self.structure, PlanarSurface)
         assert self.greens_function
-        assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
+        assert all_feq(self.shell.shape.unit_z, self.structure.shape.unit_z)
 
         # Assert that new position is in the structure
         assert feq(numpy.dot(self.pid_particle_pair[1].position - self.structure.shape.position,\
@@ -572,12 +572,12 @@ def check(self):
 #        if not self.is_reset():
 #            assert self.shell.shape.radius >= self.testShell.get_min_radius()
         if self.is_reset():
-            assert self.shell.shape.half_length == self.pid_particle_pair[1].radius
+            assert feq(self.shell.shape.half_length, self.pid_particle_pair[1].radius)
 
         assert self.is_reset() ^ (self.dt != 0.0)
         assert isinstance(self.structure, CylindricalSurface)
         assert self.greens_function
-        assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
+        assert all_feq(self.shell.shape.unit_z, self.structure.shape.unit_z)
         assert self.v < numpy.inf
 
         return True
@@ -667,12 +667,12 @@ def check(self):
         assert isinstance(self.shell.shape, Cylinder)
 
         if self.is_reset():
-            assert self.shell.shape.half_length == self.pid_particle_pair[1].radius
+            assert feq(self.shell.shape.half_length, self.pid_particle_pair[1].radius)
 
         assert self.is_reset() ^ (self.dt != 0.0)
         assert isinstance(self.structure, DiskSurface)
         #assert self.greens_function
-        assert (self.shell.shape.unit_z == self.structure.shape.unit_z).all()
+        assert all_feq(self.shell.shape.unit_z, self.structure.shape.unit_z)
 
         return True
 

From 20a54e1c6badf983305e6be444942e2a00337cc8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 1 Oct 2013 18:58:11 +0200
Subject: [PATCH 1429/1541] Check whether particles are immobile and there is
 nothing to do in the right place of newBDPropagator routine

The current order was stupid, because the program would never check
for single reactions if particles are mobile. This is fixed now.
---
 newBDPropagator.hpp | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 2e44bd97..422789f4 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -116,15 +116,7 @@ class newBDPropagator
                     boost::lexical_cast<std::string>(pp.first).c_str(),
                     dt_,
                     reaction_length_
-                 ));
-        
-        // Particles that are immobile cannot move nor hit another particle,
-        // so exit immediately if this is the case
-        if(pp.second.D() == 0.0 && pp.second.v() == 0.0) // particle is immobile
-        {
-            LOG_DEBUG(("particle is immobile (D=0, v=0), no further action"));
-            return true;
-        }            
+                 ));              
 
         /*** 2. TRY SINGLE (DECAY) REACTION ***/
         // Consider decay reactions first. Particles can move after decay, but this is done
@@ -146,7 +138,21 @@ class newBDPropagator
             ++rejected_move_count_;
             return true;
         }
+        
+        // If no single reaction happened,
+        // we will check for reactions/interactions upon particle moves.
+        
+        // First treat special cases.
+        // Particles that are immobile cannot move nor hit another particle,
+        // so exit immediately if this is the case
+        if(pp.second.D() == 0.0 && pp.second.v() == 0.0) // particle is immobile
+        {
+            LOG_DEBUG(("particle is immobile (D=0, v=0), no further action"));
+            return true;
+        }     
 
+        // OK, we seem to be in the regular case. Continue.
+        
         /*** 3.1 COLLECT INFO ***/
         // Get info of the particle
         const species_type                      pp_species(tx_.get_species(pp.second.sid()));
@@ -486,7 +492,7 @@ class newBDPropagator
                         //// 1 - CREATE NEW POSITION AND STRUCTURE ID                                                
                         if( product_species.structure_type_id() != reactant_structure->sid() )
                         {                            
-                            LOG_DEBUG(("Attempting single reaction with one product." ));
+                            LOG_DEBUG(("Attempting monomolecular reaction with one product." ));
                             
                             // Now determine the target structure id; if not staying on the origin structure,
                             // the particle is assumed to go to either the default structure or its parent structure,
@@ -505,7 +511,7 @@ class newBDPropagator
                             
                             else
                               
-                                throw not_implemented("Invalid product structure in single reaction: Must be either parent or default structure!");
+                                throw not_implemented("Invalid product structure in monomolecular reaction: Must be either parent or default structure!");
                             
                             // Get the structure behind the product_structure_id
                             const boost::shared_ptr<const structure_type> product_structure( tx_.get_structure(product_structure_id) );
@@ -602,7 +608,7 @@ class newBDPropagator
                         species_type product0_species(tx_.get_species(products[0]));
                         species_type product1_species(tx_.get_species(products[1]));
 
-                        LOG_DEBUG(("Attempting single reaction with two products." ));
+                        LOG_DEBUG(("Attempting monomolecular reaction with two products." ));
                         
                         // If the products live on different structures, one must be the parent of the other or the default structure.
                         // In this case we have to bring the products into the right order.
@@ -617,7 +623,7 @@ class newBDPropagator
                             if( !( product0_species.structure_type_id() == reactant_structure_type_id ||
                                    product1_species.structure_type_id() == reactant_structure_type_id    )
                               )
-                                throw not_implemented("Invalid product structure for first product in single reaction: One particle must stay behind on structure of origin!");
+                                throw not_implemented("Invalid product structure for first product in monomolecular reaction: One particle must stay behind on structure of origin!");
 
                             // One of the products must go into the parent or default structure
                             if( !( product0_species.structure_type_id() == parent_structure_type_id  ||
@@ -625,7 +631,7 @@ class newBDPropagator
                                    product1_species.structure_type_id() == parent_structure_type_id  ||                                 
                                    product1_species.structure_type_id() == default_structure_type_id    )
                               )
-                                throw not_implemented("Invalid product structure for second product in single reaction: Must be either parent or default structure!");
+                                throw not_implemented("Invalid product structure for second product in monomolecular reaction: Must be either parent or default structure!");
                             
                             // OK, reaction rule is legal; set the product species according to the above convention
                             if ( !(product0_species.structure_type_id() == reactant_structure_type_id) )

From 8ac12d6886e84b393f71b79242a75152d3092529 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 Oct 2013 15:18:18 +0200
Subject: [PATCH 1430/1541] Fix unbinding Disk->Plane in BD mode

---
 CylindricalSurface.hpp |  9 ++++-
 DiskSurface.hpp        | 83 ++++++++++++++----------------------------
 StructureFunctions.hpp | 14 +++++--
 3 files changed, 44 insertions(+), 62 deletions(-)

diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index a2155163..bda8cbfa 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -162,15 +162,20 @@ class CylindricalSurface
     virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
         position_type const& op_surf, length_type const& rl ) const
     {
+      
+        // FIXME FIXME FIXME What the hell is all of that calculation? What are these angles / transformations?
+        // This should just place the dissociating particle in the reaction volume close to the cylinder!
+        // NOTE Probably just copied from PlanarSurface ?
+        
         Real const rod_radius( base_type::shape().radius() );
         
         //Species living on the rod should have a larger radius than the rod.
-        assert( rod_radius < s_surf.radius() );
+        assert( rod_radius < s_surf.radius() ); // FIXME This is dangerous to put here! Revise!
     
         length_type const r01( s_bulk.radius() + s_surf.radius() );
         Real const D01( s_bulk.D() + s_surf.D() );
         Real const D_bulk_D01( s_bulk.D() / D01 );
-        Real const D_surf_D01( s_surf.D() / D01 );
+        Real const D_surf_D01( s_surf.D() / D01 );               
         
         //Commented code for direct binding case with c.o.m. reaction.
         //Real const theta_min( asin(rod_radius / r01) );       
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 7e75346f..e669f668 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -115,36 +115,37 @@ class DiskSurface
     }
     
     // Vector of dissociation from the structure into the bulk
-    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& r0, length_type const& rl ) const
+    virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& offset, length_type const& rl ) const
     {
-        // This function produces a position for a particle unbinding from the disk onto the rod.
+        // This function produces a position for a particle unbinding from the disk.
         // It should lie within the reaction volume around the disk.
         // Note that this is the same code as for the CylindricalSurface.
         Real X( rng.uniform(0.,1.) );
-        length_type const rod_radius = base_type::shape().radius();
+        length_type   const disk_radius = base_type::shape().radius();
         position_type const unit_z = base_type::shape().unit_z();
 
         // Calculate the length of the vector first
-        length_type const rrl( rod_radius + r0 + rl );
+        length_type const rrl( disk_radius + offset + rl );
         length_type const rrl_sq( gsl_pow_2(rrl) );
-        length_type const rr_sq( gsl_pow_2(rod_radius + r0) );        
+        length_type const rr_sq(  gsl_pow_2(disk_radius + offset) );
         // Create a random length between rr_sq and rrl_sq
         length_type const diss_vec_length( sqrt( rr_sq + X * (rrl_sq - rr_sq) ) );
 
         // Create a 3D vector with totally random orientation
         position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);
         // Subtract the part parallel to the axis to get the orthogonal components and normalize
-        // This creates a normed random vector orthogonal to the cylinder axis
+        // This creates a normed random vector in the disk plane
         v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
          
         // Return the created vector with the right length
-        return multiply( v, diss_vec_length); 
+        return multiply( v, (1.0 + 1e-7) * diss_vec_length);
+               // TODO define a global MINIMAL_SEPARATION_FACTOR also for BD mode
     }
     
     // Normed direction of dissociation from the structure to parent structure
     virtual position_type surface_dissociation_unit_vector( rng_type& rng ) const
     {
-        return base_type::shape().unit_z();
+        return base_type::shape().unit_z(); // FIXME
     }
     
     // Vector used to determine whether a particle has crossed the structure
@@ -159,64 +160,34 @@ class DiskSurface
         length_type const& rl ) const
     {
         // The positions of a particle dissociating into two new ones on the disk; should never happen,
-        // therefore this function just returns a dummy positions pair (2x the disk center)        
-        
+        // therefore this function just returns a dummy positions pair (2x the disk center)                
         return position_pair_type( base_type::shape().position(), base_type::shape().position() );
     }
     
     // Positions created at dissociation of one particle on the structure into two particles, one of which ends up in the bulk
-    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_surf, species_type const& s_bulk, 
-        position_type const& op_surf, length_type const& rl ) const
+    virtual position_pair_type special_geminate_dissociation_positions( rng_type& rng, species_type const& s_disk, species_type const& s_diss, 
+        position_type const& reactant_pos, length_type const& rl ) const
     {
-        // TODO 
         // This function produces two new positions for a dissociating particle in the case
         // that one stays on the surface and the other one changes to the parent structure.
-        // We have to distinguish between sink and cap here and between dissociation onto
-        // the rod and into the bulk for the cap!
-        
-        Real const rod_radius( base_type::shape().radius() );
-        
-        //Species living on the rod should have a larger radius than the rod.
-        assert( rod_radius < s_surf.radius() );
-    
-        length_type const r01( s_bulk.radius() + s_surf.radius() );
-        Real const D01( s_bulk.D() + s_surf.D() );
-        Real const D_bulk_D01( s_bulk.D() / D01 );
-        Real const D_surf_D01( s_surf.D() / D01 );
-        
-        //Commented code for direct binding case with c.o.m. reaction.
-        //Real const theta_min( asin(rod_radius / r01) );       
-        Real const theta_min( asin( (rod_radius + s_bulk.radius()) / r01) );       
-        Real const theta( theta_min + rng.uniform(0.,1.) * (M_PI - 2 * theta_min) );  
-        Real const phi( rng.uniform(0.,1.) * 2 * M_PI );
-        
-        Real const X( rng.uniform(0.,1.) );
-        length_type const r01l( r01 + rl );
-        length_type const r01l_cb( r01l * r01l * r01l );
-        length_type const r01_cb( r01 * r01 * r01 );
-        
-        length_type const diss_vec_length( cbrt( X * (r01l_cb - r01_cb) + r01_cb ) );
-        
-        position_type v;
-        v[0] = 1.; v[1] = 1.; v[2] = 1.;
+        // TODO We have to distinguish between sink and cap here and between dissociation onto
+        // the rod and into the bulk/plane!
         
-        position_type const unit_z( base_type::shape().unit_z() );      
-        position_type const unit_x( normalize( subtract( v, 
-                                        multiply( unit_z, dot_product(v, unit_z) ) ) ) );
-        position_type const unit_y( normalize( cross_product( unit_x, unit_z ) ) );
-                
-        length_type const x( diss_vec_length * sin( theta ) * cos( phi ) );
-        length_type const y( diss_vec_length * sin( theta ) * sin( phi ) );
-        length_type const z( diss_vec_length * cos( theta ) );
-                                
-        position_pair_type pp01;
+        // Note: s_disk = disk-bound species, s_diss = dissociating species (may go to bulk or plane)
+                                                 
+        length_type const disk_radius( base_type::shape().radius() );        
+        length_type const r01( s_disk.radius() + s_diss.radius() );
         
-        pp01.first = subtract( op_surf, unit_z * (z * D_surf_D01) );
+        // The following is the additional distance that we have to pass to surface_dissociation_vector() below
+        // to place the unbinding particle in contact with the disk particle or the disk, whatever has the 
+        // larger radius. surface_dissociation_vector() will add it to the disk_radius.
+        length_type offset( s_disk.radius() > disk_radius ? r01 - disk_radius : s_diss.radius());
         
-        pp01.second = add( op_surf, 
-                        add( unit_x * x,
-                          add( unit_y * y, 
-                                 unit_z * (z * D_bulk_D01) ) ) );
+        position_pair_type pp01;        
+        // Particle 0 is the one that stays on the origin structure. It does not move.
+        pp01.first  = reactant_pos;
+        // Particle 1 is the one that unbinds from the disk and is placed in the reaction volume around it.
+        pp01.second = add(reactant_pos, surface_dissociation_vector(rng, offset, rl));
         
         return pp01;
     }
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index e6004c12..d38feb14 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -430,7 +430,9 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
-
+    
+    // Here offset should be the radius of the product species
+    
     position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
     position_type new_pos( add(old_pos, displacement) );
     // TODO assert that new_pos is in target_structure
@@ -523,10 +525,14 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
 
-    /*** COMBINATION NOT SUPPORTED ***/
-    throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Plane).");
+    // Treated in the same way as unbinding from disk to bulk (see above)
+    // Here offset should be the radius of the product species
     
-    return std::make_pair(position_type(), structure_id_type());
+    position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
+    position_type new_pos( add(old_pos, displacement) );
+    // TODO assert that new_pos is in target_structure
+    
+    return std::make_pair(new_pos, target_structure.id());
 };
 
 /*****************************/

From f942817bed8890f8020fbf2d8648f83f9cf8181b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 Oct 2013 15:48:16 +0200
Subject: [PATCH 1431/1541] Introduce MINIMAL_SEPARATION_FACTOR into BD mode
 (via Defs.hpp)

---
 Defs.hpp        | 3 +++
 DiskSurface.hpp | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/Defs.hpp b/Defs.hpp
index 59adb376..1289b283 100644
--- a/Defs.hpp
+++ b/Defs.hpp
@@ -22,4 +22,7 @@ typedef size_t Index;
 
 #define IGNORE_RETURN (void)
 
+const Real SEPARATION_TOLERANCE( 1e-07  );
+const Real MINIMAL_SEPARATION_FACTOR( 1.0 + 1e-07 );
+
 #endif // __DEFS_HPP
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index e669f668..91b393bc 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -138,7 +138,7 @@ class DiskSurface
         v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
          
         // Return the created vector with the right length
-        return multiply( v, (1.0 + 1e-7) * diss_vec_length);
+        return multiply( v, MINIMAL_SEPARATION_FACTOR * diss_vec_length);
                // TODO define a global MINIMAL_SEPARATION_FACTOR also for BD mode
     }
     

From 48a1a856a440d43efe8c859082ca87d73fd7464d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 Oct 2013 15:48:47 +0200
Subject: [PATCH 1432/1541] Ignore structure overlap checks for static
 particles in BD mode

This is a (arguably ugly) workaround to ignore the cylinder touching
a disk at the interface between plane and cylinder. Since for now all
static particles are located on disks, they have to ignore the associated
cylinders.

Of course, checking whether the particle is immobile is just a secondary
criterion to filter out these cases. It will do the job for now, but
on the long term we want a better solution (i.e. explicitly find the
closest cylinder!)
---
 newBDPropagator.hpp | 47 ++++++++++++++++++++++++++++++++-------------
 1 file changed, 34 insertions(+), 13 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 422789f4..147294e1 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -2,6 +2,7 @@
 #define NEW_BD_PROPAGATOR_HPP
 
 #include <algorithm>
+#include <string>
 #include <boost/bind.hpp>
 #include <boost/lexical_cast.hpp>
 #include <boost/range/size.hpp>
@@ -483,6 +484,8 @@ class newBDPropagator
                         const structure_id_type                         parent_structure_id( reactant_structure->structure_id() );
                         const boost::shared_ptr<const structure_type>   parent_structure( tx_.get_structure( parent_structure_id ) );
                         const species_type                              product_species( tx_.get_species(products[0]) );
+                        structure_id_type                               product_structure_id( reactant_structure_id );
+                                                                        //default case, may be altered below
                         
                         // Set default values for the position and structure of the product
                         // As a default, the product stays on the structure of origin
@@ -533,27 +536,29 @@ class newBDPropagator
                             // Apply boundary conditions
                             product_pos_struct_id = tx_.apply_boundary( new_pos_sid_pair );                            
                             
-                            // Particle is allowed to move after dissociation from surface. TODO Isn't it allways allowed to move?
+                            // Particle is allowed to move after dissociation from surface. TODO Isn't it always allowed to move?
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
 
                         //// 2- CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos_struct_id.first, product_species.radius());
-                        // check for overlap with particles that are inside the propagator
+                        // Check for overlap with particles that are inside the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
                                 tx_.check_overlap(new_shape, pp.first));
                         if (overlap_particles && overlap_particles->size() > 0)
                         {
                             throw propagation_error("no space due to other particle");
                         }
-                        // check overlap with surfaces
+                        // Check overlap with surfaces
+                        // Ignore reactant and product structure
                         const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
-                                tx_.check_surface_overlap(new_shape, reactant_pos, product_pos_struct_id.second, product_species.radius(), reactant_structure_id ));
+                                tx_.check_surface_overlap(new_shape, reactant_pos, product_pos_struct_id.second, product_species.radius(), 
+                                                                                   reactant_structure_id, product_structure_id ));
                         if (overlap_surfaces && overlap_surfaces->size() > 0)
                         {
                             throw propagation_error("no space due to near surface");
                         }
-                        // check for overlap with particles outside of the propagator (for example the eGFRD simulator)
+                        // Check for overlap with particles outside of the propagator (for example the eGFRD simulator)
                         if (vc_)
                         {
                             if (!(*vc_)(new_shape, pp.first))
@@ -659,12 +664,13 @@ class newBDPropagator
                         /* Create positions (np0, np1) for the reaction products. 
                         The iv between the products lies within the reaction volume. */
                         int i (max_retry_count_);
+                        std::string error_message;
                         while (true)
                         {
                             // Escape clause #1: Too many tries
                             if (i-- == 0)
                             {
-                                throw propagation_error("no space due to particle or surface");
+                                throw propagation_error(error_message);
                             }
                         
                             //// 1a - GENERATE POSITIONS AND STRUCTURE IDs FOR PRODUCT PARTICLES AFTER REACTION
@@ -704,32 +710,47 @@ class newBDPropagator
 
 
                             //// 1b - CHECK FOR OVERLAPS
+                            // Re-query positions, structure IDs + structures (may have changed after apply boundary)
+                            product0_struct_id = pos0pos1_pair.first.second;
+                            product1_struct_id = pos0pos1_pair.second.second;
+                            const boost::shared_ptr<const structure_type> product0_struct( tx_.get_structure(product0_struct_id) );
+                            const boost::shared_ptr<const structure_type> product1_struct( tx_.get_structure(product1_struct_id) );
+                            const bool product0_mobile (product0_species.D()>0.0 or product0_species.v()>0);
+                            const bool product1_mobile (product1_species.D()>0.0 or product1_species.v()>0);
+                            // Now check
                             const particle_shape_type new_shape0(pos0pos1_pair.first.first, product0_species.radius());
-                            // check overlap with particle in the propagator
+                            // Check overlap with particles in the propagator
                             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product0(
-                                    tx_.check_overlap( new_shape0,  pp.first));
+                                                                                                  tx_.check_overlap( new_shape0,  pp.first));
                             if (overlap_particles_product0 && overlap_particles_product0->size() > 0)
                             {
+                                error_message = "no space for product0 due to particle overlap";
                                 continue;   // try other positions pair
                             }
                             /* Only when both products live in the bulk, check for possible overlap with a surface. */
                             const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product0(
-                                    tx_.check_surface_overlap(new_shape0, reactant_pos, pos0pos1_pair.first.second, product0_species.radius()));
-                            if (overlap_structures_product0 && overlap_structures_product0->size() > 0)
+                                    tx_.check_surface_overlap(new_shape0, reactant_pos, product0_struct_id, product0_species.radius(), 
+                                                                                        product0_struct_id, product1_struct_id ) );
+                            if (overlap_structures_product0 && overlap_structures_product0->size() > 0 && product0_mobile)
                             {
+                                error_message = "no space for product0 due to surface overlap";
                                 continue;   // try other positions pair
                             }
+                            // Same for the other particle
                             const particle_shape_type new_shape1(pos0pos1_pair.second.first, product1_species.radius());
                             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product1(
-                                    tx_.check_overlap( new_shape1, pp.first));
+                                                                                                  tx_.check_overlap( new_shape1, pp.first));
                             if (overlap_particles_product1 && overlap_particles_product1->size() > 0)
                             {
+                                error_message = "no space for product1 due to particle overlap";
                                 continue;   // try other positions pair
                             }
                             const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product1(
-                                    tx_.check_surface_overlap(new_shape1, reactant_pos, pos0pos1_pair.second.second, product1_species.radius()));
-                            if (overlap_structures_product1 && overlap_structures_product1->size() > 0)
+                                    tx_.check_surface_overlap(new_shape1, reactant_pos, product1_struct_id, product1_species.radius(),
+                                                                                        product0_struct_id, product1_struct_id) );
+                            if (overlap_structures_product1 && overlap_structures_product1->size() > 0 && product1_mobile)
                             {
+                                error_message = "no space for product1 due to surface overlap";
                                 continue;   // try other positions pair
                             }
                                                         

From a5ee314bc04b98526c8a8207e89f7b6c09fcd580 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 2 Oct 2013 18:10:10 +0200
Subject: [PATCH 1433/1541] Minor change

---
 Defs.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Defs.hpp b/Defs.hpp
index 1289b283..5a4e6e11 100644
--- a/Defs.hpp
+++ b/Defs.hpp
@@ -23,6 +23,6 @@ typedef size_t Index;
 #define IGNORE_RETURN (void)
 
 const Real SEPARATION_TOLERANCE( 1e-07  );
-const Real MINIMAL_SEPARATION_FACTOR( 1.0 + 1e-07 );
+const Real MINIMAL_SEPARATION_FACTOR( 1.0 + SEPARATION_TOLERANCE );
 
 #endif // __DEFS_HPP

From e09985f0f968160d39fd7693d1c2400983b262da Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 Oct 2013 13:00:36 +0200
Subject: [PATCH 1434/1541] More debug info for multis

---
 Multi.hpp | 14 ++++++++++----
 multi.py  |  3 +++
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/Multi.hpp b/Multi.hpp
index 196cf52d..91e7f42e 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -355,6 +355,8 @@ class MultiParticleContainer
                 // Note that the 0.1 prefactor is to ensure that we pick the convective
                 // timescale only when the movement is clearly dominated by convection,
                 // i.e. when both timescales are comparable we prefer the diffusion timescale.
+                if(tau_dominant == tau_D){ LOG_DEBUG(("Diffusion dominates on given reaction length"));}
+                else                     { LOG_DEBUG(("Convection dominates on given reaction length"));    }
             }
             
             // Now compare if within the current set of species this is the smallest time scale.
@@ -550,13 +552,17 @@ class MultiParticleContainer
             // which requires it to be very small!
             dt_temp = 2. * Pacc_max * step_size_factor * r_min / k_max;
             dt = std::min( dt_temp, tau_Dv ); // tau_Dv is upper limit of dt.
+            
+            if(dt == tau_Dv){ LOG_DEBUG(("Time step set by timescale of motion"));  }
+            else            { LOG_DEBUG(("Time step set by largest reaction rate, k_max = %e, r_min = %e", k_max, r_min));}
         }
         else
-            dt = tau_Dv;
-        
-        //LOG_DEBUG(("tau_Dv = %g, tau_k = %g, k_max = %g, r_min = %g, ssf = %g", tau_Dv, dt_temp, k_max, r_min, step_size_factor)); TODO Cleanup
+            dt = tau_Dv;        
         
-        if( dt < dt_hardcore_min )      dt = dt_hardcore_min;
+        if( dt < dt_hardcore_min ){
+          dt = dt_hardcore_min;
+          LOG_WARNING(("Setting timestep to hard-coded minimal bound, dt = %e", dt));
+        }
 
         return real_pair(dt, step_size_factor * r_min);
     }
diff --git a/multi.py b/multi.py
index a67df435..4a689a72 100644
--- a/multi.py
+++ b/multi.py
@@ -39,6 +39,9 @@ def initialize(self, t):
         self.start_time = t
         main = self.main()
         self.set_dt_and_reaction_length()
+        if __debug__:
+            log.info("multi: initialized with time step = %s and reaction length = %s" %
+                     (self.dt, self.reaction_length))
 
     def calculate_bd_dt(species_list):
         D_list = []

From d784ba7c0b339feb14b192691854dd15419fa4aa Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 Oct 2013 13:00:52 +0200
Subject: [PATCH 1435/1541] Ignore surface overlaps for all immobile particles
 in Multis

As mentioned before, this is a workaround for now.

We need to teach the BD propagator to find the closest cylinder of
a particle in order to fix this properly.
---
 newBDPropagator.hpp | 179 ++++++++++++++++++++++++++++----------------
 1 file changed, 116 insertions(+), 63 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index 147294e1..b6c28c98 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -124,6 +124,7 @@ class newBDPropagator
         // inside the 'attempt_single_reaction' function.
         try
         {
+            /*** ATTEMPT MONOMOLECULAR REACTION ***/
             if (attempt_single_reaction(pp))
                 return true;
         }
@@ -146,11 +147,11 @@ class newBDPropagator
         // First treat special cases.
         // Particles that are immobile cannot move nor hit another particle,
         // so exit immediately if this is the case
-        if(pp.second.D() == 0.0 && pp.second.v() == 0.0) // particle is immobile
-        {
-            LOG_DEBUG(("particle is immobile (D=0, v=0), no further action"));
-            return true;
-        }     
+//         if(pp.second.D() == 0.0 && pp.second.v() == 0.0) // particle is immobile
+//         {
+//             LOG_DEBUG(("particle is immobile (D=0, v=0), no further action"));
+//             return true;
+//         } // FIXME
 
         // OK, we seem to be in the regular case. Continue.
         
@@ -164,21 +165,26 @@ class newBDPropagator
         // declare variables to use
         position_type                   new_pos(old_pos);
         structure_id_type               new_structure_id( old_struct_id );
+        bool                            immobile( true );
 
         /*** 3.2 DISPLACEMENT TRIAL ***/
         /* Sample a potential move, and check if the particle _core_ has overlapped with another 
            particle or surface. If this is the case the particle bounces, and is returned
-           to it's original position. For a particle with D = 0, new_pos = old_pos 
-           Note that apply_boundary takes care of instant transitions between structures of the same
-           structure_type. */        
-        if (pp_species.D() != 0.0)
+           to its original position. For immobile particles with D = 0 and v=0, new_pos = old_pos.
+           Note that apply_boundary takes care of instant transitions between structures of 
+           the same structure_type.
+        */
+        if (pp_species.D() != 0.0 || pp_species.v() != 0.0)
         {
-            // get a new position, dependent on the structure the particle lives on.
+            immobile = false;
+            
+            // Get a new position on the structure that the particle lives on.
             const position_type displacement( pp_structure->bd_displacement(pp_species.v() * dt_,
                                                                             std::sqrt(2.0 * pp_species.D() * dt_),
                                                                             rng_) );
-
+            // Apply boundary conditions
             const position_structid_pair_type pos_structid(tx_.apply_boundary( std::make_pair( add(old_pos, displacement), old_struct_id )));
+            // Remember new position and structure ID
             new_pos = pos_structid.first;
             new_structure_id = pos_structid.second;
         }
@@ -222,7 +228,11 @@ class newBDPropagator
             // restore old position and structure_id
             new_pos = old_pos;
             new_structure_id = old_struct_id;
-            LOG_DEBUG( ("particle bounced, restoring old position and structure id.") ); // TESTING
+            
+            if( immobile ){
+                LOG_DEBUG( ("particle immobile, using old position and structure id.") );}
+            else{
+                LOG_DEBUG( ("particle bounced, restoring old position and structure id.") );}
             
             // re-get the reaction partners (particles), now on old position.
             boost::scoped_ptr<particle_id_pair_and_distance_list> overlap_particles_after_bounce( 
@@ -292,6 +302,8 @@ class newBDPropagator
                     {
                         LOG_DEBUG( ("fire surface interaction with surface %s.",
                                     boost::lexical_cast<std::string>(overlap_struct.first.first).c_str()) );
+                                    
+                        /*** ATTEMPT INTERACTION ***/
                         if(attempt_interaction(pp, new_pos_projected.first, overlap_struct.first.second ))
                             return true;
                     }   
@@ -304,14 +316,14 @@ class newBDPropagator
                         // prob. increment zero there.
                         // Conceptually this means that the prob. for the reaction that was just attempted
                         // and failed was zero in the first place (due to lack of space).
-                        log_.info("treating reaction as forbidden and reducing acc. probability by %s", prob_increase);
+                        log_.info("treating reaction as forbidden and reducing acc. probability by %f", prob_increase);
                         accumulated_prob -= prob_increase;
                     }
                     catch (illegal_propagation_attempt const& reason)
                     {
                         log_.info("surface interaction: illegal propagation attempt (reason: %s)", reason.what());
                         ++rejected_move_count_;
-                        log_.info("treating reaction as forbidden and reducing acc. probability by %s", prob_increase);
+                        log_.info("treating reaction as forbidden and reducing acc. probability by %f", prob_increase);
                         accumulated_prob -= prob_increase;
                     }
                 }
@@ -374,6 +386,7 @@ class newBDPropagator
                 LOG_DEBUG(("attempting to fire reaction."));
     		    try
                 {
+                    /*** ATTEMPT INTERPARTICLE REACTION ***/
                     if( attempt_pair_reaction(pp, overlap_particle.first, s0, s1) )
                         return true;
                 }
@@ -540,26 +553,34 @@ class newBDPropagator
                             product_pos_struct_id = make_move(product_species, product_pos_struct_id, pp.first);
                         }
 
-                        //// 2- CHECK FOR OVERLAPS
+                        //// 2 - CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos_struct_id.first, product_species.radius());
                         // Check for overlap with particles that are inside the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
                                 tx_.check_overlap(new_shape, pp.first));
-                        if (overlap_particles && overlap_particles->size() > 0)
+                        if(overlap_particles && overlap_particles->size() > 0)
                         {
                             throw propagation_error("no space due to other particle");
                         }
                         // Check overlap with surfaces
                         // Ignore reactant and product structure
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
-                                tx_.check_surface_overlap(new_shape, reactant_pos, product_pos_struct_id.second, product_species.radius(), 
-                                                                                   reactant_structure_id, product_structure_id ));
-                        if (overlap_surfaces && overlap_surfaces->size() > 0)
+                        const bool product_mobile( product_species.D()>0.0 or product_species.v()>0 );
+                        if( product_mobile )
                         {
-                            throw propagation_error("no space due to near surface");
+                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_surfaces(
+                                    tx_.check_surface_overlap(new_shape, reactant_pos, product_pos_struct_id.second, product_species.radius(), 
+                                                                                       reactant_structure_id, product_structure_id ));
+                            if (overlap_surfaces && overlap_surfaces->size() > 0)
+                            {
+                                throw propagation_error("no space due to near surface");
+                            }
                         }
+                        else
+                          LOG_WARNING(("Skipping surface overlap check for immobile particle."));
+                          // FIXME this is an ugly workaround to make disk particles ignore neighboring cylinders
+                            
                         // Check for overlap with particles outside of the propagator (for example the eGFRD simulator)
-                        if (vc_)
+                        if(vc_)
                         {
                             if (!(*vc_)(new_shape, pp.first))
                             {
@@ -573,7 +594,7 @@ class newBDPropagator
                         const particle_id_pair product_particle( tx_.new_particle(product_species.id(), product_pos_struct_id.second, product_pos_struct_id.first) );
                         
                         // Record changes
-                        if (rrec_)
+                        if(rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(
@@ -717,42 +738,58 @@ class newBDPropagator
                             const boost::shared_ptr<const structure_type> product1_struct( tx_.get_structure(product1_struct_id) );
                             const bool product0_mobile (product0_species.D()>0.0 or product0_species.v()>0);
                             const bool product1_mobile (product1_species.D()>0.0 or product1_species.v()>0);
-                            // Now check
+
+                            /* Now check for overlaps */
                             const particle_shape_type new_shape0(pos0pos1_pair.first.first, product0_species.radius());
-                            // Check overlap with particles in the propagator
+                            // Check for overlap with particles in the propagator
                             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product0(
                                                                                                   tx_.check_overlap( new_shape0,  pp.first));
-                            if (overlap_particles_product0 && overlap_particles_product0->size() > 0)
+                            if(overlap_particles_product0 && overlap_particles_product0->size() > 0)
                             {
                                 error_message = "no space for product0 due to particle overlap";
                                 continue;   // try other positions pair
                             }
-                            /* Only when both products live in the bulk, check for possible overlap with a surface. */
-                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product0(
-                                    tx_.check_surface_overlap(new_shape0, reactant_pos, product0_struct_id, product0_species.radius(), 
-                                                                                        product0_struct_id, product1_struct_id ) );
-                            if (overlap_structures_product0 && overlap_structures_product0->size() > 0 && product0_mobile)
-                            {
-                                error_message = "no space for product0 due to surface overlap";
-                                continue;   // try other positions pair
+                            // Check for possible overlap with a surface, ignoring the product structures
+                            if( product0_mobile ){
+                              
+                                const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product0(
+                                        tx_.check_surface_overlap(new_shape0, reactant_pos, product0_struct_id, product0_species.radius(), 
+                                                                                            product0_struct_id, product1_struct_id ) );                                                                                        
+                                if(overlap_structures_product0 && overlap_structures_product0->size() > 0)
+                                {
+                                    error_message = "no space for product0 due to surface overlap";
+                                    continue;   // try other positions pair
+                                }
                             }
-                            // Same for the other particle
+                            else
+                              LOG_WARNING(("Skipping surface overlap check for immobile particle."));
+                                  // FIXME this is an ugly workaround to make disk particles ignore neighboring cylinders
+                              
+                            /* Same for the other particle */
                             const particle_shape_type new_shape1(pos0pos1_pair.second.first, product1_species.radius());
                             const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles_product1(
                                                                                                   tx_.check_overlap( new_shape1, pp.first));
-                            if (overlap_particles_product1 && overlap_particles_product1->size() > 0)
+                            // Particle overlaps
+                            if(overlap_particles_product1 && overlap_particles_product1->size() > 0)
                             {
                                 error_message = "no space for product1 due to particle overlap";
                                 continue;   // try other positions pair
                             }
-                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product1(
-                                    tx_.check_surface_overlap(new_shape1, reactant_pos, product1_struct_id, product1_species.radius(),
-                                                                                        product0_struct_id, product1_struct_id) );
-                            if (overlap_structures_product1 && overlap_structures_product1->size() > 0 && product1_mobile)
-                            {
-                                error_message = "no space for product1 due to surface overlap";
-                                continue;   // try other positions pair
+                            // Surface overlaps
+                            if( product1_mobile ){
+                              
+                                const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures_product1(
+                                        tx_.check_surface_overlap(new_shape1, reactant_pos, product1_struct_id, product1_species.radius(),
+                                                                                            product0_struct_id, product1_struct_id) );                                                                                        
+                                if(overlap_structures_product1 && overlap_structures_product1->size() > 0)
+                                {
+                                    error_message = "no space for product1 due to surface overlap";
+                                    continue;   // try other positions pair
+                                }
                             }
+                            else
+                                LOG_WARNING(("Skipping surface overlap check for immobile particle."));
+                                    // FIXME this is an ugly workaround to make disk particles ignore neighboring cylinders
                                                         
                             //// 1c - CHECK FOR PLANE CROSSINGS
                             // first determine which one is the largest involved particle radius
@@ -973,22 +1010,30 @@ class newBDPropagator
 
                         //// 2 - CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos, product_species.radius());
-                        // check for overlap with particles that are inside the propagator
+                        // Check for overlap with particles that are inside the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
                                 tx_.check_overlap(new_shape, pp0.first, pp1.first));
                         if( overlap_particles && overlap_particles->size() > 0 )
                         {
                             throw propagation_error("no space due to particle");
                         }
-                        // Check overlap with surfaces                        
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
-                                tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius(), 
-                                                                                  reactant0_structure_id, reactant1_structure_id  ));
-                        if (overlap_structures && overlap_structures->size() > 0)
-                        {
-                            throw propagation_error("no space due to near surface");
+                        // Check for overlap with surfaces, ignoring the reactant structures
+                        bool product_mobile( product_species.D() > 0.0 or product_species.v() > 0.0 );
+                        if( product_mobile ){
+                          
+                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
+                                    tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius(), 
+                                                                                      reactant0_structure_id, reactant1_structure_id  ));
+                            if(overlap_structures && overlap_structures->size() > 0)
+                            {
+                                throw propagation_error("no space due to near surface");
+                            }
                         }
-                        // check for overlap with particles outside of the propagator (for example the eGFRD simulator)
+                        else
+                            LOG_WARNING(("Skipping surface overlap check for immobile particle."));
+                                // FIXME this is an ugly workaround to make disk particles ignore neighboring cylinders
+                                
+                        // Check for overlap with particles outside of the propagator (for example the eGFRD simulator)
                         if( vc_ )
                         {
                             if (!(*vc_)(new_shape, pp0.first, pp1.first))
@@ -1095,23 +1140,31 @@ class newBDPropagator
 
                         //// 2 - CHECK FOR OVERLAPS
                         const particle_shape_type new_shape(product_pos, product_species.radius());
-                        // check for overlap with particles that are in the propagator
+                        // Check for overlap with particles that are in the propagator
                         const boost::scoped_ptr<const particle_id_pair_and_distance_list> overlap_particles(
                             tx_.check_overlap(new_shape, pp.first));
-                        if (overlap_particles && overlap_particles->size() > 0)
+                        if(overlap_particles && overlap_particles->size() > 0)
                         {
                             throw propagation_error("no space");
                         }
-                        // check overlap with structures.
-                        // ignore reactant_structures when checking for overlaps
-                        const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
-                                tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius(), reactant_structure_id));
-                        if (overlap_structures && overlap_structures->size() > 0)
-                        {
-                            throw propagation_error("no space due to near surface");
+                        // Check overlap with structures, ignoring reactant_structures          
+                        const bool product_mobile( product_species.D()>0.0 or product_species.v()>0 );
+                        if( product_mobile ){
+                          
+                            const boost::scoped_ptr<const structure_id_pair_and_distance_list> overlap_structures(
+                                    tx_.check_surface_overlap(new_shape, product_pos, product_structure_id, product_species.radius(), reactant_structure_id));
+                                    
+                            if(overlap_structures && overlap_structures->size() > 0 && product_mobile)
+                            {
+                                throw propagation_error("no space due to near surface");
+                            }
                         }
+                        else
+                            LOG_WARNING(("Skipping surface overlap check for immobile particle."));
+                                // FIXME this is an ugly workaround to make disk particles ignore neighboring cylinders
+                        
                         // check for overlap with particles outside of the propagator (e.g. the eGFRD simulator)
-                        if (vc_)
+                        if(vc_)
                         {
                             if (!(*vc_)(new_shape, pp.first))
                             {
@@ -1124,7 +1177,7 @@ class newBDPropagator
                         // Make new particle in interaction structure 
                         const particle_id_pair product_particle( tx_.new_particle(product_species.id(), product_structure_id, product_pos) );
                         // Record changes
-                        if (rrec_)
+                        if(rrec_)
                         {
                             (*rrec_)(
                                 reaction_record_type(

From e80bc38265fc7d32e793225d738436baa9829b7a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 Oct 2013 13:02:07 +0200
Subject: [PATCH 1436/1541] Activate hardcore BD limit and overlap remover +
 more info output in egfrd.py

---
 egfrd.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 4b0fb9bf..c826a4ac 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -269,12 +269,12 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
         self.BD_ONLY_FLAG = False               # Will force the algorithm into Multi-creation, i.e. always to use BD
                                                 # Take care: This is for testing only! Keep this 'False' for normal sims!
 
-        self.BD_DT_HARDCORE_MIN = -1e-9         # This is to define a hardcore lower bound for the timestep that will be
+        self.BD_DT_HARDCORE_MIN = +1e-9         # This is to define a hardcore lower bound for the timestep that will be
                                                 # dynamically determined by the new BD scheme. It will prevent the algorithm
                                                 # to calculate ridiculously small timesteps, but will break detail balance.
                                                 # Take care: This is for testing only! Keep this at a negative value for normal sims!
 
-        self.REMOVE_OVERLAPS = False            # Ignore overlaps, only warn when they happen and move particles apart
+        self.REMOVE_OVERLAPS = True             # Ignore overlaps, only warn when they happen and move particles apart
         self.max_overlap_error = 0.0            # This remembers the largest relative error produced by removing overlaps
 
         # used datastructrures
@@ -2787,7 +2787,7 @@ def form_multi(self, single, multi_partners):
                 log.debug('add_to_multi: object(%s) is surface, not added to multi.' % partner)
 
 
-        # 3. Initialize the multi and (re-)schedule
+        # 3. Initialize the multi and (re-)schedule        
         multi.initialize(self.t)
         if isinstance(closest, Multi):
             # Multi existed before
@@ -2975,6 +2975,7 @@ def print_report(self, out=None):
 \tPair:\t%d\t(%.2f %%)\t(r-escape: %d, R-escape: %d, reaction pair: %d, single: %d, bursted: %d)
 \tMulti:\t%d\t(%.2f %%)\t(diffusion: %d, escape: %d, reaction pair: %d, single: %d, bursted: %d)
 \tavg. multi time step: %e, avg. multi reaction length: %e
+\tmulti hardcore time step minimum: %s
 total reactions:     %d
 rejected moves:      %d
 overlap remover was: %s
@@ -3009,6 +3010,7 @@ def print_report(self, out=None):
                self.multi_steps[EventType.BURST],
                avg_multi_time,
                avg_multi_rl,
+               ('inactive' if self.BD_DT_HARDCORE_MIN < 0.0 else self.BD_DT_HARDCORE_MIN),
                self.reaction_events,
                self.rejected_moves,
                ('active' if self.REMOVE_OVERLAPS else 'inactive'),

From 48bbcbdd751029e16d66f36468ba41369bd74106 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 3 Oct 2013 17:04:52 +0200
Subject: [PATCH 1437/1541] Remove costly debug statement

---
 egfrd.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index c826a4ac..759dadcd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1941,8 +1941,7 @@ def make_new_domain(self, single):
                 if (isinstance (domain, NonInteractionSingle) and domain.is_reset()):
                     multi_horizon = (single_radius + domain.pid_particle_pair[1].radius) * MULTI_SHELL_FACTOR
                     distance = self.world.distance(single_pos, domain.shell.shape.position)
-                    multi_partners.append((domain, distance - multi_horizon))
-                    log.debug('domain = %s, multi_horizon = %s' % (domain, multi_horizon))
+                    multi_partners.append((domain, distance - multi_horizon))                    
 
                 elif isinstance(domain, Multi):
                     # The dist_to_shell = dist_to_particle - multi_horizon_of_target_particle

From 36f0913b6954e3017cf6bc81fd844b21d021f648 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 Oct 2013 12:40:14 +0200
Subject: [PATCH 1438/1541] Allow user to specify time delay when reloading
 saved state

---
 egfrd.py | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 759dadcd..7f040f7c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -69,6 +69,7 @@
 
 import loadsave
 from histograms import *
+from time import sleep
 
 import logging
 log = logging.getLogger('ecell')
@@ -3624,7 +3625,7 @@ def check(self):
     # These are just wrappers around the methods
     # in loadsave.py :
 
-    def save_state(self, filename, reload=False):
+    def save_state(self, filename, reload=False, delay=0.0):
         """ Save the state of the simulator after bursting
             all domains. The latter facilitates reconstruction
             of precisely the state saved.
@@ -3643,10 +3644,22 @@ def save_state(self, filename, reload=False):
                          Python float precision.
 
                          reload = False by default.
+
+            - [delay] :  (optional) remain idle for a
+                         certain amount of seconds defined
+                         by this parameter before reloading the 
+                         saved state. This may be useful to avoid
+                         reloading of a file which has not yet
+                         been completely written.
+                         Only has an effect when reload = True.                         
         """
         loadsave.save_state(self, filename)
 
         if(reload):
+        
+            if(delay > 0.0):
+                    sleep(delay)
+
             self.load_state(filename)
 
 

From 032c116f9cec31409fd139c9642d010247686b26 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 Oct 2013 17:02:51 +0200
Subject: [PATCH 1439/1541] Some fixes in shellmaking for cylindrical domains

- Prevent construction of massively asymmetric domains that make
use of the 1D Green's function with drift to prevent convergence
problems (we have to fix the convergence issues anyhow, but for
now this measure will help to make sims more stable; the same
principle was applied before when sampling from the 2D GF in
situations in which the particle is very close to either the
radiating or absorbing boundary.) The maximal shell size
for the 1D pair is an educated guess for now, we have to improve
this by calculating what an appropriate size is.

- Check that particles are not already on the disk when attempting
to form a PlanarSurfaceDiskSurfaceInteraction (otherwise it will
do so when creation of Cyl.SurfacePlanarSurfaceIntermediateSingle
does not work out.)

- Some fixes in shellscaling for Cyl.SurfacePlanarSurfaceIntermediateSingle
---
 shells.py | 47 +++++++++++++++++++++++++++++++++++++----------
 1 file changed, 37 insertions(+), 10 deletions(-)

diff --git a/shells.py b/shells.py
index 8222818e..fb9131dd 100755
--- a/shells.py
+++ b/shells.py
@@ -2450,8 +2450,10 @@ def get_min_dr_dzright_dzleft(self):
 
     def get_max_dr_dzright_dzleft(self):
         dr          = self.dr_const
-#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink
-        dz_right_sr = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+#        dz_right_edge = self.structure.min_dist_proj_to_edge(self.get_referencepoint())    # TODO rethink        
+        dz_right_sr = min( 5.0*self.sigma, math.sqrt((self.get_searchradius())**2 - dr**2) )
+                      # stay within the searchradius and do not produce domains in which the inner IV boundary
+                      # is much closer than the outer (absorbing) IV boundary to ensure convergence of the GF # FIXME improve this!
 #        dz_right    = min(dz_right_sr, dz_right_edge)
         dz_right    = dz_right_sr
         dz_left     = dz_right
@@ -2532,6 +2534,10 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
+        if feq(self.particle_surface_distance, 0.0, typical=self.target_structure.shape.radius) \
+           or self.particle_surface_distance < 0.0:
+            raise testShellError('(CylindricalSurfaceInteraction). Zero or negative particle-surface distance, value = %s.' % self.particle_surface_distance)
+
         # initialize scaling parameters
         self.dzdr_right = 1.0
         self.drdz_right = 1.0
@@ -2602,7 +2608,12 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         assert isinstance(target_structure, DiskSurface)
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
-        
+
+        if feq(self.particle_surface_distance, 0.0, typical=self.target_structure.shape.radius) \
+           or self.particle_surface_distance < 0.0:
+            raise testShellError('(PlanarSurfaceDiskSurfaceInteractiontestShell). Zero or negative particle-surface distance, value = %s. Particle is most likely already on the disk.' \
+                                                                                  % self.particle_surface_distance                                                                      )
+
         # Initialize the scaling parameters
         # These are copied from PlanarSurfacePairtestShell
         self.dzdr_right = 0.0
@@ -2702,7 +2713,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.dzdr_left  = numpy.inf
         self.drdz_left  = 0.0
         self.r0_left    = self.dr_const
-        self.z0_left    = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        self.z0_left    = self.get_const_z_left()
 
         # Now we can also define the scaling angle
         self.right_scalingangle = self.get_right_scalingangle()
@@ -2736,17 +2747,23 @@ def get_referencepoint(self):
 
     def get_min_dr_dzright_dzleft(self):
         dr       = self.dr_const
-        dz_left  = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+        dz_left  = self.get_const_z_left()
         dz_right = self.particle_surface_distance + self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
         return dr, dz_right, dz_left
         
     def get_max_dr_dzright_dzleft(self):
         dr       = self.dr_const
-        dz_left  = self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0) # same as the minimum, i.e. no scaling of this length
+        dz_left  = self.get_const_z_left() # same as the minimum and initial value, i.e. no scaling of this length
         # TODO include max distance to other side of rod?
-        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance  # stay within the searchradius
+        dz_right = min( 3.0*dz_left, math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance)
+                   # stay within the searchradius and do not allow for terribly asymmetric domains
+                   # in order to prevent convergence problems with the 1D RadAbs GF
         return dr, dz_right, dz_left
 
+    def get_const_z_left(self):
+        # This defines how far the shell extends "outwards" from the rod, i.e. behind the cap
+        return self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
+
     def apply_safety(self, r, z_right, z_left):
         return r, z_right/SAFETY, z_left
 
@@ -2840,8 +2857,8 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
 
         # Override the shellsize determined for CylindricalSurfacePlanarSurfaceInteractionSingletestShell
         # This one has the size of a zero single; the scaling parameters can stay the same, since we are not scaling anyhow
-        self.dz_right = self.pid_particle_pair[1].radius
-        self.dz_left  = self.pid_particle_pair[1].radius
+        self.dz_left  = self.get_const_z_left()
+        self.dz_right = self.dz_left
         self.dr       = self.pid_particle_pair[1].radius
 
     def get_searchpoint(self):
@@ -2856,6 +2873,7 @@ def get_orientation_vector(self):
 
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
+        log.info('Running local get_min_dr_dzright_dzleft')
         dr       = self.dr_const
         dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
@@ -2863,11 +2881,18 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         # Radius is not scaled here so we do not to check for distance to shape edge
+        log.info('Running local get_max_dr_dzright_dzleft')
         dr       = self.dr_const
         dz_right = self.pid_particle_pair[1].radius # same as the minimum, i.e. no scaling of this length
         dz_left  = dz_right
         return dr, dz_right, dz_left
 
+    def get_const_z_left(self):
+        # This defines how far the shell extends "outwards" from the rod, i.e. behind the cap
+        # This method is used in the parent class to define some scaling parameters, which 
+        # slightly differ here.
+        return self.pid_particle_pair[1].radius
+
     def set_structure_ignore_list(self):
 
         # In this special domain we want to ignore the (disk) target structure and the cylinder that
@@ -3251,7 +3276,9 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dr       = self.dr_const
         dz_left  = self.static_particle.radius * SINGLE_SHELL_FACTOR # same as the minimum, i.e. no scaling of this length
-        dz_right = math.sqrt((self.get_searchradius())**2 - dr**2) # stay within the searchradius
+        dz_right = min( 3.0*dz_left, math.sqrt((self.get_searchradius())**2 - dr**2))
+                   # stay within the searchradius and do not allow for terribly asymmetric domains
+                   # in order to prevent convergence problems with the 1D RadAbs GF
         return dr, dz_right, dz_left
 
     def apply_safety(self, r, z_right, z_left):

From 342f7744387e44a93515221349a3dc4cad30b8d3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 14 Oct 2013 17:07:50 +0200
Subject: [PATCH 1440/1541] Cleanup

---
 shells.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/shells.py b/shells.py
index fb9131dd..7476ed64 100755
--- a/shells.py
+++ b/shells.py
@@ -2873,7 +2873,6 @@ def get_orientation_vector(self):
 
     def get_min_dr_dzright_dzleft(self):
         # TODO This will never be called, right? Why do dz_right/dz_left have value larger than particle_radius?
-        log.info('Running local get_min_dr_dzright_dzleft')
         dr       = self.dr_const
         dz_right = self.pid_particle_pair[1].radius
         dz_left  = dz_right
@@ -2881,7 +2880,6 @@ def get_min_dr_dzright_dzleft(self):
         
     def get_max_dr_dzright_dzleft(self):
         # Radius is not scaled here so we do not to check for distance to shape edge
-        log.info('Running local get_max_dr_dzright_dzleft')
         dr       = self.dr_const
         dz_right = self.pid_particle_pair[1].radius # same as the minimum, i.e. no scaling of this length
         dz_left  = dz_right

From 5afeb1fba666e069149254b9ed0aae12791dbb54 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 17 Oct 2013 11:25:45 +0200
Subject: [PATCH 1441/1541] Weaken an assert condition in pair.py to allow for
 formation of MixedPair2D3D with a_R = 0; warn instead

---
 pair.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/pair.py b/pair.py
index 609f2386..8ed1888f 100644
--- a/pair.py
+++ b/pair.py
@@ -961,9 +961,10 @@ def determine_radii(self):
             tr = ((a_r - self.r0)**2.0) / (6.0 * self.D_r)  # the expected escape time of the iv
             if self.D_R == 0:
                 tR = numpy.inf 
+                log.warn('determine_radii: infinite diffusion time for CoM, tR = inf, because D_R = 0')
             else:
                 tR = (a_R**2.0) / (4.0 * self.D_R)          # the expected escape time of the CoM
-            log.debug('determine_radii: a_r= %s, tr= %s, a_R= %s, tR= %s, delta_tRr= %s' % \
+            log.debug('determine_radii: a_r = %s, tr = %s, a_R = %s, tR = %s, delta_tRr = %s' % \
                       (FORMAT_DOUBLE % a_r, FORMAT_DOUBLE % tr,
                        FORMAT_DOUBLE % a_R, FORMAT_DOUBLE % tR,
                        FORMAT_DOUBLE % (tr-tR) ))
@@ -972,7 +973,11 @@ def determine_radii(self):
 
         # Some checks that shall never fail        
         assert (self.sigma < a_r) and (a_r < 2.0*shell_half_length * self.z_scaling_factor)
-        assert (0 < a_R) and (a_R < shell_radius)
+        assert (0 <= a_R) and (a_R <= shell_radius)
+        if a_R == 0.0:
+            log.warn('determine_radii: a_R = 0')
+        if a_R == shell_radius:
+            log.warn('determine_radii: a_R = shell_radius')
 
         return a_R, a_r
 

From 1e861a21b14e73e7e322dbd4e16541c1bc45ffc6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 17 Oct 2013 11:43:15 +0200
Subject: [PATCH 1442/1541] Equalize a_R to zero if it is very close to zero

Division can produce small deviations from zero which make the
following asserts fail.
---
 pair.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/pair.py b/pair.py
index 8ed1888f..4f537657 100644
--- a/pair.py
+++ b/pair.py
@@ -955,6 +955,9 @@ def determine_radii(self):
 
         # It then determines the CoM vector bound via
         a_R = shell_radius - space_for_iv
+        if feq(a_R, 0.0, typical=shell_radius):
+            a_R = 0.0
+            log.warn('determine_radii: setting a_R = %s to zero' % str(a_R))
 
         # Print the domain sizes and their estimated first passage times.
         if __debug__:

From 71132cda20e12bf006668ddc77eb7262b773cc13 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Thu, 17 Oct 2013 18:16:19 +0200
Subject: [PATCH 1443/1541] Allow user to connect edges of parallel structures
 and treat transitions between them accordingly

---
 StructureContainer.hpp | 143 ++++++++++++++++++++++++++++++-----------
 1 file changed, 106 insertions(+), 37 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 136a166a..17fc5df4 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -168,33 +168,72 @@ class StructureContainer
                                     planar_surface_type const& structure2, int const& side2)
     {
         // TODO if the structure are not the same, check that the planes actually touch at the right edge.
-        vector_type structure1_vector;
-        vector_type structure2_vector;
-        // FIXME cleanup code below
-        switch (side1)
-        {
-            case 0: structure1_vector = multiply(structure1.shape().unit_y(), -1.0);
-                break;
-            case 1: structure1_vector = structure1.shape().unit_y();
-                break;
-            case 2: structure1_vector = structure1.shape().unit_x();
-                break;
-            case 3: structure1_vector = multiply(structure1.shape().unit_x(), -1.0);
-                break;
-        }
-        switch (side2)
+        
+        // First check whether the planes are orthogonal or parallel, or none of this.
+        bool planes_are_orthogonal(false);
+        bool planes_are_parallel(false);
+        vector_type structure1_unit_z( structure1.shape().unit_z() );
+        vector_type structure2_unit_z( structure2.shape().unit_z() );
+        
+        if( feq(dot_product(structure1_unit_z, structure2_unit_z), 0.0, 1.0) )
+            planes_are_orthogonal = true;
+        if( feq(dot_product(structure1_unit_z, structure2_unit_z), 1.0, 1.0) )
+            planes_are_parallel = true;
+        // If they are neither parallel or orthogonal we cannot treat this situation and stop here
+        if( not(planes_are_orthogonal or planes_are_parallel) )
+            throw unsupported("StructureContainer: only orthogonal or parallel planes can be connected.");
+        
+        // Now determine which of the unit vectors of the neighboring plane is the one that shall be
+        // used for transforming the position that reaches out of the origin plane. This is relevant
+        // only for the orthogonal case. If the planes are parallel, the position does not have
+        // to be transformed at all (only the StructureID changes).
+        // For parallel planes we therefore return a zero vector below. This at once serves as 
+        // a flag indicating that the planes are indeed parallel.
+        //vector_type zero_vector( zero_vector() );
+        vector_type structure1_vector( vector_type(0.0, 0.0, 0.0) );
+        vector_type structure2_vector( vector_type(0.0, 0.0, 0.0) );
+            // this is already fine for parallel planes
+        
+        if( planes_are_orthogonal )
         {
-            case 0: structure2_vector = multiply(structure2.shape().unit_y(), -1.0);
-                break;
-            case 1: structure2_vector = structure2.shape().unit_y();
-                break;
-            case 2: structure2_vector = structure2.shape().unit_x();
-                break;
-            case 3: structure2_vector = multiply(structure2.shape().unit_x(), -1.0);
-                break;
+            // Side convention for coding neighbors:
+            //
+            //  |-------------|
+            //  |      0      |
+            //  |             |
+            //  | 2         3 |
+            //  |             |
+            //  |      1      |
+            //  |-------------|
+            //
+            // FIXME cleanup code below            
+            switch (side1)
+            {
+                case 0: structure1_vector = multiply(structure1.shape().unit_y(), -1.0);
+                    break;
+                case 1: structure1_vector = structure1.shape().unit_y();
+                    break;
+                case 2: structure1_vector = structure1.shape().unit_x();
+                    break;
+                case 3: structure1_vector = multiply(structure1.shape().unit_x(), -1.0);
+                    break;
+            }
+            switch (side2)
+            {
+                case 0: structure2_vector = multiply(structure2.shape().unit_y(), -1.0);
+                    break;
+                case 1: structure2_vector = structure2.shape().unit_y();
+                    break;
+                case 2: structure2_vector = structure2.shape().unit_x();
+                    break;
+                case 3: structure2_vector = multiply(structure2.shape().unit_x(), -1.0);
+                    break;
+            }
         }
+        
         planar_structs_bc_.set_neighbor_info(structure1.id(), side1, std::make_pair(structure2.id(), structure2_vector) );
         planar_structs_bc_.set_neighbor_info(structure2.id(), side2, std::make_pair(structure1.id(), structure1_vector) );
+        
         return true;
     }
 //    virtual bool connect_structures(cylindrical_surface_type const& structure1, cylindrical_surface_side_type const& side1,
@@ -408,6 +447,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
     typedef typename PlanarSurface<Ttraits_>::shape_type    plane_type;
     typedef typename plane_type::length_type                length_type;
     typedef typename plane_type::position_type              position_type;
+    typedef typename plane_type::position_type              vector_type;
 
     typedef std::pair<structure_id_type, position_type>     neighbor_id_vector_type;
     typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
@@ -420,12 +460,17 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
     const position_type pos_vector( subtract(pos_structure_id.first, origin_plane.position()) );
     const length_type   component_x ( dot_product(pos_vector, origin_plane.unit_x()) );
     const length_type   component_y ( dot_product(pos_vector, origin_plane.unit_y()) );
+    const vector_type   zero_vector( vector_type(0.0, 0.0, 0.0) );
 
     // declare the variables that will be written
-    structure_id_type new_id( pos_structure_id.second );
+    structure_id_type new_id( pos_structure_id.second ); // initialized with old structure ID
     position_type     neighbor_plane_par;
     position_type     neighbor_plane_inl;
     
+    // info variables
+    bool planes_are_orthogonal( false );
+    bool planes_are_parallel( false );    
+    
     // Check for (currently unsupported) self-connections
     for( int i=0; i<4; i++ )
     {
@@ -458,9 +503,15 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
                 const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 0));
 
                 new_id = neighbor_id_vector.first;
-                neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     half_extents[1]),
-                                         multiply(neighbor_id_vector.second, (component_y - half_extents[1]) ) );
+                
+                if(neighbor_id_vector.second == zero_vector)
+                    planes_are_parallel = true;
+                else{
+                    planes_are_orthogonal = true;
+                    neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
+                    neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     half_extents[1]),
+                                            multiply(neighbor_id_vector.second, (component_y - half_extents[1]) ) );
+                }
             }
             else if ( component_y < -half_extents[1] )
             {
@@ -468,9 +519,15 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
                 const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 1));
 
                 new_id = neighbor_id_vector.first;
-                neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     -half_extents[1] ),
-                                         multiply(neighbor_id_vector.second, (-component_y - half_extents[1]) ) );
+                
+                if(neighbor_id_vector.second == zero_vector)
+                    planes_are_parallel = true;
+                else{
+                    planes_are_orthogonal = true;
+                    neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
+                    neighbor_plane_inl = add(multiply(origin_plane.unit_y(),     -half_extents[1] ),
+                                            multiply(neighbor_id_vector.second, (-component_y - half_extents[1]) ) );
+                }
             }
         }
         else // half_extents[1]*abs(component_x) >= half_extents[0]*abs(component_y)
@@ -481,9 +538,14 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
                 const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 2));
 
                 new_id = neighbor_id_vector.first;
-                neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     -half_extents[0]),
-                                         multiply(neighbor_id_vector.second, (-component_x - half_extents[0]) ) );
+                if(neighbor_id_vector.second == zero_vector)
+                    planes_are_parallel = true;
+                else{
+                    planes_are_orthogonal = true;
+                    neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
+                    neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     -half_extents[0]),
+                                            multiply(neighbor_id_vector.second, (-component_x - half_extents[0]) ) );
+                }
             }
             else if ( half_extents[0] < component_x )
             {
@@ -491,13 +553,20 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
                 const neighbor_id_vector_type neighbor_id_vector (sc.get_neighbor_info(planar_surface, 3));
 
                 new_id = neighbor_id_vector.first;
-                neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
-                neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     half_extents[0]),
-                                         multiply(neighbor_id_vector.second, (component_x - half_extents[0]) ) );
+                if(neighbor_id_vector.second == zero_vector)
+                    planes_are_parallel = true;
+                else{
+                    planes_are_orthogonal = true;
+                    neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
+                    neighbor_plane_inl = add(multiply(origin_plane.unit_x(),     half_extents[0]),
+                                            multiply(neighbor_id_vector.second, (component_x - half_extents[0]) ) );
+                }
             }
         }
 
-        const position_type new_pos ( add(origin_plane.position(), add(neighbor_plane_par, neighbor_plane_inl)));
+        position_type new_pos( origin_plane.position() );
+        if(planes_are_orthogonal)
+            new_pos = add(origin_plane.position(), add(neighbor_plane_par, neighbor_plane_inl));
 
         // Check if we are in one of the corners. If yes -> do another round of border crossing from neighboring plane.
         // Only do this if the particle does not end up on another side of the same plane (the scenario of one plane 

From b4e927517f5a1c75eb79d4996e00e2572988ed23 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 18 Oct 2013 15:01:33 +0200
Subject: [PATCH 1444/1541] Some comments and clarifying renamings in distance
 measurement functions

---
 ParticleContainerBase.hpp | 54 ++++++++++++++++++++++-----------------
 PlanarSurface.hpp         |  7 ++---
 Plane.hpp                 | 16 +++++++-----
 3 files changed, 43 insertions(+), 34 deletions(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 46ebc122..fd91530a 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -318,28 +318,30 @@ class ParticleContainerBase
 
     template<typename Tfun_>
     void surface_overlap_checker(particle_shape_type const& s, position_type const& old_pos, structure_id_type const& current,
-                                        length_type const& sigma, Tfun_& checker ) const
+                                 length_type const& sigma, Tfun_& checker ) const
     {
-        const structure_id_set visible_structures (structures_.get_visible_structures(current));
+        const structure_id_set visible_structure_IDs (structures_.get_visible_structures(current));
 
-        // get and temporarily store all the visibles structures (upto now we only had their IDs)
-        structure_map temp_map;
-        for (typename structure_id_set::const_iterator i(visible_structures.begin()),
-                                                       e(visible_structures.end());
+        // Get and temporarily store all the visibles structures (upto now we only had their IDs)
+        structure_map visible_structures;
+        for (typename structure_id_set::const_iterator i(visible_structure_IDs.begin()),
+                                                       e(visible_structure_IDs.end());
              i != e; ++i)
         {
-            temp_map[(*i)] = get_structure(*i);
+            visible_structures[(*i)] = get_structure(*i);
         }
 
-        // calculate the distances and store the surface,distance tuple in the overlap checker if smaller than the particle radius.
-        for (typename structure_map::const_iterator i(temp_map.begin()),
-                                                    e(temp_map.end());
+        // Calculate the distances and store the surface,distance tuple in the overlap checker if smaller than the particle radius.
+        for (typename structure_map::const_iterator i(visible_structures.begin()),
+                                                    e(visible_structures.end());
              i != e; ++i)
         {
-            const position_type cyc_old_pos (cyclic_transpose(old_pos, s.position()));      // The old position transposed towards the new position (which may also be modified by periodic BC's)
-            const position_type displacement (subtract(s.position(), cyc_old_pos));         // the relative displacement from the 'old' position towards the real new position
-            const position_type cyc_pos      (cyclic_transpose(s.position(), ((*i).second)->position()));    // new position transposed to the structure in question
-            const position_type cyc_old_pos2 (subtract(cyc_pos, displacement));             // calculate the old_pos relative to the transposed new position.
+            const position_type cyc_old_pos  ( cyclic_transpose(old_pos, s.position()) ); // The old position transposed towards the new position (which may also be modified by periodic BC's)
+            const position_type displacement ( subtract(s.position(), cyc_old_pos) );     // the relative displacement from the 'old' position towards the real new position
+            const position_type cyc_pos      ( cyclic_transpose(s.position(), ((*i).second)->position()) ); // new position transposed to the structure in question
+            const position_type cyc_old_pos2 ( subtract(cyc_pos, displacement) );         // calculate the old_pos relative to the transposed new position.
+            // This is where the actual distance measurement happens
+            // TODO What precisely does newBD_distance calculate? Clarify!
             const length_type dist((*i).second->newBD_distance(cyc_pos, s.radius(), cyc_old_pos2, sigma));
             if (dist < s.radius())
             {
@@ -438,28 +440,32 @@ class ParticleContainerBase
     }
     
     // Get all structures close to a position pos, taking care of structure types
-    // and an ignore parameter
+    // and an ignore parameter (defining a set of ignored structures)
+    // The actual distance measurement is performed by method structure->distance(cyc_pos) below,
+    // which is implemented in the respective structure (sub-) classes.
     virtual structure_id_pair_and_distance_list* get_close_structures(position_type const& pos, structure_id_type const& current_struct_id,
                                                                       structure_id_type const& ignore) const
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
-        const structure_id_set visible_structures (structures_.get_visible_structures(current_struct_id));
+        
+        const structure_id_set visible_structures (structures_.get_visible_structure_IDs(current_struct_id));
 
-        // get and temporarily store all the visibles structures (upto now we only had their IDs)
-        structure_map temp_map;
-        for (typename structure_id_set::const_iterator i(visible_structures.begin()),
-                                                       e(visible_structures.end());
+        // Get and temporarily store all the visibles structures (upto now we only had their IDs)
+        structure_map visible_structures;
+        for (typename structure_id_set::const_iterator i(visible_structure_IDs.begin()),
+                                                       e(visible_structure_IDs.end());
              i != e; ++i)
         {
-            temp_map[(*i)] = get_structure(*i);
+            visible_structures[(*i)] = get_structure(*i);
         }
 
-        // calculate the distances and store the surface,distance tuple in the overlap checker (in a list is sorted by distance).
-        for (typename structure_map::const_iterator i(temp_map.begin()),
-                                                    e(temp_map.end());
+        // Calculate the distances and store the surface,distance tuple in the overlap checker (in a list is sorted by distance).
+        for (typename structure_map::const_iterator i(visible_structures.begin()),
+                                                    e(visible_structures.end());
              i != e; ++i)
         {
             const position_type cyc_pos(cyclic_transpose(pos, ((*i).second)->position()));
+            // Here we perform the actual distance measurement
             const length_type dist((*i).second->distance(cyc_pos));
             checker(i, dist);
         }
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 599cc987..2597d838 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -220,13 +220,14 @@ class PlanarSurface
         const boost::array<length_type, 2> half_lengths(base_type::shape().half_extent());
         const boost::array<length_type, 3> new_pos_xyz(::to_internal(base_type::shape(), new_pos));
         const boost::array<length_type, 3> old_pos_xyz(::to_internal(base_type::shape(), old_pos));
-        if (new_pos_xyz[2] * old_pos_xyz[2] < 0 &&
+        if (new_pos_xyz[2] * old_pos_xyz[2] < 0 &&            
             ((abs(new_pos_xyz[0]) < half_lengths[0] && abs(new_pos_xyz[1]) < half_lengths[1]) ||
-             (abs(old_pos_xyz[0]) < half_lengths[0] && abs(old_pos_xyz[1]) < half_lengths[1])))
+             (abs(old_pos_xyz[0]) < half_lengths[0] && abs(old_pos_xyz[1]) < half_lengths[1]))
+           ) // If the new and old positions lie on different sides of the plane
         {
             return -1.0 * base_type::distance(new_pos) + sigma;
         }
-        else
+        else // new and old position are on the same side of the plane
         {
             return base_type::distance(new_pos) + sigma;
         }
diff --git a/Plane.hpp b/Plane.hpp
index a2a4734e..06cde4e6 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -254,13 +254,16 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
     typedef typename Plane<T_>::length_type length_type;
     boost::array<length_type, 3> const x_y_z(to_internal(obj, pos));
 
+    // The (negative) distances to the plane edges (in x/y direction)
     length_type const dx(subtract( abs(x_y_z[0]), obj.half_extent()[0]));
     length_type const dy(subtract( abs(x_y_z[1]), obj.half_extent()[1]));
+    // The z-distance (may be positive or negative, depending on the side)
+    length_type const dz( x_y_z[2] );
 
     if (dx < 0 && dy < 0) {
-        // pos is positioned over the plane (projected point is in the plane and
+        // pos is positioned over the plane (projected point is in the plane,
 	// not next to it).
-        return abs(x_y_z[2]);
+        return abs(dz);
     }
 
     if (dx > 0) // outside the plane in the x direction
@@ -268,13 +271,12 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
         if (dy > 0)
         {
             // outside the plane in both x and y direction
-            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(dy) +
-                             gsl_pow_2(x_y_z[2]));
+            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(dy) + gsl_pow_2(dz));
         }
         else
         {
 	    // outside the plane in x, but inside in y direction
-            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(x_y_z[2]));
+            return std::sqrt(gsl_pow_2(dx) + gsl_pow_2(dz));
         }
     }
     else   // inside the plane in x direction
@@ -282,12 +284,12 @@ distance(Plane<T_> const& obj, typename Plane<T_>::position_type const& pos)
         if (dy > 0)
         {
 	    // outside the plane in y, but inside in x direction
-            return std::sqrt(gsl_pow_2(dy) + gsl_pow_2(x_y_z[2]));
+            return std::sqrt(gsl_pow_2(dy) + gsl_pow_2(dz));
         }
         else
         {
             // inside the plane in both x and y direction (see above)
-            return abs(x_y_z[2]);
+            return abs(dz);
         }
     }
 }

From 3f92a5ee0d87cd8e32a94dd10356cc4a565cb19f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 18 Oct 2013 17:31:56 +0200
Subject: [PATCH 1445/1541] Change logger name

---
 StructureContainer.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index 17fc5df4..b6eb4994 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -421,9 +421,9 @@ class StructureContainer
 
 //////// Link logger to the global logging system
 template <typename Tobj_, typename Tid_, typename Ttraits_>
-Logger& StructureContainer<Tobj_, Tid_, Ttraits_>::log_(Logger::get_logger("ecell.newBDPropagator"));
+Logger& StructureContainer<Tobj_, Tid_, Ttraits_>::log_(Logger::get_logger("ecell.StructureContainer"));
 //////// Also define one that can be used by the inline functions below
-static Logger& log_(Logger::get_logger("ecell.newBDPropagator"));
+static Logger& log_(Logger::get_logger("ecell.StructureContainer"));
 
 
 //////// Inline functions applicable to the StructureContainer

From 80ae624e1f7eb38b9c1500df01f876dd33a696a1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 18 Oct 2013 17:49:12 +0200
Subject: [PATCH 1446/1541] Check whether particle is in bounds before applying
 BCs in throw_in_particles()

---
 gfrdbase.py | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 5e23e8a5..f5adec65 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -508,7 +508,7 @@ def create_network_rules_wrapper(model):
     return _gfrd.NetworkRulesWrapper(model.network_rules)
 
 
-def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
+def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0], ignore_structure_overlaps=False):
     """Add n particles of a certain Species to the specified world.
 
     Arguments:
@@ -575,6 +575,15 @@ def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
         myrandom.shuffle(structure_list)
         structure = world.get_structure(structure_list[0])
         position = structure.random_position(myrandom.rng)
+
+        # Check immediately whether the position is out of the bounding box
+        # If yes, discard before applying any boundary conditions
+        out_of_bounds = ( any(position < bound_1) or any(position > bound_2) )
+        if out_of_bounds:
+            log.info('random position rejected. Out of bounding box. I will keep trying.')
+            continue
+
+        # OK, now apply boundary conditions
         position, structure_id = world.apply_boundary((position, structure.id))
 
         # Check overlap. TODO put in 'if' statement for improved efficiency?
@@ -582,14 +591,18 @@ def throw_in_particles(world, sid, n, bound_1=[0,0,0], bound_2=[0,0,0]):
         surface_overlaps  = world.check_surface_overlap((position, species.radius*MINIMAL_SEPARATION_FACTOR),
                                                         position, structure_id, species.radius)
 
+        # Check again whether we are within the imposed bounds
         out_of_bounds = ( any(position < bound_1) or any(position > bound_2) )
 
-        if (not particle_overlaps) and (not surface_overlaps) and (not out_of_bounds):
+        if  ((not particle_overlaps) and ((not surface_overlaps) or ignore_structure_overlaps)) \
+         and (not out_of_bounds):
             # All checks passed. Create particle.
             p = world.new_particle(sid, structure_id, position)
             i += 1
             if __debug__:
                 log.info('particle accepted: (%s,\n %s)' % (p[0], p[1]))
+                if ignore_structure_overlaps:
+                    log.warn('explicitly ignoring structure overlaps.')
         elif __debug__:
             if particle_overlaps:
                 log.info('\t%d-th particle rejected. Too close to particle. I will keep trying.' % i)

From d6b1598dff555e2b134d641a6e8f124774df53d2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 18 Oct 2013 17:50:11 +0200
Subject: [PATCH 1447/1541] small fix

---
 ParticleContainerBase.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index fd91530a..08ae57d0 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -448,7 +448,7 @@ class ParticleContainerBase
     {
         typename utils::template overlap_checker<structure_id_pair_and_distance_list, boost::array<structure_id_type, 1> > checker(array_gen(ignore));
         
-        const structure_id_set visible_structures (structures_.get_visible_structure_IDs(current_struct_id));
+        const structure_id_set visible_structure_IDs (structures_.get_visible_structures(current_struct_id));
 
         // Get and temporarily store all the visibles structures (upto now we only had their IDs)
         structure_map visible_structures;

From fb8b26386d10f291d0b06c82dcfc51a3542b23d4 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 21 Oct 2013 14:50:57 +0200
Subject: [PATCH 1448/1541] Two changes to egfrd.py

- Also explicitly ignore parent structures in check domain
- Define a maximal burst radius to prevent matrix errors in cases
  with higher Multi / Single shell factors
---
 egfrd.py | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7f040f7c..3399625b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -261,6 +261,8 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
 
         self.MAX_TIME_STEP = 10
 
+        self.MAX_BURST_RADIUS = 0.5 * self.world.cell_size
+
         self.DEFAULT_DT_FACTOR = 1e-5           # Diffusion time prefactor in oldBD algortithm to determine time step.
         
         self.DEFAULT_STEP_SIZE_FACTOR = 0.05    # The maximum step size in the newBD algorithm is determined as DSSF * sigma_min.
@@ -1007,7 +1009,15 @@ def burst_volume(self, pos, radius, ignore=[]):
         # Then we may want to burst in a cylindrical volume, not a sphere.
         # Same for the 1D particles on rods.
 
-        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, SAFETY*radius, ignore)
+        burst_radius = SAFETY*radius
+        log.info('burst_radius = %s, cell_size = %s' % (burst_radius, self.world.cell_size))
+
+        if burst_radius > self.MAX_BURST_RADIUS:
+
+            log.warn('Setting burst radius (= %s) to maximally allowed limit ( = %s).' % (burst_radius, self.MAX_BURST_RADIUS))
+            burst_radius = self.MAX_BURST_RADIUS / SAFETY
+
+        neighbor_ids = self.geometrycontainer.get_neighbors_within_radius_no_sort(pos, burst_radius, ignore)
 
         return self.burst_domains(neighbor_ids, ignore)
 
@@ -1862,7 +1872,7 @@ def make_new_domain(self, single):
         reaction_threshold = single_radius * SINGLE_SHELL_FACTOR
 
         # 1.0 Get neighboring domains and surfaces
-        neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id, ])        
+        neighbor_distances = self.geometrycontainer.get_neighbor_domains(single_pos, self.domains, ignore=[single.domain_id])        
         # Get also surfaces
         # Some singles have an extended ignore list, which we have to figure out first
         ignores = [] # by default
@@ -1872,6 +1882,7 @@ def make_new_domain(self, single):
                 log.info('Extended structure ignore list when making %s, ignored IDs = %s' % (single, ignores))
 
         surface_distances = get_neighbor_structures(self.world, single_pos, single.structure.id, ignores)
+        log.info('surface_distances = %s' % str(surface_distances))
 
         # 2.3 We prefer to make NonInteractionSingles for efficiency.
         #     But if objects (Shells and surfaces) get close enough (closer than
@@ -3088,7 +3099,7 @@ def check_domain(self, domain):
 
         elif isinstance(domain, SphericalSingle) or isinstance(domain, SphericalPair) or isinstance(domain, PlanarSurfaceSingle): # TODO Why not PlanarSurfacePair ?
             # 3D NonInteractionSingles can overlap with planar surfaces but not with rods
-            ignores = [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
+            ignores = [domain.structure.structure_id] + [s.id for s in self.world.structures if isinstance(s, PlanarSurface)]
             associated = []
 
         elif isinstance(domain, DiskSurfaceSingle):
@@ -3117,12 +3128,12 @@ def check_domain(self, domain):
         elif isinstance(domain, PlanarSurfacePair):
             # PlanarSurfacePair domains are also formed with a static particle located on a (sub-) disk of the plane
             # In these cases, the disk and--if present--a cylinder next to it shall be ignored.
-            ignores = domain.ignored_structure_ids # this is a list already
+            ignores = [domain.structure.structure_id] + domain.ignored_structure_ids # ignore parent structure and extra-ignore-list
             associated = [domain.structure.id]
 
         elif isinstance(domain, PlanarSurfaceTransitionSingle) or isinstance(domain, PlanarSurfaceTransitionPair):
             # Ignore surface of the particle and interaction surface
-            ignores = []
+            ignores = [domain.structure1.structure_id, domain.structure2.structure_id] # parent structures
             associated = [domain.structure1.id, domain.structure2.id]
 
         else:

From 7ca4c99e838ea29fd6cb279c2a1f344980507b8b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Mon, 21 Oct 2013 14:52:58 +0200
Subject: [PATCH 1449/1541] Cleanup

---
 egfrd.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 3399625b..cd5e9c91 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1010,7 +1010,6 @@ def burst_volume(self, pos, radius, ignore=[]):
         # Same for the 1D particles on rods.
 
         burst_radius = SAFETY*radius
-        log.info('burst_radius = %s, cell_size = %s' % (burst_radius, self.world.cell_size))
 
         if burst_radius > self.MAX_BURST_RADIUS:
 
@@ -1882,7 +1881,7 @@ def make_new_domain(self, single):
                 log.info('Extended structure ignore list when making %s, ignored IDs = %s' % (single, ignores))
 
         surface_distances = get_neighbor_structures(self.world, single_pos, single.structure.id, ignores)
-        log.info('surface_distances = %s' % str(surface_distances))
+        #log.info('surface_distances = %s' % str(surface_distances))
 
         # 2.3 We prefer to make NonInteractionSingles for efficiency.
         #     But if objects (Shells and surfaces) get close enough (closer than

From db21e887ed988ebb0d83e69b9a97dd5814c10aeb Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 15 Nov 2013 17:03:07 +0100
Subject: [PATCH 1450/1541] Improve some simulator consistency checks +
 increase allowed no. of steps in dt~0 limit to 10^5

In long simulations with significant amount of BD steps we may
get longer chains of short updates which the code then will mark
as dt~0 steps and fail very soon without reason.

On the other hand 10^5 BD steps are not expensive, so we can
keep on checking longer before we bail out a running simulation.
---
 egfrd.py | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index cd5e9c91..3f9c0a38 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -257,7 +257,7 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
         self.shell_id_generator = ShellIDGenerator(0)
 
         # some constants
-        self.MAX_NUM_DT0_STEPS = 1000
+        self.MAX_NUM_DT0_STEPS = 100000
 
         self.MAX_TIME_STEP = 10
 
@@ -506,7 +506,7 @@ def step(self):
         
         if __debug__:
             domain_counts = self.count_domains()
-            log.info('\n\n%d: t=%s dt=%s (next_time=%s)\t' %
+            log.info('\n\n%d: t=%s dt=%e (next_time=%s)\t' %
                      (self.step_counter, self.t,
                       self.dt, self.scheduler.top[1].time) + 
                      'Singles: %d, Pairs: %d, Multis: %d\n' % domain_counts + 
@@ -539,16 +539,15 @@ def step(self):
 
         # assert if not too many successive dt=0 steps occur.
         if __debug__:
-            if self.dt == 0:
+            if self.dt < 1e-10: # We consider 0.1 nanoseconds a zero-step
+
+                log.warning('dt = %e = %.10e-%.10e = zero step, working in s.t >> dt~0 Python limit.' % (self.dt, next_time, self.t))
                 self.zero_steps += 1
-                # TODO What is best solution here? Usually no prob, -> just let 
-                # user know?
-                if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
-                    raise RuntimeError('too many dt=zero steps. '
-                                       'Simulator halted?'
-                                    'dt= %.10g-%.10g' % (self.scheduler.top[1].time, self.t))
 
-                log.warning('dt=zero step, working in s.t >> dt~0 Python limit.')
+                if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
+                    raise RuntimeError('too many successive dt=zero steps -> Simulator stalled?'
+                                       'dt= %.10e-%.10e' % (next_time, self.t))
+                
             else:
                 self.zero_steps = 0
 
@@ -1038,8 +1037,17 @@ def burst_all_domains(self):
 
         # Check if the bursting procedure was correct.
         if __debug__:
-            assert len(zero_singles) == self.world.num_particles
-            assert len(ignore) == (len(all_domains) + self.world.num_particles)
+
+            if len(zero_singles) != self.world.num_particles :
+                log.warn('No. of zero singles (= %s) is not equal to world.num_particles (= %s)!' \
+                          % (len(zero_singles), self.world.num_particles) )
+
+            if len(ignore) != len(all_domains) + self.world.num_particles:
+                log.warn('Length of ignore list (= %s) is not equal to world.num_particles (= %s) plus length of all domains list (%s)!' \
+                          % (len(ignore), len(all_domains), self.world.num_particles) )
+
+            #assert len(zero_singles) == self.world.num_particles
+            #assert len(ignore) == (len(all_domains) + self.world.num_particles)
 
 
     def burst_domains(self, domain_ids, ignore=[]):

From 71333043f35132e44346e1e0e2228c6a094edb1c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Fri, 11 Apr 2014 11:45:02 +0200
Subject: [PATCH 1451/1541] Examaple script for simple reaction in 2D

---
 samples/2D_example/2D_example.py | 254 +++++++++++++++++++++++++++++++
 1 file changed, 254 insertions(+)
 create mode 100755 samples/2D_example/2D_example.py

diff --git a/samples/2D_example/2D_example.py b/samples/2D_example/2D_example.py
new file mode 100755
index 00000000..0321be8d
--- /dev/null
+++ b/samples/2D_example/2D_example.py
@@ -0,0 +1,254 @@
+#!/usr/bin/python
+
+#####################################################
+##### A simple A+B <-> C reaction on a 2D plane #####
+##### by TR Sokolowski, 2013                    #####
+#####                                           #####
+#####################################################
+
+##### Start with:
+##### PYTHONPATH=[egfrd directory] LOGLEVEL=[ERROR|DEBUG] python ./2D_example [seed] [no. of particles]
+
+
+##### Importing necessary files #####
+# import egfrd libraries
+from egfrd import *
+from bd import *
+import model
+import gfrdbase
+import _gfrd
+import os
+import math
+
+
+# Set up the model
+def set_constants():
+
+    global N_run, t_max, N_log, log_time, log_step, N_save, save_points, loadfile, ws
+    global _SEED_, _VLOG_, _INFO_
+    global N_plane_particles
+    global Pi
+
+    # Define some simulation parameters
+    world_size = 10e-6  # side length of simulation box [m]
+    ws = world_size     # only an abbreviation
+
+    Pi = math.pi
+
+    # Run and logging parameters
+    N_run = 1e5         # number of simulation steps
+    N_log = 1e9         # number of *last* steps it will log; if N_log>N_run, we will log N_run steps
+    log_step = 0        # number of steps between two log outputs
+			# if this is 0 the script will log in time intervals instead (defined below)
+    log_time = 0.1     	# seconds between two log events of the VTK logger
+    t_max    = 3600.0	# maximal bound for simulated time [sec]
+
+    N_save = 5e4        # saving interval
+    save_points = []	# define arbitrary save points (in steps) here; can be useful in debugging
+
+    loadfile=''		# specify a file with a previous state here if desired
+
+    if(log_step > 0):
+        log_time = 0.0
+
+    # The random seed
+    _SEED_ = int(par1)
+
+    # Some control flags
+    _INFO_ = 1
+    _VLOG_ = 1
+
+    # How many particles to place
+    N_plane_particles = int(par2)
+
+
+def setup_model():
+
+    global m, structure_types, membrane, A, B, C
+
+    # Create an instance of the ParticleModel class
+    m = model.ParticleModel(ws) 
+
+    # Define the membrane structure_type
+    structure_types = []
+    membrane = _gfrd.StructureType()
+    membrane['name'] = 'membrane'
+    m.add_structure_type(membrane)
+    structure_types.append(membrane)    
+
+    #############################
+    ##### General parameters ####
+    #############################
+    # Define species parameters
+    R_part  = 10.0e-9   # Particle radius [m] 
+    D_mem   = 0.5e-12   # Particle membrane diff. const. [um^2/s]
+  
+    ####################################
+    ##### Define the reaction rates ####
+    ####################################
+    kb_intr 	= 1.0e-5 # Intrinsic rate of binding at contact;
+			 # This is without the 2*pi*sigma prefactor (~1e-7 m), 
+			 # which is added automatically when calculating the Green's function;
+			 # Remember this is in [m/s]
+
+    ku		= 1.0	# Unbinding rate = 1/complex lifetime [1/s]
+
+    ##############################
+    ##### Create the species #####
+    ##############################
+    # Define chemical species
+    A = model.Species('A', D_mem, R_part, membrane)
+    B = model.Species('B', D_mem, R_part, membrane)
+    C = model.Species('C', D_mem/2.0, 2.0*R_part, membrane)
+
+    # Add species to model
+    for S in [A, B, C]:
+	m.add_species_type(S)
+
+    #######################################
+    ##### Create the reaction network #####
+    #######################################    
+
+    rb = model.create_binding_reaction_rule(  A, B, C, kb_intr )
+    ru = model.create_unbinding_reaction_rule(C, A, B, ku)
+
+    for rule in [rb, ru]:
+	m.network_rules.add_reaction_rule(rule)
+
+
+def setup_simulator():
+
+    global w, s, bb_1, bb_2
+
+    # Create the world with 3x3x3 cells for the matrixsize
+    w = gfrdbase.create_world(m, 3)
+
+    # Get default structure id
+    def_sid = w.get_def_structure_id()
+
+    # Create membranes
+    plane_z = 0.5*ws
+    plane_corner = [-1.0*ws, -1.0*ws, plane_z]
+    unit_x = [1, 0, 0]
+    unit_y = [0, 1, 0]
+
+    plane = model.create_planar_surface(membrane.id, 'plane', plane_corner, unit_x, unit_y, 3.0*ws, 3.0*ws, def_sid)
+    w.add_structure(plane)		# Note: last argument of create_planar_surface() is the parent structure's ID
+					# This is important for correct handling of unbindings from the substructures!
+
+    # Define a bounding box for particle placement
+    # If you want to restrict initial positions to a certain region change parameters here
+    bb_1 = [0.01*ws, 0.01*ws, plane_z - 0.1*ws]
+    bb_2 = [0.99*ws, 0.99*ws, plane_z + 0.1*ws]
+
+    # Create a simulator for the world:
+    myrandom.seed(_SEED_)
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    # Randomly place the particles, using the bounding box from above
+    throw_in_particles(w, A, N_plane_particles/2, bb_1, bb_2)
+    throw_in_particles(w, B, N_plane_particles/2, bb_1, bb_2)
+
+    if _INFO_:
+	# Print info about created structures
+	print "***** STRUCTURE TYPES *****"
+	for st in structure_types:
+		print ("%s \t %s" % (st.id, st['name']) )
+	print "***** STRUCTURES *****"
+	for struct in w.structures:
+		print ("%s \t %s \t %s" % (struct.id, struct.sid, struct.name) )
+
+
+def setup_VTK():
+
+    global vlogger
+
+    # Set up the visualization toolkit (VTK):
+
+    # Set VTK output directory and check if output directory isn't 
+    # already there
+    vtk_output_directory = 'VTK_out'
+    if (os.path.exists(vtk_output_directory)):
+        print '***** WARNING: VTK output directory already exists, possible '+ \
+                'present old VTK files might lead to errors.'
+    
+    # import lib and create logger instance
+    from visualization import vtklogger
+    vlogger = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=False) 
+	      # VTKLogger(self, sim, dir='vtkdata', buffer_size=None, show_shells=True, 
+	      # extra_particle_step=True, color_dict=None)
+
+
+def main():
+
+    global par1, par2
+
+    # Parameters passed to script
+    par1 = sys.argv[1] # used for seed
+    par2 = sys.argv[2] # used for no. of plane particles
+
+    # Make sure to convert parameters to right format when passing on!
+
+
+    #### Set everything up: ####
+    set_constants()
+    setup_model()
+    setup_simulator()
+    if _VLOG_:
+            setup_VTK()
+
+    if _INFO_:
+	print '* Initialization complete, starting simulation.'
+	print '* SINGLE_SHELL_FACTOR=%s, MULTI_SHELL_FACTOR=%s, MINIMAL_SEPARATION_FACTOR=%s, SAFETY=%s, TOLERANCE=%s' %(SINGLE_SHELL_FACTOR, MULTI_SHELL_FACTOR, MINIMAL_SEPARATION_FACTOR, SAFETY, TOLERANCE)
+
+
+    #### Let's roll: ####
+    step = 0
+    tlast = 0.0
+
+    if _VLOG_:
+	# log initial configuration
+	vlogger.log()
+
+    if loadfile != '':
+
+	s.load_state(loadfile)
+
+    while step < N_run and s.t <= t_max:
+
+	step += 1
+	s.step()
+	#s.check() # still sporadically causes problems with development version
+
+        if step % (N_run/100) == 0:
+            print "***** SIMULATION PROGRESS = "+str(int(step/N_run*100.0))+"%"
+
+        if step % N_save == 0 or step in save_points:
+            print "***** SAVING STATE at step "+str(int(step))
+            s.save_state('state_'+str(step)+'.ini', reload=True, delay=5.0)
+
+        if _VLOG_ and step > (N_run-N_log) and \
+          ( (log_step and step%log_step==0) or \
+            (log_time and s.t-tlast>=log_time) ):
+
+            print "***** LOGGER: logging time = "+str(s.t)
+            tlast = s.t
+            s.burst_all_domains()
+            vlogger.log()    
+            
+
+    # #### Quitting: ####
+    print '* Done, quitting.'
+
+    s.stop(s.t)
+    #s.burst_all_domains()
+    s.print_report()
+    if _VLOG_:
+            vlogger.stop()
+
+    print '* Bye.'
+
+
+if __name__ == "__main__":
+
+    main()

From 789cd2630a83d03ce5ead6282643efffe01ad6b9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Tue, 3 Jun 2014 18:36:27 +0200
Subject: [PATCH 1452/1541] Include utils.cpp into StructureFunctions.hpp to
 fix some sporadic compilation errors

---
 StructureFunctions.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index d38feb14..51d40452 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -9,6 +9,7 @@
 #include "linear_algebra.hpp"
 #include "exceptions.hpp"
 #include "Logger.hpp"
+#include "utils/math.hpp"
 
 // Forward declaration of structures
 template <typename Ttraits_>

From 2afbe8e1cb427acd29f04d64089bd14761eafb50 Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Tue, 21 Oct 2014 11:37:51 +0200
Subject: [PATCH 1453/1541] Fixes modern tools/compiler

---
 ConnectivityContainer.hpp     | 4 ++--
 Disk.hpp                      | 1 +
 Makefile.am                   | 4 ++--
 StructureFunctions.hpp        | 1 +
 World.hpp                     | 4 ++--
 binding/Makefile.am           | 6 +++---
 configure.ac                  | 6 +++---
 linear_algebra.hpp            | 2 +-
 samples/benchmark/Makefile.am | 2 +-
 test/Makefile.am              | 2 +-
 utils/array_helper.hpp        | 2 +-
 11 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/ConnectivityContainer.hpp b/ConnectivityContainer.hpp
index f81746b4..d2c2c7c9 100644
--- a/ConnectivityContainer.hpp
+++ b/ConnectivityContainer.hpp
@@ -38,7 +38,7 @@ class ConnectivityContainer
     {
         // check that the index is not too large
         if ( n >= max )
-            throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
+            throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(num_neighbors));
 
         neighbor_mapping_[obj][n] = obj_data_pair;
     }
@@ -47,7 +47,7 @@ class ConnectivityContainer
     {
         // check that the index is not too large
         if ( n >= max )
-            throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(max));
+            throw illegal_argument(std::string("Index out of range for neighbor (n= ") + boost::lexical_cast<std::string>(n) + "), max= " + boost::lexical_cast<std::string>(num_neighbors));
 
         typename obj_neighbor_objdata_array_map::const_iterator i(neighbor_mapping_.find(id));
         if (neighbor_mapping_.end() == i)
diff --git a/Disk.hpp b/Disk.hpp
index 2fee12fb..61315fbf 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -6,6 +6,7 @@
 #include "Vector3.hpp"
 #include "Shape.hpp"
 #include "linear_algebra.hpp"
+#include "utils/math.hpp"
 
 template<typename T_>
 class Disk
diff --git a/Makefile.am b/Makefile.am
index 7fe4268f..bba75e83 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -17,8 +17,8 @@ pkgpyexecdir = @pkgpyexecdir@
 
 LIBPYTHON = -lpython$(PYTHON_VERSION)
 
-INCLUDES = ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR}
-AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@
+AM_CPPFLAGS = ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR} @CPPFLAGS@ @GSL_CFLAGS@
+AM_CXXFLAGS = ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR} @CXXFLAGS@ @GSL_CFLAGS@
 LIBBOOSTPYTHON = -l@BOOST_PYTHON_LIBNAME@
 LIBBOOSTREGEX = -l@BOOST_REGEX_LIBNAME@
 
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 599f9d41..3b458275 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -9,6 +9,7 @@
 #include "linear_algebra.hpp"
 #include "exceptions.hpp"
 #include "Logger.hpp"
+#include "utils/math.hpp"
 
 // Forward declaration of structures
 template <typename Ttraits_>
diff --git a/World.hpp b/World.hpp
index 63b6ffa1..421df3f6 100644
--- a/World.hpp
+++ b/World.hpp
@@ -272,7 +272,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             position_type const& pos)
     {
         species_type const& species(get_species(sid));
-        const boost::shared_ptr<const structure_type> structure(get_structure(structure_id));
+        const boost::shared_ptr<const structure_type> structure(base_type::get_structure(structure_id));
         // assert that the structure is of the type denoted by the species of the particle.
         BOOST_ASSERT(structure->sid() == species.structure_type_id());
 
@@ -317,7 +317,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     virtual bool remove_particle(particle_id_type const& id)
     {
         bool found(false);
-        particle_id_pair pp(get_particle(id, found));               // call method in ParticleContainerBase
+        particle_id_pair pp(base_type::get_particle(id, found));               // call method in ParticleContainerBase
         if (!found)
         {
             return false;
diff --git a/binding/Makefile.am b/binding/Makefile.am
index 547ad700..144c6bdd 100644
--- a/binding/Makefile.am
+++ b/binding/Makefile.am
@@ -1,9 +1,9 @@
 NUMPY_INCLUDE_DIR = @NUMPY_INCLUDE_DIR@
 PYTHON_INCLUDES = @PYTHON_INCLUDES@
 
-INCLUDES = ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR}
-AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@ -I.. -Wall -g -Wstrict-aliasing=0 -Wno-invalid-offsetof
-AM_CPPFLAGS = @CPPFLAGS@ -DNO_IMPORT
+
+AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@ -I.. -Wall -g
+AM_CPPFLAGS = @CPPFLAGS@ -DNO_IMPORT ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR}
 
 noinst_LTLIBRARIES = libbinding_utils.la
 
diff --git a/configure.ac b/configure.ac
index fe16c47d..b0eade91 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,7 +1,7 @@
 AC_REVISION([$Id$])
 dnl
 dnl
-AC_INIT
+AC_INIT([eGFRD],[0.9a])
 AC_CONFIG_SRCDIR([autogen.sh])
 dnl
 AC_DISABLE_STATIC
@@ -14,7 +14,7 @@ AH_TEMPLATE(HAVE_INLINE)
 dnl 
 dnl
 AC_CANONICAL_TARGET([])
-AM_INIT_AUTOMAKE([epdp],[0.3b])
+AM_INIT_AUTOMAKE([subdir-objects])
 
 dnl Check pdflatex
 AC_PROG_PDFLATEX()
@@ -56,7 +56,7 @@ if test -n "$DEBUG"; then
 fi
 
 if test "$GXX" = "yes"; then
-  CXXFLAGS="$CXXFLAGS -Wall -Wstrict-aliasing=0 -Wno-invalid-offsetof"
+  CXXFLAGS="$CXXFLAGS -Wall -Wno-unused-local-typedefs"
   CFLAGS="$CFLAGS -Wall"
 fi
 
diff --git a/linear_algebra.hpp b/linear_algebra.hpp
index 701123d5..c7d64c52 100644
--- a/linear_algebra.hpp
+++ b/linear_algebra.hpp
@@ -5,7 +5,7 @@
 #include <cmath>
 #include <gsl/gsl_pow_int.h>
 #include <boost/preprocessor/tuple/elem.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
 #include <boost/mpl/bool.hpp>
diff --git a/samples/benchmark/Makefile.am b/samples/benchmark/Makefile.am
index 68c92245..735356b8 100644
--- a/samples/benchmark/Makefile.am
+++ b/samples/benchmark/Makefile.am
@@ -1,6 +1,6 @@
 noinst_PROGRAMS = hardbody
 
-INCLUDES = -I$(top_srcdir) $(PYTHON_INCLUDES)
+AM_CPPFLAGS = -I$(top_srcdir) $(PYTHON_INCLUDES)
 AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@
 
 hardbody_SOURCES = hardbody.cpp ../../NetworkRules.cpp ../../BasicNetworkRulesImpl.cpp ../../Logger.cpp ../../freeFunctions.cpp
diff --git a/test/Makefile.am b/test/Makefile.am
index fa534d91..54486b37 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -81,7 +81,7 @@ ReactionRecord_test.py
 #%.py:
 #	$(TESTS_ENVIRONMENT) $(PYTHON) $<
 
-INCLUDES = -I$(top_srcdir) $(PYTHON_INCLUDES)
+AM_CPPFLAGS = -I$(top_srcdir) $(PYTHON_INCLUDES)
 AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@ -Wall -g
 
 check_PROGRAMS = $(CPP_TESTS)
diff --git a/utils/array_helper.hpp b/utils/array_helper.hpp
index ca3936b9..39988415 100644
--- a/utils/array_helper.hpp
+++ b/utils/array_helper.hpp
@@ -3,7 +3,7 @@
 
 #include <boost/array.hpp>
 #include <boost/preprocessor/config/limits.hpp>
-#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
 #include <boost/preprocessor/repetition/enum_params.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/call_traits.hpp>

From d0e8ab5f53e50f514664c162598bc82453055456 Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Tue, 21 Oct 2014 12:08:29 +0200
Subject: [PATCH 1454/1541] Fix Python2.7 logging, close issue gfrd/egfrd#83
 and #84

---
 acinclude.m4               |  11 ++
 binding/PythonAppender.cpp | 241 +++++++++++++++++++++++++++++++++++--
 configure.ac               |   1 +
 3 files changed, 245 insertions(+), 8 deletions(-)

diff --git a/acinclude.m4 b/acinclude.m4
index 06192923..017d7a17 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -129,3 +129,14 @@ AC_DEFUN([ECELL_CHECK_NUMPY_ARRAY_DESCR], [
 ])
   CPPFLAGS="$ac_save_CPPFLAGS"                 
 ])
+
+AC_DEFUN([ECELL_CHECK_LOGGING_MODULE], [
+  AC_MSG_CHECKING([if classes in the Python's logging module is old-fashioned])
+  AC_REQUIRE([AM_PATH_PYTHON])
+  if "$PYTHON" -c "import sys, logging; sys.exit(type(logging.Handler) == type)"; then
+    AC_MSG_RESULT(yes)
+    AC_DEFINE([HAVE_OLD_FASHIONED_LOGGER_CLASSES], [1], [Defined to 1 if Python's logging module is old-fashioned])
+  else
+    AC_MSG_RESULT(no)
+  fi
+])
diff --git a/binding/PythonAppender.cpp b/binding/PythonAppender.cpp
index 91e27112..c682578e 100644
--- a/binding/PythonAppender.cpp
+++ b/binding/PythonAppender.cpp
@@ -65,10 +65,11 @@ class PythonAppender: public LogAppender
     boost::python::object makeRecord_;
 };
 
-// XXX: logging.Handler is a old-style class... *sigh*
 class CppLoggerHandler
 {
 public:
+// XXX: logging.Handler is a old-style class... *sigh*
+#ifdef HAVE_OLD_FASHIONED_LOGGER_CLASSES
     static PyObject* __class_init__(const char* name, PyObject* mod)
     {
         using namespace boost::python;
@@ -120,11 +121,6 @@ class CppLoggerHandler
         return klass.get();
     }
 
-    static void __dealloc__(void* ptr)
-    {
-        delete reinterpret_cast<CppLoggerHandler*>(ptr);
-    }
-
     static CppLoggerHandler* get_self(PyObject* _self)
     {
         boost::python::handle<> ptr(
@@ -200,6 +196,154 @@ class CppLoggerHandler
         return NULL;
     }
 
+    static PyObject* __init__(PyObject* _self, PyObject* logger)
+    try
+    {
+        BOOST_ASSERT(PyInstance_Check(_self));
+
+        CppLoggerHandler* self(new CppLoggerHandler(
+            *boost::python::extract<Logger*>(logger)()));
+
+        boost::python::handle<> ptr(
+            boost::python::allow_null(
+                PyCObject_FromVoidPtr(self, &__dealloc__)));
+        if (!ptr)
+        {
+            delete self;
+            return NULL;
+        }
+
+        if (PyObject_SetAttrString(_self, "__ptr__", ptr.get()))
+            return NULL;
+
+        boost::python::handle<> bases(
+            boost::python::borrowed(
+                reinterpret_cast<PyInstanceObject*>(_self)->in_class->cl_bases));
+
+        if (!PyTuple_Check(bases.get()))
+            return NULL;
+
+        boost::python::handle<> super_arg(PyTuple_Pack(1, _self));
+
+        for (std::size_t i(0), l(PyTuple_GET_SIZE(bases.get())); i < l; ++i)
+        {
+            boost::python::handle<> base(
+                boost::python::borrowed(PyTuple_GET_ITEM(bases.get(), i)));
+            boost::python::handle<> super_init(
+                boost::python::borrowed(
+                    PyObject_GetAttrString(base.get(), "__init__")));
+            if (PyErr_Occurred())
+            {
+                PyErr_Clear();
+                continue;
+            }
+
+            if (!boost::python::handle<>(
+                boost::python::allow_null(
+                    PyObject_Call(super_init.get(), super_arg.get(), NULL))))
+            {
+                return NULL;
+            }
+        }
+
+        return boost::python::incref(Py_None);
+    }
+    catch (boost::python::error_already_set const&)
+    {
+        return NULL;
+    }
+#else
+    void* operator new(size_t)
+    {
+        PyObject* retval = PyObject_New(PyObject, &__class__);
+        return retval;
+    }
+
+    void operator delete(void* ptr)
+    {
+        reinterpret_cast<PyObject*>(ptr)->ob_type->tp_free(reinterpret_cast<PyObject*>(ptr));
+    }
+
+    static PyObject* __class_init__(const char* name, PyObject* mod)
+    {
+        using namespace boost::python;
+
+        import_logging_module();
+        __name__ = static_cast<std::string>(
+            extract<std::string>(object(borrowed(mod)).attr("__name__")))
+            + "." + name;
+        __class__.tp_name = const_cast<char*>(__name__.c_str());
+        __class__.tp_base = reinterpret_cast<PyTypeObject*>(getattr(logging_module, "Handler").ptr());
+        if (PyType_Ready(&__class__) < 0)
+        {
+            return 0;
+        }
+        return reinterpret_cast<PyObject*>(&__class__);
+    }
+
+    static CppLoggerHandler* get_self(PyObject* _self)
+    {
+        return reinterpret_cast<CppLoggerHandler*>(_self);
+    }
+
+    static PyObject* __new__(PyTypeObject* klass, PyObject* arg, PyObject* kwarg)
+    try
+    {
+        if (PyTuple_Size(arg) != 1)
+        {
+            PyErr_SetString(PyExc_TypeError, "the number of arguments must be 1");
+            return NULL;
+        }
+
+        CppLoggerHandler* retval(
+            new CppLoggerHandler(
+                *boost::python::extract<Logger*>(
+                    PyTuple_GetItem(arg, 0))()));
+
+        if (PyErr_Occurred())
+        {
+            boost::python::decref(reinterpret_cast<PyObject*>(retval));
+            return NULL;
+        }
+        return reinterpret_cast<PyObject*>(retval);
+    }
+    catch (boost::python::error_already_set const&)
+    {
+        return NULL;
+    }
+
+    static int __init__(PyObject* self, PyObject* arg, PyObject* kwarg)
+    {
+        using namespace boost::python;
+        return handle<>(allow_null(
+            PyObject_Call(
+                PyObject_GetAttrString(
+                    reinterpret_cast<PyObject*>(Py_TYPE(self)->tp_base),
+                    const_cast<char*>("__init__")),
+                boost::python::handle<>(PyTuple_Pack(1, self)).get(),
+                NULL))) ? 0: 1;
+    }
+
+    static int __traverse__(PyObject *self, visitproc visit, void *arg)
+    {
+        Py_VISIT(reinterpret_cast<CppLoggerHandler*>(self)->__dict__.get());
+        return 0;
+    }
+
+#endif
+    ~CppLoggerHandler()
+    {
+        if (__weakreflist__)
+        {
+            PyObject_ClearWeakRefs(reinterpret_cast<PyObject*>(this));
+        }
+    }
+
+    static void __dealloc__(void* ptr)
+    {
+        delete reinterpret_cast<CppLoggerHandler*>(ptr);
+    }
+
     static PyObject* createLock(PyObject* _self)
     {
         CppLoggerHandler* const self(get_self(_self));
@@ -308,7 +452,25 @@ class CppLoggerHandler
         return boost::python::reference_existing_object::apply<Logger*>::type()(self->impl_);
     }
 
-    CppLoggerHandler(Logger& impl): impl_(impl) {}
+
+#ifndef HAVE_OLD_FASHIONED_LOGGER_CLASSES
+    static PyObject* get___dict__(PyObject *_self, void* context)
+    {
+        CppLoggerHandler* const self(get_self(_self));
+        if (!self)
+            return NULL;
+        return boost::python::incref(self->__dict__.get());
+    }
+#endif
+
+    CppLoggerHandler(Logger& impl)
+        :
+#ifndef HAVE_OLD_FASHIONED_LOGGER_CLASSES
+        __weakreflist__(0),
+        __dict__(PyDict_New()),
+#endif
+        impl_(impl)
+    {}
 
 protected:
     static enum Logger::level translate_level(PyObject* _level)
@@ -330,16 +492,28 @@ class CppLoggerHandler
 
 
 protected:
+#ifdef HAVE_OLD_FASHIONED_LOGGER_CLASSES
     static boost::python::handle<> __class__;
+#else
+    PyObject_VAR_HEAD
+    static PyTypeObject __class__;
+    static std::string __name__;
+    PyObject *__weakreflist__;
+    boost::python::handle<> __dict__;
+#endif
     static PyMethodDef __methods__[];
     static PyGetSetDef __getsets__[];
     Logger& impl_;
 };
 
-boost::python::handle<> CppLoggerHandler::__class__;
+#ifndef HAVE_OLD_FASHIONED_LOGGER_CLASSES
+std::string CppLoggerHandler::__name__;
+#endif
 
 PyMethodDef CppLoggerHandler::__methods__[] = {
+#ifdef HAVE_OLD_FASHIONED_LOGGER_CLASSES
     { "__init__", (PyCFunction)CppLoggerHandler::__init__, METH_O, "" },
+#endif
     { "createLock", (PyCFunction)CppLoggerHandler::createLock, METH_NOARGS, "" },
     { "acquire", (PyCFunction)CppLoggerHandler::acquire, METH_NOARGS, "" },
     { "release", (PyCFunction)CppLoggerHandler::release, METH_NOARGS, "" },
@@ -353,10 +527,61 @@ PyMethodDef CppLoggerHandler::__methods__[] = {
 };
 
 PyGetSetDef CppLoggerHandler::__getsets__[] = {
+#ifndef HAVE_OLD_FASHIONED_LOGGER_CLASSES
+    { const_cast<char*>("__dict__"), (getter)&CppLoggerHandler::get___dict__, NULL, NULL },
+#endif
     { const_cast<char*>("logger"), (getter)&CppLoggerHandler::get_logger, NULL, NULL },
     { NULL, NULL }
 };
 
+#ifdef HAVE_OLD_FASHIONED_LOGGER_CLASSES
+boost::python::handle<> CppLoggerHandler::__class__;
+#else
+PyTypeObject CppLoggerHandler::__class__ = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,					/* ob_size */
+	0,                  /* tp_name */
+	sizeof(CppLoggerHandler), /* tp_basicsize */
+	0,					/* tp_itemsize */
+	/* methods */
+	(destructor)&CppLoggerHandler::__dealloc__, /* tp_dealloc */
+	0,					/* tp_print */
+	0,					/* tp_getattr */
+	0,					/* tp_setattr */
+	0,					/* tp_compare */
+	0,					/* tp_repr */
+	0,					/* tp_as_number */
+	0,                  /* tp_as_sequence */
+	0,					/* tp_as_mapping */
+	0,					/* tp_hash */
+	0,					/* tp_call */
+	0,					/* tp_str */
+	PyObject_GenericGetAttr,		/* tp_getattro */
+	0,					/* tp_setattro */
+	0,					/* tp_as_buffer */
+	Py_TPFLAGS_HAVE_CLASS | Py_TPFLAGS_HAVE_WEAKREFS | Py_TPFLAGS_BASETYPE, /* tp_flags */
+	0,					/* tp_doc */
+	CppLoggerHandler::__traverse__,              	/* tp_traverse */
+	0,					/* tp_clear */
+	0,                  /* tp_richcompare */
+	offsetof(CppLoggerHandler, __weakreflist__),    /* tp_weaklistoffset */
+	0,                  /* tp_iter */
+	0,                  /* tp_iternext */
+	CppLoggerHandler::__methods__,		        	/* tp_methods */
+	0,					/* tp_members */
+    CppLoggerHandler::__getsets__, /* tp_getset */
+    0,                  /* tp_base */
+    0,                  /* tp_dict */
+    0,                  /* tp_descr_get */
+    0,                  /* tp_descr_set */
+    offsetof(CppLoggerHandler, __dict__),           /* tp_dictoffset */
+    CppLoggerHandler::__init__, /* tp_init */
+    0,                  /* tp_alloc */
+    CppLoggerHandler::__new__,  /*tp_new */
+    0                   /* tp_free */
+};
+#endif
+
 boost::python::object
 register_logger_handler_class(char const* name)
 {
diff --git a/configure.ac b/configure.ac
index b0eade91..a1929ebd 100644
--- a/configure.ac
+++ b/configure.ac
@@ -105,6 +105,7 @@ dnl
 dnl
 ECELL_CHECK_NUMPY
 ECELL_CHECK_NUMPY_ARRAY_DESCR
+ECELL_CHECK_LOGGING_MODULE
 dnl
 AM_CHECK_PYTHON_HEADERS()
 ac_save_CPPFLAGS="$CPPFLAGS"

From bcace5fdf72163d42ec02a4e6bfac3426c0c1d20 Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Wed, 22 Oct 2014 13:53:31 +0200
Subject: [PATCH 1455/1541] Fix python logger, code from motiyoshi was not
 correct for old_fashioned case (Py2.6)

---
 binding/PythonAppender.cpp | 58 +-------------------------------------
 1 file changed, 1 insertion(+), 57 deletions(-)

diff --git a/binding/PythonAppender.cpp b/binding/PythonAppender.cpp
index c682578e..099a1f7f 100644
--- a/binding/PythonAppender.cpp
+++ b/binding/PythonAppender.cpp
@@ -196,62 +196,6 @@ class CppLoggerHandler
         return NULL;
     }
 
-    static PyObject* __init__(PyObject* _self, PyObject* logger)
-    try
-    {
-        BOOST_ASSERT(PyInstance_Check(_self));
-
-        CppLoggerHandler* self(new CppLoggerHandler(
-            *boost::python::extract<Logger*>(logger)()));
-
-        boost::python::handle<> ptr(
-            boost::python::allow_null(
-                PyCObject_FromVoidPtr(self, &__dealloc__)));
-        if (!ptr)
-        {
-            delete self;
-            return NULL;
-        }
-
-        if (PyObject_SetAttrString(_self, "__ptr__", ptr.get()))
-            return NULL;
-
-        boost::python::handle<> bases(
-            boost::python::borrowed(
-                reinterpret_cast<PyInstanceObject*>(_self)->in_class->cl_bases));
-
-        if (!PyTuple_Check(bases.get()))
-            return NULL;
-
-        boost::python::handle<> super_arg(PyTuple_Pack(1, _self));
-
-        for (std::size_t i(0), l(PyTuple_GET_SIZE(bases.get())); i < l; ++i)
-        {
-            boost::python::handle<> base(
-                boost::python::borrowed(PyTuple_GET_ITEM(bases.get(), i)));
-            boost::python::handle<> super_init(
-                boost::python::borrowed(
-                    PyObject_GetAttrString(base.get(), "__init__")));
-            if (PyErr_Occurred())
-            {
-                PyErr_Clear();
-                continue;
-            }
-
-            if (!boost::python::handle<>(
-                boost::python::allow_null(
-                    PyObject_Call(super_init.get(), super_arg.get(), NULL))))
-            {
-                return NULL;
-            }
-        }
-
-        return boost::python::incref(Py_None);
-    }
-    catch (boost::python::error_already_set const&)
-    {
-        return NULL;
-    }
 #else
     void* operator new(size_t)
     {
@@ -330,7 +274,6 @@ class CppLoggerHandler
         return 0;
     }
 
-#endif
     ~CppLoggerHandler()
     {
         if (__weakreflist__)
@@ -338,6 +281,7 @@ class CppLoggerHandler
             PyObject_ClearWeakRefs(reinterpret_cast<PyObject*>(this));
         }
     }
+#endif
 
     static void __dealloc__(void* ptr)
     {

From a82f257446e35e1acae81ee57172d181cc44ad62 Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Thu, 23 Oct 2014 13:11:57 +0200
Subject: [PATCH 1456/1541] Cleanup of makefile (removed duplicate comamndline
 options).

---
 Makefile.am                   | 16 +++++-----------
 acinclude.m4                  |  3 ++-
 binding/Makefile.am           | 10 ++++------
 configure.ac                  | 17 ++++-------------
 samples/benchmark/Makefile.am |  3 +--
 test/Makefile.am              |  5 ++---
 6 files changed, 18 insertions(+), 36 deletions(-)

diff --git a/Makefile.am b/Makefile.am
index bba75e83..74f6ecbe 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -17,13 +17,11 @@ pkgpyexecdir = @pkgpyexecdir@
 
 LIBPYTHON = -lpython$(PYTHON_VERSION)
 
-AM_CPPFLAGS = ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR} @CPPFLAGS@ @GSL_CFLAGS@
-AM_CXXFLAGS = ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR} @CXXFLAGS@ @GSL_CFLAGS@
+AM_CXXFLAGS = @BOOST_CPPFLAGS@ @GSL_CFLAGS@ ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR}
+
 LIBBOOSTPYTHON = -l@BOOST_PYTHON_LIBNAME@
 LIBBOOSTREGEX = -l@BOOST_REGEX_LIBNAME@
 
-CFLAGS = @GSL_CFLAGS@ @BOOST_CPPFLAGS@
-
 PYCHECKER = @PYCHECKER@
 PYCHECKER_FLAGS = --limit 0 
 
@@ -217,16 +215,12 @@ _greens_functions_la_SOURCES=\
 	Logger.cpp\
 	ConsoleAppender.cpp
 
-_gfrd_la_LDFLAGS = -module -export-dynamic -avoid-version $(no_undefined) -Wl,--no-undefined
-_gfrd_la_LIBADD = binding/libbinding_utils.la
-_gfrd_la_LIBADD += $(LIBBOOSTPYTHON) $(LIBPYTHON) $(GSL_LIBS)
+_gfrd_la_LDFLAGS = -module -export-dynamic -avoid-version -Wl,--no-undefined
+_gfrd_la_LIBADD = binding/libbinding_utils.la $(LIBBOOSTPYTHON) $(LIBPYTHON) $(GSL_LIBS)
 
-_greens_functions_la_LDFLAGS = -module -export-dynamic -avoid-version $(no_undefined)
+_greens_functions_la_LDFLAGS = -module -export-dynamic -avoid-version 
 _greens_functions_la_LIBADD = $(LIBBOOSTPYTHON) $(LIBPYTHON) $(GSL_LIBS)
 
-#nodist__gfrd_la_SOURCES = \
-#	SphericalBesselTable.hpp
-
 nodist__greens_functions_la_SOURCES = \
 	SphericalBesselTable.hpp\
 	CylindricalBesselTable.hpp
diff --git a/acinclude.m4 b/acinclude.m4
index 017d7a17..2053200d 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -126,8 +126,9 @@ AC_DEFUN([ECELL_CHECK_NUMPY_ARRAY_DESCR], [
   ], [], [
 #include <Python.h>
 #include <numpy/arrayobject.h>
-])
+  ])
   CPPFLAGS="$ac_save_CPPFLAGS"                 
+  AC_DEFINE([NPY_NO_DEPRECATED_API], [0], [Source uses numpy deprecated api (known issue, hard to fix).])
 ])
 
 AC_DEFUN([ECELL_CHECK_LOGGING_MODULE], [
diff --git a/binding/Makefile.am b/binding/Makefile.am
index 144c6bdd..a2261390 100644
--- a/binding/Makefile.am
+++ b/binding/Makefile.am
@@ -1,17 +1,15 @@
 NUMPY_INCLUDE_DIR = @NUMPY_INCLUDE_DIR@
 PYTHON_INCLUDES = @PYTHON_INCLUDES@
 
-
-AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@ -I.. -Wall -g
-AM_CPPFLAGS = @CPPFLAGS@ -DNO_IMPORT ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR}
+AM_CXXFLAGS = -DNO_IMPORT -I.. @BOOST_CPPFLAGS@ @GSL_CFLAGS@ ${PYTHON_INCLUDES} -I${NUMPY_INCLUDE_DIR}
 
 noinst_LTLIBRARIES = libbinding_utils.la
 
 noinst_HEADERS = \
-    bd_propagator_class.hpp \
+        bd_propagator_class.hpp \
 	new_bd_propagator_class.hpp \
 	BDPropagator.hpp \
-    newBDPropagator.hpp \
+        newBDPropagator.hpp \
 	binding_common.hpp \
 	box_class.hpp \
 	Box.hpp \
@@ -96,7 +94,7 @@ noinst_HEADERS = \
 
 libbinding_utils_la_SOURCES = \
 	bd_propagator_class.cpp \
-    new_bd_propagator_class.cpp \
+        new_bd_propagator_class.cpp \
 	box_class.cpp \
 	ConsoleAppender.cpp \
 	cylinder_class.cpp \
diff --git a/configure.ac b/configure.ac
index a1929ebd..f080fb4c 100644
--- a/configure.ac
+++ b/configure.ac
@@ -50,26 +50,17 @@ AC_ARG_ENABLE([debug],
 )
 
 if test -n "$DEBUG"; then
-  CFLAGS=""
-  CXXFLAGS=""
-  CPPFLAGS="-DDEBUG=1"
-fi
-
-if test "$GXX" = "yes"; then
-  CXXFLAGS="$CXXFLAGS -Wall -Wno-unused-local-typedefs"
-  CFLAGS="$CFLAGS -Wall"
+  CXXFLAGS="-DDEBUG=1"
+else
+  CXXFLAGS="-g -O2"
 fi
 
 AC_SUBST(DEBUG)
 
-CXXFLAGS="$CXXFLAGS -g"
-CFLAGS="$CFLAGS -g"
+CXXFLAGS="$CXXFLAGS -Wall -Wno-unused-local-typedefs"
 
 AX_BOOST_BASE([1.37],,AC_MSG_ERROR([could not find required version of BOOST.]))
 
-CPPFLAGS="$CPPFLAGS $BOOST_CPPFLAGS"
-LDFLAGS="$LDFLAGS $BOOST_LDFLAGS"
-
 BOOST_PYTHON_LIBNAME=boost_python
 
 AC_ARG_WITH(boost-python-libname,
diff --git a/samples/benchmark/Makefile.am b/samples/benchmark/Makefile.am
index 735356b8..abd36b1d 100644
--- a/samples/benchmark/Makefile.am
+++ b/samples/benchmark/Makefile.am
@@ -1,7 +1,6 @@
 noinst_PROGRAMS = hardbody
 
-AM_CPPFLAGS = -I$(top_srcdir) $(PYTHON_INCLUDES)
-AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@
+AM_CXXFLAGS = -I$(top_srcdir) @BOOST_CPPFLAGS@ @GSL_CFLAGS@ $(PYTHON_INCLUDES)
 
 hardbody_SOURCES = hardbody.cpp ../../NetworkRules.cpp ../../BasicNetworkRulesImpl.cpp ../../Logger.cpp ../../freeFunctions.cpp
 
diff --git a/test/Makefile.am b/test/Makefile.am
index 54486b37..53664459 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -1,6 +1,8 @@
 PYTHON = @PYTHON@
 #PYTHONPATH = $(PYTHONPATH):$(top_srcdir)
 
+AM_CXXFLAGS = -I$(top_srcdir) @BOOST_CPPFLAGS@ @GSL_CFLAGS@ $(PYTHON_INCLUDES)
+
 CPP_TESTS =\
 DynamicPriorityQueue_test\
 SphericalBesselGenerator_test\
@@ -81,9 +83,6 @@ ReactionRecord_test.py
 #%.py:
 #	$(TESTS_ENVIRONMENT) $(PYTHON) $<
 
-AM_CPPFLAGS = -I$(top_srcdir) $(PYTHON_INCLUDES)
-AM_CXXFLAGS = @CXXFLAGS@ @GSL_CFLAGS@ -Wall -g
-
 check_PROGRAMS = $(CPP_TESTS)
 
 DynamicPriorityQueue_test_SOURCES = \

From 1950ccf8fbb007e3fdc71628956990baa92acec9 Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Thu, 23 Oct 2014 15:24:43 +0200
Subject: [PATCH 1457/1541] Updated INSTALL text.

---
 INSTALL | 34 ++++++++++++++++++----------------
 1 file changed, 18 insertions(+), 16 deletions(-)

diff --git a/INSTALL b/INSTALL
index 5123dbb1..f8944e33 100644
--- a/INSTALL
+++ b/INSTALL
@@ -1,12 +1,13 @@
 
 :author: Koichi Takahashi
+update okt-2014: Marco Seynen			
+
 
 
 Prerequisites
 -------------------------
 
-1. autotools
-   (autoconf (>=2.50), automake (>=1.11) libtool (>=2.2.6))
+1. autotools (autoconf >=2.50, automake >=1.11, libtool (>=2.2.6) or later.
 2. GNU Scientific Library (GSL) 1.11 or later.
 3. Boost C++ Library 1.37 or later.
 4. Python 2.4 or later.
@@ -15,16 +16,17 @@ Prerequisites
 If you use Fedora or any other RedHat lines of linux, check
 if the following RPM packages are installed:
 
-gsl, gsl-devel, numpy, scipy, boost, and boost-devel.
+autoconf automake libtool gcc-c++ gsl gsl-devel boost boost-devel python scipy numpy
+
 
 On Ubuntu Linux and some other Debian families, install the following:
 
-gsl-bin libgsl0-dev libboost-dev libboost-date-time-dev libboost-python-dev libboost-regex-dev libboost-test-dev python-scipy.
+autoconf automake autotools-dev libtool gsl-bin libgsl0-d libboost-all-dev python-scipy python-numpy 
+
 
+In addition to above, optionally also install packages:
 
-In addition to above, optionally,
-6. python-matplotlib if you want to use the plotting scripts in the samples.
-7. Pychecker if you want to run 'make pycheck'.
+python-matplotlib python-h5py pychecker
 
 
 A note on GSL version
@@ -39,17 +41,17 @@ For this reason, use of GSL version 1.11 or later is recommended.
 Building this package
 -------------------------
 
-1. ./configure
-2. make
-
-
-If you cannot find the configure script, or the build process
-fails to complete even if you have set up the environment correctly,
-try
+1. ./autogen.sh
+2. ./configure
+3. make
 
-./autogen.sh
+has been tested on:
+Ubuntu 14.04 LTS
+Ubuntu 10.04 LTS
+Debian 7.7.0
+Fedora 20.1
+CentOS 7.0.14.06
 
-to remake the entire build mechanism.
 
 
 Testing

From 9a19b8aac19c4749b7033e66c11296816c0f92ad Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Mon, 27 Oct 2014 10:00:19 +0100
Subject: [PATCH 1458/1541] Update Autotools build configuration

---
 INSTALL      |  2 +-
 acinclude.m4 |  2 +-
 configure.ac | 91 ++++++++++++++++++----------------------------------
 3 files changed, 33 insertions(+), 62 deletions(-)

diff --git a/INSTALL b/INSTALL
index f8944e33..57658131 100644
--- a/INSTALL
+++ b/INSTALL
@@ -21,7 +21,7 @@ autoconf automake libtool gcc-c++ gsl gsl-devel boost boost-devel python scipy n
 
 On Ubuntu Linux and some other Debian families, install the following:
 
-autoconf automake autotools-dev libtool gsl-bin libgsl0-d libboost-all-dev python-scipy python-numpy 
+autoconf automake autotools-dev libtool gsl-bin libgsl0-dev libboost-all-dev python-scipy python-numpy 
 
 
 In addition to above, optionally also install packages:
diff --git a/acinclude.m4 b/acinclude.m4
index 2053200d..8e321e8a 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -128,7 +128,7 @@ AC_DEFUN([ECELL_CHECK_NUMPY_ARRAY_DESCR], [
 #include <numpy/arrayobject.h>
   ])
   CPPFLAGS="$ac_save_CPPFLAGS"                 
-  AC_DEFINE([NPY_NO_DEPRECATED_API], [0], [Source uses numpy deprecated api (known issue, hard to fix).])
+  dnl AC_DEFINE([NPY_NO_DEPRECATED_API], [7], [Source uses numpy deprecated api (known issue, hard to fix).])
 ])
 
 AC_DEFUN([ECELL_CHECK_LOGGING_MODULE], [
diff --git a/configure.ac b/configure.ac
index f080fb4c..ba45094f 100644
--- a/configure.ac
+++ b/configure.ac
@@ -1,46 +1,25 @@
+AC_PREREQ([2.50])
 AC_REVISION([$Id$])
-dnl
-dnl
-AC_INIT([eGFRD],[0.9a])
+AC_INIT([eGFRD],[0.9a],[gfrd@amolf.nl])
 AC_CONFIG_SRCDIR([autogen.sh])
-dnl
 AC_DISABLE_STATIC
-AM_PROG_LIBTOOL
-dnl AC_CONFIG_AUX_DIR()
-dnl
-dnl 
-AH_TEMPLATE(HAVE_SINCOS)
-AH_TEMPLATE(HAVE_INLINE)
-dnl 
-dnl
+AC_LANG_CPLUSPLUS
 AC_CANONICAL_TARGET([])
 AM_INIT_AUTOMAKE([subdir-objects])
 
-dnl Check pdflatex
+dnl checks for programs
+AM_PROG_LIBTOOL
 AC_PROG_PDFLATEX()
-
-dnl
+AC_PROG_CXX
+AC_PROG_LN_S
 AC_PROG_MAKE_SET
-dnl
-dnl checks for programs
-dnl
-AM_PATH_PYTHON(2.4)
+AC_PROG_RANLIB
+AM_PATH_PYTHON(2.6)
 
-dnl
-dnl
 dnl checks for libraries
-dnl
-dnl
 AX_PATH_GSL([1.11],,AC_MSG_ERROR([could not find required version of GSL.]))
-dnl
 AC_CHECK_LIB(m,exp,,AC_MSG_ERROR([could not find libm.]))
-dnl
 AC_CHECK_LIB(python${PYTHON_VERSION},main,,AC_MSG_ERROR([could not find libpython.]))
-dnl
-AC_PROG_CXX
-AC_LANG_CPLUSPLUS
-dnl
-dnl
 
 DEBUG=
 AC_ARG_ENABLE([debug],
@@ -54,7 +33,6 @@ if test -n "$DEBUG"; then
 else
   CXXFLAGS="-g -O2"
 fi
-
 AC_SUBST(DEBUG)
 
 CXXFLAGS="$CXXFLAGS -Wall -Wno-unused-local-typedefs"
@@ -83,22 +61,29 @@ AC_ARG_WITH(boost-regex-libname,
 AC_CHECK_LIB($BOOST_REGEX_LIBNAME,main,,AC_MSG_ERROR([could not find libboost_regex.]))
 AC_SUBST(BOOST_REGEX_LIBNAME)
 
-dnl
-dnl
 AM_CHECK_PYMOD(numpy,,,[AC_MSG_ERROR([could not find Python numpy module.])])
 AM_CHECK_PYMOD(scipy,,,[AC_MSG_ERROR([could not find Python scipy module.])])
-dnl
-dnl
-dnl
+
+
 dnl checks for header files
-dnl
-dnl
-dnl
+AC_CHECK_HEADERS([limits.h unistd.h])
+AC_CHECK_HEADER_STDBOOL
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_TYPE_SIZE_T
+AC_TYPE_SSIZE_T
+AC_CHECK_TYPES([ptrdiff_t])
+
+# Checks for library functions.
+AC_FUNC_ERROR_AT_LINE
+AC_CHECK_FUNCS([memmove pow sqrt sincos isfinite])
+AH_TEMPLATE(HAVE_SINCOS)
+AH_TEMPLATE(HAVE_INLINE)
 ECELL_CHECK_NUMPY
 ECELL_CHECK_NUMPY_ARRAY_DESCR
 ECELL_CHECK_LOGGING_MODULE
-dnl
 AM_CHECK_PYTHON_HEADERS()
+
 ac_save_CPPFLAGS="$CPPFLAGS"
 CPPFLAGS="$CPPFLAGS $PYTHON_INCLUDES"
 AC_CHECK_TYPES([PyBaseExceptionObject],[],[],[
@@ -109,8 +94,7 @@ CPPFLAGS="$ac_save_CPPFLAGS"
 AC_CHECK_FUNCS([PyInt_FromSize_t],[],[],[
 #include <Python.h>
 ])
-dnl
-dnl
+
 AC_CHECK_HEADERS([unordered_map boost/unordered_map.hpp boost/functional/hash.hpp])
 AC_CHECK_HEADER([tr1/unordered_map], [
   AC_LANG_SAVE
@@ -139,29 +123,20 @@ AC_CHECK_HEADERS([tr1/functional], [
 #include <tr1/functional>
   ])
 ])
-dnl
-dnl checks for types
-dnl
-dnl
-dnl checks for structures
-dnl
-dnl
+
 dnl checks for compiler characteristics
-dnl
-dnl
 AC_C_INLINE
 if test "$ac_cv_c_inline" != no ; then
    AC_DEFINE(HAVE_INLINE,1)
    AC_SUBST(HAVE_INLINE)
 fi
-dnl
+
 dnl extract LTDL_SHLIB_EXT
-dnl
 rm -f conftest
 ./libtool --config > conftest
 . ./conftest
 rm -f conftest
-dnl
+
 dnl compatibility for libtool 1.5.6
 LTDL_SHLIB_EXT=""
 if test -n "$shrext_cmds"; then
@@ -172,17 +147,13 @@ elif test -n "$shrext"; then
     LTDL_SHLIB_EXT=$shrext
     AC_SUBST(LTDL_SHLIB_EXT)
 fi
-dnl
+
 dnl checks for library functions
-dnl
-AC_CHECK_FUNCS([sincos isfinite])
 AC_CHECK_DECLS([INFINITY, HUGE_VAL],,,[
 #include <math.h>
 ])
-dnl
-dnl
+
 dnl no checks for system services
-dnl
 AM_CONFIG_HEADER([config.h])
 AC_CONFIG_FILES([Makefile binding/Makefile test/Makefile doc/Makefile samples/benchmark/Makefile])
 AC_OUTPUT([])

From a0b26a433a2a10dcd06834a3984cf670227d67e2 Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Mon, 27 Oct 2014 12:23:11 +0100
Subject: [PATCH 1459/1541] The macro seems not to be too widespread (Ubuntu <
 14).

---
 configure.ac | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac
index ba45094f..b276bb1d 100644
--- a/configure.ac
+++ b/configure.ac
@@ -67,7 +67,7 @@ AM_CHECK_PYMOD(scipy,,,[AC_MSG_ERROR([could not find Python scipy module.])])
 
 dnl checks for header files
 AC_CHECK_HEADERS([limits.h unistd.h])
-AC_CHECK_HEADER_STDBOOL
+dnl AC_CHECK_HEADER_STDBOOL
 
 # Checks for typedefs, structures, and compiler characteristics.
 AC_TYPE_SIZE_T

From d0514f304a719e91590242e4f6410e60ca917fa7 Mon Sep 17 00:00:00 2001
From: Luc Blom <blomluc@gmail.com>
Date: Mon, 1 Dec 2014 14:43:23 +0100
Subject: [PATCH 1460/1541] Added sample unit test files

---
 unittests/Test3DOnlyEquib.py    | 122 ++++++++++++++++++++++++++++
 unittests/Test3DOnlyReaction.py | 138 ++++++++++++++++++++++++++++++++
 2 files changed, 260 insertions(+)
 create mode 100644 unittests/Test3DOnlyEquib.py
 create mode 100644 unittests/Test3DOnlyReaction.py

diff --git a/unittests/Test3DOnlyEquib.py b/unittests/Test3DOnlyEquib.py
new file mode 100644
index 00000000..ed5a13e8
--- /dev/null
+++ b/unittests/Test3DOnlyEquib.py
@@ -0,0 +1,122 @@
+# Simulation of the reactions: A + B -(ka)-> C C -(kd)-> A + B
+# ### Importing necessary files ###
+
+# import egfrd libraries
+from egfrd import * 
+import model 
+import gfrdbase 
+import _gfrd 
+
+# Extra functions
+def check_existance( species_id ):
+    pids = w.get_particle_ids(species_id)
+    if(len(pids) > 0): return True
+    else: return False 
+
+def give_pid( species_id ):
+    pids = w.get_particle_ids(species_id)
+    for pid in pids:
+        return pid
+
+# Define the simulation constants.
+def constants():
+    global L, sigma, D3, ka, kd, Kd, NA, NB, NC_max, rnd_seed, Nstep, tsim
+    ka = 1e-19 # Association constant
+    kd = 1e3 # Complex dissociation constant
+    Kd = kd / ka
+    D3 = 1e-12 # Diffusion constant (3D)
+    sigma = 1e-9 # Diameter particle
+    L = 1e-7 # Lengths of simulation
+    NA = 50 # Starting number of A particles
+    NB = 50 # Starting number of B particles
+    NC_max = 50 #Minimal number of C particles
+    rnd_seed = 42 # seed for randomizer
+    Nstep = int(1e8) # Number of steps simulation will last
+    tsim = 100 # Simulated time
+        
+    
+# Define the model (m) with three particle species (A,B,C) and two reaction rules (r1,r2).
+def setup_model():
+    global m, A, B, C, r1, r2
+    
+    # Creates an instance of the ParticleModel class
+    m = model.ParticleModel(L)
+    # Define species:
+    A = model.Species('A', D3, sigma ) # Species([name], [D], [radius=0,]
+    B = model.Species('B', D3, sigma )
+    C = model.Species('C', D3*D3, sigma )
+    # Couple these species to the previously defined particle model
+    m.add_species_type(A) # add_species_type(species)
+    m.add_species_type(B)
+    m.add_species_type(C)
+    # Adding reaction rules for B(DNA) + PROMOTOR <-> C(DNA)
+    r1 = model.create_binding_reaction_rule(A, B, C, ka)
+    m.network_rules.add_reaction_rule(r1)
+    
+    r2 = model.create_unbinding_reaction_rule(C, A, B, kd)
+    m.network_rules.add_reaction_rule(r2)
+
+# SetUp the simulator (s), given the world (w) and the model (m).
+def setup_simulator():
+    global w, s
+
+    # ### Setting up the simulator: ###
+    # Create the world with 3x3x3 cells for the matrixsize
+    w = gfrdbase.create_world(m, 3)
+    myrandom.seed( rnd_seed )
+    # Create a simulator for the world:
+    s = EGFRDSimulator(w, myrandom.rng) # EGFRDSimulator(self, world,
+                                        # rng, network_rules=None)
+    # Place reactant molecules of each species in our world:
+    #throw_in_particles(w, A, NA )
+    #throw_in_particles(w, B, NB )
+    throw_in_particles(w, C, NC_max)
+
+# Defines the number of C-particles given NA, NB, V and Kd
+def N_c(Na, Nb):
+    part = Na + Nb + Kd * L**3
+    NC_min = part - (part**2 - 4 * Na * NB)**0.5
+    return NC_min/(2 * L**3)
+
+
+# ### Set everything up: ###
+constants()
+setup_model() 
+setup_simulator() 
+print '* Initialization complete, starting simulation.'
+
+# ### Let's roll: ###
+print "NC_min_analytic = %s" %(N_c(NA, NB)) 
+t_bind = 0.0 
+t_decay = 0.0 
+oldt_decay = 0.0 
+Nbinds = 0 
+step_cntr = 0 
+lastC_pid = give_pid( A ) 
+CatLastReaction = False; 
+tCbound = 0.0 
+
+while(s.get_next_time() < tsim):
+    s.step()
+    if step_cntr%10000 == 1000:
+        print "step#: %s mln, t = %s, #rebinds = %s, #A = %s, #B = %s, #C= %s, Bound fraction = %s, [C]= %s" %(step_cntr/1e6, s.t, Nbinds, len(w.get_particle_ids(A)), len(w.get_particle_ids(B)), len(w.get_particle_ids(C)), tCbound/s.t, len(w.get_particle_ids(C))/L**3)
+  
+    if s.last_reaction:
+        #Check is last_reaction was the formation of a NEW C particle.
+        if check_existance( C ) and give_pid( C ) != lastC_pid:
+            lastC_pid = give_pid( C )
+            t_bind = s.t
+            Nbinds += 1
+        #Check if last_reaction was the dissociation of a C particle.
+        if CatLastReaction and not check_existance( C ):
+            oldt_decay = t_decay
+            t_decay = s.t
+            tCbound += t_decay - t_bind
+            
+        CatLastReaction = check_existance( C )
+    
+    step_cntr += 1
+
+# Synchronize all domains to tsim.
+s.stop(tsim)
+
diff --git a/unittests/Test3DOnlyReaction.py b/unittests/Test3DOnlyReaction.py
new file mode 100644
index 00000000..a2304a4c
--- /dev/null
+++ b/unittests/Test3DOnlyReaction.py
@@ -0,0 +1,138 @@
+# Simulation of the reactions:
+# A + B -(ka)-> C
+# C     -(kd)-> A + B
+
+
+# ### Importing necessary files ###
+from egfrd import *
+import model
+import gfrdbase
+import _gfrd
+import os
+import sys
+
+
+# Extra functions
+def check_existance( species_id ):
+    pids = w.get_particle_ids(species_id)
+    if(len(pids) > 0): return True
+    else: return False
+
+
+def give_pid( species_id ):
+    pids = w.get_particle_ids(species_id)
+    for pid in pids: return pid
+
+
+def constants():
+    '''Define the simulation constants.'''
+    global L, sigma, D, ka, kd, N, rnd_seed, tend, M_PI, P_c
+
+    M_PI = numpy.pi  # Pi
+    L     = 1e-6     # Lengths of simulation
+    V     = L*L*L    # Volume of simulation
+    sigma = 4.4e-9   # Diameter particle
+    D     = 3e-12    # Diffusion constant (3D)
+    ka    = .001 * 4 * M_PI * (2*sigma)**2 # Association constant
+    kd    = 10.      # Complex dissociation constant
+    N     = 100      # Starting number of particles
+    rnd_seed = 0     # seed for randomizer
+    tend  = 5        # Simulated time
+    c_bar = (N - 1)/V
+    P_c = ka*c_bar/(ka*c_bar + kd) #=t_c/t_tot
+
+def setup_model():
+    '''Define the model (m) with three particle species (A,B,C)
+    and two reaction rules (r1,r2).'''
+    global m, A, B, C, r1, r2
+
+    m = model.ParticleModel(L)
+    A = model.Species('A', 0.,   sigma )
+    B = model.Species('B', D ,   sigma )
+    C = model.Species('C', 0., 2*sigma )
+
+    m.add_species_type(A)
+    m.add_species_type(B)
+    m.add_species_type(C)
+
+    r1 = model.create_binding_reaction_rule(A, B, C, ka)
+    m.network_rules.add_reaction_rule(r1)
+
+    r2 = model.create_unbinding_reaction_rule(C, A, B, kd)
+    m.network_rules.add_reaction_rule(r2)
+
+
+def setup_simulator():
+    '''SetUp the simulator (s), given the world (w) and the model (m).'''
+    global w, s
+
+    w = gfrdbase.create_world(m, 3)
+
+    myrandom.seed( rnd_seed )
+    s = EGFRDSimulator(w, myrandom)
+
+    place_particle(w, A, [0.5*L,0.5*L,0.5*L])
+    throw_in_particles(w, B, N - 1)
+
+
+
+# ### Set everything up: ###
+constants()
+setup_model()
+setup_simulator()
+
+
+# ### Let's roll: ###
+t_current  = 0.0
+t_bind     = 0.0
+t_decay    = 0.0
+oldt_decay = 0.0
+Nbinds     = 0
+step_cntr  = 0
+lastC_pid  = give_pid( A )
+CatLastReaction = False;
+
+print "P_c: {0}".format(P_c)
+
+while(t_current < tend):
+    s.step()
+
+    #print "time: {0}".format(s.t)
+
+    if len(w.get_particle_ids(C)) is not 0:
+        print "step#: %s mln, t = %s, #rebinds = %s, #A = %s, #B = %s" %( step_cntr/1e6, s.t, Nbinds, len(w.get_particle_ids(A)), len(w.get_particle_ids(B)) )
+
+    if step_cntr%1000 == 0:
+        print "step#: %s mln, t = %s, #rebinds = %s, #A = %s, #B = %s" %( step_cntr/1e6, s.t, Nbinds, len(w.get_particle_ids(A)), len(w.get_particle_ids(B)) )
+
+
+    if check_existance(C):
+        print "got C particle! time: {0}".format(s.t)
+
+    if s.last_reaction:
+        #Check is last_reaction was the formation of a NEW C particle.
+        if check_existance( C ) and give_pid( C ) != lastC_pid:
+            lastC_pid = give_pid( C )
+            t_bind = s.t
+            Nbinds += 1
+
+            print "time: {0}".format(s.t)
+
+        #Check if last_reaction was the dissociation of a C particle.
+        if CatLastReaction and not check_existance( C ):
+            oldt_decay = t_decay
+            t_decay = s.t
+            outfile_t.write('%.15g %.15g %.15g\n' %(t_bind, t_decay, t_bind - oldt_decay ) )
+            print "Bind @: %s, Decay @: %s, Rebind time: %s " %(t_bind, t_decay, t_bind - oldt_decay)
+            outfile_t.flush()
+
+        CatLastReaction = check_existance( C )
+    step_cntr += 1
+    t_current = s.get_next_time()
+
+# Synchronize all domains to tend.
+s.stop(tend)
+
+
+# ### Quitting: ###
+print '* Bye.'

From 60f7614feb62431e0e3860c7a7a5e54c7c95596f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Dec 2014 12:10:50 +0100
Subject: [PATCH 1461/1541] Minor cleanup in egfrd.py

---
 egfrd.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index 3f9c0a38..6fa7972f 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1620,7 +1620,7 @@ def fire_interaction(self, single, reactant_pos, reactant_structure_id, ignore):
             # 1.5 No new position/structure_id required
             # 2. No space required
             # 3. No space required
-            # 4. process the changes (remove particle, make new ones)
+            # 4. process the changes (remove particle, make new ones)            
             self.world.remove_particle(reactant[0])
             products = []
             # zero_singles/ignore is unchanged.
@@ -2241,6 +2241,9 @@ def process_single_event(self, single, ignore):
 
             ### 5. Make a new domain (or reuse the old one) for each particle(s)
             #      (Re)schedule the (new) domain
+            if __debug__ and particles == []:
+                log.info('Empty particles list, no new domains will be made.')
+
             zero_singles = []
             for pid_particle_pair in particles:
 #               single.pid_particle_pair = pid_particle_pair         # TODO reuse single

From 064493f54e0b134c7ac5b0cee8fdbfd82d26bc91 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Dec 2014 12:12:30 +0100
Subject: [PATCH 1462/1541] Replace an assert by raise exception in shells.py

---
 shells.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index 7476ed64..9bfbe6e3 100755
--- a/shells.py
+++ b/shells.py
@@ -226,7 +226,9 @@ class testTransitionSingle(testSingle, Others):
     def __init__(self, single, target_structure):
 
         testSingle.__init__(self, single.pid_particle_pair, single.structure)
-        assert (self.structure.sid == target_structure.sid)     # Both structures are of same structure_type
+        if not self.structure.sid == target_structure.sid:
+            # Both structures should be of same structure_type for a transition
+            raise testShellError('Structures are not of equal structure type in test transition.')
 
         self.single = single
 
@@ -1712,7 +1714,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
                                            'domain = %s, radius = %s, min_radius = %s, testShell = %s' %
                                            (neighbor, radius, min_radius, self))
 
-        # we calculated a valid radius -> suscess!
+        # we calculated a valid radius -> success!
         assert radius >= min_radius, 'SphericaltestShell radius smaller than the minimum, radius = %s, min_radius = %s.' % \
                                      (radius, min_radius)
 

From f74d3539154dbcbf970eabbc64bb30a574fac22f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@bionet3.amolf.nl>
Date: Wed, 3 Dec 2014 12:14:25 +0100
Subject: [PATCH 1463/1541] Fix a typo

---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index f48e40b9..2a8b7f79 100644
--- a/utils.py
+++ b/utils.py
@@ -72,7 +72,7 @@ def feq(a, b, typical=1, tolerance=TOLERANCE):
 
     The (relative) tolerance must be positive and << 1.0
 
-    Instead of specifying an absolute tolerance, you can speciy a 
+    Instead of specifying an absolute tolerance, you can specify a 
     typical value for a or b. The absolute tolerance is then the 
     relative tolerance multipied by this typical value, and will be 
     used when comparing a value to zero. By default, the typical 

From 9c981f6e373e01b9da4eded118d563c175a2003c Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Fri, 5 Dec 2014 08:31:10 +0100
Subject: [PATCH 1464/1541] Removed compiler flag 'no-unused-local-typedefs'.

---
 configure.ac | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac
index b276bb1d..965e13d5 100644
--- a/configure.ac
+++ b/configure.ac
@@ -35,7 +35,7 @@ else
 fi
 AC_SUBST(DEBUG)
 
-CXXFLAGS="$CXXFLAGS -Wall -Wno-unused-local-typedefs"
+CXXFLAGS="$CXXFLAGS -Wall"
 
 AX_BOOST_BASE([1.37],,AC_MSG_ERROR([could not find required version of BOOST.]))
 

From 1f7bccb4d48597689bc6c01d090f1dd45a9d6dbf Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Mon, 8 Dec 2014 16:14:32 +0100
Subject: [PATCH 1465/1541] Code cleanup, removed 'unused'
 types/variables/defines. Less warnings (<10).

---
 CuboidalRegion.hpp                            |   2 +-
 Cylinder.hpp                                  |   2 +-
 CylindricalBesselGenerator.hpp                |   3 -
 CylindricalSurface.hpp                        |   2 +-
 Defs.hpp                                      |  16 +--
 Disk.hpp                                      |   2 +-
 DiskSurface.hpp                               |   2 +-
 EGFRDSimulator.hpp                            |   6 -
 GreensFunction1DRadAbs.hpp                    |   5 +-
 GreensFunction2DAbsSym.cpp                    |   2 +-
 GreensFunction2DRadAbs.cpp                    |  40 +++---
 GreensFunction3DRadAbs.cpp                    |  34 ++---
 GreensFunction3DRadInf.cpp                    |   4 +-
 Multi.hpp                                     |   6 +-
 ParticleContainerBase.hpp                     |   2 +-
 PlanarSurface.hpp                             |   2 +-
 Plane.hpp                                     |   2 +-
 SphericalBesselGenerator.hpp                  |   3 -
 SphericalSurface.hpp                          |   2 +-
 Structure.hpp                                 |   4 +-
 StructureContainer.hpp                        |  13 +-
 StructureFunctions.hpp                        | 116 +++++++++---------
 World.hpp                                     |  11 +-
 binding/module_functions.cpp                  |   2 -
 freeFunctions.cpp                             |   2 +-
 peer/wrappers/range/stl_container_wrapper.hpp |   1 -
 utils/map_adapter.hpp                         |   2 +-
 27 files changed, 130 insertions(+), 158 deletions(-)

diff --git a/CuboidalRegion.hpp b/CuboidalRegion.hpp
index ca627fbd..789d786b 100644
--- a/CuboidalRegion.hpp
+++ b/CuboidalRegion.hpp
@@ -111,7 +111,7 @@ class CuboidalRegion
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& side_comparison_vector() const
+    virtual position_type const side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/Cylinder.hpp b/Cylinder.hpp
index 67a99ea0..7dc794fa 100644
--- a/Cylinder.hpp
+++ b/Cylinder.hpp
@@ -180,7 +180,7 @@ inline typename Cylinder<T_>::length_type
 distance(Cylinder<T_> const& obj,
                 typename Cylinder<T_>::position_type const& pos)
 {
-    typedef typename Cylinder<T_>::position_type position_type;
+  //typedef typename Cylinder<T_>::position_type position_type;
     typedef typename Cylinder<T_>::length_type length_type;
 
     /* First compute the (r,z) components of pos in a coordinate system 
diff --git a/CylindricalBesselGenerator.hpp b/CylindricalBesselGenerator.hpp
index 15a630ce..d0ff1ccb 100644
--- a/CylindricalBesselGenerator.hpp
+++ b/CylindricalBesselGenerator.hpp
@@ -11,9 +11,6 @@
 
 class CylindricalBesselGenerator
 {
-
-    typedef UnsignedInteger Index;
-
 public:
 
     CylindricalBesselGenerator()
diff --git a/CylindricalSurface.hpp b/CylindricalSurface.hpp
index bda8cbfa..e27a4022 100644
--- a/CylindricalSurface.hpp
+++ b/CylindricalSurface.hpp
@@ -136,7 +136,7 @@ class CylindricalSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& side_comparison_vector() const
+    virtual position_type const side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/Defs.hpp b/Defs.hpp
index 5a4e6e11..5ba7b46f 100644
--- a/Defs.hpp
+++ b/Defs.hpp
@@ -6,21 +6,11 @@
 typedef double Real;
 typedef long int Integer;
 typedef unsigned long int UnsignedInteger;
-typedef size_t Index;
 
-// stringifiers.  see preprocessor manual
-#define XSTR( S ) STR( S )
 #define STR( S ) #S
-
-#define THROW_UNLESS( CLASS, EXPRESSION )       \
-    if( ! ( EXPRESSION ) )\
-    {\
-        throw CLASS( "Check [" + std::string( STR( EXPRESSION ) ) +\
-                     "] failed." );\
-    }\
-
-
-#define IGNORE_RETURN (void)
+#define THROW_UNLESS( CLASS, EXPRESSION )\
+    if(!(EXPRESSION))\
+      throw CLASS("Check ["+std::string(STR(EXPRESSION)) + "] failed.");
 
 const Real SEPARATION_TOLERANCE( 1e-07  );
 const Real MINIMAL_SEPARATION_FACTOR( 1.0 + SEPARATION_TOLERANCE );
diff --git a/Disk.hpp b/Disk.hpp
index b4241901..676cc33a 100644
--- a/Disk.hpp
+++ b/Disk.hpp
@@ -171,7 +171,7 @@ inline typename Disk<T_>::length_type
 distance(Disk<T_> const& obj,
                 typename Disk<T_>::position_type const& pos)
 {
-    typedef typename Disk<T_>::position_type position_type;
+  //typedef typename Disk<T_>::position_type position_type;
     typedef typename Disk<T_>::length_type length_type;
 
     /* First compute the (r,z) components of pos in a coordinate system 
diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 91b393bc..923fe1de 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -150,7 +150,7 @@ class DiskSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& side_comparison_vector() const
+    virtual position_type const side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index e69b0d0c..9d8b417b 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -2331,9 +2331,6 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
     template<typename Tshell>
     void determine_next_event(AnalyticalSingle<traits_type, Tshell>& domain)
     {
-        typedef Tshell shell_type;
-        typedef typename shell_type::shape_type shape_type;
-        typedef typename detail::get_greens_function<shape_type>::type greens_function;
         time_type const dt_reaction(draw_single_reaction_time(domain.particle().second.sid()));
         time_type const dt_escape_or_interaction(draw_escape_or_interaction_time(domain));
         LOG_DEBUG(("determine_next_event: %s => dt_reaction=%.16g, "
@@ -2454,7 +2451,6 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
     void restore_domain(AnalyticalSingle<traits_type, T>& domain,
                         std::pair<domain_id_type, length_type> const& closest)
     {
-        typedef typename AnalyticalSingle<traits_type, T>::shell_type shell_type;
         domain_type const* closest_domain(
             closest.second == std::numeric_limits<length_type>::infinity() ?
                 (domain_type const*)0: get_domain(closest.first).get());
@@ -3202,8 +3198,6 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
     template<typename T>
     void fire_event(AnalyticalPair<traits_type, T>& domain, pair_event_kind kind)
     {
-        typedef AnalyticalSingle<traits_type, T> corresponding_single_type;
-
         if (kind == PAIR_EVENT_IV_UNDETERMINED)
         {
             // Draw actual pair event for iv at very last minute.
diff --git a/GreensFunction1DRadAbs.hpp b/GreensFunction1DRadAbs.hpp
index 9a4d294d..60920ef3 100644
--- a/GreensFunction1DRadAbs.hpp
+++ b/GreensFunction1DRadAbs.hpp
@@ -262,12 +262,11 @@ class GreensFunction1DRadAbs: public GreensFunction
     uint guess_maxi( Real const& t ) const;
 
     /* this is the appropriate definition of the function in gsl. */
-    static double tan_f (double x, void *p);
-
+    static Real tan_f (Real x, void *p);
 
     /* functions for drawTime / p_survival */
 
-    static double drawT_f (double t, void *p);
+    static Real drawT_f (Real t, void *p);
 
     Real p_survival_table( Real  t, RealVector& psurvTable ) const;
 
diff --git a/GreensFunction2DAbsSym.cpp b/GreensFunction2DAbsSym.cpp
index 3b8726a1..a7289e30 100644
--- a/GreensFunction2DAbsSym.cpp
+++ b/GreensFunction2DAbsSym.cpp
@@ -244,7 +244,7 @@ GreensFunction2DAbsSym::drawR( const Real rnd, const Real t ) const
         return 0.0;
     }
 
-    const Real thresholdDistance( this->CUTOFF_H * sqrt( 4.0 * D * t ) );
+    //const Real thresholdDistance( this->CUTOFF_H * sqrt( 4.0 * D * t ) );
 
     gsl_function F;
     Real psurv;
diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index b569ca1f..544c10ee 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -121,13 +121,13 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
     // Needed? TODO
 //  const Real h_s( h * sigma);
 
-    const double J0_s_An (gsl_sf_bessel_J0(s_An));
-    const double J1_s_An (gsl_sf_bessel_J1(s_An));
-    const double J0_a_An (gsl_sf_bessel_J0(a_An));
+    const Real J0_s_An (gsl_sf_bessel_J0(s_An));
+    const Real J1_s_An (gsl_sf_bessel_J1(s_An));
+    const Real J0_a_An (gsl_sf_bessel_J0(a_An));
 
-    const double Y0_s_An (gsl_sf_bessel_Y0(s_An));
-    const double Y1_s_An (gsl_sf_bessel_Y1(s_An));
-    const double Y0_a_An (gsl_sf_bessel_Y0(a_An));	
+    const Real Y0_s_An (gsl_sf_bessel_Y0(s_An));
+    const Real Y1_s_An (gsl_sf_bessel_Y1(s_An));
+    const Real Y0_a_An (gsl_sf_bessel_Y0(a_An));	
 
 //  const double rho1 ( ( (h_s * J0_s_An) + (s_An * J1_s_An) ) * Y0_a_An );
 //  const double rho2 ( ( (h_s * Y0_s_An) + (s_An * Y1_s_An) ) * J0_a_An );
@@ -135,8 +135,8 @@ GreensFunction2DRadAbs::f_alpha0( const Real alpha ) const
 
     // Sigma can be divided out, roots will remain same:
     // (Note: actually double checked this).
-    const double rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
-    const double rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
+    const Real rho1 ( ( (h * J0_s_An) + (alpha * J1_s_An) ) * Y0_a_An );
+    const Real rho2 ( ( (h * Y0_s_An) + (alpha * Y1_s_An) ) * J0_a_An );
 
     return rho1 - rho2;
 }
@@ -172,16 +172,16 @@ const Real GreensFunction2DRadAbs::f_alpha( const Real alpha,
     const Real realn( static_cast<Real>( n ) );
     const Real h_sigma( h * sigma);
 
-    const double Jn_s_An (gsl_sf_bessel_Jn(n,s_An));
-    const double Jn1_s_An (gsl_sf_bessel_Jn(n+1,s_An));
-    const double Jn_a_An (gsl_sf_bessel_Jn(n,a_An));
+    const Real Jn_s_An (gsl_sf_bessel_Jn(n,s_An));
+    const Real Jn1_s_An (gsl_sf_bessel_Jn(n+1,s_An));
+    const Real Jn_a_An (gsl_sf_bessel_Jn(n,a_An));
 
-    const double Yn_s_An (gsl_sf_bessel_Yn(n,s_An));
-    const double Yn1_s_An (gsl_sf_bessel_Yn(n+1,s_An));
-    const double Yn_a_An (gsl_sf_bessel_Yn(n,a_An));
+    const Real Yn_s_An (gsl_sf_bessel_Yn(n,s_An));
+    const Real Yn1_s_An (gsl_sf_bessel_Yn(n+1,s_An));
+    const Real Yn_a_An (gsl_sf_bessel_Yn(n,a_An));
 
-    const double rho1 ( ( (h_sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
-    const double rho2 ( ( (h_sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
+    const Real rho1 ( ( (h_sigma * Jn_s_An) + (s_An * Jn1_s_An) - realn*Jn_s_An ) * Yn_a_An );
+    const Real rho2 ( ( (h_sigma * Yn_s_An) + (s_An * Yn1_s_An) - realn*Yn_s_An ) * Jn_a_An );
     return (rho1 - rho2); 
 
 //  Or..?
@@ -842,10 +842,10 @@ GreensFunction2DRadAbs::p_survival_table( const        Real t,
           
     if( psurvTable.size() < maxi + 1 )           // if the dimensions are good then this means
     {                                            // that the table is filled
-        IGNORE_RETURN getAlpha( 0, maxi );       // this updates the table of roots
-            this->createPsurvTable( psurvTable); // then the table is filled with data
+       getAlpha( 0, maxi );                      // this updates the table of roots
+       this->createPsurvTable( psurvTable);      // then the table is filled with data
     }
-    // A sum over terms is performed, where convergence is assumed. It is not 
+        // A sum over terms is performed, where convergence is assumed. It is not 
     // clear if this is a just assumption.
     // TODO!
     p = funcSum_all( boost::bind( &GreensFunction2DRadAbs::p_survival_i_exp_table,
@@ -1674,7 +1674,7 @@ Real GreensFunction2DRadAbs::givePDFR( const Real r, const Real t ) const
             return r0;
     }
 
-    const Real psurv( p_survival( t ) ); // calculate the survival probability at this time
+    p_survival(t); // calculate the survival probability at this time
                                          // this is used as the normalization factor
                                          // BEWARE!!! This also produces the roots An and therefore
                                          // SETS THE HIGHEST INDEX -> side effect
diff --git a/GreensFunction3DRadAbs.cpp b/GreensFunction3DRadAbs.cpp
index 8269c6be..b7152ad4 100644
--- a/GreensFunction3DRadAbs.cpp
+++ b/GreensFunction3DRadAbs.cpp
@@ -1171,7 +1171,7 @@ GreensFunction3DRadAbs::p_survival_table(Real t, RealVector& psurvTable) const
             
             if (psurvTable.size() < maxi + 1)
             {
-                IGNORE_RETURN getAlpha0(maxi);  // this updates the table
+                getAlpha0(maxi);  // this updates the table
                 this->createPsurvTable(psurvTable);
             }
 
@@ -1270,10 +1270,10 @@ struct p_survival_params
     const Real rnd;
 };
 
-static Real p_survival_F(Real t, p_survival_params const* params)
-{
-    return params->rnd - params->gf->p_survival(t);
-}
+//NOT USED static Real p_survival_F(Real t, p_survival_params const* params)
+//{
+//    return params->rnd - params->gf->p_survival(t);
+//}
 
 struct p_survival_2i_params
 { 
@@ -1281,11 +1281,11 @@ struct p_survival_2i_params
     const Real t;
 };
 
-static Real p_survival_2i_F(Real ri, p_survival_2i_params const* params)
-{
-    return params->gf->p_survival_2i_exp(static_cast<unsigned int>(ri),
-                                         params->t);
-}
+//NOT USED static Real p_survival_2i_F(Real ri, p_survival_2i_params const* params)
+//{
+//    return params->gf->p_survival_2i_exp(static_cast<unsigned int>(ri),
+//                                         params->t);
+//}
 
 struct p_survival_i_alpha_params
 { 
@@ -1293,11 +1293,11 @@ struct p_survival_i_alpha_params
     const Real t;
 };
 
-static Real p_survival_i_alpha_F(Real alpha,
-                                 p_survival_i_alpha_params const* params)
-{
-    return params->gf->p_survival_i_alpha(alpha, params->t);
-}
+//NOT USED static Real p_survival_i_alpha_F(Real alpha,
+//                                 p_survival_i_alpha_params const* params)
+//{
+//    return params->gf->p_survival_i_alpha(alpha, params->t);
+//}
 
 struct p_leave_params
 { 
@@ -1636,7 +1636,7 @@ GreensFunction3DRadAbs::drawPleaves(gsl_function const& F,
     }
     else
     {
-        Real low_value_prev(value);
+        //Real low_value_prev(value);
         low *= .1;
 
         for (;;)
@@ -1661,7 +1661,7 @@ GreensFunction3DRadAbs::drawPleaves(gsl_function const& F,
                           minT, low, GSL_FN_EVAL(&F, low), r0, dump().c_str());
                 return minT;
             }
-            low_value_prev = low_value;
+            //low_value_prev = low_value;
 
             log_.info("drawTime2: adjusting low: %.16g, Fs = %.16g", low, low_value);
             low *= .1;
diff --git a/GreensFunction3DRadInf.cpp b/GreensFunction3DRadInf.cpp
index 90a505b2..2a89c2e5 100644
--- a/GreensFunction3DRadInf.cpp
+++ b/GreensFunction3DRadInf.cpp
@@ -490,7 +490,7 @@ Real GreensFunction3DRadInf::ip_corr_n(unsigned int n, RealVector const& RnTable
 
 Real GreensFunction3DRadInf::p_corr_table(Real theta, Real r, Real t, RealVector const& RnTable) const
 {
-    const Index tableSize(RnTable.size());
+    const size_t tableSize(RnTable.size());
     if(tableSize == 0)
     {
         return 0.0;
@@ -524,7 +524,7 @@ Real GreensFunction3DRadInf::p_corr_table(Real theta, Real r, Real t, RealVector
 Real GreensFunction3DRadInf::ip_corr_table(Real theta, Real r,
                                             Real t, RealVector const& RnTable) const
 {
-    const Index tableSize(RnTable.size());
+    const size_t tableSize(RnTable.size());
     if(tableSize == 0)
     {
         return 0.0;
diff --git a/Multi.hpp b/Multi.hpp
index 91e7f42e..f10151e0 100644
--- a/Multi.hpp
+++ b/Multi.hpp
@@ -814,11 +814,7 @@ class Multi: public Domain<typename Tsim_::traits_type>
        
     void step()
     {
-        boost::scoped_ptr<
-            typename multi_particle_container_type::transaction_type>
-                tx(pc_.create_transaction());
-        typedef typename multi_particle_container_type::transaction_type::particle_id_pair_generator particle_id_pair_generator;
-        typedef typename multi_particle_container_type::transaction_type::particle_id_pair_and_distance_list particle_id_pair_and_distance_list;
+        boost::scoped_ptr<typename multi_particle_container_type::transaction_type> tx(pc_.create_transaction());  
         last_reaction_setter rs(*this);
         volume_clearer vc(*this);
         
diff --git a/ParticleContainerBase.hpp b/ParticleContainerBase.hpp
index 08ae57d0..c788bfeb 100644
--- a/ParticleContainerBase.hpp
+++ b/ParticleContainerBase.hpp
@@ -246,7 +246,7 @@ class ParticleContainerBase
         typename element_type_of<T1_>::type const& D1,
         typename element_type_of<T1_>::type const& D2)
     {
-        typedef typename element_type_of< T1_ >::type element_type;   
+      //typedef typename element_type_of< T1_ >::type element_type;   
 
         T1_ retval;
 
diff --git a/PlanarSurface.hpp b/PlanarSurface.hpp
index 2597d838..57fe0d95 100644
--- a/PlanarSurface.hpp
+++ b/PlanarSurface.hpp
@@ -132,7 +132,7 @@ class PlanarSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // For the plane the normal vector is the natural choice
-    virtual position_type const& side_comparison_vector() const
+    virtual position_type const side_comparison_vector() const
     {
         return base_type::shape().unit_z();
     }
diff --git a/Plane.hpp b/Plane.hpp
index 06cde4e6..c5e4c132 100644
--- a/Plane.hpp
+++ b/Plane.hpp
@@ -429,7 +429,7 @@ template<typename T, typename Trng>
 inline typename Plane<T>::position_type
 random_position(Plane<T> const& shape, Trng& rng)
 {
-    typedef typename Plane<T>::length_type length_type;
+  //typedef typename Plane<T>::length_type length_type;
 
     // -1 < rng() < 1. See for example PlanarSurface.hpp.
     return add(
diff --git a/SphericalBesselGenerator.hpp b/SphericalBesselGenerator.hpp
index 4cd3dc18..40f602f2 100644
--- a/SphericalBesselGenerator.hpp
+++ b/SphericalBesselGenerator.hpp
@@ -12,9 +12,6 @@
 
 class SphericalBesselGenerator
 {
-
-    typedef UnsignedInteger Index;
-
 public:
 
     SphericalBesselGenerator()
diff --git a/SphericalSurface.hpp b/SphericalSurface.hpp
index 7d004634..9c929cd2 100644
--- a/SphericalSurface.hpp
+++ b/SphericalSurface.hpp
@@ -89,7 +89,7 @@ class SphericalSurface
     
     // Vector used to determine whether a particle has crossed the structure
     // Here we return the zero-vector because there is no "sides" to cross
-    virtual position_type const& side_comparison_vector() const
+    virtual position_type const side_comparison_vector() const
     {
         return create_vector<position_type>(0.0, 0.0, 0.0);
     }
diff --git a/Structure.hpp b/Structure.hpp
index a8c0dc87..0bede63c 100644
--- a/Structure.hpp
+++ b/Structure.hpp
@@ -140,8 +140,8 @@ class Structure
     virtual projected_type project_point(position_type const& pos) const = 0;
     virtual projected_type project_point_on_surface(position_type const& pos) const = 0;
     virtual length_type distance(position_type const& pos) const = 0;
-    virtual position_type const& position() const = 0;
-    virtual position_type const& side_comparison_vector() const = 0;
+    virtual position_type const& position() const = 0;      
+    virtual position_type const side_comparison_vector() const = 0;
 
     // Methods used for edge crossing (only for the planes so far)
     virtual position_flag_pair_type deflect(position_type const& pos0, position_type const& displacement) const = 0;
diff --git a/StructureContainer.hpp b/StructureContainer.hpp
index b6eb4994..cdb105d6 100644
--- a/StructureContainer.hpp
+++ b/StructureContainer.hpp
@@ -450,7 +450,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
     typedef typename plane_type::position_type              vector_type;
 
     typedef std::pair<structure_id_type, position_type>     neighbor_id_vector_type;
-    typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
+    //typedef std::pair<position_type, structure_id_type>     position_structid_pair_type;
 
     // Note that we assume that the new position is in the plane (dot(pos, unit_z)==0)
     // and that the position is already transposed for the plane.
@@ -469,7 +469,8 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
     
     // info variables
     bool planes_are_orthogonal( false );
-    bool planes_are_parallel( false );    
+
+    //bool planes_are_parallel( false );    
     
     // Check for (currently unsupported) self-connections
     for( int i=0; i<4; i++ )
@@ -505,7 +506,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
                 new_id = neighbor_id_vector.first;
                 
                 if(neighbor_id_vector.second == zero_vector)
-                    planes_are_parallel = true;
+		  ;//planes_are_parallel = true;
                 else{
                     planes_are_orthogonal = true;
                     neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
@@ -521,7 +522,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
                 new_id = neighbor_id_vector.first;
                 
                 if(neighbor_id_vector.second == zero_vector)
-                    planes_are_parallel = true;
+		  ;//planes_are_parallel = true;
                 else{
                     planes_are_orthogonal = true;
                     neighbor_plane_par = multiply(origin_plane.unit_x(), component_x);
@@ -539,7 +540,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
 
                 new_id = neighbor_id_vector.first;
                 if(neighbor_id_vector.second == zero_vector)
-                    planes_are_parallel = true;
+		  ;//planes_are_parallel = true;
                 else{
                     planes_are_orthogonal = true;
                     neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
@@ -554,7 +555,7 @@ apply_boundary (std::pair<typename Ttraits_::position_type,
 
                 new_id = neighbor_id_vector.first;
                 if(neighbor_id_vector.second == zero_vector)
-                    planes_are_parallel = true;
+		  ;//planes_are_parallel = true;
                 else{
                     planes_are_orthogonal = true;
                     neighbor_plane_par = multiply(origin_plane.unit_y(), component_y);
diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 51d40452..8086d516 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -57,9 +57,9 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::position_type            position_type;
+  //typedef typename Ttraits_::length_type              length_type;
     
     // Currently only species change and decay are supported
     if(origin_structure.id() == target_structure.id()){
@@ -83,7 +83,7 @@ get_pos_sid_pair( CuboidalRegion<Ttraits_>              const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->Sphere).");
@@ -191,7 +191,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->CuboidalRegion).");
@@ -211,7 +211,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere).");
@@ -231,7 +231,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Cylinder).");
@@ -251,7 +251,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Disk).");
@@ -271,7 +271,7 @@ get_pos_sid_pair( SphericalSurface<Ttraits_>            const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Plane).");
@@ -292,9 +292,9 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
     
     position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
     position_type new_pos( add(old_pos, displacement) );    
@@ -313,9 +313,9 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::position_type            position_type;
+  //typedef typename Ttraits_::length_type              length_type;
 
     // Currently only species change and decay are supported
     if(origin_structure.id() == target_structure.id()){
@@ -339,7 +339,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Sphere).");
@@ -428,9 +428,9 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
     
     // Here offset should be the radius of the product species
     
@@ -453,7 +453,7 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Sphere).");
@@ -471,9 +471,9 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     position_type u( origin_structure.surface_dissociation_unit_vector(rng) );
     
@@ -498,9 +498,9 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
-    typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::position_type            position_type;
+  //typedef typename Ttraits_::length_type              length_type;
 
     // Currently only species change and decay are supported
     if(origin_structure.id() == target_structure.id()){
@@ -522,9 +522,9 @@ get_pos_sid_pair( DiskSurface<Ttraits_>                 const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     // Treated in the same way as unbinding from disk to bulk (see above)
     // Here offset should be the radius of the product species
@@ -549,9 +549,9 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
     position_type new_pos( add(old_pos, displacement) );
@@ -572,7 +572,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Sphere).");
@@ -592,7 +592,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Cylinder).");
@@ -645,7 +645,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
                   typename Ttraits_::length_type        const& reaction_length,
                   typename Ttraits_::rng_type           &rng              )
 {
-    typedef typename Ttraits_::structure_id_type          structure_id_type;
+  //typedef typename Ttraits_::structure_id_type          structure_id_type;
     typedef typename Ttraits_::position_type              position_type;
     typedef typename Ttraits_::length_type                length_type;
     typedef std::pair<length_type, length_type>           length_pair_type;
@@ -719,7 +719,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     // Currently we do not allow for pair forward/backward reactions between two different cubes
     if(origin_structure.id() == target_structure.id()){
@@ -752,7 +752,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Sphere).");
@@ -775,7 +775,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Cylinder).");
@@ -799,7 +799,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Disk).");
@@ -822,7 +822,7 @@ get_pos_sid_pair_pair( CuboidalRegion<Ttraits_>               const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (CuboidalRegion->CuboidalRegion/Plane).");
@@ -848,7 +848,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/CuboidalRegion).");
@@ -871,7 +871,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Sphere).");
@@ -894,7 +894,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Cylinder).");
@@ -917,7 +917,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Disk).");
@@ -940,7 +940,7 @@ get_pos_sid_pair_pair( SphericalSurface<Ttraits_>             const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Sphere->Sphere/Plane).");
@@ -964,9 +964,9 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            &rng                )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
     // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
@@ -993,7 +993,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     // Currently we do not allow for pair forward/backward reactions between two different cylinders
     if(origin_structure.id() == target_structure.id()){
@@ -1026,7 +1026,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Cylinder/Sphere).");
@@ -1049,7 +1049,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Cylinder/Disk).");
@@ -1072,7 +1072,7 @@ get_pos_sid_pair_pair( CylindricalSurface<Ttraits_>           const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Cylinder/Plane).");
@@ -1096,9 +1096,9 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            &rng                )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
     // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
@@ -1125,7 +1125,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Disk/Sphere).");
@@ -1148,7 +1148,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     // TODO TODO TODO
     // IMPLEMENT THE UNBINDING FROM THE DISK ACTING AS A SINK!
@@ -1174,7 +1174,7 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Disk->Disk/Disk).");
@@ -1195,9 +1195,9 @@ get_pos_sid_pair_pair( DiskSurface<Ttraits_>                  const& origin_stru
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            &rng                )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     std::pair<position_type, position_type> new_positions( origin_structure.special_geminate_dissociation_positions(rng, s_orig, s_targ, old_pos, reaction_length) );
     // special_geminate_dissociation_positions will produce two new positions close to old_pos taking into account
@@ -1226,7 +1226,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
                        typename Ttraits_::length_type         const& reaction_length,
                        typename Ttraits_::rng_type            &rng                )
 {
-    typedef typename Ttraits_::structure_id_type        structure_id_type;
+  //typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
     typedef typename Ttraits_::length_type              length_type;
     
@@ -1271,7 +1271,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Plane/Sphere).");
@@ -1294,7 +1294,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Plane/Cylinder).");
@@ -1317,7 +1317,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     /*** COMBINATION NOT SUPPORTED ***/
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Plane/Disk).");
@@ -1340,7 +1340,7 @@ get_pos_sid_pair_pair( PlanarSurface<Ttraits_>                const& origin_stru
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    typedef typename Ttraits_::length_type              length_type;
+    //typedef typename Ttraits_::length_type              length_type;
 
     // As a default we produce two new positions on the same plane; in principle the particles can end up
     // on different planes, but this should be treated afterwards via apply_boundary.
diff --git a/World.hpp b/World.hpp
index 421df3f6..de18ec81 100644
--- a/World.hpp
+++ b/World.hpp
@@ -333,7 +333,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     void add_species(species_type const& species)
     {
         // make sure that the structure_type defined in the species exists
-        structure_type_type const& structure_type(get_structure_type(species.structure_type_id()));
+        //structure_type_type const& structure_type(get_structure_type(species.structure_type_id()));
 
         species_map_[species.id()] = species;
         particle_pool_[species.id()] = particle_id_set();
@@ -363,7 +363,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
             particle_pool_.find(sid));
         if (i == particle_pool_.end())
         {
-            throw not_found(std::string("Unknown species (id=") + boost::lexical_cast<std::string>(sid) + ")");
+
+	  throw not_found(std::string("Unknown species (id=") + boost::lexical_cast<std::string>(sid) + ")");
         }
         return (*i).second;
     }
@@ -373,8 +374,8 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
     template <typename Tstructure_>
     structure_id_type add_structure(boost::shared_ptr<Tstructure_> structure)
     {
-        // check that the structure_type that is defined in the structure exists!
-        structure_type_type const& structure_type(get_structure_type(structure->sid()));
+           // check that the structure_type that is defined in the structure exists!
+      //structure_type_type const& structure_type(get_structure_type(structure->sid()));
 
         const structure_id_type structure_id(structidgen_());
         structure->set_id(structure_id);
@@ -477,7 +478,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
 
         // check that the structure_type that is defined in the structure exists!
-        structure_type_type const& structure_type(get_structure_type(cuboidal_region->sid()));
+        //structure_type_type const& structure_type(get_structure_type(cuboidal_region->sid()));
 
         cuboidal_region->set_id(default_struct_id);
         update_structure(std::make_pair(default_struct_id, cuboidal_region));
diff --git a/binding/module_functions.cpp b/binding/module_functions.cpp
index 918830cd..fd800e25 100644
--- a/binding/module_functions.cpp
+++ b/binding/module_functions.cpp
@@ -15,8 +15,6 @@ calculate_pair_CoM(Position const& p1,
                    element_type_of< Position >::type const& D2,
                    element_type_of< Position >::type const& world_size)
 {
-    typedef element_type_of<Position>::type element_type;   
-
     Position retval;
 
     const Position p2t(cyclic_transpose<Position>(p2, p1, world_size));
diff --git a/freeFunctions.cpp b/freeFunctions.cpp
index c58793fb..eb2e4ea7 100644
--- a/freeFunctions.cpp
+++ b/freeFunctions.cpp
@@ -616,7 +616,7 @@ Real I_bd_1D(Real sigma, Real t, Real D, Real v)
 
     const Real Dt4(4 * D * t);
     const Real sqrt4Dt(std::sqrt(Dt4));
-    double vt = v*t;
+    Real vt = v*t;
 
     const Real arg1(-(2*sigma + vt)*(2*sigma + vt)/Dt4);
     const Real term1(expl( -vt*vt/Dt4 ) - expl( arg1 ));
diff --git a/peer/wrappers/range/stl_container_wrapper.hpp b/peer/wrappers/range/stl_container_wrapper.hpp
index abc47838..f9640809 100644
--- a/peer/wrappers/range/stl_container_wrapper.hpp
+++ b/peer/wrappers/range/stl_container_wrapper.hpp
@@ -189,7 +189,6 @@ class stl_container_wrapper
         }
         catch (boost::python::error_already_set const&)
         {
-            return NULL;
         }
         return 0;
     }
diff --git a/utils/map_adapter.hpp b/utils/map_adapter.hpp
index 0416510c..7ecffd08 100644
--- a/utils/map_adapter.hpp
+++ b/utils/map_adapter.hpp
@@ -2,7 +2,7 @@
 #define MAP_ADAPTER_HPP
 
 #include <utility>
-#include "utils.hpp"
+//#include "utils.hpp"
 #include <boost/range/size.hpp>
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

From 02963e840e5ea552a62a52f09337434be5cb2a57 Mon Sep 17 00:00:00 2001
From: Marco Seynen <m.seynen@amolf.nl>
Date: Tue, 9 Dec 2014 15:06:53 +0100
Subject: [PATCH 1466/1541] Fixed 'narrowing'-warning.

---
 binding/MatrixSpace.hpp | 2 +-
 binding/Particle.hpp    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/binding/MatrixSpace.hpp b/binding/MatrixSpace.hpp
index 6e609f27..a2681cf5 100644
--- a/binding/MatrixSpace.hpp
+++ b/binding/MatrixSpace.hpp
@@ -80,7 +80,7 @@ struct MatrixSpaceExtrasBase
         {
             static PyObject* convert(const result_type& val)
             {
-                const npy_intp dims[1] = { val.size() };
+ 	        const npy_intp dims[1] = { static_cast<const npy_intp>(val.size()) };
                 boost::python::incref(reinterpret_cast<PyObject*>(result_type_descr_));
                 PyObject* retval = PyArray_NewFromDescr(&PyArray_Type,
                         result_type_descr_,
diff --git a/binding/Particle.hpp b/binding/Particle.hpp
index 93f5042f..82718b27 100644
--- a/binding/Particle.hpp
+++ b/binding/Particle.hpp
@@ -162,7 +162,7 @@ class ParticleWrapper
     static PyObject* get_position(ParticleWrapper* self)
     {
         typename Timpl_::position_type const& pos(self->impl_.position());
-        const npy_intp dims[1] = { boost::size(pos) };
+        const npy_intp dims[1] = { static_cast<const npy_intp>(boost::size(pos)) };
         PyObject* retval = PyArray_New(&PyArray_Type, 1,
                 const_cast<npy_intp*>(dims),
                 peer::util::get_numpy_typecode<typename Timpl_::length_type>::value,

From 0d07d5d227b6f305ea55d78e6bc037c6eb593878 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 24 Mar 2015 18:30:35 +0100
Subject: [PATCH 1467/1541] WIP/draft example making use of all features
 (1D+2D+3D)

---
 samples/1D+2D+3D_example/1D+2D+3D_example.py | 473 +++++++++++++++++++
 1 file changed, 473 insertions(+)
 create mode 100755 samples/1D+2D+3D_example/1D+2D+3D_example.py

diff --git a/samples/1D+2D+3D_example/1D+2D+3D_example.py b/samples/1D+2D+3D_example/1D+2D+3D_example.py
new file mode 100755
index 00000000..30a60eaf
--- /dev/null
+++ b/samples/1D+2D+3D_example/1D+2D+3D_example.py
@@ -0,0 +1,473 @@
+#!/usr/bin/python
+
+#####################################################
+##### A simple A+B <-> C reaction on a 2D plane #####
+##### by TR Sokolowski, 2013                    #####
+#####                                           #####
+#####################################################
+
+##### Start with:
+##### PYTHONPATH=[egfrd directory] LOGLEVEL=[ERROR|DEBUG] python ./2D_example [seed] [no. of particles]
+
+
+# #### Importing necessary files ####
+# import egfrd libraries
+from egfrd import *
+from bd import *
+import model
+import gfrdbase
+import _gfrd
+import os
+import math
+import sys
+
+# Set up the model
+def set_constants():  
+
+    global N_run, t_max, N_log, log_time, log_step, N_save, save_points, loadfile, ws
+    global _SEED_, _VLOG_, _INFO_
+    global place_bulk_particles, place_planes, place_plane_particles, place_rods, place_rod_particles, place_sinks, place_sphere
+    global N_bulk_particles, N_rod_particles, N_plane_particles
+    global Pi
+
+    # Define some simulation parameters
+    world_size = 10e-6  # side length of simulation box [m]
+    ws = world_size     # only an abbreviation
+
+    Pi = math.pi
+
+    # Run and logging parameters
+    N_run = 1e5         # number of simulation steps
+    N_log = 1e9         # number of *last* steps it will log; if N_log>N_run, we will log N_run steps
+    log_step = 0        # number of steps between two log outputs
+                        # if this is 0 the script will log in time intervals instead (defined below)
+    log_time = 0.1      # seconds between two log events of the VTK logger
+    t_max    = 3600.0   # maximal bound for simulated time [sec]
+
+    N_save = 5e4        # saving interval
+    save_points = []    # define arbitrary save points (in steps) here; can be useful in debugging
+
+    loadfile=''         # specify a file with a previous state here if desired
+
+    if(log_step > 0):
+        log_time = 0.0
+
+    # The random seed
+    _SEED_ = int(par1)
+
+    # Some control flags
+    _INFO_ = 1
+    _VLOG_ = 1
+
+    # Define flags
+    place_bulk_particles	= 1
+    place_planes                = 1
+    place_plane_particles       = 1
+    place_rods                  = 1
+    place_rod_particles         = 1
+    place_sinks                 = 0
+    place_sphere		= 0
+
+    # How many particles to place
+    N_bulk_particles		= 40
+    N_rod_particles		= 20
+    N_plane_particles		= surface_to_bulk_no_ratio * N_bulk_particles
+
+
+def setup_model():
+  
+    global m, structure_types, membrane, microtubule, cap, nr, sink
+    global A, Am, At, Ac, B, Bm
+    global L_cyl, R_cyl, R_nucl
+
+    # Create an instance of the ParticleModel class
+    m = model.ParticleModel(ws) 
+
+    # Define the membranes as structure_types
+    structure_types = []
+    membrane = _gfrd.StructureType()
+    membrane['name'] = 'membrane'
+    m.add_structure_type(membrane)
+    structure_types.append(membrane)
+
+    # Define the rod/microtubule structure type
+    microtubule = _gfrd.StructureType()
+    microtubule['name'] = 'microtubule'
+    m.add_structure_type(microtubule)
+    structure_types.append(microtubule)
+
+    # Define the cap and sink structure type
+    cap = _gfrd.StructureType()
+    cap['name'] = 'cap'
+    m.add_structure_type(cap)
+    structure_types.append(cap)
+
+    sink = _gfrd.StructureType()
+    sink['name'] = 'sink'
+    m.add_structure_type(sink)
+    structure_types.append(sink)
+
+    nr = _gfrd.StructureType()
+    nr['name'] = 'non-reactive'
+    m.add_structure_type(nr)
+    structure_types.append(nr)
+
+    #############################
+    ##### General parameters ####
+    #############################
+    # Define species parameters
+    R_part  = 30.0e-9  # Particle radius [m]
+    D_part  = 1e-12    # Particle bulk diff. const. [m^2/sec]
+    v_drift = 0.5e-6   # [m/sec]
+    L_cyl   = 0.45*ws
+    R_cyl   = 25.0e-9  # cylinder radius, 25 nm = MT radius
+    R_nucl  = 0.15*ws
+    
+    ####################################
+    ##### Define the reaction rates ####
+    ####################################
+    # Binding to the membrane
+    kb_to_membrane   = 1e-6
+    ku_from_membrane = 0
+    # Which of the bulk species should bind to the membrane
+    bind_A           = 1
+    bind_B           = 0
+
+    # Binding to the rod
+    kb_to_rod       = 1e-11
+    ku_from_rod     = 0
+
+    # Binding to the rod cap
+    kb_to_cap        = 0
+    ku_from_cap      = 0    
+        # should be zero if the following are not, and vice versa
+    # Binding to cap cluster
+    kb_to_cc         = 1e-5
+    ku_from_cc       = 1.0/tip_dwelltime
+
+    # Binding to a sink on the rod
+    kb_to_sink       = 0
+    kb_from_sink     = 0 # not used so far
+
+    # Reactions on the membrane
+    kb_on_membrane = 1e-11
+    ku_on_membrane = 1.0/membrane_dwelltime
+
+    # Reactions between bulk and membrane ("direct binding")
+    kb_to_membrane_particle = kb_on_membrane * 2.0*Pi*R_part
+    ku_from_membrane_particle = ku_on_membrane
+    
+    ##############################
+    ##### Create the species #####
+    ##############################
+    # Define chemical species
+    # Syntax: Species(name, D, radius, [surface], [drift])
+    A   = model.Species('A',   D_part, R_part)
+    Am  = model.Species('Am',  D_part/membrane_slowdown, R_part, membrane)
+    At  = model.Species('At',  D_part/10, R_part, microtubule, v_drift)
+    Ac  = model.Species('Ac',  0, R_part, cap)
+    B   = model.Species('B',   D_part, R_part)
+    Bm  = model.Species('Bm',  D_part/membrane_slowdown, R_part, membrane)
+    AB  = model.Species('AB',  D_part, 1.5*R_part)
+    ABm = model.Species('ABm', D_part/complex_slowdown, 1.5*R_part, membrane)    
+    As  = model.Species('E',   0, R_part, sink)
+
+    # Add these species to the previously defined particle model
+    m.add_species_type(A)
+    m.add_species_type(Am)
+    m.add_species_type(At)
+    m.add_species_type(Ac)
+    m.add_species_type(B)
+    m.add_species_type(Bm)
+    m.add_species_type(AB)
+    m.add_species_type(ABm)
+    m.add_species_type(As)
+    
+    #######################################
+    ##### Create the reaction network #####
+    #######################################
+    existing_rules = []
+    # Binding of A to the membrane
+    # Reaction rule A + membrane <-> Am(membrane)
+    if(kb_to_membrane > 0.0 and bind_A):
+        rb_Am = model.create_binding_reaction_rule(A, membrane, Am, kb_to_membrane)
+        existing_rules.append(rb_Am)
+    if(ku_from_membrane > 0.0):
+        ru_Am = model.create_unimolecular_reaction_rule(Am, A, ku_from_membrane)
+        existing_rules.append(ru_Am)
+        
+    # Binding of B to the membrane
+    # Reaction rule B + membrane <-> Bm
+    if(kb_to_membrane > 0.0 and bind_B):
+        rb_Bm = model.create_binding_reaction_rule(B, membrane, Bm, kb_to_membrane)
+        existing_rules.append(rb_Bm)
+    if(ku_from_membrane > 0.0):
+        ru_Bm = model.create_unimolecular_reaction_rule(Bm, B, ku_from_membrane)
+        existing_rules.append(ru_Bm)
+
+    # Binding of A to the MTs
+    # Reaction rule A + microtubule <-> At(microtubule)
+    if(kb_to_rod > 0.0):
+        rb_At = model.create_binding_reaction_rule(A, microtubule, At, kb_to_rod)
+        existing_rules.append(rb_At)
+    if(ku_from_rod > 0.0):    
+        ru_At = model.create_unimolecular_reaction_rule(At, A, ku_from_rod)
+        existing_rules.append(ru_At)
+
+    # Binding to the microtubule cap
+    # Reaction rule At(microtubule) + cap -> Ac(cap) -> A(bulk)
+    if(kb_to_cap > 0.0):
+        rb_Ac = model.create_binding_reaction_rule(At, cap, Ac, kb_to_cap)
+        existing_rules.append(rb_Ac)
+    if(ku_from_cap > 0.0):
+        ru_Ac = model.create_unimolecular_reaction_rule(Ac, A, ku_from_cap)
+        existing_rules.append(ru_Ac)
+    # ATTENTION! Make sure that this does not repeat the clustering reactions below!
+        
+    # Binding to the sink on the microtubule
+    # Reaction rule At(microtubule) + sink -> As(sink) -> At(microtubule)
+    if(kb_to_sink > 0.0):
+        rb_As = model.create_binding_reaction_rule(At, sink, As, kb_to_sink)
+        existing_rules.append(rb_As)
+    if(ku_from_sink > 0.0):
+        ru_As = model.create_unimolecular_reaction_rule(As, At, ku_from_sink)
+        existing_rules.append(ru_As)
+
+    # Reaction between A and B both on the membrane
+    # Reaction rule Am + Bm <-> ABm
+    if(kb_on_membrane > 0.0):
+        rb_ABm_mem = model.create_binding_reaction_rule(Am, Bm, ABm, kb_on_membrane)
+        existing_rules.append(rb_ABm_mem)
+    if(ku_on_membrane > 0.0):
+        ru_ABm_mem = model.create_unbinding_reaction_rule(ABm, Am, Bm, ku_on_membrane)
+        existing_rules.append(ru_ABm_mem)
+
+    # "Direct" binding of A from bulk to membrane-bound Bm
+    # Reaction rule A + Bm <-> ABm
+    if(kb_to_membrane_particle > 0.0):
+        rb_ABm_dir = model.create_binding_reaction_rule(A, Bm, ABm, kb_to_membrane_particle)
+        existing_rules.append(rb_ABm_dir)
+    if(ku_from_membrane_particle > 0.0):    
+        rb_ABm_dir = model.create_unbinding_reaction_rule(ABm, A, Bm, ku_from_membrane_particle)
+        existing_rules.append(ru_ABm_dir)
+
+    # "Direct" binding of B from bulk to membrane-bound Am
+    # Reaction rule Am + B <-> ABm
+    if(kb_to_membrane_particle > 0.0):
+        rb_ABm_dir_2 = model.create_binding_reaction_rule(Am, B, ABm, kb_to_membrane_particle)
+        existing_rules.append(rb_ABm_dir_2)
+    if(ku_from_membrane_particle > 0.0):    
+        rb_ABm_dir_2 = model.create_unbinding_reaction_rule(ABm, Am, B, ku_from_membrane_particle)
+        existing_rules.append(ru_ABm_dir_2)
+
+    ### TODO: A + B <-> C in bulk        
+
+    # Create a cascade of cap bound species and reactions between them
+    # ATTENTION! Make sure that this does not repeat the cap-binding reaction above!
+    ### TODO: polish this
+    Ncluster_max = 50
+    Ac = []
+    for i in range(0,Ncluster_max):
+
+        cluster_radius = R_part * (1.0+1.0*i/Ncluster_max)
+        Ac.append( model.Species('Ac'+str(i+1), 0, cluster_radius, cap) )
+        m.add_species_type(Ac[i])
+
+    existing_rules.append( model.create_binding_reaction_rule(At, cap, Ac[0], kb_to_cap_cluster) )
+    existing_rules.append( model.create_unimolecular_reaction_rule(Ac[0], A, ku_from_cap_cluster) )
+
+    for i in range(1,Ncluster_max):
+        existing_rules.append( model.create_binding_reaction_rule(At, Ac[i-1], Ac[i], kb_to_cap_cluster) )
+        existing_rules.append( model.create_unbinding_reaction_rule(Ac[i], Ac[i-1], A, ku_from_cap_cluster) )
+    
+    # Finalize:
+    # Add all the rules to the particle model
+    for rule in existing_rules:
+        m.add_reaction_rule(rule)
+
+
+def setup_simulator():
+
+    global w, s, bb_1, bb_2
+    
+    ###############################
+    ##### Set up the simulator ####
+    ###############################
+    # Create a world with 3x3x3 cells for the matrixsize
+    w = gfrdbase.create_world(m, 3)
+
+    # Set default bounding box
+    bb_1 = [0,0,0]
+    bb_2 = [0,0,0]    
+
+    # Get default structure id
+    def_sid = w.get_def_structure_id()
+
+    # Create membranes
+    if place_planes :
+        create_box(w, membrane, [0.5*ws, 0.5*ws, 0.5*ws], [0.95*ws, 0.4*ws, 0.4*ws],one_sided=True)
+        # redefine the bounding box for bulk particle placement
+        bb_1 = [0.10*ws, 0.33*ws, 0.33*ws]
+        bb_2 = [0.90*ws, 0.66*ws, 0.66*ws]
+
+    # Create microtubules/rods with caps
+    if place_rods :
+
+        yz_frac=0.40
+        ry1=yz_frac
+        ry2=1.0-yz_frac
+        rz1=yz_frac
+        rz2=1.0-yz_frac
+
+        rod_1f_id = create_rod(w, microtubule, cap, 'rod_1_left',  [0.5*ws, ry1*ws, rz1*ws], R_cyl, [+1,0,0], L_cyl, back_cap_structure_type=nr)
+        rod_1b_id = create_rod(w, microtubule, cap, 'rod_1_right', [0.5*ws, ry1*ws, rz1*ws], R_cyl, [-1,0,0], L_cyl, back_cap_structure_type=nr)
+        rod_2f_id = create_rod(w, microtubule, cap, 'rod_2_left',  [0.5*ws, ry1*ws, rz2*ws], R_cyl, [+1,0,0], L_cyl, back_cap_structure_type=nr)
+        rod_2b_id = create_rod(w, microtubule, cap, 'rod_2_right', [0.5*ws, ry1*ws, rz2*ws], R_cyl, [-1,0,0], L_cyl, back_cap_structure_type=nr)
+        rod_3f_id = create_rod(w, microtubule, cap, 'rod_3_left',  [0.5*ws, ry2*ws, rz1*ws], R_cyl, [+1,0,0], L_cyl, back_cap_structure_type=nr)
+        rod_3b_id = create_rod(w, microtubule, cap, 'rod_3_right', [0.5*ws, ry2*ws, rz1*ws], R_cyl, [-1,0,0], L_cyl, back_cap_structure_type=nr)
+        rod_4f_id = create_rod(w, microtubule, cap, 'rod_4_left',  [0.5*ws, ry2*ws, rz2*ws], R_cyl, [+1,0,0], L_cyl, back_cap_structure_type=nr)
+        rod_4b_id = create_rod(w, microtubule, cap, 'rod_4_right', [0.5*ws, ry2*ws, rz2*ws], R_cyl, [-1,0,0], L_cyl, back_cap_structure_type=nr)
+        
+        if place_sinks :
+            sink_1a = model.create_disk_surface(sink.id, 'sink_1a', [0.55*ws, rx1*ws, ry1*ws], R_cyl, [1,0,0], rod_1f_id)
+            #w.add_structure(sink_1a)
+            sink_1b = model.create_disk_surface(sink.id, 'sink_1b', [0.65*ws, rx1*ws, ry1*ws], R_cyl, [1,0,0], rod_1f_id)
+            #w.add_structure(sink_1b)
+            sink_1c = model.create_disk_surface(sink.id, 'sink_1c', [0.75*ws, rx1*ws, ry1*ws], R_cyl, [1,0,0], rod_1f_id)
+            #w.add_structure(sink_1c)
+
+    if place_sphere :
+
+        nucleus = model.create_spherical_surface(nr.id, 'nucleus', [0.5*ws, 0.5*ws, 0.5*ws], R_nucl, def_sid)
+        w.add_structure(nucleus)
+
+    # Create an eGFRD simulator for the world
+    myrandom.seed(_SEED_)
+    s = EGFRDSimulator(w, myrandom.rng)
+
+    ##########################
+    ##### Place particles ####
+    ##########################
+    if place_planes and place_plane_particles :
+        throw_in_particles(w, Bm, N_plane_particles)
+        
+    if place_rods and place_rod_particles :
+        throw_in_particles(w, At, N_rod_particles)
+        
+    if place_bulk_particles:
+        # this one needs a bounding box to prevent bulk particles to be placed outside of the cell
+        throw_in_particles(w, A, N_bulk_particles, bb_1, bb_2)
+        #throw_in_particles(w, B, N_bulk_particles/2, bb_1, bb_2)        
+
+    # throw_in_particles() for particles on disks (Ac, As) does not work correctly yet!
+    # but e.g. place_particle(w, Ac[1], [1e-6, 3.8e-6, 3.8e-6]) does
+
+    # Print info about created structures
+    print "***** STRUCTURE TYPES *****"
+    for st in structure_types:
+        print ("%s \t %s" % (st.id, st['name']) )
+    print "***** STRUCTURES *****"
+    for struct in w.structures:
+        print ("%s \t %s \t %s" % (struct.id, struct.sid, struct.name) )
+
+
+def setup_VTK():
+  
+    global vlogger
+    
+    # Set up the visualization toolkit (VTK):
+
+    # Set VTK output directory and check if output directory isn't 
+    # already there
+    vtk_output_directory = 'VTK_out'
+    if (os.path.exists(vtk_output_directory)):
+        print '** WARNING: VTK output directory already exists, possible '+ \
+                'present old VTK files might lead to errors.'
+    
+    # import lib and create logger instance
+    from visualization import vtklogger
+    vlogger = vtklogger.VTKLogger(s, vtk_output_directory, extra_particle_step=True) 
+        # VTKLogger(self, sim, dir='vtkdata', buffer_size=None, show_shells=True, 
+        # extra_particle_step=True, color_dict=None)
+
+
+def main():
+
+        global input_seed, surface_to_bulk_no_ratio, tip_dwelltime, membrane_dwelltime, membrane_slowdown, complex_slowdown
+
+        # #### Read input parameters ####
+        input_seed		 = int(sys.argv[1])
+        surface_to_bulk_no_ratio = float(sys.argv[2])
+        tip_dwelltime		 = float(sys.argv[3])
+        membrane_dwelltime	 = float(sys.argv[4])
+        membrane_slowdown	 = float(sys.argv[5])
+        complex_slowdown	 = float(sys.argv[6])
+
+        assert input_seed >= 0
+        assert surface_to_bulk_no_ratio >= 0.0
+        assert membrane_dwelltime > 0.0
+        assert membrane_slowdown > 0.0
+        assert complex_slowdown > 0.0
+
+        
+        # #### Set everything up: ####
+        set_constants()
+        setup_model()
+        setup_simulator()
+        if _VLOG_:
+                setup_VTK()
+        print '* Initialization complete, starting simulation.'
+        print '* SINGLE_SHELL_FACTOR=%s, MULTI_SHELL_FACTOR=%s, MINIMAL_SEPARATION_FACTOR=%s, SAFETY=%s, TOLERANCE=%s' \
+                        % (SINGLE_SHELL_FACTOR, MULTI_SHELL_FACTOR, MINIMAL_SEPARATION_FACTOR, SAFETY, TOLERANCE)
+        print '* surface_to_bulk_no_ratio=%s, tip_dwelltime=%s, membrane_dwelltime=%s, membrane_slowdown=%s, complex_slowdown=%s, input_seed=%s' \
+                        % (surface_to_bulk_no_ratio, tip_dwelltime, membrane_dwelltime, membrane_slowdown, complex_slowdown, input_seed)        
+        print [structure.id for structure in w.structures]
+        
+        
+        # #### Let's roll: ####
+        step = 0
+        tlast = 0.0
+        
+        if _VLOG_:
+            # log initial configuration
+            vlogger.log()
+        
+        if loadfile != '':
+        
+            s.load_state(loadfile)
+        
+        while step < N_run:
+        
+            step += 1
+            s.step()
+            #s.check() # can be expensive
+
+            if step % (N_run/100) == 0:
+                print "***** SIMULATION PROGRESS = "+str(int(step/N_run*100.0))+"%"
+
+            if step % N_save == 0 or step in save_points:
+                print "***** SAVING STATE at step "+str(int(step))
+                s.save_state('state_'+str(step)+'.ini', reload=True)
+        
+            if _VLOG_ and step > (N_run-N_log) and \
+              ( (log_step and step%log_step==0) or \
+                (log_time and s.t-tlast>=log_time) ):
+        
+                print "***** LOGGER: logging time = "+str(s.t)
+                tlast = s.t
+                vlogger.log()    
+                
+        
+        #### Quitting: ####
+        print '* Done, quitting.'
+        s.stop(s.t)
+        #s.burst_all_domains()
+        s.print_report()
+        if _VLOG_:
+                vlogger.stop()
+                
+        print '* Bye.'
+
+        
+if __name__ == "__main__":
+        main()

From c43407822791216a8ea49536d2e6f8a94c608d7b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 25 Mar 2015 13:18:33 +0100
Subject: [PATCH 1468/1541] Updated comments in the example script

---
 samples/1D+2D+3D_example/1D+2D+3D_example.py | 34 +++++++++++++++-----
 1 file changed, 26 insertions(+), 8 deletions(-)

diff --git a/samples/1D+2D+3D_example/1D+2D+3D_example.py b/samples/1D+2D+3D_example/1D+2D+3D_example.py
index 30a60eaf..88c452be 100755
--- a/samples/1D+2D+3D_example/1D+2D+3D_example.py
+++ b/samples/1D+2D+3D_example/1D+2D+3D_example.py
@@ -1,13 +1,31 @@
 #!/usr/bin/python
 
 #####################################################
-##### A simple A+B <-> C reaction on a 2D plane #####
-##### by TR Sokolowski, 2013                    #####
+##### An example featuring a closed box made up #####
+##### from six planes ("membranes"), involving: #####
 #####                                           #####
+#####   - 3D diffusion inside the box           #####
+#####   - 2D diffusion on the planes            #####
+#####   - 1D transport on rods inside the box   #####
+#####   - reactions in 3D                       #####
+#####   - reactions in 2D                       #####
+#####   - reactions (binding to a cap) in 1D    #####
+#####   - "direct binding" between 3D and 2D    #####
+#####                                           #####
+##### by TR Sokolowski, 2015                    #####
 #####################################################
 
 ##### Start with:
-##### PYTHONPATH=[egfrd directory] LOGLEVEL=[ERROR|DEBUG] python ./2D_example [seed] [no. of particles]
+##### PYTHONPATH=[egfrd directory] LOGLEVEL=[ERROR|DEBUG] python ./1D+2D+3D_example.py [parameters]
+##### where [parameters] = 
+#####         [seed] (random generator seed)
+#####         [surface_to_bulk_ratio] (ratio btw. no. of particles on membrane/in bulk)
+#####         [cap_dwelltime] (1 / unbinding rate from the rod caps)
+#####         [membrane_dwelltime] (1 / unbinding rate from membrane)
+#####         [membrane_slowdown] (ratio bulk diff. const. / membrane single part. diff. const.)
+#####         [complex_slowdown]  (ratio bulk diff. const. / membrane complex diff. const.)
+#####
+##### (in that order)
 
 
 # #### Importing necessary files ####
@@ -143,7 +161,7 @@ def setup_model():
         # should be zero if the following are not, and vice versa
     # Binding to cap cluster
     kb_to_cc         = 1e-5
-    ku_from_cc       = 1.0/tip_dwelltime
+    ku_from_cc       = 1.0/cap_dwelltime
 
     # Binding to a sink on the rod
     kb_to_sink       = 0
@@ -393,12 +411,12 @@ def setup_VTK():
 
 def main():
 
-        global input_seed, surface_to_bulk_no_ratio, tip_dwelltime, membrane_dwelltime, membrane_slowdown, complex_slowdown
+        global input_seed, surface_to_bulk_no_ratio, cap_dwelltime, membrane_dwelltime, membrane_slowdown, complex_slowdown
 
         # #### Read input parameters ####
         input_seed		 = int(sys.argv[1])
         surface_to_bulk_no_ratio = float(sys.argv[2])
-        tip_dwelltime		 = float(sys.argv[3])
+        cap_dwelltime		 = float(sys.argv[3])
         membrane_dwelltime	 = float(sys.argv[4])
         membrane_slowdown	 = float(sys.argv[5])
         complex_slowdown	 = float(sys.argv[6])
@@ -419,8 +437,8 @@ def main():
         print '* Initialization complete, starting simulation.'
         print '* SINGLE_SHELL_FACTOR=%s, MULTI_SHELL_FACTOR=%s, MINIMAL_SEPARATION_FACTOR=%s, SAFETY=%s, TOLERANCE=%s' \
                         % (SINGLE_SHELL_FACTOR, MULTI_SHELL_FACTOR, MINIMAL_SEPARATION_FACTOR, SAFETY, TOLERANCE)
-        print '* surface_to_bulk_no_ratio=%s, tip_dwelltime=%s, membrane_dwelltime=%s, membrane_slowdown=%s, complex_slowdown=%s, input_seed=%s' \
-                        % (surface_to_bulk_no_ratio, tip_dwelltime, membrane_dwelltime, membrane_slowdown, complex_slowdown, input_seed)        
+        print '* surface_to_bulk_no_ratio=%s, cap_dwelltime=%s, membrane_dwelltime=%s, membrane_slowdown=%s, complex_slowdown=%s, input_seed=%s' \
+                        % (surface_to_bulk_no_ratio, cap_dwelltime, membrane_dwelltime, membrane_slowdown, complex_slowdown, input_seed)        
         print [structure.id for structure in w.structures]
         
         

From f8bd09e15eff3c911122a7d02ef4378961b00c75 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 25 Mar 2015 20:46:51 +0100
Subject: [PATCH 1469/1541] Polish the example file

---
 samples/1D+2D+3D_example/1D+2D+3D_example.py | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/samples/1D+2D+3D_example/1D+2D+3D_example.py b/samples/1D+2D+3D_example/1D+2D+3D_example.py
index 88c452be..1ebe7d1d 100755
--- a/samples/1D+2D+3D_example/1D+2D+3D_example.py
+++ b/samples/1D+2D+3D_example/1D+2D+3D_example.py
@@ -55,7 +55,7 @@ def set_constants():
     Pi = math.pi
 
     # Run and logging parameters
-    N_run = 1e5         # number of simulation steps
+    N_run = 1e6         # number of simulation steps
     N_log = 1e9         # number of *last* steps it will log; if N_log>N_run, we will log N_run steps
     log_step = 0        # number of steps between two log outputs
                         # if this is 0 the script will log in time intervals instead (defined below)
@@ -71,7 +71,7 @@ def set_constants():
         log_time = 0.0
 
     # The random seed
-    _SEED_ = int(par1)
+    _SEED_ = int(input_seed)
 
     # Some control flags
     _INFO_ = 1
@@ -165,7 +165,7 @@ def setup_model():
 
     # Binding to a sink on the rod
     kb_to_sink       = 0
-    kb_from_sink     = 0 # not used so far
+    ku_from_sink     = 0 # not used so far
 
     # Reactions on the membrane
     kb_on_membrane = 1e-11
@@ -266,7 +266,7 @@ def setup_model():
         rb_ABm_dir = model.create_binding_reaction_rule(A, Bm, ABm, kb_to_membrane_particle)
         existing_rules.append(rb_ABm_dir)
     if(ku_from_membrane_particle > 0.0):    
-        rb_ABm_dir = model.create_unbinding_reaction_rule(ABm, A, Bm, ku_from_membrane_particle)
+        ru_ABm_dir = model.create_unbinding_reaction_rule(ABm, A, Bm, ku_from_membrane_particle)
         existing_rules.append(ru_ABm_dir)
 
     # "Direct" binding of B from bulk to membrane-bound Am
@@ -275,7 +275,7 @@ def setup_model():
         rb_ABm_dir_2 = model.create_binding_reaction_rule(Am, B, ABm, kb_to_membrane_particle)
         existing_rules.append(rb_ABm_dir_2)
     if(ku_from_membrane_particle > 0.0):    
-        rb_ABm_dir_2 = model.create_unbinding_reaction_rule(ABm, Am, B, ku_from_membrane_particle)
+        ru_ABm_dir_2 = model.create_unbinding_reaction_rule(ABm, Am, B, ku_from_membrane_particle)
         existing_rules.append(ru_ABm_dir_2)
 
     ### TODO: A + B <-> C in bulk        
@@ -291,12 +291,12 @@ def setup_model():
         Ac.append( model.Species('Ac'+str(i+1), 0, cluster_radius, cap) )
         m.add_species_type(Ac[i])
 
-    existing_rules.append( model.create_binding_reaction_rule(At, cap, Ac[0], kb_to_cap_cluster) )
-    existing_rules.append( model.create_unimolecular_reaction_rule(Ac[0], A, ku_from_cap_cluster) )
+    existing_rules.append( model.create_binding_reaction_rule(At, cap, Ac[0], kb_to_cc) )
+    existing_rules.append( model.create_unimolecular_reaction_rule(Ac[0], A, ku_from_cc) )
 
     for i in range(1,Ncluster_max):
-        existing_rules.append( model.create_binding_reaction_rule(At, Ac[i-1], Ac[i], kb_to_cap_cluster) )
-        existing_rules.append( model.create_unbinding_reaction_rule(Ac[i], Ac[i-1], A, ku_from_cap_cluster) )
+        existing_rules.append( model.create_binding_reaction_rule(At, Ac[i-1], Ac[i], kb_to_cc) )
+        existing_rules.append( model.create_unbinding_reaction_rule(Ac[i], Ac[i-1], A, ku_from_cc) )
     
     # Finalize:
     # Add all the rules to the particle model

From 4c308b4330b0ecbc248d7411b3f38a7103a72ed5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 26 Aug 2016 13:36:28 +0200
Subject: [PATCH 1470/1541] An early version for a new VPython based visualiser
 (TIRViE)

"The Imperial-Royal Visualizer for eGFRD"
---
 visualization/TIRViE.py | 1014 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 1014 insertions(+)
 create mode 100644 visualization/TIRViE.py

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
new file mode 100644
index 00000000..fd8075f8
--- /dev/null
+++ b/visualization/TIRViE.py
@@ -0,0 +1,1014 @@
+#
+# ---Prerequisites note---
+#
+# To use this you need to have the following packages installed:
+#
+# - VPython, usually distributed as linux package 'python-visual'
+# - ImageMagick, usually contained by default in modern Linux distributions
+#
+# On most Linux systems the following should do the job of installing them:
+#
+#   $ sudo apt-get install python-visual imagemagick
+#
+#
+import sys
+import os
+import random
+import time
+import numpy as np
+
+import visual as v
+import colorsys # only needed for drawing tomeks_double_helix() objects
+
+from _gfrd import Sphere, Cylinder, Box, Plane, Disk
+from multi import Multi
+from single import *
+from pair import *
+
+__all__ = [
+    'TIRViE',
+    'TheImperialRoyalVisualizerForEGFRD',    
+    ]
+
+    
+
+# Define a small number that will serve to define "zero extensions"
+ALMOST_ZERO = 1e-20
+    
+
+
+class TheImperialRoyalVisualizerForEGFRD:
+  """
+
+    ---The Imperial-Royal Visualizer for eGFRD---
+    
+    started upon urgent request by his Majesty the Emperor
+    by Geh. Computationsrat Dr. T.R. Sokolowski (tomek@hof.kuk)
+    ;-)
+    
+    Version 0.95
+    
+    Wien, 2016
+        
+    TODO Add more info about usage etc.
+    
+  """
+  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames'):
+
+    self.sim = eGFRDsim
+    self.world_size = self.get_world_size()
+    
+    self.objects = []
+
+    self.scene_width  = 1000
+    self.scene_height = 1000
+    self.window_title = "TIRViE -- The Imperial-Royal Visualizer for eGFRD"
+    self.window_id    = '' # set later by self.get_window_id(), once a scene has been created
+    
+    self.SCENE_BACKGROUND_COLOR = v.color.white
+    
+    self.info_label_strings_order = ('b', 's', 'd', 'c', 'o', 'w', 'i')
+    self.INFO_TIME_ONLY           = False
+    
+    # Some flags tuning visual behavior of the objects
+    self.SHOW_SIM_BOX     = True
+    self.WIREFRAME_BOX    = False
+    self.WIREFRAME_PLANES = False
+    self.SHOW_DOMAINS     = True
+    self.SHOW_STRUCTURES  = True
+    self.RODS_AS_HELICES  = False
+    self.SIM_BOX_OPACITY  = 0.05 # sth. around 0.01 -- 0.10 works well
+    self.SHELL_OPACITY    = 0.10 
+    self.PLANAR_SURFACES_OPACITY   = 0.20
+    self.CYLINDER_SURFACES_OPACITY = 0.20
+    self.DISK_SURFACES_OPACITY     = 0.60
+    self.PARTICLE_RADIUS_FACTOR    = 1  # will show particle sphere radii this times larger than actual
+    self.ROD_RADIUS_FACTOR         = 2  # will show radii of cyl. surfaces this times larger than actual
+    self.N_HELIX_COILS             = 30 # sth. btw. 15-30 seems to be a good choice; this is eyecandy anyhow ;-)
+    self.WIREFRAME_RADIUS          = self.world_size/500 # seems fair enough
+    self.HELIX_THICKNESS_FACTOR    = 0.4
+    
+    # No. of random colors in addition to primary
+    self.N_RANDOM_COLORS = 1000
+    
+    # A flag regulating output capturing
+    self.CAPTURE = capture
+    # The directory name where the captured frames will be stored
+    self.capture_dir = capture_dir
+    self.output_image_suffix = '.png' # should be in format .xxx (.png, .jpg, etc.)
+    
+    # A flag to pause/resume the execution of the simulation
+    self.PAUSED = False
+    
+    # Color lists and dictionaries for objects of different species    
+    self.create_default_color_list()
+    
+    if particle_color_dict == {}:
+      self.create_particle_color_dict()
+    else:
+      self.particle_color_dict = particle_color_dict
+    
+    if structure_color_dict == {}:
+      self.create_structure_color_dict()
+    else:
+      self.structure_color_dict = structure_color_dict
+    
+    self.create_shell_color_dict()
+
+    # Prepare the scene
+    self.create_new_scene()
+    
+    # Create output capturing directory
+    self.create_output_directory()      
+        
+        
+  #################################################################        
+  ### TESTING #####################################################
+  #################################################################
+  def visualize(self):    
+    
+    # Ask for pressed keys and handle them
+    if self.scene.kb.keys:
+      key = self.scene.kb.getkey()
+      self.handle_key(key)
+
+    # Ask for mouse click and handle it
+    if self.scene.mouse.events:
+      m = self.scene.mouse.getevent()      
+      if m.click:
+        # Move the info label to the position where the user clicked
+        self.info_label.pos = m.pos
+        
+    if self.PAUSED:
+      self.pause()
+      
+    self.clear_scene()    
+    
+    Bp, Bo, Bs, Bc = self.get_cuboidal_region_data()
+    self.draw_cuboidal_region(Bp, Bo, Bs)
+    
+    Pp, Po, Ps, Pc = self.get_planar_surface_data()
+    self.draw_planar_surfaces(Pp, Po, Ps, Pc)
+    
+    Cp, Co, Cr, Cl, Cc = self.get_cylindrical_surface_data()
+    self.draw_cylindrical_surfaces(Cp, Co, Cr, Cl, Cc)
+    
+    Pp, Pr, Pc = self.get_particle_data()
+    self.draw_particles(Pp, Pr, Pc)
+    
+    sph_shell_data, cyl_shell_data = self.get_protective_domain_data()    
+    self.draw_protective_domains(sph_shell_data, cyl_shell_data)        
+
+    self.update_info_label()
+    
+    if self.CAPTURE:
+    
+      self.capture()
+      
+    
+    #sys.exit()
+  #################################################################
+  #################################################################
+  #################################################################
+  
+  
+  ####################################      
+  ### COLOR LISTS AND DICTIONARIES ###
+  ####################################
+  def create_default_color_list(self):
+    
+    self.default_color_list = []
+    
+    # First colors are the primary ones
+    for c in [v.color.red, v.color.green, v.color.blue, v.color.cyan, v.color.magenta, v.color.yellow, v.color.orange]:
+      
+      self.default_color_list.append(c)
+      
+    # From there we create random RGB colors
+    for n in range(self.N_RANDOM_COLORS):
+        R = random.random()
+        G = random.random()
+        B = random.random()
+        
+        self.default_color_list.append( (R,G,B) )      
+      
+    
+  def create_particle_color_dict(self):   
+    
+    self.particle_color_dict = {}
+    
+    n = 0
+    for species in self.sim.world.species:
+      
+          c = self.default_color_list[n]
+          key = species.id.serial
+          self.particle_color_dict[key] = c
+          n = n + 1
+
+  
+  def create_structure_color_dict(self):   
+    
+    self.structure_color_dict = {}
+    
+    n = 0
+    for struct_type in self.sim.world.structure_types:
+      
+          c = self.default_color_list[n]
+          key = struct_type.id.serial
+          self.structure_color_dict[key] = c
+          n = n + 1
+
+          
+  def create_shell_color_dict(self):
+    
+    self.shell_color_dict = {}
+    
+    # The "top level" shell, i.e. the one to be updated next
+    self.shell_color_dict[0] = v.color.magenta
+    
+    # 'Single' shells
+    self.shell_color_dict[1] = v.color.blue
+    
+    # 'Pair' shells
+    self.shell_color_dict[2] = v.color.green
+    
+    # 'Multi" shells
+    self.shell_color_dict[3] = v.color.orange
+    
+  
+  ######################################      
+  ### SCENE / OUTPUT WINDOW HANDLING ###
+  ######################################
+  def create_new_scene(self):
+    
+    try:
+      #self.scene.delete()
+      window.delete_all()
+      self.objects = []
+    except:
+      print "No scene existing yet, creating now."
+    
+    self.scene = v.display(width = self.scene_width, height = self.scene_height, title = self.window_title)
+    self.scene.background = self.SCENE_BACKGROUND_COLOR
+    self.scene.select()
+    
+    self.info_label   = v.label(pos=(-1.1*self.world_size, 1.1*self.world_size, 0), text = 't = 0', height=10)
+    self.paused_label = v.label(text = 'PAUSED', color = v.color.red, linecolor = v.color.red, visible = False)
+    
+    #self.logo = v.text(pos=(-self.world_size, 1.1*self.world_size, 0), text='TIRViE', height=0.1*self.world_size, width=0.2*self.world_size)
+    # Sadly not working with older versions of vpython...
+    
+    self.get_window_id()
+    
+    print "Scene created."    
+    
+  
+  def clear_scene(self, types_list = [v.box, v.sphere, v.cylinder, v.ring, v.helix, v.frame, v.curve]):
+      
+    for t in types_list:
+      for obj in self.objects:
+          if isinstance(obj, t):
+            
+            # First make the object invisible            
+            obj.visible = False
+            
+            # Now delete the object
+            del obj
+        
+    self.objects = []
+    
+
+  #########################      
+  ### CAPTURING METHODS ###
+  #########################
+  def get_window_id(self):
+    
+    shell_command = 'xprop -name "' + self.window_title + '" | grep "COLORMAP" | cut -d \# -f 2 | tr -d " "'
+    self.window_id = str( os.popen(shell_command).read() )    
+    
+    
+  def create_output_directory(self):
+    
+    try:
+      os.mkdir(self.capture_dir)
+    except OSError:
+      print "WARNING: Cannot create (already existant?) TIRViE output directory."
+      
+    
+  def capture(self):
+    
+    # Check how many output frames there are already
+    frame_no = int( os.popen('ls ' + self.capture_dir + ' | wc -l').read() )
+    # Increase the frame_no by one and give it the right string format
+    formated_frame_no = "%06u" % (frame_no + 1)    
+    # Give the new frame the corresponding name
+    savename = self.capture_dir + '/frame_' + formated_frame_no + self.output_image_suffix
+    # Grab the image (using ImageMagicx) and save it
+    print 'Writing ', savename
+    os.popen('import -window "' + self.window_title + '" ' + savename)        
+    
+    
+  ####################################      
+  ### KEY HANDLING AND INFO OUTPUT ###
+  #################################### 
+  def handle_key(self, k):  
+    
+    # Pausing
+    if k == 'p' or k == 'P':
+      
+      if self.PAUSED == False:
+        
+        self.PAUSED = True
+        self.paused_label.visible = True
+        print '***** PAUSED *****'
+        
+      else:
+      
+        self.PAUSED = False
+        self.paused_label.visible = False
+        print '***** CONTINUING *****'
+        
+    # Visibility of logo and info label
+    if k == 'i' or k == 'I':
+      
+      self.info_label.visible = not(self.info_label.visible)
+      
+    # Show only time in info label
+    if k == 't' or k == 'T':
+      
+      self.INFO_TIME_ONLY = not(self.INFO_TIME_ONLY)
+        
+    # Visibility of simulation box
+    elif k == 'b' or k == 'B':
+      
+      if self.SHOW_SIM_BOX == False:
+        
+        self.SHOW_SIM_BOX = True
+        print '***** SHOWING SIMULATION BOX ("world") *****'
+        
+      else:
+        
+        self.SHOW_SIM_BOX = False
+        print '***** HIDING SIMULATION BOX ("world") *****'
+
+    # Visibility of protective domains
+    elif k == 'd' or k == 'D':
+      
+      if self.SHOW_DOMAINS == False:
+        
+        self.SHOW_DOMAINS = True
+        print '***** SHOWING PROTECTIVE DOMAIN SHELLS *****'
+        
+      else:
+        
+        self.SHOW_DOMAINS = False
+        print '***** HIDING PROTECTIVE DOMAIN SHELLS *****'
+        
+    # Visibility of static structures
+    elif k == 's' or k == 'S':
+      
+      if self.SHOW_STRUCTURES == False:
+        
+        self.SHOW_STRUCTURES = True
+        print '***** SHOWING STATIC STRUCTURES *****'
+        
+      else:
+      
+        self.SHOW_STRUCTURES = False
+        print '***** HIDING STATIC STRUCTURES *****'
+
+    # Style of drawing the cylindrical structures / rods
+    elif k == 'h' or k == 'H':
+      
+      if self.RODS_AS_HELICES == False:
+        
+        self.RODS_AS_HELICES = True
+        print '***** DRAWING RODS AS HELICES *****'
+        
+      else:
+      
+        self.RODS_AS_HELICES = False
+        print '***** DRAWING RODS AS CYLINDERS *****'
+        
+    # Style of drawing the simulation box
+    elif k == 'w' or k == 'W':
+      
+      self.WIREFRAME_BOX = not(self.WIREFRAME_BOX)
+      
+    # Style of drawing the planar surfaces
+    elif k == 'q' or k == 'Q':
+      
+      self.WIREFRAME_PLANES = not(self.WIREFRAME_PLANES)
+        
+    # Toggling output capturing
+    elif k == 'c' or k == 'C':
+      
+      self.CAPTURE = not(self.CAPTURE)
+
+
+  def pause(self):
+  
+    while self.PAUSED:
+      
+      time.sleep(0.25)
+        # prevents permanent key callback query and thus allows for better scrolling
+      
+      if self.scene.kb.keys:
+        key = self.scene.kb.getkey()
+        self.handle_key(key)
+
+        
+  def set_info_label_strings(self):
+    
+    self.info_label_strings = {}        
+      
+    if self.SHOW_SIM_BOX:
+      self.info_label_strings['b'] = '\n[b] showing sim. box'
+    else:
+      self.info_label_strings['b'] = '\n[b] hiding sim. box'      
+      
+    if self.SHOW_DOMAINS:
+      self.info_label_strings['d'] = '\n[d] showing domain shells'
+    else:
+      self.info_label_strings['d'] = '\n[d] hiding domain shells'
+      
+    if self.SHOW_STRUCTURES:
+      self.info_label_strings['s'] = '\n[s] showing structures'
+    else:
+      self.info_label_strings['s'] = '\n[s] hiding structures'
+      
+    if self.CAPTURE:
+      self.info_label_strings['c'] = '\n[c] output capturing ON'
+    else:
+      self.info_label_strings['c'] = '\n[c] output capturing OFF'              
+    
+    #if self.RODS_AS_HELICES:
+      #self.info_label_strings['h'] = '\nrods shown as helices'
+    #else:
+      #self.info_label_strings['h'] = '\nrods shown as cylinders'
+    
+    self.info_label_strings['o'] = '\n\n' + str(len(self.scene.objects)) + ' objects on scene'
+    
+    self.info_label_strings['w'] = '\n\npress [w]/[q] for wireframe box / plane'
+    self.info_label_strings['i'] = '\npress [i]/[t] to (un)hide / show time only\nleft-click to move info label position'
+    
+      
+  def update_info_label(self):
+    
+    self.set_info_label_strings()
+    
+    try:
+      time_str = "%0.3f" % self.sim.t
+      newtext = 't = ' + time_str
+      
+      if not(self.INFO_TIME_ONLY):
+        newtext = newtext + '\n'
+        for key in self.info_label_strings_order:
+          newtext = newtext + self.info_label_strings[key]
+        
+      self.info_label.text = newtext
+    except:
+      pass
+  
+
+  ##################################      
+  ### SIMULATOR QUERYING METHODS ###
+  ##################################
+  def get_world_size(self):
+    """ Returns the longest extent of the world/simulation box
+    """    
+    world_shape = self.sim.world.get_structure(self.sim.world.get_def_structure_id()).shape
+    world_size  = 2.0 * world_shape.half_extent
+
+    return max(world_size)
+    
+    
+  def get_particle_data(self):
+    
+    particles, colors = [], []
+
+    # Get particle data from simulator.
+    for species in self.sim.world.species:
+        for particle_id in self.sim.world.get_particle_ids(species):
+          
+            particle = self.sim.world.get_particle(particle_id)[1]
+            particles.append(particle)
+            
+            try:
+                color = self.particle_color_dict[species.id.serial]
+            except:
+                color = species.id.serial
+                
+            colors.append(color)
+
+    return self.process_spheres(particles, colors)
+
+        
+  def get_protective_domain_data(self):
+  
+    spheres, sphere_colors = [], []
+    cylinders, cylinder_colors = [], []
+
+    if self.SHOW_DOMAINS == True:
+      
+        number_of_shells = self.sim.scheduler.size
+
+        if number_of_shells > 0:
+            top_event_id = self.sim.scheduler.top[0]
+        else:
+            top_event_id = None
+         
+        for object in self.sim.domains.itervalues():
+          
+            # First determine the type of shell 
+            # and set the color accordingly
+            
+            # Single and pairs
+            color = self.shell_color_dict[object.multiplicity]
+
+            # Highlight top_event for singles and pairs
+            if top_event_id != None and object.event_id == top_event_id:                
+                color = self.shell_color_dict[0]                
+
+            # Multi shells
+            if isinstance(object, Multi):
+                color = self.shell_color_dict[3]
+
+            # Now get the shell data
+            try:
+                shell = object.shell_list[0][1]
+                # Only cylinders have half_length.
+                shell.shape.half_length                    
+                cylinders.append(shell)
+                cylinder_colors.append(color)                
+            except:
+                # Shell is not cylinder but sphere 
+                # (Single, Pair or Multi)
+                for _, shell in object.shell_list:
+                    spheres.append(shell)
+                    sphere_colors.append(color)
+
+    return self.process_spheres(spheres, sphere_colors), \
+              self.process_cylinders(cylinders, cylinder_colors)
+
+              
+  def get_cuboidal_region_data(self):
+    
+    boxes = [self.sim.world.get_structure(self.sim.world.get_def_structure_id()).shape]
+
+    return self.process_boxes(boxes)
+
+      
+  def get_planar_surface_data(self):
+    
+    planes, colors = [], []
+    
+    world_id = self.sim.world.get_def_structure_id()
+    planes = [surface for surface
+                      in self.sim.world.structures
+                      if isinstance(surface.shape, Plane)
+                      and not surface.id == world_id]  # why this here? The world is not a plane!
+
+    # Also make a list only containing the 'shape' objects (geometry) of the planes
+    # We have to pass this to 'process_boxes' below because the geometrical features can only
+    # be accessed via surface.shape.[..] (strangely enough, not so for the cylinders, see below)
+    plane_shapes = [surface.shape for surface in planes]    
+    
+    for pl in planes:
+      
+      try:
+        color = self.structure_color_dict[pl.sid.serial]
+      except:
+        color = pl.sid.serial
+              
+      colors.append(color)
+      
+    # In the visualizer, planes are treated as boxes with "zero" z-extension
+    return self.process_boxes(plane_shapes, colors)
+    
+    
+  def get_cylindrical_surface_data(self):
+      
+    cylinders, colors = [], []
+    
+    cylinders = [surface for surface
+                         in self.sim.world.structures
+                         if isinstance(surface.shape, Cylinder)
+                         or isinstance(surface.shape, Disk)]
+                         
+    for cyl in cylinders:
+      
+        try:
+          color = self.structure_color_dict[cyl.sid.serial]
+        except:
+          color = cyl.sid.serial
+                
+        colors.append(color)
+
+    return self.process_cylinders(cylinders, colors)
+
+    
+  def get_spherical_surface_data(self):
+    # TODO so far unused
+    
+    spheres = [surface for surface
+                       in self.sim.world.structures
+                       if isinstance(surface.shape, Sphere)]
+    return self.process_spheres(spheres)
+
+
+  ######################################      
+  ### DATA FORMAT PROCESSING METHODS ###
+  ######################################
+  def process_spheres(self, spheres=[], color_list=[]):
+    # Returns 3 lists:
+    #   - positions, as (x,y,z) vectors
+    #   - radii
+    #   - colors
+    #
+    position_list, radius_list = [], []      
+
+    for sphere in spheres:
+        # The following is necessary to distinguish
+        # shells from surfaces
+        try:
+            pos = sphere.position              
+            radius = sphere.radius
+        except:
+            pos = sphere.shape.position
+            radius = sphere.shape.radius              
+                  
+        formated_position = ( pos[0], pos[1], pos[2] )          
+        
+        position_list.append(formated_position)
+        radius_list.append(radius)
+
+    return (position_list, radius_list, color_list)
+      
+
+  def process_cylinders(self, cylinders=[], color_list=[]):
+    # Return 5 lists:
+    #   - positions
+    #   - orientations
+    #   - radii
+    #   - lengths
+    #   - colors
+    #
+    position_list, orientation_list, radius_list, length_list = [], [], [], []
+
+    for cylinder in cylinders:
+        # Pre-process disks which are put into the same
+        # list as cylinders but lack the half_length property
+        try:
+            if isinstance(cylinder.shape, Disk):
+                disk = cylinder
+                cylinder = self.get_dummy_cylinder()
+                cylinder.position    = disk.shape.position
+                cylinder.radius      = disk.shape.radius
+                cylinder.unit_z      = disk.shape.unit_z
+                cylinder.half_length = 0.0
+        except:
+            pass
+
+        # The following is necessary to distinguish
+        # shells from surfaces
+        try:
+            position = cylinder.position
+            radius = cylinder.radius
+            orientation = cylinder.unit_z
+            half_length = cylinder.half_length
+        except:
+            position = cylinder.shape.position
+            radius = cylinder.shape.radius
+            orientation = cylinder.shape.unit_z
+            half_length = cylinder.shape.half_length
+          
+        # In eGFRD the position points to the center of the cylinder,
+        # in Vpython to one of the ends, so we have to correct for this
+        position = position - half_length * orientation
+
+        position_list.append(position)
+        orientation_list.append(orientation)
+        radius_list.append(radius)
+        length_list.append(2.0*half_length)
+
+    return (position_list, orientation_list, radius_list, length_list, color_list)
+
+    
+  def process_boxes(self, boxes=[], color_list=[]):
+    
+    orientation = []
+    position_list, orientation_list, size_list = [], [], []
+
+    for box in boxes:
+        
+        position = self.to_vector(box.position)
+      
+        try:
+            dz = box.half_extent[2]
+        except IndexError:
+            # Planes don't have half_extent[2].
+            dz = ALMOST_ZERO
+                            
+        orientation_ux = self.to_vector(box.unit_x) # we take the x-axis to be "length"
+        orientation_uy = self.to_vector(box.unit_y) # we also want the other vectors to be able 
+        orientation_uz = self.to_vector(box.unit_z) # to fully construct the box when needed
+        size = (2.0 * box.half_extent[0], 2.0 * box.half_extent[1], 2.0 * dz)
+        
+        position_list.append(position)
+        orientation_list.append( [orientation_ux, orientation_uy, orientation_uz] )
+        size_list.append(size)
+
+    return (position_list, orientation_list, size_list, color_list)
+    
+
+  #############################      
+  ### VISUALIZATION METHODS ###
+  #############################
+  def draw_cuboidal_region(self, position_list, orientation_list, size_list):
+
+    if self.SHOW_SIM_BOX == True:
+      
+      # TODO Check that lists all have the same length
+      for n in range(len(position_list)):
+      
+          orientation_ux, _, _ = orientation_list[n]
+          
+          if not(self.WIREFRAME_BOX):
+            box = v.box(pos=position_list[n], axis=orientation_ux, size=size_list[n], color=(1, 1, 1), opacity=self.SIM_BOX_OPACITY)
+          else:
+            box = self.wireframe_box(pos=position_list[n], orientation=orientation_list[n], size=size_list[n], color=(0, 0, 1), radius=self.WIREFRAME_RADIUS)
+            
+          self.objects.append(box)
+  
+  
+  def draw_planar_surfaces(self, position_list, orientation_list, size_list, color_list):
+    
+    if self.SHOW_STRUCTURES == True:
+      
+      # TODO Check that lists all have the same length
+      for n in range(len(position_list)):
+        
+          orientation_ux, _, _ = orientation_list[n]
+          
+          if not(self.WIREFRAME_PLANES):
+            # Standard planes are treated as boxes with inifinitesimal length in one of the three directions
+            plane = v.box(pos=position_list[n], axis=orientation_ux, size=size_list[n], color=color_list[n], opacity=self.PLANAR_SURFACES_OPACITY)
+          else:
+            plane = box = self.wireframe_box(pos=position_list[n], orientation=orientation_list[n], size=size_list[n], color=color_list[n], radius=self.WIREFRAME_RADIUS)
+            
+          self.objects.append(plane)
+  
+  
+  def draw_cylindrical_surfaces(self, position_list, orientation_list, radius_list, length_list, color_list):
+      
+    if self.SHOW_STRUCTURES == True:
+      
+      # TODO Check that lists all have the same length
+      for n in range(len(position_list)):
+
+          outer_radius = self.ROD_RADIUS_FACTOR*radius_list[n]
+      
+          if self.RODS_AS_HELICES == True and length_list[n] > 0.0:
+            # The standard VPython helix object cannot be properly erased from the scene, so we use an own one ;-)            
+            obj = self.tomeks_double_helix(pos=position_list[n], axis=orientation_list[n], radius=outer_radius, \
+                                              length=length_list[n], color=color_list[n], thickness=self.HELIX_THICKNESS_FACTOR*outer_radius)
+                                              # thickness=self.ROD_RADIUS_FACTOR*radius_list[n]/7 also worked well
+          elif length_list[n] > 0.0:
+            obj = v.cylinder(pos=position_list[n], axis=orientation_list[n], radius=outer_radius, \
+                                  length=length_list[n], color=color_list[n], opacity=self.CYLINDER_SURFACES_OPACITY)
+          else: # the cylinder actually is a disk
+            obj = v.ring(pos=position_list[n], axis=orientation_list[n], radius=outer_radius, \
+                                  thickness=self.HELIX_THICKNESS_FACTOR*outer_radius, color=color_list[n], opacity=self.DISK_SURFACES_OPACITY)
+            
+          self.objects.append(obj)
+
+
+  def draw_particles(self, position_list, radius_list, color_list):  
+    
+    # TODO Check that lists all have the same length
+    for n in range(len(position_list)):
+      
+        sphere = v.sphere(pos=position_list[n], radius=self.PARTICLE_RADIUS_FACTOR*radius_list[n], color=color_list[n])
+        self.objects.append(sphere)
+        
+        
+  def draw_protective_domains(self, spherical_shell_data, cylindrical_shell_data):
+
+    if self.SHOW_DOMAINS == True:      
+      
+      # First unpack the data lists
+      # TODO Check that lists all have the same length      
+      Spos_list, Srad_list, Scol_list                       = spherical_shell_data
+      Cpos_list, Cori_list, Crad_list, Clen_list, Ccol_list = cylindrical_shell_data
+          
+      # Draw the spherical shells
+      for n in range(len(Spos_list)):
+          
+          used_radius  = Srad_list[n]
+          used_opacity = self.SHELL_OPACITY
+          
+          # Special case: check whether the shell is a Multi (by checking its unique color)
+          if Scol_list[n] == self.shell_color_dict[3]:
+            # Then we want to scale up the radius by the same factor as the particles and make them less opaque
+            used_radius  = self.PARTICLE_RADIUS_FACTOR * Srad_list[n]
+            used_opacity = 0.5
+          
+          shell = v.sphere(pos=Spos_list[n], radius=used_radius, color=Scol_list[n], opacity=used_opacity)
+          self.objects.append(shell)
+          
+      # Draw the cylindrical shells
+      for n in range(len(Cpos_list)):
+          
+          # TODO can we somehow also scale up the radius of the cyl. shells of cyl. bound particles (exclusively!)
+          shell = v.cylinder(pos=Cpos_list[n], axis=Cori_list[n], radius=Crad_list[n], length=Clen_list[n], color=Ccol_list[n], opacity=self.SHELL_OPACITY)
+          self.objects.append(shell)
+
+          
+  def wireframe_box(self, pos=(0,0,0), orientation=[(1,0,0),(0,1,0),(0,0,1)], size=(1,1,1), color=(0,0,0), radius=0.1):
+    
+      # Make the input VPython vectors, such that we can use VPython's vector arithmetics
+      P0 = v.vector(pos)
+      # Normalize the orientatoin vectors
+      Ux = v.norm(orientation[0])
+      Uy = v.norm(orientation[1])
+      Uz = v.norm(orientation[2])
+      
+      # Create a vector that holds the half-lengths of the box
+      H = v.vector( (size[0]/2.0, size[1]/2.0, size[2]/2.0) )
+
+      # Create the corner points
+      # Nomenclature:
+      #
+      # - B = back side, F = front side
+      # - LL = lower left, UL = upper left
+      # - LR = lower right, UR = upper right
+      #
+      # All seen with respect to the 'axis' vector (Ux)
+      #
+      C_BLL = P0 - H[0]*Ux - H[1]*Uy - H[2]*Uz      
+      C_BLR = P0 - H[0]*Ux + H[1]*Uy - H[2]*Uz
+      C_BUL = P0 - H[0]*Ux - H[1]*Uy + H[2]*Uz
+      C_BUR = P0 - H[0]*Ux + H[1]*Uy + H[2]*Uz
+      C_FLL = P0 + H[0]*Ux - H[1]*Uy - H[2]*Uz      
+      C_FLR = P0 + H[0]*Ux + H[1]*Uy - H[2]*Uz
+      C_FUL = P0 + H[0]*Ux - H[1]*Uy + H[2]*Uz
+      C_FUR = P0 + H[0]*Ux + H[1]*Uy + H[2]*Uz
+      
+      # Create lists that will hold the points for the separate curves
+      curve_points_back  = [C_BLL, C_BUL, C_BUR, C_BLR, C_BLL]
+      curve_points_front = [C_FLL, C_FUL, C_FUR, C_FLR, C_FLL]
+      curve_points_left  = [C_BLL, C_BUL, C_FUL, C_FLL, C_BLL]
+      curve_points_right = [C_BLR, C_BUR, C_FUR, C_FLR, C_BLR]
+      
+      # Now create a frame object and the separate frames, and associate the latter with the former
+      f = v.frame()
+      
+      curve_back  = v.curve(pos=curve_points_back,  color=color, radius=radius, frame=f)
+      curve_front = v.curve(pos=curve_points_front, color=color, radius=radius, frame=f)
+      curve_left  = v.curve(pos=curve_points_left,  color=color, radius=radius, frame=f)
+      curve_right = v.curve(pos=curve_points_right, color=color, radius=radius, frame=f)
+      
+      return f
+  
+  
+  def wireframe_plane(self, pos=(0,0,0), orientation=[(1,0,0),(0,1,0),(0,0,1)], size=(1,1,1), color=(0,0,0), radius=0.1):
+    
+      # Make the input VPython vectors, such that we can use VPython's vector arithmetics
+      P0 = v.vector(pos)
+      # Normalize the orientatoin vectors
+      Ux = v.norm(orientation[0])
+      Uy = v.norm(orientation[1])
+      #Uz = v.norm(orientation[2]) # not used here
+      
+      # Create a vector that holds the half-lengths of the box
+      H = v.vector( (size[0]/2.0, size[1]/2.0, 0.0) )
+
+      # Create the corner points
+      # Nomenclature:
+      #
+      # - BL = back left, BR = back right
+      # - FL = front left, FR = front right
+      #
+      # All seen with respect to the 'axis' vector (Ux)
+      C_BL = P0 - H[0]*Ux - H[1]*Uy
+      C_BR = P0 - H[0]*Ux + H[1]*Uy      
+      C_FL = P0 + H[0]*Ux - H[1]*Uy
+      C_FR = P0 + H[0]*Ux + H[1]*Uy
+      
+      # Create lists that will hold the points for the curve
+      curve_points  = [C_BL, C_FL, C_FR, C_BR, C_BL]
+      
+      # Now create the curve object      
+      curva_yebana  = v.curve(pos=curve_points, color=color, radius=radius)
+      
+      return curva_yebana
+
+      
+  def tomeks_helix(self, pos=(0,0,0), axis=(1,0,0), radius=1.0, length=10.0, color=(1,0,0), thickness=0.01):
+          
+      Ncoils  = self.N_HELIX_COILS
+      Npoints = 10 * Ncoils 
+      
+      # Draw the helix in the default coordinate system and tie it to a frame
+      f = v.frame()
+      c = v.curve( x = v.arange(0,length,length/Npoints), frame=f, color=color, radius = thickness)
+      c.y = radius * np.sin(c.x * 2.0*np.pi/length * Ncoils)
+      c.z = radius * np.cos(c.x * 2.0*np.pi/length * Ncoils)
+      
+      # Now rotate it to the right orientation
+      f.pos  = pos
+      f.axis = axis
+      
+      return f
+      
+      
+  def tomeks_double_helix(self, pos=(0,0,0), axis=(1,0,0), radius=1.0, length=10.0, color=(1,0,0), thickness=0.01):
+
+      # This is just the two of the standard 'tomeks_helices' with an offset of 1/2 of a coil
+      Ncoils  = self.N_HELIX_COILS
+      Npoints = 10 * Ncoils 
+      
+      offset = length / Ncoils / 2.0
+      
+      # Draw the helices in the default coordinate system and tie it to a frame
+      f = v.frame()
+      
+      c1 = v.curve( x = v.arange(0,length,length/Npoints), frame=f, color=color, radius = thickness)
+      c1.y = radius * np.sin(c1.x * 2.0*np.pi/length * Ncoils)
+      c1.z = radius * np.cos(c1.x * 2.0*np.pi/length * Ncoils)
+      
+      c2 = v.curve( x = v.arange(0,length,length/Npoints), frame=f, color=self.complementary(color), radius = thickness)
+      c2.y = radius * np.sin( (c2.x - offset) * 2.0*np.pi/length * Ncoils)
+      c2.z = radius * np.cos( (c2.x - offset) * 2.0*np.pi/length * Ncoils)
+      
+      # Now rotate it to the right orientation
+      f.pos  = pos
+      f.axis = axis
+      
+      return f
+      
+
+  ######################      
+  ### HELPER METHODS ###
+  ######################
+  def complementary(self, RGB_color):
+    
+      # Get the/a complementary color of a RGB color (passed as a tuple)      
+      # Convert to HSV system first; then we can change the hue
+      HSV_color = colorsys.rgb_to_hsv(RGB_color[0], RGB_color[1], RGB_color[2])            
+      H = HSV_color[0]      
+      S = HSV_color[1]
+      V = HSV_color[2]
+      
+      # Invert the hue (turn the 'hue wheel' by 120 degrees)
+      H = (H + 0.5) % 1.0
+      
+      return colorsys.hsv_to_rgb(H,S,V)
+  
+  def to_vector(self, v):
+  
+    # TODO Assert v has only 3 entries    
+    return ( v[0], v[1], v[2] )
+
+    
+  def normalize_vector(self, v):
+    
+    norm = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2])    
+    nv   = (v[0]/norm, v[1]/norm, v[2]/norm)
+    
+    return nv
+    
+    
+  def get_dummy_sphere(self):
+      return Sphere([0, 0, 0], ALMOST_ZERO)
+
+      
+  def get_dummy_cylinder(self):
+      return Cylinder([0, 0, 0], ALMOST_ZERO, [0, 0, 1], ALMOST_ZERO)
+
+      
+  def get_dummy_box(self):
+      return Box([0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1],
+                  ALMOST_ZERO, ALMOST_ZERO, ALMOST_ZERO)
+
+  def cisleithanian_name(self):
+      return "Der k. u. k. eGFRD-Visualisator"
+      
+  def transleithanian_name(self):
+      return "Az csaszari es kiralyi eGFRD vizualizacioja szoftver"
+
+
+
+# A derived / wrapper class with a shorter (i.e. usable) name
+class TIRViE(TheImperialRoyalVisualizerForEGFRD):
+  """
+
+    This is just an alias for 'TheImperialRoyalVisualizerForEGFRD'
+  
+  """
+  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames'):
+
+    TheImperialRoyalVisualizerForEGFRD.__init__(self,eGFRDsim, particle_color_dict, structure_color_dict, capture, capture_dir)
+    
+    
\ No newline at end of file

From 441729b8a4c1d83516c9911e781bfe8422c6bb34 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 26 Aug 2016 15:48:25 +0200
Subject: [PATCH 1471/1541] Add a new flag to DiskStructure to reg. movement of
 dissoc. particles

---
 DiskSurface.hpp         | 19 ++++++++++++++++++-
 binding/DiskSurface.hpp |  3 +++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 923fe1de..fe352fd7 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -53,6 +53,23 @@ class DiskSurface
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
+    // As a specialty, the DiskStructure has a flag that can be set to prevent a move of the particle
+    // upon a dissociation event; this can be used for disks that are "sinks" (binding sites) on cylindrical structures
+    bool MOVES_AFTER_DISSOCIATION; // by default it is true, automatically set by constructor below
+    // Setters for the flag
+    virtual void forbid_move_after_dissociation()
+    {
+        this->MOVES_AFTER_DISSOCIATION = false;
+    }    
+    virtual void allow_move_after_dissociation()
+    {
+        this->MOVES_AFTER_DISSOCIATION = true;
+    }
+    // Getters
+    virtual bool const& moves_after_dissociation() const
+    {
+        return this->MOVES_AFTER_DISSOCIATION;
+    }
     
     /*** Info functions ***/
     virtual position_type const& position() const
@@ -456,7 +473,7 @@ class DiskSurface
     }
         
     DiskSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
-        : base_type(name, sid, parent_struct_id, shape) {}
+        : base_type(name, sid, parent_struct_id, shape), MOVES_AFTER_DISSOCIATION(true) {}
 };
 
 #endif /* DISK_SURFACE_HPP */
diff --git a/binding/DiskSurface.hpp b/binding/DiskSurface.hpp
index e7364f85..576c4222 100644
--- a/binding/DiskSurface.hpp
+++ b/binding/DiskSurface.hpp
@@ -21,6 +21,9 @@ inline boost::python::objects::class_base register_disk_surface_class(char const
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
+        .def("allow_move_after_dissociation", &impl_type::allow_move_after_dissociation)
+        .def("forbid_move_after_dissociation", &impl_type::forbid_move_after_dissociation)
+        .def("moves_after_dissociation", &impl_type::moves_after_dissociation, return_value_policy<return_by_value>())
         ;
 }
 

From b4b5b3f296cef9a66a6ee5a2a997212919c36720 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 26 Aug 2016 16:08:32 +0200
Subject: [PATCH 1472/1541] Some meaningful renaming

---
 DiskSurface.hpp         | 21 +++++++++++----------
 binding/DiskSurface.hpp |  6 +++---
 2 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index fe352fd7..6584fa7e 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -53,22 +53,23 @@ class DiskSurface
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
-    // As a specialty, the DiskStructure has a flag that can be set to prevent a move of the particle
-    // upon a dissociation event; this can be used for disks that are "sinks" (binding sites) on cylindrical structures
-    bool MOVES_AFTER_DISSOCIATION; // by default it is true, automatically set by constructor below
+    // As a specialty, the DiskStructure has a flag that can be set to make the particle not move radially upon
+    // a dissociation event, but axially (i.e., in direction of the cylinder axis of the parent cylinder)
+    // This can be used for disks that are "sinks" (binding sites) on cylindrical structures
+    bool RADIAL_DISSOCIATION; // by default it is true, automatically set by constructor below
     // Setters for the flag
-    virtual void forbid_move_after_dissociation()
+    virtual void forbid_radial_dissociation()
     {
-        this->MOVES_AFTER_DISSOCIATION = false;
+        this->RADIAL_DISSOCIATION = false;
     }    
-    virtual void allow_move_after_dissociation()
+    virtual void allow_radial_dissociation()
     {
-        this->MOVES_AFTER_DISSOCIATION = true;
+        this->RADIAL_DISSOCIATION = true;
     }
     // Getters
-    virtual bool const& moves_after_dissociation() const
+    virtual bool const& dissociates_radially() const
     {
-        return this->MOVES_AFTER_DISSOCIATION;
+        return this->RADIAL_DISSOCIATION;
     }
     
     /*** Info functions ***/
@@ -473,7 +474,7 @@ class DiskSurface
     }
         
     DiskSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
-        : base_type(name, sid, parent_struct_id, shape), MOVES_AFTER_DISSOCIATION(true) {}
+        : base_type(name, sid, parent_struct_id, shape), RADIAL_DISSOCIATION(true) {}
 };
 
 #endif /* DISK_SURFACE_HPP */
diff --git a/binding/DiskSurface.hpp b/binding/DiskSurface.hpp
index 576c4222..1b662cfa 100644
--- a/binding/DiskSurface.hpp
+++ b/binding/DiskSurface.hpp
@@ -21,9 +21,9 @@ inline boost::python::objects::class_base register_disk_surface_class(char const
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
-        .def("allow_move_after_dissociation", &impl_type::allow_move_after_dissociation)
-        .def("forbid_move_after_dissociation", &impl_type::forbid_move_after_dissociation)
-        .def("moves_after_dissociation", &impl_type::moves_after_dissociation, return_value_policy<return_by_value>())
+        .def("allow_radial_dissociation", &impl_type::allow_radial_dissociation)
+        .def("forbid_radial_dissociation", &impl_type::forbid_radial_dissociation)
+        .def("dissociates_radially", &impl_type::dissociates_radially, return_value_policy<return_by_value>())
         ;
 }
 

From 79f19cfc6448ecc86e7b9d4397d55cea70784f89 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 26 Aug 2016 16:49:41 +0200
Subject: [PATCH 1473/1541] Allow for different ways of dissociation from
 DiskSurface (egfrd.py)

We still have to fix it also in the C part (newBDPropagator)
---
 egfrd.py | 63 ++++++++++++++++++++++++++++++++++++++------------------
 utils.py | 11 +++++++++-
 2 files changed, 53 insertions(+), 21 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6fa7972f..cd6a31b9 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1225,14 +1225,21 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                         product_pos_list.append(vector)
 
                 elif isinstance(reactant_structure, DiskSurface):
-                    # The particle unbinds perpendicularly to disk unit vector (i.e. like on cylinder)
-                    vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
-                    for _ in range(self.dissociation_retry_moves):
-                        unit_vector3D = random_unit_vector()
-                        unit_vector2D = normalize(unit_vector3D - 
-                                        (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
-                        vector = reactant_pos + vector_length * unit_vector2D
-                        product_pos_list.append(vector)
+                    # Initially check whether the DiskSurface dissociates the particles in radial direction (default setting)
+                    if reactant_structure.dissociates_radially():
+                      
+                      # The particle unbinds perpendicularly to disk unit vector (i.e. like on cylinder)
+                      vector_length = (product_radius + reactant_structure.shape.radius) * MINIMAL_SEPARATION_FACTOR
+                      for _ in range(self.dissociation_retry_moves):
+                          unit_vector3D = random_unit_vector()
+                          unit_vector2D = normalize(unit_vector3D - 
+                                          (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
+                          vector = reactant_pos + vector_length * unit_vector2D
+                          product_pos_list.append(vector)
+                          
+                    else:
+                      # The particle stays where it is
+                      product_pos_list.append(reactant_pos)
 
                 else:
                     # cannot decay from 3D to other structure
@@ -1313,7 +1320,7 @@ def fire_single_reaction(self, single, reactant_pos, reactant_structure_id, igno
                     log.warn('Reactant structure is default structure, but products do not end up in bulk. Something seems wrong!')
 
                 # Figure out which product stays in the surface and which one goes to the bulk or parent structure
-                # Note that A is a particle in the surface and B is in the 3D
+                # Note that A is a particle staying in the surface of origin (of the reactant) and B goes to the "higher" structure
                 if product2_structure_type_id == def_sid or product2_structure_type_id == parent_sid:
                     # product2 goes to bulk or parent structure and is now particleB (product1 is particleA and is on the surface)
                     product1_structure_id = reactant_structure_id # TODO after the displacement the structure can change!
@@ -1451,17 +1458,33 @@ def conditional_swap(newposA, newposB):
 
                     # productA always must stay on the disk, in the position of the reactant
                     newposA = reactant_pos
-
-                    # Create the position of the particle that goes into the bulk (productB)
-                    # This is the same as for the single reaction of a completely dissociating disk-bound particle (see above)
-                    vector_length = (productB_radius + max(productA_radius, reactant_structure.shape.radius)) * MINIMAL_SEPARATION_FACTOR
-                    for _ in range(self.dissociation_retry_moves):
-                        unit_vector3D = random_unit_vector()
-                        unit_vector2D = normalize(unit_vector3D - 
-                                        (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
-                        newposB = reactant_pos + vector_length * unit_vector2D                    
-
-                        product_pos_list.append(conditional_swap(newposA, newposB))
+                    
+                    # Check whether the DiskSurface dissociates the particles in radial direction (default setting)
+                    if reactant_structure.dissociates_radially():
+
+                      # Create the position of the particle that goes into the bulk (productB)
+                      # This is the same as for the single reaction of a completely dissociating disk-bound particle (see above)
+                      vector_length = (productB_radius + max(productA_radius, reactant_structure.shape.radius)) * MINIMAL_SEPARATION_FACTOR
+                      for _ in range(self.dissociation_retry_moves):
+                          unit_vector3D = random_unit_vector()
+                          unit_vector2D = normalize(unit_vector3D - 
+                                          (reactant_structure.shape.unit_z * numpy.dot(unit_vector3D, reactant_structure.shape.unit_z)))
+                          newposB = reactant_pos + vector_length * unit_vector2D                    
+
+                          product_pos_list.append(conditional_swap(newposA, newposB))
+                          
+                    else:
+                      # The particle does not dissociate into the bulk but moves back onto the parent cylinder
+                      # and is placed adjacent (touching) next to particle A
+                      vector_length = (productB_radius + productA_radius) * MINIMAL_SEPARATION_FACTOR
+                      for _ in range(self.dissociation_retry_moves):
+                          # Determine a random dissociation direction
+                          unit_vector1D =  random_sign() * reactant_structure.shape.unit_z
+                          newposB = reactant_pos + vector_length * unit_vector1D
+                          # TODO We may have to carry out additional checks for free space here first, 
+                          # but in principle the code below should handle it correctly as in all other cases
+
+                          product_pos_list.append(conditional_swap(newposA, newposB))                      
 
                 else:
                     # cannot decay from 3D to other structure
diff --git a/utils.py b/utils.py
index 2a8b7f79..72d9cb79 100644
--- a/utils.py
+++ b/utils.py
@@ -208,7 +208,7 @@ def random_unit_vector_s():
 
 def random_unit_vector():
     v = [myrandom.uniform(-1,1), myrandom.uniform(-1,1), myrandom.uniform(-1,1)]
-    return _gfrd.normalize(v, 1)
+    return _gfrd.normalize(v, 1)   
 
 def random_vector(r):
     # v, s = [0.0, 0.0, 0.0], 2.0
@@ -239,6 +239,15 @@ def random_vector2D(r):
     norm = numpy.linalg.norm(v)
     return v * (r / norm)
 
+def random_sign():
+    # NOTE Do not use the numpy.sign function,
+    # because it returns 0 for 0 input!
+    r = myrandom.uniform(-1,1)
+    if r<0:
+      return -1
+    else:
+      return 1
+    
 def length(a):
     return _gfrd.length(a)
 

From 445c864455b2f74839c61322fe12ebe8dd61fe34 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 26 Aug 2016 18:14:12 +0200
Subject: [PATCH 1474/1541] Include new DiskSurface features into load/save
 system

---
 loadsave.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/loadsave.py b/loadsave.py
index 9d12909d..bf7dfc45 100644
--- a/loadsave.py
+++ b/loadsave.py
@@ -302,6 +302,8 @@ def save_state(simulator, filename):
 
             cp.set(sectionname, 'unit_z', list(structure.shape.unit_z))
             cp.set(sectionname, 'radius', structure.shape.radius)
+            cp.set(sectionname, 'dissociates_radially', int(structure.dissociates_radially()))
+            # we store boolean flags as int, which facilitates reading them in later
 
         elif isinstance(structure, PlanarSurface):
 
@@ -767,13 +769,18 @@ def load_state(filename):
             
             unit_z      = vectorize(cp.get(sectionname, 'unit_z'))            
             radius      = cp.getfloat(sectionname, 'radius')
+            diss_rad    = cp.getint(sectionname, 'dissociates_radially')
 
             structure_type = structure_types_dict[st_id]            
 
             # Create the structure
             structure = model.create_disk_surface(structure_type.id, name, position, radius, \
                                                   unit_z, parent_structure.id)
-
+                                                  
+            # Check whether it does not dissociate radially (standard setting by constructor)
+            if not(diss_rad):
+                structure.forbid_radial_dissociation()
+                
         elif structure_object_type == PlanarSurface:
 
             unit_x      = vectorize(cp.get(sectionname, 'unit_x'))

From d8d892d7ffc429a08958a2aee56d3de37a49d87d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 26 Aug 2016 18:18:09 +0200
Subject: [PATCH 1475/1541] Small correction in
 CylindricalSurfaceCapInteractionShell

But this has to be fixed properly at some point!
---
 shells.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 9bfbe6e3..4bb02ae7 100755
--- a/shells.py
+++ b/shells.py
@@ -2695,8 +2695,10 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
         # We want to form this domain only if the cap actually is a substructure of the cylinder of origin
-        #if not target_structure.id == single.structure.structure_id:
+        #if not target_structure.structure_id == single.structure.id:
             #raise testShellError('(CylindricalSurfaceCapInteraction). Target structure is not a substructure of the origin structure.')
+            ### FIXME This cannot be longer fulfilled when the cylinder-plane interaction test shells
+            ### inherit from this class!
 
         # Initialize scaling parameters
         # - the reference point is at the cap disk position

From 008d563fa0aca585943b3e25a60088fbf7fc5920 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 29 Aug 2016 11:46:14 +0200
Subject: [PATCH 1476/1541] Fix different unbinding modes for Disk in BD mode

---
 DiskSurface.hpp | 101 ++++++++++++++++++++++++++++++++----------------
 1 file changed, 68 insertions(+), 33 deletions(-)

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 6584fa7e..191a398e 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -136,28 +136,40 @@ class DiskSurface
     virtual position_type surface_dissociation_vector( rng_type& rng, length_type const& offset, length_type const& rl ) const
     {
         // This function produces a position for a particle unbinding from the disk.
-        // It should lie within the reaction volume around the disk.
-        // Note that this is the same code as for the CylindricalSurface.
-        Real X( rng.uniform(0.,1.) );
-        length_type   const disk_radius = base_type::shape().radius();
-        position_type const unit_z = base_type::shape().unit_z();
+        // If it unbinds radially (standard case), it should lie within the reaction volume around the disk        
+        // (Note that in that case this is the same code as for the CylindricalSurface!)
+        // If it unbinds axially (i.e., back to the cylinder), it does not change its position.
+        // We therefore initialize the new position with the Disk position by default,
+        // and only create a new vector if needed below.
+        position_type new_pos( base_type::shape().position() );
+        
+        if( this->RADIAL_DISSOCIATION == true ){
+          
+            Real X( rng.uniform(0.,1.) );
+            length_type   const disk_radius = base_type::shape().radius();
+            position_type const unit_z = base_type::shape().unit_z();
 
-        // Calculate the length of the vector first
-        length_type const rrl( disk_radius + offset + rl );
-        length_type const rrl_sq( gsl_pow_2(rrl) );
-        length_type const rr_sq(  gsl_pow_2(disk_radius + offset) );
-        // Create a random length between rr_sq and rrl_sq
-        length_type const diss_vec_length( sqrt( rr_sq + X * (rrl_sq - rr_sq) ) );
+            // Calculate the length of the vector first
+            length_type const rrl( disk_radius + offset + rl );
+            length_type const rrl_sq( gsl_pow_2(rrl) );
+            length_type const rr_sq(  gsl_pow_2(disk_radius + offset) );
+            // Create a random length between rr_sq and rrl_sq
+            length_type const diss_vec_length( sqrt( rr_sq + X * (rrl_sq - rr_sq) ) );
 
-        // Create a 3D vector with totally random orientation
-        position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);
-        // Subtract the part parallel to the axis to get the orthogonal components and normalize
-        // This creates a normed random vector in the disk plane
-        v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
-         
-        // Return the created vector with the right length
-        return multiply( v, MINIMAL_SEPARATION_FACTOR * diss_vec_length);
-               // TODO define a global MINIMAL_SEPARATION_FACTOR also for BD mode
+            // Create a 3D vector with totally random orientation
+            position_type v(rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5, rng.uniform(0.,1.) - .5);
+            // Subtract the part parallel to the axis to get the orthogonal components and normalize
+            // This creates a normed random vector in the disk plane
+            v = normalize( subtract(v, multiply( unit_z, dot_product( unit_z, v ) ) ) );
+            
+            new_pos = multiply( v, MINIMAL_SEPARATION_FACTOR * diss_vec_length);
+                      // TODO define a global MINIMAL_SEPARATION_FACTOR also for BD mode
+        }
+        else
+            ; // nothing changes, new_pos already correctly initialized above
+                    
+        return new_pos;
+        
     }
     
     // Normed direction of dissociation from the structure to parent structure
@@ -191,21 +203,44 @@ class DiskSurface
         // TODO We have to distinguish between sink and cap here and between dissociation onto
         // the rod and into the bulk/plane!
         
-        // Note: s_disk = disk-bound species, s_diss = dissociating species (may go to bulk or plane)
-                                                 
-        length_type const disk_radius( base_type::shape().radius() );        
-        length_type const r01( s_disk.radius() + s_diss.radius() );
-        
-        // The following is the additional distance that we have to pass to surface_dissociation_vector() below
-        // to place the unbinding particle in contact with the disk particle or the disk, whatever has the 
-        // larger radius. surface_dissociation_vector() will add it to the disk_radius.
-        length_type offset( s_disk.radius() > disk_radius ? r01 - disk_radius : s_diss.radius());
-        
-        position_pair_type pp01;        
+        // Note: s_disk = disk-bound species, s_diss = dissociating species (may go to bulk or cylinder)
+
+        // Initialize the position_pair that will hold the new positions of the 2 particles
+        position_pair_type pp01;
         // Particle 0 is the one that stays on the origin structure. It does not move.
         pp01.first  = reactant_pos;
-        // Particle 1 is the one that unbinds from the disk and is placed in the reaction volume around it.
-        pp01.second = add(reactant_pos, surface_dissociation_vector(rng, offset, rl));
+        // Particle 1 is the one that unbinds from the disk and is placed in the reaction volume
+        // around it (in case of radial unbinding) or next to/touching the first particle
+        // (taking into account the reaction vol.) on the cylinder (in case of axial unbinding)
+        
+        if( this->RADIAL_DISSOCIATION == true )
+        {
+            length_type const disk_radius( base_type::shape().radius() );        
+            length_type const r01( s_disk.radius() + s_diss.radius() );
+            
+            // The following is the additional distance that we have to pass to surface_dissociation_vector() below
+            // to place the unbinding particle in contact with the disk particle or the disk, whatever has the larger radius.
+            // Later surface_dissociation_vector() will add this offset length to the disk_radius.
+            // If the disk-bound particle is larger than the disk, the final distance should be equal to r01, 
+            // so we subtract disk_radius here (because it will be automatically added later); if in turn the 
+            // disk is larger than the disk-bound particle, the offset is the radius of the dissoc. particle.
+            length_type offset( s_disk.radius() > disk_radius ? r01 - disk_radius : s_diss.radius());
+                                                
+            pp01.second = add(reactant_pos, surface_dissociation_vector(rng, offset, rl));
+        }
+        else
+        {                        
+            // Generate a random distance within the reaction volume
+            Real X( rng.uniform(0.0, 1.0) );            
+            length_type const r01( s_disk.radius() + s_diss.radius() + X * rl );
+            // Generate another random number to determine the direction of dissociaton
+            Real D( rng.uniform(0.0, 1.0) );
+            // Construct the dissociation vector in axial direction (given by unit_z of the disk)
+            position_type const disk_unit_z( base_type::shape().unit_z() );
+            position_type const axial_diss_vector( D>0.5? multiply(disk_unit_z, r01) : multiply(disk_unit_z, -r01) );
+            // Add to the original position of the reactant
+            pp01.second = add(reactant_pos, axial_diss_vector);
+        }
         
         return pp01;
     }

From 08842496f21c6223e39e5e217d6227770a7350ee Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 29 Aug 2016 12:50:39 +0200
Subject: [PATCH 1477/1541] Prevent forming interaction domains when distance
 to surface is zero

This caused problems with the interaction domains formed after
unbinding from a reactive disk ("sink") on the cylinder, when
the distance btw. sink and recently unbound particle is zero.

In such and similar cases we want to use BD mode instead.
---
 shells.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 4bb02ae7..02e1e0c7 100755
--- a/shells.py
+++ b/shells.py
@@ -193,9 +193,13 @@ def __init__(self, single, origin_structure, target_structure):
         # Cyclic transpose needed when calling target_structure.project_point!
         pos_transposed = self.world.cyclic_transpose(self.pid_particle_pair[1].position,
                                                      self.target_structure.shape.position)
-        self.reference_point, (_, dist_to_surface_edge) = self.target_structure.project_point(pos_transposed)
+        self.reference_point, (normal_comp, dist_to_surface_edge) = self.target_structure.project_point(pos_transposed)
         if dist_to_surface_edge >= 0:
             raise testShellError('(testInteractionSingle). Projected point of particle is not in surface.')
+        elif feq(normal_comp, 0.0, self.pid_particle_pair[1].radius):
+            raise testShellError('(testInteractionSingle). Normal component = %g / particle is already in surface.' % normal_comp)
+            # If the distance to the reactive surface is zero we want to better use BD, because the
+            # zero distance can cause problems with (cylinder) shellmaking and reaction sampling.
 
         self.min_dist_proj_to_edge = abs(dist_to_surface_edge)
         # projection_distance can be negative in case of plane

From 6c2ef05fdd72274b9e791e6c48ca549ce081e3a8 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 29 Aug 2016 13:06:06 +0200
Subject: [PATCH 1478/1541] Add a screen output retarding feature to TIRViE
 visualizer

---
 visualization/TIRViE.py | 33 ++++++++++++++++++++++++++++-----
 1 file changed, 28 insertions(+), 5 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index fd8075f8..bf357bea 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -67,7 +67,7 @@ def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, ca
     
     self.SCENE_BACKGROUND_COLOR = v.color.white
     
-    self.info_label_strings_order = ('b', 's', 'd', 'c', 'o', 'w', 'i')
+    self.info_label_strings_order = ('b', 's', 'd', 'r', 'c', 'o', 'w', 'i')
     self.INFO_TIME_ONLY           = False
     
     # Some flags tuning visual behavior of the objects
@@ -100,6 +100,11 @@ def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, ca
     # A flag to pause/resume the execution of the simulation
     self.PAUSED = False
     
+    # A flag to activate/inactivate retarding of progress in case
+    # the visualization cannot keep speed with the simulation
+    self.RETARD = False
+    self.RETARDING_SECONDS = 0.1
+    
     # Color lists and dictionaries for objects of different species    
     self.create_default_color_list()
     
@@ -141,6 +146,9 @@ def visualize(self):
         
     if self.PAUSED:
       self.pause()
+
+    if self.RETARD:
+      self.retard()
       
     self.clear_scene()    
     
@@ -327,8 +335,13 @@ def handle_key(self, k):
         self.PAUSED = False
         self.paused_label.visible = False
         print '***** CONTINUING *****'
-        
-    # Visibility of logo and info label
+
+    # Screen output retarding
+    elif k == 'r' or k == 'R':
+      
+      self.RETARD = not(self.RETARD)
+      
+    # Visibility of info label
     if k == 'i' or k == 'I':
       
       self.info_label.visible = not(self.info_label.visible)
@@ -417,7 +430,12 @@ def pause(self):
         key = self.scene.kb.getkey()
         self.handle_key(key)
 
-        
+
+  def retard(self):
+    
+      time.sleep(self.RETARDING_SECONDS)
+      
+      
   def set_info_label_strings(self):
     
     self.info_label_strings = {}        
@@ -437,10 +455,15 @@ def set_info_label_strings(self):
     else:
       self.info_label_strings['s'] = '\n[s] hiding structures'
       
+    if self.RETARD:
+      self.info_label_strings['r'] = '\n[r] output retarding ON'
+    else:
+      self.info_label_strings['r'] = '\n[r] output retarding OFF'
+      
     if self.CAPTURE:
       self.info_label_strings['c'] = '\n[c] output capturing ON'
     else:
-      self.info_label_strings['c'] = '\n[c] output capturing OFF'              
+      self.info_label_strings['c'] = '\n[c] output capturing OFF'                        
     
     #if self.RODS_AS_HELICES:
       #self.info_label_strings['h'] = '\nrods shown as helices'

From a106e85a6647c41f5d67f18d2dd3f1d15c56e143 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 29 Aug 2016 14:41:06 +0200
Subject: [PATCH 1479/1541] Add 's' to time string in TIRViE

---
 visualization/TIRViE.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index bf357bea..5c45975c 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -260,7 +260,7 @@ def create_new_scene(self):
     self.scene.background = self.SCENE_BACKGROUND_COLOR
     self.scene.select()
     
-    self.info_label   = v.label(pos=(-1.1*self.world_size, 1.1*self.world_size, 0), text = 't = 0', height=10)
+    self.info_label   = v.label(pos=(-1.1*self.world_size, 1.1*self.world_size, 0), text = 't = 0 s', height=10)
     self.paused_label = v.label(text = 'PAUSED', color = v.color.red, linecolor = v.color.red, visible = False)
     
     #self.logo = v.text(pos=(-self.world_size, 1.1*self.world_size, 0), text='TIRViE', height=0.1*self.world_size, width=0.2*self.world_size)
@@ -482,7 +482,7 @@ def update_info_label(self):
     
     try:
       time_str = "%0.3f" % self.sim.t
-      newtext = 't = ' + time_str
+      newtext = 't = ' + time_str + ' s'
       
       if not(self.INFO_TIME_ONLY):
         newtext = newtext + '\n'

From a4f7df77b1f36684c2c0c4e45e4443b8defd743f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 29 Aug 2016 15:33:41 +0200
Subject: [PATCH 1480/1541] Fix color dictionary management for Multis in
 TIRViE

---
 visualization/TIRViE.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index 5c45975c..3443dcb5 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -547,7 +547,9 @@ def get_protective_domain_data(self):
             # and set the color accordingly
             
             # Single and pairs
-            color = self.shell_color_dict[object.multiplicity]
+            if object.multiplicity <= 2:
+                # if it is > 2 it is a Multi, handled below
+                color = self.shell_color_dict[object.multiplicity]
 
             # Highlight top_event for singles and pairs
             if top_event_id != None and object.event_id == top_event_id:                

From 0f19f312c5465b72d3f251a519b1f80e9acf0bdc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 30 Aug 2016 18:10:42 +0200
Subject: [PATCH 1481/1541] Small fix to event-type statistics

---
 egfrd.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/egfrd.py b/egfrd.py
index cd6a31b9..6df0db01 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -340,6 +340,7 @@ def reset(self):
                              'MAKE_NEW_DOMAIN':0}
         self.interaction_steps = {EventType.IV_INTERACTION:0,
                                   EventType.IV_ESCAPE:0,
+                                  EventType.SINGLE_ESCAPE:0,
                                   EventType.BURST:0}
         self.pair_steps = {EventType.SINGLE_REACTION:0,
                            EventType.IV_REACTION:0,
@@ -2254,8 +2255,12 @@ def process_single_event(self, single, ignore):
                 zero_singles_b = []   # no bursting takes place, ignore list remains unchanged
                 # Update statistics
                 if single.event_type == EventType.SINGLE_ESCAPE or\
+                   single.event_type == EventType.IV_ESCAPE or\
                    single.event_type == EventType.BURST:
-                    self.single_steps[single.event_type] += 1
+                      if isinstance(single, InteractionSingle):
+                          self.interaction_steps[single.event_type] += 1
+                      else:
+                          self.single_steps[single.event_type] += 1
                 elif __debug__:
                     log.warning('Omitting to count a single event with unforeseen event type (%s).' % single.event_type)
                     

From 0d912d9392a03e0014a0ed608463b6d2e58a4f2f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 30 Aug 2016 18:15:59 +0200
Subject: [PATCH 1482/1541] Some commenting in TIRViE

---
 visualization/TIRViE.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index 3443dcb5..f64e74a6 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -52,6 +52,12 @@ class TheImperialRoyalVisualizerForEGFRD:
         
     TODO Add more info about usage etc.
     
+    TODO:
+      - Use the central eGFRD error logger for warnings/error messages
+      - Custom output window size
+      - Stereo view for 3D glasses (easily supported by VPython)
+      - Optional PoVRay output (files that can be rendered by PoVRay)
+    
   """
   def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames'):
 

From ace5afb754cc83930c67f4bf701380237ad08c85 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 2 Sep 2016 12:43:15 +0200
Subject: [PATCH 1483/1541] Some renaming that seems to make sense ("cap" ->
 "disk")

---
 egfrd.py  | 12 +++++-----
 shells.py | 69 +++++++++++++++++++++++++++++--------------------------
 single.py | 55 ++++++++++++++++++++++----------------------
 3 files changed, 70 insertions(+), 66 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6df0db01..6b46ca81 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -57,7 +57,7 @@
     PlanarSurfaceInteractiontestShell,
     PlanarSurfaceDiskSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
-    CylindricalSurfaceCapInteractiontestShell,
+    CylindricalSurfaceDiskInteractiontestShell,
     CylindricalSurfacePlanarSurfaceInteractionSingletestShell,
     CylindricalSurfacePlanarSurfaceIntermediateSingletestShell,
     CylindricalSurfacePlanarSurfaceInterfaceSingletestShell,
@@ -128,7 +128,7 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
             raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(target_structure, DiskSurface):
-            return CylindricalSurfaceCapInteractiontestShell (single, target_structure, geometrycontainer, domains)
+            return CylindricalSurfaceDiskInteractiontestShell (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, CylindricalSurface):
             return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, PlanarSurface):
@@ -145,13 +145,13 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction    (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell): # must be first because it is a special case of CylindricalSurfaceCapInteractiontestShell
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
         return CylindricalSurfacePlanarSurfaceInteractionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell): # this is actually not a "real" interaction, but we need to put it here to ignore the target structure
         return CylindricalSurfacePlanarSurfaceIntermediateSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfaceCapInteractiontestShell):
-        return CylindricalSurfaceCapInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfaceSinktestShell):
+    elif isinstance(testShell, CylindricalSurfaceDiskInteractiontestShell):
+        return CylindricalSurfaceDiskInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfaceSinktestShell): # FIXME not sure we ever construct this; we have to give it priority over Cyl.Surf.DiskInteraction for non-capping disks!
         return CylindricalSurfaceSink           (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
 ### Transitions
diff --git a/shells.py b/shells.py
index 02e1e0c7..974efe6c 100755
--- a/shells.py
+++ b/shells.py
@@ -50,7 +50,7 @@
     'CylindricalSurfacePairtestShell',
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
-    'CylindricalSurfaceCapInteractiontestShell',
+    'CylindricalSurfaceDiskInteractiontestShell',
     'CylindricalSurfacePlanarSurfaceInteractionSingletestShell',
     'CylindricalSurfacePlanarSurfaceIntermediateSingletestShell',
     'CylindricalSurfacePlanarSurfaceInterfaceSingletestShell',
@@ -467,7 +467,7 @@ def __init__(self, single1D, static_single):
                 
         testPair.__init__(self, single1D, static_single)
         # Note: this makes self.single1/self.pid_particle_pair1/self.structure1 for the 1D particle
-        #              and self.single2/self.pid_particle_pair2/self.structure2 for the cap particle
+        #              and self.single2/self.pid_particle_pair2/self.structure2 for the disk particle
 
         # For clarity define:
         self.single1D         = single1D
@@ -480,7 +480,7 @@ def __init__(self, single1D, static_single):
         # Note that we have to use pid_particle_pair1(2) in the methods defined below
         # because they are called at the initialization of testPair().
 
-        # Make sure cap particle is immobile; this is required for testSimplePair routines
+        # Make sure disk particle is immobile; this is required for testSimplePair routines
         # to give the proper results for this case.
         if not(self.static_particle.D == 0 and self.static_particle.v == 0):
             raise testShellError('Particle %s is not static in testMixedPair1DStatic.' % str(self.static_particle))
@@ -508,7 +508,7 @@ def do_transform(self):
 
         # In the MixedPair1DStatic only the 1D particle moves. We therefore use
         # iv to sample its position and com for the position of the static
-        # cap particle; this is initialized here:
+        # disk particle; this is initialized here:
         com = pos2
         com = self.world.apply_boundary(pos2)
         
@@ -2299,11 +2299,11 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
         testNonInteractionSingle.__init__(self, pid_particle_pair, structure)
 
         # Initialize scaling parameters
-        # - the reference point is at the cap disk position
-        # - the orientation vector points from the cap towards the rod center, i.e.:
+        # - the reference point is at the disk position
+        # - the orientation vector points from the disk towards the rod center, i.e.:
         #       - the right scaling point is for the scaling "inwards", i.e. onto the rod
-        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
-        #       - dz_left stays constant and is equal to the cap-bound particle radius
+        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and disk)
+        #       - dz_left stays constant and is equal to the disk-bound particle radius
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
         self.dr_const   = self.pid_particle_pair[1].radius*CYLINDER_R_FACTOR
@@ -2692,24 +2692,24 @@ def set_structure_ignore_list(self):
         # NOTE copied from CylindricalSurfacePlanarSurfaceIntermediateSingle
         
 
-class CylindricalSurfaceCapInteractiontestShell(CylindricaltestShell, testInteractionSingle):
+class CylindricalSurfaceDiskInteractiontestShell(CylindricaltestShell, testInteractionSingle):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
-        # We want to form this domain only if the cap actually is a substructure of the cylinder of origin
+        # We want to form this domain only if the disk actually is a substructure of the cylinder of origin
         #if not target_structure.structure_id == single.structure.id:
-            #raise testShellError('(CylindricalSurfaceCapInteraction). Target structure is not a substructure of the origin structure.')
+            #raise testShellError('(CylindricalSurfaceDiskInteraction). Target structure is not a substructure of the origin structure.')
             ### FIXME This cannot be longer fulfilled when the cylinder-plane interaction test shells
             ### inherit from this class!
 
         # Initialize scaling parameters
-        # - the reference point is at the cap disk position
-        # - the orientation vector points from the cap towards the rod particle, i.e.:
-        #       - the right scaling point is for the scaling "inwards", i.e. onto the rod
-        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
-        #       - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
+        # - the reference point is at the disk position
+        # - the orientation vector points from the disk towards the cylinder-bound particle, i.e.:
+        #       - the right scaling point is for the scaling "inwards", i.e. onto the cylinder
+        #       - the left scaling point is for the scaling "outwards", i.e. away from the cylinder (and the disk if it is a "cap")
+        #       - dz_left stays constant and is equal to the disk-bound particle radius * a safety factor
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
         self.dr_const   = self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR
@@ -2740,10 +2740,10 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
                             self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], \
                                                                                     self.ignored_structure_ids)
         except ShellmakingError as e:
-            raise testShellError('(CylindricalSurfaceCapInteraction). %s' % (str(e)) )
+            raise testShellError('(CylindricalSurfaceDiskInteraction). %s' % (str(e)) )
 
     def get_orientation_vector(self):
-        # The orientation vector is the (normalized) vector that points from the cap
+        # The orientation vector is the (normalized) vector that points from the disk
         # towards the particle on the rod
         return normalize(self.pid_particle_pair[1].position - self.target_structure.shape.position)
 
@@ -2762,14 +2762,15 @@ def get_min_dr_dzright_dzleft(self):
     def get_max_dr_dzright_dzleft(self):
         dr       = self.dr_const
         dz_left  = self.get_const_z_left() # same as the minimum and initial value, i.e. no scaling of this length
-        # TODO include max distance to other side of rod?
+        # TODO include max distance to other side of cylinder?
         dz_right = min( 3.0*dz_left, math.sqrt((self.get_searchradius())**2 - dr**2) + self.particle_surface_distance)
                    # stay within the searchradius and do not allow for terribly asymmetric domains
                    # in order to prevent convergence problems with the 1D RadAbs GF
         return dr, dz_right, dz_left
 
     def get_const_z_left(self):
-        # This defines how far the shell extends "outwards" from the rod, i.e. behind the cap
+        # This defines how far the shell extends "outwards" from the cylinder, i.e. behind the disk
+        # FIXME: We want to distinguish between a real "cap" disk and a disk in the middle of the cylinder here!
         return self.pid_particle_pair[1].radius * math.sqrt(MULTI_SHELL_FACTOR**2 - 1.0)
 
     def apply_safety(self, r, z_right, z_left):
@@ -2779,11 +2780,11 @@ def set_structure_ignore_list(self):
 
         return [self.target_structure.id]
 
-class CylindricalSurfacePlanarSurfaceInteractionSingletestShell(CylindricalSurfaceCapInteractiontestShell):
+class CylindricalSurfacePlanarSurfaceInteractionSingletestShell(CylindricalSurfaceDiskInteractiontestShell):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
-        CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
-        # This is essentially the same as CylindricalSurfaceCapInteractiontestShell, only that
+        CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
+        # This is essentially the same as CylindricalSurfaceDiskInteractiontestShell, only that
         # the orientation vector has to be calculated in a different way.
         
         assert isinstance(target_structure, PlanarSurface)
@@ -2846,7 +2847,7 @@ def find_daughter_disk(self):
         else:
             raise testShellError('Could not find correct disk surface at the interface between cylinder and plane.')
 
-class CylindricalSurfacePlanarSurfaceIntermediateSingletestShell(CylindricalSurfaceCapInteractiontestShell):
+class CylindricalSurfacePlanarSurfaceIntermediateSingletestShell(CylindricalSurfaceDiskInteractiontestShell):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
 
@@ -2861,7 +2862,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) Particle is not directly at disk position, distance from center = %s' % distance_from_center)
 
         # If everything seems OK, we can proceed with creating the test shell
-        CylindricalSurfaceCapInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
+        CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
 
         # Override the shellsize determined for CylindricalSurfacePlanarSurfaceInteractionSingletestShell
         # This one has the size of a zero single; the scaling parameters can stay the same, since we are not scaling anyhow
@@ -2894,7 +2895,7 @@ def get_max_dr_dzright_dzleft(self):
         return dr, dz_right, dz_left
 
     def get_const_z_left(self):
-        # This defines how far the shell extends "outwards" from the rod, i.e. behind the cap
+        # This defines how far the shell extends "outwards" from the rod, i.e. behind the disk
         # This method is used in the parent class to define some scaling parameters, which 
         # slightly differ here.
         return self.pid_particle_pair[1].radius
@@ -2928,6 +2929,8 @@ class CylindricalSurfaceSinktestShell(CylindricaltestShell, testInteractionSingl
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
+        
+        # FIXME Check: Is this actually ever created, or does the main loop always pick 'CylindricalSurfaceDiskInteraction'?
 
         # initialize scaling parameters
         self.dr_const   = self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR
@@ -3215,20 +3218,20 @@ def apply_safety(self, r, z_right, z_left):
 
 class MixedPair1DStatictestShell(CylindricaltestShell, testMixedPair1DStatic):
 
-    def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?
+    def __init__(self, single1D, disk_single, geometrycontainer, domains): # TODO Do we need target_structure (for the ignore list)?
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
-        testMixedPair1DStatic.__init__(self, single1D, cap_single)
+        testMixedPair1DStatic.__init__(self, single1D, disk_single)
 
         # NOTE: The following is already defined by testMixedPair1DStatic:
         # - self.single1D, self.structure1D, self.particle1D
         # - self.static_single, self.static_structure, self.static_particle
 
         # Initialize scaling parameters
-        # - the reference point is at the cap disk position
-        # - the orientation vector points from the cap towards the rod particle, i.e.:
+        # - the reference point is at the disk position
+        # - the orientation vector points from the disk towards the rod particle, i.e.:
         #       - the right scaling point is for the scaling "inwards", i.e. onto the rod
-        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and cap)
-        #       - dz_left stays constant and is equal to the cap-bound particle radius * a safety factor
+        #       - the left scaling point is for the scaling "outwards", i.e. away from the rod (and disk)
+        #       - dz_left stays constant and is equal to the disk-bound particle radius * a safety factor
         #       - dz_right can be scaled, minimum is set accordingly
         # - dr stays constant and is determined by the maximal radius involved
         CRF             = CYLINDER_R_FACTOR
@@ -3263,7 +3266,7 @@ def __init__(self, single1D, cap_single, geometrycontainer, domains): # TODO Do
                                  (str(e)))
 
     def get_orientation_vector(self):        
-        # The orientation vector is the (normalized) vector that points from the cap
+        # The orientation vector is the (normalized) vector that points from the disk
         # towards the particle on the rod
         return normalize(self.particle1D.position - self.static_particle.position)
 
diff --git a/single.py b/single.py
index 3725c5c6..fe0fddbf 100644
--- a/single.py
+++ b/single.py
@@ -31,7 +31,7 @@
     'NonInteractionSingle',
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
-    'CylindricalSurfaceCapInteraction',
+    'CylindricalSurfaceDiskInteraction',
     'CylindricalSurfacePlanarSurfaceInteractionSingle',
     'CylindricalSurfacePlanarSurfaceIntermediateSingle',
     'CylindricalSurfaceSink',
@@ -1139,10 +1139,11 @@ def __str__(self):
         return 'CylindricalSurfaceSink ' + Single.__str__(self)
 
 
-class CylindricalSurfaceCapInteraction(InteractionSingle):
+class CylindricalSurfaceDiskInteraction(InteractionSingle):
     """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
-       limited by a cap. The cap is a reactive surface to the particle
-       and defines the exit point from the cylinder.
+       interacting with a disk (mostly a cap limiting the cylinder).
+       The disk is a reactive surface to the particle and defines 
+       the exit point from the cylinder.
 
         * Particle coordinates on surface: z.
         * Domain: cartesian z.
@@ -1151,10 +1152,10 @@ class CylindricalSurfaceCapInteraction(InteractionSingle):
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
-        assert isinstance(testShell, CylindricalSurfaceCapInteractiontestShell)
+        assert isinstance(testShell, CylindricalSurfaceDiskInteractiontestShell)
         InteractionSingle.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
-        self.zcap = self.testShell.get_referencepoint()
+        self.zdisk = self.testShell.get_referencepoint()
 
     def getv(self):
         return self.pid_particle_pair[1].v
@@ -1162,17 +1163,17 @@ def getv(self):
 
     def get_inner_dz_left(self):
         # This is the distance that the particle can travel from its initial position
-        # towards the reactive cap.
-        # For the cap it is the center of particle that "reacts" with it.
+        # towards the reactive disk.
+        # For the disk it is the center of particle that "reacts" with it.
         # The testShell is taking this into account at construction to ensure that
-        # there is enough space around the cap in case of reaction.
-        # Note that the reference point of the shell is the cap position.
+        # there is enough space around the disk in case of reaction.
+        # Note that the reference point of the shell is the disk position.
         return self.testShell.particle_surface_distance
 
     def get_inner_dz_right(self):
         # This is the distance that the particle can travel from its initial position
-        # towards the absorbing cylinder boundary opposite of the cap.
-        # Note that the reference point of the shell is the cap position,
+        # towards the absorbing cylinder boundary opposite of the disk.
+        # Note that the reference point of the shell is the disk position,
         # therefore we have to subtract particle_surface_distance here.
         to_abs_bnd_distance = self.testShell.dz_right \
                               - self.testShell.particle_surface_distance \
@@ -1190,15 +1191,15 @@ def determine_next_event(self):
 
     def iv_greens_function(self):
 
-        # zcap = position of the cap relative to the initial particle position.
-        # zabs = position of the absorbing cylinder boundary opposite of the cap
-        dz_cap = -self.get_inner_dz_left()
-        dz_abs = self.get_inner_dz_right()
+        # zdisk = position of the disk relative to the initial particle position.
+        # zabs  = position of the absorbing cylinder boundary opposite of the disk
+        dz_disk = -self.get_inner_dz_left()
+        dz_abs  = self.get_inner_dz_right()
 
         if( numpy.isinf(self.interaction_ktot) ):
-            return GreensFunction1DAbsAbs(self.D, self.v, 0.0, dz_cap, dz_abs)
+            return GreensFunction1DAbsAbs(self.D, self.v, 0.0, dz_disk, dz_abs)
         else:
-            return GreensFunction1DRadAbs(self.D, self.v, self.interaction_ktot, 0.0, dz_cap, dz_abs)
+            return GreensFunction1DRadAbs(self.D, self.v, self.interaction_ktot, 0.0, dz_disk, dz_abs)
 
     def draw_new_position(self, dt, event_type):
 
@@ -1211,13 +1212,13 @@ def draw_new_position(self, dt, event_type):
             gf = self.iv_greens_function()
 
             if event_type == EventType.IV_INTERACTION:
-                # The particle left the domain through the reactive boundary, i.e. bound to the cap.
+                # The particle left the domain through the reactive boundary, i.e. bound to the disk.
                 dz = -self.get_inner_dz_left()
                 structure_id = self.target_structure.id
 
             elif event_type == EventType.IV_ESCAPE:
                 # The particle left the domain through the absorbing boundary,
-                # i.e. opposite of the cap.
+                # i.e. opposite of the disk.
                 dz = self.get_inner_dz_right()
                 structure_id = self.origin_structure.id
 
@@ -1231,7 +1232,7 @@ def draw_new_position(self, dt, event_type):
 
             # Add displacement to particle.position.
             # The direction of the shell is leading (not direction of the structure)
-            # The convention is that shell.shape.unit_z points from the cap towards
+            # The convention is that shell.shape.unit_z points from the disk towards
             # the particle's initial position.
             dz_vector = self.shell.shape.unit_z * dz
             newpos = oldpos + dz_vector
@@ -1239,9 +1240,9 @@ def draw_new_position(self, dt, event_type):
         return newpos, structure_id
 
     def __str__(self):
-        return 'CylindricalSurfaceCapInteraction ' + Single.__str__(self)
+        return 'CylindricalSurfaceDiskInteraction ' + Single.__str__(self)
 
-class CylindricalSurfacePlanarSurfaceInteractionSingle(CylindricalSurfaceCapInteraction):
+class CylindricalSurfacePlanarSurfaceInteractionSingle(CylindricalSurfaceDiskInteraction):
     """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
        limited by a plane. The plane is a reactive surface to the particle
        and its intersection with the cylinder axis defines the exit point 
@@ -1254,14 +1255,14 @@ class CylindricalSurfacePlanarSurfaceInteractionSingle(CylindricalSurfaceCapInte
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
         assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell)
-        CylindricalSurfaceCapInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
-        # For now this just does the same as the cap interaction, but the test shells
+        CylindricalSurfaceDiskInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+        # For now this just does the same as the disk interaction, but the test shells
         # slightly differ and we like to keep things apart and organized.
 
     def __str__(self):
         return 'CylindricalSurfacePlanarSurfaceInteraction ' + Single.__str__(self)
 
-class CylindricalSurfacePlanarSurfaceIntermediateSingle(CylindricalSurfaceCapInteraction):
+class CylindricalSurfacePlanarSurfaceIntermediateSingle(CylindricalSurfaceDiskInteraction):
     """1 Particle on a DiskSurface at the interface of a PlanarSurface and CylindricalSurface.
 
         * Particle coordinates on surface: z.
@@ -1272,7 +1273,7 @@ class CylindricalSurfacePlanarSurfaceIntermediateSingle(CylindricalSurfaceCapInt
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
         assert isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell)
-        CylindricalSurfaceCapInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+        CylindricalSurfaceDiskInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
     def getv(self):
         

From 1c12393154c4fe6841aad7f60bddd7534d4d10f3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 2 Sep 2016 13:18:00 +0200
Subject: [PATCH 1484/1541] try/except for finding the closest structure of a
 certain type

...because it turns out that get_closest_structure() sometimes
(randomly?) fails and returns 'None' (even though there is one).

Why? To be solved...

For now we throw a shellmaking exception to make sure that
the simulation does not crash and at least makes a single or
goes to BD mode.
---
 shells.py | 39 ++++++++++++++++++++++++++++-----------
 1 file changed, 28 insertions(+), 11 deletions(-)

diff --git a/shells.py b/shells.py
index 974efe6c..38c3b339 100755
--- a/shells.py
+++ b/shells.py
@@ -2193,8 +2193,12 @@ def set_structure_ignore_list(self):
         disk_radius = self.static_single.structure.shape.radius
         search_pos  = disk_pos
 
-        closest_cyl, closest_cyl_dist = \
-                get_closest_structure(self.world, search_pos, self.static_single.structure.id, [], structure_class=CylindricalSurface)
+        try:
+            closest_cyl, closest_cyl_dist = \
+                    get_closest_structure(self.world, search_pos, self.static_single.structure.id, [], structure_class=CylindricalSurface)
+        except:
+            raise testShellError('(MixedPair2DStatic) get_closest_structure() failed, could not determine closest cylinder.')
+                    
 
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
         if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
@@ -2383,13 +2387,16 @@ def set_structure_ignore_list(self):
         disk_radius = self.structure.shape.radius
         search_pos  = disk_pos
 
-        closest_cyl, closest_cyl_dist = \
-                get_closest_structure(self.world, search_pos, self.structure.id, [], structure_class=CylindricalSurface)
+        try:
+            closest_cyl, closest_cyl_dist = \
+                    get_closest_structure(self.world, search_pos, self.structure.id, [], structure_class=CylindricalSurface)
+        except:
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) get_closest_structure() failed, could not determine closest cylinder.')
 
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
         if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
 
-              raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Disk is not below closest cylinder, distance to axis = %s' \
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInterfaceSingle) Disk is not below closest cylinder, distance to axis = %s' \
                                                                                                                 % disk_to_cylinder_axis_distance)
         if closest_cyl is not None:
             ignore_list = [closest_cyl.id]
@@ -2673,8 +2680,11 @@ def set_structure_ignore_list(self):
         disk_radius = self.target_structure.shape.radius
         search_pos  = disk_pos
 
-        closest_cyl, closest_cyl_dist = \
-                get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
+        try:
+            closest_cyl, closest_cyl_dist = \
+                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
+        except:
+            raise testShellError('(PlanarSurfaceDiskSurfaceInteractionSingle) get_closest_structure() failed, could not determine closest cylinder.')
 
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
         if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
@@ -2810,8 +2820,11 @@ def find_daughter_disk(self):
         search_pos      = self.pid_particle_pair[1].position        
         found_good_disk = False
 
-        closest_disk, closest_disk_dist = \
-                get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+        try:
+            closest_disk, closest_disk_dist = \
+                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+        except:
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInteractionSingle) get_closest_structure() failed, could not determine closest disk.')
 
         if closest_disk is not None:
                                     
@@ -2909,8 +2922,12 @@ def set_structure_ignore_list(self):
         disk_radius = self.target_structure.shape.radius
         search_pos  = disk_pos
 
-        closest_cyl, closest_cyl_dist = \
-                get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
+        try:
+            closest_cyl, closest_cyl_dist = \
+                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
+        except:
+            raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) get_closest_structure() failed, could not determine closest cylinder.')
+                    
 
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
         if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):

From 764e858ed47ee755bebcc754abdafddb88a6bbf5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 6 Sep 2016 12:29:45 +0200
Subject: [PATCH 1485/1541] Move info printing in step() to prevent SEGFAULTS

Printing info on the next-event time before it was actually created
sometimes caused nasty SEGFAULT errors, namely precisely in the
situation when there is only one (Multi) domain!

To prevent this, the info statements were moved after the
event processing block, which ends by inserting a new event time
into the scheduler.

(The same issue probably caused the problems in simulations
 with only one particle -- to be tested!)
---
 egfrd.py | 28 +++++++++++++++++-----------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 6b46ca81..93b2866b 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -498,21 +498,13 @@ def step(self):
         
         # 1. Get the next event from the scheduler
         #
+        log.info('step: getting next event from scheduler')
         id, event = self.scheduler.pop()
         domain = self.domains[event.data]
         if event.time == numpy.inf:
             self.t, self.last_event = self.MAX_TIME_STEP, event
         else:
-            self.t, self.last_event = event.time, event
-        
-        if __debug__:
-            domain_counts = self.count_domains()
-            log.info('\n\n%d: t=%s dt=%e (next_time=%s)\t' %
-                     (self.step_counter, self.t,
-                      self.dt, self.scheduler.top[1].time) + 
-                     'Singles: %d, Pairs: %d, Multis: %d\n' % domain_counts + 
-                     'event=#%d reactions=%d rejectedmoves=%d' %
-                     (id, self.reaction_events, self.rejected_moves))
+            self.t, self.last_event = event.time, event               
 
         # 2. Use the correct method to process (fire) the shell that produced the event
         #
@@ -520,6 +512,7 @@ def step(self):
         # different classes of shells (see bottom egfrd.py) 
         # event.data holds the object (Single, Pair, Multi) that is associated with the next event.
         # e.g. "if class is Single, then process_single_event" ~ MW
+        log.info('step: dispatching to appropriate event handler')
         for klass, f in self.dispatch:
 
             if isinstance(domain, klass):
@@ -535,9 +528,22 @@ def step(self):
         # 3. Adjust the simulation time
         #
         next_time = self.scheduler.top[1].time
-        log.info('next_time=%s' % next_time)
+        log.info('step: next_time=%s' % next_time)
         self.dt = next_time - self.t
 
+        # Print some info
+        # Make sure this comes after the new event has been created, 
+        # otherwise we risk a SEGFAULT here at low particle numbers,
+        # because self.scheduler.top[1] may not exist!
+        if __debug__:
+            domain_counts = self.count_domains()
+            log.info('\n\n%d: t=%s dt=%e (next_time=%s)\t' %
+                     (self.step_counter, self.t,
+                      self.dt, self.scheduler.top[1].time) + 
+                     'Singles: %d, Pairs: %d, Multis: %d\n' % domain_counts + 
+                     'event=#%d reactions=%d rejectedmoves=%d' %
+                     (id, self.reaction_events, self.rejected_moves))
+                     
         # assert if not too many successive dt=0 steps occur.
         if __debug__:
             if self.dt < 1e-10: # We consider 0.1 nanoseconds a zero-step

From 0115d0494886fb0809975f7704941c2498e90ce5 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 11:16:20 +0200
Subject: [PATCH 1486/1541] exit() function + aliases for TIRViE

---
 visualization/TIRViE.py | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index f64e74a6..6abb3788 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -179,8 +179,6 @@ def visualize(self):
     
       self.capture()
       
-    
-    #sys.exit()
   #################################################################
   #################################################################
   #################################################################
@@ -441,6 +439,23 @@ def retard(self):
     
       time.sleep(self.RETARDING_SECONDS)
       
+
+  def exit(self):
+    
+      print "TIRViE: Stopping"
+      self.scene.exit = True
+      exit()
+
+      
+  def quit(self):
+      # Just an alias
+      self.exit()
+
+      
+  def stop(self):
+      # Just an alias
+      self.exit()
+      
       
   def set_info_label_strings(self):
     

From aa6169b02b3edf80bfcd27d3ed228a5bc9c72372 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 11:16:40 +0200
Subject: [PATCH 1487/1541] Make wireframe mode for simulation box default in
 TIRViE

---
 visualization/TIRViE.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index 6abb3788..a770d0ee 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -78,7 +78,7 @@ def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, ca
     
     # Some flags tuning visual behavior of the objects
     self.SHOW_SIM_BOX     = True
-    self.WIREFRAME_BOX    = False
+    self.WIREFRAME_BOX    = True
     self.WIREFRAME_PLANES = False
     self.SHOW_DOMAINS     = True
     self.SHOW_STRUCTURES  = True

From e1cc0b97eba2f5929195d825a96968f88b04edca Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 11:18:48 +0200
Subject: [PATCH 1488/1541] Rename ROD_RADIUS_FACTOR -> CYL_SURF_RADIUS_FACTOR
 and reset default value to 1

---
 visualization/TIRViE.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index a770d0ee..dd2ab05e 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -89,7 +89,7 @@ def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, ca
     self.CYLINDER_SURFACES_OPACITY = 0.20
     self.DISK_SURFACES_OPACITY     = 0.60
     self.PARTICLE_RADIUS_FACTOR    = 1  # will show particle sphere radii this times larger than actual
-    self.ROD_RADIUS_FACTOR         = 2  # will show radii of cyl. surfaces this times larger than actual
+    self.CYL_SURF_RADIUS_FACTOR    = 1  # will show radii of cyl. surfaces this times larger than actual
     self.N_HELIX_COILS             = 30 # sth. btw. 15-30 seems to be a good choice; this is eyecandy anyhow ;-)
     self.WIREFRAME_RADIUS          = self.world_size/500 # seems fair enough
     self.HELIX_THICKNESS_FACTOR    = 0.4
@@ -813,13 +813,13 @@ def draw_cylindrical_surfaces(self, position_list, orientation_list, radius_list
       # TODO Check that lists all have the same length
       for n in range(len(position_list)):
 
-          outer_radius = self.ROD_RADIUS_FACTOR*radius_list[n]
+          outer_radius = self.CYL_SURF_RADIUS_FACTOR*radius_list[n]
       
           if self.RODS_AS_HELICES == True and length_list[n] > 0.0:
             # The standard VPython helix object cannot be properly erased from the scene, so we use an own one ;-)            
             obj = self.tomeks_double_helix(pos=position_list[n], axis=orientation_list[n], radius=outer_radius, \
                                               length=length_list[n], color=color_list[n], thickness=self.HELIX_THICKNESS_FACTOR*outer_radius)
-                                              # thickness=self.ROD_RADIUS_FACTOR*radius_list[n]/7 also worked well
+                                              # thickness=self.CYL_SURF_RADIUS_FACTOR*radius_list[n]/7 also worked well
           elif length_list[n] > 0.0:
             obj = v.cylinder(pos=position_list[n], axis=orientation_list[n], radius=outer_radius, \
                                   length=length_list[n], color=color_list[n], opacity=self.CYLINDER_SURFACES_OPACITY)

From a97044f48f4fda3056ded15ec29d1fa8ad41b2f1 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 11:23:25 +0200
Subject: [PATCH 1489/1541] Make radius size factor a(n) (optional) parameter
 to TIRViE

...and cleanup constructors a bit.
---
 visualization/TIRViE.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index dd2ab05e..df2e342f 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -59,7 +59,7 @@ class TheImperialRoyalVisualizerForEGFRD:
       - Optional PoVRay output (files that can be rendered by PoVRay)
     
   """
-  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames'):
+  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames', radius_factor=1):
 
     self.sim = eGFRDsim
     self.world_size = self.get_world_size()
@@ -88,8 +88,8 @@ def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, ca
     self.PLANAR_SURFACES_OPACITY   = 0.20
     self.CYLINDER_SURFACES_OPACITY = 0.20
     self.DISK_SURFACES_OPACITY     = 0.60
-    self.PARTICLE_RADIUS_FACTOR    = 1  # will show particle sphere radii this times larger than actual
-    self.CYL_SURF_RADIUS_FACTOR    = 1  # will show radii of cyl. surfaces this times larger than actual
+    self.PARTICLE_RADIUS_FACTOR    = radius_factor  # will show particle sphere radii this times larger than actual
+    self.CYL_SURF_RADIUS_FACTOR    = radius_factor  # will show radii of cyl. surfaces this times larger than actual
     self.N_HELIX_COILS             = 30 # sth. btw. 15-30 seems to be a good choice; this is eyecandy anyhow ;-)
     self.WIREFRAME_RADIUS          = self.world_size/500 # seems fair enough
     self.HELIX_THICKNESS_FACTOR    = 0.4
@@ -1053,8 +1053,11 @@ class TIRViE(TheImperialRoyalVisualizerForEGFRD):
     This is just an alias for 'TheImperialRoyalVisualizerForEGFRD'
   
   """
-  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames'):
+  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames',radius_factor=1):
 
-    TheImperialRoyalVisualizerForEGFRD.__init__(self,eGFRDsim, particle_color_dict, structure_color_dict, capture, capture_dir)
-    
+    TheImperialRoyalVisualizerForEGFRD.__init__(self, eGFRDsim=eGFRDsim, \
+                                                      particle_color_dict=particle_color_dict, structure_color_dict=structure_color_dict, \
+                                                      capture=capture, capture_dir=capture_dir, \
+                                                      radius_factor=radius_factor)
+                                                      
     
\ No newline at end of file

From 1554afee25a17ac57d7999754c326da134d5d159 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 11:28:16 +0200
Subject: [PATCH 1490/1541] Allow for independent specification of particle and
 cyl. surf. radius factor

---
 visualization/TIRViE.py | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index df2e342f..17374e20 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -59,7 +59,8 @@ class TheImperialRoyalVisualizerForEGFRD:
       - Optional PoVRay output (files that can be rendered by PoVRay)
     
   """
-  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames', radius_factor=1):
+  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, \
+                        capture=False, capture_dir='./tirvie_frames', particle_radius_factor=1, cyl_radius_factor=1):
 
     self.sim = eGFRDsim
     self.world_size = self.get_world_size()
@@ -88,8 +89,8 @@ def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, ca
     self.PLANAR_SURFACES_OPACITY   = 0.20
     self.CYLINDER_SURFACES_OPACITY = 0.20
     self.DISK_SURFACES_OPACITY     = 0.60
-    self.PARTICLE_RADIUS_FACTOR    = radius_factor  # will show particle sphere radii this times larger than actual
-    self.CYL_SURF_RADIUS_FACTOR    = radius_factor  # will show radii of cyl. surfaces this times larger than actual
+    self.PARTICLE_RADIUS_FACTOR    = particle_radius_factor  # will show particle sphere radii this times larger than actual
+    self.CYL_SURF_RADIUS_FACTOR    = cyl_radius_factor       # will show radii of cyl. surfaces this times larger than actual
     self.N_HELIX_COILS             = 30 # sth. btw. 15-30 seems to be a good choice; this is eyecandy anyhow ;-)
     self.WIREFRAME_RADIUS          = self.world_size/500 # seems fair enough
     self.HELIX_THICKNESS_FACTOR    = 0.4
@@ -1053,11 +1054,11 @@ class TIRViE(TheImperialRoyalVisualizerForEGFRD):
     This is just an alias for 'TheImperialRoyalVisualizerForEGFRD'
   
   """
-  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames',radius_factor=1):
+  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames', particle_radius_factor=1, cyl_radius_factor=1):
 
     TheImperialRoyalVisualizerForEGFRD.__init__(self, eGFRDsim=eGFRDsim, \
                                                       particle_color_dict=particle_color_dict, structure_color_dict=structure_color_dict, \
                                                       capture=capture, capture_dir=capture_dir, \
-                                                      radius_factor=radius_factor)
+                                                      particle_radius_factor=particle_radius_factor, cyl_radius_factor=cyl_radius_factor)
                                                       
     
\ No newline at end of file

From afb98f6a244fb290c3e53c76895c907fda8a6330 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 11:49:47 +0200
Subject: [PATCH 1491/1541] Improvements to Tomek's helix eyecandy

In particular, it will now adjust the number of coils when
scaled up or down in length.

The number of coils is now computed with respect to the world size.
---
 visualization/TIRViE.py | 39 ++++++++++++++++++++++++---------------
 1 file changed, 24 insertions(+), 15 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index 17374e20..c5f4148b 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -955,13 +955,18 @@ def wireframe_plane(self, pos=(0,0,0), orientation=[(1,0,0),(0,1,0),(0,0,1)], si
   def tomeks_helix(self, pos=(0,0,0), axis=(1,0,0), radius=1.0, length=10.0, color=(1,0,0), thickness=0.01):
           
       Ncoils  = self.N_HELIX_COILS
-      Npoints = 10 * Ncoils 
+      Npoints = 10 * self.N_HELIX_COILS
+      
+      intercoil_dist = length / Ncoils
+      interpnt_dist  = length / Npoints            
       
       # Draw the helix in the default coordinate system and tie it to a frame
-      f = v.frame()
-      c = v.curve( x = v.arange(0,length,length/Npoints), frame=f, color=color, radius = thickness)
-      c.y = radius * np.sin(c.x * 2.0*np.pi/length * Ncoils)
-      c.z = radius * np.cos(c.x * 2.0*np.pi/length * Ncoils)
+      f         = v.frame()
+      x_lattice = v.arange(0, length, interpnt_dist)
+      
+      c = v.curve(x = x_lattice, frame=f, color=color, radius = thickness)
+      c.y = radius * np.sin(c.x * 2.0*np.pi/intercoil_dist)
+      c.z = radius * np.cos(c.x * 2.0*np.pi/intercoil_dist)
       
       # Now rotate it to the right orientation
       f.pos  = pos
@@ -973,21 +978,25 @@ def tomeks_helix(self, pos=(0,0,0), axis=(1,0,0), radius=1.0, length=10.0, color
   def tomeks_double_helix(self, pos=(0,0,0), axis=(1,0,0), radius=1.0, length=10.0, color=(1,0,0), thickness=0.01):
 
       # This is just the two of the standard 'tomeks_helices' with an offset of 1/2 of a coil
-      Ncoils  = self.N_HELIX_COILS
-      Npoints = 10 * Ncoils 
+      Ncoils  = int(self.N_HELIX_COILS * length/self.world_size)
+      Npoints = 10 * self.N_HELIX_COILS
+      
+      intercoil_dist = length / Ncoils
+      interpnt_dist  = length / Npoints
       
-      offset = length / Ncoils / 2.0
+      offset = intercoil_dist / 2.0 # offset of second helix with respect to first one
       
       # Draw the helices in the default coordinate system and tie it to a frame
-      f = v.frame()
+      f         = v.frame()      
+      x_lattice = v.arange(0, length, interpnt_dist)
       
-      c1 = v.curve( x = v.arange(0,length,length/Npoints), frame=f, color=color, radius = thickness)
-      c1.y = radius * np.sin(c1.x * 2.0*np.pi/length * Ncoils)
-      c1.z = radius * np.cos(c1.x * 2.0*np.pi/length * Ncoils)
+      c1 = v.curve(x = x_lattice, frame=f, color=color, radius = thickness)
+      c1.y = radius * np.sin(c1.x * 2.0*np.pi/intercoil_dist)
+      c1.z = radius * np.cos(c1.x * 2.0*np.pi/intercoil_dist)
       
-      c2 = v.curve( x = v.arange(0,length,length/Npoints), frame=f, color=self.complementary(color), radius = thickness)
-      c2.y = radius * np.sin( (c2.x - offset) * 2.0*np.pi/length * Ncoils)
-      c2.z = radius * np.cos( (c2.x - offset) * 2.0*np.pi/length * Ncoils)
+      c2 = v.curve(x = x_lattice, frame=f, color=self.complementary(color), radius = thickness)
+      c2.y = radius * np.sin( (c2.x - offset) * 2.0*np.pi/intercoil_dist)
+      c2.z = radius * np.cos( (c2.x - offset) * 2.0*np.pi/intercoil_dist)
       
       # Now rotate it to the right orientation
       f.pos  = pos

From 01900eeff48b6f79f665789ba9e3a80c3effcdf2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 15:22:08 +0200
Subject: [PATCH 1492/1541] Aliases to get_next_time() and some exception
 message cleanup

---
 egfrd.py | 42 +++++++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 93b2866b..0b62032e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -320,6 +320,14 @@ def get_next_time(self):
         else:
             return self.scheduler.top[1].time
 
+    # Some alias methods for the one above
+    def get_next_event_time(self):        
+        return self.get_next_time()        
+    def next_time(self):
+        return self.get_next_time()
+    def next_event_time(self):
+        return self.get_next_time()
+
     #####################################################
     #### METHODS FOR GENERAL SIMULATOR FUNCTIONALITY ####
     #####################################################
@@ -435,10 +443,10 @@ def stop(self, t):
             return                              # FIXME: is this accurate? Probably use feq from utils.py
 
         if t >= self.scheduler.top[1].time:     # Can't schedule a stop later than the next event time
-            raise RuntimeError('Stop time >= next event time.')
+            raise RuntimeError('stop: stop time >= next event time.')
 
         if t < self.t:
-            raise RuntimeError('Stop time < current time.')
+            raise RuntimeError('stop: stop time < current time.')
 
         self.t = t
 
@@ -494,7 +502,7 @@ def step(self):
 
         if __debug__:
             if self.scheduler.size == 0:
-                raise RuntimeError('No Events in scheduler.')
+                raise RuntimeError('step: no Events in scheduler.')
         
         # 1. Get the next event from the scheduler
         #
@@ -523,7 +531,7 @@ def step(self):
 
         if __debug__:
             if self.scheduler.size == 0:
-                raise RuntimeError('Zero events left.')
+                raise RuntimeError('step: zero events left.')
 
         # 3. Adjust the simulation time
         #
@@ -552,7 +560,7 @@ def step(self):
                 self.zero_steps += 1
 
                 if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
-                    raise RuntimeError('too many successive dt=zero steps -> Simulator stalled?'
+                    raise RuntimeError('step: too many successive dt=zero steps --> Simulator stalled???'
                                        'dt= %.10e-%.10e' % (next_time, self.t))
                 
             else:
@@ -1433,7 +1441,7 @@ def conditional_swap(newposA, newposB):
                             Ns = Ns + 1
                             if Ns > self.MAX_NUM_DT0_STEPS:   # To avoid an infinite loop we need some kind of break condition
                                                               # We take the same looping limit as for dt=0 steps because this is a similar situation
-                                raise RuntimeError('Too many resampling attempts in fire_single on PlanarSurface with two products: Ns = %s > %s' \
+                                raise RuntimeError('fire_single_reaction: too many resampling attempts in reaction on PlanarSurface with two products: Ns = %s > %s' \
                                                   % (Ns, self.MAX_NUM_DT0_STEPS) )
                                                   # TODO This should not necessarily raise RuntimeError but just a warning;
                                                   # this is for TESTING only; replace by something better
@@ -1495,7 +1503,7 @@ def conditional_swap(newposA, newposB):
 
                 else:
                     # cannot decay from 3D to other structure
-                    raise RuntimeError('fire_single_reaction: Can not decay from 3D to other structure')
+                    raise RuntimeError('fire_single_reaction: can not decay from 3D to other structure')
 
 
             # 1.5 Get new positions and structure_ids of particles
@@ -2995,7 +3003,7 @@ def domain_distance(self, pos, domain):
     def obj_distance_array(self, pos, domains):
         dists = numpy.array([self.domain_distance(pos, domain) for domain in domains])
         return dists
-            
+        
 
     ####################
     #### STATISTICS ####
@@ -3449,7 +3457,7 @@ def check_event_stoichiometry(self):
                     assert (abs(domain.last_time + domain.dt - event.time) <= TIME_TOLERANCE * event.time)
                     break
             else:
-                raise RuntimeError('Event for domain_id %s could not be found in scheduler' % str(domain_id) )
+                raise RuntimeError('check_event_stoichiometry: event for domain_id %s could not be found in scheduler' % str(domain_id) )
 
             # make sure that we had not already found it earlier
             assert domain_id not in already_in_scheduler
@@ -3467,7 +3475,7 @@ def check_particle_consistency(self):
             domain_population += domain.multiplicity
 
         if world_population != domain_population:
-            raise RuntimeError('population %d != domain_population %d' %
+            raise RuntimeError('check_event_stoichiometry: population %d != domain_population %d' %
                                (world_population, domain_population))
 
         # If control bounds are defined, check whether all particles are within
@@ -3539,7 +3547,7 @@ def check_shell_matrix(self):
                 for sid in diff:
                     print shell_map.get(sid, None)
 
-                raise RuntimeError('number of shells are inconsistent '
+                raise RuntimeError('check_shell_matrix: number of shells are inconsistent '
                                    '(%d != %d; %s) - %s' %
                                    (len(shell_ids), domain.num_shells, 
                                     domain.domain_id, diff))
@@ -3547,7 +3555,7 @@ def check_shell_matrix(self):
         # check that total number of shells in domains==total number of shells in shell container
         matrix_population = self.geometrycontainer.get_total_num_shells()
         if shell_population != matrix_population:
-            raise RuntimeError('num shells (%d) != matrix population (%d)' %
+            raise RuntimeError('check_shell_matrix: num shells (%d) != matrix population (%d)' %
                                (shell_population, matrix_population))
         # Since the number of shells in the domains is equal to the number of shells in the
         # geometrycontainer this now also means that all the shells in the geometrycontainer are
@@ -3612,15 +3620,15 @@ def check_domains(self):
         # check that all the event_id in the scheduler are also stored in a domain
         for id, event in self.scheduler:
             if id not in event_ids:
-                raise RuntimeError('Event %s in EventScheduler has no domain in self.domains' %
+                raise RuntimeError('check_domains: event %s in event scheduler has no domain in self.domains' %
                                    event)
             else:
                 event_ids.remove(id)
 
         # self.domains always include a None  --> this can change in future
         if event_ids:
-            raise RuntimeError('following domains in self.domains are not in '
-                               'Event Scheduler: %s' % str(tuple(event_ids)))
+            raise RuntimeError('check_domains: following domains in self.domains are not in '
+                               'event scheduler: %s' % str(tuple(event_ids)))
 
     def check_pair_pos(self, pair, pos1, pos2, com, radius):
         particle1 = pair.pid_particle_pair1[1]
@@ -3648,7 +3656,7 @@ def check_pair_pos(self, pair, pos1, pos2, com, radius):
         d1 = self.world.distance(old_com, pos1) + particle1.radius
         d2 = self.world.distance(old_com, pos2) + particle2.radius
         if d1 > radius or d2 > radius:
-            raise RuntimeError('New particle(s) out of protective sphere. ' 
+            raise RuntimeError('check_pair_pos: new particle(s) out of protective sphere. ' 
                                'radius = %s, d1 = %s, d2 = %s ' %
                                (FORMAT_DOUBLE % radius, FORMAT_DOUBLE % d1,
                                 FORMAT_DOUBLE % d2))
@@ -3779,7 +3787,7 @@ def count_domains(self):
             elif isinstance(d, Multi):
                 num_multis += 1
             else:
-                raise RuntimeError('DO NOT GET HERE')
+                raise RuntimeError('count_domains: domain has unknown type!')
 
         return (num_singles, num_pairs, num_multis)
 

From 197ebd6f7ffec3d5735165bfe51097d443e49bca Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 15:22:40 +0200
Subject: [PATCH 1493/1541] Improved clear_scene() method in TIRViE

---
 visualization/TIRViE.py | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index c5f4148b..ef69600e 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -276,19 +276,28 @@ def create_new_scene(self):
     print "Scene created."    
     
   
-  def clear_scene(self, types_list = [v.box, v.sphere, v.cylinder, v.ring, v.helix, v.frame, v.curve]):
-      
-    for t in types_list:
-      for obj in self.objects:
-          if isinstance(obj, t):
-            
-            # First make the object invisible            
-            obj.visible = False
+  def clear_scene(self):
+    
+    #self.scene.delete() ### not functional in older VPython versions; we need the workaround below    
+    
+    for obj in self.objects:          
+          
+          try:
+            # First make the object invisible
+            obj.visible = False                        
             
             # Now delete the object
             del obj
-        
-    self.objects = []
+            
+          except:
+            print "WARNING! Could not delete 3D object " + str(obj) + " from scene!"
+    
+    self.objects = [] # This is way faster than self.objects.remove() while iterating
+    
+    if len(self.scene.objects) > 1:
+        # One object usually remains on scene--the info label
+        print "WARNING! Not all 3D objects deleted from scene!"
+        print "self.scene.objects = " + str(self.scene.objects)
     
 
   #########################      

From 3f7be7b6a90584345bd038d623d2a33d8357d37a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 7 Sep 2016 17:09:04 +0200
Subject: [PATCH 1494/1541] More changes to clear_scene(), treating frame
 deletion more carfully

---
 visualization/TIRViE.py | 40 ++++++++++++++++++++++++++++++++--------
 1 file changed, 32 insertions(+), 8 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index ef69600e..76248095 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -282,15 +282,25 @@ def clear_scene(self):
     
     for obj in self.objects:          
           
-          try:
-            # First make the object invisible
-            obj.visible = False                        
-            
-            # Now delete the object
-            del obj
+          if isinstance(obj, v.frame) or isinstance(obj, v.curve):
+            # In frames we want to loop over the grouped objects individually
+            # to make sure that Python 'del' works correctly on all of them below
+            # BEWARE! Omitting this extra step may cause memory leaks!
+            try:
+              primitives = obj.objects
+            except:
+              print "WARNING! Primitive object list does not exist for supposed frame object => risk of incomplete deletion!"
+              primitives = [obj]
+              
+          else:
+            primitives = [obj]
             
-          except:
-            print "WARNING! Could not delete 3D object " + str(obj) + " from scene!"
+          for p in primitives:
+            self.delete_vpython_object(p)
+              
+          # Do not forget to properly delete the frame as well
+          if isinstance(obj, v.frame):
+            self.delete_vpython_object(obj)
     
     self.objects = [] # This is way faster than self.objects.remove() while iterating
     
@@ -298,7 +308,21 @@ def clear_scene(self):
         # One object usually remains on scene--the info label
         print "WARNING! Not all 3D objects deleted from scene!"
         print "self.scene.objects = " + str(self.scene.objects)
+
     
+  # Helper function for clear_scene() above
+  def delete_vpython_object(self, obj):
+    
+    try:
+      # First make the object invisible
+      obj.visible = False
+      
+      # Now delete the object
+      del obj
+      
+    except:
+      print "WARNING! Could not delete primitive 3D object " + str(obj) + " from scene!"
+          
 
   #########################      
   ### CAPTURING METHODS ###

From 04b8e894b42d91facedfb4bb24805eb8beea4b6a Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Thu, 8 Sep 2016 13:59:29 +0200
Subject: [PATCH 1495/1541] Another flag for DiskSurface to distinguish cap
 from sink

We want to use this to determine when the code should try
to make a CylindricalSurfaceDiskSurfaceInteraction vs.
a CylindricalSurfaceSinkInteraction.

Note that both are different with respect to the resulting
diffusion behaviour--particles cannot diffuse past "caps"!
---
 DiskSurface.hpp         | 34 ++++++++++++++++++++++++++++------
 binding/DiskSurface.hpp |  6 +++++-
 2 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 191a398e..8358fec4 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -53,20 +53,42 @@ class DiskSurface
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
-    // As a specialty, the DiskStructure has a flag that can be set to make the particle not move radially upon
+    // As a specialty, the DiskStructure has flags that can be set to specify its usage/behavior
+    // If a DiskStructure is set to be a "cap" it is assumed that it "caps" a cylinder, i.e. is located
+    // at the end of a finite cylinder. If it is a "sink" it is inside the cylinder; in that case, the
+    // main loop will try to make a CylindricalSurfaceSinkInteraction domain, which also allows
+    // for diffusion of the particle past the sink. If the disk is a cap, particles cannot diffuse past it!
+    // In addition, the flag "RADIAL_DISSOCIATION" can be used to make the particle not move radially upon
     // a dissociation event, but axially (i.e., in direction of the cylinder axis of the parent cylinder)
     // This can be used for disks that are "sinks" (binding sites) on cylindrical structures
-    bool RADIAL_DISSOCIATION; // by default it is true, automatically set by constructor below
-    // Setters for the flag
+    bool IS_CAP;              // by default it is assumed that the disk is a cap; automatically set by constructor below
+    bool RADIAL_DISSOCIATION; // accordingly, this is assumed to be true by default as well
+    // Setters for these flags
+    virtual void treat_as_sink()
+    {
+        this->IS_CAP = false;
+    }
+    virtual void treat_as_cap()
+    {
+        this->IS_CAP = true;
+    }
     virtual void forbid_radial_dissociation()
     {
         this->RADIAL_DISSOCIATION = false;
-    }    
+    }
     virtual void allow_radial_dissociation()
     {
         this->RADIAL_DISSOCIATION = true;
     }
-    // Getters
+    // Getters    
+    virtual bool const& is_cap() const
+    {
+        return this->IS_CAP;
+    }
+    virtual bool const& is_sink() const
+    {
+        return not(this->IS_CAP);
+    }
     virtual bool const& dissociates_radially() const
     {
         return this->RADIAL_DISSOCIATION;
@@ -509,7 +531,7 @@ class DiskSurface
     }
         
     DiskSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
-        : base_type(name, sid, parent_struct_id, shape), RADIAL_DISSOCIATION(true) {}
+        : base_type(name, sid, parent_struct_id, shape), IS_CAP(true), RADIAL_DISSOCIATION(true) {}
 };
 
 #endif /* DISK_SURFACE_HPP */
diff --git a/binding/DiskSurface.hpp b/binding/DiskSurface.hpp
index 1b662cfa..e494a79d 100644
--- a/binding/DiskSurface.hpp
+++ b/binding/DiskSurface.hpp
@@ -21,8 +21,12 @@ inline boost::python::objects::class_base register_disk_surface_class(char const
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
-        .def("allow_radial_dissociation", &impl_type::allow_radial_dissociation)
+        .def("treat_as_cap",  &impl_type::treat_as_cap)
+        .def("treat_as_sink", &impl_type::treat_as_sink)
+        .def("allow_radial_dissociation",  &impl_type::allow_radial_dissociation)
         .def("forbid_radial_dissociation", &impl_type::forbid_radial_dissociation)
+        .def("is_cap",  &impl_type::is_cap,  return_value_policy<return_by_value>())
+        .def("is_sink", &impl_type::is_sink, return_value_policy<return_by_value>())
         .def("dissociates_radially", &impl_type::dissociates_radially, return_value_policy<return_by_value>())
         ;
 }

From 7cc8d69df8307f87b3580f2bee4d3f1ea931d155 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Thu, 8 Sep 2016 15:05:08 +0200
Subject: [PATCH 1496/1541] Some renaming ("cap" -> "barrier") and fixes to
 barrier/sink distinction

---
 DiskSurface.hpp         | 33 +++++++++++++++++----------------
 binding/DiskSurface.hpp |  7 +++----
 egfrd.py                |  9 ++++++---
 shells.py               |  7 +++++--
 4 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/DiskSurface.hpp b/DiskSurface.hpp
index 8358fec4..3707f80a 100644
--- a/DiskSurface.hpp
+++ b/DiskSurface.hpp
@@ -53,24 +53,29 @@ class DiskSurface
     typedef std::pair<position_type, structure_id_type>                           position_structid_pair_type;
     typedef std::pair<position_structid_pair_type, position_structid_pair_type>   position_structid_pair_pair_type;
 
-    // As a specialty, the DiskStructure has flags that can be set to specify its usage/behavior
-    // If a DiskStructure is set to be a "cap" it is assumed that it "caps" a cylinder, i.e. is located
-    // at the end of a finite cylinder. If it is a "sink" it is inside the cylinder; in that case, the
-    // main loop will try to make a CylindricalSurfaceSinkInteraction domain, which also allows
+    // As a specialty, the DiskStructure has flags that can be set to specify its usage/behavior.
+    //
+    // If a DiskStructure is set to be a "barrier" ("cap") particles cannot pass by it, unless they
+    // first bind to it and then unbind. Usually this is used to "cap" a cylinder, i.e. to place a
+    // reactive disk at the end of a finite cylinder.
+    // If it is a "sink" it is inside the cylinder; in that case, particle can diffuse past it without reacting
+    // and the main loop will try to make a CylindricalSurfaceSinkInteraction domain, which also allows
     // for diffusion of the particle past the sink. If the disk is a cap, particles cannot diffuse past it!
+    //
     // In addition, the flag "RADIAL_DISSOCIATION" can be used to make the particle not move radially upon
     // a dissociation event, but axially (i.e., in direction of the cylinder axis of the parent cylinder)
     // This can be used for disks that are "sinks" (binding sites) on cylindrical structures
-    bool IS_CAP;              // by default it is assumed that the disk is a cap; automatically set by constructor below
+    //
+    bool IS_BARRIER;          // by default the disk is a cap/barrier to particles; automatically set by constructor below
     bool RADIAL_DISSOCIATION; // accordingly, this is assumed to be true by default as well
     // Setters for these flags
     virtual void treat_as_sink()
     {
-        this->IS_CAP = false;
+        this->IS_BARRIER = false;
     }
-    virtual void treat_as_cap()
+    virtual void treat_as_barrier()
     {
-        this->IS_CAP = true;
+        this->IS_BARRIER = true;
     }
     virtual void forbid_radial_dissociation()
     {
@@ -81,14 +86,10 @@ class DiskSurface
         this->RADIAL_DISSOCIATION = true;
     }
     // Getters    
-    virtual bool const& is_cap() const
+    virtual bool const& is_barrier() const
     {
-        return this->IS_CAP;
-    }
-    virtual bool const& is_sink() const
-    {
-        return not(this->IS_CAP);
-    }
+        return this->IS_BARRIER;
+    }    
     virtual bool const& dissociates_radially() const
     {
         return this->RADIAL_DISSOCIATION;
@@ -531,7 +532,7 @@ class DiskSurface
     }
         
     DiskSurface(structure_name_type const& name, structure_type_id_type const& sid, structure_id_type const& parent_struct_id, shape_type const& shape)
-        : base_type(name, sid, parent_struct_id, shape), IS_CAP(true), RADIAL_DISSOCIATION(true) {}
+        : base_type(name, sid, parent_struct_id, shape), IS_BARRIER(true), RADIAL_DISSOCIATION(true) {}
 };
 
 #endif /* DISK_SURFACE_HPP */
diff --git a/binding/DiskSurface.hpp b/binding/DiskSurface.hpp
index e494a79d..56256282 100644
--- a/binding/DiskSurface.hpp
+++ b/binding/DiskSurface.hpp
@@ -21,12 +21,11 @@ inline boost::python::objects::class_base register_disk_surface_class(char const
                        typename impl_type::shape_type>())
         .add_property("shape",
             make_function((typename impl_type::shape_type const&(impl_type::*)()const)&impl_type::shape, return_value_policy<return_by_value>()))
-        .def("treat_as_cap",  &impl_type::treat_as_cap)
-        .def("treat_as_sink", &impl_type::treat_as_sink)
+        .def("treat_as_barrier", &impl_type::treat_as_barrier)
+        .def("treat_as_sink",    &impl_type::treat_as_sink)
         .def("allow_radial_dissociation",  &impl_type::allow_radial_dissociation)
         .def("forbid_radial_dissociation", &impl_type::forbid_radial_dissociation)
-        .def("is_cap",  &impl_type::is_cap,  return_value_policy<return_by_value>())
-        .def("is_sink", &impl_type::is_sink, return_value_policy<return_by_value>())
+        .def("is_barrier",  &impl_type::is_barrier,  return_value_policy<return_by_value>())
         .def("dissociates_radially", &impl_type::dissociates_radially, return_value_policy<return_by_value>())
         ;
 }
diff --git a/egfrd.py b/egfrd.py
index 0b62032e..80a2cc8c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -128,9 +128,12 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
             raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(target_structure, DiskSurface):
-            return CylindricalSurfaceDiskInteractiontestShell (single, target_structure, geometrycontainer, domains)
-        elif isinstance(target_structure, CylindricalSurface):
-            return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
+            try:
+                return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
+            except testShellError as e:
+                if __debug__:
+                      log.warn('Could not make CylindricalSurfaceSinktestShell, %s; now trying CylindricalSurfaceDiskInteractiontestShell.' % str(e))
+                return CylindricalSurfaceDiskInteractiontestShell (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, PlanarSurface):
             return CylindricalSurfacePlanarSurfaceInteractionSingletestShell (single, target_structure, geometrycontainer, domains)
         else:
diff --git a/shells.py b/shells.py
index 38c3b339..a3011d3c 100755
--- a/shells.py
+++ b/shells.py
@@ -2949,6 +2949,9 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         
         # FIXME Check: Is this actually ever created, or does the main loop always pick 'CylindricalSurfaceDiskInteraction'?
 
+        if self.target_structure.is_barrier():
+            raise testShellError('(CylindricalSurfaceSink) DiskSurface is not a sink')
+          
         # initialize scaling parameters
         self.dr_const   = self.pid_particle_pair[1].radius * CYLINDER_R_FACTOR
 
@@ -2975,7 +2978,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             self.dr, self.dz_right, self.dz_left = \
                             self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], [self.target_structure.id])
         except ShellmakingError as e:
-            raise testShellError('(CylindricalSurfaceSink). %s' %
+            raise testShellError('(CylindricalSurfaceSink) %s' %
                                  (str(e)))
 
         # make sure the domain is symmetric around the particle
@@ -2984,7 +2987,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         # check if the domain is still large enough for the interaction
         _, _, min_dz_left = self.get_min_dr_dzright_dzleft()
         if self.dz_left < min_dz_left:
-            raise testShellError('(CylindricalSurfaceSink). Domain too small after symmetricalizing.')
+            raise testShellError('(CylindricalSurfaceSink) Domain too small after symmetricalizing')
 
 
     def get_orientation_vector(self):

From 7d9d1bea82eaae8e22b57274778f4f78a2456921 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Thu, 8 Sep 2016 15:20:23 +0200
Subject: [PATCH 1497/1541] More detailed error output in stop() method

---
 egfrd.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 80a2cc8c..8905f127 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -446,10 +446,10 @@ def stop(self, t):
             return                              # FIXME: is this accurate? Probably use feq from utils.py
 
         if t >= self.scheduler.top[1].time:     # Can't schedule a stop later than the next event time
-            raise RuntimeError('stop: stop time >= next event time.')
+            raise RuntimeError('stop: stop time (%g) >= next event time (%g).' % (t, self.next_time()))
 
         if t < self.t:
-            raise RuntimeError('stop: stop time < current time.')
+            raise RuntimeError('stop: stop time (%g) < current time (%g).' % (t, self.t))
 
         self.t = t
 

From b6f15b762997432d93524ca687183aad2330eb96 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 31 Oct 2016 15:13:01 +0100
Subject: [PATCH 1498/1541] Fix creation of
 'CylindricalSurfacePlanarSurfaceIntermediateSingletestShell'

So far it was not even created because of a standard check that discards
creation of an interaction shell when the particle already is in the
surface that it tries to interact with.

The latter, however, is a precondition for forming the abovementioned
shell, so we needed to make an exception!
---
 shells.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index a3011d3c..ae8f36d0 100755
--- a/shells.py
+++ b/shells.py
@@ -196,10 +196,12 @@ def __init__(self, single, origin_structure, target_structure):
         self.reference_point, (normal_comp, dist_to_surface_edge) = self.target_structure.project_point(pos_transposed)
         if dist_to_surface_edge >= 0:
             raise testShellError('(testInteractionSingle). Projected point of particle is not in surface.')
-        elif feq(normal_comp, 0.0, self.pid_particle_pair[1].radius):
+        elif feq(normal_comp, 0.0, self.pid_particle_pair[1].radius) and not isinstance(self, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell):
             raise testShellError('(testInteractionSingle). Normal component = %g / particle is already in surface.' % normal_comp)
             # If the distance to the reactive surface is zero we want to better use BD, because the
             # zero distance can cause problems with (cylinder) shellmaking and reaction sampling.
+            # We make an exception here for CylindricalSurfacePlanarSurfaceIntermediateSingletestShell,
+            # because here the particle already is "in" the surface by purpose (and a precondition for forming the shell)
 
         self.min_dist_proj_to_edge = abs(dist_to_surface_edge)
         # projection_distance can be negative in case of plane

From 3c52b1d732ecbb231ab06ca9986e1837bfa09656 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 31 Oct 2016 17:05:59 +0100
Subject: [PATCH 1499/1541] Make DiskSurfaceSingle and rod-plane interface
 domains ignore other disks (in addition to ignoring nearby cylinders)

This is still somewhat of a hack, because ideally we want to filter out
the closest cylinders and disks in the overlap checking and for the
ignore lists.
---
 egfrd.py  | 12 ++++++++----
 shells.py |  6 +++++-
 2 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8905f127..0cdc3e99 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3158,15 +3158,19 @@ def check_domain(self, domain):
             associated = []
 
         elif isinstance(domain, DiskSurfaceSingle):
-            # Particles bound to DiskSurfaces ignore all rods for now.
-            ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
+            # Particles bound to DiskSurfaces ignore all rods and other disks for now.
+            ignores_cyl = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
+            ignores_dsk = [s.id for s in self.world.structures if isinstance(s, DiskSurface)] # TODO Only ignore closest disks
+            ignores = ignores_cyl + ignores_dsk
             associated = [domain.structure.id, domain.structure.structure_id] # the latter is the ID of the parent structure
 
         elif isinstance(domain, CylindricalSurfacePlanarSurfaceIntermediateSingle) or isinstance(domain, MixedPair1DStatic) \
           or isinstance(domain, PlanarSurfaceDiskSurfaceInteraction):
-            # Ignore the planar surface and sub-disk that holds/will hold the particle, and the neighboring cylinder
+            # Ignore the planar surface and sub-disk that holds/will hold the particle, and the neighboring cylinder PLUS its disks
             # Note that the plane is the parent structure of the disk, which in both cases is the target structure
-            ignores = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
+            ignores_cyl = [s.id for s in self.world.structures if isinstance(s, CylindricalSurface)] # TODO Only ignore closest cylinder
+            ignores_dsk = [s.id for s in self.world.structures if isinstance(s, DiskSurface)] # TODO Only ignore closest disks
+            ignores = ignores_cyl + ignores_dsk
             associated = [domain.origin_structure.id, domain.target_structure.id, domain.target_structure.structure_id]
                                                                                   # the latter is the ID of the parent structure
 
diff --git a/shells.py b/shells.py
index ae8f36d0..adc93669 100755
--- a/shells.py
+++ b/shells.py
@@ -2929,6 +2929,10 @@ def set_structure_ignore_list(self):
                     get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
         except:
             raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) get_closest_structure() failed, could not determine closest cylinder.')
+          
+        # We also want to ignore possible other disk structures that are substructures of the cylinder
+        # No 'try' here, because there simply may be no such
+        closest_cyl_disk, closest_cyl_disk_dist = get_closest_structure(self.world, search_pos, closest_cyl.id, [], structure_class=DiskSurface)
                     
 
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
@@ -2937,7 +2941,7 @@ def set_structure_ignore_list(self):
               raise testShellError('(CylindricalSurfacePlanarSurfaceIntermediateSingle) Disk is not below closest cylinder, distance to axis = %s' \
                                                                                                                 % disk_to_cylinder_axis_distance)
         if closest_cyl is not None:
-            ignore_list = [self.target_structure.id, closest_cyl.id]
+            ignore_list = [self.target_structure.id, closest_cyl.id, closest_cyl_disk.id]
         else:
             ignore_list = [self.target_structure.id]
         

From b0c4305e79585cf20b05bab535ac5f4ee8144ffe Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 31 Oct 2016 17:53:20 +0100
Subject: [PATCH 1500/1541] More fixes to ignore other disks when forming
 cyl./plane interface domains

---
 shells.py | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/shells.py b/shells.py
index adc93669..598a55d8 100755
--- a/shells.py
+++ b/shells.py
@@ -44,6 +44,7 @@
     'PlanarSurfacePairtestShell',
     'PlanarSurfaceTransitionSingletestShell',
     'PlanarSurfaceTransitionPairtestShell',
+    #'PlanarSurfaceCylindricalSurfaceInteractiontestShell',
     'PlanarSurfaceDiskSurfaceInteractiontestShell',
     'CylindricalSurfaceSingletestShell',
     'DiskSurfaceSingletestShell',
@@ -2614,7 +2615,7 @@ def apply_safety(self, r, z_right, z_left):
     def set_structure_ignore_list(self):
 
         return [self.target_structure.id]
-
+        
 class PlanarSurfaceDiskSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
 
     # This class is in essence the same as CylindricalSurfaceInteractiontestShell, but with
@@ -2797,7 +2798,8 @@ class CylindricalSurfacePlanarSurfaceInteractionSingletestShell(CylindricalSurfa
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
         # This is essentially the same as CylindricalSurfaceDiskInteractiontestShell, only that
-        # the orientation vector has to be calculated in a different way.
+        # the orientation vector has to be calculated in a different way, and the structure ignore list
+        # also contains possible subdisks of the origin cylinder, located at the interface
         
         assert isinstance(target_structure, PlanarSurface)
         assert isinstance(self.origin_structure, CylindricalSurface)
@@ -2861,6 +2863,19 @@ def find_daughter_disk(self):
 
         else:
             raise testShellError('Could not find correct disk surface at the interface between cylinder and plane.')
+          
+    def set_structure_ignore_list(self):
+
+        # This checks whether there is also a sub-disk of the origin structure (cylinder) nearby
+        # If yes, we want to ignore these as well, because then they are part of the (double-sided) interface
+        search_pos = self.pid_particle_pair[1].position
+        other_disk, other_disk_dist = \
+                    get_closest_structure(self.world, search_pos, self.origin_structure.id, [], structure_class=DiskSurface)
+                    
+        if other_disk is not None:
+          return [self.target_structure.id, other_disk.id]
+        else:
+          return [self.target_structure.id]
 
 class CylindricalSurfacePlanarSurfaceIntermediateSingletestShell(CylindricalSurfaceDiskInteractiontestShell):
 

From 3518501e1640b3888651e80c19f11c09bcb5ee7f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 31 Oct 2016 17:54:40 +0100
Subject: [PATCH 1501/1541] Stub for a
 PlanarSurfaceCylindricalSurfaceInteraction test shell

---
 shells.py | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 598a55d8..2b338bf9 100755
--- a/shells.py
+++ b/shells.py
@@ -44,7 +44,7 @@
     'PlanarSurfacePairtestShell',
     'PlanarSurfaceTransitionSingletestShell',
     'PlanarSurfaceTransitionPairtestShell',
-    #'PlanarSurfaceCylindricalSurfaceInteractiontestShell',
+    'PlanarSurfaceCylindricalSurfaceInteractiontestShell',
     'PlanarSurfaceDiskSurfaceInteractiontestShell',
     'CylindricalSurfaceSingletestShell',
     'DiskSurfaceSingletestShell',
@@ -2615,6 +2615,20 @@ def apply_safety(self, r, z_right, z_left):
     def set_structure_ignore_list(self):
 
         return [self.target_structure.id]
+
+class PlanarSurfaceCylindricalSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
+
+    # A special case of CylindricalSurfaceInteractiontestShell in which the origin structure is a plane
+    # Here we allow for a different ignore list which ignores any disk surfaces
+    # Apart from that it is the same as the mother class
+    def __init__(self, single, target_structure, geometrycontainer, domains):
+        CylindricalSurfaceInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
+        
+        assert( isinstance(self.origin_structure, PlanarSurface) )
+    
+    def set_structure_ignore_list(self):
+
+        return [self.target_structure.id] ### TODO adapt!
         
 class PlanarSurfaceDiskSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
 

From 6765d9423af82bcc03d9647d781dd22670d0c904 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 31 Oct 2016 18:36:19 +0100
Subject: [PATCH 1502/1541] Continue PlanarSurfaceCyl.SurfaceInteraction test
 shell

---
 shells.py | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 2b338bf9..aaca5903 100755
--- a/shells.py
+++ b/shells.py
@@ -2628,8 +2628,22 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
     
     def set_structure_ignore_list(self):
 
-        return [self.target_structure.id] ### TODO adapt!
+        # This checks whether there is also a sub-disk of the origin structure (plane) or the target structure (cylinder) nearby
+        # If yes, we want to ignore these as well, because then they are part of the (double-sided) interface
+        search_pos = self.pid_particle_pair[1].position
+        plane_disk, plane_disk_dist = \
+                    get_closest_structure(self.world, search_pos, self.origin_structure.id, [], structure_class=DiskSurface)
+        cyl_disk, cyl_disk_dist = \
+                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
         
+        nearby_disk_list = []
+        if plane_disk is not None:
+          nearby_disk_list = nearby_disk_list + [plane_disk]
+        if cyl_disk is not None:
+          nearby_disk_list = nearby_disk_list + [cyl_disk]
+          
+        return [self.target_structure.id] + nearby_disk_list
+                
 class PlanarSurfaceDiskSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
 
     # This class is in essence the same as CylindricalSurfaceInteractiontestShell, but with

From 37e330bd60b33e7854893706d6faf0efcde71f3b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 2 Nov 2016 14:54:13 +0100
Subject: [PATCH 1503/1541] Some consistent renaming and useful comments for
 CylindricalSurfacePlanarSurfaceInteraction

The name 'CylindricalSurfacePlanarSurfaceInteractionSingle' did not parallel
the other names in the naming convention.
---
 egfrd.py  | 12 ++++++------
 shells.py | 31 +++++++++++++++++--------------
 single.py |  6 +++---
 3 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 0cdc3e99..ffbac3e6 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -58,7 +58,7 @@
     PlanarSurfaceDiskSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceDiskInteractiontestShell,
-    CylindricalSurfacePlanarSurfaceInteractionSingletestShell,
+    CylindricalSurfacePlanarSurfaceInteractiontestShell,
     CylindricalSurfacePlanarSurfaceIntermediateSingletestShell,
     CylindricalSurfacePlanarSurfaceInterfaceSingletestShell,
     CylindricalSurfaceSinktestShell,
@@ -135,7 +135,7 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
                       log.warn('Could not make CylindricalSurfaceSinktestShell, %s; now trying CylindricalSurfaceDiskInteractiontestShell.' % str(e))
                 return CylindricalSurfaceDiskInteractiontestShell (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, PlanarSurface):
-            return CylindricalSurfacePlanarSurfaceInteractionSingletestShell (single, target_structure, geometrycontainer, domains)
+            return CylindricalSurfacePlanarSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported')
     else:
@@ -148,8 +148,8 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction    (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
-        return CylindricalSurfacePlanarSurfaceInteractionSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
+        return CylindricalSurfacePlanarSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell): # this is actually not a "real" interaction, but we need to put it here to ignore the target structure
         return CylindricalSurfacePlanarSurfaceIntermediateSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceDiskInteractiontestShell):
@@ -660,7 +660,7 @@ def create_transition(self, testShell):
     # We assume here that the testShell was successfully created.
 
         assert isinstance(testShell, PlanarSurfaceTransitionSingletestShell) or \
-               isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell)
+               isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell)
                # TODO should be generalized
 
         # 1. generate identifiers for the domain and shell. event_id is generated by
@@ -3174,7 +3174,7 @@ def check_domain(self, domain):
             associated = [domain.origin_structure.id, domain.target_structure.id, domain.target_structure.structure_id]
                                                                                   # the latter is the ID of the parent structure
 
-        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteractionSingle):
+        elif isinstance(domain, CylindricalSurfaceInteraction) or isinstance(domain, CylindricalSurfacePlanarSurfaceInteraction):
             # Ignore surface of the particle and interaction surface and all DiskSurfaces for now.
             ignores = [s.id for s in self.world.structures if isinstance(s, DiskSurface)] # TODO Only ignore closest disk
             associated = [domain.origin_structure.id, domain.target_structure.id]
diff --git a/shells.py b/shells.py
index aaca5903..52beeb4f 100755
--- a/shells.py
+++ b/shells.py
@@ -52,7 +52,7 @@
     'PlanarSurfaceInteractiontestShell',
     'CylindricalSurfaceInteractiontestShell',
     'CylindricalSurfaceDiskInteractiontestShell',
-    'CylindricalSurfacePlanarSurfaceInteractionSingletestShell',
+    'CylindricalSurfacePlanarSurfaceInteractiontestShell',
     'CylindricalSurfacePlanarSurfaceIntermediateSingletestShell',
     'CylindricalSurfacePlanarSurfaceInterfaceSingletestShell',
     'CylindricalSurfaceSinktestShell',
@@ -2384,8 +2384,8 @@ def __init__(self, pid_particle_pair, structure, geometrycontainer, domains):
     def set_structure_ignore_list(self):
 
         # In this special domain we want to ignore the (disk) target structure and the cylinder that
-        # is closest to it. Since we assume that the disk is capping the closest cylinder we double-check
-        # here whether this is actually the case.
+        # is closest to it. Since we assume that the disk is capping the closest cylinder, 
+        # we double-check here whether this is actually the case.
         disk_pos    = self.structure.shape.position
         disk_radius = self.structure.shape.radius
         search_pos  = disk_pos
@@ -2620,7 +2620,7 @@ class PlanarSurfaceCylindricalSurfaceInteractiontestShell(CylindricalSurfaceInte
 
     # A special case of CylindricalSurfaceInteractiontestShell in which the origin structure is a plane
     # Here we allow for a different ignore list which ignores any disk surfaces
-    # Apart from that it is the same as the mother class
+    # Apart from that, it is the same as the mother class
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricalSurfaceInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
         
@@ -2821,7 +2821,7 @@ def set_structure_ignore_list(self):
 
         return [self.target_structure.id]
 
-class CylindricalSurfacePlanarSurfaceInteractionSingletestShell(CylindricalSurfaceDiskInteractiontestShell):
+class CylindricalSurfacePlanarSurfaceInteractiontestShell(CylindricalSurfaceDiskInteractiontestShell):
 
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
@@ -2836,7 +2836,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
             self.daughter_disk = self.find_daughter_disk()
 
         except testShellError as e:
-            raise testShellError('(CylindricalSurfacePlanarSurfaceInteractionSingle) %s' % (str(e)) )
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInteraction) %s' % (str(e)) )
 
     def get_orientation_vector(self):
         # The orientation vector is the (normalized) difference vector pointing from
@@ -2847,16 +2847,19 @@ def get_orientation_vector(self):
 
     def find_daughter_disk(self):
 
-        # Determine the distance to the closest disk
-        # First get the closest disk, then check whether it is actually at the interface between plane and cylinder.
+        # Determine the distance to the daughter disk of the planar surface
+        # First get the closest disk, then check whether it is actually at the interface between plane and cylinder,
+        # and whether the plane (target structure) is its parent structure
         search_pos      = self.pid_particle_pair[1].position        
         found_good_disk = False
 
         try:
+            # The following will (should!) find only disks that are visible from the target structure (=plane),
+            # i.e. already is limited to daughter disks of the plane
             closest_disk, closest_disk_dist = \
                     get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
         except:
-            raise testShellError('(CylindricalSurfacePlanarSurfaceInteractionSingle) get_closest_structure() failed, could not determine closest disk.')
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInteraction) get_closest_structure() failed, could not determine plane-associated disk.')
 
         if closest_disk is not None:
                                     
@@ -2871,26 +2874,26 @@ def find_daughter_disk(self):
 
                 found_good_disk = False
                 if __debug__:
-                    log.warn('(CylindricalSurfacePlanarSurfaceInteractionSingle) Disk surface does not have target plane as parent structure.')
+                    log.warn('(CylindricalSurfacePlanarSurfaceInteraction) Disk surface does not have target plane as parent structure.')
 
             if not feq(distance_from_plane, 0.0, typical = closest_disk.shape.radius):
 
                 found_good_disk = False
                 if __debug__:
-                    log.warn('(CylindricalSurfacePlanarSurfaceInteractionSingle) Disk surface is not situated in target plane.')
+                    log.warn('(CylindricalSurfacePlanarSurfaceInteraction) Disk surface is not situated in target plane.')
 
             if not feq(distance_from_cylinder_axis, 0.0, typical = self.origin_structure.shape.radius):
 
                 found_good_disk = False
                 if __debug__:
-                    log.warn('(CylindricalSurfacePlanarSurfaceInteractionSingle) Disk surface is not situated below cylinder.')
+                    log.warn('(CylindricalSurfacePlanarSurfaceInteraction) Disk surface is not situated below cylinder.')
 
         # OK, if everything is good, return the disk. If not, we don't make this domain and the plane is an obstacle.
         if found_good_disk:
             return closest_disk
 
         else:
-            raise testShellError('Could not find correct disk surface at the interface between cylinder and plane.')
+            raise testShellError('Could not find correct (plane-associated) disk surface at the interface between cylinder and plane.')
           
     def set_structure_ignore_list(self):
 
@@ -2922,7 +2925,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         # If everything seems OK, we can proceed with creating the test shell
         CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
 
-        # Override the shellsize determined for CylindricalSurfacePlanarSurfaceInteractionSingletestShell
+        # Override the shellsize determined for CylindricalSurfacePlanarSurfaceInteractiontestShell
         # This one has the size of a zero single; the scaling parameters can stay the same, since we are not scaling anyhow
         self.dz_left  = self.get_const_z_left()
         self.dz_right = self.dz_left
diff --git a/single.py b/single.py
index fe0fddbf..656b5ade 100644
--- a/single.py
+++ b/single.py
@@ -32,7 +32,7 @@
     'InteractionSingle',
     'CylindricalSurfaceInteraction',
     'CylindricalSurfaceDiskInteraction',
-    'CylindricalSurfacePlanarSurfaceInteractionSingle',
+    'CylindricalSurfacePlanarSurfaceInteraction',
     'CylindricalSurfacePlanarSurfaceIntermediateSingle',
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
@@ -1242,7 +1242,7 @@ def draw_new_position(self, dt, event_type):
     def __str__(self):
         return 'CylindricalSurfaceDiskInteraction ' + Single.__str__(self)
 
-class CylindricalSurfacePlanarSurfaceInteractionSingle(CylindricalSurfaceDiskInteraction):
+class CylindricalSurfacePlanarSurfaceInteraction(CylindricalSurfaceDiskInteraction):
     """1 Particle inside a (Cylindrical) shell on a CylindricalSurface
        limited by a plane. The plane is a reactive surface to the particle
        and its intersection with the cylinder axis defines the exit point 
@@ -1254,7 +1254,7 @@ class CylindricalSurfacePlanarSurfaceInteractionSingle(CylindricalSurfaceDiskInt
     """
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
-        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractionSingletestShell)
+        assert isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell)
         CylindricalSurfaceDiskInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
         # For now this just does the same as the disk interaction, but the test shells
         # slightly differ and we like to keep things apart and organized.

From e2d5daf489415ac0f7d3b0c7e7cccb9a8e115ca9 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 2 Nov 2016 15:04:26 +0100
Subject: [PATCH 1504/1541] find_daughter_disk() routine in
 PlanarSurfaceCylindricalSurfaceInteractiontestShell

This essentially parallels the corresponding routine in
Cyl.SurfacePlanarSurfaceInteractiontestShell
---
 shells.py | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 58 insertions(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 52beeb4f..28234fbe 100755
--- a/shells.py
+++ b/shells.py
@@ -2625,7 +2625,64 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricalSurfaceInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
         
         assert( isinstance(self.origin_structure, PlanarSurface) )
-    
+        assert( isinstance(self.target_structure, CylindricalSurface) )
+        
+        try:
+            self.daughter_disk = self.find_daughter_disk()
+
+        except testShellError as e:
+            raise testShellError('(CylindricalSurfacePlanarSurfaceInteraction) %s' % (str(e)) )
+
+    def find_daughter_disk(self):
+
+        # Determine the distance to the daughter disk of the cylindrical surface
+        # First get the closest disk, then check whether it is actually at the interface between plane and cylinder,
+        # and whether the plane (target structure) is its parent structure
+        search_pos      = self.pid_particle_pair[1].position        
+        found_good_disk = False
+
+        try:
+            # The following will (should!) find only disks that are visible from the target structure (=cylinder),
+            # i.e. already is limited to daughter disks of the cylinder
+            closest_disk, closest_disk_dist = \
+                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+        except:
+            raise testShellError('(PlanarSurfaceCylindricalSurfaceInteraction) get_closest_structure() failed, could not determine plane-associated disk.')
+
+        if closest_disk is not None:
+                                    
+            disk_parent_structure       = self.world.get_structure(closest_disk.structure_id)
+            distance_from_cylinder_axis = self.target_structure.project_point(closest_disk.shape.position)[1][0]
+            distance_from_plane         = self.origin_structure.project_point(closest_disk.shape.position)[1][0]            
+
+            found_good_disk = True
+            
+            # Check whether the disk indeed fulfills all requirements, if not drop warnings.
+            if not disk_parent_structure.id == self.target_structure.id:
+
+                found_good_disk = False
+                if __debug__:
+                    log.warn('(PlanarSurfaceCylindricalSurfaceInteraction) Disk surface does not have target cylinder as parent structure.')            
+
+            if not feq(distance_from_cylinder_axis, 0.0, typical = self.origin_structure.shape.radius):
+
+                found_good_disk = False
+                if __debug__:
+                    log.warn('(PlanarSurfaceCylindricalSurfaceInteraction) Disk surface is not situated in target cylinder.')
+                    
+            if not feq(distance_from_plane, 0.0, typical = closest_disk.shape.radius):
+
+                found_good_disk = False
+                if __debug__:
+                    log.warn('(PlanarSurfaceCylindricalSurfaceInteraction) Disk surface is not situated below target cylinder in the origin plane.')
+
+        # OK, if everything is good, return the disk. If not, we don't make this domain and the plane is an obstacle.
+        if found_good_disk:
+            return closest_disk
+
+        else:
+            raise testShellError('Could not find correct (cylinder-associated) disk surface at the interface between cylinder and plane.')
+          
     def set_structure_ignore_list(self):
 
         # This checks whether there is also a sub-disk of the origin structure (plane) or the target structure (cylinder) nearby

From 2863b2a1b64cebebea80d43569dea1968668e954 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 2 Nov 2016 15:39:40 +0100
Subject: [PATCH 1505/1541] Revise constructor of
 PlanarSurfaceCylindricalSurfaceInteractiontestShell

We should use the same one as previously for the
PlanarSurfaceDiskSurfaceInteractiontestShell
---
 shells.py | 83 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 66 insertions(+), 17 deletions(-)

diff --git a/shells.py b/shells.py
index 28234fbe..3b900886 100755
--- a/shells.py
+++ b/shells.py
@@ -2618,20 +2618,53 @@ def set_structure_ignore_list(self):
 
 class PlanarSurfaceCylindricalSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
 
-    # A special case of CylindricalSurfaceInteractiontestShell in which the origin structure is a plane
+    # This test shell treats the case of a plane-bound particle trying to interact with a cylinder
+    # that has a (disk-) interface with the planar surface.
+    # It is in essence the same as CylindricalSurfaceInteractiontestShell, but with
+    # different shellscaling parameters. Therefore a new constructor has to be defined.
     # Here we allow for a different ignore list which ignores any disk surfaces
-    # Apart from that, it is the same as the mother class
-    def __init__(self, single, target_structure, geometrycontainer, domains):
-        CylindricalSurfaceInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
-        
-        assert( isinstance(self.origin_structure, PlanarSurface) )
+    # The working principle put forward here is akin to (->) CylindricalSurfacePlanarSurfaceInteractiontestShell    
+    def __init__(self, single, target_structure, geometrycontainer, domains):              
         assert( isinstance(self.target_structure, CylindricalSurface) )
-        
+        CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
+        testInteractionSingle.__init__(self, single, single.structure, target_structure)
+
+        if feq(self.particle_surface_distance, 0.0, typical=self.target_structure.shape.radius) \
+           or self.particle_surface_distance < 0.0:
+            raise testShellError('(PlanarSurfaceDiskSurfaceInteractiontestShell). Zero or negative particle-surface distance, value = %s. Particle is most likely already on the disk.' \
+                                                                                  % self.particle_surface_distance                                                                      )
+
+        # Initialize the scaling parameters
+        # These are copied from PlanarSurfacePairtestShell
+        self.dzdr_right = 0.0
+        self.drdz_right = numpy.inf
+        self.r0_right   = 0.0
+        self.z0_right   = self.pid_particle_pair[1].radius
+        self.dzdr_left  = 0.0
+        self.drdz_left  = numpy.inf
+        self.r0_left    = 0.0
+        self.z0_left    = self.z0_right
+
+        # Now we can also define the scaling angle
+        self.right_scalingangle = self.get_right_scalingangle()
+        self.left_scalingangle  = self.get_left_scalingangle()
+        # In particular store the tangent, because math.tan is expensive!
+        self.tan_right_scalingangle = math.tan(self.right_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+
+        # This will determine if the shell is possible.
+        # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
+        # If not possible, it throws an exception and the construction of the testShell IS ABORTED!        
+        self.ignored_structure_ids = self.set_structure_ignore_list()
         try:
+            # First we check whether the cylinder that we try to interact with actually has an interface disk
             self.daughter_disk = self.find_daughter_disk()
-
-        except testShellError as e:
-            raise testShellError('(CylindricalSurfacePlanarSurfaceInteraction) %s' % (str(e)) )
+          
+            self.dr, self.dz_right, self.dz_left = \
+                            self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], \
+                                                                                    self.ignored_structure_ids)
+        except ShellmakingError as e:
+            raise testShellError('(PlanarSurfaceDiskSurfaceInteraction). %s' % (str(e)) )                                     
 
     def find_daughter_disk(self):
 
@@ -2682,7 +2715,22 @@ def find_daughter_disk(self):
 
         else:
             raise testShellError('Could not find correct (cylinder-associated) disk surface at the interface between cylinder and plane.')
-          
+
+    def get_min_dr_dzright_dzleft(self):        
+        dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + (self.particle_surface_distance + self.target_structure.shape.radius)
+        dz_right = self.pid_particle_pair[1].radius
+        dz_left  = dz_right
+        return dr, dz_right, dz_left
+
+    def get_max_dr_dzright_dzleft(self): # same as for PlanarSurfaceSingletestShell
+        dz_right = self.pid_particle_pair[1].radius
+        dz_left  = dz_right
+        dr_sr    = math.sqrt((self.get_searchradius())**2 - dz_right**2) # stay within the searchradius
+#        dr_edge  = self.structure.min_dist_proj_to_edge(self.get_referencepoint()) # TODO rethink this
+#        dr       = min(dr_sr, dr_edge)
+        dr = dr_sr
+        return dr, dz_right, dz_left
+        
     def set_structure_ignore_list(self):
 
         # This checks whether there is also a sub-disk of the origin structure (plane) or the target structure (cylinder) nearby
@@ -2700,7 +2748,7 @@ def set_structure_ignore_list(self):
           nearby_disk_list = nearby_disk_list + [cyl_disk]
           
         return [self.target_structure.id] + nearby_disk_list
-                
+        
 class PlanarSurfaceDiskSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
 
     # This class is in essence the same as CylindricalSurfaceInteractiontestShell, but with
@@ -2772,7 +2820,7 @@ def set_structure_ignore_list(self):
             closest_cyl, closest_cyl_dist = \
                     get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=CylindricalSurface)
         except:
-            raise testShellError('(PlanarSurfaceDiskSurfaceInteractionSingle) get_closest_structure() failed, could not determine closest cylinder.')
+            raise testShellError('(PlanarSurfaceDiskSurfaceInteraction) get_closest_structure() failed, could not determine closest cylinder.')
 
         disk_to_cylinder_axis_distance = closest_cyl.project_point(disk_pos)[1][0]
         if not feq(disk_to_cylinder_axis_distance, 0.0, typical=disk_radius):
@@ -2880,11 +2928,12 @@ def set_structure_ignore_list(self):
 
 class CylindricalSurfacePlanarSurfaceInteractiontestShell(CylindricalSurfaceDiskInteractiontestShell):
 
+    # This is essentially the same as CylindricalSurfaceDiskInteractiontestShell, only that
+    # the orientation vector has to be calculated in a different way, and the structure ignore list
+    # also contains possible subdisks of the origin cylinder, located at the interface
+    # The working principle put forward here is akin to (->) PlanarSurfaceCylindricalSurfaceInteractiontestShell
     def __init__(self, single, target_structure, geometrycontainer, domains):
-        CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)
-        # This is essentially the same as CylindricalSurfaceDiskInteractiontestShell, only that
-        # the orientation vector has to be calculated in a different way, and the structure ignore list
-        # also contains possible subdisks of the origin cylinder, located at the interface
+        CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)        
         
         assert isinstance(target_structure, PlanarSurface)
         assert isinstance(self.origin_structure, CylindricalSurface)

From 85a83ea0999fe432e3714afbb8848b9cacd2a035 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 2 Nov 2016 18:01:08 +0100
Subject: [PATCH 1506/1541] Some fixes to shellscaling routines and ignore list
 in PlanarSurfaceCylindricalSurfaceInteractiontestShell

In particular, we have to use the structure IDs, not
the structures themselves in the ignore list!
---
 shells.py | 48 ++++++++++++++++++++++++++++++------------------
 1 file changed, 30 insertions(+), 18 deletions(-)

diff --git a/shells.py b/shells.py
index 3b900886..78868e54 100755
--- a/shells.py
+++ b/shells.py
@@ -195,8 +195,8 @@ def __init__(self, single, origin_structure, target_structure):
         pos_transposed = self.world.cyclic_transpose(self.pid_particle_pair[1].position,
                                                      self.target_structure.shape.position)
         self.reference_point, (normal_comp, dist_to_surface_edge) = self.target_structure.project_point(pos_transposed)
-        if dist_to_surface_edge >= 0:
-            raise testShellError('(testInteractionSingle). Projected point of particle is not in surface.')
+        if not( dist_to_surface_edge < 0 or feq(dist_to_surface_edge, 0.0, self.pid_particle_pair[1].radius) ):
+            raise testShellError('(testInteractionSingle). Projected point of particle is not in surface (dist. to surf. edge = %g).' % dist_to_surface_edge)
         elif feq(normal_comp, 0.0, self.pid_particle_pair[1].radius) and not isinstance(self, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell):
             raise testShellError('(testInteractionSingle). Normal component = %g / particle is already in surface.' % normal_comp)
             # If the distance to the reactive surface is zero we want to better use BD, because the
@@ -922,7 +922,7 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
     relative_orientation = abs(numpy.dot(orientation_vector, shape.unit_z))
 
     if feq(relative_orientation, 1.0):
-    #### If the cylinders are parallel ####
+    #### If the cylinders are parallel ####    
 
         # calculate ref_to_shell_r/z in the cylindrical coordinate system on the right/left side
         ref_to_shell_z_vec = ref_to_shell_z * orientation_vector
@@ -947,8 +947,8 @@ def get_dr_dzright_dzleft_to_CylindricalShape(shape, testShell, r, z_right, z_le
             z1_new = min(z1, (ref_to_shell_z - shell_half_length))
             r_new  = min(r,  r1_function(z1_new))           # TODO if z1 hasn't changed we also don't have to recalculate this
         else:
-            # shell hits the scaling cylinder on the radial side
-            r_new = min(r, (ref_to_shell_r - shell_radius))
+            # shell hits the scaling cylinder on the radial side            
+            r_new = min(r, (ref_to_shell_r - shell_radius))            
             z1_new = min(z1, z1_function(r_new))
 
     elif feq(relative_orientation, 0):
@@ -1866,6 +1866,7 @@ def determine_possible_shell(self, base_structure_id, ignore, ignores):
         # or planar surfaces and parallel to the testCylinder axis
         for surface, distance in neighbor_surfaces:
             # TODO
+            log.info('Scaling cylindrical test shell with respect to %s.' % surface)
             if isinstance(surface, SphericalSurface):
                 dr, dz_right, dz_left = get_dr_dzright_dzleft_to_SphericalShape(surface.shape, self, dr, dz_right, dz_left)
             elif isinstance(surface, CylindricalSurface):
@@ -2620,12 +2621,12 @@ class PlanarSurfaceCylindricalSurfaceInteractiontestShell(CylindricalSurfaceInte
 
     # This test shell treats the case of a plane-bound particle trying to interact with a cylinder
     # that has a (disk-) interface with the planar surface.
-    # It is in essence the same as CylindricalSurfaceInteractiontestShell, but with
-    # different shellscaling parameters. Therefore a new constructor has to be defined.
+    # It is in essence the same as CylindricalSurfaceInteractiontestShell, but with different
+    # shellscaling parameters (akin to PlanarSurfacePair). Therefore a new constructor has to be defined.
     # Here we allow for a different ignore list which ignores any disk surfaces
     # The working principle put forward here is akin to (->) CylindricalSurfacePlanarSurfaceInteractiontestShell    
     def __init__(self, single, target_structure, geometrycontainer, domains):              
-        assert( isinstance(self.target_structure, CylindricalSurface) )
+        assert( isinstance(target_structure, CylindricalSurface) )
         CylindricaltestShell.__init__(self, geometrycontainer, domains)  # this must be first because of world definition
         testInteractionSingle.__init__(self, single, single.structure, target_structure)
 
@@ -2643,14 +2644,14 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.dzdr_left  = 0.0
         self.drdz_left  = numpy.inf
         self.r0_left    = 0.0
-        self.z0_left    = self.z0_right
+        self.z0_left    = self.z0_right                
 
         # Now we can also define the scaling angle
         self.right_scalingangle = self.get_right_scalingangle()
         self.left_scalingangle  = self.get_left_scalingangle()
         # In particular store the tangent, because math.tan is expensive!
         self.tan_right_scalingangle = math.tan(self.right_scalingangle)
-        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)
+        self.tan_left_scalingangle  = math.tan(self.left_scalingangle)        
 
         # This will determine if the shell is possible.
         # If possible, it will write the dr, dz_right, dz_left defining the dimensions of the cylindrical shell.
@@ -2664,13 +2665,23 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
                             self.determine_possible_shell(self.origin_structure.id, [self.single.domain_id], \
                                                                                     self.ignored_structure_ids)
         except ShellmakingError as e:
-            raise testShellError('(PlanarSurfaceDiskSurfaceInteraction). %s' % (str(e)) )                                     
+            raise testShellError('(PlanarSurfaceCylindricalSurfaceInteraction). %s' % (str(e)) )                                     
+
+    def get_orientation_vector(self):
+        return self.structure.shape.unit_z
 
+    def get_searchpoint(self):
+        return self.daughter_disk.shape.position
+
+    def get_referencepoint(self):
+        return self.daughter_disk.shape.position
+        
     def find_daughter_disk(self):
 
         # Determine the distance to the daughter disk of the cylindrical surface
         # First get the closest disk, then check whether it is actually at the interface between plane and cylinder,
-        # and whether the plane (target structure) is its parent structure
+        # and whether the cylinder (target structure) is its parent structure
+        # TODO: We may want to drop this requirement; it is actually not needed for direct transfers onto the cylinders
         search_pos      = self.pid_particle_pair[1].position        
         found_good_disk = False
 
@@ -2697,7 +2708,7 @@ def find_daughter_disk(self):
                 if __debug__:
                     log.warn('(PlanarSurfaceCylindricalSurfaceInteraction) Disk surface does not have target cylinder as parent structure.')            
 
-            if not feq(distance_from_cylinder_axis, 0.0, typical = self.origin_structure.shape.radius):
+            if not feq(distance_from_cylinder_axis, 0.0, typical = self.target_structure.shape.radius):
 
                 found_good_disk = False
                 if __debug__:
@@ -2709,8 +2720,9 @@ def find_daughter_disk(self):
                 if __debug__:
                     log.warn('(PlanarSurfaceCylindricalSurfaceInteraction) Disk surface is not situated below target cylinder in the origin plane.')
 
-        # OK, if everything is good, return the disk. If not, we don't make this domain and the plane is an obstacle.
+        # OK, if everything is good, return the disk. If not, we don't make this domain and the cylinder is an obstacle.
         if found_good_disk:
+            log.warn('(PlanarSurfaceCylindricalSurfaceInteraction) Found proper daughter disk.')
             return closest_disk
 
         else:
@@ -2741,13 +2753,13 @@ def set_structure_ignore_list(self):
         cyl_disk, cyl_disk_dist = \
                     get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
         
-        nearby_disk_list = []
+        nearby_disk_id_list = []
         if plane_disk is not None:
-          nearby_disk_list = nearby_disk_list + [plane_disk]
+          nearby_disk_id_list = nearby_disk_id_list + [plane_disk.id]
         if cyl_disk is not None:
-          nearby_disk_list = nearby_disk_list + [cyl_disk]
+          nearby_disk_id_list = nearby_disk_id_list + [cyl_disk.id]          
           
-        return [self.target_structure.id] + nearby_disk_list
+        return [self.target_structure.id] + nearby_disk_id_list
         
 class PlanarSurfaceDiskSurfaceInteractiontestShell(CylindricalSurfaceInteractiontestShell):
 

From 10b0c47435a0f8c3d943c710fda82ad6a087d2bc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 2 Nov 2016 18:08:06 +0100
Subject: [PATCH 1507/1541] Make the main routine use the new test shell and
 domain (PlanarSurfaceCylindricalSurfaceInteraction...)

This now seems to work for direct transitions between
plane and cylinder (i.e., not yet involving any "interface" disks)
---
 egfrd.py | 46 ++++++++++++++++++++++++++--------------------
 1 file changed, 26 insertions(+), 20 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ffbac3e6..fcb8f596 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -56,6 +56,7 @@
     DiskSurfaceSingletestShell,
     PlanarSurfaceInteractiontestShell,
     PlanarSurfaceDiskSurfaceInteractiontestShell,
+    PlanarSurfaceCylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceInteractiontestShell,
     CylindricalSurfaceDiskInteractiontestShell,
     CylindricalSurfacePlanarSurfaceInteractiontestShell,
@@ -79,20 +80,22 @@
 ### Singles
 def create_default_single(domain_id, shell_id, pid_particle_pair, structure, reaction_rules, geometrycontainer, domains):
     if isinstance(structure, CuboidalRegion):
-        # first make the test shell
+        # First make the test shell
         testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return SphericalSingle          (domain_id, shell_id, testSingle, reaction_rules)
     elif isinstance(structure, PlanarSurface):
-        # first make the test shell
+        # First make the test shell
         testSingle = PlanarSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return PlanarSurfaceSingle      (domain_id, shell_id, testSingle, reaction_rules)
     elif isinstance(structure, CylindricalSurface):
-        # first make the test shell
+        # First make the test shell
         testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
     elif isinstance(structure, DiskSurface):
-        # first make the test shell
+        # First make the test shell        
         try:
+            # Here we first want to try a special case, in which the particle is at the "interface" btw. cylinder and plane
+            # The corresponding test shell is akin to the standard DiskSurfaceSingle, but has an extended ignore list
             testSingle = CylindricalSurfacePlanarSurfaceInterfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         except testShellError as e:
             if __debug__:
@@ -100,20 +103,21 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
             # making the default testShell should never fail
             testSingle = DiskSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
 
-        return DiskSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
+        return DiskSurfaceSingle        (domain_id, shell_id, testSingle, reaction_rules)
 
 ### Interactions
 def try_default_testinteraction(single, target_structure, geometrycontainer, domains):
     if isinstance(single.structure, CuboidalRegion):
         if isinstance(target_structure, PlanarSurface):
-            return PlanarSurfaceInteractiontestShell(single, target_structure, geometrycontainer, domains)
+            return PlanarSurfaceInteractiontestShell      (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, CylindricalSurface):
-            return CylindricalSurfaceInteractiontestShell(single, target_structure, geometrycontainer, domains)
+            return CylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
         else:
             raise testShellError('(Interaction). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
-        if isinstance(target_structure, CylindricalSurface):
-            raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
+        if isinstance(target_structure, CylindricalSurface): ### TESTING ###
+            return PlanarSurfaceCylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
+            #raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
         elif isinstance(target_structure, DiskSurface):
             # Here we have 2 possibilities; first we try the less probable one (special conditions apply that are checked
             # upon test shell construction), then the more common one.
@@ -122,18 +126,18 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
             except testShellError as e:
                 if __debug__:
                     log.warn('Could not make CylindricalSurfacePlanarSurfaceIntermediateSingletestShell, %s; now trying PlanarSurfaceDiskSurfaceInteractiontestShell.' % str(e))
-                return PlanarSurfaceDiskSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
+                return PlanarSurfaceDiskSurfaceInteractiontestShell               (single, target_structure, geometrycontainer, domains)
                 # if both shells do not work in this situation the second try will result in raising another shellmaking exception       
         else:
             raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
         if isinstance(target_structure, DiskSurface):
             try:
-                return CylindricalSurfaceSinktestShell (single, target_structure, geometrycontainer, domains)
+                return CylindricalSurfaceSinktestShell                 (single, target_structure, geometrycontainer, domains)
             except testShellError as e:
                 if __debug__:
                       log.warn('Could not make CylindricalSurfaceSinktestShell, %s; now trying CylindricalSurfaceDiskInteractiontestShell.' % str(e))
-                return CylindricalSurfaceDiskInteractiontestShell (single, target_structure, geometrycontainer, domains)
+                return CylindricalSurfaceDiskInteractiontestShell      (single, target_structure, geometrycontainer, domains)
         elif isinstance(target_structure, PlanarSurface):
             return CylindricalSurfacePlanarSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
         else:
@@ -142,20 +146,22 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
         raise testShellError('(Interaction). structure of particle was of invalid type')
 
 def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, interaction_rules):
-    if isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceInteractiontestShell
-        return PlanarSurfaceDiskSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    if isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell): # must be first because it is a special case of PlanarSurfaceDiskSurfaceInteractiontestShell below
+        return PlanarSurfaceCylindricalSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+    if isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceInteractiontestShell below
+        return PlanarSurfaceDiskSurfaceInteraction        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceInteractiontestShell):
-        return CylindricalSurfaceInteraction    (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return CylindricalSurfaceInteraction              (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
-        return PlanarSurfaceInteraction         (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return PlanarSurfaceInteraction                   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
-        return CylindricalSurfacePlanarSurfaceInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return CylindricalSurfacePlanarSurfaceInteraction        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell): # this is actually not a "real" interaction, but we need to put it here to ignore the target structure
         return CylindricalSurfacePlanarSurfaceIntermediateSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceDiskInteractiontestShell):
-        return CylindricalSurfaceDiskInteraction (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return CylindricalSurfaceDiskInteraction                 (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfaceSinktestShell): # FIXME not sure we ever construct this; we have to give it priority over Cyl.Surf.DiskInteraction for non-capping disks!
-        return CylindricalSurfaceSink           (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
+        return CylindricalSurfaceSink                            (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
 
 ### Transitions
 def try_default_testtransition(single, target_structure, geometrycontainer, domains):
@@ -173,7 +179,7 @@ def try_default_testtransition(single, target_structure, geometrycontainer, doma
 
 def create_default_transition(domain_id, shell_id, testShell, reaction_rules):
     if isinstance(testShell, PlanarSurfaceTransitionSingletestShell):
-        return PlanarSurfaceTransitionSingle                   (domain_id, shell_id, testShell, reaction_rules)
+        return PlanarSurfaceTransitionSingle              (domain_id, shell_id, testShell, reaction_rules)
 
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):

From d9ddbfbed8420d5f927318afe7b38192726bff1b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 2 Nov 2016 18:29:57 +0100
Subject: [PATCH 1508/1541] Preliminary version of
 PlanarSurfaceCylindricalSurfaceInteraction domain

This one still derives directly from PlanarSurfaceDiskSurfaceInteraction,
we want to make this more pretty at some point...
---
 single.py | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/single.py b/single.py
index 656b5ade..105147e3 100644
--- a/single.py
+++ b/single.py
@@ -37,6 +37,7 @@
     'CylindricalSurfaceSink',
     'PlanarSurfaceInteraction',
     'PlanarSurfaceDiskSurfaceInteraction',
+    'PlanarSurfaceCylindricalSurfaceInteraction',
     'TransitionSingle',
     'PlanarSurfaceTransitionSingle',
     ]
@@ -984,7 +985,8 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # This domain is basically equivalent to CylindricalSurfaceInteraction. It uses
         # the same Green's function for binding, but the particle's z-coordinate does not
         # change here. Thus we have to modify draw_new_position() accordingly.
-        assert isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell)
+        assert isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell) \
+            or isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell)
         # Initialize the parent class. This should be fine since the test shell also has
         # CylindricalSurfaceInteractiontestShell as a parent class.
         CylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
@@ -1045,6 +1047,17 @@ def __str__(self):
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))
 
+class PlanarSurfaceCylindricalSurfaceInteraction(PlanarSurfaceDiskSurfaceInteraction):
+      # For now this is just a wrapper around / special case of PlanarSurfaceDiskSurfaceInteraction
+      def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
+        PlanarSurfaceDiskSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+        
+        isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell)
+  
+      def __str__(self):
+        return ('PlanarSurfaceCylindricalSurfaceInteraction' + Single.__str__(self) + \
+               'radius = %s, half_length = %s' %
+                (self.shell.shape.radius, self.shell.shape.half_length))                
 
 class CylindricalSurfaceSink(InteractionSingle):
     """1 Particle inside a (Cylindrical) shell on a CylindricalSurface.

From 544119441c0b8d7e5c8e61c0a4cbb5e9d672a8ad Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 2 Nov 2016 18:38:48 +0100
Subject: [PATCH 1509/1541] Make PlanarSurfaceDiskSurfaceInterface a special
 case of PlanarSurfaceCyl.SurfaceInterface

...and not vice versa.

Since the two domains essentialy only differ by which testShell they require,
we can just exchange them.
---
 single.py | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/single.py b/single.py
index 105147e3..3a5fc9fc 100644
--- a/single.py
+++ b/single.py
@@ -970,9 +970,9 @@ def __str__(self):
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))
 
-class PlanarSurfaceDiskSurfaceInteraction(CylindricalSurfaceInteraction):
-    """1 Particle on a PlanarSurface close to a DiskSurface, 
-       inside a cylindrical shell that surrounds the DiskSurface.
+class PlanarSurfaceCylindricalSurfaceInteraction(CylindricalSurfaceInteraction):
+    """1 Particle on a PlanarSurface close to a CylindricalSurface, 
+       inside a cylindrical shell that surrounds the cap of the CylindricalSurface.
 
         * Particle coordinates inside shell: r, theta, z.
         * Domains: composite r-theta, cartesian z.
@@ -985,13 +985,13 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # This domain is basically equivalent to CylindricalSurfaceInteraction. It uses
         # the same Green's function for binding, but the particle's z-coordinate does not
         # change here. Thus we have to modify draw_new_position() accordingly.
-        assert isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell) \
-            or isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell)
+        assert isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell) \
+            or isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell) # the latter is a special case of this one
         # Initialize the parent class. This should be fine since the test shell also has
         # CylindricalSurfaceInteractiontestShell as a parent class.
         CylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
 
-        self.product_structure = self.target_structure # DEPRECATED rethink this
+        self.product_structure = self.target_structure # DEPRECATED do we actually need this?
 
     def draw_escape_time_tuple(self):
         # This draws the time for escape in z-direction; since the particle in this domain
@@ -1043,19 +1043,21 @@ def draw_new_position(self, dt, event_type):
         return newpos, structure_id
 
     def __str__(self):
-        return ('PlanarSurfaceDiskSurfaceInteraction' + Single.__str__(self) + \
+        return ('PlanarSurfaceCylindricalSurfaceInteraction' + Single.__str__(self) + \
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))
 
-class PlanarSurfaceCylindricalSurfaceInteraction(PlanarSurfaceDiskSurfaceInteraction):
-      # For now this is just a wrapper around / special case of PlanarSurfaceDiskSurfaceInteraction
+class PlanarSurfaceDiskSurfaceInteraction(PlanarSurfaceCylindricalSurfaceInteraction):
+      # This is just a wrapper around / special case of PlanarSurfaceCylindricalSurfaceInteraction,
+      # meaning that we treat the binding to a disk as a special case of binding to a cylinder      
       def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
-        PlanarSurfaceDiskSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
+        PlanarSurfaceCylindricalSurfaceInteraction.__init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules)
         
-        isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell)
+        isinstance(testShell, PlanarSurfaceDiskSurfaceInteractiontestShell)
+        # TODO Maybe some extra checks are still needed here
   
       def __str__(self):
-        return ('PlanarSurfaceCylindricalSurfaceInteraction' + Single.__str__(self) + \
+        return ('PlanarSurfaceDiskSurfaceInteraction' + Single.__str__(self) + \
                'radius = %s, half_length = %s' %
                 (self.shell.shape.radius, self.shell.shape.half_length))                
 

From 465bf6e6b0d69060fe8c1122efbc4902cbfc6a74 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 4 Nov 2016 16:40:49 +0100
Subject: [PATCH 1510/1541] More info output for interactions

In particular, output the total interaction rate.
---
 egfrd.py                   | 13 +++++++------
 greens_function_wrapper.py | 10 +++++-----
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fcb8f596..faff010c 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -1970,8 +1970,8 @@ def make_new_domain(self, single):
 
         pair_interaction_partners = sorted(pair_interaction_partners, key=lambda domain_overlap: domain_overlap[1])
 
-        # For each particles/particle or particle/surface pair, check if a pair or interaction can be
-        # made. Note that we check the closest one first and only check if the object are within the horizon
+        # For each particles/particle or particle/surface pair, check if a pair or interaction can be made
+        # Note that we check the closest one first and only check if the object are within the horizon
         domain = None
         for obj, hor_overlap in pair_interaction_partners:
 
@@ -2148,7 +2148,7 @@ def update_single(self, single):
         single.shell_id_shell_pair = shell_id_shell_pair
         self.geometrycontainer.move_shell(shell_id_shell_pair)
         if __debug__:
-            log.info('        *Updated single: single: %s, new_shell = %s' % \
+            log.info('        * Updated single: single: %s, new_shell = %s' % \
                      (single, str(new_shell)))
 
         single.dt, single.event_type = single.determine_next_event()
@@ -2678,7 +2678,8 @@ def try_interaction(self, single, target_structure):
             # make the domain
             interaction = self.create_interaction(testShell)
             if __debug__:
-                log.info('        *Created: %s' % (interaction))
+                log.info('        * Created: %s' % (interaction))
+                log.info('        * Total interaction rate: k_tot = %g' % interaction.interaction_ktot)
 
             # get the next event time
             interaction.dt, interaction.event_type, = interaction.determine_next_event()
@@ -2727,7 +2728,7 @@ def try_transition(self, single, target_structure):
             # make the domain
             transition = self.create_transition(testShell)
             if __debug__:
-                log.info('        *Created: %s' % (transition))
+                log.info('        * Created: %s' % (transition))
 
             # get the next event time
             transition.dt, transition.event_type, = transition.determine_next_event()
@@ -2778,7 +2779,7 @@ def try_pair(self, single1, single2):
         if testShell:
             pair = self.create_pair(testShell)
             if __debug__:
-                log.info('        *Created: %s' % (pair))
+                log.info('        * Created: %s' % (pair))
 
             pair.dt, pair.event_type, pair.reactingsingle = pair.determine_next_event(pair.r0)
             if __debug__:
diff --git a/greens_function_wrapper.py b/greens_function_wrapper.py
index 772dfab0..ba259ba6 100644
--- a/greens_function_wrapper.py
+++ b/greens_function_wrapper.py
@@ -12,7 +12,7 @@ def draw_time_wrapper(gf):
     rnd = myrandom.uniform()
 
     if __debug__:
-        log.debug('        *drawTime. ' + gf.__class__.__name__)
+        log.debug('        * drawTime: ' + gf.__class__.__name__)
     try:
         dt = gf.drawTime(rnd)
     except Exception, e:
@@ -25,7 +25,7 @@ def draw_event_type_wrapper(gf, dt):
     rnd = myrandom.uniform()
 
     if __debug__:
-        log.debug('        *drawEventType. ' + gf.__class__.__name__)
+        log.debug('        * drawEventType: ' + gf.__class__.__name__)
     try:
         event_type = gf.drawEventType(rnd, dt)
     except Exception, e:
@@ -38,12 +38,12 @@ def draw_r_wrapper(gf, dt, a, sigma=None):
     rnd = myrandom.uniform()
 
     if __debug__:
-        log.debug('        *drawR. ' + gf.__class__.__name__)
+        log.debug('        * drawR: ' + gf.__class__.__name__)
     try:
         r = gf.drawR(rnd, dt)
         while r > a or r <= sigma: # redraw; shouldn't happen often
             if __debug__:
-                log.debug('        *drawR: redraw')
+                log.debug('        * drawR: redraw')
             rnd = myrandom.uniform()
             r = gf.drawR(rnd, dt)
     except Exception, e:
@@ -64,7 +64,7 @@ def draw_theta_wrapper(gf, r, dt):
     rnd = myrandom.uniform()
 
     if __debug__:
-        log.debug('        *drawTheta. ' + gf.__class__.__name__)
+        log.debug('        * drawTheta: ' + gf.__class__.__name__)
     try:
         theta = gf.drawTheta(rnd, r, dt)
     except Exception, e:

From 04e6e412e44f1acb8714f71eacfdab0d0cfd2711 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 4 Nov 2016 18:52:53 +0100
Subject: [PATCH 1511/1541] More informative output during
 interactions/overlaps in newBDpropagator

---
 newBDPropagator.hpp | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index b6c28c98..c08ad501 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -204,6 +204,9 @@ class newBDPropagator
         while(!bounced && j < particles_in_overlap)
             bounced = overlap_particles->at(j++).second < r0;
         
+        if(bounced)
+            LOG_DEBUG( ("particle bounced with another particle.") );
+        
         //// 4.2 CHECK FOR CORE OVERLAPS WITH STRUCTURES
         /* If the particle has not bounced with another particle check for overlap with a surface. */
         boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures;
@@ -214,11 +217,14 @@ class newBDPropagator
             boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_tmp(
                 tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, new_structure_id, r0, old_struct_id));
             overlap_structures.swap(overlap_structures_tmp);
-            structures_in_overlap = (int)(overlap_structures ? overlap_structures->size(): 0);
+            structures_in_overlap = (int)(overlap_structures ? overlap_structures->size(): 0);            
  
             j = 0;
             while(!bounced && j < structures_in_overlap)
                 bounced = overlap_structures->at(j++).second < r0;
+            
+            if(bounced)
+                LOG_DEBUG( ("particle bounced with structure.") );
         }
          
         /*** 5. TREAT BOUNCING => CHECK FOR POTENTIAL REACTIONS / INTERACTIONS ***/
@@ -240,8 +246,8 @@ class newBDPropagator
             overlap_particles.swap( overlap_particles_after_bounce );     // FIXME is there no better way?
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
-            particles_in_overlap = overlap_particles ? overlap_particles->size(): 0; 
-            LOG_DEBUG( ("particles_in_overlap = %g", particles_in_overlap) ); // TESTING
+            particles_in_overlap = (int)(overlap_particles ? overlap_particles->size(): 0); 
+            LOG_DEBUG( ("now particles_in_overlap = %u", particles_in_overlap) ); // TESTING
             
             // re-get the reaction partners (structures), now on old position.
             boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_after_bounce( 
@@ -250,7 +256,7 @@ class newBDPropagator
             // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
             // and surfaces is False!
             structures_in_overlap = (int)(overlap_structures ? overlap_structures->size(): 0);
-            LOG_DEBUG( ("structures_in_overlap = %g", structures_in_overlap) ); // TESTING
+            LOG_DEBUG( ("now structures_in_overlap = %u", structures_in_overlap) ); // TESTING
         }
         
 

From cd56ed2fb99f733a390ff6f3e520b71c9e705639 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 7 Nov 2016 18:03:25 +0100
Subject: [PATCH 1512/1541] Yet more informative debug output in
 newBDpropagator

---
 newBDPropagator.hpp | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index c08ad501..f5c43d58 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -193,16 +193,20 @@ class newBDPropagator
         bool bounced( false );
         // Get all the particles that are in the reaction volume at the new position (and that may consequently also be in the core)
         /* Use a spherical shape with radius = particle_radius + reaction_length.
-	       We use it to check for overlaps with other particles. */
+           Note that at this point this is only a search radius, not a radius that defines volume exclusion;
+           for this, only r0 (instead of r0 + reaction_length_) is used further below.                       */
         boost::scoped_ptr<particle_id_pair_and_distance_list> overlap_particles(
                 tx_.check_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), pp.first));
         int particles_in_overlap(overlap_particles ? overlap_particles->size(): 0);
+        if(particles_in_overlap)
+            LOG_DEBUG( ("%u particles in overlap at new position.", particles_in_overlap) );
 
         //// 4.1 CHECK FOR CORE OVERLAPS WITH PARTICLES
-        /* Check if the particle at new_pos overlaps with any particle cores. */        
+        /* Check if the particle at new_pos overlaps with any particle cores. */
         int j( 0 );
         while(!bounced && j < particles_in_overlap)
             bounced = overlap_particles->at(j++).second < r0;
+                      // use only r0 as an exclusion radius here!
         
         if(bounced)
             LOG_DEBUG( ("particle bounced with another particle.") );
@@ -218,11 +222,15 @@ class newBDPropagator
                 tx_.check_surface_overlap(particle_shape_type( new_pos, r0 + reaction_length_ ), old_pos, new_structure_id, r0, old_struct_id));
             overlap_structures.swap(overlap_structures_tmp);
             structures_in_overlap = (int)(overlap_structures ? overlap_structures->size(): 0);            
- 
+            
+            if(structures_in_overlap)
+                LOG_DEBUG( ("%u structures in overlap at new position.", structures_in_overlap) );
+            
             j = 0;
             while(!bounced && j < structures_in_overlap)
                 bounced = overlap_structures->at(j++).second < r0;
-            
+                          // use only r0 as an exclusion radius here!
+                        
             if(bounced)
                 LOG_DEBUG( ("particle bounced with structure.") );
         }
@@ -244,20 +252,22 @@ class newBDPropagator
             boost::scoped_ptr<particle_id_pair_and_distance_list> overlap_particles_after_bounce( 
                     tx_.check_overlap( particle_shape_type( old_pos, r0 + reaction_length_ ), pp.first) );
             overlap_particles.swap( overlap_particles_after_bounce );     // FIXME is there no better way?
-            // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
-            // and surfaces is False!
+            // NOTE that it is asserted that the particle overlap criterium for the particle with 
+            // other particles and surfaces is False!
             particles_in_overlap = (int)(overlap_particles ? overlap_particles->size(): 0); 
-            LOG_DEBUG( ("now particles_in_overlap = %u", particles_in_overlap) ); // TESTING
+            LOG_DEBUG( ("now %u particles in overlap at old position", particles_in_overlap) );
             
             // re-get the reaction partners (structures), now on old position.
             boost::scoped_ptr<structure_id_pair_and_distance_list> overlap_structures_after_bounce( 
                     tx_.check_surface_overlap( particle_shape_type( old_pos, r0 + reaction_length_ ), old_pos, old_struct_id, r0) );
             overlap_structures.swap( overlap_structures_after_bounce );   // FIXME is there no better way?
-            // NOTE that it is asserted that the particle overlap criterium for the particle with other particles
-            // and surfaces is False!
+            // NOTE that it is asserted that the particle overlap criterium for the particle with
+            // other particles and surfaces is False!
             structures_in_overlap = (int)(overlap_structures ? overlap_structures->size(): 0);
-            LOG_DEBUG( ("now structures_in_overlap = %u", structures_in_overlap) ); // TESTING
+            LOG_DEBUG( ("now %u structures in overlap at old position", structures_in_overlap) );
         }
+        // NOTE that overlap_structures and overlap_particles also have been defined properly above when bounced = false;
+        // in that case, there were no core overlaps, but possibly still overlaps within the reaction volume
         
 
         /*** 6. REACTIONS & INTERACTIONS ***/

From 0c119314e64a22bb1e4f802715bd046be63dae06 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 13:00:14 +0100
Subject: [PATCH 1513/1541] WIP: A new hashtable allowing to selectively
 deactivate constr. of domain types

Still has to be fixed for Single and Pair types.
---
 egfrd.py | 131 +++++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 104 insertions(+), 27 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index faff010c..ea65b872 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -77,73 +77,147 @@
 
 import os
 
+
+# Hashtable that selectively decides which domains can be constructed,
+# irrespective of all other circumstances; this can be used, e.g., to
+# switch off the construction of certain domains for testing, and to
+# force the system to use Brownian Dynamics (make a Multi) in certain
+# situations / circumstances instead.
+# The "filter" map is based on the test shells, because certain special
+# test shells result in the same domain type later in spite of different
+# initial circumstances.
+allowed_to_make = {
+        # Singles
+        SphericalSingletestShell:                                       True,
+        PlanarSurfaceSingletestShell:                                   True,
+        CylindricalSurfaceSingletestShell:                              True,
+        # (Special singles)
+        CylindricalSurfacePlanarSurfaceInterfaceSingletestShell:        True,
+        # Interactions
+        # (Bulk -> 2D and 1D)
+        PlanarSurfaceInteractiontestShell:                              True,
+        CylindricalSurfaceInteractiontestShell:                         True,
+        # (Among 2D and 1D structures)
+        PlanarSurfaceCylindricalSurfaceInteractiontestShell:            True,
+        PlanarSurfaceDiskSurfaceInteractiontestShell:                   True,
+        CylindricalSurfacePlanarSurfaceIntermediateSingletestShell:     True,
+        CylindricalSurfaceSinktestShell:                                True,
+        CylindricalSurfaceDiskInteractiontestShell:                     True,
+        CylindricalSurfacePlanarSurfaceInteractiontestShell:            True,
+        # Transitions
+        PlanarSurfaceTransitionSingletestShell:                         True,
+        # Pairs
+        }        
+
+# Now in the following we define the "gearbox" functions that figure out
+# which domain type should be constructed
+
 ### Singles
 def create_default_single(domain_id, shell_id, pid_particle_pair, structure, reaction_rules, geometrycontainer, domains):
+    # Bulk single
     if isinstance(structure, CuboidalRegion):
         # First make the test shell
         testSingle = SphericalSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return SphericalSingle          (domain_id, shell_id, testSingle, reaction_rules)
+    # Plane single
     elif isinstance(structure, PlanarSurface):
         # First make the test shell
         testSingle = PlanarSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return PlanarSurfaceSingle      (domain_id, shell_id, testSingle, reaction_rules)
+    # Cylinder single
     elif isinstance(structure, CylindricalSurface):
         # First make the test shell
         testSingle = CylindricalSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
         return CylindricalSurfaceSingle (domain_id, shell_id, testSingle, reaction_rules)
+    # Disk single
     elif isinstance(structure, DiskSurface):
-        # First make the test shell        
+        # Here we first want to try a special case, in which the particle is at the "interface" btw. cylinder and plane
+        # The corresponding test shell is akin to the standard DiskSurfaceSingle, but has an extended ignore list
         try:
-            # Here we first want to try a special case, in which the particle is at the "interface" btw. cylinder and plane
-            # The corresponding test shell is akin to the standard DiskSurfaceSingle, but has an extended ignore list
-            testSingle = CylindricalSurfacePlanarSurfaceInterfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+            if allowed_to_make[CylindricalSurfacePlanarSurfaceInterfaceSingletestShell]:
+                testSingle = CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (pid_particle_pair, structure, geometrycontainer, domains)
+            else:
+                raise testShellError('Creation of domain type deactivated')
         except testShellError as e:
             if __debug__:
                 log.warn('Could not make CylindricalSurfacePlanarSurfaceInterfaceSingletestShell, %s' % str(e))
-            # making the default testShell should never fail
-            testSingle = DiskSurfaceSingletestShell(pid_particle_pair, structure, geometrycontainer, domains)
+            # Making the default testShell should never fail
+            testSingle = DiskSurfaceSingletestShell (pid_particle_pair, structure, geometrycontainer, domains)
 
         return DiskSurfaceSingle        (domain_id, shell_id, testSingle, reaction_rules)
 
 ### Interactions
 def try_default_testinteraction(single, target_structure, geometrycontainer, domains):
+  
+    # [Bulk -> Plane] or [Bulk -> Cylinder]
     if isinstance(single.structure, CuboidalRegion):
-        if isinstance(target_structure, PlanarSurface):
+        # [Bulk -> Plane]
+        if isinstance(target_structure, PlanarSurface) and allowed_to_make[PlanarSurfaceInteractiontestShell]:
             return PlanarSurfaceInteractiontestShell      (single, target_structure, geometrycontainer, domains)
-        elif isinstance(target_structure, CylindricalSurface):
+        # [Bulk -> Cylinder]
+        elif isinstance(target_structure, CylindricalSurface) and allowed_to_make[CylindricalSurfaceInteractiontestShell]:
             return CylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
         else:
-            raise testShellError('(Interaction). Combination of (3D particle, target_structure) is not supported')
+            raise testShellError('(Interaction). Combination of (3D particle, target_structure) is not supported or deactivated')
+    
+    # [Plane -> Cylinder] or [Plane -> Disk]
     elif isinstance(single.structure, PlanarSurface):
-        if isinstance(target_structure, CylindricalSurface): ### TESTING ###
+        # [Plane -> Cylinder]
+        if isinstance(target_structure, CylindricalSurface) and allowed_to_make[PlanarSurfaceCylindricalSurfaceInteractiontestShell]: ### TESTING ###
             return PlanarSurfaceCylindricalSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
-            #raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
-        elif isinstance(target_structure, DiskSurface):
+        # [Plane -> Disk]
+        elif isinstance(target_structure, DiskSurface) \
+             and (  allowed_to_make[CylindricalSurfacePlanarSurfaceIntermediateSingletestShell] \
+                 or allowed_to_make[PlanarSurfaceDiskSurfaceInteractiontestShell]               ):
             # Here we have 2 possibilities; first we try the less probable one (special conditions apply that are checked
             # upon test shell construction), then the more common one.
             try:
-                return CylindricalSurfacePlanarSurfaceIntermediateSingletestShell (single, target_structure, geometrycontainer, domains)
+                if allowed_to_make[CylindricalSurfacePlanarSurfaceIntermediateSingletestShell]:
+                    return CylindricalSurfacePlanarSurfaceIntermediateSingletestShell (single, target_structure, geometrycontainer, domains)                    
+                else:
+                    raise testShellError('Creation of domain type deactivated')
             except testShellError as e:
                 if __debug__:
-                    log.warn('Could not make CylindricalSurfacePlanarSurfaceIntermediateSingletestShell, %s; now trying PlanarSurfaceDiskSurfaceInteractiontestShell.' % str(e))
-                return PlanarSurfaceDiskSurfaceInteractiontestShell               (single, target_structure, geometrycontainer, domains)
-                # if both shells do not work in this situation the second try will result in raising another shellmaking exception       
+                    log.warn('Could not make CylindricalSurfacePlanarSurfaceIntermediateSingletestShell, %s.' % str(e))
+            # OK, we could not make the special domain, but we still want to try the more standard one instead
+            # If both shells do not work in this situation the second try will result in raising another shellmaking exception
+            if allowed_to_make[PlanarSurfaceDiskSurfaceInteractiontestShell]:
+                log.info('Now trying PlanarSurfaceDiskSurfaceInteractiontestShell.')
+                return PlanarSurfaceDiskSurfaceInteractiontestShell    (single, target_structure, geometrycontainer, domains)                
+            else:
+                raise testShellError('Creation of domain type deactivated')
+        # Unsupported cases
         else:
-            raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported')
+            raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported or deactivated')
+          
+    # [Cylinder -> Disk] or [Cylinder -> Plane]
     elif isinstance(single.structure, CylindricalSurface):
-        if isinstance(target_structure, DiskSurface):
+        # [Cylinder -> Disk]
+        if isinstance(target_structure, DiskSurface) \
+           and (  allowed_to_make[CylindricalSurfaceSinktestShell] \
+               or allowed_to_make[CylindricalSurfaceDiskInteractiontestShell] ):
             try:
-                return CylindricalSurfaceSinktestShell                 (single, target_structure, geometrycontainer, domains)
+                if allowed_to_make[CylindricalSurfaceSinktestShell]:
+                    return CylindricalSurfaceSinktestShell             (single, target_structure, geometrycontainer, domains)
+                else:
+                    raise testShellError('Creation of domain type deactivated')
             except testShellError as e:
                 if __debug__:
                       log.warn('Could not make CylindricalSurfaceSinktestShell, %s; now trying CylindricalSurfaceDiskInteractiontestShell.' % str(e))
-                return CylindricalSurfaceDiskInteractiontestShell      (single, target_structure, geometrycontainer, domains)
-        elif isinstance(target_structure, PlanarSurface):
+                if allowed_to_make[CylindricalSurfaceDiskInteractiontestShell]:
+                    return CylindricalSurfaceDiskInteractiontestShell  (single, target_structure, geometrycontainer, domains)                
+                else:
+                    raise testShellError('Creation of domain type deactivated')
+        # [Cylinder -> Plane]
+        elif isinstance(target_structure, PlanarSurface) and allowed_to_make[CylindricalSurfacePlanarSurfaceInteractiontestShell]:
             return CylindricalSurfacePlanarSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
+        # Unsupported cases
         else:
-            raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported')
+            raise testShellError('(Interaction). Combination of (1D particle, target_structure) is not supported or deactivated')
+          
+    # All other unsupported cases
     else:
-        raise testShellError('(Interaction). structure of particle was of invalid type')
+        raise testShellError('(Interaction). Structure of particle was of invalid type')
 
 def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, interaction_rules):
     if isinstance(testShell, PlanarSurfaceCylindricalSurfaceInteractiontestShell): # must be first because it is a special case of PlanarSurfaceDiskSurfaceInteractiontestShell below
@@ -169,17 +243,20 @@ def try_default_testtransition(single, target_structure, geometrycontainer, doma
             raise testShellError('(Transition). Combination of (3D particle, target_structure) is not supported')
     elif isinstance(single.structure, PlanarSurface):
         if isinstance(target_structure, PlanarSurface):
-            return PlanarSurfaceTransitionSingletestShell (single, target_structure, geometrycontainer, domains)
+            if allowed_to_make[PlanarSurfaceTransitionSingletestShell]:
+                return PlanarSurfaceTransitionSingletestShell (single, target_structure, geometrycontainer, domains)
+            else:
+                raise testShellError('Creation of domain type deactivated')
         else:
             raise testShellError('(Transition). Combination of (2D particle, target_structure other than plane) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
             raise testShellError('(Transition). Combination of (1D particle, target_structure) is not supported')
     else:
-        raise testShellError('(Transition). structure of particle was of invalid type')
+        raise testShellError('(Transition). Structure of particle was of invalid type')
 
 def create_default_transition(domain_id, shell_id, testShell, reaction_rules):
     if isinstance(testShell, PlanarSurfaceTransitionSingletestShell):
-        return PlanarSurfaceTransitionSingle              (domain_id, shell_id, testShell, reaction_rules)
+        return PlanarSurfaceTransitionSingle (domain_id, shell_id, testShell, reaction_rules)
 
 ### Pairs
 def try_default_testpair(single1, single2, geometrycontainer, domains):
@@ -3234,7 +3311,7 @@ def check_domain(self, domain):
                             log.warn('%s (%s) overlaps with %s by %s.' % \
                                       (str(domain), str(shell), str(surface), FORMAT_DOUBLE % overlap) )
                 assert overlap >= -1.0*overlap_tolerance, \
-                    'Overlap out of overlap_tolerance = %s.' % str(overlap_tolerance)
+                    'Overlap (%s) out of overlap_tolerance (%s).' % (str(overlap), str(overlap_tolerance))
                     
 
             ### Check that shells DO overlap with associated surfaces.

From 6ecee66463b117da0839c364d54100694500f6ec Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 13:21:00 +0100
Subject: [PATCH 1514/1541] Namefix

---
 shells.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/shells.py b/shells.py
index 78868e54..20dd7f53 100755
--- a/shells.py
+++ b/shells.py
@@ -2632,7 +2632,7 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
 
         if feq(self.particle_surface_distance, 0.0, typical=self.target_structure.shape.radius) \
            or self.particle_surface_distance < 0.0:
-            raise testShellError('(PlanarSurfaceDiskSurfaceInteractiontestShell). Zero or negative particle-surface distance, value = %s. Particle is most likely already on the disk.' \
+            raise testShellError('(PlanarSurfaceCylindricalSurfaceInteractiontestShell). Zero or negative particle-surface distance, value = %s. Particle is most likely already on the disk.' \
                                                                                   % self.particle_surface_distance                                                                      )
 
         # Initialize the scaling parameters

From cc40c213c08124cf5421e89209af1249852f02ee Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 13:35:07 +0100
Subject: [PATCH 1515/1541] Allow selective deactivation of domain creation
 also for Singles

---
 egfrd.py | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ea65b872..fa44f063 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -86,6 +86,9 @@
 # The "filter" map is based on the test shells, because certain special
 # test shells result in the same domain type later in spite of different
 # initial circumstances.
+# Note that for the Singles setting the respective value to "False" will
+# only block their "upscaling" in update_single(), because by convention
+# we always allow for the creation of "zero-Singles".
 allowed_to_make = {
         # Singles
         SphericalSingletestShell:                                       True,
@@ -107,6 +110,7 @@
         # Transitions
         PlanarSurfaceTransitionSingletestShell:                         True,
         # Pairs
+        ### TODO
         }        
 
 # Now in the following we define the "gearbox" functions that figure out
@@ -2124,11 +2128,16 @@ def make_new_domain(self, single):
                     log.debug('Overlap partner = %s' % str(multi_partners[0][0]))
 
             # If the closest partner is within the multi horizon we do Multi, otherwise Single
-            if closest_overlap > 0.0 and not self.BD_ONLY_FLAG : 
+            # Here we also check whether the uses force-deactivated the construction of this particular
+            # Single type, or wants to run the simulator in BD mode only anyhow
+            if  closest_overlap > 0.0 and not self.BD_ONLY_FLAG:
                 try:
-                    # Just make a normal NonInteractionSingle
-                    self.update_single(single)
-                    bin_domain = single
+                    if allowed_to_make[single.testShell.__class__]:                    
+                        # Just make a normal NonInteractionSingle
+                        self.update_single(single)
+                        bin_domain = single
+                    else:
+                        raise testShellError('Creation of domain type deactivated.')
 
                 except Exception as e:
                     # If in rare cases the single update fails, make at least a Multi and warn

From a247a4a6258595d900cc3291530e413820316551 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 15:28:50 +0100
Subject: [PATCH 1516/1541] Allow selective deactivation of formation of Pair
 domain classes

... and some cleanup in exception messages relevant to this.
---
 egfrd.py | 68 ++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 44 insertions(+), 24 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index fa44f063..8be92176 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -94,6 +94,7 @@
         SphericalSingletestShell:                                       True,
         PlanarSurfaceSingletestShell:                                   True,
         CylindricalSurfaceSingletestShell:                              True,
+        DiskSurfaceSingletestShell:                                     True,
         # (Special singles)
         CylindricalSurfacePlanarSurfaceInterfaceSingletestShell:        True,
         # Interactions
@@ -110,9 +111,25 @@
         # Transitions
         PlanarSurfaceTransitionSingletestShell:                         True,
         # Pairs
-        ### TODO
-        }        
-
+        SphericalPairtestShell:                                         True,
+        PlanarSurfacePairtestShell:                                     True,
+        CylindricalSurfacePairtestShell:                                True,
+        PlanarSurfaceTransitionPairtestShell:                           True,
+        MixedPair2D3DtestShell:                                         True,
+        MixedPair2DStatictestShell:                                     True,
+        MixedPair1DStatictestShell:                                     True
+}        
+
+# A helper function to unify/facilitate checking whether construction of Pairs 
+# is activated, used further below
+def pair_testShell_if_allowed(pair_testShell_class, singleA, singleB, geometrycontainer, domains):
+
+    if allowed_to_make[pair_testShell_class]:
+        return pair_testShell_class(singleA,  singleB, geometrycontainer, domains)
+    else:
+        raise testShellError('Creation of test shell type deactivated for %s' % pair_testShell_class)
+      
+        
 # Now in the following we define the "gearbox" functions that figure out
 # which domain type should be constructed
 
@@ -141,7 +158,7 @@ def create_default_single(domain_id, shell_id, pid_particle_pair, structure, rea
             if allowed_to_make[CylindricalSurfacePlanarSurfaceInterfaceSingletestShell]:
                 testSingle = CylindricalSurfacePlanarSurfaceInterfaceSingletestShell (pid_particle_pair, structure, geometrycontainer, domains)
             else:
-                raise testShellError('Creation of domain type deactivated')
+                raise testShellError('Creation of test shell type deactivated for %s' % CylindricalSurfacePlanarSurfaceInterfaceSingletestShell)
         except testShellError as e:
             if __debug__:
                 log.warn('Could not make CylindricalSurfacePlanarSurfaceInterfaceSingletestShell, %s' % str(e))
@@ -179,7 +196,7 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
                 if allowed_to_make[CylindricalSurfacePlanarSurfaceIntermediateSingletestShell]:
                     return CylindricalSurfacePlanarSurfaceIntermediateSingletestShell (single, target_structure, geometrycontainer, domains)                    
                 else:
-                    raise testShellError('Creation of domain type deactivated')
+                    raise testShellError('Creation of test shell type deactivated for %s' % CylindricalSurfacePlanarSurfaceIntermediateSingletestShell)
             except testShellError as e:
                 if __debug__:
                     log.warn('Could not make CylindricalSurfacePlanarSurfaceIntermediateSingletestShell, %s.' % str(e))
@@ -189,7 +206,7 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
                 log.info('Now trying PlanarSurfaceDiskSurfaceInteractiontestShell.')
                 return PlanarSurfaceDiskSurfaceInteractiontestShell    (single, target_structure, geometrycontainer, domains)                
             else:
-                raise testShellError('Creation of domain type deactivated')
+                raise testShellError('Creation of test shell type deactivated for %s' % PlanarSurfaceDiskSurfaceInteractiontestShell)
         # Unsupported cases
         else:
             raise testShellError('(Interaction). Combination of (2D particle, target_structure) is not supported or deactivated')
@@ -204,14 +221,14 @@ def try_default_testinteraction(single, target_structure, geometrycontainer, dom
                 if allowed_to_make[CylindricalSurfaceSinktestShell]:
                     return CylindricalSurfaceSinktestShell             (single, target_structure, geometrycontainer, domains)
                 else:
-                    raise testShellError('Creation of domain type deactivated')
+                    raise testShellError('Creation of test shell type deactivated for %s' % CylindricalSurfaceSinktestShell)
             except testShellError as e:
                 if __debug__:
                       log.warn('Could not make CylindricalSurfaceSinktestShell, %s; now trying CylindricalSurfaceDiskInteractiontestShell.' % str(e))
                 if allowed_to_make[CylindricalSurfaceDiskInteractiontestShell]:
                     return CylindricalSurfaceDiskInteractiontestShell  (single, target_structure, geometrycontainer, domains)                
                 else:
-                    raise testShellError('Creation of domain type deactivated')
+                    raise testShellError('Creation of test shell type deactivated for %s' % CylindricalSurfaceDiskInteractiontestShell)
         # [Cylinder -> Plane]
         elif isinstance(target_structure, PlanarSurface) and allowed_to_make[CylindricalSurfacePlanarSurfaceInteractiontestShell]:
             return CylindricalSurfacePlanarSurfaceInteractiontestShell (single, target_structure, geometrycontainer, domains)
@@ -250,7 +267,7 @@ def try_default_testtransition(single, target_structure, geometrycontainer, doma
             if allowed_to_make[PlanarSurfaceTransitionSingletestShell]:
                 return PlanarSurfaceTransitionSingletestShell (single, target_structure, geometrycontainer, domains)
             else:
-                raise testShellError('Creation of domain type deactivated')
+                raise testShellError('Creation of test shell type deactivated for %s' % PlanarSurfaceTransitionSingletestShell)
         else:
             raise testShellError('(Transition). Combination of (2D particle, target_structure other than plane) is not supported')
     elif isinstance(single.structure, CylindricalSurface):
@@ -266,28 +283,31 @@ def create_default_transition(domain_id, shell_id, testShell, reaction_rules):
 def try_default_testpair(single1, single2, geometrycontainer, domains):
     if single1.structure == single2.structure:
         if isinstance(single1.structure, CuboidalRegion):
-            return SphericalPairtestShell           (single1, single2, geometrycontainer, domains)
+            return pair_testShell_if_allowed(SphericalPairtestShell, single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, PlanarSurface):
-            return PlanarSurfacePairtestShell       (single1, single2, geometrycontainer, domains)
+            return pair_testShell_if_allowed(PlanarSurfacePairtestShell, single1, single2, geometrycontainer, domains)
         elif isinstance(single1.structure, CylindricalSurface):
-            return CylindricalSurfacePairtestShell  (single1, single2, geometrycontainer, domains)
+            return pair_testShell_if_allowed(CylindricalSurfacePairtestShell, single1, single2, geometrycontainer, domains)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, PlanarSurface)):
-        return PlanarSurfaceTransitionPairtestShell (single1, single2, geometrycontainer, domains) 
+        return pair_testShell_if_allowed(PlanarSurfaceTransitionPairtestShell, single1, single2, geometrycontainer, domains) 
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell               (single1, single2, geometrycontainer, domains) 
+        return pair_testShell_if_allowed(MixedPair2D3DtestShell, single1, single2, geometrycontainer, domains) 
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, CuboidalRegion)):
-        return MixedPair2D3DtestShell(single2, single1, geometrycontainer, domains)
+        return pair_testShell_if_allowed(MixedPair2D3DtestShell, single2, single1, geometrycontainer, domains)
+        # (same as above with other particle order)
     elif (isinstance(single1.structure, PlanarSurface) and isinstance(single2.structure, DiskSurface)):
-        return MixedPair2DStatictestShell(single1, single2, geometrycontainer, domains)
+        return pair_testShell_if_allowed(MixedPair2DStatictestShell, single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, PlanarSurface) and isinstance(single1.structure, DiskSurface)):
-        return MixedPair2DStatictestShell(single2, single1, geometrycontainer, domains)
+        return pair_testShell_if_allowed(MixedPair2DStatictestShell, single2, single1, geometrycontainer, domains)
+        # (same as above with other particle order)
     elif (isinstance(single1.structure, CylindricalSurface) and isinstance(single2.structure, DiskSurface)):
-        return MixedPair1DStatictestShell(single1, single2, geometrycontainer, domains)
+        return pair_testShell_if_allowed(MixedPair1DStatictestShell, single1, single2, geometrycontainer, domains)
     elif (isinstance(single2.structure, CylindricalSurface) and isinstance(single1.structure, DiskSurface)):
-        return MixedPair1DStatictestShell(single2, single1, geometrycontainer, domains)
+        return pair_testShell_if_allowed(MixedPair1DStatictestShell, single2, single1, geometrycontainer, domains)
+        # (same as above with other particle order)
     else:
         # another mixed pair was supposed to be formed -> unsupported
-        raise testShellError('(MixedPair). combination of structures not supported')
+        raise testShellError('(MixedPair). Combination of structures not supported')
 
 def create_default_pair(domain_id, shell_id, testShell, reaction_rules):
     # Either SphericalPair, PlanarSurfacePair, or CylindricalSurfacePair.
@@ -2135,7 +2155,7 @@ def make_new_domain(self, single):
                     if allowed_to_make[single.testShell.__class__]:                    
                         # Just make a normal NonInteractionSingle
                         self.update_single(single)
-                        bin_domain = single
+                        bin_domain = single                        
                     else:
                         raise testShellError('Creation of domain type deactivated.')
 
@@ -2754,7 +2774,7 @@ def try_interaction(self, single, target_structure):
         except testShellError as e:
             testShell = None
             if __debug__:
-                log.debug('%s not formed %s' % \
+                log.debug('%s not formed: %s' % \
                           ('Interaction(%s, %s)' % (single.pid_particle_pair[0], target_structure),
                           str(e) ))
 
@@ -2804,7 +2824,7 @@ def try_transition(self, single, target_structure):
         except testShellError as e:
             testShell = None
             if __debug__:
-                log.debug('%s not formed %s' % \
+                log.debug('%s not formed: %s' % \
                           ('Transition(%s, %s)' % (single.pid_particle_pair[0], target_structure),
                           str(e) ))
 
@@ -2856,7 +2876,7 @@ def try_pair(self, single1, single2):
         except testShellError as e:
             testShell = None
             if __debug__:
-                log.debug('%s not formed %s' % \
+                log.debug('%s not formed: %s' % \
                           ('Pair(%s, %s)' % (single1.pid_particle_pair[0], single2.pid_particle_pair[0]),
                           str(e) ))
 

From 01a8b1fd548d6a2e0a667aa56203bfbb6b7100f2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 15:30:11 +0100
Subject: [PATCH 1517/1541] Increase SAFETY to 1.03 (from 1.01)

This will "waste" 3% of the maximal available space for domains
(instead of 1% before), but appears to work better for small systems,
in which collisions and overlaps are more frequent.
---
 utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/utils.py b/utils.py
index 72d9cb79..91b64774 100644
--- a/utils.py
+++ b/utils.py
@@ -17,7 +17,7 @@
 ZEROPOS = numpy.array([0., 0., 0.])
 NOWHERE = numpy.array((INF, INF, INF))
 
-SAFETY = 1.0 + 1e-2     # Lengths of shell in construction are divided by this safety factor 
+SAFETY = 1.0 + 3e-2     # Lengths of shell in construction are divided by this safety factor 
                         # to make sure that they do not overlap due to numerical rounding errors
 
 # Tolerance used for float comparison functions. Oversimplifying: two floats a 

From 11d1f8eeeca3641c167fccd2c04a02621d41491f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 15:35:55 +0100
Subject: [PATCH 1518/1541] Slightly change order in "domain creation hashmap"

---
 egfrd.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 8be92176..38781476 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -104,10 +104,10 @@
         # (Among 2D and 1D structures)
         PlanarSurfaceCylindricalSurfaceInteractiontestShell:            True,
         PlanarSurfaceDiskSurfaceInteractiontestShell:                   True,
-        CylindricalSurfacePlanarSurfaceIntermediateSingletestShell:     True,
-        CylindricalSurfaceSinktestShell:                                True,
-        CylindricalSurfaceDiskInteractiontestShell:                     True,
         CylindricalSurfacePlanarSurfaceInteractiontestShell:            True,
+        CylindricalSurfacePlanarSurfaceIntermediateSingletestShell:     True,        
+        CylindricalSurfaceDiskInteractiontestShell:                     True,
+        CylindricalSurfaceSinktestShell:                                True,
         # Transitions
         PlanarSurfaceTransitionSingletestShell:                         True,
         # Pairs

From 1418a32238c7866b1143af683877ed3b315b9991 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 15:43:58 +0100
Subject: [PATCH 1519/1541] Some commenting

---
 egfrd.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/egfrd.py b/egfrd.py
index 38781476..ddd2c716 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -89,6 +89,9 @@
 # Note that for the Singles setting the respective value to "False" will
 # only block their "upscaling" in update_single(), because by convention
 # we always allow for the creation of "zero-Singles".
+# Use this feature with care, because switching off the formation of
+# domains with central importance, such as the SphericalSingle, can lead
+# to substantial performance loss. This is mainly to be used for testing.
 allowed_to_make = {
         # Singles
         SphericalSingletestShell:                                       True,

From 6ccd935bd9732f0b4617ce952aa0cf7742679de3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 16:11:13 +0100
Subject: [PATCH 1520/1541] More informative output in newBDpropagator.hpp

---
 newBDPropagator.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/newBDPropagator.hpp b/newBDPropagator.hpp
index f5c43d58..984f1424 100644
--- a/newBDPropagator.hpp
+++ b/newBDPropagator.hpp
@@ -345,7 +345,7 @@ class newBDPropagator
                 }
                 else
                 {
-                    LOG_DEBUG( ("particle attempted an interaction with the non-interactive surface %s.", 
+                    LOG_DEBUG( ("particle attempted an interaction with surface %s; interaction not accepted.", 
                                 boost::lexical_cast<std::string>(overlap_struct.first.first).c_str()) );
                 }
             }
@@ -417,7 +417,7 @@ class newBDPropagator
             }
             else                
             {
-                LOG_DEBUG(("particle attempted a reaction with particle %s and failed.", 
+                LOG_DEBUG(("particle attempted a reaction with particle %s; reaction not accepted.", 
                     boost::lexical_cast<std::string>(overlap_particle.first.first).c_str()));
             }
             

From 2330b50b08d987214447d9ee47601f31fdca2479 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 17:11:11 +0100
Subject: [PATCH 1521/1541] Allow for transitions Plane->Cylinder in BD mode

This only works for single particles for now, no "mixed pairs"
(reactions btw. plane-bound and cylinder-bound particles) yet.
---
 StructureFunctions.hpp | 29 ++++++++++++++++++++---------
 1 file changed, 20 insertions(+), 9 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 8086d516..60c064e3 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -366,8 +366,8 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     length_type         proj_dist( target_structure.project_point(old_pos).second.second );
         // the distance of the projection of old_pos on target_structure to the boundary of target_structure
     
-    // Note that this function also correctly handles the pair reaction between a particle on a disk
-    // and a particle on a cylinder. Since we assume that the product will end up on the disk, new_pos
+    // Note that this function also correctly handles the pair reaction between a particle on a cylinder
+    // and a particle on a disk. Since we assume that the product will end up on the disk, new_pos
     // (which is the projection of the center of mass of both particles on the disk) will be the
     // correct product position.
     if(proj_dist < 0){ // if projection of old_pos is in structure
@@ -592,10 +592,25 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
 {
     typedef typename Ttraits_::structure_id_type        structure_id_type;
     typedef typename Ttraits_::position_type            position_type;
-    //typedef typename Ttraits_::length_type              length_type;
+    typedef typename Ttraits_::length_type              length_type;
+    
+    // This is treated in the same way as the case CuboidalRegion->Cylinder
+    structure_id_type   new_id(    target_structure.id() );
+    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    length_type         proj_dist( target_structure.project_point(old_pos).second.second );
+        // the distance of the projection of old_pos on target_structure to target_structure
+    
+    if(proj_dist < 0){ // if projection of old_pos is in structure
+     
+          return std::make_pair( new_pos, new_id );
+    }
+    else // structure transition not allowed
+      
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (Plane->Cylinder).");
 
-    /*** COMBINATION NOT SUPPORTED ***/
+    /*** COMBINATION NOT SUPPORTED 
     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Plane->Cylinder).");
+    ***/            
     
     return std::make_pair(position_type(), structure_id_type());
 };
@@ -619,10 +634,6 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     length_type         proj_dist( target_structure.project_point(old_pos).second.second );
         // the distance of the projection of old_pos on target_structure to the boundary of target_structure
     
-    // Note that this function also correctly handles the pair reaction between a particle on a disk
-    // and a particle on a cylinder. Since we assume that the product will end up on the disk, new_pos
-    // (which is the projection of the center of mass of both particles on the disk) will be the
-    // correct product position.
     if(proj_dist < 0){ // if projection of old_pos is in structure
                        // Note: Disk.project_point also returns a neg. value if the position is in one plane with the disk
      
@@ -630,7 +641,7 @@ get_pos_sid_pair( PlanarSurface<Ttraits_>               const& origin_structure,
     }
     else // structure transition not allowed
       
-      throw illegal_propagation_attempt("Illegal original particle position for structure transition (Plane->Disk).");        
+      throw illegal_propagation_attempt("Illegal original particle position for structure transition (Plane->Disk).");
     
     return std::make_pair(position_type(), structure_id_type());
 };

From 008754f7e3a65d3c1e7d3d6a119adb4b624a54a7 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 18:39:27 +0100
Subject: [PATCH 1522/1541] Fix unbinding behavior for Cyl.->Plane interaction
 in BD mode

This was not implemented correctly--we forgot about the
surface_dissociation_vector.

(But then again we also never used this transition...)
---
 StructureFunctions.hpp | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/StructureFunctions.hpp b/StructureFunctions.hpp
index 60c064e3..af1f7c70 100644
--- a/StructureFunctions.hpp
+++ b/StructureFunctions.hpp
@@ -394,12 +394,18 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
     typedef typename Ttraits_::length_type              length_type;
 
     structure_id_type   new_id(    target_structure.id() );
-    position_type       new_pos(   target_structure.project_point(old_pos).first );
+    position_type       proj_pos(  target_structure.project_point(old_pos).first );
     length_type         proj_dist( target_structure.project_point(old_pos).second.second );
         // the distance of the projection of old_pos on target_structure to the boundary of target_structure
         
     if(proj_dist < 0){ // if projection of old_pos is in structure
      
+          // The old position projected on the plane is not yet the correct new position!
+          // We still have to displace the particle by the cylinder (!) radius at a random angle
+          // The latter is generated in the same way as for regular cylinder unbinding
+          position_type displacement( origin_structure.surface_dissociation_vector(rng, offset, reaction_length) );
+          position_type new_pos( add(proj_pos, displacement) );
+          
           return std::make_pair( new_pos, new_id );
     }
     else // structure transition not allowed
@@ -407,12 +413,7 @@ get_pos_sid_pair( CylindricalSurface<Ttraits_>          const& origin_structure,
       throw illegal_propagation_attempt("Illegal original particle position for structure transition (Cylinder->Plane).");
     
     // TODO Does that also handle correctly the interaction of a rod particle with a particle located on the plane?
-    // (whether this is relevant for now is the other question...)
-    
-//     /*** COMBINATION NOT SUPPORTED ***/
-//     throw illegal_propagation_attempt("Structure transition between combination of origin structure and target structure not supported (Cylinder->Plane).");
-//     
-//     return std::make_pair(position_type(), structure_id_type());
+    // (whether this is relevant for now is the other question...)    
 };
 
 /***************************/

From 97b3703e819515b97edbc76434a115bc1856eb21 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 8 Nov 2016 19:15:03 +0100
Subject: [PATCH 1523/1541] Cyl.SurfacePlanarSurfaceInteractiontestShell can be
 returned w/o daughter disk

---
 egfrd.py  | 12 ++++++------
 shells.py | 16 +++++++++-------
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ddd2c716..7989e25e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -105,11 +105,11 @@
         PlanarSurfaceInteractiontestShell:                              True,
         CylindricalSurfaceInteractiontestShell:                         True,
         # (Among 2D and 1D structures)
-        PlanarSurfaceCylindricalSurfaceInteractiontestShell:            True,
-        PlanarSurfaceDiskSurfaceInteractiontestShell:                   True,
-        CylindricalSurfacePlanarSurfaceInteractiontestShell:            True,
-        CylindricalSurfacePlanarSurfaceIntermediateSingletestShell:     True,        
-        CylindricalSurfaceDiskInteractiontestShell:                     True,
+        PlanarSurfaceCylindricalSurfaceInteractiontestShell:            False,
+        PlanarSurfaceDiskSurfaceInteractiontestShell:                   False,
+        CylindricalSurfacePlanarSurfaceInteractiontestShell:            False,
+        CylindricalSurfacePlanarSurfaceIntermediateSingletestShell:     False,        
+        CylindricalSurfaceDiskInteractiontestShell:                     False,
         CylindricalSurfaceSinktestShell:                                True,
         # Transitions
         PlanarSurfaceTransitionSingletestShell:                         True,
@@ -252,7 +252,7 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction              (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction                   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell) and not(testShell.daughter_disk==None): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
         return CylindricalSurfacePlanarSurfaceInteraction        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell): # this is actually not a "real" interaction, but we need to put it here to ignore the target structure
         return CylindricalSurfacePlanarSurfaceIntermediateSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
diff --git a/shells.py b/shells.py
index 20dd7f53..1cad0c0e 100755
--- a/shells.py
+++ b/shells.py
@@ -2952,6 +2952,8 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
 
         try:
             self.daughter_disk = self.find_daughter_disk()
+            # Note (see below) that this can result in self.daughter_disk being set to 'None'
+            # In that case we have to make sure to construct a domain that does not require a daughter disk on the plane
 
         except testShellError as e:
             raise testShellError('(CylindricalSurfacePlanarSurfaceInteraction) %s' % (str(e)) )
@@ -3004,14 +3006,14 @@ def find_daughter_disk(self):
 
                 found_good_disk = False
                 if __debug__:
-                    log.warn('(CylindricalSurfacePlanarSurfaceInteraction) Disk surface is not situated below cylinder.')
+                    log.warn('(CylindricalSurfacePlanarSurfaceInteraction) Disk surface is not situated below cylinder.')                    
 
-        # OK, if everything is good, return the disk. If not, we don't make this domain and the plane is an obstacle.
-        if found_good_disk:
-            return closest_disk
-
-        else:
-            raise testShellError('Could not find correct (plane-associated) disk surface at the interface between cylinder and plane.')
+            # OK, if everything is good, return the disk. If not, we return 'None' in order to indicate that there is no disk
+            # Then we still do not raise a testShellError and return this test shell, but another domain has to be constructed afterwards
+            if not found_good_disk:
+                raise testShellError('Closest disk surface at the interface between cylinder and plane does not match requirements.')
+                
+        return closest_disk # which may be 'None'
           
     def set_structure_ignore_list(self):
 

From 200c4f93815887b46a275c3ec8556eae1d641166 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 9 Nov 2016 15:49:56 +0100
Subject: [PATCH 1524/1541] Changes to Cyl.SurfacePlanarSurfaceInteraction
 domain in single.py

...incorporating the check for whether there is a daughter disk
on the plane or not, and making the interaction behavior dependent
on that.
---
 single.py | 54 ++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 48 insertions(+), 6 deletions(-)

diff --git a/single.py b/single.py
index 3a5fc9fc..1fdd1e62 100644
--- a/single.py
+++ b/single.py
@@ -1206,8 +1206,8 @@ def determine_next_event(self):
 
     def iv_greens_function(self):
 
-        # zdisk = position of the disk relative to the initial particle position.
-        # zabs  = position of the absorbing cylinder boundary opposite of the disk
+        # dz_disk = position of the disk relative to the initial particle position.
+        # dz_abs  = position of the absorbing cylinder boundary opposite of the disk
         dz_disk = -self.get_inner_dz_left()
         dz_abs  = self.get_inner_dz_right()
 
@@ -1217,7 +1217,18 @@ def iv_greens_function(self):
             return GreensFunction1DRadAbs(self.D, self.v, self.interaction_ktot, 0.0, dz_disk, dz_abs)
 
     def draw_new_position(self, dt, event_type):
-
+      
+        # A wrapper method; we need to do this because some daughter classes still
+        # post-process the position generated by self.draw_new_position_on_disk(..)
+        return self.draw_new_position_on_disk(dt, event_type)
+        
+    def draw_new_position_on_disk(self, dt, event_type):
+        
+        # dz_disk = position of the disk relative to the initial particle position.
+        # dz_abs  = position of the absorbing cylinder boundary opposite of the disk
+        dz_disk = -self.get_inner_dz_left()
+        dz_abs  = self.get_inner_dz_right()
+        
         oldpos = self.pid_particle_pair[1].position
 
         if self.D == 0 or \
@@ -1228,13 +1239,13 @@ def draw_new_position(self, dt, event_type):
 
             if event_type == EventType.IV_INTERACTION:
                 # The particle left the domain through the reactive boundary, i.e. bound to the disk.
-                dz = -self.get_inner_dz_left()
+                dz = dz_disk
                 structure_id = self.target_structure.id
 
             elif event_type == EventType.IV_ESCAPE:
                 # The particle left the domain through the absorbing boundary,
                 # i.e. opposite of the disk.
-                dz = self.get_inner_dz_right()
+                dz = dz_abs
                 structure_id = self.origin_structure.id
 
             else:
@@ -1242,7 +1253,7 @@ def draw_new_position(self, dt, event_type):
                 # as a consequence it stays on the origin structure.
                 # NOTE: draw_r_wrapper(): attention, order of arguments inverted!
                 # Last two arguments are a, sigma (in this order!)
-                dz = draw_r_wrapper(gf, dt, self.get_inner_dz_right(), -self.get_inner_dz_left())
+                dz = draw_r_wrapper(gf, dt, dz_abs, dz_disk)
                 structure_id = self.origin_structure.id
 
             # Add displacement to particle.position.
@@ -1274,6 +1285,37 @@ def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrul
         # For now this just does the same as the disk interaction, but the test shells
         # slightly differ and we like to keep things apart and organized.
 
+    def draw_new_position(self, dt, event_type):
+      
+        # Method self.draw_new_position_on_disk(..) is inherited from the parent class
+        # Here we decide whether we use the position generated by this method, or still
+        # post process it, based on whether the target plane has a daughter disk or not
+        # (we post process in the latter case by yet adding a random unbinding vector)
+        try:
+            daughter_disk = testShell.daughter_disk
+        except AttributeError:
+            raise ShellmakingError('Could not make CylindricalSurfacePlanarSurfaceInteraction, %s' % str(e))
+          
+        if daughter_disk == None:
+            
+          # Get the position in the prolongation of the cylinder axis,
+          # which we still have to post-process
+          axis_pos, structure_id = self.draw_new_position_on_disk(dt, event_type)
+          assert(structure_id == self.target_structure.id)
+          
+          particle_radius = self.pid_particle_pair[1].radius
+          
+          vector_length = (origin_structure.shape.radius + particle_radius) * MINIMAL_SEPARATION_FACTOR
+          unit_vector3D = random_unit_vector()
+          unit_vector2D = normalize(unit_vector3D - \
+                          (self.origin_structure.shape.unit_z * numpy.dot(unit_vector3D, self.origin_structure.shape.unit_z)))
+          
+          return axis_pos + vector_length * unit_vector2D, structure_id
+        
+        else:            
+          
+          return self.draw_new_position_on_disk(dt, event_type)          
+        
     def __str__(self):
         return 'CylindricalSurfacePlanarSurfaceInteraction ' + Single.__str__(self)
 

From d3819516539a02ee08ac772b7f917c0f63cc1dad Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 9 Nov 2016 16:52:49 +0100
Subject: [PATCH 1525/1541] Some debugging and balancing of new features (WIP)

---
 egfrd.py  | 12 ++++++------
 shells.py | 56 +++++++++++++++++++++++++++++++++++--------------------
 single.py |  6 ++++--
 3 files changed, 46 insertions(+), 28 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 7989e25e..ddd2c716 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -105,11 +105,11 @@
         PlanarSurfaceInteractiontestShell:                              True,
         CylindricalSurfaceInteractiontestShell:                         True,
         # (Among 2D and 1D structures)
-        PlanarSurfaceCylindricalSurfaceInteractiontestShell:            False,
-        PlanarSurfaceDiskSurfaceInteractiontestShell:                   False,
-        CylindricalSurfacePlanarSurfaceInteractiontestShell:            False,
-        CylindricalSurfacePlanarSurfaceIntermediateSingletestShell:     False,        
-        CylindricalSurfaceDiskInteractiontestShell:                     False,
+        PlanarSurfaceCylindricalSurfaceInteractiontestShell:            True,
+        PlanarSurfaceDiskSurfaceInteractiontestShell:                   True,
+        CylindricalSurfacePlanarSurfaceInteractiontestShell:            True,
+        CylindricalSurfacePlanarSurfaceIntermediateSingletestShell:     True,        
+        CylindricalSurfaceDiskInteractiontestShell:                     True,
         CylindricalSurfaceSinktestShell:                                True,
         # Transitions
         PlanarSurfaceTransitionSingletestShell:                         True,
@@ -252,7 +252,7 @@ def create_default_interaction(domain_id, shell_id, testShell, reaction_rules, i
         return CylindricalSurfaceInteraction              (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, PlanarSurfaceInteractiontestShell):
         return PlanarSurfaceInteraction                   (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
-    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell) and not(testShell.daughter_disk==None): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
+    elif isinstance(testShell, CylindricalSurfacePlanarSurfaceInteractiontestShell): # must be first because it is a special case of CylindricalSurfaceDiskInteractiontestShell
         return CylindricalSurfacePlanarSurfaceInteraction        (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
     elif isinstance(testShell, CylindricalSurfacePlanarSurfaceIntermediateSingletestShell): # this is actually not a "real" interaction, but we need to put it here to ignore the target structure
         return CylindricalSurfacePlanarSurfaceIntermediateSingle (domain_id, shell_id, testShell, reaction_rules, interaction_rules)
diff --git a/shells.py b/shells.py
index 1cad0c0e..4d390db4 100755
--- a/shells.py
+++ b/shells.py
@@ -2659,6 +2659,8 @@ def __init__(self, single, target_structure, geometrycontainer, domains):
         self.ignored_structure_ids = self.set_structure_ignore_list()
         try:
             # First we check whether the cylinder that we try to interact with actually has an interface disk
+            # and also compute the position at which the cylinder hits the plane (assuming orthogonality)
+            self.interface_position, _ = self.origin_structure.project_point(self.target_structure.shape.position)
             self.daughter_disk = self.find_daughter_disk()
           
             self.dr, self.dz_right, self.dz_left = \
@@ -2671,10 +2673,12 @@ def get_orientation_vector(self):
         return self.structure.shape.unit_z
 
     def get_searchpoint(self):
-        return self.daughter_disk.shape.position
+        return self.interface_position
+        #return self.daughter_disk.shape.position
 
     def get_referencepoint(self):
-        return self.daughter_disk.shape.position
+        return self.interface_position
+        #return self.daughter_disk.shape.position
         
     def find_daughter_disk(self):
 
@@ -2688,8 +2692,13 @@ def find_daughter_disk(self):
         try:
             # The following will (should!) find only disks that are visible from the target structure (=cylinder),
             # i.e. already is limited to daughter disks of the cylinder
-            closest_disk, closest_disk_dist = \
-                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+            closest_disk_info = get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+            
+            if closest_disk_info != None:
+                closest_disk, closest_disk_dist = closest_disk_info
+            else:
+                closest_disk = None
+                
         except:
             raise testShellError('(PlanarSurfaceCylindricalSurfaceInteraction) get_closest_structure() failed, could not determine plane-associated disk.')
 
@@ -2723,10 +2732,8 @@ def find_daughter_disk(self):
         # OK, if everything is good, return the disk. If not, we don't make this domain and the cylinder is an obstacle.
         if found_good_disk:
             log.warn('(PlanarSurfaceCylindricalSurfaceInteraction) Found proper daughter disk.')
-            return closest_disk
-
-        else:
-            raise testShellError('Could not find correct (cylinder-associated) disk surface at the interface between cylinder and plane.')
+            
+        return closest_disk # which may be 'None'
 
     def get_min_dr_dzright_dzleft(self):        
         dr       = self.pid_particle_pair[1].radius * SINGLE_SHELL_FACTOR + (self.particle_surface_distance + self.target_structure.shape.radius)
@@ -2748,15 +2755,18 @@ def set_structure_ignore_list(self):
         # This checks whether there is also a sub-disk of the origin structure (plane) or the target structure (cylinder) nearby
         # If yes, we want to ignore these as well, because then they are part of the (double-sided) interface
         search_pos = self.pid_particle_pair[1].position
-        plane_disk, plane_disk_dist = \
-                    get_closest_structure(self.world, search_pos, self.origin_structure.id, [], structure_class=DiskSurface)
-        cyl_disk, cyl_disk_dist = \
-                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+        
+        plane_disk_info = get_closest_structure(self.world, search_pos, self.origin_structure.id, [], structure_class=DiskSurface)        
+        cyl_disk_info   = get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
         
         nearby_disk_id_list = []
-        if plane_disk is not None:
+        
+        if plane_disk_info is not None:
+          plane_disk, plane_disk_dist = plane_disk_info
           nearby_disk_id_list = nearby_disk_id_list + [plane_disk.id]
-        if cyl_disk is not None:
+          
+        if cyl_disk_info is not None:
+          cyl_disk, cyl_disk_dist = cyl_disk_info
           nearby_disk_id_list = nearby_disk_id_list + [cyl_disk.id]          
           
         return [self.target_structure.id] + nearby_disk_id_list
@@ -2976,8 +2986,12 @@ def find_daughter_disk(self):
         try:
             # The following will (should!) find only disks that are visible from the target structure (=plane),
             # i.e. already is limited to daughter disks of the plane
-            closest_disk, closest_disk_dist = \
-                    get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+            closest_disk_info = get_closest_structure(self.world, search_pos, self.target_structure.id, [], structure_class=DiskSurface)
+            if closest_disk_info != None:
+                closest_disk, closest_disk_dist = closest_disk_info
+            else:
+                closest_disk = None
+                
         except:
             raise testShellError('(CylindricalSurfacePlanarSurfaceInteraction) get_closest_structure() failed, could not determine plane-associated disk.')
 
@@ -3020,11 +3034,13 @@ def set_structure_ignore_list(self):
         # This checks whether there is also a sub-disk of the origin structure (cylinder) nearby
         # If yes, we want to ignore these as well, because then they are part of the (double-sided) interface
         search_pos = self.pid_particle_pair[1].position
-        other_disk, other_disk_dist = \
-                    get_closest_structure(self.world, search_pos, self.origin_structure.id, [], structure_class=DiskSurface)
-                    
-        if other_disk is not None:
+        
+        closest_structure_info = get_closest_structure(self.world, search_pos, self.origin_structure.id, [], structure_class=DiskSurface)
+        
+        if closest_structure_info != None:        
+          other_disk, other_disk_dist = closest_structure_info
           return [self.target_structure.id, other_disk.id]
+          
         else:
           return [self.target_structure.id]
 
diff --git a/single.py b/single.py
index 1fdd1e62..c1422448 100644
--- a/single.py
+++ b/single.py
@@ -980,6 +980,8 @@ class PlanarSurfaceCylindricalSurfaceInteraction(CylindricalSurfaceInteraction):
         * Selected randomly when drawing displacement vector: none.
 
     """
+    ### TODO: Use self.testShell.daughter_disk to also allow placement of the product on a daughter disk
+    ###       of the cylinder, akin to the inverse processs in CylindricalSurfacePlanarSurfaceInteraction
     def __init__(self, domain_id, shell_id, testShell, reactionrules, interactionrules):
 
         # This domain is basically equivalent to CylindricalSurfaceInteraction. It uses
@@ -1292,7 +1294,7 @@ def draw_new_position(self, dt, event_type):
         # post process it, based on whether the target plane has a daughter disk or not
         # (we post process in the latter case by yet adding a random unbinding vector)
         try:
-            daughter_disk = testShell.daughter_disk
+            daughter_disk = self.testShell.daughter_disk
         except AttributeError:
             raise ShellmakingError('Could not make CylindricalSurfacePlanarSurfaceInteraction, %s' % str(e))
           
@@ -1305,7 +1307,7 @@ def draw_new_position(self, dt, event_type):
           
           particle_radius = self.pid_particle_pair[1].radius
           
-          vector_length = (origin_structure.shape.radius + particle_radius) * MINIMAL_SEPARATION_FACTOR
+          vector_length = (self.origin_structure.shape.radius + particle_radius) * MINIMAL_SEPARATION_FACTOR
           unit_vector3D = random_unit_vector()
           unit_vector2D = normalize(unit_vector3D - \
                           (self.origin_structure.shape.unit_z * numpy.dot(unit_vector3D, self.origin_structure.shape.unit_z)))

From fb87d74292603c746aa7ddca6ad13c9f0a30bc23 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 14 Nov 2016 16:13:11 +0100
Subject: [PATCH 1526/1541] Further fixes to the newly implemented Cyl./Plane
 interaction domains

---
 shells.py | 4 ++--
 single.py | 6 ++++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/shells.py b/shells.py
index 4d390db4..a6d2e07c 100755
--- a/shells.py
+++ b/shells.py
@@ -2956,9 +2956,9 @@ class CylindricalSurfacePlanarSurfaceInteractiontestShell(CylindricalSurfaceDisk
     # The working principle put forward here is akin to (->) PlanarSurfaceCylindricalSurfaceInteractiontestShell
     def __init__(self, single, target_structure, geometrycontainer, domains):
         CylindricalSurfaceDiskInteractiontestShell.__init__(self, single, target_structure, geometrycontainer, domains)        
-        
-        assert isinstance(target_structure, PlanarSurface)
+                
         assert isinstance(self.origin_structure, CylindricalSurface)
+        assert isinstance(self.target_structure, PlanarSurface)
 
         try:
             self.daughter_disk = self.find_daughter_disk()
diff --git a/single.py b/single.py
index c1422448..4b90fa9b 100644
--- a/single.py
+++ b/single.py
@@ -1292,13 +1292,15 @@ def draw_new_position(self, dt, event_type):
         # Method self.draw_new_position_on_disk(..) is inherited from the parent class
         # Here we decide whether we use the position generated by this method, or still
         # post process it, based on whether the target plane has a daughter disk or not
-        # (we post process in the latter case by yet adding a random unbinding vector)
+        # (for the IV_INTERACTION event, when the particle actually undergoes a successful
+        #  interaction with the plane, we post-process the position by still 
+        #  adding a random unbinding vector)
         try:
             daughter_disk = self.testShell.daughter_disk
         except AttributeError:
             raise ShellmakingError('Could not make CylindricalSurfacePlanarSurfaceInteraction, %s' % str(e))
           
-        if daughter_disk == None:
+        if daughter_disk == None and event_type == EventType.IV_INTERACTION:
             
           # Get the position in the prolongation of the cylinder axis,
           # which we still have to post-process

From 782875d82811074a345eefc88b433a61f943371e Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 14 Nov 2016 16:14:34 +0100
Subject: [PATCH 1527/1541] Some better info output upon placing particles

---
 gfrdbase.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index f5adec65..e1094981 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -192,7 +192,7 @@ def get_closest_structure(world, pos, current_struct_id, ignores=[], structure_c
                   CuboidalRegion, PlanarSurface, CylindricalSurface, DiskSurface, SphericalSurface
     """
     sorted_close_structures = \
-            get_neighbor_structures(world, pos, current_struct_id, ignores, structure_class)
+            get_neighbor_structures(world, pos, current_struct_id, ignores, structure_class)    
 
     if sorted_close_structures != []:
         return sorted_close_structures[0]
@@ -710,8 +710,8 @@ def place_particle(world, sid, position):
         if not (surface and 
                 distance < TOLERANCE*radius and 
                 surface.id in structure_ids):
-            raise RuntimeError('  Placing particle failed: %s %s. Position should be in structure of structure_type \"%s\".' %
-                                  (sid, position, world.get_structure_type(species.structure_type_id)['name']) )
+            raise RuntimeError('  Placing particle failed: %s %s. Position should be in structure of structure_type \"%s\" (distance to %s = %s).' %
+                                  (sid, position, world.get_structure_type(species.structure_type_id)['name'], surface, distance) )
         else:
             structure_id = surface.id
 

From bb7b34cdac42d97137390b28dcf564921c197be3 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Fri, 3 Mar 2017 17:53:40 +0100
Subject: [PATCH 1528/1541] Fixes to failing typecast in binding of particle
 model

---
 binding/Model.hpp         | 45 +++++++++++++++++++++++++++++++++------
 binding/ParticleModel.hpp | 26 ++++++++++++++++++----
 2 files changed, 60 insertions(+), 11 deletions(-)

diff --git a/binding/Model.hpp b/binding/Model.hpp
index 5e659e5b..d3c64202 100644
--- a/binding/Model.hpp
+++ b/binding/Model.hpp
@@ -14,6 +14,40 @@ static void Model___setitem__(Timpl* model, std::string const& key, std::string
 }
 
 
+template<typename Tmodel_>
+struct rfr_attr
+{
+   typedef Tmodel_ impl_type;
+   typedef typename boost::remove_reference<typename impl_type::attributes_range>::type range_type;
+   typedef typename boost::range_const_iterator<range_type>::type result_type;
+
+   typedef peer::wrappers::stl_iterator_wrapper<result_type, boost::python::object> wrapper_type;
+
+   static PyObject* create_wrapper(boost::python::back_reference<const impl_type &> backref)
+   {
+      wrapper_type::__class_init__(typeid(result_type).name());
+      return wrapper_type::create(backref.get().attributes(), backref.source());
+   }
+};
+
+template<typename Tmodel_>
+struct rfr_species
+{
+   typedef Tmodel_ impl_type;
+   typedef typename boost::remove_reference<typename impl_type::species_type_range>::type range_type;
+   typedef typename boost::range_const_iterator<range_type>::type result_type;
+
+   typedef peer::wrappers::stl_iterator_wrapper<result_type, boost::python::object> wrapper_type;
+
+   static PyObject* create_wrapper(boost::python::back_reference<const impl_type &> backref)
+   {
+      wrapper_type::__class_init__(typeid(result_type).name());
+      return wrapper_type::create(backref.get().get_species_types(), backref.source());
+   }
+};
+
+
+
 ////// Registering master function
 template<typename Tmodel_>
 inline void register_model_class(char const* name)
@@ -35,16 +69,13 @@ inline void register_model_class(char const* name)
                 &impl_type::operator[], return_value_policy<copy_const_reference>())
         .def("__setitem__", &Model___setitem__<Tmodel_>)
         .add_property("attributes",
-                peer::util::range_from_range<
-                    typename impl_type::attributes_range,
-                    impl_type, &impl_type::attributes>())
+               boost::python::make_function(&rfr_attr<impl_type>::create_wrapper))
         .add_property("species_types",
-                peer::util::range_from_range<
-                    typename impl_type::species_type_range,
-                    impl_type, &impl_type::get_species_types>())
-        ;
+               boost::python::make_function(&rfr_species<impl_type>::create_wrapper))
+       ;
 }
 
 } // namespace binding
 
 #endif /* BINDING_MODEL_HPP */
+
diff --git a/binding/ParticleModel.hpp b/binding/ParticleModel.hpp
index 78f5f9ed..59ca17d2 100644
--- a/binding/ParticleModel.hpp
+++ b/binding/ParticleModel.hpp
@@ -7,6 +7,25 @@
 namespace binding {
 
 
+
+template<typename Tmodel_>
+struct rfr_structure
+{
+   typedef Tmodel_ impl_type;
+   typedef typename boost::remove_reference<typename impl_type::structure_types_range>::type range_type;
+   typedef typename boost::range_const_iterator<range_type>::type result_type;
+
+   typedef peer::wrappers::stl_iterator_wrapper<result_type, boost::python::object> wrapper_type;
+
+   static PyObject* create_wrapper(boost::python::back_reference<const impl_type &> backref)
+   {
+      wrapper_type::__class_init__(typeid(result_type).name());
+      return wrapper_type::create(backref.get().get_structure_types(), backref.source());
+   }
+};
+
+
+
 ////// Registering master function
 template<typename Tparticle_model_>
 inline void register_particle_model_class(char const* name)
@@ -20,12 +39,11 @@ inline void register_particle_model_class(char const* name)
         .def("get_structure_type_by_id", &impl_type::get_structure_type_by_id)
         .def("get_def_structure_type_id", &impl_type::get_def_structure_type_id)
         .add_property("structure_types",
-                peer::util::range_from_range<
-                    typename impl_type::structure_types_range,
-                    impl_type, &impl_type::get_structure_types>())
-        ;
+           boost::python::make_function(&rfr_structure<impl_type>::create_wrapper))
+       ;
 }
 
 } // namespace binding
 
 #endif /* BINDING_MODEL_HPP */
+

From 17a2aa91d9aa76262857a2f1a1e9f844963013d6 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Mon, 6 Mar 2017 15:39:15 +0100
Subject: [PATCH 1529/1541] Add CPP-flag '-std=gnu++98' as default for
 compilation

It seems that the current code can be compiled best on different
machines and systems with this setting (rather than newer standards).
---
 configure.ac | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/configure.ac b/configure.ac
index 965e13d5..1b422acc 100644
--- a/configure.ac
+++ b/configure.ac
@@ -35,7 +35,7 @@ else
 fi
 AC_SUBST(DEBUG)
 
-CXXFLAGS="$CXXFLAGS -Wall"
+CXXFLAGS="$CXXFLAGS -std=gnu++98 -Wall"
 
 AX_BOOST_BASE([1.37],,AC_MSG_ERROR([could not find required version of BOOST.]))
 

From f3ae176a4a47a9fffd5f97408ad0f31f628308cc Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 7 Mar 2017 16:06:39 +0100
Subject: [PATCH 1530/1541] Add a method to quickly remove all particles from
 the simulator

---
 gfrdbase.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/gfrdbase.py b/gfrdbase.py
index e1094981..60fb432c 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -33,6 +33,7 @@
     'p_free',
     'throw_in_particles',
     'place_particle',
+    'remove_all_particles',
     'NoSpace',
     'create_world',
     'create_box',
@@ -731,6 +732,17 @@ def place_particle(world, sid, position):
     return particle
 
 
+def remove_all_particles(world):
+
+    all_particles = list(world)
+    # Keep in mind that the entries of this list 
+    # are actually pid_particle_pairs
+
+    for p in all_particles:
+
+        world.remove_particle(p[0])
+
+
 class DomainEvent(_gfrd.Event):
     __slot__ = ['data']
     def __init__(self, time, domain):

From 28d18424810d670709287c0d50c563686cc15704 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 7 Mar 2017 16:07:10 +0100
Subject: [PATCH 1531/1541] Fix coordinate mapping in TIRViE visualizer

It did not show eGFRD planes correctly in some situations because
VPython uses a slightly different coordinate convention as eGFRD.
---
 visualization/TIRViE.py | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index 76248095..8738945b 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -790,10 +790,16 @@ def process_boxes(self, boxes=[], color_list=[]):
             # Planes don't have half_extent[2].
             dz = ALMOST_ZERO
                             
-        orientation_ux = self.to_vector(box.unit_x) # we take the x-axis to be "length"
+        # Now construct the corresponding vectors in VPython coordinates
+        # Here we have to take into account that the orientation vector for boxes in
+        # VPython is aligned with the x-axis, while for eGFRD planes it is aligned 
+        # with the z-axis; this is why we have to make the z-axis of eGFRD the x-axis
+        # of the box in VPython
+        orientation_ux = self.to_vector(box.unit_z) # we take the x-axis to be "length"
         orientation_uy = self.to_vector(box.unit_y) # we also want the other vectors to be able 
-        orientation_uz = self.to_vector(box.unit_z) # to fully construct the box when needed
-        size = (2.0 * box.half_extent[0], 2.0 * box.half_extent[1], 2.0 * dz)
+        orientation_uz = self.to_vector(box.unit_x) # to fully construct the box when needed
+
+        size = (2.0 * dz, 2.0 * box.half_extent[1], 2.0 * box.half_extent[0])
         
         position_list.append(position)
         orientation_list.append( [orientation_ux, orientation_uy, orientation_uz] )
@@ -829,13 +835,13 @@ def draw_planar_surfaces(self, position_list, orientation_list, size_list, color
       # TODO Check that lists all have the same length
       for n in range(len(position_list)):
         
-          orientation_ux, _, _ = orientation_list[n]
+          orientation_ux, orientation_uy, orientation_uz = orientation_list[n]
           
           if not(self.WIREFRAME_PLANES):
             # Standard planes are treated as boxes with inifinitesimal length in one of the three directions
             plane = v.box(pos=position_list[n], axis=orientation_ux, size=size_list[n], color=color_list[n], opacity=self.PLANAR_SURFACES_OPACITY)
           else:
-            plane = box = self.wireframe_box(pos=position_list[n], orientation=orientation_list[n], size=size_list[n], color=color_list[n], radius=self.WIREFRAME_RADIUS)
+            plane = self.wireframe_box(pos=position_list[n], orientation=orientation_list[n], size=size_list[n], color=color_list[n], radius=self.WIREFRAME_RADIUS)
             
           self.objects.append(plane)
   
@@ -1103,4 +1109,4 @@ def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, ca
                                                       capture=capture, capture_dir=capture_dir, \
                                                       particle_radius_factor=particle_radius_factor, cyl_radius_factor=cyl_radius_factor)
                                                       
-    
\ No newline at end of file
+    

From a0be9e3e63f4fabc0ca1fd2225e4c26704237c0d Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 8 Mar 2017 18:51:38 +0100
Subject: [PATCH 1532/1541] Allow to selectively remove particles of a certain
 species

---
 gfrdbase.py | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/gfrdbase.py b/gfrdbase.py
index 60fb432c..83377093 100644
--- a/gfrdbase.py
+++ b/gfrdbase.py
@@ -732,15 +732,23 @@ def place_particle(world, sid, position):
     return particle
 
 
-def remove_all_particles(world):
+def remove_all_particles(world, species=None):
 
-    all_particles = list(world)
-    # Keep in mind that the entries of this list 
-    # are actually pid_particle_pairs
+    if species == None:
 
-    for p in all_particles:
+        all_particles = list(world)
+        # Keep in mind that the entries of this list 
+        # are actually pid_particle_pairs
 
-        world.remove_particle(p[0])
+        for p in all_particles:
+
+            world.remove_particle(p[0])
+            # p[0] is the particle ID, see comment above
+    else:
+
+        for pid in world.get_particle_ids(species):
+
+            world.remove_particle(pid)
 
 
 class DomainEvent(_gfrd.Event):

From cf3487edcbaae5f0863c052968255b15df18fc88 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Wed, 8 Mar 2017 18:52:21 +0100
Subject: [PATCH 1533/1541] Methods for (un)setting the BD_ONLY_FLAG in eGFRD
 simulator

(for testing/profiling)
---
 egfrd.py | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index ddd2c716..dc3adcfd 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -3879,9 +3879,9 @@ def load_state(self, filename):
         self.t = time_info[0]
 
 
-    ###############################
-    #### METHODS FOR DEBUGGING ####
-    ###############################
+    #########################################
+    #### METHODS FOR DEBUGGING & TESTING ####
+    #########################################
     def dump_scheduler(self):
         """Dump scheduler information.
 
@@ -3914,6 +3914,15 @@ def count_domains(self):
 
         return (num_singles, num_pairs, num_multis)
 
+    def set_BD_only(self):
+
+        self.BD_ONLY_FLAG = True
+
+    def unset_BD_only(self):
+
+        self.BD_ONLY_FLAG = False
+
+
     dispatch = [
         (Single, process_single_event),
         (Pair, process_pair_event),

From 4e50508d49ea63787746b35c3fc30f5f7795046b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Thu, 30 Mar 2017 13:13:59 +0200
Subject: [PATCH 1534/1541] Small fix

---
 egfrd.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index dc3adcfd..00ad8706 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -2241,13 +2241,12 @@ def update_single(self, single):
         # The method only works for NonInteractionSingles
         assert isinstance(single, NonInteractionSingle)
 
-        singlepos = single.pid_particle_pair[1].position    # TODO get the position as an argument
-
+        single_pos = single.pid_particle_pair[1].position    # TODO get the position as an argument
 
         # Create a new updated shell
         # If this does not work for some reason an exception is risen;
         # then make_new_domain() will make a Multi as a default fallback
-        new_shell = single.create_updated_shell(singlepos)
+        new_shell = single.create_updated_shell(single_pos)
         assert new_shell, 'Method single.create_updated_shell() returned None.'
 
         # Replace shell in domain and geometrycontainer.

From 987bb3dc97d7d9a02dd695de07343dbd4efa8f74 Mon Sep 17 00:00:00 2001
From: Seynen <m.seynen@amolf.nl>
Date: Wed, 7 Jun 2017 10:40:53 +0200
Subject: [PATCH 1535/1541] Fix for GCC 4.9 and above (template arg deduction
 error in range_from_range).  (#112)

* Fix error 'could not convert template argument' for GCC compiler version > 4.8 (tested on 4.9 and 5.4)
* Minor but important fixes: correct integral types, verify instead of assert, tab/spaces in py files, div-0 check, index-out-of-range check.
* Fix for GCC 6.2
* made make_table compatible with python 3
* Revert "Fixed 'narrowing'-warning."
This reverts commit 02963e840e5ea552a62a52f09337434be5cb2a57.
* Removed unused enumeration variables (side_enum_type)
* Commented out failing Python UnitTests.
* Removed unused variables/types (less warnings).
* Added structure ID to CylindericalSurface tests.
* Added structure Type to PlanarSurface_test.
* Updated unittest to use the most current BDSimulator.
* GreensFunction input variables update.
* Update to run cpp tests using one file.
* Removed empty file.
* Added more working CPP unittests.

Closes #110, Closes #111
---
 EGFRDSimulator.hpp                  |  2 +-
 GreensFunction1DAbsSinkAbs.cpp      |  4 +-
 GreensFunction2DRadAbs.cpp          |  2 +-
 GreensFunction2DRadAbs.hpp          |  2 +-
 MatrixSpace.hpp                     |  4 +-
 World.hpp                           |  4 +-
 binding/Model.hpp                   | 44 ++++++++++++++++---
 binding/ParticleModel.hpp           | 25 +++++++++--
 configure.ac                        |  2 +-
 egfrd.py                            |  4 +-
 logger.py                           |  2 +-
 make_cjy_table.py                   |  4 +-
 make_sjy_table.py                   |  4 +-
 pair.py                             | 16 +++++--
 test/EGFRDSimulator_test.py         |  0
 test/GreensFunction1DAbsAbs_test.py | 68 ++++++++++++++---------------
 test/GreensFunction1DRadAbs_test.py | 34 +++++++--------
 17 files changed, 138 insertions(+), 83 deletions(-)
 mode change 100755 => 100644 test/EGFRDSimulator_test.py

diff --git a/EGFRDSimulator.hpp b/EGFRDSimulator.hpp
index 9d8b417b..a961b27e 100644
--- a/EGFRDSimulator.hpp
+++ b/EGFRDSimulator.hpp
@@ -976,7 +976,7 @@ class EGFRDSimulator: public ParticleSimulator<Ttraits_>
 
     std::pair<shell_id_type, shell_variant_type> get_shell(shell_id_type const& id)
     {
-        shell_variant_type result;
+        shell_variant_type result(boost::none);
         boost::fusion::for_each(smatm_, shell_finder(id, result));
         return std::make_pair(id, result);
     }
diff --git a/GreensFunction1DAbsSinkAbs.cpp b/GreensFunction1DAbsSinkAbs.cpp
index 1f70b330..943efc40 100644
--- a/GreensFunction1DAbsSinkAbs.cpp
+++ b/GreensFunction1DAbsSinkAbs.cpp
@@ -508,7 +508,7 @@ Real GreensFunction1DAbsSinkAbs::flux_leaves(Real t) const
         return 0.0;
     }
 
-    const Real maxi( guess_maxi( t ) );
+    const uint maxi( guess_maxi( t ) );
 
     if( getr0() >= getrsink() )
         return flux_abs_Ll( t, maxi );
@@ -525,7 +525,7 @@ Real GreensFunction1DAbsSinkAbs::flux_leavea(Real t) const
         return 0.0;
     }
 
-    const Real maxi( guess_maxi( t ) );
+    const uint maxi( guess_maxi( t ) );
 
     if( getr0() < getrsink() )
         return - flux_abs_Ll( t, maxi );
diff --git a/GreensFunction2DRadAbs.cpp b/GreensFunction2DRadAbs.cpp
index 544c10ee..8a4509f9 100644
--- a/GreensFunction2DRadAbs.cpp
+++ b/GreensFunction2DRadAbs.cpp
@@ -480,7 +480,7 @@ const void GreensFunction2DRadAbs::GiveRootIntervalSimple(
             Real& low,          // Variable to return left boundary interval
             Real& high,         // Variable to return right boundary interval
             const Integer n,    // Order of Bessel functions
-            const Real i) const // ith root 
+            const Integer i) const // ith root 
 {
     // Offset is simply based on previous root, the interval in which the first 
     // root (i=0) lies is never calculated with this function.
diff --git a/GreensFunction2DRadAbs.hpp b/GreensFunction2DRadAbs.hpp
index e123d05c..06b2870e 100644
--- a/GreensFunction2DRadAbs.hpp
+++ b/GreensFunction2DRadAbs.hpp
@@ -154,7 +154,7 @@ class GreensFunction2DRadAbs
                                                                     
 
     const void GiveRootIntervalSimple(  Real& low, Real& high, 
-                                        const Integer n, const Real i
+                                        const Integer n, const Integer i
                                      ) const;
 
     const Real getAlphaRoot0( const Real low,
diff --git a/MatrixSpace.hpp b/MatrixSpace.hpp
index 3851dca9..9933ad32 100644
--- a/MatrixSpace.hpp
+++ b/MatrixSpace.hpp
@@ -286,7 +286,7 @@ class MatrixSpace
 
         typename all_values_type::size_type const old_index(i - values_.begin());
 
-        BOOST_ASSERT(cell(index((*i).second.position())).erase(old_index));
+        BOOST_VERIFY(cell(index((*i).second.position())).erase(old_index));
         rmap_.erase((*i).first);
 
         typename all_values_type::size_type const last_index(values_.size() - 1);
@@ -295,7 +295,7 @@ class MatrixSpace
         {
             value_type const& last(values_[last_index]);
             cell_type& old_c(cell(index(last.second.position())));
-            BOOST_ASSERT(old_c.erase(last_index));
+            BOOST_VERIFY(old_c.erase(last_index));
             old_c.push(old_index);
             rmap_[last.first] = old_index;
             reinterpret_cast<nonconst_value_type&>(*i) = last; 
diff --git a/World.hpp b/World.hpp
index de18ec81..dda8b34c 100644
--- a/World.hpp
+++ b/World.hpp
@@ -308,7 +308,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
 
         // The particle didn't exist yet
-        BOOST_ASSERT(base_type::update_particle(pi_pair));                              // update particle
+        BOOST_VERIFY(base_type::update_particle(pi_pair));                              // update particle
         particle_pool_[pi_pair.second.sid()].insert(pi_pair.first);                     // update species->particles map
         particleonstruct_pool_[pi_pair.second.structure_id()].insert(pi_pair.first);    // update structure->particles map
         return true;
@@ -406,7 +406,7 @@ class World: public ParticleContainerBase<World<Ttraits_>, Ttraits_>
         }
 
         // The structure was not yet in the world.
-        BOOST_ASSERT(base_type::update_structure(structid_pair));
+        BOOST_VERIFY(base_type::update_structure(structid_pair));
         // update the mapping 'structure_type_id -> set of structure ids'
         structure_pool_[structid_pair.second->sid()].insert(structid_pair.first);
         // create a new mapping from structure id -> set of particles
diff --git a/binding/Model.hpp b/binding/Model.hpp
index 5e659e5b..fca9ec5b 100644
--- a/binding/Model.hpp
+++ b/binding/Model.hpp
@@ -14,6 +14,40 @@ static void Model___setitem__(Timpl* model, std::string const& key, std::string
 }
 
 
+template<typename Tmodel_>
+struct rfr_attr
+{
+   typedef Tmodel_ impl_type;
+   typedef typename boost::remove_reference<typename impl_type::attributes_range>::type range_type;
+   typedef typename boost::range_const_iterator<range_type>::type result_type;
+
+   typedef peer::wrappers::stl_iterator_wrapper<result_type, boost::python::object> wrapper_type;
+
+   static PyObject* create_wrapper(boost::python::back_reference<const impl_type &> backref)
+   {
+      wrapper_type::__class_init__(typeid(result_type).name());
+      return wrapper_type::create(backref.get().attributes(), backref.source());
+   }
+};
+
+template<typename Tmodel_>
+struct rfr_species
+{
+   typedef Tmodel_ impl_type;
+   typedef typename boost::remove_reference<typename impl_type::species_type_range>::type range_type;
+   typedef typename boost::range_const_iterator<range_type>::type result_type;
+
+   typedef peer::wrappers::stl_iterator_wrapper<result_type, boost::python::object> wrapper_type;
+
+   static PyObject* create_wrapper(boost::python::back_reference<const impl_type &> backref)
+   {
+      wrapper_type::__class_init__(typeid(result_type).name());
+      return wrapper_type::create(backref.get().get_species_types(), backref.source());
+   }
+};
+
+
+
 ////// Registering master function
 template<typename Tmodel_>
 inline void register_model_class(char const* name)
@@ -35,14 +69,10 @@ inline void register_model_class(char const* name)
                 &impl_type::operator[], return_value_policy<copy_const_reference>())
         .def("__setitem__", &Model___setitem__<Tmodel_>)
         .add_property("attributes",
-                peer::util::range_from_range<
-                    typename impl_type::attributes_range,
-                    impl_type, &impl_type::attributes>())
+               boost::python::make_function(&rfr_attr<impl_type>::create_wrapper))
         .add_property("species_types",
-                peer::util::range_from_range<
-                    typename impl_type::species_type_range,
-                    impl_type, &impl_type::get_species_types>())
-        ;
+               boost::python::make_function(&rfr_species<impl_type>::create_wrapper))
+       ;
 }
 
 } // namespace binding
diff --git a/binding/ParticleModel.hpp b/binding/ParticleModel.hpp
index 78f5f9ed..083f3c5e 100644
--- a/binding/ParticleModel.hpp
+++ b/binding/ParticleModel.hpp
@@ -7,6 +7,25 @@
 namespace binding {
 
 
+
+template<typename Tmodel_>
+struct rfr_structure
+{
+   typedef Tmodel_ impl_type;
+   typedef typename boost::remove_reference<typename impl_type::structure_types_range>::type range_type;
+   typedef typename boost::range_const_iterator<range_type>::type result_type;
+
+   typedef peer::wrappers::stl_iterator_wrapper<result_type, boost::python::object> wrapper_type;
+
+   static PyObject* create_wrapper(boost::python::back_reference<const impl_type &> backref)
+   {
+      wrapper_type::__class_init__(typeid(result_type).name());
+      return wrapper_type::create(backref.get().get_structure_types(), backref.source());
+   }
+};
+
+
+
 ////// Registering master function
 template<typename Tparticle_model_>
 inline void register_particle_model_class(char const* name)
@@ -20,10 +39,8 @@ inline void register_particle_model_class(char const* name)
         .def("get_structure_type_by_id", &impl_type::get_structure_type_by_id)
         .def("get_def_structure_type_id", &impl_type::get_def_structure_type_id)
         .add_property("structure_types",
-                peer::util::range_from_range<
-                    typename impl_type::structure_types_range,
-                    impl_type, &impl_type::get_structure_types>())
-        ;
+           boost::python::make_function(&rfr_structure<impl_type>::create_wrapper))
+       ;
 }
 
 } // namespace binding
diff --git a/configure.ac b/configure.ac
index 965e13d5..1b422acc 100644
--- a/configure.ac
+++ b/configure.ac
@@ -35,7 +35,7 @@ else
 fi
 AC_SUBST(DEBUG)
 
-CXXFLAGS="$CXXFLAGS -Wall"
+CXXFLAGS="$CXXFLAGS -std=gnu++98 -Wall"
 
 AX_BOOST_BASE([1.37],,AC_MSG_ERROR([could not find required version of BOOST.]))
 
diff --git a/egfrd.py b/egfrd.py
index 6fa7972f..8ea17d72 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -508,7 +508,7 @@ def step(self):
             domain_counts = self.count_domains()
             log.info('\n\n%d: t=%s dt=%e (next_time=%s)\t' %
                      (self.step_counter, self.t,
-                      self.dt, self.scheduler.top[1].time) + 
+                      self.dt, self.scheduler.top[1].time if self.scheduler.size > 0 else 0) + 
                      'Singles: %d, Pairs: %d, Multis: %d\n' % domain_counts + 
                      'event=#%d reactions=%d rejectedmoves=%d' %
                      (id, self.reaction_events, self.rejected_moves))
@@ -541,7 +541,7 @@ def step(self):
         if __debug__:
             if self.dt < 1e-10: # We consider 0.1 nanoseconds a zero-step
 
-                log.warning('dt = %e = %.10e-%.10e = zero step, working in s.t >> dt~0 Python limit.' % (self.dt, next_time, self.t))
+                # log.warning('dt = %e = %.10e-%.10e = zero step, working in s.t >> dt~0 Python limit.' % (self.dt, next_time, self.t))
                 self.zero_steps += 1
 
                 if self.zero_steps >= max(self.scheduler.size * 3, self.MAX_NUM_DT0_STEPS): 
diff --git a/logger.py b/logger.py
index 611fa2c9..f0355f4e 100644
--- a/logger.py
+++ b/logger.py
@@ -5,7 +5,7 @@
 import numpy
 
 import logging
-import h5py # added by sakurai@advancesoft.jp
+#import h5py # added by sakurai@advancesoft.jp
 from egfrd import Single, Pair, Multi # added by sakurai@advancesoft.jp
 
 __all__ = [
diff --git a/make_cjy_table.py b/make_cjy_table.py
index 42b14a5a..24f8347c 100644
--- a/make_cjy_table.py
+++ b/make_cjy_table.py
@@ -196,7 +196,7 @@ def write_table(file, name, N, x_start, delta_x):
         jdot = jdot_table[n][start:end]
         write_arrays(file, 'cj_table%d_f' % n, j, jdot)
         write_table(file, 'cj_table%d' % n, end-start, z_start, delta_z)
-    print 'j', len(j)
+    print('j', len(j))
 
     # y
     for n in range(minn_y, maxn_y + 1):
@@ -209,7 +209,7 @@ def write_table(file, name, N, x_start, delta_x):
         write_arrays(file, 'cy_table%d_f' % n, y, ydot)
         write_table(file, 'cy_table%d' % n, end-start, z_start, delta_z)
 
-    print 'y', len(y)
+    print('y', len(y))
 
     write_table_array(file, 'cj_table', minn_j, maxn_j)
     write_table_array(file, 'cy_table', minn_y, maxn_y)
diff --git a/make_sjy_table.py b/make_sjy_table.py
index 83c63001..493d7e59 100644
--- a/make_sjy_table.py
+++ b/make_sjy_table.py
@@ -231,7 +231,7 @@ def write_table(file, name, N, x_start, delta_x):
         jdot = jdot_table[n][start:end]
         write_arrays(file, 'sj_table%d_f' % n, j, jdot)
         write_table(file, 'sj_table%d' % n, end-start, z_start, delta_z)
-    print 'j', len(j)
+    print('j', len(j))
 
     # y
     for n in range(minn_y, maxn_y + 1):
@@ -244,7 +244,7 @@ def write_table(file, name, N, x_start, delta_x):
         write_arrays(file, 'sy_table%d_f' % n, y, ydot)
         write_table(file, 'sy_table%d' % n, end-start, z_start, delta_z)
 
-    print 'y', len(y)
+    print('y', len(y))
 
     write_table_array(file, 'sj_table', minn_j, maxn_j)
     write_table_array(file, 'sy_table', minn_y, maxn_y)
diff --git a/pair.py b/pair.py
index 4f537657..5b044004 100644
--- a/pair.py
+++ b/pair.py
@@ -262,8 +262,12 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
             log.warn('Particles live on different structures in StandardPair, structure1=%s, structure2=%s' \
                                                                                % (structure1, structure2) )
         D_tot = D1 + D2
-        pos1 = com - iv * (D1 / D_tot)
-        pos2 = com + iv * (D2 / D_tot)
+        if (D_tot != 0):
+            pos1 = com - iv * (D1 / D_tot)
+            pos2 = com + iv * (D2 / D_tot)
+        else:
+            pos1 = com - iv * 0.5
+            pos2 = com + iv * 0.5
 
         return pos1, pos2, structure1.id, structure2.id
 
@@ -378,8 +382,12 @@ def do_back_transform(cls, com, iv, D1, D2, radius1, radius2, structure1, struct
         assert(structure1.id == structure2.id)
 
         D_tot = D1 + D2
-        pos1 = com - iv * (D1 / D_tot)
-        pos2 = com + iv * (D2 / D_tot)
+        if (D_tot != 0):
+            pos1 = com - iv * (D1 / D_tot)
+            pos2 = com + iv * (D2 / D_tot)
+        else:
+            pos1 = com - iv * 0.5
+            pos2 = com + iv * 0.5
 
         return pos1, pos2, structure1.id, structure2.id
 
diff --git a/test/EGFRDSimulator_test.py b/test/EGFRDSimulator_test.py
old mode 100755
new mode 100644
diff --git a/test/GreensFunction1DAbsAbs_test.py b/test/GreensFunction1DAbsAbs_test.py
index 1eb8998c..9f962f18 100755
--- a/test/GreensFunction1DAbsAbs_test.py
+++ b/test/GreensFunction1DAbsAbs_test.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python
 
 __author__    = 'Laurens Bossen, Thomas Sokolowski'
 __copyright__ = ''
@@ -23,9 +23,9 @@ def tearDown( self ):
 
     def test_Instantiation( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 2e-7
-	r0 = L/2
+        r0 = L/2
 
         gf = mod.GreensFunction1DAbsAbs( D, v, r0, L )
         self.failIf( gf == None )
@@ -33,7 +33,7 @@ def test_Instantiation( self ):
 
     def test_DrawTime( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 2e-7
         r0 = 5e-8
 
@@ -41,25 +41,25 @@ def test_DrawTime( self ):
 
         t = gf.drawTime( 0.5 )
         self.failIf( t <= 0.0 or t >= numpy.inf )
-	print " "
-	print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
+        print " "
+        print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
 
         t = gf.drawTime( 0.0 )
         self.failIf( t < 0.0 or t >= numpy.inf )
-	print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
+        print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
 
         t = gf.drawTime( 1e-16 )
         self.failIf( t <= 0.0 or t >= numpy.inf )
-	print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
+        print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
 
         t = gf.drawTime( 1 - 1e-16 )
         self.failIf( t <= 0.0 or t >= numpy.inf )
-	print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
+        print "GreensFunction1DAbsAbs_test.py : test_DrawTime : t =",t
 
 
     def test_DrawTime_a_equal_sigma( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 0.0
         r0 = L
 
@@ -69,13 +69,13 @@ def test_DrawTime_a_equal_sigma( self ):
 
         t = gf.drawTime( 0.5 )
         self.assertEqual( 0.0, t )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawTime_a_equal_sigma : t =",t
 
 
     def test_DrawTime_a_near_sigma( self ):
         D = 1e-12
-	v = 0	
+        v = 0        
         L = 2e-14
         r0 = L/2
 
@@ -83,13 +83,13 @@ def test_DrawTime_a_near_sigma( self ):
 
         t = gf.drawTime( 0.5 )
         self.failIf( t <= 0.0 or t >= numpy.inf )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawTime_a_near_sigma : t =",t
 
 
     def test_DrawTime_r0_equal_a( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 2e-7
         r0 = L
 
@@ -97,13 +97,13 @@ def test_DrawTime_r0_equal_a( self ):
 
         t = gf.drawTime( 0.5 )
         self.assertEqual( 0.0, t )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawTime_r0_equal_a : t =",t
 
 
     def test_DrawTime_r0_equal_sigma( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 1e-7
         r0 = 0
 
@@ -111,13 +111,13 @@ def test_DrawTime_r0_equal_sigma( self ):
 
         t = gf.drawTime( 0.5 )
         self.failIf( t < 0.0 or t >= numpy.inf )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawTime_r0_equal_sigma : t =",t
 
 
     def test_DrawEventType( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 2e-7
         r0 = L/2
 
@@ -126,8 +126,8 @@ def test_DrawEventType( self ):
         t = gf.drawTime( 0.5 )
         eventType = gf.drawEventType( 0.5, t )
         self.failIf( eventType != 12 and eventType != 13 and eventType != 14 )
-	print " "
-	print "GreensFunction1DAbsAbs_test.py : test_DrawEventType : eventType =",eventType
+        print " "
+        print "GreensFunction1DAbsAbs_test.py : test_DrawEventType : eventType =",eventType
 
         eventType = gf.drawEventType( 0.999999, t )
         self.assertEqual( eventType, 13 ) # ESCAPE
@@ -138,7 +138,7 @@ def test_DrawEventType( self ):
 
     def no_test_DrawEventType_smallt( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 2e-6
         r0 = L/2
 
@@ -148,7 +148,7 @@ def no_test_DrawEventType_smallt( self ):
 
         eventType = gf.drawEventType( 0.5, t )
         self.failIf( eventType != 12 and eventType != 13 and eventType != 14 )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawEventType_smallt : eventType =",eventType
 
         eventType = gf.drawEventType( 0.9999, t )
@@ -160,7 +160,7 @@ def no_test_DrawEventType_smallt( self ):
 
     def test_DrawR( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 2e-7
         r0 = L/2
 
@@ -179,14 +179,14 @@ def test_DrawR( self ):
 
         self.assertAlmostEqual( r1, 0 )
         self.assertAlmostEqual( r2, L )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawR : r1 =",r1
         print "GreensFunction1DAbsAbs_test.py : test_DrawR : r2 =",r2
 
 
     def test_DrawR_zerot( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 1e-7
         r0 = L/2
 
@@ -196,30 +196,30 @@ def test_DrawR_zerot( self ):
 
         r = gf.drawR( 0.5, t )
         self.assertEqual( r0, r )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawR_zerot : r =",r
 
 
     def test_DrawR_r0_equal_sigma( self ):
         D = 1e-12
-	v = 0
+        v = 0
         L = 2e-7
         r0 = 0
 
         t = 0.0#1e-3
 
         gf = mod.GreensFunction1DAbsAbs( D, v, r0, L )       
-       	
-	# This raises an exception, which at this point we cannot catch
+               
+        # This raises an exception, which at this point we cannot catch
         # r = gf.drawR( 0.5, t )
         # self.failIf( r < 0 or r > L )
 
     def test_DrawR_squeezed( self ):
 
         D = 1e-12
-	v = 0
+        v = 0
         L = 0.02e-8
-	r0 = L/2
+        r0 = L/2
 
         gf = mod.GreensFunction1DAbsAbs( D, v, r0, L )        
 
@@ -232,12 +232,12 @@ def test_DrawR_squeezed( self ):
 
         # near s
         r0 = 0.0001e-8
-	gf.setr0 ( r0 )        
+        gf.setr0 ( r0 )        
         r = gf.drawR( 0.502, t )
         self.failIf( r < 0 or r > L )
-	print " "
+        print " "
         print "GreensFunction1DAbsAbs_test.py : test_DrawR_squeezed : 1st drawn r =",r
-	
+        
         # near a
         r0 = L - 0.0001e-8
         gf.setr0 ( r0 )
diff --git a/test/GreensFunction1DRadAbs_test.py b/test/GreensFunction1DRadAbs_test.py
index d39115a2..83fec7a8 100755
--- a/test/GreensFunction1DRadAbs_test.py
+++ b/test/GreensFunction1DRadAbs_test.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python
 
 __author__    = 'Laurens Bossen, Thomas Sokolowski'
 __copyright__ = ''
@@ -21,10 +21,10 @@ def tearDown( self ):
 
     def test_Instantiation( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-7
-	r0 = L/2
+        r0 = L/2
 
         gf = mod.GreensFunction1DRadAbs( D, kf, v, r0, L )
         self.failIf( gf == None )
@@ -32,7 +32,7 @@ def test_Instantiation( self ):
 
     def test_DrawTime( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-7
         r0 = 5e-8
@@ -55,7 +55,7 @@ def test_DrawTime( self ):
 
     def test_DrawTime_a_equal_sigma( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 0
         r0 = L
@@ -69,7 +69,7 @@ def test_DrawTime_a_equal_sigma( self ):
 
     def test_DrawTime_a_near_sigma( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-14
         r0 = L/2
@@ -86,7 +86,7 @@ def test_DrawTime_a_near_sigma( self ):
 
     def test_DrawTime_r0_equal_a( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-7
         r0 = L
@@ -101,14 +101,14 @@ def test_DrawTime_r0_equal_a( self ):
 
     def test_DrawTime_r0_equal_sigma_kf_zero( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 0.0 # note this
         L = 1e-7
         r0 = 0
 
         gf = mod.GreensFunction1DRadAbs( D, kf, v, r0, L )
 
-        t = gf.drawTime( 0.5 )				# This does not converge for negative v ~< -1e-16
+        t = gf.drawTime( 0.5 )                                # This does not converge for negative v ~< -1e-16
         self.failIf( t < 0.0 or t >= numpy.inf )
         print " "
         print "GreensFunction1DRadAbs_test.py : test_DrawTime_r0_equal_sigma_kf_zero : t =",t
@@ -116,7 +116,7 @@ def test_DrawTime_r0_equal_sigma_kf_zero( self ):
 
     def no_test_DrawTime_r0_equal_sigma_kf_large( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 20e-7
         r0 = 1e-12
@@ -131,7 +131,7 @@ def no_test_DrawTime_r0_equal_sigma_kf_large( self ):
 
     def test_DrawEventType( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-7
         r0 = L/2
@@ -153,7 +153,7 @@ def test_DrawEventType( self ):
 
     def no_test_DrawEventType_smallt( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-6
         r0 = L/2
@@ -176,7 +176,7 @@ def no_test_DrawEventType_smallt( self ):
 
     def test_DrawR( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-7
         r0 = L/2
@@ -203,7 +203,7 @@ def test_DrawR( self ):
 
     def test_DrawR_zerot( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 1e-7
         r0 = L/2
@@ -220,7 +220,7 @@ def test_DrawR_zerot( self ):
 
     def test_DrawR_r0_equal_sigma( self ):
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 2e-7
         r0 = 0
@@ -236,10 +236,10 @@ def test_DrawR_r0_equal_sigma( self ):
     def test_DrawR_squeezed( self ):
 
         D = 1e-12
-	v = -3e-8
+        v = -3e-8
         kf = 1e-8
         L = 0.02e-8
-	r0 = L/2
+        r0 = L/2
 
         gf = mod.GreensFunction1DRadAbs( D, kf, v, r0, L )
 

From d8954a5373ab7a3bc9cbd0eeaa535c70009b91a2 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <tsokolowski@bigshot.ista.local>
Date: Thu, 8 Jun 2017 14:30:26 +0200
Subject: [PATCH 1536/1541] Small changes to allow for correct resetting of
 BD_ONLY_FLAG upon reloading and recording of total simulated time

This is to avoid that "BD only" simulations will not be carried out
correctly when there are load-save interrupts on the way.

Also, we now allow to specify whether the last time of the load file
should be used as a starting time or not, and to monitor the total
simulated time using the given instance of the simulator.
---
 egfrd.py | 39 +++++++++++++++++++++++++++++++--------
 1 file changed, 31 insertions(+), 8 deletions(-)

diff --git a/egfrd.py b/egfrd.py
index 00ad8706..f58eec0e 100644
--- a/egfrd.py
+++ b/egfrd.py
@@ -382,13 +382,14 @@ def __init__(self, world, rng=myrandom.rng, network_rules=None, reset=True):
                                                 # Make sure that DEFAULT_STEP_SIZE_FACTOR < MULTI_SHELL_FACTOR, or else the 
                                                 # reaction volume sticks out of the multi. 
 
-        self.BD_ONLY_FLAG = False               # Will force the algorithm into Multi-creation, i.e. always to use BD
-                                                # Take care: This is for testing only! Keep this 'False' for normal sims!
-
         self.BD_DT_HARDCORE_MIN = +1e-9         # This is to define a hardcore lower bound for the timestep that will be
                                                 # dynamically determined by the new BD scheme. It will prevent the algorithm
                                                 # to calculate ridiculously small timesteps, but will break detail balance.
                                                 # Take care: This is for testing only! Keep this at a negative value for normal sims!
+	if reset:
+      		self.BD_ONLY_FLAG = False       # Will force the algorithm into Multi-creation, i.e. always to use BD
+                                        	# Take care: This is for testing only! Keep this 'False' for normal sims!
+						# (However, we want to retain user-set values if the __init__ is not a reset)
 
         self.REMOVE_OVERLAPS = True             # Ignore overlaps, only warn when they happen and move particles apart
         self.max_overlap_error = 0.0            # This remembers the largest relative error produced by removing overlaps
@@ -453,7 +454,9 @@ def reset(self):
         run before starting the "real experiment".
         """ #~ MW
         self.t = 0.0        
-        self.dt = 0.0        
+        self.dt = 0.0
+	self.t0 = self.t # Saves the starting time before the first event was fired
+			 # Can be reset when loading a state via load_state()
         self.step_counter = 0
         self.single_steps = {EventType.SINGLE_ESCAPE:0,
                              EventType.SINGLE_REACTION:0,
@@ -486,6 +489,8 @@ def reset(self):
         self.last_event = None
         self.last_reaction = None
 
+	self.t0 = 0.0
+
         self.is_dirty = True            # simulator needs to be re-initialized
 
 
@@ -3148,6 +3153,8 @@ def print_report(self, out=None):
 
         report = '''
 t = %g
+t0 = %g
+sim. time: %g
 \tNonmulti: %g\tMulti: %g
 steps: %d 
 updates: %d
@@ -3162,7 +3169,10 @@ def print_report(self, out=None):
 overlap remover was: %s
 max. overlap error:  %g
 ''' \
-            % (self.t, self.nonmulti_time, self.multi_time,
+            % (self.t, 
+	       self.t0,
+	       self.t - self.t0,
+	       self.nonmulti_time, self.multi_time,
                self.step_counter, total_steps,
                single_steps,
                (100.0*single_steps) / total_steps,
@@ -3845,16 +3855,26 @@ def save_state(self, filename, reload=False, delay=0.0):
             if(delay > 0.0):
                     sleep(delay)
 
-            self.load_state(filename)
+            self.load_state(filename, reset_t0=False)
+	    # When reloading to continue the simulation, we
+	    # want to make sure that the recorded starting time
+	    # is not overwritten
 
 
-    def load_state(self, filename):
+    def load_state(self, filename, reset_t0=True):
         """ Load a state previously saved via save_state()
             and re-initialize the simulator with the loaded
             data.
             
             Takes the name of the save-file as an argument
             of string-type.
+
+	    If the optional parameter reset_t0 is set to 'True'
+	    the starting time of the scheduler (self.t0) will be
+	    set to the scheduler time saved in the input file.
+	    It is 'True' by default and typically only set to
+	    'False' during temporary interrupts with saving and
+	    reloading of the current state.
         """
         # Run the load function which will return a
         # new world containing the read-in model and
@@ -3875,7 +3895,10 @@ def load_state(self, filename):
         # This is to avoid divergence between the original and the
         # restarted simulation because of the limited floating point 
         # precision of Python
-        self.t = time_info[0]
+        self.t  = time_info[0]
+
+	if reset_t0:
+	        self.t0 = self.t
 
 
     #########################################

From 69b84a4ab72e62c482706af896c559933acc3e0b Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 29 Aug 2017 13:00:43 +0200
Subject: [PATCH 1537/1541] Updated README and INSTALL files

---
 INSTALL |   4 ++-
 README  | 104 +++++++++++++++++++++++++++++++++++++++-----------------
 2 files changed, 75 insertions(+), 33 deletions(-)

diff --git a/INSTALL b/INSTALL
index 57658131..f0dbb717 100644
--- a/INSTALL
+++ b/INSTALL
@@ -48,7 +48,9 @@ Building this package
 has been tested on:
 Ubuntu 14.04 LTS
 Ubuntu 10.04 LTS
-Debian 7.7.0
+Debian 7.7
+Debian 7.9
+Debian 7.11
 Fedora 20.1
 CentOS 7.0.14.06
 
diff --git a/README b/README
index 1d226859..5b5b3957 100644
--- a/README
+++ b/README
@@ -1,24 +1,28 @@
 
-:author: Koichi Takahashi
+:author: Thomas R. Sokolowski, Koichi Takahashi
 
 
-E-Cell Particle Dynamics Prototype
+=== 1D-2D-3D eGFRD Prototype ===
 
+originally based on the E-Cell Particle Dynamics Prototype
+
+Copyright (C) 2009-2017 AMOLF
 Copyright (C) 2008-2010 RIKEN
-Copyright (C) 2009-2010 AMOLF
 Copyright (C) 2005-2008 The Molecular Sciences Institute
 
 
 About this package
 ========================
 
-This package is tentatively named E-Cell Particle Dynamics Prototype
-(EPDP).  It currently implements the enhanced Greens Function Reaction
-Dynamics (eGFRD) algorithm and the reaction Brownian Dynamics (BD) simulation
-algorithm.  Implementation of the original version of GFRD will
-possibly be added in future.  The code is implemented with the hope
-that it will eventually be part of the E-Cell System Version 4
-multi-algorithm, multi-space simulation platform.
+This package is tentatively named "1D-2D-3D eGFRD Prototype", and was
+originally forked from RIKEN's E-Cell Particle Dynamics Prototype (EPDP).
+It currently implements the enhanced Greens Function Reaction Dynamics 
+(eGFRD) algorithm working in all dimensions, the Reaction Brownian 
+Dynamics (RBD) simulation algorithm, and another BD simulator based on 
+the Rection Volume Method (rvm-BD). Implementation of the original 
+version of GFRD will possibly be added in future. The code was designed
+and implemented with the hope that it will eventually be part of the 
+E-Cell System Version 4 multi-algorithm, multi-space simulation platform.
 
 The purpose of this prototype code written in mixed Python and C++ is
 to establish a solid and practical implementation of the algorithms,
@@ -26,21 +30,31 @@ and to extend it into a form that is suitable for large-scale
 biochemical and cell simulations.
 
 The eGFRD algorithm first appeared and be used in a paper by
-Takahashi, Tanase-Nicola and ten Wolde [1], and will be described more
-in detail in a forthcoming paper[2].
+Takahashi, Tanase-Nicola and ten Wolde [1]. A detailed introduction 
+to eGFRD, and in particular a description of the extensions to lower 
+dimensions is found in the PhD Thesis of Sokolowski [2]. Review [3]
+also contains a good introduction into the current eGFRD version.
+All new features will be described in detail in a forthcoming paper [4]. 
 
-The reaction Brownian Dynamics algorithm is described in a paper by
-Morrelli and ten Wolde[3].
+The Reaction Brownian Dynamics algorithm is described in a paper by
+Morrelli and ten Wolde [5]; the Reaction Volume Method and rvm-BD
+are described in detail in the Master's Thesis of Paijmans[6], and 
+also briefly in [2-4].
 
 
 Authors
 ========================
 
 (alphabetical order)
+
+Laurens Bossen
 Kazunari Kaizu
 Moriyoshi Koizumi
-Thomase Miedema
+Thomas Miedema
+Joris Paijmans
+Thomas R. Sokolowski
 Koichi Takahashi
+Martijn Wehrens
 
 
 License
@@ -62,34 +76,60 @@ History of the Code
 Koichi Takahashi initially stated development of the code in 2005 to
 implement his prototype of Greens Function Reaction Dynamics
 simulation method invented by Jeroen van Zon and Pieter Rein ten Wolde
-in AMOLF, Amsterdam[4].  He gave a brief invited talk about
+in AMOLF, Amsterdam [7].  He gave a brief invited talk about
 performance evaluation and applicability of the method to yeast
 pheromon response pathway (the Alpha pathway) using the prototype in
-the Third Annual Alpha Project Research Symposium (June 16-27, 2005, at UC
-Berkeley Art Museum).
+the Third Annual Alpha Project Research Symposium (June 16-27, 2005, at 
+UC Berkeley Art Museum).
 
-Later, in December 2006, ten Wolde, Sorin Tanase-Nicola, and Takahashi
-introduced the concept called first-passage processes[5][6] to Greens
+Later, in December 2006, ten Wolde, Tanase-Nicola, and Takahashi
+introduced the concept called first-passage processes [8,9] to Greens
 Function Reaction Dynamics by putting protective domains around
 particles to further boost the performance and accuracy of the method.
 The new method was named eGFRD (enhanced Greens Function Reaction
-Dynamics).
+Dynamics). By 2010, it was implemented for simulating particle-based
+reaction-diffusion systems in 3D, and fully integrated with a BD
+fallback system; the framework was applied to study details of
+enzymatic reactions in the MAPK push-pull networks [1].
+
+Starting from 2009, Sokolowski, Bossen, Miedema and ten Wolde began
+to derive the Green's functions and implementing the new domains
+needed for extending eGFRD to lower dimensions. Later Paijmans and
+Wehrens joined these efforts. Since extension of RBD to lower dimensions 
+turned out to be difficult, Paijmans and ten Wolde devised rvm-BD, a new
+BD simulation method that preserves detailed balance, based on the
+Reaction Volume Method (described in more detail in [6, 2-4]).
+
+All extensions to lower dimensions were assembled together by Bossen 
+and Sokolowski in 2012-2013. In 2013, Sokolowski finally created a
+first working prototype comprising all new features mentioned above.
+In the following years, this prototype was tested and improved, and
+some further new features, such as the option of transiting particles
+between cylinders and planes, were integrated. The prototype code
+then was used to simulate an idealized model of Pom1 gradient formation,
+as described in [4].
 
 
 Plans
 =========================
 
-Some features planned to be added are; surfaces, interactions between
-membrane proteins and proteins in solution, optimistic discrete-event
-scheduling for massive parallelization, connections to non-spatial 
-simulation methods such as ODE and Gillespie methods.
-
+Some features planned to be added are:
+- outsourcing further core routines from Python to C++
+- optimistic discrete-event scheduling for massive parallelization 
+- connections to non-spatial simulation methods such as ODE and Gillespie methods
+- more efficient visualizers / visualization interfaces
 
-[1] K. Takahashi, S. Tanase-Nicola and P.R. ten Wolde, PNAS doi:10.1073/pnas.0906885107 (2010).
-[2] K. Takahashi, S. Tanase-Nicola and P.R. ten Wolde, in preparation. 
-[3] M.J. Morelli and P.R. ten Wolde, J. Chem. Phys. 7;129(5):054112 (2008).
-[4] van Zon and ten Wolde, Phys. Rev. Lett. 94 (2005).
-[5] T. Opplestrup, V.V. Bulatov, G.H. Gilmer, M.H. Kalos, and B. Sadigh, Phys. Rev. Lett. 97 (2006).
-[6] M.H. Kalos, D. Levesque and L. Verlet, Phys. Rev. A 9 (1974).
 
+References
+=========================
 
+[1] K. Takahashi, S. Tanase-Nicola and P.R. ten Wolde, PNAS doi:10.1073/pnas.0906885107 (2010).
+[2] T.R. Sokolowski, "A Computational Study of Robust Formation of Spatial Protein Patterns", 
+    PhD Thesis, VU Amsteram, ISBN: 978-90-77209-72-1 (2013).
+[3] T.R. Sokolowski and P.R. ten Wolde, arXiv:170508669 [q-bio:MN] (2017).
+[4] T.R. Sokolowski et al., in preparation (2017).
+[5] M.J. Morelli and P.R. ten Wolde, J. Chem. Phys. 7;129(5):054112 (2008).
+[6] J. Paijmans, Master's Thesis, University of Amsterdam (2012).
+[7] van Zon and ten Wolde, Phys. Rev. Lett. 94 (2005).
+[8] T. Opplestrup, V.V. Bulatov, G.H. Gilmer, M.H. Kalos, and B. Sadigh, Phys. Rev. Lett. 97 (2006).
+[9] M.H. Kalos, D. Levesque and L. Verlet, Phys. Rev. A 9 (1974).

From cd9abca3a19a22925607b2f84f61ce1e72b50efd Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 29 Aug 2017 16:08:23 +0200
Subject: [PATCH 1538/1541] More updates to README file

---
 README | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/README b/README
index 5b5b3957..eb531f69 100644
--- a/README
+++ b/README
@@ -2,7 +2,7 @@
 :author: Thomas R. Sokolowski, Koichi Takahashi
 
 
-=== 1D-2D-3D eGFRD Prototype ===
+=== eGFRD 2 Prototype ===
 
 originally based on the E-Cell Particle Dynamics Prototype
 
@@ -14,7 +14,7 @@ Copyright (C) 2005-2008 The Molecular Sciences Institute
 About this package
 ========================
 
-This package is tentatively named "1D-2D-3D eGFRD Prototype", and was
+This package is tentatively named "eGFRD 2 Prototype", and was 
 originally forked from RIKEN's E-Cell Particle Dynamics Prototype (EPDP).
 It currently implements the enhanced Greens Function Reaction Dynamics 
 (eGFRD) algorithm working in all dimensions, the Reaction Brownian 
@@ -22,23 +22,24 @@ Dynamics (RBD) simulation algorithm, and another BD simulator based on
 the Rection Volume Method (rvm-BD). Implementation of the original 
 version of GFRD will possibly be added in future. The code was designed
 and implemented with the hope that it will eventually be part of the 
-E-Cell System Version 4 multi-algorithm, multi-space simulation platform.
+"E-Cell System Version 4" multi-algorithm, multi-space simulation 
+platform, or its subsequent versions.
 
 The purpose of this prototype code written in mixed Python and C++ is
 to establish a solid and practical implementation of the algorithms,
 and to extend it into a form that is suitable for large-scale
 biochemical and cell simulations.
 
-The eGFRD algorithm first appeared and be used in a paper by
+The eGFRD algorithm first appeared and was used in a paper by
 Takahashi, Tanase-Nicola and ten Wolde [1]. A detailed introduction 
 to eGFRD, and in particular a description of the extensions to lower 
 dimensions is found in the PhD Thesis of Sokolowski [2]. Review [3]
 also contains a good introduction into the current eGFRD version.
-All new features will be described in detail in a forthcoming paper [4]. 
+Moreover, eGFRD 2 will be described in detail in a forthcoming paper [4]. 
 
 The Reaction Brownian Dynamics algorithm is described in a paper by
 Morrelli and ten Wolde [5]; the Reaction Volume Method and rvm-BD
-are described in detail in the Master's Thesis of Paijmans[6], and 
+are described in detail in the Master's Thesis of Paijmans [6], and 
 also briefly in [2-4].
 
 
@@ -101,13 +102,12 @@ BD simulation method that preserves detailed balance, based on the
 Reaction Volume Method (described in more detail in [6, 2-4]).
 
 All extensions to lower dimensions were assembled together by Bossen 
-and Sokolowski in 2012-2013. In 2013, Sokolowski finally created a
-first working prototype comprising all new features mentioned above.
-In the following years, this prototype was tested and improved, and
-some further new features, such as the option of transiting particles
-between cylinders and planes, were integrated. The prototype code
-then was used to simulate an idealized model of Pom1 gradient formation,
-as described in [4].
+and Sokolowski in 2012-2013. In 2013, Sokolowski created a first working 
+prototype comprising all new features mentioned above. In the following 
+years, this prototype was tested and improved, and some further new features, 
+such as the option of transiting particles between cylinders and planes, 
+were integrated. The prototype code then was used to simulate an idealized 
+model of Pom1 gradient formation, as described in [4].
 
 
 Plans

From cd866f2121598c3a833bb738d6ac206d6b19854c Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Thu, 31 Aug 2017 13:36:59 +0200
Subject: [PATCH 1539/1541] Fix references in README

---
 README | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/README b/README
index eb531f69..0b84f86f 100644
--- a/README
+++ b/README
@@ -2,7 +2,7 @@
 :author: Thomas R. Sokolowski, Koichi Takahashi
 
 
-=== eGFRD 2 Prototype ===
+=== eGFRD2 Prototype ===
 
 originally based on the E-Cell Particle Dynamics Prototype
 
@@ -14,7 +14,7 @@ Copyright (C) 2005-2008 The Molecular Sciences Institute
 About this package
 ========================
 
-This package is tentatively named "eGFRD 2 Prototype", and was 
+This package is tentatively named "eGFRD2 Prototype", and was 
 originally forked from RIKEN's E-Cell Particle Dynamics Prototype (EPDP).
 It currently implements the enhanced Greens Function Reaction Dynamics 
 (eGFRD) algorithm working in all dimensions, the Reaction Brownian 
@@ -35,7 +35,8 @@ Takahashi, Tanase-Nicola and ten Wolde [1]. A detailed introduction
 to eGFRD, and in particular a description of the extensions to lower 
 dimensions is found in the PhD Thesis of Sokolowski [2]. Review [3]
 also contains a good introduction into the current eGFRD version.
-Moreover, eGFRD 2 will be described in detail in a forthcoming paper [4]. 
+Moreover, eGFRD2 is described in detail in a forthcoming paper, 
+currently available as a preprint on arXiv [4].
 
 The Reaction Brownian Dynamics algorithm is described in a paper by
 Morrelli and ten Wolde [5]; the Reaction Volume Method and rvm-BD
@@ -126,8 +127,8 @@ References
 [1] K. Takahashi, S. Tanase-Nicola and P.R. ten Wolde, PNAS doi:10.1073/pnas.0906885107 (2010).
 [2] T.R. Sokolowski, "A Computational Study of Robust Formation of Spatial Protein Patterns", 
     PhD Thesis, VU Amsteram, ISBN: 978-90-77209-72-1 (2013).
-[3] T.R. Sokolowski and P.R. ten Wolde, arXiv:170508669 [q-bio:MN] (2017).
-[4] T.R. Sokolowski et al., in preparation (2017).
+[3] T.R. Sokolowski and P.R. ten Wolde, arXiv:1705.08669 [q-bio.MN] (2017).
+[4] T.R. Sokolowski et al., arXiv:1708.09364 [q-bio.MN] (2017).
 [5] M.J. Morelli and P.R. ten Wolde, J. Chem. Phys. 7;129(5):054112 (2008).
 [6] J. Paijmans, Master's Thesis, University of Amsterdam (2012).
 [7] van Zon and ten Wolde, Phys. Rev. Lett. 94 (2005).

From d1b2b24d8c58c4ca06006948d503349eeee96bd0 Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 17 Oct 2017 15:45:08 +0200
Subject: [PATCH 1540/1541] Some tweaks to TIRViE visualizer

- a new optional parameter to set the view center point (default = [0,0,0])

- new default resolution (1600 x 900 pixels)
---
 visualization/TIRViE.py | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/visualization/TIRViE.py b/visualization/TIRViE.py
index 8738945b..8021b823 100644
--- a/visualization/TIRViE.py
+++ b/visualization/TIRViE.py
@@ -60,17 +60,20 @@ class TheImperialRoyalVisualizerForEGFRD:
     
   """
   def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, \
-                        capture=False, capture_dir='./tirvie_frames', particle_radius_factor=1, cyl_radius_factor=1):
+                        capture=False, capture_dir='./tirvie_frames', particle_radius_factor=1, cyl_radius_factor=1, \
+                        view_center=[0, 0, 0] ):
 
     self.sim = eGFRDsim
     self.world_size = self.get_world_size()
     
     self.objects = []
 
-    self.scene_width  = 1000
-    self.scene_height = 1000
+    self.scene_width  = 1600
+    self.scene_height = 900
     self.window_title = "TIRViE -- The Imperial-Royal Visualizer for eGFRD"
     self.window_id    = '' # set later by self.get_window_id(), once a scene has been created
+
+    self.view_center  = view_center # the point at which the camera will always look; [0,0,0] by default
     
     self.SCENE_BACKGROUND_COLOR = v.color.white
     
@@ -261,7 +264,7 @@ def create_new_scene(self):
     except:
       print "No scene existing yet, creating now."
     
-    self.scene = v.display(width = self.scene_width, height = self.scene_height, title = self.window_title)
+    self.scene = v.display(width = self.scene_width, height = self.scene_height, title = self.window_title, center = self.view_center)
     self.scene.background = self.SCENE_BACKGROUND_COLOR
     self.scene.select()
     
@@ -1102,11 +1105,13 @@ class TIRViE(TheImperialRoyalVisualizerForEGFRD):
     This is just an alias for 'TheImperialRoyalVisualizerForEGFRD'
   
   """
-  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames', particle_radius_factor=1, cyl_radius_factor=1):
+  def __init__(self, eGFRDsim, particle_color_dict={}, structure_color_dict={}, capture=False, capture_dir='./tirvie_frames', \
+                     particle_radius_factor=1, cyl_radius_factor=1, view_center=[0, 0, 0] ):
 
     TheImperialRoyalVisualizerForEGFRD.__init__(self, eGFRDsim=eGFRDsim, \
                                                       particle_color_dict=particle_color_dict, structure_color_dict=structure_color_dict, \
                                                       capture=capture, capture_dir=capture_dir, \
-                                                      particle_radius_factor=particle_radius_factor, cyl_radius_factor=cyl_radius_factor)
+                                                      particle_radius_factor=particle_radius_factor, cyl_radius_factor=cyl_radius_factor, \
+                                                      view_center=view_center)
                                                       
     

From 173ecfefc194f2eb303d01add5655bcf07ac551f Mon Sep 17 00:00:00 2001
From: Thomas Sokolowski <sokolowski@amolf.nl>
Date: Tue, 17 Oct 2017 17:06:22 +0200
Subject: [PATCH 1541/1541] Fixes to list of included boost files, to improve
 compilation behavior

In particular, an internal issue of boost is fixed by including
<boost/detail/workaround.hpp> before <boost/type_traits/remove_pointer.hpp>.

This caused linking errors on some systems.
---
 Model.cpp         | 1 +
 ParticleModel.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/Model.cpp b/Model.cpp
index 3a8defb6..e687bb7e 100644
--- a/Model.cpp
+++ b/Model.cpp
@@ -3,6 +3,7 @@
 #endif /* HAVE_CONFIG_H */
 
 #include <algorithm>
+#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/remove_pointer.hpp>
 #include <boost/lexical_cast.hpp>
 
diff --git a/ParticleModel.cpp b/ParticleModel.cpp
index 799d9183..64d67b59 100644
--- a/ParticleModel.cpp
+++ b/ParticleModel.cpp
@@ -3,6 +3,7 @@
 #endif /* HAVE_CONFIG_H */
 
 #include <algorithm>
+#include <boost/detail/workaround.hpp>
 #include <boost/type_traits/remove_pointer.hpp>
 #include <boost/lexical_cast.hpp>